func createBlobManager() (blobManager BlobManager, fs *fakesys.FakeFileSystem) {
fs = fakesys.NewFakeFileSystem()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
blobManager = NewBlobManager(fs, dirProvider)
return
}
func init() {
Describe("Testing with Ginkgo", func() {
It("new drain script", func() {
runner := fakesys.NewFakeCmdRunner()
fs := fakesys.NewFakeFileSystem()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
scriptProvider := NewConcreteDrainScriptProvider(runner, fs, dirProvider)
drainScript := scriptProvider.NewDrainScript("foo")
Expect(drainScript.Path()).To(Equal("/var/vcap/jobs/foo/bin/drain"))
})
})
}
fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes"
boshsettings "github.com/cloudfoundry/bosh-agent/settings"
boshdir "github.com/cloudfoundry/bosh-agent/settings/directories"
boshuuid "github.com/cloudfoundry/bosh-agent/uuid"
)
var _ = Describe("Provider", func() {
var (
platform *fakeplatform.FakePlatform
logger boshlog.Logger
provider Provider
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
logger = boshlog.NewLogger(boshlog.LevelNone)
provider = NewProvider(platform, dirProvider, logger)
})
Describe("Get", func() {
It("get dummy", func() {
blobstore, err := provider.Get(boshsettings.Blobstore{
Type: boshsettings.BlobstoreTypeDummy,
})
Expect(err).ToNot(HaveOccurred())
Expect(blobstore).ToNot(BeNil())
})
It("get external when external command in path", func() {
options := map[string]interface{}{"key": "value"}
boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories"
)
var _ = Describe("FetchLogsAction", func() {
var (
compressor *fakecmd.FakeCompressor
copier *fakecmd.FakeCopier
blobstore *fakeblobstore.FakeBlobstore
dirProvider boshdirs.DirectoriesProvider
action FetchLogsAction
)
BeforeEach(func() {
compressor = fakecmd.NewFakeCompressor()
blobstore = &fakeblobstore.FakeBlobstore{}
dirProvider = boshdirs.NewDirectoriesProvider("/fake/dir")
copier = fakecmd.NewFakeCopier()
action = NewFetchLogs(compressor, copier, blobstore, dirProvider)
})
It("logs should be asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
Describe("Run", func() {
testLogs := func(logType string, filters []string, expectedFilters []string) {
copier.FilteredCopyToTempTempDir = "/fake-temp-dir"
func buildSSHAction(settingsService boshsettings.Service) (*fakeplatform.FakePlatform, SSHAction) {
platform := fakeplatform.NewFakePlatform()
dirProvider := boshdirs.NewDirectoriesProvider("/foo")
action := NewSSH(settingsService, platform, dirProvider)
return platform, action
}
func init() {
Describe("provider", func() {
var (
platform *fakeplatform.FakePlatform
client *fakemonit.FakeMonitClient
logger boshlog.Logger
dirProvider boshdir.DirectoriesProvider
jobFailuresServerPort int
handler *fakembus.FakeHandler
provider Provider
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
client = fakemonit.NewFakeMonitClient()
logger = boshlog.NewLogger(boshlog.LevelNone)
dirProvider = boshdir.NewDirectoriesProvider("/fake-base-dir")
jobFailuresServerPort = 2825
handler = &fakembus.FakeHandler{}
provider = NewProvider(
platform,
client,
logger,
dirProvider,
handler,
)
})
It("provides a monit job supervisor", func() {
actualSupervisor, err := provider.Get("monit")
Expect(err).ToNot(HaveOccurred())
expectedSupervisor := NewMonitJobSupervisor(
platform.Fs,
platform.Runner,
client,
logger,
dirProvider,
jobFailuresServerPort,
MonitReloadOptions{
MaxTries: 3,
MaxCheckTries: 6,
DelayBetweenCheckTries: 5 * time.Second,
},
)
Expect(actualSupervisor).To(Equal(expectedSupervisor))
})
It("provides a dummy job supervisor", func() {
actualSupervisor, err := provider.Get("dummy")
Expect(err).ToNot(HaveOccurred())
expectedSupervisor := NewDummyJobSupervisor()
Expect(actualSupervisor).To(Equal(expectedSupervisor))
})
It("provides a dummy nats job supervisor", func() {
actualSupervisor, err := provider.Get("dummy-nats")
Expect(err).NotTo(HaveOccurred())
expectedSupervisor := NewDummyNatsJobSupervisor(handler)
Expect(actualSupervisor).To(Equal(expectedSupervisor))
})
It("returns an error when the supervisor is not found", func() {
_, err := provider.Get("does-not-exist")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("does-not-exist could not be found"))
})
})
}
fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes"
boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories"
fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes"
)
var _ = Describe("MountDiskAction", func() {
var (
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
action MountDiskAction
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
dirProvider := boshdirs.NewDirectoriesProvider("/fake-base-dir")
action = NewMountDisk(settingsService, platform, platform, dirProvider)
})
It("is asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
Describe("Run", func() {
Context("when settings can be loaded", func() {
Context("when disk cid can be resolved to a device path from infrastructure settings", func() {
BeforeEach(func() {
func (p *FakePlatform) GetDirProvider() (dirProvider boshdir.DirectoriesProvider) {
return boshdir.NewDirectoriesProvider("/var/vcap")
}
func init() {
Describe("concreteApplier", func() {
var (
jobApplier *fakeja.FakeJobApplier
packageApplier *fakepa.FakePackageApplier
logRotateDelegate *FakeLogRotateDelegate
jobSupervisor *fakejobsuper.FakeJobSupervisor
applier Applier
)
BeforeEach(func() {
jobApplier = fakeja.NewFakeJobApplier()
packageApplier = fakepa.NewFakePackageApplier()
logRotateDelegate = &FakeLogRotateDelegate{}
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
applier = NewConcreteApplier(
jobApplier,
packageApplier,
logRotateDelegate,
jobSupervisor,
boshdirs.NewDirectoriesProvider("/fake-base-dir"),
)
})
Describe("Prepare", func() {
It("prepares each jobs", func() {
job := buildJob()
err := applier.Prepare(
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.PreparedJobs).To(Equal([]models.Job{job}))
})
It("returns error when preparing jobs fails", func() {
job := buildJob()
jobApplier.PrepareError = errors.New("fake-prepare-job-error")
err := applier.Prepare(
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-prepare-job-error"))
})
It("prepares each packages", func() {
pkg1 := buildPackage()
pkg2 := buildPackage()
err := applier.Prepare(
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg1, pkg2}},
)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.PreparedPackages).To(Equal([]models.Package{pkg1, pkg2}))
})
It("returns error when preparing packages fails", func() {
pkg := buildPackage()
packageApplier.PrepareError = errors.New("fake-prepare-package-error")
err := applier.Prepare(
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-prepare-package-error"))
})
})
Describe("Apply", func() {
It("removes all jobs from job supervisor", func() {
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{})
Expect(err).ToNot(HaveOccurred())
Expect(jobSupervisor.RemovedAllJobs).To(BeTrue())
})
It("removes all previous jobs from job supervisor before starting to apply jobs", func() {
// force remove all error
jobSupervisor.RemovedAllJobsErr = errors.New("fake-remove-all-jobs-error")
job := buildJob()
applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
// check that jobs were not applied before removing all other jobs
Expect(jobApplier.AppliedJobs).To(Equal([]models.Job{}))
})
It("returns error if removing all jobs from job supervisor fails", func() {
jobSupervisor.RemovedAllJobsErr = errors.New("fake-remove-all-jobs-error")
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-all-jobs-error"))
})
It("apply applies jobs", func() {
job := buildJob()
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.AppliedJobs).To(Equal([]models.Job{job}))
})
It("apply errs when applying jobs errs", func() {
job := buildJob()
jobApplier.ApplyError = errors.New("fake-apply-job-error")
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-job-error"))
})
It("asked jobApplier to keep only the jobs in the desired and current specs", func() {
currentJob := buildJob()
desiredJob := buildJob()
err := applier.Apply(
&fakeas.FakeApplySpec{JobResults: []models.Job{currentJob}},
&fakeas.FakeApplySpec{JobResults: []models.Job{desiredJob}},
)
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.KeepOnlyJobs).To(Equal([]models.Job{currentJob, desiredJob}))
})
It("returns error when jobApplier fails to keep only the jobs in the desired and current specs", func() {
jobApplier.KeepOnlyErr = errors.New("fake-keep-only-error")
currentJob := buildJob()
desiredJob := buildJob()
err := applier.Apply(
&fakeas.FakeApplySpec{JobResults: []models.Job{currentJob}},
&fakeas.FakeApplySpec{JobResults: []models.Job{desiredJob}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-error"))
})
It("apply applies packages", func() {
pkg1 := buildPackage()
pkg2 := buildPackage()
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg1, pkg2}},
)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.AppliedPackages).To(Equal([]models.Package{pkg1, pkg2}))
})
It("apply errs when applying packages errs", func() {
pkg := buildPackage()
packageApplier.ApplyError = errors.New("fake-apply-package-error")
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{PackageResults: []models.Package{pkg}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-package-error"))
})
It("asked packageApplier to keep only the packages in the desired and current specs", func() {
currentPkg := buildPackage()
desiredPkg := buildPackage()
err := applier.Apply(
&fakeas.FakeApplySpec{PackageResults: []models.Package{currentPkg}},
&fakeas.FakeApplySpec{PackageResults: []models.Package{desiredPkg}},
)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.KeptOnlyPackages).To(Equal([]models.Package{currentPkg, desiredPkg}))
})
It("returns error when packageApplier fails to keep only the packages in the desired and current specs", func() {
packageApplier.KeepOnlyErr = errors.New("fake-keep-only-error")
currentPkg := buildPackage()
desiredPkg := buildPackage()
err := applier.Apply(
&fakeas.FakeApplySpec{PackageResults: []models.Package{currentPkg}},
&fakeas.FakeApplySpec{PackageResults: []models.Package{desiredPkg}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-error"))
})
It("apply configures jobs", func() {
job1 := models.Job{Name: "fake-job-name-1", Version: "fake-version-name-1"}
job2 := models.Job{Name: "fake-job-name-2", Version: "fake-version-name-2"}
jobs := []models.Job{job1, job2}
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: jobs})
Expect(err).ToNot(HaveOccurred())
Expect(jobApplier.ConfiguredJobs).To(Equal([]models.Job{job2, job1}))
Expect(jobApplier.ConfiguredJobIndices).To(Equal([]int{0, 1}))
Expect(jobSupervisor.Reloaded).To(BeTrue())
})
It("apply errs if monitor fails reload", func() {
jobs := []models.Job{}
jobSupervisor.ReloadErr = errors.New("error reloading monit")
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: jobs})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("error reloading monit"))
})
It("apply errs if a job fails configuring", func() {
jobApplier.ConfigureError = errors.New("error configuring job")
job := models.Job{Name: "fake-job-name-1", Version: "fake-version-name-1"}
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{JobResults: []models.Job{job}},
)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("error configuring job"))
})
It("apply sets up logrotation", func() {
err := applier.Apply(
&fakeas.FakeApplySpec{},
&fakeas.FakeApplySpec{MaxLogFileSizeResult: "fake-size"},
)
Expect(err).ToNot(HaveOccurred())
assert.Equal(GinkgoT(), logRotateDelegate.SetupLogrotateArgs, SetupLogrotateArgs{
GroupName: boshsettings.VCAPUsername,
BasePath: "/fake-base-dir",
Size: "fake-size",
})
})
It("apply errs if setup logrotate fails", func() {
logRotateDelegate.SetupLogrotateErr = errors.New("fake-set-up-logrotate-error")
err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-set-up-logrotate-error"))
})
})
})
}
