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"))