func buildApplyAction() (*fakeappl.FakeApplier, *fakesys.FakeFileSystem, *fakeplatform.FakePlatform, applyAction) {
applier := fakeappl.NewFakeApplier()
platform := fakeplatform.NewFakePlatform()
fs := platform.Fs
action := newApply(applier, fs, platform)
return applier, fs, platform, action
}
func buildFactory() (
deps concreteFactoryDependencies,
factory Factory) {
deps.settings = &fakesettings.FakeSettingsService{}
deps.platform = fakeplatform.NewFakePlatform()
deps.blobstore = &fakeblobstore.FakeBlobstore{}
deps.taskService = &faketask.FakeService{}
deps.notifier = fakenotif.NewFakeNotifier()
deps.applier = fakeappl.NewFakeApplier()
deps.compiler = fakecomp.NewFakeCompiler()
deps.monitor = fakemon.NewFakeMonitor()
deps.specService = fakeas.NewFakeV1Service()
deps.dirProvider = boshdirs.NewDirectoriesProvider("/foo")
deps.drainScriptProvider = boshdrain.NewDrainScriptProvider(nil, nil, deps.dirProvider)
factory = NewFactory(
deps.settings,
deps.platform,
deps.blobstore,
deps.taskService,
deps.notifier,
deps.applier,
deps.compiler,
deps.monitor,
deps.specService,
deps.dirProvider,
deps.drainScriptProvider,
)
return
}
func buildFactory() (
deps concreteFactoryDependencies,
factory Factory) {
deps.settings = &fakesettings.FakeSettingsService{}
deps.platform = fakeplatform.NewFakePlatform()
deps.blobstore = &fakeblobstore.FakeBlobstore{}
deps.taskService = &faketask.FakeService{}
deps.notifier = fakenotif.NewFakeNotifier()
deps.applier = fakeappl.NewFakeApplier()
deps.compiler = fakecomp.NewFakeCompiler()
deps.jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
deps.specService = fakeas.NewFakeV1Service()
deps.drainScriptProvider = boshdrain.NewConcreteDrainScriptProvider(nil, nil, deps.platform.GetDirProvider())
factory = NewFactory(
deps.settings,
deps.platform,
deps.blobstore,
deps.taskService,
deps.notifier,
deps.applier,
deps.compiler,
deps.jobSupervisor,
deps.specService,
deps.drainScriptProvider,
)
return
}
func buildFactory() (
settings *fakesettings.FakeSettingsService,
platform *fakeplatform.FakePlatform,
blobstore *fakeblobstore.FakeBlobstore,
taskService *faketask.FakeService,
applier *fakeappl.FakeApplier,
factory Factory) {
settings = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
blobstore = &fakeblobstore.FakeBlobstore{}
taskService = &faketask.FakeService{}
applier = fakeappl.NewFakeApplier()
factory = NewFactory(settings, platform, blobstore, taskService, applier)
return
}
func init() {
Describe("concreteFactory", func() {
var (
settings *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
infrastructure *fakeinfrastructure.FakeInfrastructure
blobstore *fakeblobstore.FakeBlobstore
taskService *faketask.FakeService
notifier *fakenotif.FakeNotifier
applier *fakeappl.FakeApplier
compiler *fakecomp.FakeCompiler
jobSupervisor *fakejobsuper.FakeJobSupervisor
specService *fakeas.FakeV1Service
drainScriptProvider boshdrain.DrainScriptProvider
factory Factory
logger boshlog.Logger
)
BeforeEach(func() {
settings = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
infrastructure = fakeinfrastructure.NewFakeInfrastructure()
blobstore = &fakeblobstore.FakeBlobstore{}
taskService = &faketask.FakeService{}
notifier = fakenotif.NewFakeNotifier()
applier = fakeappl.NewFakeApplier()
compiler = fakecomp.NewFakeCompiler()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
specService = fakeas.NewFakeV1Service()
drainScriptProvider = boshdrain.NewConcreteDrainScriptProvider(nil, nil, platform.GetDirProvider())
logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
})
JustBeforeEach(func() {
factory = NewFactory(
settings,
platform,
infrastructure,
blobstore,
taskService,
notifier,
applier,
compiler,
jobSupervisor,
specService,
drainScriptProvider,
logger,
)
})
It("new factory", func() {
actions := []string{
"apply",
"drain",
"fetch_logs",
"get_task",
"get_state",
"list_disk",
"migrate_disk",
"mount_disk",
"ping",
"prepare_network_change",
"ssh",
"start",
"stop",
"unmount_disk",
"compile_package",
"release_apply_spec",
}
for _, actionName := range actions {
action, err := factory.Create(actionName)
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
}
action, err := factory.Create("gobberish")
Expect(err).To(HaveOccurred())
Expect(action).To(BeNil())
})
It("apply", func() {
action, err := factory.Create("apply")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewApply(applier, specService)).To(Equal(action))
})
It("drain", func() {
action, err := factory.Create("drain")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewDrain(notifier, specService, drainScriptProvider, jobSupervisor)).To(Equal(action))
})
It("fetch_logs", func() {
action, err := factory.Create("fetch_logs")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewLogs(platform.GetCompressor(), platform.GetCopier(), blobstore, platform.GetDirProvider())).To(Equal(action))
})
It("get_task", func() {
action, err := factory.Create("get_task")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewGetTask(taskService)).To(Equal(action))
})
It("get_state", func() {
ntpService := boshntp.NewConcreteService(platform.GetFs(), platform.GetDirProvider())
action, err := factory.Create("get_state")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewGetState(settings, specService, jobSupervisor, platform.GetVitalsService(), ntpService)).To(Equal(action))
})
It("list_disk", func() {
action, err := factory.Create("list_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewListDisk(settings, platform, logger)).To(Equal(action))
})
It("migrate_disk", func() {
action, err := factory.Create("migrate_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewMigrateDisk(platform, platform.GetDirProvider())).To(Equal(action))
})
It("mount_disk", func() {
action, err := factory.Create("mount_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewMountDisk(settings, infrastructure, platform, platform.GetDirProvider())).To(Equal(action))
})
It("prepare_network_change", func() {
action, err := factory.Create("prepare_network_change")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewPrepareNetworkChange(platform.GetFs(), settings)).To(Equal(action))
})
It("prepare_configure_networks", func() {
action, err := factory.Create("prepare_configure_networks")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewPrepareConfigureNetworks(platform.GetFs(), settings)).To(Equal(action))
})
It("configure_networks", func() {
action, err := factory.Create("configure_networks")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewConfigureNetworks()).To(Equal(action))
})
It("ssh", func() {
action, err := factory.Create("ssh")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewSsh(settings, platform, platform.GetDirProvider())).To(Equal(action))
})
It("start", func() {
action, err := factory.Create("start")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewStart(jobSupervisor)).To(Equal(action))
})
It("unmount_disk", func() {
action, err := factory.Create("unmount_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewUnmountDisk(settings, platform)).To(Equal(action))
})
It("compile_package", func() {
action, err := factory.Create("compile_package")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewCompilePackage(compiler)).To(Equal(action))
})
})
}
func buildApplyAction() (*fakeappl.FakeApplier, *fakeas.FakeV1Service, ApplyAction) {
applier := fakeappl.NewFakeApplier()
specService := fakeas.NewFakeV1Service()
action := NewApply(applier, specService)
return applier, specService, action
}
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/agent/action"
boshas "bosh/agent/applier/applyspec"
fakeappl "bosh/agent/applier/fakes"
)
var _ = Describe("PrepareAction", func() {
var (
applier *fakeappl.FakeApplier
action PrepareAction
)
BeforeEach(func() {
applier = fakeappl.NewFakeApplier()
action = NewPrepare(applier)
})
It("is asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
Describe("Run", func() {
desiredApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash"}
It("runs applier to prepare vm for future configuration with desired apply spec", func() {
func init() {
Describe("ApplyAction", func() {
var (
applier *fakeappl.FakeApplier
specService *fakeas.FakeV1Service
settingsService *fakesettings.FakeSettingsService
action ApplyAction
)
BeforeEach(func() {
applier = fakeappl.NewFakeApplier()
specService = fakeas.NewFakeV1Service()
settingsService = &fakesettings.FakeSettingsService{}
action = NewApply(applier, specService, settingsService)
})
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.PopulateDynamicNetworksSpec).To(Equal(desiredApplySpec))
Expect(specService.PopulateDynamicNetworksSettings).To(Equal(settings))
})
Context("when resolving dynamic networks succeeds", func() {
BeforeEach(func() {
specService.PopulateDynamicNetworksResultSpec = 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("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.PopulateDynamicNetworksErr = 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.PopulateDynamicNetworksSpec).To(Equal(desiredApplySpec))
Expect(specService.PopulateDynamicNetworksSettings).To(Equal(settings))
})
Context("when resolving dynamic networks succeeds", func() {
BeforeEach(func() {
specService.PopulateDynamicNetworksResultSpec = 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.PopulateDynamicNetworksErr = 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))
})
})
})
})
})
}
