func NewProvider( fs system.FileSystem, runner system.CmdRunner, configDir string, logger boshlog.Logger, ) Provider { return Provider{ uuidGen: boshuuid.NewGenerator(), fs: fs, runner: runner, configDir: configDir, logger: logger, } }
func NewRequestRetryable( request *http.Request, delegate Client, logger boshlog.Logger, ) RequestRetryable { return &requestRetryable{ request: request, delegate: delegate, attempt: 0, uuidGenerator: boshuuid.NewGenerator(), logger: logger, logTag: "clientRetryable", } }
func buildPkg(bc *fakebc.FakeBundleCollection) (models.Package, *fakebc.FakeBundle) { uuidGen := boshuuid.NewGenerator() uuid, err := uuidGen.Generate() Expect(err).ToNot(HaveOccurred()) pkg := models.Package{ Name: "fake-package-name" + uuid, Version: "fake-package-name", Source: models.Source{ Sha1: "fake-blob-sha1", BlobstoreID: "fake-blobstore-id", }, } bundle := bc.FakeGet(pkg) return pkg, bundle }
func buildJob(bc *fakebc.FakeBundleCollection) (models.Job, *fakebc.FakeBundle) { uuidGen := boshuuid.NewGenerator() uuid, err := uuidGen.Generate() Expect(err).ToNot(HaveOccurred()) job := models.Job{ Name: "fake-job-name" + uuid, Version: "fake-job-version", Source: models.Source{ Sha1: "fake-blob-sha1", BlobstoreID: "fake-blobstore-id", PathInArchive: "fake-path-in-archive", }, Packages: []models.Package{ models.Package{ Name: "fake-package1-name" + uuid, Version: "fake-package1-version", Source: models.Source{ Sha1: "fake-package1-sha1", BlobstoreID: "fake-package1-blobstore-id", PathInArchive: "", }, }, models.Package{ Name: "fake-package2-name" + uuid, Version: "fake-package2-version", Source: models.Source{ Sha1: "fake-package2-sha1", BlobstoreID: "fake-package2-blobstore-id", PathInArchive: "", }, }, }, } bundle := bc.FakeGet(job) return job, bundle }
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.NewProvider(opts.BaseDirectory) // 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, dirProvider, sigarCollector, 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(dirProvider.BoshDir(), "settings.json"), settingsSource, app.platform, app.logger, ) boot := boshagent.NewBootstrap( app.platform, 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, dirProvider) if err != nil { return bosherr.WrapError(err, "Getting mbus handler") } blobstoreProvider := boshblob.NewProvider(app.platform.GetFs(), app.platform.GetRunner(), 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, 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(), specFilePath, ) drainScriptProvider := boshdrain.NewConcreteScriptProvider( 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, ) syslogServer := boshsyslog.NewServer(33331, app.logger) timeService := clock.NewClock() app.agent = boshagent.New( app.logger, mbusHandler, app.platform, actionDispatcher, jobSupervisor, specService, syslogServer, time.Minute, settingsService, uuidGen, timeService, ) return nil }
It("get dummy", func() { blobstore, err := provider.Get(BlobstoreTypeDummy, map[string]interface{}{}) Expect(err).ToNot(HaveOccurred()) Expect(blobstore).ToNot(BeNil()) }) It("get external when external command in path", func() { options := map[string]interface{}{"key": "value"} runner.CommandExistsValue = true expectedBlobstore := NewExternalBlobstore( "fake-external-type", options, fs, runner, boshuuid.NewGenerator(), "/var/vcap/config/blobstore-fake-external-type.json", ) expectedBlobstore = NewSHA1VerifiableBlobstore(expectedBlobstore) expectedBlobstore = NewRetryableBlobstore(expectedBlobstore, 3, logger) blobstore, err := provider.Get("fake-external-type", options) Expect(err).ToNot(HaveOccurred()) Expect(blobstore).To(Equal(expectedBlobstore)) err = expectedBlobstore.Validate() Expect(err).ToNot(HaveOccurred()) }) It("get external errs when external command not in path", func() { options := map[string]interface{}{"key": "value"}
func buildPackage() models.Package { uuidGen := boshuuid.NewGenerator() uuid, err := uuidGen.Generate() Expect(err).ToNot(HaveOccurred()) return models.Package{Name: "fake-package-name" + uuid, Version: "fake-package-name"} }
func buildJob() models.Job { uuidGen := boshuuid.NewGenerator() uuid, err := uuidGen.Generate() Expect(err).ToNot(HaveOccurred()) return models.Job{Name: "fake-job-name" + uuid, Version: "fake-version-name"} }