func (d *ExecDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error) { // Get the command command, ok := task.Config["command"] if !ok || command == "" { return nil, fmt.Errorf("missing command for exec driver") } // Get the environment variables. envVars := TaskEnvironmentVariables(ctx, task) // Look for arguments var args []string if argRaw, ok := task.Config["args"]; ok { args = append(args, argRaw) } // Setup the command cmd := executor.Command(command, args...) if err := cmd.Limit(task.Resources); err != nil { return nil, fmt.Errorf("failed to constrain resources: %s", err) } // Populate environment variables cmd.Command().Env = envVars.List() if err := cmd.ConfigureTaskDir(d.taskName, ctx.AllocDir); err != nil { return nil, fmt.Errorf("failed to configure task directory: %v", err) } if err := cmd.Start(); err != nil { return nil, fmt.Errorf("failed to start command: %v", err) } // Return a driver handle h := &execHandle{ cmd: cmd, doneCh: make(chan struct{}), waitCh: make(chan error, 1), } go h.run() return h, nil }
func (d *JavaDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error) { // Get the jar source source, ok := task.Config["jar_source"] if !ok || source == "" { return nil, fmt.Errorf("missing jar source for Java Jar driver") } taskDir, ok := ctx.AllocDir.TaskDirs[d.DriverContext.taskName] if !ok { return nil, fmt.Errorf("Could not find task directory for task: %v", d.DriverContext.taskName) } destDir := filepath.Join(taskDir, allocdir.TaskLocal) // Create a location to download the binary. jarName := path.Base(source) jarPath := filepath.Join(destDir, jarName) if err := getter.GetFile(jarPath, source); err != nil { return nil, fmt.Errorf("Error downloading source for Java driver: %s", err) } // Get the environment variables. envVars := TaskEnvironmentVariables(ctx, task) args := []string{} // Look for jvm options jvm_options, ok := task.Config["jvm_options"] if ok && jvm_options != "" { d.logger.Printf("[DEBUG] driver.java: found JVM options: %s", jvm_options) args = append(args, jvm_options) } // Build the argument list. args = append(args, "-jar", filepath.Join(allocdir.TaskLocal, jarName)) if argRaw, ok := task.Config["args"]; ok { args = append(args, argRaw) } // Setup the command // Assumes Java is in the $PATH, but could probably be detected cmd := executor.Command("java", args...) // Populate environment variables cmd.Command().Env = envVars.List() if err := cmd.Limit(task.Resources); err != nil { return nil, fmt.Errorf("failed to constrain resources: %s", err) } if err := cmd.ConfigureTaskDir(d.taskName, ctx.AllocDir); err != nil { return nil, fmt.Errorf("failed to configure task directory: %v", err) } if err := cmd.Start(); err != nil { return nil, fmt.Errorf("failed to start source: %v", err) } // Return a driver handle h := &javaHandle{ cmd: cmd, doneCh: make(chan struct{}), waitCh: make(chan error, 1), } go h.run() return h, nil }
func (d *JavaDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error) { // Get the jar source source, ok := task.Config["jar_source"] if !ok || source == "" { return nil, fmt.Errorf("missing jar source for Java Jar driver") } // Attempt to download the thing // Should be extracted to some kind of Http Fetcher // Right now, assume publicly accessible HTTP url resp, err := http.Get(source) if err != nil { return nil, fmt.Errorf("Error downloading source for Java driver: %s", err) } // Get the tasks local directory. taskDir, ok := ctx.AllocDir.TaskDirs[d.DriverContext.taskName] if !ok { return nil, fmt.Errorf("Could not find task directory for task: %v", d.DriverContext.taskName) } taskLocal := filepath.Join(taskDir, allocdir.TaskLocal) // Create a location to download the binary. fName := path.Base(source) fPath := filepath.Join(taskLocal, fName) f, err := os.OpenFile(fPath, os.O_CREATE|os.O_WRONLY, 0666) if err != nil { return nil, fmt.Errorf("Error opening file to download to: %s", err) } defer f.Close() defer resp.Body.Close() // Copy remote file to local directory for execution // TODO: a retry of sort if io.Copy fails, for large binaries _, ioErr := io.Copy(f, resp.Body) if ioErr != nil { return nil, fmt.Errorf("Error copying jar from source: %s", ioErr) } // Get the environment variables. envVars := TaskEnvironmentVariables(ctx, task) // Build the argument list. args := []string{"-jar", filepath.Join(allocdir.TaskLocal, fName)} if argRaw, ok := task.Config["args"]; ok { args = append(args, argRaw) } // Setup the command // Assumes Java is in the $PATH, but could probably be detected cmd := executor.Command("java", args...) // Populate environment variables cmd.Command().Env = envVars.List() if err := cmd.Limit(task.Resources); err != nil { return nil, fmt.Errorf("failed to constrain resources: %s", err) } if err := cmd.ConfigureTaskDir(d.taskName, ctx.AllocDir); err != nil { return nil, fmt.Errorf("failed to configure task directory: %v", err) } if err := cmd.Start(); err != nil { return nil, fmt.Errorf("failed to start source: %v", err) } // Return a driver handle h := &javaHandle{ cmd: cmd, doneCh: make(chan struct{}), waitCh: make(chan error, 1), } go h.run() return h, nil }
func (d *ExecDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error) { // Get the command to be ran command, ok := task.Config["command"] if !ok || command == "" { return nil, fmt.Errorf("missing command for exec driver") } // Check if an artificat is specified and attempt to download it source, ok := task.Config["artifact_source"] if ok && source != "" { // Proceed to download an artifact to be executed. // We use go-getter to support a variety of protocols, but need to change // file permissions of the resulted download to be executable // Create a location to download the artifact. taskDir, ok := ctx.AllocDir.TaskDirs[d.DriverContext.taskName] if !ok { return nil, fmt.Errorf("Could not find task directory for task: %v", d.DriverContext.taskName) } destDir := filepath.Join(taskDir, allocdir.TaskLocal) artifactName := path.Base(source) artifactFile := filepath.Join(destDir, artifactName) if err := getter.GetFile(artifactFile, source); err != nil { return nil, fmt.Errorf("Error downloading artifact for Exec driver: %s", err) } // Add execution permissions to the newly downloaded artifact if err := syscall.Chmod(artifactFile, 0755); err != nil { log.Printf("[ERR] driver.exec: Error making artifact executable: %s", err) } } // Get the environment variables. envVars := TaskEnvironmentVariables(ctx, task) // Look for arguments var args []string if argRaw, ok := task.Config["args"]; ok { args = append(args, argRaw) } // Setup the command cmd := executor.Command(command, args...) if err := cmd.Limit(task.Resources); err != nil { return nil, fmt.Errorf("failed to constrain resources: %s", err) } // Populate environment variables cmd.Command().Env = envVars.List() if err := cmd.ConfigureTaskDir(d.taskName, ctx.AllocDir); err != nil { return nil, fmt.Errorf("failed to configure task directory: %v", err) } if err := cmd.Start(); err != nil { return nil, fmt.Errorf("failed to start command: %v", err) } // Return a driver handle h := &execHandle{ cmd: cmd, doneCh: make(chan struct{}), waitCh: make(chan error, 1), } go h.run() return h, nil }