func (cmd CreateBuildpack) createBuildpack(buildpackName string, c *cli.Context) (buildpack models.Buildpack, apiErr error) { position, err := strconv.Atoi(c.Args()[2]) if err != nil { apiErr = errors.NewWithFmt(T("Invalid position. {{.ErrorDescription}}", map[string]interface{}{"ErrorDescription": err.Error()})) return } enabled := c.Bool("enable") disabled := c.Bool("disable") if enabled && disabled { apiErr = errors.New(T("Cannot specify both {{.Enabled}} and {{.Disabled}}.", map[string]interface{}{ "Enabled": "enabled", "Disabled": "disabled", })) return } var enableOption *bool = nil if enabled { enableOption = &enabled } if disabled { disabled = false enableOption = &disabled } buildpack, apiErr = cmd.buildpackRepo.Create(buildpackName, &position, enableOption, nil) return }
func (repo CloudControllerServiceRepository) DeleteService(instance models.ServiceInstance) (apiErr error) { if len(instance.ServiceBindings) > 0 { return errors.New("Cannot delete service instance, apps are still bound to it") } path := fmt.Sprintf("%s/v2/service_instances/%s", repo.config.ApiEndpoint(), instance.Guid) return repo.gateway.DeleteResource(path) }
func (repo CloudControllerUserRepository) getAuthEndpoint() (string, error) { uaaEndpoint := repo.config.UaaEndpoint() if uaaEndpoint == "" { return "", errors.New(T("UAA endpoint missing from config file")) } return uaaEndpoint, nil }
func (repo ManifestDiskRepository) readAllYAMLFiles(path string) (mergedMap generic.Map, err error) { file, err := os.Open(filepath.Clean(path)) if err != nil { return } defer file.Close() mapp, err := parseManifest(file) if err != nil { return } if !mapp.Has("inherit") { mergedMap = mapp return } inheritedPath, ok := mapp.Get("inherit").(string) if !ok { err = errors.New(T("invalid inherit path in manifest")) return } if !filepath.IsAbs(inheritedPath) { inheritedPath = filepath.Join(filepath.Dir(path), inheritedPath) } inheritedMap, err := repo.readAllYAMLFiles(inheritedPath) if err != nil { return } mergedMap = generic.DeepMerge(inheritedMap, mapp) return }
func (m Manifest) getAppMaps(data generic.Map) (apps []generic.Map, errs []error) { globalProperties := data.Except([]interface{}{"applications"}) if data.Has("applications") { appMaps, ok := data.Get("applications").([]interface{}) if !ok { errs = append(errs, errors.New(T("Expected applications to be a list"))) return } for _, appData := range appMaps { if !generic.IsMappable(appData) { errs = append(errs, errors.NewWithFmt(T("Expected application to be a list of key/value pairs\nError occurred in manifest near:\n'{{.YmlSnippet}}'", map[string]interface{}{"YmlSnippet": appData}))) continue } appMap := generic.DeepMerge(globalProperties, generic.NewMap(appData)) apps = append(apps, appMap) } } else { apps = append(apps, globalProperties) } return }
func (gateway Gateway) waitForJob(jobUrl, accessToken string, timeout time.Duration) (err error) { startTime := gateway.Clock() for true { if gateway.Clock().Sub(startTime) > timeout && timeout != 0 { return errors.NewAsyncTimeoutError(jobUrl) } var request *Request request, err = gateway.NewRequest("GET", jobUrl, accessToken, nil) response := &JobResource{} _, err = gateway.PerformRequestForJSONResponse(request, response) if err != nil { return } switch response.Entity.Status { case JOB_FINISHED: return case JOB_FAILED: err = errors.New(response.Entity.ErrorDetails.Description) return } accessToken = request.HttpReq.Header.Get("Authorization") time.Sleep(gateway.PollingThrottle) } return }
func (repo *FakeBuildpackBitsRepository) UploadBuildpack(buildpack models.Buildpack, dir string) error { if repo.UploadBuildpackErr { return errors.New("Invalid buildpack") } repo.UploadBuildpackPath = dir return repo.UploadBuildpackApiResponse }
func (repo *FakeZoneRepository) Update(zoneGuid string, params models.ZoneParams) (apiErr error) { repo.UpdateZoneGuid = zoneGuid repo.UpdateZoneParams = params if repo.UpdateErr { apiErr = errors.New("Error updating zone.") } return }
func normalizeBuildpackArchive(inputFile *os.File, outputFile *os.File) error { stats, err := inputFile.Stat() if err != nil { return err } reader, err := zip.NewReader(inputFile, stats.Size()) if err != nil { return err } contents := reader.File parentPath, hasBuildpack := findBuildpackPath(contents) if !hasBuildpack { return errors.New(T("Zip archive does not contain a buildpack")) } writer := zip.NewWriter(outputFile) for _, file := range contents { name := file.Name if strings.HasPrefix(name, parentPath) { relativeFilename := strings.TrimPrefix(name, parentPath+"/") if relativeFilename == "" { continue } fileInfo := file.FileInfo() header, err := zip.FileInfoHeader(fileInfo) if err != nil { return err } header.Name = relativeFilename w, err := writer.CreateHeader(header) if err != nil { return err } r, err := file.Open() if err != nil { return err } io.Copy(w, r) err = r.Close() if err != nil { return err } } } writer.Close() outputFile.Seek(0, 0) return nil }
func (repo *FakeApplicationRepository) Update(appGuid string, params models.AppParams) (updatedApp models.Application, apiErr error) { repo.UpdateAppGuid = appGuid repo.UpdateParams = params updatedApp = repo.UpdateAppResult if repo.UpdateErr { apiErr = errors.New("Error updating app.") } return }
func validateEnvVars(input generic.Map) (errs []error) { generic.Each(input, func(key, value interface{}) { if value == nil { errs = append(errs, errors.New(fmt.Sprintf(T("env var '{{.PropertyName}}' should not be null", map[string]interface{}{"PropertyName": key})))) } }) return }
func PrepareRedirect(req *http.Request, via []*http.Request) error { if len(via) > 1 { return errors.New(T("stopped after 1 redirect")) } prevReq := via[len(via)-1] req.Header.Set("Authorization", prevReq.Header.Get("Authorization")) dumpRequest(req) return nil }
func (repo *FakeServiceRepo) UpdateServiceInstance(instanceGuid, planGuid string) (apiErr error) { if repo.UpdateServiceInstanceReturnsErr { apiErr = errors.New("Error updating service instance") } else { repo.UpdateServiceInstanceArgs.InstanceGuid = instanceGuid repo.UpdateServiceInstanceArgs.PlanGuid = planGuid } return }
func addApp(apps *[]models.AppParams, app models.AppParams) (err error) { if app.Name == nil { err = errors.New(T("App name is a required field")) } if app.Path == nil { cwd, _ := os.Getwd() app.Path = &cwd } *apps = append(*apps, app) return }
func (repo CloudControllerPasswordRepository) UpdatePassword(old string, new string) error { uaaEndpoint := repo.config.UaaEndpoint() if uaaEndpoint == "" { return errors.New(T("UAA endpoint missing from config file")) } url := fmt.Sprintf("%s/Users/%s/password", uaaEndpoint, repo.config.UserGuid()) body := fmt.Sprintf(`{"password":"******","oldPassword":"******"}`, new, old) return repo.gateway.UpdateResource(url, strings.NewReader(body)) }
func (cmd DeleteUser) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) { if len(c.Args()) != 1 { err = errors.New(T("Invalid usage")) cmd.ui.FailWithUsage(c) return } reqs = append(reqs, requirementsFactory.NewLoginRequirement()) return }
func (cmd *DeleteQuota) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) { if len(c.Args()) != 1 { err = errors.New(T("Incorrect Usage")) cmd.ui.FailWithUsage(c) return } reqs = []requirements.Requirement{ requirementsFactory.NewLoginRequirement(), } return }
func (repo *FakeRouteRepository) ListRoutes(cb func(models.Route) bool) (apiErr error) { if repo.ListErr { return errors.New("WHOOPSIE") } for _, route := range repo.Routes { if !cb(route) { break } } return }
func findAppWithNameInManifest(name string, manifestApps []models.AppParams) (app models.AppParams, err error) { for _, appParams := range manifestApps { if appParams.Name != nil && *appParams.Name == name { app = appParams return } } err = errors.New(T("Could not find app named '{{.AppName}}' in manifest", map[string]interface{}{"AppName": name})) return }
func (repo CloudControllerDomainRepository) defaultDomain(orgGuid string) (models.DomainFields, error) { var foundDomain *models.DomainFields repo.ListDomainsForOrg(orgGuid, func(domain models.DomainFields) bool { foundDomain = &domain return !domain.Shared }) if foundDomain == nil { return models.DomainFields{}, errors.New(T("Could not find a default domain")) } return *foundDomain, nil }
func (repo *FakeDomainRepository) FindByName(name string) (domain models.DomainFields, apiErr error) { repo.FindByNameName = name domain = repo.FindByNameDomain if repo.FindByNameNotFound { apiErr = errors.NewModelNotFoundError("Domain", name) } if repo.FindByNameErr { apiErr = errors.New("Error finding domain") } return }
func (repo *FakeRouteRepository) CreateInSpace(host, domainGuid, spaceGuid string) (createdRoute models.Route, apiErr error) { repo.CreateInSpaceHost = host repo.CreateInSpaceDomainGuid = domainGuid repo.CreateInSpaceSpaceGuid = spaceGuid if repo.CreateInSpaceErr { apiErr = errors.New("Error") } else { createdRoute = repo.CreateInSpaceCreatedRoute } return }
func (repo *FakeServiceBrokerRepo) ListServiceBrokers(callback func(broker models.ServiceBroker) bool) error { for _, broker := range repo.ServiceBrokers { if !callback(broker) { break } } if repo.ListErr { return errors.New("Error finding service brokers") } else { return nil } }
func findPlanFromOfferings(offerings models.ServiceOfferings, name string) (plan models.ServicePlanFields, err error) { for _, offering := range offerings { for _, plan := range offering.Plans { if name == plan.Name { return plan, nil } } } err = errors.New(T("Could not find plan with name {{.ServicePlanName}}", map[string]interface{}{"ServicePlanName": name}, )) return }
func findOfferings(offerings []models.ServiceOffering, name string) (matchingOfferings models.ServiceOfferings, err error) { for _, offering := range offerings { if name == offering.Label { matchingOfferings = append(matchingOfferings, offering) } } if len(matchingOfferings) == 0 { err = errors.New(T("Could not find any offerings with name {{.ServiceOfferingName}}", map[string]interface{}{"ServiceOfferingName": name}, )) } return }
func (cmd Target) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) { if len(c.Args()) != 0 { err = errors.New(T("incorrect usage")) cmd.ui.FailWithUsage(c) return } reqs = append(reqs, requirementsFactory.NewApiEndpointRequirement()) if c.String("o") != "" || c.String("s") != "" { reqs = append(reqs, requirementsFactory.NewLoginRequirement()) } return }
func parseManifest(file io.Reader) (yamlMap generic.Map, err error) { decoder := candiedyaml.NewDecoder(file) yamlMap = generic.NewMap() err = decoder.Decode(yamlMap) if err != nil { return } if !generic.IsMappable(yamlMap) { err = errors.New(T("Invalid manifest. Expected a map")) return } return }
func (cmd Target) setSpace(spaceName string) error { cmd.config.SetSpaceFields(models.SpaceFields{}) if !cmd.config.HasOrganization() { return errors.New(T("An org must be targeted before targeting a space")) } space, apiErr := cmd.spaceRepo.FindByName(spaceName) if apiErr != nil { return errors.NewWithFmt(T("Unable to access space {{.SpaceName}}.\n{{.ApiErr}}", map[string]interface{}{"SpaceName": spaceName, "ApiErr": apiErr.Error()})) } cmd.config.SetSpaceFields(space.SpaceFields) return nil }
func (auth *FakeAuthenticationRepository) Authenticate(credentials map[string]string) (apiErr error) { auth.AuthenticateArgs.Credentials = append(auth.AuthenticateArgs.Credentials, copyMap(credentials)) if auth.AuthError { apiErr = errors.New("Error authenticating.") return } if auth.AccessToken == "" { auth.AccessToken = "BEARER some_access_token" } auth.Config.SetAccessToken(auth.AccessToken) auth.Config.SetRefreshToken(auth.RefreshToken) return }
func (uaa UAAAuthenticationRepository) Authenticate(credentials map[string]string) (apiErr error) { data := url.Values{ "grant_type": {"password"}, "scope": {""}, } for key, val := range credentials { data[key] = []string{val} } apiErr = uaa.getAuthToken(data) switch response := apiErr.(type) { case errors.HttpError: if response.StatusCode() == 401 { apiErr = errors.New(T("Credentials were rejected, please try again.")) } } return }