Expect(err).ToNot(HaveOccurred()) fileBytes := readFile(readOnlyFile) Expect(string(fileBytes)).To(Equal("some data")) }) It("writes", func() { blobManager := NewBlobManager(fs, basePath) fs.WriteFileString(blobPath, "some data") defer fs.RemoveAll(blobPath) err := blobManager.Write(blobId, toWrite) Expect(err).ToNot(HaveOccurred()) contents, err := fs.ReadFileString(blobPath) Expect(err).ToNot(HaveOccurred()) Expect(contents).To(Equal("new data")) }) Context("when it writes", func() { BeforeEach(func() { basePath = filepath.ToSlash(basePath) blobPath = filepath.ToSlash(blobPath) }) It("creates and closes the file", func() { fs_ := boshsysfake.NewFakeFileSystem() blobManager := NewBlobManager(fs_, basePath) err := blobManager.Write(blobId, toWrite) Expect(err).ToNot(HaveOccurred())
"./other_logs/", "./some_directory/", "./some_directory/sub_dir/", "./some_directory/sub_dir/other_sub_dir/", "./some_directory/sub_dir/other_sub_dir/.keep", "./symlink_dir", "./other_logs/more_logs/", "./other_logs/other_app.stderr.log", "./other_logs/other_app.stdout.log", "./other_logs/more_logs/more.stdout.log", )) _, _, _, err = cmdRunner.RunCommand("tar", "-xzpf", tgzName, "-C", dstDir) Expect(err).ToNot(HaveOccurred()) content, err := fs.ReadFileString(dstDir + "/app.stdout.log") Expect(err).ToNot(HaveOccurred()) Expect(content).To(ContainSubstring("this is app stdout")) content, err = fs.ReadFileString(dstDir + "/app.stderr.log") Expect(err).ToNot(HaveOccurred()) Expect(content).To(ContainSubstring("this is app stderr")) content, err = fs.ReadFileString(dstDir + "/other_logs/other_app.stdout.log") Expect(err).ToNot(HaveOccurred()) Expect(content).To(ContainSubstring("this is other app stdout")) }) }) Describe("CompressSpecificFilesInDir", func() { It("compresses the given files in the given directory", func() {
func init() { Describe("ApplyAction", func() { var ( applier *fakeappl.FakeApplier specService *fakeas.FakeV1Service settingsService *fakesettings.FakeSettingsService dirProvider boshdir.Provider action ApplyAction fs boshsys.FileSystem ) BeforeEach(func() { applier = fakeappl.NewFakeApplier() specService = fakeas.NewFakeV1Service() settingsService = &fakesettings.FakeSettingsService{} dirProvider = boshdir.NewProvider("/var/vcap") fs = fakesys.NewFakeFileSystem() action = NewApply(applier, specService, settingsService, dirProvider.InstanceDir(), fs) }) It("apply should be asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) Describe("Run", func() { settings := boshsettings.Settings{AgentID: "fake-agent-id"} BeforeEach(func() { settingsService.Settings = settings }) Context("when desired spec has configuration hash", func() { currentApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-current-config-hash"} desiredApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash"} populatedDesiredApplySpec := boshas.V1ApplySpec{ ConfigurationHash: "fake-populated-desired-config-hash", } Context("when current spec can be retrieved", func() { BeforeEach(func() { specService.Spec = currentApplySpec }) It("populates dynamic networks in desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(specService.PopulateDHCPNetworksSpec).To(Equal(desiredApplySpec)) Expect(specService.PopulateDHCPNetworksSettings).To(Equal(settings)) }) Context("when resolving dynamic networks succeeds", func() { BeforeEach(func() { specService.PopulateDHCPNetworksResultSpec = populatedDesiredApplySpec }) It("runs applier with populated desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(applier.Applied).To(BeTrue()) Expect(applier.ApplyCurrentApplySpec).To(Equal(currentApplySpec)) Expect(applier.ApplyDesiredApplySpec).To(Equal(populatedDesiredApplySpec)) }) Context("when applier succeeds applying desired spec", func() { Context("when saving desires spec as current spec succeeds", func() { It("returns 'applied' after setting populated desired spec as current spec", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) Expect(specService.Spec).To(Equal(populatedDesiredApplySpec)) }) Context("desired spec has id, instance name, deployment name, and az", func() { BeforeEach(func() { desiredApplySpec = boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash", NodeID: "node-id01-123f-r2344", AvailabilityZone: "ex-az", Deployment: "deployment-name", Name: "instance-name"} specService.PopulateDHCPNetworksResultSpec = desiredApplySpec }) It("returns 'applied' and writes the id, instance name, deployment name, and az to files in the instance directory", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) instanceDir := dirProvider.InstanceDir() id, err := fs.ReadFileString(path.Join(instanceDir, "id")) Expect(err).ToNot(HaveOccurred()) Expect(id).To(Equal(desiredApplySpec.NodeID)) az, err := fs.ReadFileString(path.Join(instanceDir, "az")) Expect(err).ToNot(HaveOccurred()) Expect(az).To(Equal(desiredApplySpec.AvailabilityZone)) instanceName, err := fs.ReadFileString(path.Join(instanceDir, "name")) Expect(err).ToNot(HaveOccurred()) Expect(instanceName).To(Equal(desiredApplySpec.Name)) deploymentName, err := fs.ReadFileString(path.Join(instanceDir, "deployment")) Expect(err).ToNot(HaveOccurred()) Expect(deploymentName).To(Equal(desiredApplySpec.Deployment)) }) }) }) Context("when saving populated desires spec as current spec fails", func() { It("returns error because agent was not able to remember that is converged to desired spec", func() { specService.SetErr = errors.New("fake-set-error") _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-error")) }) }) }) Context("when applier fails applying desired spec", func() { BeforeEach(func() { applier.ApplyError = errors.New("fake-apply-error") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-apply-error")) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when resolving dynamic networks fails", func() { BeforeEach(func() { specService.PopulateDHCPNetworksErr = errors.New("fake-populate-dynamic-networks-err") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err")) }) It("does not apply desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when current spec cannot be retrieved", func() { BeforeEach(func() { specService.Spec = currentApplySpec specService.GetErr = errors.New("fake-get-error") }) It("returns error and does not apply desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-error")) }) It("does not run applier with desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when desired spec does not have a configuration hash", func() { desiredApplySpec := boshas.V1ApplySpec{ JobSpec: boshas.JobSpec{ Template: "fake-job-template", }, } populatedDesiredApplySpec := boshas.V1ApplySpec{ JobSpec: boshas.JobSpec{ Template: "fake-populated-job-template", }, } It("populates dynamic networks in desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(specService.PopulateDHCPNetworksSpec).To(Equal(desiredApplySpec)) Expect(specService.PopulateDHCPNetworksSettings).To(Equal(settings)) }) Context("when resolving dynamic networks succeeds", func() { BeforeEach(func() { specService.PopulateDHCPNetworksResultSpec = populatedDesiredApplySpec }) Context("when saving desires spec as current spec succeeds", func() { It("returns 'applied' after setting desired spec as current spec", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) Expect(specService.Spec).To(Equal(populatedDesiredApplySpec)) }) It("does not try to apply desired spec since it does not have jobs and packages", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) }) Context("when saving desires spec as current spec fails", func() { BeforeEach(func() { specService.SetErr = errors.New("fake-set-error") }) It("returns error because agent was not able to remember that is converged to desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-error")) }) It("does not try to apply desired spec since it does not have jobs and packages", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) }) }) Context("when resolving dynamic networks fails", func() { BeforeEach(func() { specService.PopulateDHCPNetworksErr = errors.New("fake-populate-dynamic-networks-err") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err")) }) It("does not apply desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).ToNot(Equal(desiredApplySpec)) }) }) }) }) }) }
renderedJobList.Add(renderedJob1) // compress archive, err := renderedJobListCompressor.Compress(renderedJobList) Expect(err).ToNot(HaveOccurred()) defer func() { err := archive.Delete(); Expect(err).ToNot(HaveOccurred()) }() // decompress renderedJobListDir, err := fs.TempDir("RenderedJobListCompressorTest") Expect(err).ToNot(HaveOccurred()) defer func() { err := fs.RemoveAll(renderedJobListDir); Expect(err).ToNot(HaveOccurred()) }() err = compressor.DecompressFileToDir(archive.Path(), renderedJobListDir, boshcmd.CompressorOptions{}) Expect(err).ToNot(HaveOccurred()) // verify that archive contained rendered scripts from job 0 content, err := fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-0", "script-0")) Expect(err).ToNot(HaveOccurred()) Expect(content).To(Equal("fake-rendered-job-0-script-0-content")) content, err = fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-0", "script-1")) Expect(err).ToNot(HaveOccurred()) Expect(content).To(Equal("fake-rendered-job-0-script-1-content")) // verify that archive contained rendered scripts from job 1 content, err = fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-1", "script-0")) Expect(err).ToNot(HaveOccurred()) Expect(content).To(Equal("fake-rendered-job-1-script-0-content")) }) }) Context("with a fake fs & compressor", func() { var (
Expect(jobSupervisor.Start()).To(Succeed()) for _, proc := range conf.Processes { stdout, _, _, err := runner.RunCommand("powershell", "/C", "get-service", proc.Name) Expect(err).ToNot(HaveOccurred()) Expect(stdout).To(ContainSubstring(proc.Name)) Expect(stdout).To(ContainSubstring("Running")) } }) It("writes logs to job log directory", func() { Expect(jobSupervisor.Start()).To(Succeed()) for i, proc := range conf.Processes { readLogFile := func() (string, error) { return fs.ReadFileString(path.Join(logDir, "say-hello", proc.Name, "job-service-wrapper.out.log")) } Eventually(readLogFile, DefaultTimeout, DefaultInterval).Should(ContainSubstring(fmt.Sprintf("Hello %d", i+1))) } }) It("sets the LOG_DIR env variable for the pipe", func() { Expect(jobSupervisor.Start()).To(Succeed()) validFile := func(name string) func() error { return func() error { fi, err := os.Stat(name) if err != nil { return err } if fi.Size() == 0 {
Expect(err).ToNot(HaveOccurred()) Expect(copiedFiles).To(Equal([]string{ dstDir + "/app.stderr.log", dstDir + "/app.stdout.log", dstDir + "/other_logs/more_logs/more.stdout.log", dstDir + "/other_logs/other_app.stdout.log", dstDir + "/some_directory/sub_dir/other_sub_dir/.keep", })) tarDirStat, err := os.Stat(dstDir) Expect(err).ToNot(HaveOccurred()) Expect(os.FileMode(0755)).To(Equal(tarDirStat.Mode().Perm())) content, err := fs.ReadFileString(dstDir + "/app.stdout.log") Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is app stdout") content, err = fs.ReadFileString(dstDir + "/app.stderr.log") Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is app stderr") content, err = fs.ReadFileString(dstDir + "/other_logs/other_app.stdout.log") Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is other app stdout") content, err = fs.ReadFileString(dstDir + "/other_logs/more_logs/more.stdout.log") Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is more stdout")
"./app.stdout.log", "./other_logs/", "./some_directory/", "./some_directory/sub_dir/", "./some_directory/sub_dir/other_sub_dir/", "./some_directory/sub_dir/other_sub_dir/.keep", "./other_logs/more_logs/", "./other_logs/other_app.stderr.log", "./other_logs/other_app.stdout.log", "./other_logs/more_logs/more.stdout.log", )) _, _, _, err = cmdRunner.RunCommand("tar", "-xzpf", tgzName, "-C", dstDir) Expect(err).ToNot(HaveOccurred()) content, err := fs.ReadFileString(dstDir + "/app.stdout.log") Expect(err).ToNot(HaveOccurred()) Expect(content).To(ContainSubstring("this is app stdout")) content, err = fs.ReadFileString(dstDir + "/app.stderr.log") Expect(err).ToNot(HaveOccurred()) Expect(content).To(ContainSubstring("this is app stderr")) content, err = fs.ReadFileString(dstDir + "/other_logs/other_app.stdout.log") Expect(err).ToNot(HaveOccurred()) Expect(content).To(ContainSubstring("this is other app stdout")) }) }) Describe("DecompressFileToDir", func() { It("decompresses the file to the given directory", func() {
Expect(agentState.JobState).To(Equal("running")) }) It("can run a drain script", func() { natsClient.PrepareJob("say-hello") err := natsClient.RunDrain() Expect(err).NotTo(HaveOccurred()) logsDir, err := fs.TempDir("windows-agent-drain-test") Expect(err).NotTo(HaveOccurred()) defer fs.RemoveAll(logsDir) natsClient.FetchLogs(logsDir) drainLogContents, err := fs.ReadFileString(filepath.Join(logsDir, "say-hello", "drain.log")) Expect(err).NotTo(HaveOccurred()) Expect(drainLogContents).To(ContainSubstring("Hello from drain")) }) It("can unmonitor the job during drain script", func() { natsClient.PrepareJob("unmonitor-hello") runStartResponse, err := natsClient.RunStart() Expect(err).NotTo(HaveOccurred()) Expect(runStartResponse["value"]).To(Equal("started")) agentState := natsClient.GetState() Expect(agentState.JobState).To(Equal("running"))
defer os.RemoveAll(dstDir) copiedFiles := filesInDir(dstDir) Expect(err).ToNot(HaveOccurred()) Expect(copiedFiles).To(Equal([]string{ filepath.Join(dstDir, "app.stderr.log"), filepath.Join(dstDir, "app.stdout.log"), filepath.Join(dstDir, "other_logs", "more_logs", "more.stdout.log"), filepath.Join(dstDir, "other_logs", "other_app.stdout.log"), filepath.Join(dstDir, "some_directory", "sub_dir", "other_sub_dir", ".keep"), })) content, err := fs.ReadFileString(filepath.Join(dstDir, "app.stdout.log")) Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is app stdout") content, err = fs.ReadFileString(filepath.Join(dstDir, "app.stderr.log")) Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is app stderr") content, err = fs.ReadFileString(filepath.Join(dstDir, "other_logs", "other_app.stdout.log")) Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is other app stdout") content, err = fs.ReadFileString(filepath.Join(dstDir, "other_logs", "more_logs", "more.stdout.log")) Expect(err).ToNot(HaveOccurred()) assert.Contains(GinkgoT(), content, "this is more stdout")