func (s *ServiceRuntime) StopOldVersion(appCfg config.App, limit int) error {
containers, err := s.ManagedContainers()
if err != nil {
return err
}
stopped := 0
for _, container := range containers {
if stopped == limit {
return nil
}
env := s.EnvFor(container)
// Container name does match one that would be started w/ this service config
if env["GALAXY_APP"] != appCfg.Name() {
continue
}
image, err := s.InspectImage(container.Image)
if err != nil {
log.Errorf("ERROR: Unable to inspect image: %s", container.Image)
continue
}
if image == nil {
log.Errorf("ERROR: Image for container %s does not exist!", container.ID[0:12])
continue
}
version := env["GALAXY_VERSION"]
if version == "" {
log.Printf("WARNING: %s missing GALAXY_VERSION", appCfg.ContainerName())
}
if version != strconv.FormatInt(appCfg.ID(), 10) && version != "" {
s.stopContainer(container)
stopped = stopped + 1
}
}
return nil
}
func (s *ServiceRuntime) Start(env, pool string, appCfg config.App) (*docker.Container, error) {
img := appCfg.Version()
imgIdRef := appCfg.Version()
if appCfg.VersionID() != "" {
imgIdRef = appCfg.VersionID()
}
// see if we have the image locally
image, err := s.PullImage(img, imgIdRef)
if err != nil {
return nil, err
}
// setup env vars from etcd
var envVars []string
envVars = append(envVars, "ENV"+"="+env)
for key, value := range appCfg.Env() {
if key == "ENV" {
continue
}
envVars = append(envVars, strings.ToUpper(key)+"="+s.replaceVarEnv(value, s.hostIP))
}
instanceId, err := s.NextInstanceSlot(appCfg.Name(), strconv.FormatInt(appCfg.ID(), 10))
if err != nil {
return nil, err
}
envVars = append(envVars, fmt.Sprintf("HOST_IP=%s", s.hostIP))
envVars = append(envVars, fmt.Sprintf("GALAXY_APP=%s", appCfg.Name()))
envVars = append(envVars, fmt.Sprintf("GALAXY_VERSION=%s", strconv.FormatInt(appCfg.ID(), 10)))
envVars = append(envVars, fmt.Sprintf("GALAXY_INSTANCE=%s", strconv.FormatInt(int64(instanceId), 10)))
publicDns, err := EC2PublicHostname()
if err != nil {
log.Warnf("Unable to determine public hostname. Not on AWS? %s", err)
publicDns = "127.0.0.1"
}
envVars = append(envVars, fmt.Sprintf("PUBLIC_HOSTNAME=%s", publicDns))
containerName := appCfg.ContainerName() + "." + strconv.FormatInt(int64(instanceId), 10)
container, err := s.dockerClient.InspectContainer(containerName)
_, ok := err.(*docker.NoSuchContainer)
if err != nil && !ok {
return nil, err
}
// Existing container is running or stopped. If the image has changed, stop
// and re-create it.
if container != nil && container.Image != image.ID {
if container.State.Running || container.State.Restarting || container.State.Paused {
log.Printf("Stopping %s version %s running as %s", appCfg.Name(), appCfg.Version(), container.ID[0:12])
err := s.dockerClient.StopContainer(container.ID, 10)
if err != nil {
return nil, err
}
}
log.Printf("Removing %s version %s running as %s", appCfg.Name(), appCfg.Version(), container.ID[0:12])
err = s.dockerClient.RemoveContainer(docker.RemoveContainerOptions{
ID: container.ID,
})
if err != nil {
return nil, err
}
container = nil
}
if container == nil {
config := &docker.Config{
Image: img,
Env: envVars,
}
mem := appCfg.GetMemory(pool)
if mem != "" {
m, err := utils.ParseMemory(mem)
if err != nil {
return nil, err
}
config.Memory = m
}
cpu := appCfg.GetCPUShares(pool)
if cpu != "" {
if c, err := strconv.Atoi(cpu); err == nil {
config.CPUShares = int64(c)
}
}
log.Printf("Creating %s version %s", appCfg.Name(), appCfg.Version())
container, err = s.dockerClient.CreateContainer(docker.CreateContainerOptions{
Name: containerName,
Config: config,
})
if err != nil {
return nil, err
}
}
log.Printf("Starting %s version %s running as %s", appCfg.Name(), appCfg.Version(), container.ID[0:12])
config := &docker.HostConfig{
PublishAllPorts: true,
RestartPolicy: docker.RestartPolicy{
Name: "on-failure",
MaximumRetryCount: 16,
},
}
if s.dns != "" {
config.DNS = []string{s.dns}
}
err = s.dockerClient.StartContainer(container.ID, config)
return container, err
}
