open-nomad/client/driver/driver.go

189 lines
5.0 KiB
Go
Raw Normal View History

2015-08-20 23:50:28 +00:00
package driver
import (
"fmt"
"log"
"path/filepath"
2015-08-23 22:36:06 +00:00
"sync"
2015-08-20 23:50:28 +00:00
"github.com/hashicorp/nomad/client/allocdir"
"github.com/hashicorp/nomad/client/config"
2016-01-11 17:58:26 +00:00
"github.com/hashicorp/nomad/client/driver/env"
2015-08-20 23:50:28 +00:00
"github.com/hashicorp/nomad/client/fingerprint"
2015-08-23 23:49:48 +00:00
"github.com/hashicorp/nomad/nomad/structs"
cstructs "github.com/hashicorp/nomad/client/driver/structs"
2015-08-20 23:50:28 +00:00
)
// BuiltinDrivers contains the built in registered drivers
// which are available for allocation handling
var BuiltinDrivers = map[string]Factory{
"docker": NewDockerDriver,
"exec": NewExecDriver,
"raw_exec": NewRawExecDriver,
"java": NewJavaDriver,
"qemu": NewQemuDriver,
"rkt": NewRktDriver,
2015-08-20 23:50:28 +00:00
}
// NewDriver is used to instantiate and return a new driver
// given the name and a logger
func NewDriver(name string, ctx *DriverContext) (Driver, error) {
2015-08-20 23:50:28 +00:00
// Lookup the factory function
factory, ok := BuiltinDrivers[name]
if !ok {
return nil, fmt.Errorf("unknown driver '%s'", name)
}
// Instantiate the driver
f := factory(ctx)
2015-08-20 23:50:28 +00:00
return f, nil
}
// Factory is used to instantiate a new Driver
type Factory func(*DriverContext) Driver
2015-08-20 23:50:28 +00:00
// Driver is used for execution of tasks. This allows Nomad
// to support many pluggable implementations of task drivers.
// Examples could include LXC, Docker, Qemu, etc.
type Driver interface {
// Drivers must support the fingerprint interface for detection
fingerprint.Fingerprint
2015-08-23 23:49:48 +00:00
// Start is used to being task execution
Start(ctx *ExecContext, task *structs.Task) (DriverHandle, error)
// Open is used to re-open a handle to a task
Open(ctx *ExecContext, handleID string) (DriverHandle, error)
// Drivers must validate their configuration
Validate(map[string]interface{}) error
2015-08-23 23:49:48 +00:00
}
// DriverContext is a means to inject dependencies such as loggers, configs, and
// node attributes into a Driver without having to change the Driver interface
// each time we do it. Used in conjection with Factory, above.
type DriverContext struct {
taskName string
config *config.Config
logger *log.Logger
node *structs.Node
2016-01-11 17:58:26 +00:00
taskEnv *env.TaskEnvironment
}
// NewEmptyDriverContext returns a DriverContext with all fields set to their
// zero value.
func NewEmptyDriverContext() *DriverContext {
return &DriverContext{
taskName: "",
config: nil,
node: nil,
logger: nil,
taskEnv: nil,
}
}
// NewDriverContext initializes a new DriverContext with the specified fields.
// This enables other packages to create DriverContexts but keeps the fields
// private to the driver. If we want to change this later we can gorename all of
// the fields in DriverContext.
2016-01-11 17:58:26 +00:00
func NewDriverContext(taskName string, config *config.Config, node *structs.Node,
logger *log.Logger, taskEnv *env.TaskEnvironment) *DriverContext {
return &DriverContext{
taskName: taskName,
config: config,
node: node,
logger: logger,
2016-01-11 17:58:26 +00:00
taskEnv: taskEnv,
}
}
2015-08-23 23:49:48 +00:00
// DriverHandle is an opaque handle into a driver used for task
// manipulation
type DriverHandle interface {
// Returns an opaque handle that can be used to re-open the handle
ID() string
// WaitCh is used to return a channel used wait for task completion
WaitCh() chan *cstructs.WaitResult
2015-08-23 23:49:48 +00:00
// Update is used to update the task if possible and update task related
// configurations.
2015-08-29 22:46:10 +00:00
Update(task *structs.Task) error
2015-08-23 23:49:48 +00:00
// Kill is used to stop the task
Kill() error
2015-08-20 23:50:28 +00:00
}
2015-08-23 22:36:06 +00:00
// ExecContext is shared between drivers within an allocation
type ExecContext struct {
sync.Mutex
2015-08-31 00:35:58 +00:00
// AllocDir contains information about the alloc directory structure.
AllocDir *allocdir.AllocDir
// Alloc ID
AllocID string
2015-08-23 22:36:06 +00:00
}
// NewExecContext is used to create a new execution context
func NewExecContext(alloc *allocdir.AllocDir, allocID string) *ExecContext {
return &ExecContext{AllocDir: alloc, AllocID: allocID}
2015-08-23 22:36:06 +00:00
}
// GetTaskEnv converts the alloc dir, the node, task and alloc into a
// TaskEnvironment.
func GetTaskEnv(allocDir *allocdir.AllocDir, node *structs.Node,
task *structs.Task, alloc *structs.Allocation) (*env.TaskEnvironment, error) {
2016-03-25 00:39:09 +00:00
tg := alloc.Job.LookupTaskGroup(alloc.TaskGroup)
2016-01-11 17:58:26 +00:00
env := env.NewTaskEnvironment(node).
2016-03-25 00:39:09 +00:00
SetTaskMeta(task.Meta).
SetTaskGroupMeta(tg.Meta).
SetJobMeta(alloc.Job.Meta).
SetEnvvars(task.Env).
SetTaskName(task.Name)
2016-01-11 17:58:26 +00:00
if allocDir != nil {
env.SetAllocDir(allocDir.SharedDir)
taskdir, ok := allocDir.TaskDirs[task.Name]
if !ok {
2016-01-11 17:58:26 +00:00
return nil, fmt.Errorf("failed to get task directory for task %q", task.Name)
}
env.SetTaskLocalDir(filepath.Join(taskdir, allocdir.TaskLocal))
}
2015-09-23 06:11:55 +00:00
if task.Resources != nil {
env.SetMemLimit(task.Resources.MemoryMB).
SetCpuLimit(task.Resources.CPU).
SetNetworks(task.Resources.Networks)
}
if alloc != nil {
env.SetAlloc(alloc)
2015-09-23 06:11:55 +00:00
}
2016-01-11 17:58:26 +00:00
return env.Build(), nil
}
func mapMergeStrInt(maps ...map[string]int) map[string]int {
out := map[string]int{}
for _, in := range maps {
for key, val := range in {
out[key] = val
}
}
return out
}
func mapMergeStrStr(maps ...map[string]string) map[string]string {
out := map[string]string{}
for _, in := range maps {
for key, val := range in {
out[key] = val
}
}
return out
}