func (cmd *Push) Run(c *cli.Context) {
appSet := cmd.findAndValidateAppsToPush(c)
_, apiErr := cmd.authRepo.RefreshAuthToken()
if apiErr != nil {
cmd.ui.Failed(fmt.Sprintf("Error refreshing auth token.\n%s", apiErr.Error()))
return
}
routeActor := actors.NewRouteActor(cmd.ui, cmd.routeRepo)
noHostname := c.Bool("no-hostname")
for _, appParams := range appSet {
cmd.fetchStackGuid(&appParams)
app := cmd.createOrUpdateApp(appParams)
cmd.updateRoutes(routeActor, app, appParams, noHostname)
cmd.ui.Say(T("Uploading {{.AppName}}...",
map[string]interface{}{"AppName": terminal.EntityNameColor(app.Name)}))
apiErr := cmd.appBitsRepo.UploadApp(app.Guid, *appParams.Path, cmd.describeUploadOperation)
if apiErr != nil {
cmd.ui.Failed(fmt.Sprintf(T("Error uploading application.\n{{.ApiErr}}",
map[string]interface{}{"ApiErr": apiErr.Error()})))
return
}
cmd.ui.Ok()
if appParams.ServicesToBind != nil {
cmd.bindAppToServices(*appParams.ServicesToBind, app)
}
cmd.restart(app, appParams, c)
}
}
func (cmd *Push) Execute(c flags.FlagContext) {
appSet := cmd.findAndValidateAppsToPush(c)
_, apiErr := cmd.authRepo.RefreshAuthToken()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
routeActor := actors.NewRouteActor(cmd.ui, cmd.routeRepo)
for _, appParams := range appSet {
cmd.fetchStackGuid(&appParams)
app := cmd.createOrUpdateApp(appParams)
cmd.updateRoutes(routeActor, app, appParams)
cmd.ui.Say(T("Uploading {{.AppName}}...",
map[string]interface{}{"AppName": terminal.EntityNameColor(app.Name)}))
apiErr := cmd.uploadApp(app.Guid, *appParams.Path)
if apiErr != nil {
cmd.ui.Failed(fmt.Sprintf(T("Error uploading application.\n{{.ApiErr}}",
map[string]interface{}{"ApiErr": apiErr.Error()})))
return
}
cmd.ui.Ok()
if appParams.ServicesToBind != nil {
cmd.bindAppToServices(*appParams.ServicesToBind, app)
}
cmd.restart(app, appParams, c)
}
}
func (cmd *Push) Execute(c flags.FlagContext) {
appSet := cmd.findAndValidateAppsToPush(c)
_, apiErr := cmd.authRepo.RefreshAuthToken()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
routeActor := actors.NewRouteActor(cmd.ui, cmd.routeRepo)
for _, appParams := range appSet {
cmd.fetchStackGuid(&appParams)
if c.IsSet("docker-image") {
diego := true
appParams.Diego = &diego
}
app := cmd.createOrUpdateApp(appParams)
cmd.updateRoutes(routeActor, app, appParams)
if c.String("docker-image") == "" {
err := cmd.actor.ProcessPath(*appParams.Path, cmd.processPathCallback(*appParams.Path, app))
if err != nil {
cmd.ui.Failed(
T("Error processing app files: {{.Error}}",
map[string]interface{}{
"Error": err.Error(),
}),
)
return
}
}
if appParams.ServicesToBind != nil {
cmd.bindAppToServices(*appParams.ServicesToBind, app)
}
cmd.restart(app, appParams, c)
}
}
func (cmd *Push) Execute(c flags.FlagContext) {
appSet := cmd.findAndValidateAppsToPush(c)
_, apiErr := cmd.authRepo.RefreshAuthToken()
if apiErr != nil {
cmd.ui.Failed(apiErr.Error())
return
}
routeActor := actors.NewRouteActor(cmd.ui, cmd.routeRepo)
for _, appParams := range appSet {
cmd.fetchStackGuid(&appParams)
if c.IsSet("docker-image") {
diego := true
appParams.Diego = &diego
}
app := cmd.createOrUpdateApp(appParams)
cmd.updateRoutes(routeActor, app, appParams)
if c.String("docker-image") == "" {
cmd.actor.ProcessPath(*appParams.Path, func(appDir string) {
localFiles, err := cmd.appfiles.AppFilesInDir(appDir)
if err != nil {
cmd.ui.Failed(
T("Error processing app files in '{{.Path}}': {{.Error}}",
map[string]interface{}{
"Path": *appParams.Path,
"Error": err.Error(),
}),
)
}
if len(localFiles) == 0 {
cmd.ui.Failed(
T("No app files found in '{{.Path}}'",
map[string]interface{}{
"Path": *appParams.Path,
}),
)
}
cmd.ui.Say(T("Uploading {{.AppName}}...",
map[string]interface{}{"AppName": terminal.EntityNameColor(app.Name)}))
apiErr := cmd.uploadApp(app.Guid, appDir, *appParams.Path, localFiles)
if apiErr != nil {
cmd.ui.Failed(fmt.Sprintf(T("Error uploading application.\n{{.ApiErr}}",
map[string]interface{}{"ApiErr": apiErr.Error()})))
return
}
cmd.ui.Ok()
})
}
if appParams.ServicesToBind != nil {
cmd.bindAppToServices(*appParams.ServicesToBind, app)
}
cmd.restart(app, appParams, c)
}
}
func (cmd *Push) Execute(c flags.FlagContext) {
appsFromManifest := cmd.getAppParamsFromManifest(c)
appFromContext := cmd.getAppParamsFromContext(c)
appSet := cmd.createAppSetFromContextAndManifest(appFromContext, appsFromManifest)
_, err := cmd.authRepo.RefreshAuthToken()
if err != nil {
cmd.ui.Failed(err.Error())
return
}
routeActor := actors.NewRouteActor(cmd.ui, cmd.routeRepo)
for _, appParams := range appSet {
if appParams.Name == nil {
cmd.ui.Failed(T("Error: No name found for app"))
}
cmd.fetchStackGuid(&appParams)
if c.IsSet("docker-image") {
diego := true
appParams.Diego = &diego
}
var app models.Application
existingApp, err := cmd.appRepo.Read(*appParams.Name)
switch err.(type) {
case nil:
cmd.ui.Say(T("Updating app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"AppName": terminal.EntityNameColor(existingApp.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
if appParams.EnvironmentVars != nil {
for key, val := range existingApp.EnvironmentVars {
if _, ok := (*appParams.EnvironmentVars)[key]; !ok {
(*appParams.EnvironmentVars)[key] = val
}
}
}
app, err = cmd.appRepo.Update(existingApp.Guid, appParams)
if err != nil {
cmd.ui.Failed(err.Error())
}
case *errors.ModelNotFoundError:
spaceGuid := cmd.config.SpaceFields().Guid
appParams.SpaceGuid = &spaceGuid
cmd.ui.Say(T("Creating app {{.AppName}} in org {{.OrgName}} / space {{.SpaceName}} as {{.Username}}...",
map[string]interface{}{
"AppName": terminal.EntityNameColor(*appParams.Name),
"OrgName": terminal.EntityNameColor(cmd.config.OrganizationFields().Name),
"SpaceName": terminal.EntityNameColor(cmd.config.SpaceFields().Name),
"Username": terminal.EntityNameColor(cmd.config.Username())}))
app, err = cmd.appRepo.Create(appParams)
if err != nil {
cmd.ui.Failed(err.Error())
}
default:
cmd.ui.Failed(err.Error())
}
cmd.ui.Ok()
cmd.ui.Say("")
cmd.updateRoutes(routeActor, app, appParams)
if c.String("docker-image") == "" {
err := cmd.actor.ProcessPath(*appParams.Path, cmd.processPathCallback(*appParams.Path, app))
if err != nil {
cmd.ui.Failed(
T("Error processing app files: {{.Error}}",
map[string]interface{}{
"Error": err.Error(),
}),
)
return
}
}
if appParams.ServicesToBind != nil {
cmd.bindAppToServices(*appParams.ServicesToBind, app)
}
cmd.restart(app, appParams, c)
}
}
func NewDependency(writer io.Writer, logger trace.Printer, envDialTimeout string) Dependency {
deps := Dependency{}
deps.TeePrinter = terminal.NewTeePrinter(writer)
deps.UI = terminal.NewUI(os.Stdin, writer, deps.TeePrinter, logger)
errorHandler := func(err error) {
if err != nil {
deps.UI.Failed(fmt.Sprintf("Config error: %s", err))
}
}
configPath, err := confighelpers.DefaultFilePath()
if err != nil {
errorHandler(err)
}
deps.Config = coreconfig.NewRepositoryFromFilepath(configPath, errorHandler)
deps.ManifestRepo = manifest.NewDiskRepository()
deps.AppManifest = manifest.NewGenerator()
pluginPath := filepath.Join(confighelpers.PluginRepoDir(), ".cf", "plugins")
deps.PluginConfig = pluginconfig.NewPluginConfig(
errorHandler,
configuration.NewDiskPersistor(filepath.Join(pluginPath, "config.json")),
pluginPath,
)
terminal.UserAskedForColors = deps.Config.ColorEnabled()
terminal.InitColorSupport()
deps.Gateways = map[string]net.Gateway{
"cloud-controller": net.NewCloudControllerGateway(deps.Config, time.Now, deps.UI, logger, envDialTimeout),
"uaa": net.NewUAAGateway(deps.Config, deps.UI, logger, envDialTimeout),
"routing-api": net.NewRoutingAPIGateway(deps.Config, time.Now, deps.UI, logger, envDialTimeout),
}
deps.RepoLocator = api.NewRepositoryLocator(deps.Config, deps.Gateways, logger)
deps.PluginModels = &PluginModels{Application: nil}
deps.PlanBuilder = planbuilder.NewBuilder(
deps.RepoLocator.GetServicePlanRepository(),
deps.RepoLocator.GetServicePlanVisibilityRepository(),
deps.RepoLocator.GetOrganizationRepository(),
)
deps.ServiceBuilder = servicebuilder.NewBuilder(
deps.RepoLocator.GetServiceRepository(),
deps.PlanBuilder,
)
deps.BrokerBuilder = brokerbuilder.NewBuilder(
deps.RepoLocator.GetServiceBrokerRepository(),
deps.ServiceBuilder,
)
deps.PluginRepo = pluginrepo.NewPluginRepo()
deps.ServiceHandler = actors.NewServiceHandler(
deps.RepoLocator.GetOrganizationRepository(),
deps.BrokerBuilder,
deps.ServiceBuilder,
)
deps.ServicePlanHandler = actors.NewServicePlanHandler(
deps.RepoLocator.GetServicePlanRepository(),
deps.RepoLocator.GetServicePlanVisibilityRepository(),
deps.RepoLocator.GetOrganizationRepository(),
deps.PlanBuilder,
deps.ServiceBuilder,
)
deps.WordGenerator = generator.NewWordGenerator()
deps.AppZipper = appfiles.ApplicationZipper{}
deps.AppFiles = appfiles.ApplicationFiles{}
deps.PushActor = actors.NewPushActor(deps.RepoLocator.GetApplicationBitsRepository(), deps.AppZipper, deps.AppFiles)
deps.RouteActor = actors.NewRouteActor(deps.UI, deps.RepoLocator.GetRouteRepository())
deps.ChecksumUtil = utils.NewSha1Checksum("")
deps.Logger = logger
return deps
}