Example #1
0
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
}
Example #2
0
func (p *parser) parseNetworkManifests(rawNetworks []network) ([]Network, error) {
	networks := make([]Network, len(rawNetworks), len(rawNetworks))
	for i, rawNetwork := range rawNetworks {
		network := Network{
			Name: rawNetwork.Name,
			Type: NetworkType(rawNetwork.Type),
			DNS:  rawNetwork.DNS,
		}

		cloudProperties, err := biproperty.BuildMap(rawNetwork.CloudProperties)
		if err != nil {
			return networks, bosherr.WrapErrorf(err, "Parsing network '%s' cloud_properties: %#v", rawNetwork.Name, rawNetwork.CloudProperties)
		}
		network.CloudProperties = cloudProperties

		for _, subnet := range rawNetwork.Subnets {
			cloudProperties, err := biproperty.BuildMap(subnet.CloudProperties)
			if err != nil {
				return networks, bosherr.WrapErrorf(err, "Parsing network subnet '%s' cloud_properties: %#v", rawNetwork.Name, subnet.CloudProperties)
			}

			network.Subnets = append(network.Subnets, Subnet{
				Range:           subnet.Range,
				Gateway:         subnet.Gateway,
				DNS:             subnet.DNS,
				CloudProperties: cloudProperties,
			})
		}

		networks[i] = network
	}

	return networks, nil
}
Example #3
0
func (p *parser) parseJobManifests(rawJobs []job) ([]Job, error) {
	jobs := make([]Job, len(rawJobs), len(rawJobs))
	for i, rawJob := range rawJobs {
		job := Job{
			Name:               rawJob.Name,
			Instances:          rawJob.Instances,
			Lifecycle:          JobLifecycle(rawJob.Lifecycle),
			PersistentDisk:     rawJob.PersistentDisk,
			PersistentDiskPool: rawJob.PersistentDiskPool,
			ResourcePool:       rawJob.ResourcePool,
		}

		if rawJob.Templates != nil {
			releaseJobRefs := make([]ReleaseJobRef, len(rawJob.Templates), len(rawJob.Templates))
			for i, rawJobRef := range rawJob.Templates {
				releaseJobRefs[i] = ReleaseJobRef{
					Name:    rawJobRef.Name,
					Release: rawJobRef.Release,
				}
			}
			job.Templates = releaseJobRefs
		}

		if rawJob.Networks != nil {
			jobNetworks := make([]JobNetwork, len(rawJob.Networks), len(rawJob.Networks))
			for i, rawJobNetwork := range rawJob.Networks {
				jobNetwork := JobNetwork{
					Name:      rawJobNetwork.Name,
					StaticIPs: rawJobNetwork.StaticIPs,
				}

				if rawJobNetwork.Defaults != nil {
					networkDefaults := make([]NetworkDefault, len(rawJobNetwork.Defaults), len(rawJobNetwork.Defaults))
					for i, rawDefaults := range rawJobNetwork.Defaults {
						networkDefaults[i] = NetworkDefault(rawDefaults)
					}
					jobNetwork.Defaults = networkDefaults
				}

				jobNetworks[i] = jobNetwork
			}
			job.Networks = jobNetworks
		}

		if rawJob.Properties != nil {
			properties, err := biproperty.BuildMap(rawJob.Properties)
			if err != nil {
				return jobs, bosherr.WrapErrorf(err, "Parsing job '%s' properties: %#v", rawJob.Name, rawJob.Properties)
			}
			job.Properties = properties
		}

		jobs[i] = job
	}

	return jobs, nil
}
Example #4
0
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
}
Example #5
0
func (p *parser) parseDeploymentManifest(depManifest manifest, path string) (Manifest, error) {
	deployment := boshDeploymentDefaults
	deployment.Name = depManifest.Name

	networks, err := p.parseNetworkManifests(depManifest.Networks)
	if err != nil {
		return Manifest{}, bosherr.WrapErrorf(err, "Parsing networks: %#v", depManifest.Networks)
	}
	deployment.Networks = networks

	resourcePools, err := p.parseResourcePoolManifests(depManifest.ResourcePools, path)
	if err != nil {
		return Manifest{}, bosherr.WrapErrorf(err, "Parsing resource_pools: %#v", depManifest.ResourcePools)
	}

	deployment.ResourcePools = resourcePools

	diskPools, err := p.parseDiskPoolManifests(depManifest.DiskPools)
	if err != nil {
		return Manifest{}, bosherr.WrapErrorf(err, "Parsing disk_pools: %#v", depManifest.DiskPools)
	}
	deployment.DiskPools = diskPools

	jobs, err := p.parseJobManifests(depManifest.Jobs)
	if err != nil {
		return Manifest{}, bosherr.WrapErrorf(err, "Parsing jobs: %#v", depManifest.Jobs)
	}
	deployment.Jobs = jobs

	properties, err := biproperty.BuildMap(depManifest.Properties)
	if err != nil {
		return Manifest{}, bosherr.WrapErrorf(err, "Parsing global manifest properties: %#v", depManifest.Properties)
	}
	deployment.Properties = properties

	if depManifest.Update.UpdateWatchTime != nil {
		updateWatchTime, err := NewWatchTime(*depManifest.Update.UpdateWatchTime)
		if err != nil {
			return Manifest{}, bosherr.WrapError(err, "Parsing update watch time")
		}

		deployment.Update = Update{
			UpdateWatchTime: updateWatchTime,
		}
	}

	return deployment, nil
}
Example #6
0
func (p *parser) parseDiskPoolManifests(rawDiskPools []diskPool) ([]DiskPool, error) {
	diskPools := make([]DiskPool, len(rawDiskPools), len(rawDiskPools))
	for i, rawDiskPool := range rawDiskPools {
		diskPool := DiskPool{
			Name:     rawDiskPool.Name,
			DiskSize: rawDiskPool.DiskSize,
		}

		cloudProperties, err := biproperty.BuildMap(rawDiskPool.CloudProperties)
		if err != nil {
			return diskPools, bosherr.WrapErrorf(err, "Parsing disk_pool '%s' cloud_properties: %#v", rawDiskPool.Name, rawDiskPool.CloudProperties)
		}
		diskPool.CloudProperties = cloudProperties

		diskPools[i] = diskPool
	}

	return diskPools, nil
}
Example #7
0
func (s reader) Read(stemcellTarballPath string, extractedPath string) (ExtractedStemcell, error) {
	err := s.compressor.DecompressFileToDir(stemcellTarballPath, extractedPath, boshcmd.CompressorOptions{})
	if err != nil {
		return nil, bosherr.WrapErrorf(err, "Extracting stemcell from '%s' to '%s'", stemcellTarballPath, extractedPath)
	}

	var rawManifest manifest
	manifestPath := filepath.Join(extractedPath, "stemcell.MF")

	manifestContents, err := s.fs.ReadFile(manifestPath)
	if err != nil {
		return nil, bosherr.WrapErrorf(err, "Reading stemcell manifest '%s'", manifestPath)
	}

	err = yaml.Unmarshal(manifestContents, &rawManifest)
	if err != nil {
		return nil, bosherr.WrapErrorf(err, "Parsing stemcell manifest: %s", manifestContents)
	}

	manifest := Manifest{
		Name:    rawManifest.Name,
		Version: rawManifest.Version,
		OS:      rawManifest.OS,
		SHA1:    rawManifest.SHA1,
	}

	cloudProperties, err := biproperty.BuildMap(rawManifest.CloudProperties)
	if err != nil {
		return nil, bosherr.WrapErrorf(err, "Parsing stemcell cloud_properties: %#v", rawManifest.CloudProperties)
	}
	manifest.CloudProperties = cloudProperties

	manifest.ImagePath = filepath.Join(extractedPath, "image")

	stemcell := NewExtractedStemcell(
		manifest,
		extractedPath,
		s.fs,
	)

	return stemcell, nil
}