func doTest(bldPrefix, debugStr string, same bool, oc *exutil.CLI) {
// corrupt the builder image
exutil.CorruptImage(fullImageName, corruptor)
if bldPrefix == buildPrefixFC || bldPrefix == buildPrefixTC {
// grant access to the custom build strategy
err := oc.AsAdmin().Run("adm").Args("policy", "add-cluster-role-to-user", "system:build-strategy-custom", oc.Username()).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
defer func() {
err = oc.AsAdmin().Run("adm").Args("policy", "remove-cluster-role-from-user", "system:build-strategy-custom", oc.Username()).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
}()
}
// kick off the app/lang build and verify the builder image accordingly
_, err := exutil.StartBuildAndWait(oc, bldPrefix)
o.ExpectWithOffset(1, err).NotTo(o.HaveOccurred())
if same {
exutil.VerifyImagesSame(fullImageName, corruptor, debugStr)
} else {
exutil.VerifyImagesDifferent(fullImageName, corruptor, debugStr)
}
// reset corrupted tagging for next test
exutil.ResetImage(resetData)
// dump tags/hexids for debug
_, err = exutil.DumpAndReturnTagging(tags)
o.ExpectWithOffset(1, err).NotTo(o.HaveOccurred())
}
func doTest(bldPrefix, debugStr string, same bool, oc *exutil.CLI) {
// corrupt the builder image
exutil.CorruptImage(fullImageName, corruptor)
// kick off the app/lang build and verify the builder image accordingly
_, err := exutil.StartBuildAndWait(oc, bldPrefix)
o.ExpectWithOffset(1, err).NotTo(o.HaveOccurred())
if same {
exutil.VerifyImagesSame(fullImageName, corruptor, debugStr)
} else {
exutil.VerifyImagesDifferent(fullImageName, corruptor, debugStr)
}
// reset corrupted tagging for next test
exutil.ResetImage(resetData)
// dump tags/hexids for debug
_, err = exutil.DumpAndReturnTagging(tags)
o.ExpectWithOffset(1, err).NotTo(o.HaveOccurred())
}
g.It("by creating slave from existing builder and adding it to Jenkins master", func() {
g.By("create the jenkins slave builder template")
err := oc.Run("create").Args("-f", jenkinsSlaveBuilderTemplate).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("create the jenkins master template")
err = oc.Run("create").Args("-f", jenkinsMasterTemplate).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("instantiate the slave template")
err = oc.Run("new-app").Args("--template", "jenkins-slave-builder").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("build the Jenkins slave for ruby-22-centos7")
br, err := exutil.StartBuildAndWait(oc, "ruby-22-centos7-jenkins-slave", "--wait", "--from-dir", "examples/jenkins/master-slave/slave")
br.AssertSuccess()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("grant service account in jenkins container access to API")
err = oc.Run("policy").Args("add-role-to-user", "edit", "system:serviceaccount:"+oc.Namespace()+":default", "-n", oc.Namespace()).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("instantiate the master template")
err = oc.Run("new-app").Args("--template", "jenkins-master").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("build the Jenkins master")
br, err = exutil.StartBuildAndWait(oc, "jenkins-master", "--wait", "--from-dir", "examples/jenkins/master-slave")
br.AssertSuccess()
o.Expect(err).NotTo(o.HaveOccurred())
g.Describe("build with long names", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.It("delete builds with long names without collateral damage", func() {
g.By("creating long_names fixtures")
err := oc.Run("create").Args("-f", longNamesFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
// Names can be a maximum of 253 chars. These build config names are 201 (to allow for suffixes appiled during the test process, e.g. -1, -2 for builds and log filenames)
// and the names differ only in the last character.
bcA := "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890a"
bcB := "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890b"
g.By("starting long name build config A-1")
brA1, err := exutil.StartBuildAndWait(oc, bcA)
brA1.AssertSuccess()
g.By("starting long name build config B-1")
brB1, err := exutil.StartBuildAndWait(oc, bcB)
brB1.AssertSuccess()
g.By("starting long name build config A-2")
brA2, err := exutil.StartBuildAndWait(oc, bcA)
brA2.AssertSuccess()
g.By("starting long name build config B-2")
brB2, err := exutil.StartBuildAndWait(oc, bcB)
brB2.AssertSuccess()
builds := [...]*exutil.BuildResult{brA1, brB1, brA2, brB2}
})
g.Describe("S2I build from a template", func() {
g.It(fmt.Sprintf("should create a image from %q template with proper Docker labels", stiBuildFixture), func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc create -f %q", imageStreamFixture))
err := oc.Run("create").Args("-f", imageStreamFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By(fmt.Sprintf("calling oc create -f %q", stiBuildFixture))
err = oc.Run("create").Args("-f", stiBuildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a test build")
br, err := exutil.StartBuildAndWait(oc, "test")
br.AssertSuccess()
g.By("getting the Docker image reference from ImageStream")
imageRef, err := exutil.GetDockerImageReference(oc.REST().ImageStreams(oc.Namespace()), "test", "latest")
o.Expect(err).NotTo(o.HaveOccurred())
imageLabels, err := eximages.GetImageLabels(oc.REST().ImageStreamImages(oc.Namespace()), "test", imageRef)
o.Expect(err).NotTo(o.HaveOccurred())
g.By("inspecting the new image for proper Docker labels")
err = ExpectOpenShiftLabels(imageLabels)
o.Expect(err).NotTo(o.HaveOccurred())
})
})
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("oc start-build source-build --wait", func() {
g.It("Source: should start a build and wait for the build failed and build pod being killed by kubelet", func() {
g.By("calling oc create source-build")
err := oc.Run("create").Args("-f", sourceFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting the source build with --wait flag and short timeout")
br, err := exutil.StartBuildAndWait(oc, "source-build", "--wait")
o.Expect(br.StartBuildErr).To(o.HaveOccurred()) // start-build should detect the build error
g.By("verifying the build status")
o.Expect(br.BuildAttempt).To(o.BeTrue()) // the build should have been attempted
o.Expect(br.Build.Status.Phase).Should(o.BeEquivalentTo(buildapi.BuildPhaseFailed)) // the build should have failed
g.By("verifying the build pod status")
pod, err := oc.KubeREST().Pods(oc.Namespace()).Get(buildapi.GetBuildPodName(br.Build))
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(pod.Status.Phase).Should(o.BeEquivalentTo(kapi.PodFailed))
o.Expect(pod.Status.Reason).Should(o.ContainSubstring("DeadlineExceeded"))
})
})
})
g.Context("Pipeline with maven slave", func() {
g.It("Should build and complete successfully", func() {
// Deploy Jenkins
g.By(fmt.Sprintf("calling oc new-app -f %q", jenkinsTemplatePath))
err := oc.Run("new-app").Args("-f", jenkinsTemplatePath).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
// instantiate the template
g.By(fmt.Sprintf("calling oc new-app -f %q", mavenSlavePipelinePath))
err = oc.Run("new-app").Args("-f", mavenSlavePipelinePath).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
// start the build
g.By("starting the pipeline build and waiting for it to complete")
br, _ := exutil.StartBuildAndWait(oc, "openshift-jee-sample")
br.AssertSuccess()
// wait for the service to be running
g.By("expecting the openshift-jee-sample service to be deployed and running")
_, err = exutil.GetEndpointAddress(oc, "openshift-jee-sample")
o.Expect(err).NotTo(o.HaveOccurred())
})
})
g.Context("Orchestration pipeline", func() {
g.It("Should build and complete successfully", func() {
// Deploy Jenkins
g.By(fmt.Sprintf("calling oc new-app -f %q", jenkinsTemplatePath))
err := oc.Run("new-app").Args("-f", jenkinsTemplatePath).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
buildFixture = exutil.FixturePath("testdata", "test-build-proxy.json")
oc = exutil.NewCLI("build-proxy", exutil.KubeConfigPath())
)
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
oc.Run("create").Args("-f", buildFixture).Execute()
})
g.Describe("start build with broken proxy", func() {
g.It("should start a build and wait for the build to to fail", func() {
g.By("starting the build")
br, _ := exutil.StartBuildAndWait(oc, "sample-build")
br.AssertFailure()
g.By("verifying the build sample-build-1 output")
// The git ls-remote check should exit the build when the remote
// repository is not accessible. It should never get to the clone.
buildLog, err := br.Logs()
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(buildLog).NotTo(o.ContainSubstring("clone"))
if !strings.Contains(buildLog, `unable to access 'https://github.com/openshift/ruby-hello-world.git/': Failed connect to 127.0.0.1:3128`) {
fmt.Fprintf(g.GinkgoWriter, "\nbuild log:\n%s\n", buildLog)
}
o.Expect(buildLog).To(o.ContainSubstring(`unable to access 'https://github.com/openshift/ruby-hello-world.git/': Failed connect to 127.0.0.1:3128`))
g.By("verifying the build sample-build-1 status")
o.Expect(br.Build.Status.Phase).Should(o.BeEquivalentTo(buildapi.BuildPhaseFailed))
})
g.Describe("Building from a template", func() {
g.It(fmt.Sprintf("should create a image from %q template and run it in a pod", stiEnvBuildFixture), func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc create -f %q", imageStreamFixture))
err := oc.Run("create").Args("-f", imageStreamFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By(fmt.Sprintf("calling oc create -f %q", stiEnvBuildFixture))
err = oc.Run("create").Args("-f", stiEnvBuildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a test build")
br, _ := exutil.StartBuildAndWait(oc, "test")
br.AssertSuccess()
g.By("getting the Docker image reference from ImageStream")
imageName, err := exutil.GetDockerImageReference(oc.REST().ImageStreams(oc.Namespace()), "test", "latest")
o.Expect(err).NotTo(o.HaveOccurred())
g.By("instantiating a pod and service with the new image")
err = oc.Run("new-app").Args("-f", podAndServiceFixture, "-p", "IMAGE_NAME="+imageName).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("waiting for the service to become available")
err = oc.KubeFramework().WaitForAnEndpoint(buildTestService)
o.Expect(err).NotTo(o.HaveOccurred())
g.By("expecting the pod container has TEST_ENV variable set")
// See this issue for details: https://github.com/openshift/origin/issues/10103
err = exutil.WaitForAnImageStreamTag(oc, "openshift", "wildfly", "10.0")
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("with scripts from the source repository", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.It("should use assemble-runtime script from the source repository", func() {
g.By("creating jvm-runner configuration")
err := exutil.CreateResource(runnerConf, oc)
o.Expect(err).NotTo(o.HaveOccurred())
g.By("building jvm-runner image")
br, _ := exutil.StartBuildAndWait(oc, "jvm-runner")
br.AssertSuccess()
g.By("creating build config")
err = exutil.CreateResource(scriptsFromRepoBc, oc)
o.Expect(err).NotTo(o.HaveOccurred())
g.By("running the build")
br, _ = exutil.StartBuildAndWait(oc, "java-extended-build-from-repo", "--build-loglevel=5")
br.AssertSuccess()
buildLog, err := br.Logs()
if err != nil {
e2e.Failf("Failed to fetch build logs: %v", err)
}
g.By("expecting that .s2i/bin/assemble-runtime was executed")
defer g.GinkgoRecover()
var (
dockerImageFixture = exutil.FixturePath("testdata", "test-docker-no-outputname.json")
s2iImageFixture = exutil.FixturePath("testdata", "test-s2i-no-outputname.json")
oc = exutil.NewCLI("build-no-outputname", exutil.KubeConfigPath())
)
g.Describe("building from templates", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.It(fmt.Sprintf("should create an image from %q docker template without an output image reference defined", dockerImageFixture), func() {
err := oc.Run("create").Args("-f", dockerImageFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("expecting build to pass without an output image reference specified")
br, err := exutil.StartBuildAndWait(oc, "test-docker")
br.AssertSuccess()
g.By("verifying the build test-docker-1 output")
buildLog, err := br.Logs()
fmt.Fprintf(g.GinkgoWriter, "\nBuild log:\n%s\n", buildLog)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(buildLog).Should(o.ContainSubstring(`Build complete, no image push requested`))
})
g.It(fmt.Sprintf("should create an image from %q S2i template without an output image reference defined", s2iImageFixture), func() {
err := oc.Run("create").Args("-f", s2iImageFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("expecting build to pass without an output image reference specified")
br, err := exutil.StartBuildAndWait(oc, "test-sti")
g.By("creating secret fixtures")
err := oc.Run("create").Args("-f", secretsFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
err = oc.Run("create").Args("-f", secondSecretsFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("creating test image stream")
err = oc.Run("create").Args("-f", isFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("creating test build config")
err = oc.Run("create").Args("-f", sourceBuildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting the test source build")
br, _ := exutil.StartBuildAndWait(oc, "test", "--from-dir", sourceBuildBinDir)
br.AssertSuccess()
g.By("getting the image name")
image, err := exutil.GetDockerImageReference(oc.REST().ImageStreams(oc.Namespace()), "test", "latest")
o.Expect(err).NotTo(o.HaveOccurred())
g.By("verifying the build secrets were available during build and not present in the output image")
pod := exutil.GetPodForContainer(kapi.Container{Name: "test", Image: image})
oc.KubeFramework().TestContainerOutput("test-build-secret-source", pod, 0, []string{
"testsecret/secret1=secret1",
"testsecret/secret2=secret2",
"testsecret/secret3=secret3",
"testsecret2/secret1=secret1",
"testsecret2/secret2=secret2",
"testsecret2/secret3=secret3",
defer g.GinkgoRecover()
var (
buildFixture = exutil.FixturePath("testdata", "test-nosrc-build.json")
oc = exutil.NewCLI("cli-build-nosrc", exutil.KubeConfigPath())
exampleBuild = exutil.FixturePath("testdata", "test-build-app")
)
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeClient().Core().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
oc.Run("create").Args("-f", buildFixture).Execute()
})
g.Describe("started build", func() {
g.It("should build even with an empty source in build config", func() {
g.By("starting the empty source build")
br, err := exutil.StartBuildAndWait(oc, "nosrc-build", fmt.Sprintf("--from-dir=%s", exampleBuild))
br.AssertSuccess()
g.By(fmt.Sprintf("verifying the status of %q", br.BuildPath))
build, err := oc.Client().Builds(oc.Namespace()).Get(br.Build.Name)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(build.Spec.Source.Dockerfile).To(o.BeNil())
o.Expect(build.Spec.Source.Git).To(o.BeNil())
o.Expect(build.Spec.Source.Images).To(o.BeNil())
o.Expect(build.Spec.Source.Binary).NotTo(o.BeNil())
})
})
})
)
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("s2i build with a rootable builder", func() {
g.It("should not be able to switch to root with an assemble script", func() {
g.By("calling oc new-build for rootable-builder")
err := oc.Run("new-build").Args("--binary", "--name=rootable-ruby").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting the rootable-ruby build")
br, _ := exutil.StartBuildAndWait(oc, "rootable-ruby", fmt.Sprintf("--from-dir=%s", s2ibuilderFixture))
br.AssertSuccess()
g.By("creating a build that tries to gain root access via su")
err = oc.Run("create").Args("-f", rootAccessBuildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("start the root-access-build which attempts root access")
br2, _ := exutil.StartBuildAndWait(oc, "root-access-build")
br2.AssertFailure()
})
})
})
binaryBuildDir = exutil.FixturePath("testdata", "statusfail-assemble")
oc = exutil.NewCLI("update-buildstatus", exutil.KubeConfigPath())
)
g.JustBeforeEach(func() {
g.By("waiting for the builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeClient().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("Build status postcommit hook failure", func() {
g.It("should contain the post commit hook failure reason and message", func() {
err := oc.Run("create").Args("-f", postCommitHookFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
br, err := exutil.StartBuildAndWait(oc, "statusfail-postcommithook")
o.Expect(err).NotTo(o.HaveOccurred())
br.AssertFailure()
build, err := oc.Client().Builds(oc.Namespace()).Get(br.Build.Name)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(build.Status.Reason).To(o.Equal(buildapi.StatusReasonPostCommitHookFailed))
o.Expect(build.Status.Message).To(o.Equal(buildapi.StatusMessagePostCommitHookFailed))
})
})
g.Describe("Build status Docker fetch source failure", func() {
g.It("should contain the Docker build fetch source failure reason and message", func() {
err := oc.Run("create").Args("-f", fetchDockerSrc).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeClient().Core().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
oc.Run("create").Args("-f", buildFixture).Execute()
g.By("waiting for istag to initialize")
exutil.WaitForAnImageStreamTag(oc, oc.Namespace(), "busybox", "1")
})
g.Describe("testing postCommit hook", func() {
g.It("successful postCommit script with args", func() {
err := oc.Run("patch").Args("bc/busybox", "-p", "{\"spec\":{\"postCommit\":{\"script\":\"echo hello $1\",\"args\":[\"world\"],\"command\":null}}}").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
br, _ := exutil.StartBuildAndWait(oc, "busybox")
br.AssertSuccess()
o.Expect(br.Logs()).To(o.ContainSubstring("hello world"))
})
g.It("successful postCommit explicit command", func() {
err := oc.Run("patch").Args("bc/busybox", "-p", "{\"spec\":{\"postCommit\":{\"command\":[\"sh\",\"-c\"],\"args\":[\"echo explicit command\"],\"script\":\"\"}}}").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
br, _ := exutil.StartBuildAndWait(oc, "busybox")
br.AssertSuccess()
o.Expect(br.Logs()).To(o.ContainSubstring("explicit command"))
})
g.It("successful postCommit default entrypoint", func() {
err := oc.Run("patch").Args("bc/busybox", "-p", "{\"spec\":{\"postCommit\":{\"args\":[\"echo\",\"default entrypoint\"],\"command\":null,\"script\":\"\"}}}").Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.AdminKubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("Building from a template", func() {
g.It("should create an s2i build with a quota and run it", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc create -f %q", buildFixture))
err := oc.Run("create").Args("-f", buildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a test build")
br, _ := exutil.StartBuildAndWait(oc, "s2i-build-quota", "--from-dir", exutil.FixturePath("testdata", "build-quota"))
br.AssertSuccess()
g.By("expecting the build logs to contain the correct cgroups values")
buildLog, err := br.Logs()
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(buildLog).To(o.ContainSubstring("MEMORY=209715200"))
o.Expect(buildLog).To(o.ContainSubstring("MEMORYSWAP=209715200"))
o.Expect(buildLog).To(o.ContainSubstring("SHARES=61"))
o.Expect(buildLog).To(o.ContainSubstring("PERIOD=100000"))
o.Expect(buildLog).To(o.ContainSubstring("QUOTA=6000"))
})
})
})
})
g.Describe("Building from a template", func() {
g.It(fmt.Sprintf("should create a image from %q template and run it in a pod", stiEnvBuildFixture), func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc create -f %q", imageStreamFixture))
err := oc.Run("create").Args("-f", imageStreamFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By(fmt.Sprintf("calling oc create -f %q", stiEnvBuildFixture))
err = oc.Run("create").Args("-f", stiEnvBuildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a test build")
br, _ := exutil.StartBuildAndWait(oc, "test", "--from-dir", "test/extended/testdata/sti-environment-build-app")
br.AssertSuccess()
g.By("getting the Docker image reference from ImageStream")
imageName, err := exutil.GetDockerImageReference(oc.Client().ImageStreams(oc.Namespace()), "test", "latest")
o.Expect(err).NotTo(o.HaveOccurred())
g.By("instantiating a pod and service with the new image")
err = oc.Run("new-app").Args("-f", podAndServiceFixture, "-p", "IMAGE_NAME="+imageName).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("waiting for the service to become available")
err = oc.KubeFramework().WaitForAnEndpoint(buildTestService)
o.Expect(err).NotTo(o.HaveOccurred())
g.By("expecting the pod container has TEST_ENV variable set")
g.Context("Manual deploy the jenkins and trigger a jenkins pipeline build", func() {
g.It("JenkinsPipeline build should succeed when manual deploy the jenkins service", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc new-app -f %q", jenkinsTemplatePath))
err := oc.Run("new-app").Args("-f", jenkinsTemplatePath).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
//wait for the jenkins deployment complete
g.By("waiting the jenkins service deployed")
err = exutil.WaitForADeploymentToComplete(oc.KubeREST().ReplicationControllers(oc.Namespace()), "jenkins", oc)
if err != nil {
exutil.DumpDeploymentLogs("jenkins", oc)
}
o.Expect(err).NotTo(o.HaveOccurred())
// create the pipeline build example
g.By(fmt.Sprintf("calling oc new-app -f %q", pipelineTemplatePath))
err = oc.Run("new-app").Args("-f", pipelineTemplatePath).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a pipeline build")
br, _ := exutil.StartBuildAndWait(oc, "sample-pipeline")
if !br.BuildSuccess {
exutil.DumpDeploymentLogs("jenkins", oc)
}
br.AssertSuccess()
})
})
})
var oc = exutil.NewCLI("forcepull", exutil.KubeConfigPath())
g.BeforeEach(func() {
g.By("refresh corruptor, prep forcepull builder")
exutil.PullImage(corruptor, dockerClient.AuthConfiguration{})
exutil.DumpImage(corruptor)
// create the image streams and build configs for a test case specific builders
setupPath := exutil.FixturePath("testdata", "forcepull-setup.json")
err := exutil.CreateResource(setupPath, oc)
// kick off the build for the new builder image just for force pull so we can corrupt them without conflicting with
// any other tests potentially running in parallel
br, _ := exutil.StartBuildAndWait(oc, bldrPrefix)
br.AssertSuccess()
serviceIP, err := oc.Run("get").Args("svc", "docker-registry", "-n", "default", "--config", exutil.KubeConfigPath()).Template("{{.spec.clusterIP}}").Output()
o.Expect(err).NotTo(o.HaveOccurred())
port, err := oc.Run("get").Args("svc", "docker-registry", "-n", "default", "--config", exutil.KubeConfigPath()).Template("{{ $x := index .spec.ports 0}}{{$x.port}}").Output()
o.Expect(err).NotTo(o.HaveOccurred())
g.By(fmt.Sprintf("docker-registry service IP is %s and port %s ", serviceIP, port))
// get the auth so we can pull the build image from the internal docker registry since the builder controller will remove it
// from the docker daemon cache when the docker build completes;
authCfg, err = exutil.BuildAuthConfiguration(serviceIP+":"+port, oc)
// now actually pull the image back in from the openshift internal docker registry
fullImageName = authCfg.ServerAddress + "/" + oc.Namespace() + "/" + bldr
err = exutil.PullImage(fullImageName, *authCfg)
oc = exutil.NewCLI("docker-build-pullsecret", exutil.KubeConfigPath())
)
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.AdminKubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("Building from a template", func() {
g.It("should create a docker build that pulls using a secret run it", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc create -f %q", buildFixture))
err := oc.Run("create").Args("-f", buildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a build")
br, err := exutil.StartBuildAndWait(oc, "docker-build")
o.Expect(err).NotTo(o.HaveOccurred())
br.AssertSuccess()
g.By("starting a second build that pulls the image from the first build")
br, err = exutil.StartBuildAndWait(oc, "docker-build-pull")
o.Expect(err).NotTo(o.HaveOccurred())
br.AssertSuccess()
})
})
})
pushToRegistryFixture = exutil.FixturePath("testdata", "statusfail-pushtoregistry.yaml")
failedAssembleFixture = exutil.FixturePath("testdata", "statusfail-failedassemble.yaml")
)
g.JustBeforeEach(func() {
g.By("waiting for the builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeClient().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("Build status postcommit hook failure", func() {
g.It("should contain the post commit hook failure reason and message", func() {
err := oc.Run("create").Args("-f", postCommitHookFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
br, err := exutil.StartBuildAndWait(oc, "failstatus-postcommithook")
o.Expect(err).NotTo(o.HaveOccurred())
br.AssertFailure()
build, err := oc.Client().Builds(oc.Namespace()).Get(br.Build.Name)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(build.Status.Reason).To(o.Equal(buildapi.StatusReasonPostCommitHookFailed))
o.Expect(build.Status.Message).To(o.Equal(buildapi.StatusMessagePostCommitHookFailed))
})
})
g.Describe("Build status fetch source failure", func() {
g.It("should contain the fetch source failure reason and message", func() {
err := oc.Run("create").Args("-f", gitCloneFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
// BuildAndPushImageOfSizeWithBuilder tries to build an image of wanted size and number of layers. Built image
// is stored as an image stream tag <name>:<tag>. If shouldSucceed is false, a build is expected to fail with
// a denied error. Note the size is only approximate. Resulting image size will be different depending on used
// compression algorithm and metadata overhead.
func BuildAndPushImageOfSizeWithBuilder(
oc *exutil.CLI,
dClient *dockerclient.Client,
namespace, name, tag string,
size uint64,
numberOfLayers int,
shouldSucceed bool,
) error {
istName := name
if tag != "" {
istName += ":" + tag
}
bc, err := oc.REST().BuildConfigs(namespace).Get(name)
if err == nil {
if bc.Spec.CommonSpec.Output.To.Kind != "ImageStreamTag" {
return fmt.Errorf("Unexpected kind of buildspec's output (%s != %s)", bc.Spec.CommonSpec.Output.To.Kind, "ImageStreamTag")
}
bc.Spec.CommonSpec.Output.To.Name = istName
if _, err = oc.REST().BuildConfigs(namespace).Update(bc); err != nil {
return err
}
} else {
err = oc.Run("new-build").Args("--binary", "--name", name, "--to", istName).Execute()
if err != nil {
return err
}
}
tempDir, err := ioutil.TempDir("", "name-build")
if err != nil {
return err
}
dataSize := calculateRoughDataSize(oc.Stdout(), size, numberOfLayers)
lines := make([]string, numberOfLayers+1)
lines[0] = "FROM scratch"
for i := 1; i <= numberOfLayers; i++ {
blobName := fmt.Sprintf("data%d", i)
if err := createRandomBlob(path.Join(tempDir, blobName), dataSize); err != nil {
return err
}
lines[i] = fmt.Sprintf("COPY %s /%s", blobName, blobName)
}
if err := ioutil.WriteFile(path.Join(tempDir, "Dockerfile"), []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
return err
}
br, _ := exutil.StartBuildAndWait(oc, name, "--from-dir", tempDir)
br.AssertSuccess()
buildLog, logsErr := br.Logs()
if match := reSuccessfulBuild.FindStringSubmatch(buildLog); len(match) > 1 {
defer dClient.RemoveImageExtended(match[1], dockerclient.RemoveImageOptions{Force: true})
}
if shouldSucceed && err != nil {
return fmt.Errorf("Got unexpected build error: %v", err)
}
if !shouldSucceed {
if err == nil {
return fmt.Errorf("Build unexpectedly succeeded")
}
if logsErr != nil {
return fmt.Errorf("Failed to show log of build config %s: %v", name, err)
}
if !reExpectedDeniedError.MatchString(buildLog) {
return fmt.Errorf("Failed to match expected %q in: %q", reExpectedDeniedError.String(), buildLog)
}
}
return nil
}
buildFixture = exutil.FixturePath("testdata", "test-build-proxy.json")
oc = exutil.NewCLI("build-proxy", exutil.KubeConfigPath())
)
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeClient().Core().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
oc.Run("create").Args("-f", buildFixture).Execute()
})
g.Describe("start build with broken proxy", func() {
g.It("should start a build and wait for the build to fail", func() {
g.By("starting the build")
br, _ := exutil.StartBuildAndWait(oc, "sample-build")
br.AssertFailure()
g.By("verifying the build sample-build-1 output")
// The git ls-remote check should exit the build when the remote
// repository is not accessible. It should never get to the clone.
buildLog, err := br.Logs()
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(buildLog).NotTo(o.ContainSubstring("clone"))
if !strings.Contains(buildLog, `unable to access 'https://github.com/openshift/ruby-hello-world.git/': Failed connect to 127.0.0.1:3128`) {
fmt.Fprintf(g.GinkgoWriter, "\nbuild log:\n%s\n", buildLog)
}
o.Expect(buildLog).To(o.ContainSubstring(`unable to access 'https://github.com/openshift/ruby-hello-world.git/': Failed connect to 127.0.0.1:3128`))
g.By("verifying the build sample-build-1 status")
o.Expect(br.Build.Status.Phase).Should(o.BeEquivalentTo(buildapi.BuildPhaseFailed))
err := exutil.WaitForBuilderAccount(oc.KubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
g.By("waiting for imagestreams to be imported")
err = exutil.WaitForAnImageStream(oc.AdminREST().ImageStreams("openshift"), "jenkins", exutil.CheckImageStreamLatestTagPopulatedFn, exutil.CheckImageStreamTagNotFoundFn)
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("build with image source", func() {
g.It("should complete successfully and contain the expected file", func() {
g.By("Creating build configs for source build")
err := oc.Run("create").Args("-f", buildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting the source strategy build")
br, err := exutil.StartBuildAndWait(oc, "imagesourcebuild")
br.AssertSuccess()
g.By("expecting the pod to deploy successfully")
pods, err := exutil.WaitForPods(oc.KubeREST().Pods(oc.Namespace()), imageSourceLabel, exutil.CheckPodIsRunningFn, 1, 2*time.Minute)
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(len(pods)).To(o.Equal(1))
pod, err := oc.KubeREST().Pods(oc.Namespace()).Get(pods[0])
o.Expect(err).NotTo(o.HaveOccurred())
g.By("expecting the pod to contain the file from the input image")
out, err := oc.Run("exec").Args(pod.Name, "-c", pod.Spec.Containers[0].Name, "--", "ls", "injected/dir").Output()
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(out).To(o.ContainSubstring("jenkins.war"))
})
})
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.AdminKubeClient().Core().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("Building from a template", func() {
g.It("should create a docker build with a quota and run it", func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc create -f %q", buildFixture))
err := oc.Run("create").Args("-f", buildFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a test build")
br, err := exutil.StartBuildAndWait(oc, "docker-build-quota", "--from-dir", exutil.FixturePath("testdata", "build-quota"))
g.By("expecting the build is in Failed phase")
br.AssertFailure()
g.By("expecting the build logs to contain the correct cgroups values")
out, err := br.Logs()
o.Expect(err).NotTo(o.HaveOccurred())
o.Expect(out).To(o.ContainSubstring("MEMORY=209715200"))
o.Expect(out).To(o.ContainSubstring("MEMORYSWAP=209715200"))
o.Expect(out).To(o.ContainSubstring("SHARES=61"))
o.Expect(out).To(o.ContainSubstring("PERIOD=100000"))
o.Expect(out).To(o.ContainSubstring("QUOTA=6000"))
})
})
})
exampleGemfile = exutil.FixturePath("testdata", "test-build-app", "Gemfile")
exampleBuild = exutil.FixturePath("testdata", "test-build-app")
oc = exutil.NewCLI("cli-start-build", exutil.KubeConfigPath())
)
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.KubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
oc.Run("create").Args("-f", buildFixture).Execute()
})
g.Describe("oc start-build --wait", func() {
g.It("should start a build and wait for the build to complete", func() {
g.By("starting the build with --wait flag")
br, err := exutil.StartBuildAndWait(oc, "sample-build", "--wait")
o.Expect(err).NotTo(o.HaveOccurred())
br.AssertSuccess()
})
g.It("should start a build and wait for the build to fail", func() {
g.By("starting the build with --wait flag but wrong --commit")
br, _ := exutil.StartBuildAndWait(oc, "sample-build", "--wait", "--commit=fffffff")
br.AssertFailure()
o.Expect(br.StartBuildErr).To(o.HaveOccurred()) // start-build should detect the build error with --wait flag
o.Expect(br.StartBuildStdErr).Should(o.ContainSubstring(`status is "Failed"`))
})
})
g.Describe("override environment", func() {
g.It("should accept environment variables", func() {
g.JustBeforeEach(func() {
g.By("waiting for builder service account")
err := exutil.WaitForBuilderAccount(oc.AdminKubeREST().ServiceAccounts(oc.Namespace()))
o.Expect(err).NotTo(o.HaveOccurred())
})
g.Describe("Building from a template", func() {
g.It(fmt.Sprintf("should create a build from %q template and run it", templateFixture), func() {
oc.SetOutputDir(exutil.TestContext.OutputDir)
g.By(fmt.Sprintf("calling oc new-app -f %q", templateFixture))
err := oc.Run("new-app").Args("-f", templateFixture).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("starting a test build")
br, _ := exutil.StartBuildAndWait(oc, "initial-build")
br.AssertSuccess()
g.By("starting a test build using the image produced by the last build")
br2, _ := exutil.StartBuildAndWait(oc, "internal-build")
br2.AssertSuccess()
g.By("getting the Docker image reference from ImageStream")
imageName, err := exutil.GetDockerImageReference(oc.REST().ImageStreams(oc.Namespace()), "internal-image", "latest")
o.Expect(err).NotTo(o.HaveOccurred())
g.By("instantiating a pod and service with the new image")
err = oc.Run("new-app").Args("-f", podAndServiceFixture, "-p", "IMAGE_NAME="+imageName).Execute()
o.Expect(err).NotTo(o.HaveOccurred())
g.By("waiting for the service to become available")