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
}