cellA = ginkgomon.Invoke(grouper.NewParallel(os.Kill, grouper.Members{ {"rep", cellARepRunner}, })) cellB = ginkgomon.Invoke(grouper.NewParallel(os.Kill, grouper.Members{ {"rep", cellBRepRunner}, })) test_helper.CreateZipArchive( filepath.Join(fileServerStaticDir, "lrp.zip"), fixtures.GoServerApp(), ) }) AfterEach(func() { helpers.StopProcesses(runtime, cellA, cellB) }) It("handles evacuation", func() { By("desiring an LRP") lrp := helpers.DefaultLRPCreateRequest(processGuid, "log-guid", 1) lrp.Setup = &models.DownloadAction{ From: fmt.Sprintf("http://%s/v1/static/%s", componentMaker.Addresses.FileServer, "lrp.zip"), To: "/tmp", User: "******", } lrp.Action = &models.RunAction{ User: "******", Path: "/tmp/go-server", Env: []models.EnvironmentVariable{{"PORT", "8080"}}, }
fileServerRunner, fileServerStaticDir = componentMaker.FileServer() cellGroup := grouper.Members{ {"file-server", fileServerRunner}, {"rep", componentMaker.Rep("-memoryMB", "1024")}, {"auctioneer", componentMaker.Auctioneer()}, {"converger", componentMaker.Converger()}, } cellProcess = ginkgomon.Invoke(grouper.NewParallel(os.Interrupt, cellGroup)) Eventually(receptorClient.Cells).Should(HaveLen(1)) }) AfterEach(func() { helpers.StopProcesses(cellProcess) }) Describe("Running a task", func() { var guid string BeforeEach(func() { guid = helpers.GenerateGuid() }) It("runs the command as a specific user", func() { taskRequest := helpers.TaskCreateRequest( guid, &models.RunAction{ User: "******", Path: "sh",
gardenClient = componentMaker.GardenClient() natsClient = componentMaker.NATSClient() receptorClient = componentMaker.ReceptorClient() helpers.UpsertInigoDomain(receptorClient) inigo_announcement_server.Start(componentMaker.ExternalAddress) }) var _ = AfterEach(func() { inigo_announcement_server.Stop() destroyContainerErrors := helpers.CleanupGarden(gardenClient) helpers.StopProcesses(plumbing) Expect(destroyContainerErrors).To( BeEmpty(), "%d containers failed to be destroyed!", len(destroyContainerErrors), ) }) func TestCell(t *testing.T) { helpers.RegisterDefaultTimeouts() RegisterFailHandler(Fail) RunSpecsWithDefaultAndCustomReporters(t, "Cell Integration Suite", []Reporter{ ginkgoreporter.New(GinkgoWriter),
var ( auctioneerProcess ifrit.Process cellProcess ifrit.Process convergerProcess ifrit.Process ) BeforeEach(func() { auctioneerProcess = nil cellProcess = nil convergerProcess = nil }) AfterEach(func() { helpers.StopProcesses( auctioneerProcess, cellProcess, convergerProcess, ) }) Context("when a rep, and auctioneer are running", func() { BeforeEach(func() { cellProcess = ginkgomon.Invoke(grouper.NewParallel(os.Kill, grouper.Members{ {"rep", componentMaker.Rep("-memoryMB", "1024")}, })) auctioneerProcess = ginkgomon.Invoke(componentMaker.Auctioneer()) }) Context("and a standard Task is desired", func() { var taskGuid string
lrps, err := receptorClient.ActualLRPsByProcessGuid(processGuid) Expect(err).NotTo(HaveOccurred()) return lrps }).Should(HaveLen(2)) Eventually( helpers.LRPInstanceStatePoller(receptorClient, processGuid, 0, nil), ).Should(Equal(receptor.ActualLRPStateRunning)) Eventually( helpers.LRPInstanceStatePoller(receptorClient, processGuid, 1, nil), ).Should(Equal(receptor.ActualLRPStateRunning)) }) AfterEach(func() { helpers.StopProcesses(runtime) }) Context("when valid process guid and index are used in the username", func() { It("can ssh to appropriate app instance container", func() { verifySSH(address, processGuid, 0) verifySSH(address, processGuid, 1) }) It("supports local port fowarding", func() { clientConfig := &ssh.ClientConfig{ User: fmt.Sprintf("diego:%s/%d", processGuid, 0), Auth: []ssh.AuthMethod{ssh.Password("")}, } client, err := ssh.Dial("tcp", address, clientConfig)
{"cc", fakeCC}, {"stager", componentMaker.Stager()}, {"nsync-listener", componentMaker.NsyncListener()}, })) u, err := url.Parse(fakeCC.Address()) Expect(err).NotTo(HaveOccurred()) u.User = url.UserPassword(fakeCC.Username(), fakeCC.Password()) u.Path = urljoiner.Join("staging", "droplets", appId, "upload?async=true") dropletUploadUri = u.String() u.Path = urljoiner.Join("staging", "buildpack_cache", appId, "upload") buildArtifactsUploadUri = u.String() }) AfterEach(func() { helpers.StopProcesses(cell, brain, bridge) }) stageApplication := func(stagingGuid, payload string) (*http.Response, error) { stageURL := urljoiner.Join("http://"+componentMaker.Addresses.Stager, "v1", "staging", stagingGuid) request, err := http.NewRequest("PUT", stageURL, strings.NewReader(payload)) Expect(err).NotTo(HaveOccurred()) return http.DefaultClient.Do(request) } Context("when unable to find an appropriate compiler", func() { It("returns an error", func() { resp, err := stageApplication(fmt.Sprintf("%s-%s", appId, taskId), fmt.Sprintf(`{ "app_id": "%s", "log_guid": "%s",
componentMaker = helpers.MakeComponentMaker(builtArtifacts, localIP) }) var _ = BeforeEach(func() { gardenProcess = ginkgomon.Invoke(grouper.NewParallel(os.Kill, grouper.Members{ {"garden-linux", componentMaker.GardenLinux()}, })) gardenClient = componentMaker.GardenClient() }) var _ = AfterEach(func() { destroyContainerErrors := helpers.CleanupGarden(gardenClient) helpers.StopProcesses(gardenProcess) Expect(destroyContainerErrors).To( BeEmpty(), "%d containers failed to be destroyed!", len(destroyContainerErrors), ) }) func TestExecutor(t *testing.T) { helpers.RegisterDefaultTimeouts() RegisterFailHandler(Fail) RunSpecsWithDefaultAndCustomReporters(t, "Executor Integration Suite", []Reporter{ ginkgoreporter.New(GinkgoWriter),
) appId = helpers.GenerateGuid() processGuid = helpers.GenerateGuid() runningLRPsPoller = func() []receptor.ActualLRPResponse { return helpers.ActiveActualLRPs(receptorClient, processGuid) } helloWorldInstancePoller = helpers.HelloWorldInstancePoller(componentMaker.Addresses.Router, helpers.DefaultHost) }) AfterEach(func() { By("Stopping all the processes") helpers.StopProcesses(auctioneer, rep, converger, runtime) }) Describe("Executor fault tolerance", func() { BeforeEach(func() { auctioneer = ginkgomon.Invoke(componentMaker.Auctioneer()) }) Context("when an rep, and converger are running", func() { BeforeEach(func() { rep = ginkgomon.Invoke(componentMaker.Rep()) converger = ginkgomon.Invoke(componentMaker.Converger( "-convergeRepeatInterval", "1s", )) })
{"nsync-listener", componentMaker.NsyncListener()}, })) archive_helper.CreateZipArchive( filepath.Join(fileServerStaticDir, "droplet.zip"), fixtures.HelloWorldIndexApp(), ) helpers.Copy( componentMaker.Artifacts.Lifecycles[componentMaker.DefaultStack()], filepath.Join(fileServerStaticDir, world.LifecycleFilename), ) }) AfterEach(func() { helpers.StopProcesses(runtime, bridge) }) Describe("Start an application", func() { guid := "process-guid" Context("when the running message contains a start_command", func() { It("runs the app on the executor, registers routes, and shows that they are running via the tps", func() { // desire the app resp, err := desireApp(guid, `["route-1", "route-2"]`, 2) Expect(err).NotTo(HaveOccurred()) Expect(resp.StatusCode).To(Equal(http.StatusAccepted)) // check lrp instance statuses Eventually(helpers.RunningLRPInstancesPoller(componentMaker.Addresses.TPSListener, guid)).Should(HaveLen(2))