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"}
}