func GetInfo() *Info {
nearestTagSHA := ""
nearestTag, err := cmd.StdoutErr("git", "describe", "--tags", "--abbrev=0")
if err != nil {
nearestTag = ""
} else {
nearestTagSHA = cmd.Stdout("git", "rev-parse", nearestTag)
}
return &Info{
CommitSHA: cmd.Stdout("git", "rev-parse", "HEAD"),
OriginURL: getOriginURL(),
NearestTag: nearestTag,
NearestTagSHA: nearestTagSHA,
}
}
// CalculateSousHash returns a hash of the current version of Sous and its main
// configuration file.
func CalculateSousHash() string {
inputs := []string{cmd.Stdout("sous", "version")}
if c, ok := file.ReadString("~/.sous/config"); ok {
inputs = append(inputs, c)
}
return HashSum(inputs...)
}
// 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 RequireDaemon() {
if c := cmd.ExitCode("docker", "ps"); c != 0 {
cli.Logf("`docker ps` exited with code %d", c)
if dockermachine.Installed() {
vms := dockermachine.RunningVMs()
if len(vms) != 0 {
cli.Fatalf(`Tip: eval "$(docker-machine env %s)"`, vms[0])
}
vms = dockermachine.VMs()
switch len(vms) {
case 0:
cli.Logf("Tip: you should create a machine using docker-machine")
case 1:
start := ""
if cmd.Stdout("docker-machine", "status", vms[0]) != "Running" {
start = fmt.Sprintf("docker-machine start %s && ", vms[0])
}
cli.Logf(`Tip: %seval "$(docker-machine env %s)"`, start, vms[0])
default:
cli.Logf("Tip: start one of your docker machines (%s)",
strings.Join(vms, ", "))
}
}
cli.Fatal()
}
}
// Dockerfile returns a configured *docker.Dockerfile which is used by Sous
// to build new Docker images when needed.
func (t *CompileTarget) Dockerfile(*core.Context) *docker.Dockerfile {
df := t.NodeJSPack.baseDockerfile(t.Name())
// This is a non-portable container, since it includes the UID of the
// logged-in user.
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.
df.AddRun(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.)
df.AddRun(fmt.Sprintf("useradd --no-log-init -M --uid %s --gid %s %s", uid, gid, username))
df.AddRun("npm install -g npm@2")
return df
}
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 RunningVMs() []string {
list := []string{}
for _, v := range VMs() {
if cmd.Stdout("docker-machine", "status", v) == "Running" {
list = append(list, v)
}
}
return list
}
func GetContext(action string) *Context {
var c = config.Load()
registry := c.DockerRegistry
gitInfo := git.GetInfo()
bs := GetBuildState(action, gitInfo)
wd, err := os.Getwd()
if err != nil {
cli.Fatalf("Unable to get current working directory: %s", err)
}
return &Context{
Git: gitInfo,
WorkDir: wd,
TargetName: action,
DockerRegistry: registry,
Host: cmd.Stdout("hostname"),
FullHost: cmd.Stdout("hostname", "-f"),
User: getUser(),
BuildState: bs,
BuildVersion: buildVersion(gitInfo),
}
}
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
}
// CalculateTreeHash returns a hash of the current state of the working tree,
// leaning heavily on git for optimisation.
func CalculateTreeHash() string {
inputs := []string{}
indexDiffs := cmd.Stdout("git", "diff-index", "HEAD")
if len(indexDiffs) != 0 {
inputs = append(inputs, indexDiffs)
}
newFiles := git.UntrackedUnignoredFiles()
if len(newFiles) != 0 {
for _, f := range newFiles {
inputs = append(inputs, f)
if content, ok := file.ReadString(f); ok {
inputs = append(inputs, content)
}
}
}
return HashSum(inputs...)
}
func getUser() string {
if buildingInCI() {
return "ci"
}
return cmd.Stdout("id", "-un")
}