// compilePackages compiles the specified packages, in the order specified, uploads them to the Blobstore, and returns the blob references
func (c *dependencyCompiler) compilePackages(requiredPackages []*birelpkg.Package, stage biui.Stage) ([]CompiledPackageRef, error) {
packageRefs := make([]CompiledPackageRef, 0, len(requiredPackages))
for _, pkg := range requiredPackages {
stepName := fmt.Sprintf("Compiling package '%s/%s'", pkg.Name, pkg.Fingerprint)
err := stage.Perform(stepName, func() error {
compiledPackageRecord, isAlreadyCompiled, err := c.packageCompiler.Compile(pkg)
if err != nil {
return err
}
packageRef := CompiledPackageRef{
Name: pkg.Name,
Version: pkg.Fingerprint,
BlobstoreID: compiledPackageRecord.BlobID,
SHA1: compiledPackageRecord.BlobSHA1,
}
packageRefs = append(packageRefs, packageRef)
if isAlreadyCompiled {
return biui.NewSkipStageError(bosherr.Error(fmt.Sprintf("Package '%s' is already compiled. Skipped compilation", pkg.Name)), "Package already compiled")
}
return nil
})
if err != nil {
return nil, err
}
}
return packageRefs, nil
}
// Upload stemcell to an IAAS. It does the following steps:
// 1) uploads the stemcell to the cloud (if needed),
// 2) saves a record of the uploaded stemcell in the repo
func (m *manager) Upload(extractedStemcell ExtractedStemcell, uploadStage biui.Stage) (cloudStemcell CloudStemcell, err error) {
manifest := extractedStemcell.Manifest()
stageName := fmt.Sprintf("Uploading stemcell '%s/%s'", manifest.Name, manifest.Version)
err = uploadStage.Perform(stageName, func() error {
foundStemcellRecord, found, err := m.repo.Find(manifest.Name, manifest.Version)
if err != nil {
return bosherr.WrapError(err, "Finding existing stemcell record in repo")
}
if found {
cloudStemcell = NewCloudStemcell(foundStemcellRecord, m.repo, m.cloud)
return biui.NewSkipStageError(bosherr.Errorf("Found stemcell: %#v", foundStemcellRecord), "Stemcell already uploaded")
}
cid, err := m.cloud.CreateStemcell(manifest.ImagePath, manifest.CloudProperties)
if err != nil {
return bosherr.WrapErrorf(err, "creating stemcell (%s %s)", manifest.Name, manifest.Version)
}
stemcellRecord, err := m.repo.Save(manifest.Name, manifest.Version, cid)
if err != nil {
//TODO: delete stemcell from cloud when saving fails
return bosherr.WrapErrorf(err, "saving stemcell record in repo (cid=%s, stemcell=%s)", cid, extractedStemcell)
}
cloudStemcell = NewCloudStemcell(stemcellRecord, m.repo, m.cloud)
return nil
})
if err != nil {
return cloudStemcell, err
}
return cloudStemcell, nil
}
func (i *instance) Delete(
pingTimeout time.Duration,
pingDelay time.Duration,
stage biui.Stage,
) error {
vmExists, err := i.vm.Exists()
if err != nil {
return bosherr.WrapErrorf(err, "Checking existance of vm for instance '%s/%d'", i.jobName, i.id)
}
if vmExists {
if err = i.shutdown(pingTimeout, pingDelay, stage); err != nil {
return err
}
}
// non-existent VMs still need to be 'deleted' to clean up related resources owned by the CPI
stepName := fmt.Sprintf("Deleting VM '%s'", i.vm.CID())
return stage.Perform(stepName, func() error {
err := i.vm.Delete()
cloudErr, ok := err.(bicloud.Error)
if ok && cloudErr.Type() == bicloud.VMNotFoundError {
return biui.NewSkipStageError(cloudErr, "VM not found")
}
return err
})
}
func (d *deployment) deleteStemcell(deleteStage biui.Stage, stemcell bistemcell.CloudStemcell) error {
stepName := fmt.Sprintf("Deleting stemcell '%s'", stemcell.CID())
return deleteStage.Perform(stepName, func() error {
err := stemcell.Delete()
cloudErr, ok := err.(bicloud.Error)
if ok && cloudErr.Type() == bicloud.StemcellNotFoundError {
return biui.NewSkipStageError(cloudErr, "Stemcell not found")
}
return err
})
}
func (d *deployment) deleteDisk(deleteStage biui.Stage, disk bidisk.Disk) error {
stepName := fmt.Sprintf("Deleting disk '%s'", disk.CID())
return deleteStage.Perform(stepName, func() error {
err := disk.Delete()
cloudErr, ok := err.(bicloud.Error)
if ok && cloudErr.Type() == bicloud.DiskNotFoundError {
return biui.NewSkipStageError(cloudErr, "Disk not found")
}
return err
})
}
func (p *provider) Get(source Source, stage biui.Stage) (string, error) {
if strings.HasPrefix(source.GetURL(), "file://") {
filePath := strings.TrimPrefix(source.GetURL(), "file://")
expandedPath, err := p.fs.ExpandPath(filePath)
if err != nil {
p.logger.Warn(p.logTag, "Failed to expand file path %s, using original URL", filePath)
return filePath, nil
}
p.logger.Debug(p.logTag, "Using the tarball from file source: '%s'", filePath)
return expandedPath, nil
}
if !strings.HasPrefix(source.GetURL(), "http") {
return "", bosherr.Errorf("Invalid source URL: '%s', must be either file:// or http(s)://", source.GetURL())
}
var cachedPath string
err := stage.Perform(fmt.Sprintf("Downloading %s", source.Description()), func() error {
var found bool
cachedPath, found = p.cache.Get(source)
if found {
p.logger.Debug(p.logTag, "Using the tarball from cache: '%s'", cachedPath)
return biui.NewSkipStageError(bosherr.Error("Already downloaded"), "Found in local cache")
}
retryStrategy := boshretry.NewAttemptRetryStrategy(p.downloadAttempts, p.delayTimeout, p.downloadRetryable(source), p.logger)
err := retryStrategy.Try()
if err != nil {
return bosherr.WrapErrorf(err, "Failed to download from '%s'", source.GetURL())
}
p.logger.Debug(p.logTag, "Using the downloaded tarball: '%s'", cachedPath)
return nil
})
if err != nil {
return "", err
}
return p.cache.Path(source), nil
}
func (m *manager) DeleteUnused(deleteStage biui.Stage) error {
stemcells, err := m.FindUnused()
if err != nil {
return bosherr.WrapError(err, "Finding unused stemcells")
}
for _, stemcell := range stemcells {
stepName := fmt.Sprintf("Deleting unused stemcell '%s'", stemcell.CID())
err = deleteStage.Perform(stepName, func() error {
err := stemcell.Delete()
cloudErr, ok := err.(bicloud.Error)
if ok && cloudErr.Type() == bicloud.StemcellNotFoundError {
return biui.NewSkipStageError(cloudErr, "Stemcell not found")
}
return err
})
if err != nil {
return err
}
}
return nil
}
func (m *manager) DeleteUnused(eventLoggerStage biui.Stage) error {
disks, err := m.FindUnused()
if err != nil {
return bosherr.WrapError(err, "Finding unused disks")
}
for _, disk := range disks {
stepName := fmt.Sprintf("Deleting unused disk '%s'", disk.CID())
err = eventLoggerStage.Perform(stepName, func() error {
err := disk.Delete()
cloudErr, ok := err.(bicloud.Error)
if ok && cloudErr.Type() == bicloud.DiskNotFoundError {
return biui.NewSkipStageError(cloudErr, "Disk Not Found")
}
return err
})
if err != nil {
return err
}
}
return nil
}