func (repo *FakeRouteRepository) FindByHostAndDomain(host, domain string) (route models.Route, apiErr error) {
repo.FindByHostAndDomainHost = host
repo.FindByHostAndDomainDomain = domain
if repo.FindByHostAndDomainErr {
apiErr = errors.NewModelNotFoundError("Route", host)
}
if repo.FindByHostAndDomainNotFound {
apiErr = errors.NewModelNotFoundError("Org", host+"."+domain)
}
route = repo.FindByHostAndDomainRoute
return
}
func (repo CloudControllerServiceRepository) FindInstanceByName(name string) (instance models.ServiceInstance, apiErr errors.Error) {
path := fmt.Sprintf("%s/v2/spaces/%s/service_instances?return_user_provided_service_instances=true&q=%s&inline-relations-depth=1", repo.config.ApiEndpoint(), repo.config.SpaceFields().Guid, url.QueryEscape("name:"+name))
resources := new(PaginatedServiceInstanceResources)
apiErr = repo.gateway.GetResource(path, repo.config.AccessToken(), resources)
if apiErr != nil {
return
}
if len(resources.Resources) == 0 {
apiErr = errors.NewModelNotFoundError("Service instance", name)
return
}
instanceResource := resources.Resources[0]
instance = instanceResource.ToModel()
if instanceResource.Entity.ServicePlan.Metadata.Guid != "" {
resource := &ServiceOfferingResource{}
path = fmt.Sprintf("%s/v2/services/%s", repo.config.ApiEndpoint(), instanceResource.Entity.ServicePlan.Entity.ServiceOfferingGuid)
apiErr = repo.gateway.GetResource(path, repo.config.AccessToken(), resource)
instance.ServiceOffering = resource.ToFields()
}
return
}
func (repo *FakeUserRepository) FindByUsername(username string) (user models.UserFields, apiErr error) {
repo.FindByUsernameUsername = username
user = repo.FindByUsernameUserFields
if repo.FindByUsernameNotFound {
apiErr = errors.NewModelNotFoundError("User", "")
}
return
}
func (repo *FakeServiceBrokerRepo) FindByName(name string) (serviceBroker models.ServiceBroker, apiErr errors.Error) {
repo.FindByNameName = name
serviceBroker = repo.FindByNameServiceBroker
if repo.FindByNameNotFound {
apiErr = errors.NewModelNotFoundError("Service Broker", name)
}
return
}
func (repo *FakeBuildpackRepository) FindByName(name string) (buildpack models.Buildpack, apiErr error) {
repo.FindByNameName = name
buildpack = repo.FindByNameBuildpack
if repo.FindByNameNotFound {
apiErr = errors.NewModelNotFoundError("Buildpack", name)
}
return
}
func (repo *FakeQuotaRepository) FindByName(name string) (quota models.QuotaFields, apiErr error) {
repo.FindByNameName = name
quota = repo.FindByNameQuota
if repo.FindByNameNotFound {
apiErr = errors.NewModelNotFoundError("Org", name)
}
if repo.FindByNameErr {
apiErr = errors.New("Error finding quota")
}
return
}
func (repo CloudControllerServiceRepository) FindServiceOfferingByLabelAndProvider(label, provider string) (models.ServiceOffering, error) {
path := fmt.Sprintf("/v2/services?q=%s", url.QueryEscape("label:"+label+";provider:"+provider))
offerings, apiErr := repo.getServiceOfferings(path)
if apiErr != nil {
return models.ServiceOffering{}, apiErr
} else if len(offerings) == 0 {
apiErr = errors.NewModelNotFoundError("Service offering", label+" "+provider)
return models.ServiceOffering{}, apiErr
}
return offerings[0], apiErr
}
func (repo CloudControllerDomainRepository) FindByNameInOrg(name string, orgGuid string) (domain models.DomainFields, apiErr error) {
domain, apiErr = repo.findOneWithPath(repo.strategy.OrgDomainURL(orgGuid, name), name)
switch apiErr.(type) {
case *errors.ModelNotFoundError:
domain, apiErr = repo.FindByName(name)
if !domain.Shared {
apiErr = errors.NewModelNotFoundError("Domain", name)
}
}
return
}
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 CloudControllerDomainRepository) findOneWithPath(path, name string) (domain models.DomainFields, apiErr error) {
foundDomain := false
apiErr = repo.listDomains(path, func(result models.DomainFields) bool {
domain = result
foundDomain = true
return false
})
if apiErr == nil && !foundDomain {
apiErr = errors.NewModelNotFoundError("Domain", name)
}
return
}
func (repo CloudControllerServiceRepository) FindServiceOfferingsForSpaceByLabel(spaceGuid, name string) (offerings models.ServiceOfferings, err error) {
offerings, err = repo.getServiceOfferings(
fmt.Sprintf("/v2/spaces/%s/services?q=%s&inline-relations-depth=1", spaceGuid, url.QueryEscape("label:"+name)))
if httpErr, ok := err.(errors.HttpError); ok && httpErr.ErrorCode() == errors.BAD_QUERY_PARAM {
offerings, err = repo.findServiceOfferingsByPaginating(spaceGuid, name)
}
if err == nil && len(offerings) == 0 {
err = errors.NewModelNotFoundError("Service offering", name)
}
return
}
func (repo CloudControllerServiceRepository) FindServiceOfferingByLabelAndProvider(label, provider string) (offering models.ServiceOffering, apiErr errors.Error) {
path := fmt.Sprintf("%s/v2/services?q=%s", repo.config.ApiEndpoint(), url.QueryEscape("label:"+label+";provider:"+provider))
resources := new(PaginatedServiceOfferingResources)
apiErr = repo.gateway.GetResource(path, repo.config.AccessToken(), resources)
if apiErr != nil {
return
} else if len(resources.Resources) == 0 {
apiErr = errors.NewModelNotFoundError("Service offering", label+" "+provider)
} else {
offering = resources.Resources[0].ToModel()
}
return
}
func (repo CloudControllerDomainRepository) FindByNameInOrg(name string, orgGuid string) (domain models.DomainFields, apiErr error) {
domain, apiErr = repo.findOneWithPath(
fmt.Sprintf("/v2/organizations/%s/domains?inline-relations-depth=1&q=%s", orgGuid, url.QueryEscape("name:"+name)),
name)
switch apiErr.(type) {
case errors.ModelNotFoundError:
domain, apiErr = repo.FindByName(name)
if !domain.Shared {
apiErr = errors.NewModelNotFoundError("Domain", name)
}
}
return
}
func (repo CloudControllerQuotaRepository) FindByName(name string) (quota models.QuotaFields, apiErr error) {
path := fmt.Sprintf("%s/v2/quota_definitions?q=%s", repo.config.ApiEndpoint(), url.QueryEscape("name:"+name))
quotas, apiErr := repo.findAllWithPath(path)
if apiErr != nil {
return
}
if len(quotas) == 0 {
apiErr = errors.NewModelNotFoundError("Quota", name)
return
}
quota = quotas[0]
return
}
func (repo CloudControllerServiceAuthTokenRepository) FindByLabelAndProvider(label, provider string) (authToken models.ServiceAuthTokenFields, apiErr errors.Error) {
path := fmt.Sprintf("%s/v2/service_auth_tokens?q=%s", repo.config.ApiEndpoint(), url.QueryEscape("label:"+label+";provider:"+provider))
authTokens, apiErr := repo.findAllWithPath(path)
if apiErr != nil {
return
}
if len(authTokens) == 0 {
apiErr = errors.NewModelNotFoundError("Service Auth Token", label+" "+provider)
return
}
authToken = authTokens[0]
return
}
func (repo CloudControllerStackRepository) FindByName(name string) (stack models.Stack, apiErr error) {
path := fmt.Sprintf("/v2/stacks?q=%s", url.QueryEscape("name:"+name))
stacks, apiErr := repo.findAllWithPath(path)
if apiErr != nil {
return
}
if len(stacks) == 0 {
apiErr = errors.NewModelNotFoundError("Stack", name)
return
}
stack = stacks[0]
return
}
func (repo *FakeApplicationRepository) Read(name string) (app models.Application, apiErr error) {
repo.ReadName = name
app = repo.ReadApp
if repo.ReadErr {
apiErr = errors.New("Error finding app by name.")
}
if repo.ReadAuthErr {
apiErr = errors.NewHttpError(401, "1000", "Authentication failed.")
}
if repo.ReadNotFound {
apiErr = errors.NewModelNotFoundError("App", name)
}
return
}
func (repo CloudControllerBuildpackRepository) FindByName(name string) (buildpack models.Buildpack, apiErr error) {
foundIt := false
apiErr = repo.gateway.ListPaginatedResources(
repo.config.ApiEndpoint(),
fmt.Sprintf("%s?q=%s", buildpacks_path, url.QueryEscape("name:"+name)),
resources.BuildpackResource{},
func(resource interface{}) bool {
buildpack = resource.(resources.BuildpackResource).ToFields()
foundIt = true
return false
})
if !foundIt {
apiErr = errors.NewModelNotFoundError("Buildpack", name)
}
return
}
func (repo CloudControllerApplicationRepository) Read(name string) (app models.Application, apiErr error) {
path := fmt.Sprintf("%s/v2/spaces/%s/apps?q=%s&inline-relations-depth=1", repo.config.ApiEndpoint(), repo.config.SpaceFields().Guid, url.QueryEscape("name:"+name))
appResources := new(resources.PaginatedApplicationResources)
apiErr = repo.gateway.GetResource(path, appResources)
if apiErr != nil {
return
}
if len(appResources.Resources) == 0 {
apiErr = errors.NewModelNotFoundError("App", name)
return
}
res := appResources.Resources[0]
app = res.ToModel()
return
}
func (repo CloudControllerOrganizationRepository) FindByName(name string) (org models.Organization, apiErr error) {
found := false
apiErr = repo.gateway.ListPaginatedResources(
repo.config.ApiEndpoint(),
fmt.Sprintf("/v2/organizations?q=%s&inline-relations-depth=1", url.QueryEscape("name:"+strings.ToLower(name))),
resources.OrganizationResource{},
func(resource interface{}) bool {
org = resource.(resources.OrganizationResource).ToModel()
found = true
return false
})
if !found {
apiErr = errors.NewModelNotFoundError("Organization", name)
}
return
}
func (repo CloudControllerUserRepository) FindByUsername(username string) (user models.UserFields, apiErr error) {
uaaEndpoint, apiErr := repo.getAuthEndpoint()
if apiErr != nil {
return
}
usernameFilter := neturl.QueryEscape(fmt.Sprintf(`userName Eq "%s"`, username))
path := fmt.Sprintf("%s/Users?attributes=id,userName&filter=%s", uaaEndpoint, usernameFilter)
users, apiErr := repo.updateOrFindUsersWithUAAPath([]models.UserFields{}, path)
if len(users) == 0 {
apiErr = errors.NewModelNotFoundError("User", username)
return
}
user = users[0]
return
}
func (repo CloudControllerServiceBrokerRepository) FindByName(name string) (serviceBroker models.ServiceBroker, apiErr error) {
foundBroker := false
apiErr = repo.gateway.ListPaginatedResources(
repo.config.ApiEndpoint(),
fmt.Sprintf("/v2/service_brokers?q=%s", url.QueryEscape("name:"+name)),
resources.ServiceBrokerResource{},
func(resource interface{}) bool {
serviceBroker = resource.(resources.ServiceBrokerResource).ToFields()
foundBroker = true
return false
})
if !foundBroker {
apiErr = errors.NewModelNotFoundError("Service Broker", name)
}
return
}
func (repo CloudControllerSpaceRepository) FindByNameInOrg(name, orgGuid string) (space models.Space, apiErr error) {
foundSpace := false
apiErr = repo.gateway.ListPaginatedResources(
repo.config.ApiEndpoint(),
fmt.Sprintf("/v2/organizations/%s/spaces?q=%s&inline-relations-depth=1", orgGuid, url.QueryEscape("name:"+strings.ToLower(name))),
resources.SpaceResource{},
func(resource interface{}) bool {
space = resource.(resources.SpaceResource).ToModel()
foundSpace = true
return false
})
if !foundSpace {
apiErr = errors.NewModelNotFoundError("Space", name)
}
return
}
func (repo CloudControllerRouteRepository) FindByHost(host string) (route models.Route, apiErr error) {
found := false
apiErr = repo.gateway.ListPaginatedResources(
repo.config.ApiEndpoint(),
repo.config.AccessToken(),
fmt.Sprintf("/v2/routes?inline-relations-depth=1&q=%s", url.QueryEscape("host:"+host)),
RouteResource{},
func(resource interface{}) bool {
route = resource.(RouteResource).ToModel()
found = true
return false
})
if apiErr == nil && !found {
apiErr = errors.NewModelNotFoundError("Route", host)
}
return
}
func (repo *FakeServiceRepo) FindInstanceByName(name string) (instance models.ServiceInstance, apiErr 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.New("Error finding instance")
}
if repo.FindInstanceByNameNotFound {
apiErr = errors.NewModelNotFoundError("Service instance", name)
}
return
}
func (repo *FakeSpaceRepository) FindByName(name string) (space models.Space, apiErr 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.New("Error finding space by name.")
}
if repo.FindByNameNotFound {
apiErr = errors.NewModelNotFoundError("Space", name)
}
return
}
func (repo *FakeOrgRepository) FindByName(name string) (org models.Organization, apiErr 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.New("Error finding organization by name.")
}
if repo.FindByNameNotFound {
apiErr = errors.NewModelNotFoundError("Org", name)
}
return
}
func (repo CloudControllerRouteRepository) FindByHostAndDomain(host, domainName string) (route models.Route, apiErr error) {
domain, apiErr := repo.domainRepo.FindByName(domainName)
if apiErr != nil {
return
}
found := false
apiErr = repo.gateway.ListPaginatedResources(
repo.config.ApiEndpoint(),
fmt.Sprintf("/v2/routes?inline-relations-depth=1&q=%s", url.QueryEscape("host:"+host+";domain_guid:"+domain.Guid)),
resources.RouteResource{},
func(resource interface{}) bool {
route = resource.(resources.RouteResource).ToModel()
found = true
return false
})
if apiErr == nil && !found {
apiErr = errors.NewModelNotFoundError("Route", host)
}
return
}
func (repo CloudControllerServiceRepository) FindServicePlanByDescription(planDescription resources.ServicePlanDescription) (string, error) {
path := fmt.Sprintf("/v2/services?inline-relations-depth=1&q=%s",
url.QueryEscape("label:"+planDescription.ServiceLabel+";provider:"+planDescription.ServiceProvider))
var planGuid string
offerings, apiErr := repo.getServiceOfferings(path)
if apiErr != nil {
return planGuid, apiErr
}
for _, serviceOfferingResource := range offerings {
for _, servicePlanResource := range serviceOfferingResource.Plans {
if servicePlanResource.Name == planDescription.ServicePlanName {
planGuid := servicePlanResource.Guid
return planGuid, apiErr
}
}
}
apiErr = errors.NewModelNotFoundError("Plan", planDescription.String())
return planGuid, apiErr
}
func (repo CloudControllerServiceRepository) FindServicePlanByDescription(planDescription ServicePlanDescription) (planGuid string, apiErr errors.Error) {
path := fmt.Sprintf("%s/v2/services?inline-relations-depth=1&q=%s",
repo.config.ApiEndpoint(),
url.QueryEscape("label:"+planDescription.ServiceLabel+";provider:"+planDescription.ServiceProvider))
response := new(PaginatedServiceOfferingResources)
apiErr = repo.gateway.GetResource(path, repo.config.AccessToken(), response)
if apiErr != nil {
return
}
for _, serviceOfferingResource := range response.Resources {
for _, servicePlanResource := range serviceOfferingResource.Entity.ServicePlans {
if servicePlanResource.Entity.Name == planDescription.ServicePlanName {
planGuid = servicePlanResource.Metadata.Guid
return
}
}
}
apiErr = errors.NewModelNotFoundError("Plan", planDescription.String())
return
}