func singleAppManifest() *manifest.Manifest { return &manifest.Manifest{ Path: "manifest.yml", Data: generic.NewMap(map[interface{}]interface{}{ "applications": []interface{}{ generic.NewMap(map[interface{}]interface{}{ "name": "manifest-app-name", "memory": "128MB", "instances": 1, "host": "manifest-host", "domain": "manifest-example.com", "stack": "custom-stack", "timeout": 360, "buildpack": "some-buildpack", "command": `JAVA_HOME=$PWD/.openjdk JAVA_OPTS="-Xss995K" ./bin/start.sh run`, "path": filepath.Clean("some/path/from/manifest"), "env": generic.NewMap(map[interface{}]interface{}{ "FOO": "baz", "PATH": "/u/apps/my-app/bin", }), }), }, }), } }
func (resource EventResourceNewV2) ToFields() models.EventFields { metadata := generic.NewMap(resource.Entity.Metadata) if metadata.Has("request") { metadata = generic.NewMap(metadata.Get("request")) } return models.EventFields{ Guid: resource.Metadata.Guid, Name: resource.Entity.Type, Timestamp: resource.Entity.Timestamp, Description: formatDescription(metadata, knownMetadataKeys), ActorName: resource.Entity.ActorName, } }
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 (m Manifest) Applications() (apps []models.AppParams, err error) { rawData, errs := expandProperties(m.Data, generator.NewWordGenerator()) if len(errs) > 0 { err = errors.NewWithSlice(errs) return } data := generic.NewMap(rawData) appMaps, errs := m.getAppMaps(data) if len(errs) > 0 { err = errors.NewWithSlice(errs) return } for _, appMap := range appMaps { app, errs := mapToAppParams(filepath.Dir(m.Path), appMap) if len(errs) > 0 { err = errors.NewWithSlice(errs) continue } apps = append(apps, app) } return }
func envVarOrEmptyMap(yamlMap generic.Map, errs *[]error) *map[string]string { key := "env" switch envVars := yamlMap.Get(key).(type) { case nil: aMap := make(map[string]string, 0) return &aMap case map[string]interface{}: yamlMap.Set(key, generic.NewMap(yamlMap.Get(key))) return envVarOrEmptyMap(yamlMap, errs) case map[interface{}]interface{}: yamlMap.Set(key, generic.NewMap(yamlMap.Get(key))) return envVarOrEmptyMap(yamlMap, errs) case generic.Map: merrs := validateEnvVars(envVars) if merrs != nil { *errs = append(*errs, merrs...) return nil } result := make(map[string]string, envVars.Count()) generic.Each(envVars, func(key, value interface{}) { switch value.(type) { case string: result[key.(string)] = value.(string) case int64, int, int32: result[key.(string)] = fmt.Sprintf("%d", value) case float32, float64: result[key.(string)] = fmt.Sprintf("%f", value) default: *errs = append(*errs, errors.NewWithFmt(T("Expected environment variable {{.PropertyName}} to have a string value, but it was a {{.PropertyType}}.", map[string]interface{}{"PropertyName": key, "PropertyType": value}))) } }) return &result default: *errs = append(*errs, errors.NewWithFmt(T("Expected {{.Name}} to be a set of key => value, but it was a {{.Type}}.", map[string]interface{}{"Name": key, "Type": envVars}))) return nil } }
func manifestWithServicesAndEnv() *manifest.Manifest { return &manifest.Manifest{ Data: generic.NewMap(map[interface{}]interface{}{ "applications": []interface{}{ generic.NewMap(map[interface{}]interface{}{ "name": "app1", "services": []interface{}{"app1-service", "global-service"}, "env": generic.NewMap(map[interface{}]interface{}{ "SOMETHING": "definitely-something", }), }), generic.NewMap(map[interface{}]interface{}{ "name": "app2", "services": []interface{}{"app2-service", "global-service"}, "env": generic.NewMap(map[interface{}]interface{}{ "SOMETHING": "nothing", }), }), }, }), } }
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 expandProperties(input interface{}, babbler generator.WordGenerator) (output interface{}, errs []error) { switch input := input.(type) { case string: match := propertyRegex.FindStringSubmatch(input) if match != nil { if match[0] == "${random-word}" { output = strings.Replace(input, "${random-word}", strings.ToLower(babbler.Babble()), -1) } else { err := errors.NewWithFmt(T("Property '{{.PropertyName}}' found in manifest. This feature is no longer supported. Please remove it and try again.", map[string]interface{}{"PropertyName": match[0]})) errs = append(errs, err) } } else { output = input } case []interface{}: outputSlice := make([]interface{}, len(input)) for index, item := range input { itemOutput, itemErrs := expandProperties(item, babbler) outputSlice[index] = itemOutput errs = append(errs, itemErrs...) } output = outputSlice case map[interface{}]interface{}: outputMap := make(map[interface{}]interface{}) for key, value := range input { itemOutput, itemErrs := expandProperties(value, babbler) outputMap[key] = itemOutput errs = append(errs, itemErrs...) } output = outputMap case generic.Map: outputMap := generic.NewMap() generic.Each(input, func(key, value interface{}) { itemOutput, itemErrs := expandProperties(value, babbler) outputMap.Set(key, itemOutput) errs = append(errs, itemErrs...) }) output = outputMap default: output = input } return }
func NewEmptyManifest() (m *Manifest) { return &Manifest{Data: generic.NewMap()} }
. "github.com/onsi/gomega" . "github.com/nttlabs/cli/testhelpers/matchers" ) func NewManifest(path string, data generic.Map) (m *manifest.Manifest) { return &manifest.Manifest{Path: path, Data: data} } var _ = Describe("Manifests", func() { It("merges global properties into each app's properties", func() { m := NewManifest("/some/path/manifest.yml", generic.NewMap(map[interface{}]interface{}{ "instances": "3", "memory": "512M", "applications": []interface{}{ map[interface{}]interface{}{ "name": "bitcoin-miner", "no-route": true, }, }, })) apps, err := m.Applications() Expect(err).NotTo(HaveOccurred()) Expect(*apps[0].InstanceCount).To(Equal(3)) Expect(*apps[0].Memory).To(Equal(int64(512))) Expect(apps[0].NoRoute).To(BeTrue()) }) Describe("when there is no applications block", func() { It("returns a single application with the global properties", func() {
)) Expect(ui.Outputs).ToNot(ContainSubstrings([]string{"existing-app.example.com"})) Expect(routeRepo.FindByHostAndDomainCalledWith.Domain.Name).To(Equal("example.com")) Expect(routeRepo.FindByHostAndDomainCalledWith.Host).To(Equal("")) Expect(routeRepo.CreatedHost).To(Equal("")) Expect(routeRepo.CreatedDomainGuid).To(Equal("domain-guid")) }) }) }) Describe("service instances", func() { BeforeEach(func() { serviceRepo.FindInstanceByNameMap = generic.NewMap(map[interface{}]interface{}{ "global-service": maker.NewServiceInstance("global-service"), "app1-service": maker.NewServiceInstance("app1-service"), "app2-service": maker.NewServiceInstance("app2-service"), }) manifestRepo.ReadManifestReturns.Manifest = manifestWithServicesAndEnv() }) Context("when the service is not bound", func() { BeforeEach(func() { appRepo.ReadReturns.Error = errors.NewModelNotFoundError("App", "the-app") }) It("binds service instances to the app", func() { callPush() Expect(len(serviceBinder.AppsToBind)).To(Equal(4)) Expect(serviceBinder.AppsToBind[0].Name).To(Equal("app1"))