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())
}