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 (app app) Run(args []string) (err error) { opts, err := ParseOptions(args) if err != nil { err = bosherr.WrapError(err, "Parsing options") return } dirProvider := boshdirs.NewDirectoriesProvider(opts.BaseDirectory) platformProvider := boshplatform.NewProvider(app.logger, dirProvider) platform, err := platformProvider.Get(opts.PlatformName) if err != nil { err = bosherr.WrapError(err, "Getting platform") return } infProvider := boshinf.NewProvider(app.logger, platform) infrastructure, err := infProvider.Get(opts.InfrastructureName) if err != nil { err = bosherr.WrapError(err, "Getting infrastructure") return } boot := boshboot.New(infrastructure, platform, dirProvider) settingsService, err := boot.Run() if err != nil { err = bosherr.WrapError(err, "Running bootstrap") return } mbusHandlerProvider := boshmbus.NewHandlerProvider(settingsService, app.logger) mbusHandler, err := mbusHandlerProvider.Get(platform, dirProvider) if err != nil { err = bosherr.WrapError(err, "Getting mbus handler") return } blobstoreProvider := boshblob.NewProvider(platform, dirProvider) blobstore, err := blobstoreProvider.Get(settingsService.GetBlobstore()) if err != nil { err = bosherr.WrapError(err, "Getting blobstore") return } monitClientProvider := boshmonit.NewProvider(platform) monitClient, err := monitClientProvider.Get() if err != nil { err = bosherr.WrapError(err, "Getting monit client") return } jobSupervisorProvider := boshjobsuper.NewProvider(platform, monitClient, app.logger, dirProvider) jobSupervisor, err := jobSupervisorProvider.Get(opts.JobSupervisor) if err != nil { err = bosherr.WrapError(err, "Getting job supervisor") return } notifier := boshnotif.NewNotifier(mbusHandler) installPath := filepath.Join(dirProvider.BaseDir(), "data") jobsBc := bc.NewFileBundleCollection(installPath, dirProvider.BaseDir(), "jobs", platform.GetFs()) jobApplier := ja.NewRenderedJobApplier( jobsBc, blobstore, platform.GetCompressor(), jobSupervisor, ) packagesBc := bc.NewFileBundleCollection(installPath, dirProvider.BaseDir(), "packages", platform.GetFs()) packageApplier := pa.NewConcretePackageApplier( packagesBc, blobstore, platform.GetCompressor(), ) applier := boshapplier.NewConcreteApplier(jobApplier, packageApplier, platform, jobSupervisor, dirProvider) compiler := boshcomp.NewConcreteCompiler( platform.GetCompressor(), blobstore, platform.GetFs(), platform.GetRunner(), dirProvider, packageApplier, packagesBc, ) taskService := boshtask.NewAsyncTaskService(app.logger) specFilePath := filepath.Join(dirProvider.BaseDir(), "bosh", "spec.json") specService := boshas.NewConcreteV1Service(platform.GetFs(), specFilePath) drainScriptProvider := boshdrain.NewConcreteDrainScriptProvider(platform.GetRunner(), platform.GetFs(), dirProvider) actionFactory := boshaction.NewFactory( settingsService, platform, blobstore, taskService, notifier, applier, compiler, jobSupervisor, specService, drainScriptProvider, ) actionRunner := boshaction.NewRunner() actionDispatcher := boshagent.NewActionDispatcher(app.logger, taskService, actionFactory, actionRunner) alertBuilder := boshalert.NewBuilder(settingsService, app.logger) agent := boshagent.New(app.logger, mbusHandler, platform, actionDispatcher, alertBuilder, jobSupervisor, time.Minute) err = agent.Run() if err != nil { err = bosherr.WrapError(err, "Running agent") } return }
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") } dirProvider := boshdirs.NewDirectoriesProvider(opts.BaseDirectory) platformProvider := boshplatform.NewProvider(app.logger, dirProvider, config.Platform) app.platform, err = platformProvider.Get(opts.PlatformName) if err != nil { return bosherr.WrapError(err, "Getting platform") } infProvider := boshinf.NewProvider(app.logger, app.platform) app.infrastructure, err = infProvider.Get(opts.InfrastructureName) app.platform.SetDevicePathResolver(app.infrastructure.GetDevicePathResolver()) if err != nil { return bosherr.WrapError(err, "Getting infrastructure") } settingsServiceProvider := boshsettings.NewServiceProvider() boot := boshboot.New( app.infrastructure, app.platform, dirProvider, settingsServiceProvider, app.logger, ) settingsService, err := boot.Run() if err != nil { return bosherr.WrapError(err, "Running bootstrap") } mbusHandlerProvider := boshmbus.NewHandlerProvider(settingsService, app.logger) mbusHandler, err := mbusHandlerProvider.Get(app.platform, dirProvider) if err != nil { return bosherr.WrapError(err, "Getting mbus handler") } blobstoreProvider := boshblob.NewProvider(app.platform, dirProvider) blobstore, err := blobstoreProvider.Get(settingsService.GetBlobstore()) 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, 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(dirProvider, blobstore, jobSupervisor) uuidGen := boshuuid.NewGenerator() taskService := boshtask.NewAsyncTaskService(uuidGen, app.logger) taskManager := boshtask.NewManagerProvider().NewManager( app.logger, app.platform.GetFs(), dirProvider.BoshDir(), ) specFilePath := filepath.Join(dirProvider.BoshDir(), "spec.json") specService := boshas.NewConcreteV1Service( app.platform.GetFs(), app.platform, specFilePath, ) drainScriptProvider := boshdrain.NewConcreteDrainScriptProvider( app.platform.GetRunner(), app.platform.GetFs(), dirProvider, ) actionFactory := boshaction.NewFactory( settingsService, app.platform, blobstore, taskService, notifier, applier, compiler, jobSupervisor, specService, drainScriptProvider, app.logger, ) actionRunner := boshaction.NewRunner() actionDispatcher := boshagent.NewActionDispatcher( app.logger, taskService, taskManager, actionFactory, actionRunner, ) alertBuilder := boshalert.NewBuilder(settingsService, app.logger) alertSender := boshagent.NewAlertSender(mbusHandler, alertBuilder) app.agent = boshagent.New( app.logger, mbusHandler, app.platform, actionDispatcher, alertSender, jobSupervisor, specService, time.Minute, ) return nil }
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)) }) }) }
drainScriptProvider boshdrain.DrainScriptProvider factory Factory logger boshlog.Logger ) 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() drainScriptProvider = boshdrain.NewConcreteDrainScriptProvider(nil, nil, platform.GetDirProvider()) logger = boshlog.NewLogger(boshlog.LevelNone) factory = NewFactory( settingsService, platform, blobstore, taskService, notifier, applier, compiler, jobSupervisor, specService, drainScriptProvider, logger, )