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("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 (cmd *Push) findDefaultDomain() (domain models.DomainFields, err error) {
foundIt := false
listDomainsCallback := func(aDomain models.DomainFields) bool {
if aDomain.Shared {
domain = aDomain
foundIt = true
}
return !foundIt
}
apiErr := cmd.domainRepo.ListSharedDomains(listDomainsCallback)
// FIXME: needs semantic API version
switch apiErr.(type) {
case errors.HttpNotFoundError:
apiErr = cmd.domainRepo.ListDomains(listDomainsCallback)
}
if !foundIt {
err = errors.New("Could not find a default domain")
return
}
return
}
func (gateway Gateway) waitForJob(jobUrl, accessToken string, timeout time.Duration) (err error) {
startTime := time.Now()
for true {
if time.Since(startTime) > timeout {
err = errors.NewWithFmt("Error: timed out waiting for async job '%s' to finish", jobUrl)
return
}
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 (cmd PurgeServiceOffering) GetRequirements(reqFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 1 {
err = errors.New("incorrect usage")
cmd.ui.FailWithUsage(c, "purge-service-offering")
}
return
}
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("Invalid position. %s", err.Error())
return
}
enabled := c.Bool("enable")
disabled := c.Bool("disable")
if enabled && disabled {
apiErr = errors.New("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
}
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 (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("Expected applications to be a list"))
return
}
for _, appData := range appMaps {
if !generic.IsMappable(appData) {
errs = append(errs, errors.NewWithFmt("Expected application to be a list of key/value pairs\nError occurred in manifest near:\n'%s'", appData))
continue
}
appMap := generic.DeepMerge(globalProperties, generic.NewMap(appData))
apps = append(apps, appMap)
}
} else {
apps = append(apps, globalProperties)
}
return
}
func (repo CloudControllerUserRepository) getAuthEndpoint() (string, error) {
uaaEndpoint := repo.config.UaaEndpoint()
if uaaEndpoint == "" {
return "", errors.New("UAA endpoint missing from config file")
}
return uaaEndpoint, nil
}
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 validateEnvVars(input generic.Map) (errs []error) {
generic.Each(input, func(key, value interface{}) {
if value == nil {
errs = append(errs, errors.New(fmt.Sprintf("env var '%s' should not be null", key)))
}
})
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("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 (cmd CreateService) GetRequirements(reqFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 3 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "create-service")
return
}
return
}
func (cmd *DeleteApp) GetRequirements(reqFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) == 0 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "delete")
return
}
return
}
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 normalizeBuildpackArchive(inputFile *os.File, outputFile *os.File) (err error) {
stats, err := inputFile.Stat()
if err != nil {
return
}
reader, err := zip.NewReader(inputFile, stats.Size())
if err != nil {
return
}
contents := reader.File
parentPath, hasBuildpack := findBuildpackPath(contents)
if !hasBuildpack {
return errors.New("Zip archive does not contain a buildpack")
}
writer := zip.NewWriter(outputFile)
for _, file := range contents {
name := file.Name
if parentPath == "." || strings.HasPrefix(name, parentPath) {
var (
r io.ReadCloser
w io.Writer
header *zip.FileHeader
)
fileInfo := file.FileInfo()
header, err = zip.FileInfoHeader(fileInfo)
header.Name = strings.Replace(name, parentPath+"/", "", 1)
r, err = file.Open()
if err != nil {
return
}
w, err = writer.CreateHeader(header)
if err != nil {
return
}
io.Copy(w, r)
err = r.Close()
if err != nil {
return
}
}
}
writer.Close()
outputFile.Seek(0, 0)
return
}
func (repo *FakeRouteRepository) FindByHost(host string) (route models.Route, apiErr error) {
repo.FindByHostHost = host
if repo.FindByHostErr {
apiErr = errors.New("Route not found")
}
route = repo.FindByHostRoute
return
}
func (cmd CreateUser) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 2 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "create-user")
}
reqs = append(reqs, requirementsFactory.NewLoginRequirement())
return
}
func (cmd *RenameBuildpack) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 2 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "rename-buildpack")
return
}
reqs = []requirements.Requirement{requirementsFactory.NewLoginRequirement()}
return
}
func (cmd DeleteServiceBroker) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 1 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "delete-service-broker")
return
}
reqs = append(reqs, requirementsFactory.NewLoginRequirement())
return
}
func (cmd *DeleteOrg) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 1 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "delete-org")
return
}
reqs = []requirements.Requirement{requirementsFactory.NewLoginRequirement()}
return
}
func (cmd DeleteServiceAuthTokenFields) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 2 {
err = errors.New("Incorrect usage")
cmd.ui.FailWithUsage(c, "delete-service-auth-token")
return
}
reqs = append(reqs, requirementsFactory.NewLoginRequirement())
return
}
func findAppWithNameInManifest(name string, m *manifest.Manifest) (app models.AppParams, err error) {
for _, appParams := range m.Applications {
if appParams.Name != nil && *appParams.Name == name {
app = appParams
return
}
}
err = errors.New("Could not find named app in manifest")
return
}
func addApp(apps *[]models.AppParams, app models.AppParams) (err error) {
if app.Name == nil {
err = errors.New("App name is a required field")
}
if app.Path == nil {
cwd, _ := os.Getwd()
app.Path = &cwd
}
*apps = append(*apps, app)
return
}
func PrepareRedirect(req *http.Request, via []*http.Request) error {
if len(via) > 1 {
return errors.New("stopped after 1 redirect")
}
prevReq := via[len(via)-1]
req.Header.Set("Authorization", prevReq.Header.Get("Authorization"))
dumpRequest(req)
return nil
}
func (cmd DeleteUserFields) GetRequirements(reqFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 1 {
err = errors.New("Invalid usage")
cmd.ui.FailWithUsage(c, "delete-user")
return
}
reqs = append(reqs, reqFactory.NewLoginRequirement())
return
}
func (repo CloudControllerPasswordRepository) UpdatePassword(old string, new string) error {
uaaEndpoint := repo.config.UaaEndpoint()
if uaaEndpoint == "" {
return errors.New("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 *Start) GetRequirements(requirementsFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) == 0 {
err = errors.New("Incorrect Usage")
cmd.ui.FailWithUsage(c, "start")
return
}
cmd.appReq = requirementsFactory.NewApplicationRequirement(c.Args()[0])
reqs = []requirements.Requirement{requirementsFactory.NewLoginRequirement(), cmd.appReq}
return
}
func (cmd *MigrateServiceInstances) GetRequirements(reqFactory requirements.Factory, c *cli.Context) (reqs []requirements.Requirement, err error) {
if len(c.Args()) != 5 {
err = errors.New("incorrect usage")
cmd.ui.FailWithUsage(c, "migrate-service-instances")
return
}
reqs = []requirements.Requirement{
reqFactory.NewLoginRequirement(),
}
return
}
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(fmt.Sprintf("Could not find plan with name %s", 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(fmt.Sprintf("Could not find any offerings with name %s", name))
}
return
}
