Esempio n. 1
0
func (cmd CreateBuildpack) createBuildpack(buildpackName string, c *cli.Context) (buildpack models.Buildpack, apiErr errors.Error) {
	position, err := strconv.Atoi(c.Args()[2])
	if err != nil {
		apiErr = errors.NewErrorWithMessage("Invalid position. %s", err.Error())
		return
	}

	enabled := c.Bool("enable")
	disabled := c.Bool("disable")
	if enabled && disabled {
		apiErr = errors.NewErrorWithMessage("Cannot specify both enabled and 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
}
Esempio n. 2
0
func (repo CloudControllerApplicationBitsRepository) UploadApp(appGuid string, appDir string, cb func(path string, zipSize, fileCount uint64)) (apiErr errors.Error) {
	fileutils.TempDir("apps", func(uploadDir string, err error) {
		if err != nil {
			apiErr = errors.NewErrorWithMessage(err.Error())
			return
		}

		var presentResourcesJson []byte
		repo.sourceDir(appDir, func(sourceDir string, sourceErr error) {
			if sourceErr != nil {
				err = sourceErr
				return
			}
			presentResourcesJson, err = repo.copyUploadableFiles(sourceDir, uploadDir)
		})

		if err != nil {
			apiErr = errors.NewErrorWithMessage("%s", err)
			return
		}

		fileutils.TempFile("uploads", func(zipFile *os.File, err error) {
			if err != nil {
				apiErr = errors.NewErrorWithMessage("%s", err.Error())
				return
			}

			err = repo.zipper.Zip(uploadDir, zipFile)
			if err != nil {
				apiErr = errors.NewErrorWithError("Error zipping application", err)
				return
			}

			stat, err := zipFile.Stat()
			if err != nil {
				apiErr = errors.NewErrorWithError("Error zipping application", err)
				return
			}
			cb(appDir, uint64(stat.Size()), app_files.CountFiles(uploadDir))

			apiErr = repo.uploadBits(appGuid, zipFile, presentResourcesJson)
			if apiErr != nil {
				return
			}
		})
	})
	return
}
Esempio n. 3
0
func (repo CloudControllerUserRepository) getAuthEndpoint() (string, errors.Error) {
	uaaEndpoint := repo.config.UaaEndpoint()
	if uaaEndpoint == "" {
		return "", errors.NewErrorWithMessage("UAA endpoint missing from config file")
	}
	return uaaEndpoint, nil
}
Esempio n. 4
0
func (gateway Gateway) waitForJob(jobUrl, accessToken string, timeout time.Duration) (apiErr errors.Error) {
	startTime := time.Now()
	for true {
		if time.Since(startTime) > timeout {
			apiErr = errors.NewErrorWithMessage("Error: timed out waiting for async job '%s' to finish", jobUrl)
			return
		}

		var request *Request
		request, apiErr = gateway.NewRequest("GET", jobUrl, accessToken, nil)
		response := &JobResponse{}

		_, apiErr = gateway.PerformRequestForJSONResponse(request, response)
		if apiErr != nil {
			return
		}

		switch response.Entity.Status {
		case JOB_FINISHED:
			return
		case JOB_FAILED:
			apiErr = errors.NewError("Job failed", JOB_FAILED)
			return
		}

		accessToken = request.HttpReq.Header.Get("Authorization")

		time.Sleep(gateway.PollingThrottle)
	}
	return
}
Esempio n. 5
0
func (repo CloudControllerServiceRepository) DeleteService(instance models.ServiceInstance) (apiErr errors.Error) {
	if len(instance.ServiceBindings) > 0 {
		return errors.NewErrorWithMessage("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, repo.config.AccessToken())
}
Esempio n. 6
0
func (repo *FakeBuildpackBitsRepository) UploadBuildpack(buildpack models.Buildpack, dir string) errors.Error {
	if repo.UploadBuildpackErr {
		return errors.NewErrorWithMessage("Invalid buildpack")
	}

	repo.UploadBuildpackPath = dir
	return repo.UploadBuildpackApiResponse
}
Esempio n. 7
0
func (repo RemoteEndpointRepository) GetCloudControllerEndpoint() (endpoint string, apiErr errors.Error) {
	if repo.config.ApiEndpoint() == "" {
		apiErr = errors.NewErrorWithMessage("Target endpoint missing from config file")
		return
	}

	endpoint = repo.config.ApiEndpoint()
	return
}
Esempio n. 8
0
func (repo *FakeApplicationRepository) Update(appGuid string, params models.AppParams) (updatedApp models.Application, apiErr errors.Error) {
	repo.UpdateAppGuid = appGuid
	repo.UpdateParams = params
	updatedApp = repo.UpdateAppResult
	if repo.UpdateErr {
		apiErr = errors.NewErrorWithMessage("Error updating app.")
	}
	return
}
Esempio n. 9
0
func (repo RemoteEndpointRepository) GetUAAEndpoint() (endpoint string, apiErr errors.Error) {
	if repo.config.AuthorizationEndpoint() == "" {
		apiErr = errors.NewErrorWithMessage("UAA endpoint missing from config file")
		return
	}

	endpoint = strings.Replace(repo.config.AuthorizationEndpoint(), "login", "uaa", 1)

	return
}
Esempio n. 10
0
func (repo *FakeRouteRepository) FindByHost(host string) (route models.Route, apiErr errors.Error) {
	repo.FindByHostHost = host

	if repo.FindByHostErr {
		apiErr = errors.NewErrorWithMessage("Route not found")
	}

	route = repo.FindByHostRoute
	return
}
Esempio n. 11
0
func (repo CloudControllerUserRepository) checkSpaceRole(userGuid, spaceGuid, role string) (fullPath string, apiErr errors.Error) {
	rolePath, found := spaceRoleToPathMap[role]

	if !found {
		apiErr = errors.NewErrorWithMessage("Invalid Role %s", role)
	}

	fullPath = fmt.Sprintf("%s/v2/spaces/%s/%s/%s", repo.config.ApiEndpoint(), spaceGuid, rolePath, userGuid)
	return
}
Esempio n. 12
0
func (repo CloudControllerPasswordRepository) UpdatePassword(old string, new string) errors.Error {
	uaaEndpoint := repo.config.UaaEndpoint()
	if uaaEndpoint == "" {
		return errors.NewErrorWithMessage("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, repo.config.AccessToken(), strings.NewReader(body))
}
Esempio n. 13
0
func (repo *FakeRouteRepository) ListRoutes(cb func(models.Route) bool) (apiErr errors.Error) {
	if repo.ListErr {
		return errors.NewErrorWithMessage("WHOOPSIE")
	}

	for _, route := range repo.Routes {
		if !cb(route) {
			break
		}
	}
	return
}
Esempio n. 14
0
func (repo *FakeQuotaRepository) FindByName(name string) (quota models.QuotaFields, apiErr errors.Error) {
	repo.FindByNameName = name
	quota = repo.FindByNameQuota

	if repo.FindByNameNotFound {
		apiErr = errors.NewModelNotFoundError("Org", name)
	}
	if repo.FindByNameErr {
		apiErr = errors.NewErrorWithMessage("Error finding quota")
	}

	return
}
Esempio n. 15
0
func (cmd Target) setOrganization(orgName string) error {
	// setting an org necessarily invalidates any space you had previously targeted
	cmd.config.SetOrganizationFields(models.OrganizationFields{})
	cmd.config.SetSpaceFields(models.SpaceFields{})

	org, apiErr := cmd.orgRepo.FindByName(orgName)
	if apiErr != nil {
		return errors.NewErrorWithMessage("Could not target org.\n%s", apiErr.Error())
	}

	cmd.config.SetOrganizationFields(org.OrganizationFields)
	return nil
}
Esempio n. 16
0
func (repo *FakeRouteRepository) CreateInSpace(host, domainGuid, spaceGuid string) (createdRoute models.Route, apiErr errors.Error) {
	repo.CreateInSpaceHost = host
	repo.CreateInSpaceDomainGuid = domainGuid
	repo.CreateInSpaceSpaceGuid = spaceGuid

	if repo.CreateInSpaceErr {
		apiErr = errors.NewErrorWithMessage("Error")
	} else {
		createdRoute = repo.CreateInSpaceCreatedRoute
	}

	return
}
Esempio n. 17
0
func (repo *FakeDomainRepository) FindByName(name string) (domain models.DomainFields, apiErr errors.Error) {
	repo.FindByNameName = name
	domain = repo.FindByNameDomain

	if repo.FindByNameNotFound {
		apiErr = errors.NewModelNotFoundError("Domain", name)
	}
	if repo.FindByNameErr {
		apiErr = errors.NewErrorWithMessage("Error finding domain")
	}

	return
}
Esempio n. 18
0
func (repo *FakeServiceBrokerRepo) ListServiceBrokers(callback func(broker models.ServiceBroker) bool) errors.Error {
	for _, broker := range repo.ServiceBrokers {
		if !callback(broker) {
			break
		}
	}

	if repo.ListErr {
		return errors.NewErrorWithMessage("Error finding service brokers")
	} else {
		return nil
	}
}
Esempio n. 19
0
func (repo RemoteEndpointRepository) GetLoggregatorEndpoint() (endpoint string, apiErr errors.Error) {
	if repo.config.LoggregatorEndpoint() == "" {
		if repo.config.ApiEndpoint() == "" {
			apiErr = errors.NewErrorWithMessage("Loggregator endpoint missing from config file")
		} else {
			endpoint = defaultLoggregatorEndpoint(repo.config.ApiEndpoint())
		}
	} else {
		endpoint = repo.config.LoggregatorEndpoint()
	}

	return
}
Esempio n. 20
0
func (repo *FakeApplicationBitsRepository) UploadApp(appGuid, dir string, cb func(path string, zipSize, fileCount uint64)) (apiErr errors.Error) {
	repo.UploadedDir = dir
	repo.UploadedAppGuid = appGuid

	if repo.UploadAppErr {
		apiErr = errors.NewErrorWithMessage("Error uploading app")
		return
	}

	cb(repo.CallbackPath, repo.CallbackZipSize, repo.CallbackFileCount)

	return
}
Esempio n. 21
0
func (cmd Target) setSpace(spaceName string) error {
	cmd.config.SetSpaceFields(models.SpaceFields{})

	if !cmd.config.HasOrganization() {
		return errors.New("An org must be targeted before targeting a space")
	}

	space, apiErr := cmd.spaceRepo.FindByName(spaceName)
	if apiErr != nil {
		return errors.NewErrorWithMessage("Unable to access space %s.\n%s", spaceName, apiErr.Error())
	}

	cmd.config.SetSpaceFields(space.SpaceFields)
	return nil
}
Esempio n. 22
0
func (repo CloudControllerStackRepository) FindByName(name string) (stack models.Stack, apiErr errors.Error) {
	path := fmt.Sprintf("%s/v2/stacks?q=%s", repo.config.ApiEndpoint(), url.QueryEscape("name:"+name))
	stacks, apiErr := repo.findAllWithPath(path)
	if apiErr != nil {
		return
	}

	if len(stacks) == 0 {
		apiErr = errors.NewErrorWithMessage("Stack '%s' not found", name)
		return
	}

	stack = stacks[0]
	return
}
Esempio n. 23
0
func (repo *FakeRouteRepository) FindByHostAndDomain(host, domain string) (route models.Route, apiErr errors.Error) {
	repo.FindByHostAndDomainHost = host
	repo.FindByHostAndDomainDomain = domain

	if repo.FindByHostAndDomainErr {
		apiErr = errors.NewErrorWithMessage("Error finding Route")
	}

	if repo.FindByHostAndDomainNotFound {
		apiErr = errors.NewModelNotFoundError("Org", host+"."+domain)
	}

	route = repo.FindByHostAndDomainRoute
	return
}
Esempio n. 24
0
func (repo *FakeApplicationRepository) Read(name string) (app models.Application, apiErr errors.Error) {
	repo.ReadName = name
	app = repo.ReadApp

	if repo.ReadErr {
		apiErr = errors.NewErrorWithMessage("Error finding app by name.")
	}
	if repo.ReadAuthErr {
		apiErr = errors.NewHttpError(401, "", "", "1000", "Authentication failed.")
	}
	if repo.ReadNotFound {
		apiErr = errors.NewModelNotFoundError("App", name)
	}

	return
}
Esempio n. 25
0
func (auth *FakeAuthenticationRepository) Authenticate(credentials map[string]string) (apiErr errors.Error) {
	auth.AuthenticateArgs.Credentials = credentials

	if auth.AuthError {
		apiErr = errors.NewErrorWithMessage("Error authenticating.")
		return
	}

	if auth.AccessToken == "" {
		auth.AccessToken = "BEARER some_access_token"
	}

	auth.Config.SetAccessToken(auth.AccessToken)
	auth.Config.SetRefreshToken(auth.RefreshToken)

	return
}
Esempio n. 26
0
func (repo *FakeServiceRepo) FindInstanceByName(name string) (instance models.ServiceInstance, apiErr errors.Error) {
	repo.FindInstanceByNameName = name

	if repo.FindInstanceByNameMap != nil && repo.FindInstanceByNameMap.Has(name) {
		instance = repo.FindInstanceByNameMap.Get(name).(models.ServiceInstance)
	} else {
		instance = repo.FindInstanceByNameServiceInstance
	}

	if repo.FindInstanceByNameErr {
		apiErr = errors.NewErrorWithMessage("Error finding instance")
	}

	if repo.FindInstanceByNameNotFound {
		apiErr = errors.NewModelNotFoundError("Service instance", name)
	}

	return
}
Esempio n. 27
0
func (uaa UAAAuthenticationRepository) Authenticate(credentials map[string]string) (apiErr errors.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.NewErrorWithMessage("Password is incorrect, please try again.")
		}
	}

	return
}
Esempio n. 28
0
func (repo CloudControllerUserRepository) setOrUnsetOrgRole(verb, userGuid, orgGuid, role string) (apiErr errors.Error) {
	rolePath, found := orgRoleToPathMap[role]

	if !found {
		apiErr = errors.NewErrorWithMessage("Invalid Role %s", role)
		return
	}

	path := fmt.Sprintf("%s/v2/organizations/%s/%s/%s", repo.config.ApiEndpoint(), orgGuid, rolePath, userGuid)

	request, apiErr := repo.ccGateway.NewRequest(verb, path, repo.config.AccessToken(), nil)
	if apiErr != nil {
		return
	}

	apiErr = repo.ccGateway.PerformRequest(request)
	if apiErr != nil {
		return
	}
	return
}
Esempio n. 29
0
func (repo *FakeSpaceRepository) FindByName(name string) (space models.Space, apiErr errors.Error) {
	repo.FindByNameName = name

	var foundSpace bool = false
	for _, someSpace := range repo.Spaces {
		if name == someSpace.Name {
			foundSpace = true
			space = someSpace
			break
		}
	}

	if repo.FindByNameErr || !foundSpace {
		apiErr = errors.NewErrorWithMessage("Error finding space by name.")
	}

	if repo.FindByNameNotFound {
		apiErr = errors.NewModelNotFoundError("Space", name)
	}

	return
}
Esempio n. 30
0
func (repo *FakeOrgRepository) FindByName(name string) (org models.Organization, apiErr errors.Error) {
	repo.FindByNameName = name

	var foundOrg bool = false
	for _, anOrg := range repo.Organizations {
		if name == anOrg.Name {
			foundOrg = true
			org = anOrg
			break
		}
	}

	if repo.FindByNameErr || !foundOrg {
		apiErr = errors.NewErrorWithMessage("Error finding organization by name.")
	}

	if repo.FindByNameNotFound {
		apiErr = errors.NewModelNotFoundError("Org", name)
	}

	return
}