func NewRepositoryLocator(config coreconfig.ReadWriter, gatewaysByName map[string]net.Gateway, logger trace.Printer, envDialTimeout string) (loc RepositoryLocator) {
strategy := strategy.NewEndpointStrategy(config.APIVersion())
cloudControllerGateway := gatewaysByName["cloud-controller"]
routingAPIGateway := gatewaysByName["routing-api"]
uaaGateway := gatewaysByName["uaa"]
loc.authRepo = authentication.NewUAARepository(uaaGateway, config, net.NewRequestDumper(logger))
// ensure gateway refreshers are set before passing them by value to repositories
cloudControllerGateway.SetTokenRefresher(loc.authRepo)
uaaGateway.SetTokenRefresher(loc.authRepo)
loc.appBitsRepo = applicationbits.NewCloudControllerApplicationBitsRepository(config, cloudControllerGateway)
loc.appEventsRepo = appevents.NewCloudControllerAppEventsRepository(config, cloudControllerGateway, strategy)
loc.appFilesRepo = api_appfiles.NewCloudControllerAppFilesRepository(config, cloudControllerGateway)
loc.appRepo = applications.NewCloudControllerRepository(config, cloudControllerGateway)
loc.appSummaryRepo = NewCloudControllerAppSummaryRepository(config, cloudControllerGateway)
loc.appInstancesRepo = appinstances.NewCloudControllerAppInstancesRepository(config, cloudControllerGateway)
loc.authTokenRepo = NewCloudControllerServiceAuthTokenRepository(config, cloudControllerGateway)
loc.curlRepo = NewCloudControllerCurlRepository(config, cloudControllerGateway)
loc.domainRepo = NewCloudControllerDomainRepository(config, cloudControllerGateway, strategy)
loc.endpointRepo = NewEndpointRepository(cloudControllerGateway)
tlsConfig := net.NewTLSConfig([]tls.Certificate{}, config.IsSSLDisabled())
apiVersion, _ := semver.Make(config.APIVersion())
var noaaRetryTimeout time.Duration
convertedTime, err := strconv.Atoi(envDialTimeout)
if err != nil {
noaaRetryTimeout = noaaRetryDefaultTimeout
} else {
noaaRetryTimeout = time.Duration(convertedTime) * 3 * time.Second
}
if apiVersion.GTE(cf.NoaaMinimumAPIVersion) {
consumer := consumer.New(config.DopplerEndpoint(), tlsConfig, http.ProxyFromEnvironment)
consumer.SetDebugPrinter(terminal.DebugPrinter{Logger: logger})
loc.logsRepo = logs.NewNoaaLogsRepository(config, consumer, loc.authRepo, noaaRetryTimeout)
} else {
consumer := loggregator_consumer.New(config.LoggregatorEndpoint(), tlsConfig, http.ProxyFromEnvironment)
consumer.SetDebugPrinter(terminal.DebugPrinter{Logger: logger})
loc.logsRepo = logs.NewLoggregatorLogsRepository(config, consumer, loc.authRepo)
}
loc.organizationRepo = organizations.NewCloudControllerOrganizationRepository(config, cloudControllerGateway)
loc.passwordRepo = password.NewCloudControllerRepository(config, uaaGateway)
loc.quotaRepo = quotas.NewCloudControllerQuotaRepository(config, cloudControllerGateway)
loc.routeRepo = NewCloudControllerRouteRepository(config, cloudControllerGateway)
loc.routeServiceBindingRepo = NewCloudControllerRouteServiceBindingRepository(config, cloudControllerGateway)
loc.routingAPIRepo = NewRoutingAPIRepository(config, routingAPIGateway)
loc.stackRepo = stacks.NewCloudControllerStackRepository(config, cloudControllerGateway)
loc.serviceRepo = NewCloudControllerServiceRepository(config, cloudControllerGateway)
loc.serviceKeyRepo = NewCloudControllerServiceKeyRepository(config, cloudControllerGateway)
loc.serviceBindingRepo = NewCloudControllerServiceBindingRepository(config, cloudControllerGateway)
loc.serviceBrokerRepo = NewCloudControllerServiceBrokerRepository(config, cloudControllerGateway)
loc.servicePlanRepo = NewCloudControllerServicePlanRepository(config, cloudControllerGateway)
loc.servicePlanVisibilityRepo = NewCloudControllerServicePlanVisibilityRepository(config, cloudControllerGateway)
loc.serviceSummaryRepo = NewCloudControllerServiceSummaryRepository(config, cloudControllerGateway)
loc.spaceRepo = spaces.NewCloudControllerSpaceRepository(config, cloudControllerGateway)
loc.userProvidedServiceInstanceRepo = NewCCUserProvidedServiceInstanceRepository(config, cloudControllerGateway)
loc.userRepo = NewCloudControllerUserRepository(config, uaaGateway, cloudControllerGateway)
loc.buildpackRepo = NewCloudControllerBuildpackRepository(config, cloudControllerGateway)
loc.buildpackBitsRepo = NewCloudControllerBuildpackBitsRepository(config, cloudControllerGateway, appfiles.ApplicationZipper{})
loc.securityGroupRepo = securitygroups.NewSecurityGroupRepo(config, cloudControllerGateway)
loc.stagingSecurityGroupRepo = staging.NewSecurityGroupsRepo(config, cloudControllerGateway)
loc.runningSecurityGroupRepo = running.NewSecurityGroupsRepo(config, cloudControllerGateway)
loc.securityGroupSpaceBinder = securitygroupspaces.NewSecurityGroupSpaceBinder(config, cloudControllerGateway)
loc.spaceQuotaRepo = spacequotas.NewCloudControllerSpaceQuotaRepository(config, cloudControllerGateway)
loc.featureFlagRepo = featureflags.NewCloudControllerFeatureFlagRepository(config, cloudControllerGateway)
loc.environmentVariableGroupRepo = environmentvariablegroups.NewCloudControllerRepository(config, cloudControllerGateway)
loc.copyAppSourceRepo = copyapplicationsource.NewCloudControllerCopyApplicationSourceRepository(config, cloudControllerGateway)
client := v3client.NewClient(config.APIEndpoint(), config.AuthenticationEndpoint(), config.AccessToken(), config.RefreshToken())
loc.v3Repository = repository.NewRepository(config, client)
return
}
Describe("GetApplications", func() {
It("tries to get applications from CC with a token handler", func() {
r.GetApplications()
Expect(ccClient.GetApplicationsCallCount()).To(Equal(1))
})
Context("when the client has updated tokens", func() {
BeforeEach(func() {
ccClient.TokensUpdatedReturns(true)
ccClient.GetUpdatedTokensReturns("updated-access-token", "updated-refresh-token")
})
It("stores the new tokens in the config", func() {
r.GetApplications()
Expect(config.AccessToken()).To(Equal("updated-access-token"))
Expect(config.RefreshToken()).To(Equal("updated-refresh-token"))
})
})
Context("when getting the applications succeeds", func() {
BeforeEach(func() {
ccClient.GetApplicationsReturns(getApplicationsJSON, nil)
})
It("returns a slice of application model objects", func() {
applications, err := r.GetApplications()
Expect(err).NotTo(HaveOccurred())
Expect(applications).To(Equal([]models.V3Application{
{
Name: "app-1-name",
DesiredState: "STOPPED",
"username": "******",
"password": "******",
})
})
Describe("when login succeeds", func() {
BeforeEach(func() {
setupTestServer(successfulLoginRequest)
})
It("stores the access and refresh tokens in the config", func() {
Expect(handler).To(HaveAllRequestsCalled())
Expect(err).NotTo(HaveOccurred())
Expect(config.AuthenticationEndpoint()).To(Equal(testServer.URL))
Expect(config.AccessToken()).To(Equal("BEARER my_access_token"))
Expect(config.RefreshToken()).To(Equal("my_refresh_token"))
})
})
Describe("when login fails", func() {
BeforeEach(func() {
setupTestServer(unsuccessfulLoginRequest)
})
It("returns an error", func() {
Expect(handler).To(HaveAllRequestsCalled())
Expect(err).NotTo(BeNil())
Expect(err.Error()).To(Equal("Credentials were rejected, please try again."))
Expect(config.AccessToken()).To(BeEmpty())
Expect(config.RefreshToken()).To(BeEmpty())
})
It("refreshes the token when UAA requests fail", func() {
apiServer := httptest.NewTLSServer(refreshTokenAPIEndPoint(
`{ "error": "invalid_token", "error_description": "Auth token is invalid" }`,
testnet.TestResponse{Status: http.StatusOK},
))
defer apiServer.Close()
ccGateway.SetTrustedCerts(apiServer.TLS.Certificates)
config, auth := createAuthenticationRepository(apiServer, authServer)
uaaGateway.SetTokenRefresher(auth)
request, apiErr := uaaGateway.NewRequest("POST", config.APIEndpoint()+"/v2/foo", config.AccessToken(), strings.NewReader("expected body"))
_, apiErr = uaaGateway.PerformRequest(request)
Expect(apiErr).NotTo(HaveOccurred())
Expect(config.AccessToken()).To(Equal("bearer new-access-token"))
Expect(config.RefreshToken()).To(Equal("new-refresh-token"))
})
It("refreshes the token when CC requests fail", func() {
apiServer := httptest.NewTLSServer(refreshTokenAPIEndPoint(
`{ "code": 1000, "description": "Auth token is invalid" }`,
testnet.TestResponse{Status: http.StatusOK}))
defer apiServer.Close()
ccGateway.SetTrustedCerts(apiServer.TLS.Certificates)
config, auth := createAuthenticationRepository(apiServer, authServer)
ccGateway.SetTokenRefresher(auth)
request, apiErr := ccGateway.NewRequest("POST", config.APIEndpoint()+"/v2/foo", config.AccessToken(), strings.NewReader("expected body"))
_, apiErr = ccGateway.PerformRequest(request)
Expect(apiErr).NotTo(HaveOccurred())