func pullTemplateImages(template *servicetemplate.ServiceTemplate) error {
for _, img := range getImageIDs(template.Services...) {
imageID, err := commons.ParseImageID(img)
if err != nil {
return err
}
tag := imageID.Tag
if tag == "" {
tag = "latest"
}
image := fmt.Sprintf("%s:%s", imageID.BaseName(), tag)
glog.Infof("Pulling image %s", image)
if err := docker.PullImage(image); err != nil {
glog.Warningf("Unable to pull image %s", image)
}
}
return nil
}
func StartDocker(cfg *ProcessConfig, port string) (*exec.Cmd, error) {
var svc service.Service
// Create a control center client to look up the service
cp, err := node.NewControlClient(port)
if err != nil {
glog.Errorf("could not create a control center client %v", err)
return nil, err
}
glog.Infof("Connected to the control center at port %s", port)
if err := cp.GetService(cfg.ServiceID, &svc); err != nil {
glog.Errorf("unable to find service %s", cfg.ServiceID)
return nil, err
}
// make sure docker image is present
if _, err = docker.FindImage(svc.ImageID, false); err != nil {
if err == docker.ErrNoSuchImage {
if err := docker.PullImage(svc.ImageID); err != nil {
glog.Errorf("unable to pull image %s: %s", svc.ImageID, err)
return nil, err
}
} else {
glog.Errorf("unable to inspect image %s: %s", svc.ImageID, err)
return nil, err
}
}
// bind mount on /serviced
dir, bin, err := node.ExecPath()
if err != nil {
glog.Errorf("serviced not found: %s", err)
return nil, err
}
servicedVolume := fmt.Sprintf("%s:/serviced", dir)
// bind mount the pwd
dir, err = os.Getwd()
pwdVolume := fmt.Sprintf("%s:/mnt/pwd", dir)
// get the shell command
shellcmd := cfg.Command
if cfg.Command == "" {
shellcmd = "su -"
}
// get the serviced command
svcdcmd := fmt.Sprintf("/serviced/%s", bin)
// get the proxy command
proxycmd := []string{
svcdcmd,
fmt.Sprintf("--logtostderr=%t", cfg.LogToStderr),
"service",
"proxy",
"--autorestart=false",
"--disable-metric-forwarding",
fmt.Sprintf("--logstash=%t", cfg.LogStash.Enable),
fmt.Sprintf("--logstash-idle-flush-time=%s", cfg.LogStash.IdleFlushTime),
fmt.Sprintf("--logstash-settle-time=%s", cfg.LogStash.SettleTime),
svc.ID,
"0",
shellcmd,
}
// get the docker start command
docker, err := exec.LookPath("docker")
if err != nil {
glog.Errorf("Docker not found: %v", err)
return nil, err
}
argv := []string{"run", "-v", servicedVolume, "-v", pwdVolume, "-v", utils.ResourcesDir() + ":" + "/usr/local/serviced/resources"}
for _, mount := range cfg.Mount {
hostPath, containerPath, err := parseMountArg(mount)
if err != nil {
return nil, err
}
argv = append(argv, "-v", fmt.Sprintf("%s:%s", hostPath, containerPath))
}
argv = append(argv, cfg.Envv...)
if cfg.SaveAs != "" {
argv = append(argv, fmt.Sprintf("--name=%s", cfg.SaveAs))
} else {
argv = append(argv, "--rm")
}
if cfg.IsTTY {
argv = append(argv, "-i", "-t")
}
// set the systemuser and password
unused := 0
systemUser := user.User{}
err = cp.GetSystemUser(unused, &systemUser)
if err != nil {
glog.Errorf("Unable to get system user account for client %s", err)
}
argv = append(argv, "-e", fmt.Sprintf("CONTROLPLANE_SYSTEM_USER=%s ", systemUser.Name))
argv = append(argv, "-e", fmt.Sprintf("CONTROLPLANE_SYSTEM_PASSWORD=%s ", systemUser.Password))
argv = append(argv, "-e", fmt.Sprintf("SERVICED_NOREGISTRY=%s", os.Getenv("SERVICED_NOREGISTRY")))
argv = append(argv, "-e", fmt.Sprintf("SERVICED_IS_SERVICE_SHELL=true"))
argv = append(argv, "-e", fmt.Sprintf("SERVICED_SERVICE_IMAGE=%s", svc.ImageID))
argv = append(argv, svc.ImageID)
argv = append(argv, proxycmd...)
// wait for the DFS to be ready in order to start container on the latest image
glog.Infof("Acquiring image from the dfs...")
cp.ReadyDFS(false, nil)
glog.Infof("Acquired! Starting shell")
glog.V(1).Infof("command: docker %+v", argv)
return exec.Command(docker, argv...), nil
}
