func (b *AbstractShell) writeFetchCmd(w ShellWriter, build *common.Build, projectDir string, gitDir string) {
depth := build.GetGitDepth()
w.IfDirectory(gitDir)
if depth != "" {
w.Notice("Fetching changes for %s with git depth set to %s...", build.RefName, depth)
} else {
w.Notice("Fetching changes...")
}
w.Cd(projectDir)
w.Command("git", "clean", "-ffdx")
w.Command("git", "reset", "--hard")
w.Command("git", "remote", "set-url", "origin", build.RepoURL)
if depth != "" {
var refspec string
if build.Tag {
refspec = "+refs/tags/" + build.RefName + ":refs/tags/" + build.RefName
} else {
refspec = "+refs/heads/" + build.RefName + ":refs/remotes/origin/" + build.RefName
}
w.Command("git", "fetch", "--depth", depth, "origin", "--prune", refspec)
} else {
w.Command("git", "fetch", "origin", "--prune", "+refs/heads/*:refs/remotes/origin/*", "+refs/tags/*:refs/tags/*")
}
w.Else()
b.writeCloneCmd(w, build, projectDir)
w.EndIf()
}
func (e *machineExecutor) Prepare(globalConfig *common.Config, config *common.RunnerConfig, build *common.Build) (err error) {
e.build = build
// Use the machine
e.config, e.data, err = e.provider.Use(config, build.ExecutorData)
if err != nil {
return err
}
// TODO: Currently the docker-machine doesn't support multiple builds
build.ProjectRunnerID = 0
if details, _ := build.ExecutorData.(*machineDetails); details != nil {
build.Hostname = details.Name
} else if details, _ := e.data.(*machineDetails); details != nil {
build.Hostname = details.Name
}
e.log().Infoln("Starting docker-machine build...")
// Create original executor
e.executor = e.provider.provider.Create()
if e.executor == nil {
return errors.New("failed to create an executor")
}
return e.executor.Prepare(globalConfig, &e.config, build)
}
func (b *AbstractShell) writeCloneCmd(w ShellWriter, build *common.Build, projectDir string) {
w.RmDir(projectDir)
if depth := build.GetGitDepth(); depth != "" {
w.Notice("Cloning repository for %s with git depth set to %s...", build.RefName, depth)
w.Command("git", "clone", build.RepoURL, projectDir, "--depth", depth, "--branch", build.RefName)
} else {
w.Notice("Cloning repository...")
w.Command("git", "clone", build.RepoURL, projectDir)
}
w.Cd(projectDir)
}
func (r *RunSingleCommand) processBuild(data common.ExecutorData, abortSignal chan os.Signal) (err error) {
buildData, healthy := r.network.GetBuild(r.RunnerConfig)
if !healthy {
log.Println("Runner is not healthy!")
select {
case <-time.After(common.NotHealthyCheckInterval * time.Second):
case <-abortSignal:
}
return
}
if buildData == nil {
select {
case <-time.After(common.CheckInterval):
case <-abortSignal:
}
return
}
config := common.NewConfig()
newBuild := common.Build{
GetBuildResponse: *buildData,
Runner: &r.RunnerConfig,
SystemInterrupt: abortSignal,
ExecutorData: data,
}
buildCredentials := &common.BuildCredentials{
ID: buildData.ID,
Token: buildData.Token,
}
trace := r.network.ProcessBuild(r.RunnerConfig, buildCredentials)
defer trace.Fail(err)
err = newBuild.Run(config, trace)
return
}
func (b *AbstractShell) cacheFile(build *common.Build, userKey string) (key, file string) {
if build.CacheDir == "" {
return
}
// Deduce cache key
key = path.Join(build.Name, build.RefName)
if userKey != "" {
key = build.GetAllVariables().ExpandValue(userKey)
}
// Ignore cache without the key
if key == "" {
return
}
file = path.Join(build.CacheDir, key, "cache.zip")
file, err := filepath.Rel(build.BuildDir, file)
if err != nil {
return "", ""
}
return
}