func TestHandlerProviderGetReturnsConcreteProvider(t *testing.T) {
platform := fakeplatform.NewFakePlatform()
blobstore := fakeblob.NewFakeBlobstore()
jobSupervisor := fakejobsuper.NewFakeJobSupervisor()
expectedPackageApplier := pa.NewConcretePackageApplier(
bc.NewFileBundleCollection("/fake-base-dir/data", "/fake-base-dir", "packages", platform.GetFs()),
blobstore,
platform.GetCompressor(),
)
expectedJobApplier := ja.NewRenderedJobApplier(
bc.NewFileBundleCollection("/fake-base-dir/data", "/fake-base-dir", "jobs", platform.GetFs()),
blobstore,
platform.GetCompressor(),
jobSupervisor,
)
dirProvider := boshdirs.NewDirectoriesProvider("/fake-base-dir")
expectedApplier := NewConcreteApplier(
expectedJobApplier,
expectedPackageApplier,
platform,
jobSupervisor,
dirProvider,
)
provider := NewApplierProvider(platform, blobstore, jobSupervisor, dirProvider)
applier := provider.Get()
assert.Equal(t, expectedApplier, applier)
}
func (p ApplierProvider) Get() (applier Applier) {
jobsBc := bc.NewFileBundleCollection(
"jobs", boshsettings.VCAP_BASE_DIR, p.platform.GetFs())
packagesBc := bc.NewFileBundleCollection(
"packages", boshsettings.VCAP_BASE_DIR, p.platform.GetFs())
packageApplier := pa.NewConcretePackageApplier(
packagesBc,
p.blobstore,
p.platform.GetCompressor(),
)
return NewConcreteApplier(jobsBc, packageApplier, p.platform)
}
func (app *app) buildApplierAndCompiler(
dirProvider boshdirs.DirectoriesProvider,
blobstore boshblob.Blobstore,
jobSupervisor boshjobsuper.JobSupervisor,
) (boshapplier.Applier, boshcomp.Compiler) {
jobsBc := boshbc.NewFileBundleCollection(
dirProvider.DataDir(),
dirProvider.BaseDir(),
"jobs",
app.platform.GetFs(),
app.logger,
)
packageApplierProvider := boshpa.NewConcretePackageApplierProvider(
dirProvider.DataDir(),
dirProvider.BaseDir(),
dirProvider.JobsDir(),
"packages",
blobstore,
app.platform.GetCompressor(),
app.platform.GetFs(),
app.logger,
)
jobApplier := boshja.NewRenderedJobApplier(
jobsBc,
jobSupervisor,
packageApplierProvider,
blobstore,
app.platform.GetCompressor(),
app.platform.GetFs(),
app.logger,
)
applier := boshapplier.NewConcreteApplier(
jobApplier,
packageApplierProvider.Root(),
app.platform,
jobSupervisor,
dirProvider,
)
compiler := boshcomp.NewConcreteCompiler(
app.platform.GetCompressor(),
blobstore,
app.platform.GetFs(),
app.platform.GetRunner(),
dirProvider,
packageApplierProvider.Root(),
packageApplierProvider.RootBundleCollection(),
)
return applier, compiler
}
func TestHandlerProviderGetReturnsConcreteProvider(t *testing.T) {
platform := fakeplatform.NewFakePlatform()
blobstore := fakeblob.NewFakeBlobstore()
expectedPackageApplier := pa.NewConcretePackageApplier(
bc.NewFileBundleCollection("packages", "/var/vcap", platform.GetFs()),
blobstore,
platform.GetCompressor(),
)
expectedApplier := NewConcreteApplier(
bc.NewFileBundleCollection("jobs", "/var/vcap", platform.GetFs()),
expectedPackageApplier,
platform,
)
provider := NewApplierProvider(platform, blobstore)
applier := provider.Get()
assert.Equal(t, expectedApplier, applier)
}
func (p ApplierProvider) Get() (applier Applier) {
installPath := filepath.Join(p.dirProvider.BaseDir(), "data")
jobsBc := bc.NewFileBundleCollection(installPath, p.dirProvider.BaseDir(), "jobs", p.platform.GetFs())
jobApplier := ja.NewRenderedJobApplier(
jobsBc,
p.blobstore,
p.platform.GetCompressor(),
p.jobSupervisor,
)
packagesBc := bc.NewFileBundleCollection(installPath, p.dirProvider.BaseDir(), "packages", p.platform.GetFs())
packageApplier := pa.NewConcretePackageApplier(
packagesBc,
p.blobstore,
p.platform.GetCompressor(),
)
return NewConcreteApplier(jobApplier, packageApplier, p.platform, p.jobSupervisor, p.dirProvider)
}
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 (p concretePackageApplierProvider) RootBundleCollection() boshbc.BundleCollection {
return boshbc.NewFileBundleCollection(p.installPath, p.rootEnablePath, p.name, p.fs, p.logger)
}
// JobSpecific provides package applier that operates on job-specific packages.
// (e.g manages /var/vcap/jobs/job-name/packages/pkg-a -> /var/vcap/data/packages/pkg-a)
func (p concretePackageApplierProvider) JobSpecific(jobName string) PackageApplier {
enablePath := filepath.Join(p.jobSpecificEnablePath, jobName)
packagesBc := boshbc.NewFileBundleCollection(p.installPath, enablePath, p.name, p.fs, p.logger)
return NewConcretePackageApplier(packagesBc, false, p.blobstore, p.compressor, p.fs, p.logger)
}
"fake-job-specific-enable-path",
"fake-name",
blobstore,
compressor,
fs,
logger,
)
})
Describe("Root", func() {
It("returns package applier that is configured to update system wide packages", func() {
expected := NewConcretePackageApplier(
boshbc.NewFileBundleCollection(
"fake-install-path",
"fake-root-enable-path",
"fake-name",
fs,
logger,
),
true,
blobstore,
compressor,
fs,
logger,
)
Expect(provider.Root()).To(Equal(expected))
})
})
Describe("JobSpecific", func() {
It("returns package applier that is configured to only update job specific packages", func() {
