func init() {
Describe("Stop", func() {
var (
jobSupervisor *fakejobsuper.FakeJobSupervisor
platform *fakeplatform.FakePlatform
settingsService *fakesettings.FakeSettingsService
logger boshlog.Logger
specService *fakeas.FakeV1Service
dualDCSupport *nimbus.DualDCSupport
action StopAction
)
BeforeEach(func() {
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
specService = fakeas.NewFakeV1Service()
settingsService = &fakesettings.FakeSettingsService{}
dualDCSupport = nimbus.NewDualDCSupport(
platform.GetRunner(),
platform.GetFs(),
platform.GetDirProvider(),
specService,
settingsService,
logger,
)
action = NewStop(jobSupervisor, dualDCSupport, platform)
})
It("is asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
It("returns stopped", func() {
stopped, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(stopped).To(Equal("stopped"))
})
It("stops job supervisor services", func() {
_, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(jobSupervisor.Stopped).To(BeTrue())
})
})
}
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
blobstore = &fakeblobstore.FakeBlobstore{}
taskService = &faketask.FakeService{}
notifier = fakenotif.NewFakeNotifier()
applier = fakeappl.NewFakeApplier()
compiler = fakecomp.NewFakeCompiler()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
specService = fakeas.NewFakeV1Service()
jobScriptProvider = &fakescript.FakeJobScriptProvider{}
logger = boshlog.NewLogger(boshlog.LevelNone)
dualDCSupport = nimbus.NewDualDCSupport(
platform.GetRunner(),
platform.GetFs(),
platform.GetDirProvider(),
specService,
settingsService,
logger,
)
factory = NewFactory(
settingsService,
platform,
blobstore,
taskService,
notifier,
applier,
compiler,
jobSupervisor,
specService,
jobScriptProvider,
func init() {
Describe("ApplyAction", func() {
var (
applier *fakeappl.FakeApplier
specService *fakeas.FakeV1Service
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
dualDCSupport *nimbus.DualDCSupport
logger boshlog.Logger
action ApplyAction
)
BeforeEach(func() {
applier = fakeappl.NewFakeApplier()
specService = fakeas.NewFakeV1Service()
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
dualDCSupport = nimbus.NewDualDCSupport(
platform.GetRunner(),
platform.GetFs(),
platform.GetDirProvider(),
specService,
settingsService,
logger,
)
action = NewApply(applier, specService, settingsService, dualDCSupport, platform)
})
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("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))
})
})
})
})
})
}
func init() {
Describe("Start", func() {
var (
jobSupervisor *fakejobsuper.FakeJobSupervisor
applier *fakeappl.FakeApplier
specService *fakeas.FakeV1Service
platform *fakeplatform.FakePlatform
settingsService *fakesettings.FakeSettingsService
logger boshlog.Logger
dualDCSupport *nimbus.DualDCSupport
action StartAction
)
BeforeEach(func() {
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
applier = fakeappl.NewFakeApplier()
specService = fakeas.NewFakeV1Service()
action = NewStart(jobSupervisor, applier, specService, dualDCSupport, platform)
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
settingsService = &fakesettings.FakeSettingsService{}
dualDCSupport = nimbus.NewDualDCSupport(
platform.GetRunner(),
platform.GetFs(),
platform.GetDirProvider(),
specService,
settingsService,
logger,
)
action = NewStart(jobSupervisor, applier, specService, dualDCSupport, platform)
})
It("is synchronous", func() {
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
It("returns started", func() {
started, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(started).To(Equal("started"))
})
It("starts monitor services", func() {
_, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(jobSupervisor.Started).To(BeTrue())
})
It("configures jobs", func() {
_, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(applier.Configured).To(BeTrue())
})
It("apply errs if a job fails configuring", func() {
applier.ConfiguredError = errors.New("fake error")
_, err := action.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Configuring jobs"))
})
})
}
func (app *app) Setup(args []string) error {
opts, err := ParseOptions(args)
if err != nil {
return bosherr.WrapError(err, "Parsing options")
}
config, err := app.loadConfig(opts.ConfigPath)
if err != nil {
return bosherr.WrapError(err, "Loading config")
}
app.dirProvider = boshdirs.NewProvider(opts.BaseDirectory)
app.logStemcellInfo()
// Pulled outside of the platform provider so bosh-init will not pull in
// sigar when cross compiling linux -> darwin
sigarCollector := boshsigar.NewSigarStatsCollector(&sigar.ConcreteSigar{})
platformProvider := boshplatform.NewProvider(app.logger, app.dirProvider, sigarCollector, app.fs, config.Platform)
app.platform, err = platformProvider.Get(opts.PlatformName)
if err != nil {
return bosherr.WrapError(err, "Getting platform")
}
settingsSourceFactory := boshinf.NewSettingsSourceFactory(config.Infrastructure.Settings, app.platform, app.logger)
settingsSource, err := settingsSourceFactory.New()
if err != nil {
return bosherr.WrapError(err, "Getting Settings Source")
}
settingsService := boshsettings.NewService(
app.platform.GetFs(),
filepath.Join(app.dirProvider.BoshDir(), "settings.json"),
settingsSource,
app.platform,
app.logger,
)
app.dualDCSupport = nimbus.NewDualDCSupport(
app.platform.GetRunner(),
app.platform.GetFs(),
app.dirProvider,
boshas.NewConcreteV1Service(app.platform.GetFs(), filepath.Join(app.dirProvider.BoshDir(), "spec.json")),
settingsService,
app.logger,
)
// wrap platform with nimbus specific features - Mount/Unmount persistent disk
platformWrapper := nimbus.NewPlatformWrapper(app.platform, app.dualDCSupport)
app.platform = platformWrapper
boot := boshagent.NewBootstrap(
app.platform,
app.dirProvider,
settingsService,
app.logger,
)
if err = boot.Run(); err != nil {
return bosherr.WrapError(err, "Running bootstrap")
}
mbusHandlerProvider := boshmbus.NewHandlerProvider(settingsService, app.logger)
mbusHandler, err := mbusHandlerProvider.Get(app.platform, app.dirProvider)
if err != nil {
return bosherr.WrapError(err, "Getting mbus handler")
}
blobstoreProvider := boshblob.NewProvider(app.platform.GetFs(), app.platform.GetRunner(), app.dirProvider.EtcDir(), app.logger)
blobsettings := settingsService.GetSettings().Blobstore
blobstore, err := blobstoreProvider.Get(blobsettings.Type, blobsettings.Options)
if err != nil {
return bosherr.WrapError(err, "Getting blobstore")
}
monitClientProvider := boshmonit.NewProvider(app.platform, app.logger)
monitClient, err := monitClientProvider.Get()
if err != nil {
return bosherr.WrapError(err, "Getting monit client")
}
jobSupervisorProvider := boshjobsuper.NewProvider(
app.platform,
monitClient,
app.logger,
app.dirProvider,
mbusHandler,
)
jobSupervisor, err := jobSupervisorProvider.Get(opts.JobSupervisor)
if err != nil {
return bosherr.WrapError(err, "Getting job supervisor")
}
notifier := boshnotif.NewNotifier(mbusHandler)
applier, compiler := app.buildApplierAndCompiler(app.dirProvider, blobstore, jobSupervisor)
uuidGen := boshuuid.NewGenerator()
taskService := boshtask.NewAsyncTaskService(uuidGen, app.logger)
taskManager := boshtask.NewManagerProvider().NewManager(
app.logger,
app.platform.GetFs(),
app.dirProvider.BoshDir(),
)
specFilePath := filepath.Join(app.dirProvider.BoshDir(), "spec.json")
specService := boshas.NewConcreteV1Service(
app.platform.GetFs(),
specFilePath,
)
timeService := clock.NewClock()
jobScriptProvider := boshscript.NewConcreteJobScriptProvider(
app.platform.GetRunner(),
app.platform.GetFs(),
app.platform.GetDirProvider(),
timeService,
app.logger,
)
actionFactory := boshaction.NewFactory(
settingsService,
app.platform,
blobstore,
taskService,
notifier,
applier,
compiler,
jobSupervisor,
specService,
jobScriptProvider,
app.dualDCSupport,
app.logger,
)
actionRunner := boshaction.NewRunner()
actionDispatcher := boshagent.NewActionDispatcher(
app.logger,
taskService,
taskManager,
actionFactory,
actionRunner,
)
syslogServer := boshsyslog.NewServer(33331, net.Listen, app.logger)
app.agent = boshagent.New(
app.logger,
mbusHandler,
app.platform,
actionDispatcher,
jobSupervisor,
specService,
syslogServer,
time.Minute,
settingsService,
uuidGen,
timeService,
)
return nil
}