func (t *AppTarget) DockerRun(c *core.Context) *docker.Run { dr := docker.NewRun(c.DockerTag()) port0, err := ports.GetFreePort() if err != nil { cli.Fatalf("Unable to get free port: %s", err) } dr.AddEnv("PORT0", strconv.Itoa(port0)) dr.AddEnv("TASK_HOST", core.DivineTaskHost()) return dr }
// DockerRun returns a configured *docker.Run, which is used to create a new // container when the old one is stale or does not exist. func (t *CompileTarget) DockerRun(c *core.Context) *docker.Run { containerName := t.ContainerName(c) run := docker.NewRun(c.DockerTag()) run.Name = containerName run.AddEnv("ARTIFACT_NAME", t.artifactName(c)) uid := cmd.Stdout("id", "-u") gid := cmd.Stdout("id", "-g") artifactOwner := fmt.Sprintf("%s:%s", uid, gid) run.AddEnv("ARTIFACT_OWNER", artifactOwner) artDir := t.artifactDir(c) dir.EnsureExists(artDir) run.AddVolume(artDir, "/artifacts") run.AddVolume(c.WorkDir, "/wd") run.Command = "npm install" return run }
func (t *TestTarget) DockerRun(c *core.Context) *docker.Run { containerName := t.ContainerName(c) run := docker.NewRun(c.DockerTag()) run.Name = containerName //run.AddEnv("ARTIFACT_NAME", t.artifactName(c)) uid := cmd.Stdout("id", "-u") gid := cmd.Stdout("id", "-g") artifactOwner := fmt.Sprintf("%s:%s", uid, gid) run.AddEnv("ARTIFACT_OWNER", artifactOwner) artDir := t.artifactDir(c) dir.EnsureExists(artDir) run.AddVolume(artDir, "/artifacts") run.AddVolume(c.WorkDir, "/wd") run.Command = fmt.Sprintf("go generate && { [ -d Godeps ] && godep go test ./... || go test ./...; }") return run }
func (t *CompileTarget) DockerRun(c *core.Context) *docker.Run { containerName := t.ContainerName(c) run := docker.NewRun(c.DockerTag()) run.Name = containerName run.AddEnv("ARTIFACT_NAME", t.artifactName(c)) uid := cmd.Stdout("id", "-u") gid := cmd.Stdout("id", "-g") artifactOwner := fmt.Sprintf("%s:%s", uid, gid) run.AddEnv("ARTIFACT_OWNER", artifactOwner) artDir := t.artifactDir(c) dir.EnsureExists(artDir) run.AddVolume(artDir, "/artifacts") run.AddVolume(c.WorkDir, "/wd") binName := fmt.Sprintf("%s-%s", c.CanonicalPackageName(), c.BuildVersion) run.Command = fmt.Sprintf("[ -d Godeps ] && godep go build -o %s || go build -o %s", binName, binName) return run }
func (t *AppTarget) Dockerfile(c *core.Context) *docker.Dockerfile { if t.artifactPath == "" { // Actually, it is first set by compile target, then the PreDockerBuild // step links it into the WD and resets artifactPath to a local, relative // path. t.artifactPath = "<¡ artifact path set by compile target !>" } df := &docker.Dockerfile{} df.From = t.pack.baseImageTag("app") // Since the artifact is tar.gz, and the dest is a directory, docker automatically unpacks it. df.AddAdd(t.artifactPath, "/srv/app/") // Pick out the contents of NPM start to invoke directly (using npm start in // production shields the app from signals, which are required to be handled by // the app itself to do graceful shutdown. df.Entrypoint = []string{ fmt.Sprintf("/srv/app/%s-%s", c.CanonicalPackageName(), c.BuildVersion), } return df }
func (t *TestTarget) Dockerfile(c *core.Context) *docker.Dockerfile { df := &docker.Dockerfile{} df.From = t.pack.baseImageTag("test") c.TemporaryLinkResource("build-prep.bash") buildPrepContainerPath := "/build-prep.bash" df.AddAdd("build-prep.bash", buildPrepContainerPath) df.AddRun(fmt.Sprintf("chmod +x %s", buildPrepContainerPath)) uid := cmd.Stdout("id", "-u") gid := cmd.Stdout("id", "-g") username := cmd.Stdout("whoami") // Just use the username for group name, it doesn't matter as long as // the IDs are right. groupAdd := fmt.Sprintf("groupadd -g %s %s", gid, username) // Explanation of some of the below useradd flags: // -M means do not create home directory, which we do not need // --no-log-init means do not create a 32G sparse file (which Docker commit // cannot handle properly, and tries to create a non-sparse 32G file.) userAdd := fmt.Sprintf("useradd --no-log-init -M --uid %s --gid %s %s", uid, gid, username) df.AddRun(fmt.Sprintf("%s && %s", groupAdd, userAdd)) df.Entrypoint = []string{"/build-prep.bash"} return df }
// ContainerName returns the name that will be given to the next container we // build. This does not have to change for each build, Sous will automatically // deleted any pre-existing containers with this name before creating a new one. func (t *CompileTarget) ContainerName(c *core.Context) string { return fmt.Sprintf("%s_reusable-builder", c.CanonicalPackageName()) }
// ImageTag return the tag that should be applied to the next image we build. func (t *CompileTarget) ImageTag(c *core.Context) string { return strconv.Itoa(c.BuildNumber()) }
func (t *CompileTarget) artifactName(c *core.Context) string { return fmt.Sprintf("%s-%s-%s-%d", c.CanonicalPackageName(), c.BuildVersion, c.Git.CommitSHA, c.BuildNumber()) }
func (t *CompileTarget) artifactDir(c *core.Context) string { return c.FilePath("artifacts") }
func (t *TestTarget) ContainerName(c *core.Context) string { return c.CanonicalPackageName() + "_test" }
func (t *AppTarget) ContainerName(c *core.Context) string { return c.CanonicalPackageName() }
func (t *TestTarget) ContainerName(c *core.Context) string { return fmt.Sprintf("%s_test-container", c.CanonicalPackageName()) }