// execute is responsible for running a build
func (c *builderConfig) execute(b builder) error {
gitEnv, err := c.setupGitEnvironment()
if err != nil {
return err
}
gitClient := git.NewRepositoryWithEnv(gitEnv)
/*
cgLimits, err := bld.GetCGroupLimits()
if err != nil {
return fmt.Errorf("failed to retrieve cgroup limits: %v", err)
}
glog.V(2).Infof("Running build with cgroup limits: %#v", *cgLimits)
*/
if err := b.Build(c.dockerClient, c.dockerEndpoint, c.buildsClient, c.build, gitClient, nil); err != nil {
return fmt.Errorf("build error: %v", err)
}
if c.build.Spec.Output.To == nil || len(c.build.Spec.Output.To.Name) == 0 {
glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.")
}
return nil
}
func TestCheckRemoteGit(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusUnauthorized)
}))
defer server.Close()
gitRepo := git.NewRepositoryWithEnv([]string{"GIT_ASKPASS=true"})
var err error
err = checkRemoteGit(gitRepo, server.URL, 10*time.Second)
switch v := err.(type) {
case gitAuthError:
default:
t.Errorf("expected gitAuthError, got %q", v)
}
t0 := time.Now()
err = checkRemoteGit(gitRepo, "https://254.254.254.254/foo/bar", 4*time.Second)
t1 := time.Now()
if err == nil || (err != nil && !strings.Contains(fmt.Sprintf("%s", err), "timeout")) {
t.Errorf("expected timeout error, got %q", err)
}
if t1.Sub(t0) > 5*time.Second {
t.Errorf("expected timeout in 4 seconds, it took %v", t1.Sub(t0))
}
err = checkRemoteGit(gitRepo, "https://github.com/openshift/origin", 10*time.Second)
if err != nil {
t.Errorf("unexpected error %q", err)
}
}
// execute is responsible for running a build
func (c *builderConfig) execute(b builder) error {
secretTmpDir, gitEnv, err := c.setupGitEnvironment()
if err != nil {
return err
}
gitClient := git.NewRepositoryWithEnv(gitEnv)
cgLimits, err := bld.GetCGroupLimits()
if err != nil {
return fmt.Errorf("failed to retrieve cgroup limits: %v", err)
}
glog.V(4).Infof("Running build with cgroup limits: %#v", *cgLimits)
if err := b.Build(c.dockerClient, c.dockerEndpoint, c.buildsClient, c.build, gitClient, cgLimits); err != nil {
return fmt.Errorf("build error: %v", err)
}
if c.build.Spec.Output.To == nil || len(c.build.Spec.Output.To.Name) == 0 {
fmt.Fprintf(c.out, "Build complete, no image push requested\n")
}
os.RemoveAll(secretTmpDir)
return nil
}
func TestCloneFromBranch(t *testing.T) {
repo, err := initializeTestGitRepo("branch")
defer repo.cleanup()
if err != nil {
t.Errorf("%v", err)
}
if err := repo.addSubmodule(); err != nil {
t.Errorf("%v", err)
}
// add two commits to check that shallow clone take account
if err := repo.addCommit(); err != nil {
t.Errorf("unable to add commit: %v", err)
}
if err := repo.createBranch("test"); err != nil {
t.Errorf("%v", err)
}
if err := repo.addCommit(); err != nil {
t.Errorf("unable to add commit: %v", err)
}
if err := repo.switchBranch("master"); err != nil {
t.Errorf("%v", err)
}
if err := repo.addCommit(); err != nil {
t.Errorf("unable to add commit: %v", err)
}
destDir, err := ioutil.TempDir("", "branch-dest-")
defer os.RemoveAll(destDir)
client := git.NewRepositoryWithEnv([]string{})
source := &api.GitBuildSource{
URI: "file://" + repo.Path,
Ref: "test",
}
revision := api.SourceRevision{Git: &api.GitSourceRevision{}}
if _, err = extractGitSource(client, source, &revision, destDir, 10*time.Second); err != nil {
t.Errorf("%v", err)
}
for _, f := range repo.Files[:len(repo.Files)-1] {
if _, err := os.Stat(filepath.Join(destDir, path.Base(f))); os.IsNotExist(err) {
t.Errorf("file %q should not exists in the test branch", f)
}
}
if _, err := os.Stat(filepath.Join(destDir, path.Base(repo.Files[len(repo.Files)-1]))); !os.IsNotExist(err) {
t.Errorf("last file should not exists in the test branch")
}
if _, err := os.Stat(filepath.Join(destDir, "sub")); os.IsNotExist(err) {
t.Errorf("unable to find submodule dir")
}
for _, f := range repo.Submodule.Files {
if _, err := os.Stat(filepath.Join(destDir, "sub/"+path.Base(f))); os.IsNotExist(err) {
t.Errorf("unable to find submodule repository file %q", path.Base(f))
}
}
}
// execute is responsible for running a build
func (c *builderConfig) execute(b builder) error {
gitEnv, err := c.setupGitEnvironment()
if err != nil {
return err
}
gitClient := git.NewRepositoryWithEnv(gitEnv)
if err := b.Build(c.dockerClient, c.dockerEndpoint, c.buildsClient, c.build, gitClient); err != nil {
return fmt.Errorf("build error: %v", err)
}
if c.build.Spec.Output.To == nil || len(c.build.Spec.Output.To.Name) == 0 {
glog.Warning("Build does not have an Output defined, no output image was pushed to a registry.")
}
return nil
}
func TestCheckRemoteGit(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusUnauthorized)
}))
defer server.Close()
gitRepo := git.NewRepositoryWithEnv([]string{"GIT_ASKPASS=true"})
var err error
err = checkRemoteGit(gitRepo, server.URL, 10*time.Second)
switch v := err.(type) {
case gitAuthError:
default:
t.Errorf("expected gitAuthError, got %q", v)
}
err = checkRemoteGit(gitRepo, "https://github.com/openshift/origin", 10*time.Second)
if err != nil {
t.Errorf("unexpected error %q", err)
}
}
// DetectAuth returns an error if the source repository cannot be cloned
// without the current user's environment. The following changes are made to the
// environment:
// 1) The HOME directory is set to a temporary dir to avoid loading any settings in .gitconfig
// 2) The GIT_SSH variable is set to /dev/null so the regular SSH keys are not used
// (changing the HOME directory is not enough).
// 3) GIT_CONFIG_NOSYSTEM prevents git from loading system-wide config
// 4) GIT_ASKPASS to prevent git from prompting for a user/password
func (r *SourceRepository) DetectAuth() error {
url, ok, err := r.RemoteURL()
if err != nil {
return err
}
if !ok {
return nil // No auth needed, we can't find a remote URL
}
tempHome, err := ioutil.TempDir("", "githome")
if err != nil {
return err
}
defer os.RemoveAll(tempHome)
tempSrc, err := ioutil.TempDir("", "gen")
if err != nil {
return err
}
defer os.RemoveAll(tempSrc)
env := []string{
fmt.Sprintf("HOME=%s", tempHome),
"GIT_SSH=/dev/null",
"GIT_CONFIG_NOSYSTEM=true",
"GIT_ASKPASS=true",
}
if runtime.GOOS == "windows" {
env = append(env,
fmt.Sprintf("ProgramData=%s", os.Getenv("ProgramData")),
fmt.Sprintf("SystemRoot=%s", os.Getenv("SystemRoot")),
)
}
gitRepo := git.NewRepositoryWithEnv(env)
localURL, ref := cloneURLAndRef(url)
_, err = CloneAndCheckoutSources(gitRepo, localURL.String(), ref, tempSrc, "")
if err != nil {
r.requiresAuth = true
}
return nil
}
func TestUnqualifiedClone(t *testing.T) {
repo, err := initializeTestGitRepo("unqualified")
defer repo.cleanup()
if err != nil {
t.Errorf("%v", err)
}
if err := repo.addSubmodule(); err != nil {
t.Errorf("%v", err)
}
// add two commits to check that shallow clone take account
if err := repo.addCommit(); err != nil {
t.Errorf("unable to add commit: %v", err)
}
if err := repo.addCommit(); err != nil {
t.Errorf("unable to add commit: %v", err)
}
destDir, err := ioutil.TempDir("", "clone-dest-")
defer os.RemoveAll(destDir)
client := git.NewRepositoryWithEnv([]string{})
source := &api.GitBuildSource{URI: "file://" + repo.Path}
revision := api.SourceRevision{Git: &api.GitSourceRevision{}}
if _, err = extractGitSource(client, source, &revision, destDir, 10*time.Second); err != nil {
t.Errorf("%v", err)
}
for _, f := range repo.Files {
if _, err := os.Stat(filepath.Join(destDir, path.Base(f))); os.IsNotExist(err) {
t.Errorf("unable to find repository file %q", path.Base(f))
}
}
if _, err := os.Stat(filepath.Join(destDir, "sub")); os.IsNotExist(err) {
t.Errorf("unable to find submodule dir")
}
for _, f := range repo.Submodule.Files {
if _, err := os.Stat(filepath.Join(destDir, "sub/"+path.Base(f))); os.IsNotExist(err) {
t.Errorf("unable to find submodule repository file %q", path.Base(f))
}
}
}