func (app app) Run(args []string) (err error) {
opts, err := parseOptions(args)
if err != nil {
return
}
infProvider := boshinf.NewProvider(app.logger)
infrastructure, err := infProvider.Get(opts.InfrastructureName)
if err != nil {
err = bosherr.WrapError(err, "Getting infrastructure")
return
}
platformProvider := boshplatform.NewProvider(app.logger)
platform, err := platformProvider.Get(opts.PlatformName)
if err != nil {
err = bosherr.WrapError(err, "Getting platform")
return
}
boot := boshboot.New(infrastructure, platform)
settingsService, err := boot.Run()
if err != nil {
err = bosherr.WrapError(err, "Running bootstrap")
return
}
mbusHandlerProvider := boshmbus.NewHandlerProvider(settingsService, app.logger)
mbusHandler, err := mbusHandlerProvider.Get()
if err != nil {
err = bosherr.WrapError(err, "Getting mbus handler")
return
}
blobstoreProvider := boshblob.NewProvider(platform)
blobstore, err := blobstoreProvider.Get(settingsService.GetBlobstore())
if err != nil {
err = bosherr.WrapError(err, "Getting blobstore")
return
}
taskService := boshtask.NewAsyncTaskService(app.logger)
applier := boshas.NewApplierProvider(platform, blobstore).Get()
actionFactory := boshaction.NewFactory(settingsService, platform, blobstore, taskService, applier)
agent := boshagent.New(settingsService, app.logger, mbusHandler, platform, taskService, actionFactory)
err = agent.Run()
if err != nil {
err = bosherr.WrapError(err, "Running agent")
}
return
}
func (app app) Run(args []string) (err error) {
opts, err := parseOptions(args)
if err != nil {
return
}
infProvider := boshinf.NewProvider()
infrastructure, err := infProvider.Get(opts.InfrastructureName)
if err != nil {
return
}
platformProvider := boshplatform.NewProvider()
platform, err := platformProvider.Get(opts.PlatformName)
if err != nil {
return
}
boot := boshboot.New(infrastructure, platform)
settings, err := boot.Run()
if err != nil {
return
}
mbusHandlerProvider := boshmbus.NewHandlerProvider(settings)
mbusHandler, err := mbusHandlerProvider.Get()
if err != nil {
return
}
blobstoreProvider := boshblobstore.NewProvider()
blobstore, err := blobstoreProvider.Get(settings.Blobstore)
if err != nil {
return
}
taskService := boshtask.NewAsyncTaskService()
actionFactory := boshaction.NewFactory(settings, platform, blobstore, taskService)
agent := boshagent.New(settings, mbusHandler, platform, taskService, actionFactory)
err = agent.Run()
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 (app app) Run(args []string) (err error) {
opts, err := parseOptions(args)
if err != nil {
err = bosherr.WrapError(err, "Parsing options")
return
}
dirProvider := boshdirs.NewDirectoriesProvider("/var/vcap")
infProvider := boshinf.NewProvider(app.logger)
infrastructure, err := infProvider.Get(opts.InfrastructureName)
if err != nil {
err = bosherr.WrapError(err, "Getting infrastructure")
return
}
platformProvider := boshplatform.NewProvider(app.logger, dirProvider)
platform, err := platformProvider.Get(opts.PlatformName)
if err != nil {
err = bosherr.WrapError(err, "Getting platform")
return
}
boot := boshboot.New(infrastructure, platform)
settingsService, err := boot.Run()
if err != nil {
err = bosherr.WrapError(err, "Running bootstrap")
return
}
mbusHandlerProvider := boshmbus.NewHandlerProvider(settingsService, app.logger)
mbusHandler, err := mbusHandlerProvider.Get()
if err != nil {
err = bosherr.WrapError(err, "Getting mbus handler")
return
}
blobstoreProvider := boshblob.NewProvider(platform)
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
}
monitor := boshmon.NewMonit(platform.GetFs(), platform.GetRunner(), monitClient, app.logger)
notifier := boshnotif.NewNotifier(mbusHandler)
applier := boshappl.NewApplierProvider(platform, blobstore, monitor, dirProvider).Get()
compiler := boshcomp.NewCompilerProvider(platform, blobstore, dirProvider).Get()
taskService := boshtask.NewAsyncTaskService(app.logger)
specFilePath := filepath.Join(dirProvider.BaseDir(), "bosh", "spec.json")
specService := boshas.NewConcreteV1Service(platform.GetFs(), specFilePath)
drainScriptProvider := boshdrain.NewDrainScriptProvider(platform.GetRunner(), platform.GetFs(), dirProvider)
actionFactory := boshaction.NewFactory(
settingsService,
platform,
blobstore,
taskService,
notifier,
applier,
compiler,
monitor,
specService,
dirProvider,
drainScriptProvider,
)
actionRunner := boshaction.NewRunner()
actionDispatcher := boshagent.NewActionDispatcher(app.logger, taskService, actionFactory, actionRunner)
agent := boshagent.New(settingsService, app.logger, mbusHandler, platform, actionDispatcher)
err = agent.Run()
if err != nil {
err = bosherr.WrapError(err, "Running agent")
}
return
}