func (p linux) partitionEphemeralDisk(realPath string) (string, string, error) {
p.logger.Info(logTag, "Creating swap & ephemeral partitions on ephemeral disk...")
p.logger.Debug(logTag, "Getting device size of `%s'", realPath)
diskSizeInBytes, err := p.diskManager.GetPartitioner().GetDeviceSizeInBytes(realPath)
if err != nil {
return "", "", bosherr.WrapError(err, "Getting device size")
}
p.logger.Debug(logTag, "Calculating ephemeral disk partition sizes of `%s' with total disk size %dB", realPath, diskSizeInBytes)
swapSizeInBytes, linuxSizeInBytes, err := p.calculateEphemeralDiskPartitionSizes(diskSizeInBytes)
if err != nil {
return "", "", bosherr.WrapError(err, "Calculating partition sizes")
}
partitions := []boshdisk.Partition{
{SizeInBytes: swapSizeInBytes, Type: boshdisk.PartitionTypeSwap},
{SizeInBytes: linuxSizeInBytes, Type: boshdisk.PartitionTypeLinux},
}
p.logger.Info(logTag, "Partitioning ephemeral disk `%s' with %s", realPath, partitions)
err = p.diskManager.GetPartitioner().Partition(realPath, partitions)
if err != nil {
return "", "", bosherr.WrapErrorf(err, "Partitioning ephemeral disk `%s'", realPath)
}
swapPartitionPath := realPath + "1"
dataPartitionPath := realPath + "2"
return swapPartitionPath, dataPartitionPath, nil
}
func (fs *osFileSystem) Chown(path, username string) error {
fs.logger.Debug(fs.logTag, "Chown %s to user %s", path, username)
uid, err := fs.runCommand(fmt.Sprintf("id -u %s", username))
if err != nil {
return bosherr.WrapErrorf(err, "Getting user id for '%s'", username)
}
uidAsInt, err := strconv.Atoi(uid)
if err != nil {
return bosherr.WrapError(err, "Converting UID to integer")
}
gid, err := fs.runCommand(fmt.Sprintf("id -g %s", username))
if err != nil {
return bosherr.WrapErrorf(err, "Getting group id for '%s'", username)
}
gidAsInt, err := strconv.Atoi(gid)
if err != nil {
return bosherr.WrapError(err, "Converting GID to integer")
}
err = os.Chown(path, uidAsInt, gidAsInt)
if err != nil {
return bosherr.WrapError(err, "Doing Chown")
}
return nil
}
func (p linux) findRootDevicePath() (string, error) {
mounts, err := p.diskManager.GetMountsSearcher().SearchMounts()
if err != nil {
return "", bosherr.WrapError(err, "Searching mounts")
}
for _, mount := range mounts {
if mount.MountPoint == "/" && strings.HasPrefix(mount.PartitionPath, "/dev/") {
p.logger.Debug(logTag, "Found root partition: `%s'", mount.PartitionPath)
stdout, _, _, err := p.cmdRunner.RunCommand("readlink", "-f", mount.PartitionPath)
if err != nil {
return "", bosherr.WrapError(err, "Shelling out to readlink")
}
rootPartition := strings.Trim(stdout, "\n")
p.logger.Debug(logTag, "Symlink is: `%s'", rootPartition)
validRootPartition := regexp.MustCompile(`^/dev/[a-z]+1$`)
if !validRootPartition.MatchString(rootPartition) {
return "", bosherr.Error("Root partition is not the first partition")
}
return strings.Trim(rootPartition, "1"), nil
}
}
return "", bosherr.Error("Getting root partition device")
}
func (net centosNetManager) detectMacAddresses() (map[string]string, error) {
addresses := map[string]string{}
filePaths, err := net.fs.Glob("/sys/class/net/*")
if err != nil {
return addresses, bosherr.WrapError(err, "Getting file list from /sys/class/net")
}
var macAddress string
for _, filePath := range filePaths {
isPhysicalDevice := net.fs.FileExists(filepath.Join(filePath, "device"))
if isPhysicalDevice {
macAddress, err = net.fs.ReadFileString(filepath.Join(filePath, "address"))
if err != nil {
return addresses, bosherr.WrapError(err, "Reading mac address from file")
}
macAddress = strings.Trim(macAddress, "\n")
interfaceName := filepath.Base(filePath)
addresses[macAddress] = interfaceName
}
}
return addresses, nil
}
func (r diskRepo) Save(cid string, size int, cloudProperties biproperty.Map) (DiskRecord, error) {
config, records, err := r.load()
if err != nil {
return DiskRecord{}, err
}
oldRecord, found := r.find(records, cid)
if found {
return DiskRecord{}, bosherr.Errorf("Failed to save disk cid '%s', existing record found '%#v'", cid, oldRecord)
}
newRecord := DiskRecord{
CID: cid,
Size: size,
CloudProperties: cloudProperties,
}
newRecord.ID, err = r.uuidGenerator.Generate()
if err != nil {
return newRecord, bosherr.WrapError(err, "Generating disk id")
}
records = append(records, newRecord)
config.Disks = records
err = r.deploymentStateService.Save(config)
if err != nil {
return newRecord, bosherr.WrapError(err, "Saving new config")
}
return newRecord, nil
}
func (r releaseRepo) Update(releases []release.Release) error {
newRecordIDs := []string{}
newRecords := []ReleaseRecord{}
deploymentState, err := r.deploymentStateService.Load()
if err != nil {
return bosherr.WrapError(err, "Loading existing config")
}
for _, release := range releases {
newRecord := ReleaseRecord{
Name: release.Name(),
Version: release.Version(),
}
newRecord.ID, err = r.uuidGenerator.Generate()
if err != nil {
return bosherr.WrapError(err, "Generating release id")
}
newRecords = append(newRecords, newRecord)
newRecordIDs = append(newRecordIDs, newRecord.ID)
}
deploymentState.CurrentReleaseIDs = newRecordIDs
deploymentState.Releases = newRecords
err = r.deploymentStateService.Save(deploymentState)
if err != nil {
return bosherr.WrapError(err, "Updating current release record")
}
return nil
}
func (s *cloudStemcell) Delete() error {
deleteErr := s.cloud.DeleteStemcell(s.cid)
if deleteErr != nil {
// allow StemcellNotFoundError for idempotency
cloudErr, ok := deleteErr.(bicloud.Error)
if !ok || cloudErr.Type() != bicloud.StemcellNotFoundError {
return bosherr.WrapError(deleteErr, "Deleting stemcell from cloud")
}
}
stemcellRecord, found, err := s.repo.Find(s.name, s.version)
if err != nil {
return bosherr.WrapErrorf(err, "Finding stemcell record (name=%s, version=%s)", s.name, s.version)
}
if !found {
return nil
}
err = s.repo.Delete(stemcellRecord)
if err != nil {
return bosherr.WrapError(err, "Deleting stemcell record")
}
return deleteErr
}
func (net UbuntuNetManager) SetupNetworking(networks boshsettings.Networks, errCh chan error) error {
staticConfigs, dhcpConfigs, dnsServers, err := net.ComputeNetworkConfig(networks)
if err != nil {
return bosherr.WrapError(err, "Computing network configuration")
}
interfacesChanged, err := net.writeNetworkInterfaces(dhcpConfigs, staticConfigs, dnsServers)
if err != nil {
return bosherr.WrapError(err, "Writing network configuration")
}
dhcpChanged := false
if len(dhcpConfigs) > 0 {
dhcpChanged, err = net.writeDHCPConfiguration(dnsServers)
if err != nil {
return err
}
}
if interfacesChanged || dhcpChanged {
err = net.removeDhcpDNSConfiguration()
if err != nil {
return err
}
net.restartNetworkingInterfaces()
}
net.broadcastIps(staticConfigs, dhcpConfigs, errCh)
return 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 linux) SetupHostname(hostname string) (err error) {
_, _, _, err = p.cmdRunner.RunCommand("hostname", hostname)
if err != nil {
err = bosherr.WrapError(err, "Shelling out to hostname")
return
}
err = p.fs.WriteFileString("/etc/hostname", hostname)
if err != nil {
err = bosherr.WrapError(err, "Writing /etc/hostname")
return
}
buffer := bytes.NewBuffer([]byte{})
t := template.Must(template.New("etc-hosts").Parse(etcHostsTemplate))
err = t.Execute(buffer, hostname)
if err != nil {
err = bosherr.WrapError(err, "Generating config from template")
return
}
err = p.fs.WriteFile("/etc/hosts", buffer.Bytes())
if err != nil {
err = bosherr.WrapError(err, "Writing to /etc/hosts")
}
return
}
func (d *disk) Delete() error {
deleteErr := d.cloud.DeleteDisk(d.cid)
if deleteErr != nil {
// allow DiskNotFoundError for idempotency
cloudErr, ok := deleteErr.(bicloud.Error)
if !ok || cloudErr.Type() != bicloud.DiskNotFoundError {
return bosherr.WrapError(deleteErr, "Deleting disk in the cloud")
}
}
diskRecord, found, err := d.repo.Find(d.cid)
if err != nil {
return bosherr.WrapErrorf(err, "Finding disk record (cid=%s)", d.cid)
}
if !found {
return nil
}
err = d.repo.Delete(diskRecord)
if err != nil {
return bosherr.WrapError(err, "Deleting disk record")
}
// returns bicloud.Error only if it is a DiskNotFoundError
return deleteErr
}
func (ms *configDriveMetadataService) loadFromDiskPath(diskPath string) error {
contentPaths := []string{ms.metaDataFilePath, ms.userDataFilePath}
contents, err := ms.platform.GetFilesContentsFromDisk(diskPath, contentPaths)
if err != nil {
return bosherr.WrapError(err, "Reading files on config drive")
}
var metadata MetadataContentsType
err = json.Unmarshal(contents[0], &metadata)
if err != nil {
return bosherr.WrapError(err, "Parsing config drive metadata from meta_data.json")
}
ms.metaDataContents = metadata
var userdata UserDataContentsType
err = json.Unmarshal(contents[1], &userdata)
if err != nil {
return bosherr.WrapError(err, "Parsing config drive metadata from user_data")
}
ms.userDataContents = userdata
return nil
}
func describeMultilineError() {
var err error
It("returns a simple single-line message string (depth=0)", func() {
err = bosherr.Error("omg")
Expect(MultilineError(err)).To(Equal("omg"))
})
Context("when given a composite error", func() {
It("returns a multi-line, indented message string (depth=1)", func() {
err = bosherr.WrapError(bosherr.Error("inner omg"), "omg")
Expect(MultilineError(err)).To(Equal("omg:\n inner omg"))
})
It("returns a multi-line, indented message string (depth=2)", func() {
err = bosherr.WrapError(bosherr.WrapError(bosherr.Error("inner omg"), "omg"), "outer omg")
Expect(MultilineError(err)).To(Equal("outer omg:\n omg:\n inner omg"))
})
It("returns a multi-line, indented message string (depth=3)", func() {
err = bosherr.WrapError(bosherr.WrapError(bosherr.WrapError(bosherr.Error("inner omg"), "almost inner omg"), "almost outer omg"), "outer omg")
Expect(MultilineError(err)).To(Equal("outer omg:\n almost outer omg:\n almost inner omg:\n inner omg"))
})
})
Context("when given an explainable error", func() {
It("returns a multi-line message string with sibling errors at the same indentation", func() {
err = bosherr.NewMultiError(bosherr.Error("a"), bosherr.Error("b"))
Expect(MultilineError(err)).To(Equal("a\nb"))
})
It("returns a multi-line message string with sibling errors at the same indentation", func() {
complex := bosherr.WrapError(bosherr.Error("inner a"), "outer a")
err = bosherr.NewMultiError(complex, bosherr.Error("b"))
Expect(MultilineError(err)).To(Equal("outer a:\n inner a\nb"))
})
It("returns a multi-line message string with sibling errors at the same indentation", func() {
complex := bosherr.WrapError(bosherr.Error("inner b"), "outer b")
err = bosherr.NewMultiError(bosherr.Error("a"), complex)
Expect(MultilineError(err)).To(Equal("a\nouter b:\n inner b"))
})
})
Context("when given a composite err with explainable errors", func() {
It("returns a multi-line message string with sibling errors at the same indentation", func() {
multi := bosherr.NewMultiError(bosherr.Error("inner a"), bosherr.Error("inner b"))
err = bosherr.WrapError(multi, "outer omg")
Expect(MultilineError(err)).To(Equal("outer omg:\n inner a\n inner b"))
})
})
Context("when given an ExecError", func() {
It("returns a multi-line message string with the command, stdout, & stderr at the same indentation", func() {
execErr := boshsys.NewExecError("fake-cmd --flag with some args", "some\nmultiline\nstdout", "some\nmultiline\nstderr")
err = bosherr.WrapError(execErr, "outer omg")
Expect(MultilineError(err)).To(Equal("outer omg:\n Error Executing Command:\n fake-cmd --flag with some args\n StdOut:\n some\n multiline\n stdout\n StdErr:\n some\n multiline\n stderr"))
})
})
}
func (i *instance) UpdateJobs(
deploymentManifest bideplmanifest.Manifest,
stage biui.Stage,
) error {
newState, err := i.stateBuilder.Build(i.jobName, i.id, deploymentManifest, stage)
if err != nil {
return bosherr.WrapErrorf(err, "Building state for instance '%s/%d'", i.jobName, i.id)
}
stepName := fmt.Sprintf("Updating instance '%s/%d'", i.jobName, i.id)
err = stage.Perform(stepName, func() error {
err := i.vm.Stop()
if err != nil {
return bosherr.WrapError(err, "Stopping the agent")
}
err = i.vm.Apply(newState.ToApplySpec())
if err != nil {
return bosherr.WrapError(err, "Applying the agent state")
}
err = i.vm.Start()
if err != nil {
return bosherr.WrapError(err, "Starting the agent")
}
return nil
})
if err != nil {
return err
}
return i.waitUntilJobsAreRunning(deploymentManifest.Update.UpdateWatchTime, stage)
}
func (r *reader) Read() (Release, error) {
err := r.extractor.DecompressFileToDir(r.tarFilePath, r.extractedReleasePath, boshcmd.CompressorOptions{})
if err != nil {
return nil, bosherr.WrapError(err, "Extracting release")
}
releaseManifestPath := path.Join(r.extractedReleasePath, "release.MF")
releaseManifestBytes, err := r.fs.ReadFile(releaseManifestPath)
if err != nil {
return nil, bosherr.WrapErrorf(err, "Reading release manifest '%s'", releaseManifestPath)
}
var manifest birelmanifest.Manifest
err = yaml.Unmarshal(releaseManifestBytes, &manifest)
if err != nil {
return nil, bosherr.WrapError(err, "Parsing release manifest")
}
release, err := r.newReleaseFromManifest(manifest)
if err != nil {
return nil, bosherr.WrapError(err, "Constructing release from manifest")
}
return release, nil
}
func (y DeploymentManifestParser) GetDeploymentManifest(deploymentManifestPath string, releaseSetManifest birelsetmanifest.Manifest, stage biui.Stage) (bideplmanifest.Manifest, error) {
var deploymentManifest bideplmanifest.Manifest
err := stage.Perform("Validating deployment manifest", func() error {
var err error
deploymentManifest, err = y.DeploymentParser.Parse(deploymentManifestPath)
if err != nil {
return bosherr.WrapErrorf(err, "Parsing deployment manifest '%s'", deploymentManifestPath)
}
err = y.DeploymentValidator.Validate(deploymentManifest, releaseSetManifest)
if err != nil {
return bosherr.WrapError(err, "Validating deployment manifest")
}
err = y.DeploymentValidator.ValidateReleaseJobs(deploymentManifest, y.ReleaseManager)
if err != nil {
return bosherr.WrapError(err, "Validating deployment jobs refer to jobs in release")
}
return nil
})
if err != nil {
return bideplmanifest.Manifest{}, err
}
return deploymentManifest, nil
}
func (net UbuntuNetManager) writeNetworkInterfaces(dhcpConfigs DHCPInterfaceConfigurations, staticConfigs StaticInterfaceConfigurations, dnsServers []string) (bool, error) {
sort.Stable(dhcpConfigs)
sort.Stable(staticConfigs)
networkInterfaceValues := networkInterfaceConfig{
DHCPConfigs: dhcpConfigs,
StaticConfigs: staticConfigs,
HasDNSNameServers: true,
DNSServers: dnsServers,
}
buffer := bytes.NewBuffer([]byte{})
t := template.Must(template.New("network-interfaces").Parse(networkInterfacesTemplate))
err := t.Execute(buffer, networkInterfaceValues)
if err != nil {
return false, bosherr.WrapError(err, "Generating config from template")
}
changed, err := net.fs.ConvergeFileContents("/etc/network/interfaces", buffer.Bytes())
if err != nil {
return changed, bosherr.WrapError(err, "Writing to /etc/network/interfaces")
}
return changed, nil
}
func (ms httpMetadataService) getUserData() (UserDataContentsType, error) {
var userData UserDataContentsType
err := ms.ensureMinimalNetworkSetup()
if err != nil {
return userData, err
}
userDataURL := fmt.Sprintf("%s/latest/user-data", ms.metadataHost)
userDataResp, err := http.Get(userDataURL)
if err != nil {
return userData, bosherr.WrapError(err, "Getting user data from url")
}
defer userDataResp.Body.Close()
userDataBytes, err := ioutil.ReadAll(userDataResp.Body)
if err != nil {
return userData, bosherr.WrapError(err, "Reading user data response body")
}
err = json.Unmarshal(userDataBytes, &userData)
if err != nil {
return userData, bosherr.WrapError(err, "Unmarshalling user data")
}
return userData, nil
}
func (p linux) MigratePersistentDisk(fromMountPoint, toMountPoint string) (err error) {
p.logger.Debug(logTag, "Migrating persistent disk %v to %v", fromMountPoint, toMountPoint)
err = p.diskManager.GetMounter().RemountAsReadonly(fromMountPoint)
if err != nil {
err = bosherr.WrapError(err, "Remounting persistent disk as readonly")
return
}
// Golang does not implement a file copy that would allow us to preserve dates...
// So we have to shell out to tar to perform the copy instead of delegating to the FileSystem
tarCopy := fmt.Sprintf("(tar -C %s -cf - .) | (tar -C %s -xpf -)", fromMountPoint, toMountPoint)
_, _, _, err = p.cmdRunner.RunCommand("sh", "-c", tarCopy)
if err != nil {
err = bosherr.WrapError(err, "Copying files from old disk to new disk")
return
}
_, err = p.diskManager.GetMounter().Unmount(fromMountPoint)
if err != nil {
err = bosherr.WrapError(err, "Unmounting old persistent disk")
return
}
err = p.diskManager.GetMounter().Remount(toMountPoint, fromMountPoint)
if err != nil {
err = bosherr.WrapError(err, "Remounting new disk on original mountpoint")
}
return
}
func (r erbRenderer) Render(srcPath, dstPath string, context TemplateEvaluationContext) error {
r.logger.Debug(r.logTag, "Rendering template %s", dstPath)
tmpDir, err := r.fs.TempDir("erb-renderer")
if err != nil {
return bosherr.WrapError(err, "Creating temporary directory")
}
defer r.fs.RemoveAll(tmpDir)
rendererScriptPath := filepath.Join(tmpDir, "erb-render.rb")
err = r.writeRendererScript(rendererScriptPath)
if err != nil {
return err
}
contextPath := filepath.Join(tmpDir, "erb-context.json")
err = r.writeContext(contextPath, context)
if err != nil {
return err
}
command := boshsys.Command{
Name: "ruby",
Args: []string{rendererScriptPath, contextPath, srcPath, dstPath},
}
_, _, _, err = r.runner.RunComplexCommand(command)
if err != nil {
return bosherr.WrapError(err, "Running ruby to render templates")
}
return nil
}
func (net centosNetManager) writeNetworkInterfaces(dhcpInterfaceConfigurations []DHCPInterfaceConfiguration, staticInterfaceConfigurations []StaticInterfaceConfiguration, dnsServers []string) (bool, error) {
anyInterfaceChanged := false
staticConfig := centosStaticIfcfg{}
staticConfig.DNSServers = newDNSConfigs(dnsServers)
staticTemplate := template.Must(template.New("ifcfg").Parse(centosStaticIfcfgTemplate))
for i := range staticInterfaceConfigurations {
staticConfig.StaticInterfaceConfiguration = &staticInterfaceConfigurations[i]
changed, err := net.writeIfcfgFile(staticConfig.StaticInterfaceConfiguration.Name, staticTemplate, staticConfig)
if err != nil {
return false, bosherr.WrapError(err, "Writing static config")
}
anyInterfaceChanged = anyInterfaceChanged || changed
}
dhcpTemplate := template.Must(template.New("ifcfg").Parse(centosDHCPIfcfgTemplate))
for i := range dhcpInterfaceConfigurations {
config := &dhcpInterfaceConfigurations[i]
changed, err := net.writeIfcfgFile(config.Name, dhcpTemplate, config)
if err != nil {
return false, bosherr.WrapError(err, "Writing dhcp config")
}
anyInterfaceChanged = anyInterfaceChanged || changed
}
return anyInterfaceChanged, nil
}
func (v *validator) Validate(release Release) error {
errs := []error{}
err := v.validateReleaseName(release)
if err != nil {
errs = append(errs, bosherr.WrapError(err, "Validating release name"))
}
err = v.validateReleaseVersion(release)
if err != nil {
errs = append(errs, bosherr.WrapError(err, "Validating release version"))
}
err = v.validateReleaseJobs(release)
if err != nil {
errs = append(errs, bosherr.WrapError(err, "Validating release jobs"))
}
err = v.validateReleasePackages(release)
if err != nil {
errs = append(errs, bosherr.WrapError(err, "Validating release packages"))
}
if len(errs) > 0 {
return bosherr.NewMultiError(errs...)
}
return nil
}
func (v *deploymentRecord) IsDeployed(manifestPath string, releases []birel.Release, stemcell bistemcell.ExtractedStemcell) (bool, error) {
manifestSHA1, found, err := v.deploymentRepo.FindCurrent()
if err != nil {
return false, bosherr.WrapError(err, "Finding sha1 of currently deployed manifest")
}
if !found {
return false, nil
}
newSHA1, err := v.sha1Calculator.Calculate(manifestPath)
if err != nil {
return false, bosherr.WrapError(err, "Calculating sha1 of current deployment manifest")
}
if manifestSHA1 != newSHA1 {
return false, nil
}
currentStemcell, found, err := v.stemcellRepo.FindCurrent()
if err != nil {
return false, bosherr.WrapError(err, "Finding currently deployed stemcell")
}
if !found {
return false, nil
}
if currentStemcell.Name != stemcell.Manifest().Name || currentStemcell.Version != stemcell.Manifest().Version {
return false, nil
}
currentReleaseRecords, err := v.releaseRepo.List()
if err != nil {
return false, bosherr.WrapError(err, "Finding currently deployed release")
}
if len(currentReleaseRecords) == 0 {
return false, nil
}
if len(releases) != len(currentReleaseRecords) {
return false, nil
}
for _, release := range releases {
found := false
for _, releaseRecord := range currentReleaseRecords {
if releaseRecord.Name == release.Name() && releaseRecord.Version == release.Version() {
found = true
break
}
}
if !found {
return false, nil
}
}
return true, nil
}
func (d *diskDeployer) Deploy(diskPool bideplmanifest.DiskPool, cloud bicloud.Cloud, vm VM, stage biui.Stage) ([]bidisk.Disk, error) {
if diskPool.DiskSize == 0 {
return []bidisk.Disk{}, nil
}
d.diskManager = d.diskManagerFactory.NewManager(cloud)
disks, err := d.diskManager.FindCurrent()
if err != nil {
return disks, bosherr.WrapError(err, "Finding existing disk")
}
if len(disks) > 1 {
return disks, bosherr.WrapError(err, "Multiple current disks not supported")
} else if len(disks) == 1 {
disks, err = d.deployExistingDisk(disks[0], diskPool, vm, stage)
if err != nil {
return disks, err
}
} else {
disks, err = d.deployNewDisk(diskPool, vm, stage)
if err != nil {
return disks, err
}
}
err = d.diskManager.DeleteUnused(stage)
if err != nil {
return disks, err
}
return disks, nil
}
func (r *reader) newReleaseFromManifest(releaseManifest birelmanifest.Manifest) (Release, error) {
errors := []error{}
packages, isCompiledRelease, err := r.newPackagesFromManifestPackages(releaseManifest)
if err != nil {
errors = append(errors, bosherr.WrapError(err, "Constructing packages from manifest"))
}
jobs, err := r.newJobsFromManifestJobs(packages, releaseManifest.Jobs)
if err != nil {
errors = append(errors, bosherr.WrapError(err, "Constructing jobs from manifest"))
}
if len(errors) > 0 {
return nil, bosherr.NewMultiError(errors...)
}
release := &release{
name: releaseManifest.Name,
version: releaseManifest.Version,
jobs: jobs,
packages: packages,
extractedPath: r.extractedReleasePath,
fs: r.fs,
isCompiled: isCompiledRelease,
}
return release, nil
}
func (s concreteService) Get() (vitals Vitals, err error) {
var (
loadStats boshstats.CPULoad
cpuStats boshstats.CPUStats
memStats boshstats.Usage
swapStats boshstats.Usage
diskStats DiskVitals
)
loadStats, err = s.statsCollector.GetCPULoad()
if err != nil {
err = bosherr.WrapError(err, "Getting CPU Load")
return
}
cpuStats, err = s.statsCollector.GetCPUStats()
if err != nil {
err = bosherr.WrapError(err, "Getting CPU Stats")
return
}
memStats, err = s.statsCollector.GetMemStats()
if err != nil {
err = bosherr.WrapError(err, "Getting Memory Stats")
return
}
swapStats, err = s.statsCollector.GetSwapStats()
if err != nil {
err = bosherr.WrapError(err, "Getting Swap Stats")
return
}
diskStats, err = s.getDiskStats()
if err != nil {
err = bosherr.WrapError(err, "Getting Disk Stats")
return
}
vitals = Vitals{
Load: []string{
fmt.Sprintf("%.2f", loadStats.One),
fmt.Sprintf("%.2f", loadStats.Five),
fmt.Sprintf("%.2f", loadStats.Fifteen),
},
CPU: CPUVitals{
User: cpuStats.UserPercent().FormatFractionOf100(1),
Sys: cpuStats.SysPercent().FormatFractionOf100(1),
Wait: cpuStats.WaitPercent().FormatFractionOf100(1),
},
Mem: createMemVitals(memStats),
Swap: createMemVitals(swapStats),
Disk: diskStats,
}
return
}
func (m *manager) Create(stemcell bistemcell.CloudStemcell, deploymentManifest bideplmanifest.Manifest) (VM, error) {
jobName := deploymentManifest.JobName()
networkInterfaces, err := deploymentManifest.NetworkInterfaces(jobName)
m.logger.Debug(m.logTag, "Creating VM with network interfaces: %#v", networkInterfaces)
if err != nil {
return nil, bosherr.WrapError(err, "Getting network spec")
}
resourcePool, err := deploymentManifest.ResourcePool(jobName)
if err != nil {
return nil, bosherr.WrapErrorf(err, "Getting resource pool for job '%s'", jobName)
}
agentID, err := m.uuidGenerator.Generate()
if err != nil {
return nil, bosherr.WrapError(err, "Generating agent ID")
}
cid, err := m.createAndRecordVm(agentID, stemcell, resourcePool, networkInterfaces)
if err != nil {
return nil, err
}
metadata := bicloud.VMMetadata{
Deployment: deploymentManifest.Name,
Job: deploymentManifest.JobName(),
Index: "0",
Director: "bosh-init",
}
err = m.cloud.SetVMMetadata(cid, metadata)
if err != nil {
cloudErr, ok := err.(bicloud.Error)
if ok && cloudErr.Type() == bicloud.NotImplementedError {
//ignore it
} else {
return nil, bosherr.WrapErrorf(err, "Setting VM metadata to %s", metadata)
}
}
vm := NewVM(
cid,
m.vmRepo,
m.stemcellRepo,
m.diskDeployer,
m.agentClient,
m.cloud,
m.fs,
m.logger,
)
return vm, nil
}
func (i *instance) UpdateDisks(deploymentManifest bideplmanifest.Manifest, stage biui.Stage) ([]bidisk.Disk, error) {
diskPool, err := deploymentManifest.DiskPool(i.jobName)
if err != nil {
return []bidisk.Disk{}, bosherr.WrapError(err, "Getting disk pool")
}
disks, err := i.vm.UpdateDisks(diskPool, stage)
if err != nil {
return disks, bosherr.WrapError(err, "Updating disks")
}
return disks, nil
}
// Compile resolves and compiles all transitive dependencies of multiple release jobs
func (c *dependencyCompiler) Compile(releaseJobs []bireljob.Job, stage biui.Stage) ([]CompiledPackageRef, error) {
compileOrderReleasePackages, err := c.resolveJobCompilationDependencies(releaseJobs)
if err != nil {
return nil, bosherr.WrapError(err, "Resolving job package dependencies")
}
compiledPackageRefs, err := c.compilePackages(compileOrderReleasePackages, stage)
if err != nil {
return nil, bosherr.WrapError(err, "Compiling job package dependencies")
}
return compiledPackageRefs, nil
}
func (r erbRenderer) writeContext(contextPath string, context TemplateEvaluationContext) error {
contextBytes, err := json.Marshal(context)
if err != nil {
return bosherr.WrapError(err, "Marshalling context")
}
err = r.fs.WriteFileString(contextPath, string(contextBytes))
if err != nil {
return bosherr.WrapError(err, "Writing context")
}
return nil
}
