open-nomad/client/driver/java.go

206 lines
5.0 KiB
Go
Raw Normal View History

2015-09-01 21:57:21 +00:00
package driver
import (
"bytes"
2015-09-01 21:57:21 +00:00
"fmt"
"os/exec"
"path/filepath"
"runtime"
2015-09-01 21:57:21 +00:00
"strings"
"syscall"
2015-09-01 21:57:21 +00:00
"time"
"github.com/hashicorp/nomad/client/allocdir"
2015-09-01 21:57:21 +00:00
"github.com/hashicorp/nomad/client/config"
"github.com/hashicorp/nomad/client/driver/executor"
2015-11-03 21:16:17 +00:00
"github.com/hashicorp/nomad/client/getter"
2015-09-01 21:57:21 +00:00
"github.com/hashicorp/nomad/nomad/structs"
)
// JavaDriver is a simple driver to execute applications packaged in Jars.
// It literally just fork/execs tasks with the java command.
type JavaDriver struct {
DriverContext
2015-09-01 21:57:21 +00:00
}
// javaHandle is returned from Start/Open as a handle to the PID
type javaHandle struct {
cmd executor.Executor
2015-09-01 21:57:21 +00:00
waitCh chan error
doneCh chan struct{}
}
// NewJavaDriver is used to create a new exec driver
func NewJavaDriver(ctx *DriverContext) Driver {
return &JavaDriver{*ctx}
2015-09-01 21:57:21 +00:00
}
func (d *JavaDriver) Fingerprint(cfg *config.Config, node *structs.Node) (bool, error) {
// Only enable if we are root when running on non-windows systems.
if runtime.GOOS == "linux" && syscall.Geteuid() != 0 {
d.logger.Printf("[DEBUG] driver.java: must run as root user on linux, disabling")
return false, nil
}
// Find java version
var out bytes.Buffer
var erOut bytes.Buffer
cmd := exec.Command("java", "-version")
cmd.Stdout = &out
cmd.Stderr = &erOut
err := cmd.Run()
if err != nil {
// assume Java wasn't found
return false, nil
}
// 'java -version' returns output on Stderr typically.
// Check stdout, but it's probably empty
var infoString string
if out.String() != "" {
infoString = out.String()
}
if erOut.String() != "" {
infoString = erOut.String()
}
if infoString == "" {
2015-10-16 18:32:37 +00:00
d.logger.Println("[WARN] driver.java: error parsing Java version information, aborting")
return false, nil
}
// Assume 'java -version' returns 3 lines:
// java version "1.6.0_36"
// OpenJDK Runtime Environment (IcedTea6 1.13.8) (6b36-1.13.8-0ubuntu1~12.04)
// OpenJDK 64-Bit Server VM (build 23.25-b01, mixed mode)
// Each line is terminated by \n
info := strings.Split(infoString, "\n")
versionString := info[0]
versionString = strings.TrimPrefix(versionString, "java version ")
versionString = strings.Trim(versionString, "\"")
2015-09-01 21:57:21 +00:00
node.Attributes["driver.java"] = "1"
node.Attributes["driver.java.version"] = versionString
node.Attributes["driver.java.runtime"] = info[1]
node.Attributes["driver.java.vm"] = info[2]
2015-09-01 21:57:21 +00:00
return true, nil
}
func (d *JavaDriver) Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error) {
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)
}
2015-11-03 21:16:17 +00:00
// Proceed to download an artifact to be executed.
path, err := getter.GetArtifact(
filepath.Join(taskDir, allocdir.TaskLocal),
task.Config["artifact_source"],
task.Config["checksum"],
d.logger,
)
if err != nil {
return nil, err
2015-09-01 21:57:21 +00:00
}
2015-11-03 21:16:17 +00:00
jarName := filepath.Base(path)
2015-09-26 22:37:48 +00:00
// Get the environment variables.
envVars := TaskEnvironmentVariables(ctx, task)
2015-10-16 19:33:29 +00:00
args := []string{}
2015-10-16 18:32:37 +00:00
// 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)
2015-10-16 18:32:37 +00:00
}
2015-09-26 22:37:48 +00:00
// Build the argument list.
args = append(args, "-jar", filepath.Join(allocdir.TaskLocal, jarName))
2015-09-26 22:37:48 +00:00
if argRaw, ok := task.Config["args"]; ok {
args = append(args, argRaw)
2015-09-01 21:57:21 +00:00
}
// Setup the command
// Assumes Java is in the $PATH, but could probably be detected
cmd := executor.Command("java", args...)
2015-09-23 05:36:10 +00:00
// Populate environment variables
cmd.Command().Env = envVars.List()
2015-09-23 05:36:10 +00:00
2015-09-25 23:49:14 +00:00
if err := cmd.Limit(task.Resources); err != nil {
2015-09-15 20:45:48 +00:00
return nil, fmt.Errorf("failed to constrain resources: %s", err)
}
2015-09-25 23:49:14 +00:00
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 {
2015-09-01 21:57:21 +00:00
return nil, fmt.Errorf("failed to start source: %v", err)
}
// Return a driver handle
h := &javaHandle{
2015-09-15 20:45:48 +00:00
cmd: cmd,
2015-09-01 21:57:21 +00:00
doneCh: make(chan struct{}),
waitCh: make(chan error, 1),
}
go h.run()
return h, nil
}
func (d *JavaDriver) Open(ctx *ExecContext, handleID string) (DriverHandle, error) {
// Find the process
cmd, err := executor.OpenId(handleID)
2015-09-15 20:45:48 +00:00
if err != nil {
return nil, fmt.Errorf("failed to open ID %v: %v", handleID, err)
2015-09-01 21:57:21 +00:00
}
// Return a driver handle
h := &javaHandle{
2015-09-15 20:45:48 +00:00
cmd: cmd,
2015-09-01 21:57:21 +00:00
doneCh: make(chan struct{}),
waitCh: make(chan error, 1),
}
go h.run()
return h, nil
}
func (h *javaHandle) ID() string {
id, _ := h.cmd.ID()
return id
2015-09-01 21:57:21 +00:00
}
func (h *javaHandle) WaitCh() chan error {
return h.waitCh
}
func (h *javaHandle) Update(task *structs.Task) error {
// Update is not possible
return nil
}
func (h *javaHandle) Kill() error {
2015-09-15 20:45:48 +00:00
h.cmd.Shutdown()
2015-09-01 21:57:21 +00:00
select {
case <-h.doneCh:
return nil
case <-time.After(5 * time.Second):
2015-09-15 20:45:48 +00:00
return h.cmd.ForceStop()
2015-09-01 21:57:21 +00:00
}
}
func (h *javaHandle) run() {
2015-09-15 20:45:48 +00:00
err := h.cmd.Wait()
2015-09-01 21:57:21 +00:00
close(h.doneCh)
if err != nil {
h.waitCh <- err
}
close(h.waitCh)
}