func (p *parser) parseResourcePoolManifests(rawResourcePools []resourcePool, path string) ([]ResourcePool, error) {
resourcePools := make([]ResourcePool, len(rawResourcePools), len(rawResourcePools))
for i, rawResourcePool := range rawResourcePools {
resourcePool := ResourcePool{
Name: rawResourcePool.Name,
Network: rawResourcePool.Network,
Stemcell: StemcellRef(rawResourcePool.Stemcell),
}
cloudProperties, err := biproperty.BuildMap(rawResourcePool.CloudProperties)
if err != nil {
return resourcePools, bosherr.WrapErrorf(err, "Parsing resource_pool '%s' cloud_properties: %#v", rawResourcePool.Name, rawResourcePool.CloudProperties)
}
resourcePool.CloudProperties = cloudProperties
env, err := biproperty.BuildMap(rawResourcePool.Env)
if err != nil {
return resourcePools, bosherr.WrapErrorf(err, "Parsing resource_pool '%s' env: %#v", rawResourcePool.Name, rawResourcePool.Env)
}
resourcePool.Env = env
resourcePool.Stemcell.URL, err = biutil.AbsolutifyPath(path, resourcePool.Stemcell.URL, p.fs)
if err != nil {
return resourcePools, bosherr.WrapErrorf(err, "Resolving stemcell path '%s", resourcePool.Stemcell.URL)
}
resourcePools[i] = resourcePool
}
return resourcePools, nil
}
func (p *parser) Parse(path string) (Manifest, error) {
contents, err := p.fs.ReadFile(path)
if err != nil {
return Manifest{}, bosherr.WrapErrorf(err, "Reading file %s", path)
}
comboManifest := manifest{}
err = yaml.Unmarshal(contents, &comboManifest)
if err != nil {
return Manifest{}, bosherr.WrapError(err, "Unmarshalling release set manifest")
}
p.logger.Debug(p.logTag, "Parsed release set manifest: %#v", comboManifest)
for i, releaseRef := range comboManifest.Releases {
comboManifest.Releases[i].URL, err = biutil.AbsolutifyPath(path, releaseRef.URL, p.fs)
if err != nil {
return Manifest{}, bosherr.WrapErrorf(err, "Resolving release path '%s", releaseRef.URL)
}
}
releaseSetManifest := Manifest{
Releases: comboManifest.Releases,
}
err = p.validator.Validate(releaseSetManifest)
if err != nil {
return Manifest{}, bosherr.WrapError(err, "Validating release set manifest")
}
return releaseSetManifest, nil
}
func (p *parser) Parse(path string, releaseSetManifest birelsetmanifest.Manifest) (Manifest, error) {
contents, err := p.fs.ReadFile(path)
if err != nil {
return Manifest{}, bosherr.WrapErrorf(err, "Reading file %s", path)
}
comboManifest := manifest{}
err = yaml.Unmarshal(contents, &comboManifest)
if err != nil {
return Manifest{}, bosherr.WrapError(err, "Unmarshalling installation manifest")
}
p.logger.Debug(p.logTag, "Parsed installation manifest: %#v", comboManifest)
if comboManifest.CloudProvider.SSHTunnel.PrivateKey != "" {
comboManifest.CloudProvider.SSHTunnel.PrivateKey, err = biutil.AbsolutifyPath(path, comboManifest.CloudProvider.SSHTunnel.PrivateKey, p.fs)
if err != nil {
return Manifest{}, bosherr.WrapErrorf(err, "Expanding private_key path")
}
}
installationManifest := Manifest{
Name: comboManifest.Name,
Template: ReleaseJobRef{
Name: comboManifest.CloudProvider.Template.Name,
Release: comboManifest.CloudProvider.Template.Release,
},
Mbus: comboManifest.CloudProvider.Mbus,
}
properties, err := biproperty.BuildMap(comboManifest.CloudProvider.Properties)
if err != nil {
return Manifest{}, bosherr.WrapErrorf(err, "Parsing cloud_provider manifest properties: %#v", comboManifest.CloudProvider.Properties)
}
installationManifest.Properties = properties
if comboManifest.CloudProvider.HasSSHTunnel() {
password, err := p.uuidGenerator.Generate()
if err != nil {
return Manifest{}, bosherr.WrapError(err, "Generating registry password")
}
installationManifest.PopulateRegistry("registry", password, "127.0.0.1", 6901, comboManifest.CloudProvider.SSHTunnel)
}
err = p.validator.Validate(installationManifest, releaseSetManifest)
if err != nil {
return Manifest{}, bosherr.WrapError(err, "Validating installation manifest")
}
return installationManifest, nil
}
var _ = Describe("AbsolutifyPath", func() {
var realfs boshsys.FileSystem
var fakeManifestPath, fakeFilePath string
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
realfs = boshsys.NewOsFileSystem(logger)
fakeManifestPath = "/fake/manifest/path/manifest.yml"
})
Context("File path is not a url", func() {
Context("File path is relative", func() {
Context("File path begins with a series of ../", func() {
It("joins file path to the manifest directory", func() {
fakeFilePath = "../fake/relative/path/file.tgz"
Expect(util.AbsolutifyPath(fakeManifestPath, fakeFilePath, realfs)).To(
Equal("/fake/manifest/fake/relative/path/file.tgz"))
})
})
Context("File is located in same directory as manifest or subdirectory", func() {
It("makes the file path relative to the manifest directory", func() {
fakeFilePath = "fake/relative/path/file.tgz"
result, err := util.AbsolutifyPath(fakeManifestPath, fakeFilePath, realfs)
Expect(result).To(Equal("/fake/manifest/path/fake/relative/path/file.tgz"))
Expect(err).ToNot(HaveOccurred())
})
})
})
Context("File path is absolute", func() {
Context("file path starts with ~", func() {