)
var _ = Describe("Provider", func() {
var (
fs *fakesys.FakeFileSystem
runner *fakesys.FakeCmdRunner
logger boshlog.Logger
provider Provider
digestProvider boshcrypto.DigestProvider
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
runner = fakesys.NewFakeCmdRunner()
logger = boshlog.NewLogger(boshlog.LevelNone)
digestProvider = boshcrypto.NewDigestProvider(fs)
provider = NewProvider(fs, runner, "/var/vcap/config", digestProvider, logger)
})
Describe("Get", func() {
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(
fixtureSHA1 = "da39a3ee5e6b4b0d3255bfef95601890afd80709"
fixtureSHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
fixtureSHA512 = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
)
var (
innerBlobstore *fakeblob.FakeBlobstore
checksumVerifiableBlobstore boshblob.Blobstore
checksumProvider boshcrypto.DigestProvider
fixtureDigest boshcrypto.Digest
)
BeforeEach(func() {
fixtureDigest = boshcrypto.NewDigest(boshcrypto.DigestAlgorithmSHA1, fixtureSHA1)
innerBlobstore = &fakeblob.FakeBlobstore{}
checksumProvider = boshcrypto.NewDigestProvider(fakesys.NewFakeFileSystem())
checksumVerifiableBlobstore = boshblob.NewDigestVerifiableBlobstore(innerBlobstore, checksumProvider)
})
Describe("Get", func() {
It("returns without an error if sha1 matches", func() {
innerBlobstore.GetFileName = fixturePath
fileName, err := checksumVerifiableBlobstore.Get("fake-blob-id", fixtureDigest)
Expect(err).ToNot(HaveOccurred())
Expect(innerBlobstore.GetBlobIDs).To(Equal([]string{"fake-blob-id"}))
Expect(fileName).To(Equal(fixturePath))
})
It("returns error if sha1 does not match", func() {
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.digestProvider = boshcrypto.NewDigestProvider(app.fs)
app.dirProvider = boshdirs.NewProvider(opts.BaseDirectory)
app.logStemcellInfo()
statsCollector := boshsigar.NewSigarStatsCollector(&sigar.ConcreteSigar{})
state, err := boshplatform.NewBootstrapState(app.fs, filepath.Join(app.dirProvider.BoshDir(), "agent_state.json"))
if err != nil {
return bosherr.WrapError(err, "Loading state")
}
timeService := clock.NewClock()
platformProvider := boshplatform.NewProvider(app.logger, app.dirProvider, statsCollector, app.fs, config.Platform, state, timeService)
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,
)
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")
}
blobManager := boshblob.NewBlobManager(app.platform.GetFs(), app.dirProvider.BlobsDir())
blobstore, err := app.setupBlobstore(settingsService.GetSettings().Blobstore, blobManager)
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,
)
jobScriptProvider := boshscript.NewConcreteJobScriptProvider(
app.platform.GetRunner(),
app.platform.GetFs(),
app.platform.GetDirProvider(),
timeService,
app.logger,
)
actionFactory := boshaction.NewFactory(
settingsService,
app.platform,
blobstore,
blobManager,
taskService,
notifier,
applier,
compiler,
jobSupervisor,
specService,
jobScriptProvider,
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.Second*30,
settingsService,
uuidGen,
timeService,
)
return nil
}