// createDockerCmd creates a docker command suitable for the given network type.
func (e *dockerEngine) createDockerCmd(env map[string]string, networkType jobs.NetworkType) (cmdline.Cmdline, error) {
c := cmdline.Cmdline{}
switch networkType {
case "", jobs.NetworkTypeDefault, jobs.NetworkTypeHost:
return *c.Add(nil, e.dockerPath), nil
case jobs.NetworkTypeWeave:
return *c.Add(nil, e.dockerPath).Add(env, fmt.Sprintf("-H=%s", e.weavePluginSocket)), nil
default:
return cmdline.Cmdline{}, maskAny(fmt.Errorf("Unknown network type '%s", networkType))
}
}
// addDockerNetworkArgs adds docker network arguments for the given task.
func (e *dockerEngine) addDockerNetworkArgs(c *cmdline.Cmdline, env map[string]string, t *jobs.Task) error {
switch t.Network {
case "", jobs.NetworkTypeDefault:
return nil
case jobs.NetworkTypeHost:
c.Add(env, "--net=host")
return nil
case jobs.NetworkTypeWeave:
if !t.Type.IsProxy() {
c.Add(env, fmt.Sprintf("--hostname=%s", t.WeaveDomainName()))
} else {
c.Add(env, fmt.Sprintf("--hostname=%s", t.PrivateDomainName()))
}
return nil
default:
return maskAny(fmt.Errorf("Unknown network type '%s", t.Network))
}
}
func (e *dockerEngine) cleanupCmd() cmdline.Cmdline {
cmd := cmdline.Cmdline{AllowFailure: true}
cmd.Add(nil, e.cleanupScriptPath)
return cmd
}
func (e *dockerEngine) removeCmd(containerName string) cmdline.Cmdline {
cmd := cmdline.Cmdline{AllowFailure: true}
cmd.Add(nil, e.dockerPath, "rm", "-f", containerName)
return cmd
}
func (e *dockerEngine) stopCmd(containerName string) cmdline.Cmdline {
cmd := cmdline.Cmdline{AllowFailure: true}
cmd.Add(nil, e.dockerPath, "stop", fmt.Sprintf("-t %v", e.containerTimeoutStopSec), containerName)
return cmd
}
// createVolumeDockerCmdLine creates the `ExecStart` line for
// the volume unit.
func (e *dockerEngine) createVolumeDockerCmdLine(t *jobs.Task, containerName, containerImage string, vol jobs.Volume, volPrefix, volHostPath string, env map[string]string, scalingGroup uint) (cmdline.Cmdline, error) {
var cmd cmdline.Cmdline
cmd.Add(nil, e.dockerPath, "run", "--rm", fmt.Sprintf("--name %s", containerName), "--net=host", "--privileged")
cmd.Add(env, fmt.Sprintf("-v %s:%s:shared", volHostPath, vol.Path))
cmd.Add(env, "-v /usr/bin/etcdctl:/usr/bin/etcdctl")
if e.options.EnvFile != "" {
cmd.Add(env, fmt.Sprintf("--env-file=%s", e.options.EnvFile))
}
cmd.Add(env, "-e SERVICE_IGNORE=true") // Support registrator
cmd.Add(env, "-e PREFIX="+volPrefix)
cmd.Add(env, "-e TARGET="+vol.Path)
cmd.Add(env, "-e WAIT=1")
if v, err := vol.MountOption("uid"); err == nil {
cmd.Add(env, "-e UID="+v)
}
if v, err := vol.MountOption("gid"); err == nil {
cmd.Add(env, "-e GID="+v)
}
for _, arg := range t.LogDriver.CreateDockerLogArgs(e.options) {
cmd.Add(env, arg)
}
cmd.Add(nil, containerImage)
return cmd, nil
}
// createSecretsUnit creates a unit used to extract secrets from vault
func (e *dockerEngine) createSecretsExecStartPre(t *jobs.Task, containerImage string, env map[string]string, scalingGroup uint) ([]cmdline.Cmdline, error) {
if len(t.Secrets) == 0 {
// No secrets to extract
return nil, nil
}
// Create all secret extraction commands
jobID := t.JobID()
if jobID == "" {
return nil, maskAny(fmt.Errorf("job ID missing for job %s with secrets", t.JobName()))
}
// Prepare volume paths
secretsRoot := secretsRootPath(t, scalingGroup)
secretsRootVol := fmt.Sprintf("%s:%s", secretsRoot, secretsRoot)
vaultCrtVol := "/etc/pulcy/vault.crt:/etc/pulcy/vault.crt:ro"
clusterIdVol := "/etc/pulcy/cluster-id:/etc/pulcy/cluster-id:ro"
machineIdVol := "/etc/machine-id:/etc/machine-id:ro"
var cmds []cmdline.Cmdline
cmds = append(cmds,
*cmdline.New(nil, "/usr/bin/mkdir", "-p", secretsRoot),
e.pullCmd(containerImage),
)
envPaths := []string{}
for _, secret := range t.Secrets {
if ok, _ := secret.TargetFile(); ok {
targetPath, err := secretFilePath(t, scalingGroup, secret)
if err != nil {
return nil, maskAny(err)
}
var cmd cmdline.Cmdline
cmd.Add(nil, e.dockerPath, "run", "--rm")
//cmd.Add(env, fmt.Sprintf("--name %s-sc", t.containerName(ctx.ScalingGroup)))
cmd.Add(env, "--net=host")
cmd.Add(env, "-v "+secretsRootVol)
cmd.Add(env, "-v "+vaultCrtVol)
cmd.Add(env, "-v "+clusterIdVol)
cmd.Add(env, "-v "+machineIdVol)
cmd.Add(env, "--env-file /etc/pulcy/vault.env")
/*if ctx.DockerOptions.EnvFile != "" {
cmd.Add(env,fmt.Sprintf("--env-file=%s", ctx.DockerOptions.EnvFile))
}*/
for _, arg := range t.LogDriver.CreateDockerLogArgs(e.options) {
cmd.Add(env, arg)
}
cmd.Add(env, containerImage)
cmd.Add(nil, "extract", "file")
cmd.Add(env, "--target "+targetPath)
cmd.Add(env, "--job-id "+jobID)
cmd.Add(env, secret.VaultPath())
cmds = append(cmds, cmd)
} else if ok, environmentKey := secret.TargetEnviroment(); ok {
envPaths = append(envPaths, fmt.Sprintf("%s=%s", environmentKey, secret.VaultPath()))
}
}
if len(envPaths) > 0 {
targetPath := secretEnvironmentPath(t, scalingGroup)
var cmd cmdline.Cmdline
cmd.Add(nil, e.dockerPath, "run", "--rm")
//cmd.Add(env, fmt.Sprintf("--name %s-sc", t.containerName(ctx.ScalingGroup)))
cmd.Add(env, "--net=host")
cmd.Add(env, "-v "+secretsRootVol)
cmd.Add(env, "-v "+vaultCrtVol)
cmd.Add(env, "-v "+clusterIdVol)
cmd.Add(env, "-v "+machineIdVol)
cmd.Add(env, "--env-file /etc/pulcy/vault.env")
/*if ctx.DockerOptions.EnvFile != "" {
cmd.Add(env, fmt.Sprintf("--env-file=%s", ctx.DockerOptions.EnvFile))
}*/
for _, arg := range t.LogDriver.CreateDockerLogArgs(e.options) {
cmd.Add(env, arg)
}
cmd.Add(env, containerImage)
cmd.Add(nil, "extract", "env")
cmd.Add(env, "--target "+targetPath)
cmd.Add(env, "--job-id "+jobID)
for _, envPath := range envPaths {
cmd.Add(env, envPath)
}
cmds = append(cmds, cmd)
}
return cmds, nil
}
// createProxyDockerCmdLine creates the `ExecStart` line for
// the proxy unit.
func (e *dockerEngine) createProxyDockerCmdLine(t *jobs.Task, containerName, containerImage string, link jobs.Link, env map[string]string, scalingGroup uint) (cmdline.Cmdline, error) {
var cmd cmdline.Cmdline
cmd, err := e.createDockerCmd(env, t.Network)
if err != nil {
return cmd, maskAny(err)
}
cmd.Add(nil, "run", "--rm", fmt.Sprintf("--name %s", containerName))
for _, p := range link.Ports {
cmd.Add(env, fmt.Sprintf("--expose %d", p))
}
cmd.Add(env, "-P")
if e.options.EnvFile != "" {
cmd.Add(env, fmt.Sprintf("--env-file=%s", e.options.EnvFile))
}
cmd.Add(env, "-e SERVICE_IGNORE=true") // Support registrator
for _, arg := range t.LogDriver.CreateDockerLogArgs(e.options) {
cmd.Add(env, arg)
}
cmd.Add(nil, containerImage)
cmd.Add(env, "--etcd-endpoint=${ETCD_ENDPOINTS}")
cmd.Add(env, fmt.Sprintf("--etcd-path=/pulcy/service/%s", link.Target.EtcdServiceName()))
return cmd, nil
}