func (s *renderedJobApplier) downloadAndInstall(job models.Job, jobBundle boshbc.Bundle) error {
tmpDir, err := s.fs.TempDir("bosh-agent-applier-jobs-RenderedJobApplier-Apply")
if err != nil {
return bosherr.WrapError(err, "Getting temp dir")
}
defer func() {
if err = s.fs.RemoveAll(tmpDir); err != nil {
s.logger.Warn(logTag, "Failed to clean up temp directory: %s", err.Error())
}
}()
digest, err := boshcrypto.ParseDigestString(job.Source.Sha1)
if err != nil {
return bosherr.WrapError(err, "Parsing job blob digest")
}
file, err := s.blobstore.Get(job.Source.BlobstoreID, digest)
if err != nil {
return bosherr.WrapError(err, "Getting job source from blobstore")
}
defer func() {
if err = s.blobstore.CleanUp(file); err != nil {
s.logger.Warn(logTag, "Failed to clean up blobstore blob: %s", err.Error())
}
}()
err = s.compressor.DecompressFileToDir(file, tmpDir, boshcmd.CompressorOptions{})
if err != nil {
return bosherr.WrapError(err, "Decompressing files to temp dir")
}
binPath := path.Join(tmpDir, job.Source.PathInArchive, "bin") + "/"
err = s.fs.Walk(path.Join(tmpDir, job.Source.PathInArchive), func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
} else if info.IsDir() || strings.HasPrefix(path, binPath) {
return s.fs.Chmod(path, os.FileMode(0755))
} else {
return s.fs.Chmod(path, os.FileMode(0644))
}
})
if err != nil {
return bosherr.WrapError(err, "Correcting file permissions")
}
_, _, err = jobBundle.Install(path.Join(tmpDir, job.Source.PathInArchive))
if err != nil {
return bosherr.WrapError(err, "Installing job bundle")
}
return nil
}
func (s *compiledPackageApplier) downloadAndInstall(pkg models.Package, pkgBundle bc.Bundle) error {
tmpDir, err := s.fs.TempDir("bosh-agent-applier-packages-CompiledPackageApplier-Apply")
if err != nil {
return bosherr.WrapError(err, "Getting temp dir")
}
defer func() {
if err = s.fs.RemoveAll(tmpDir); err != nil {
s.logger.Warn(logTag, "Failed to clean up tmpDir: %s", err.Error())
}
}()
digest, err := boshcrypto.ParseDigestString(pkg.Source.Sha1)
if err != nil {
return bosherr.WrapError(err, "Parsing package blob digest")
}
file, err := s.blobstore.Get(pkg.Source.BlobstoreID, digest)
if err != nil {
return bosherr.WrapError(err, "Fetching package blob")
}
defer func() {
if err = s.blobstore.CleanUp(file); err != nil {
s.logger.Warn(logTag, "Failed to clean up blobstore blob: %s", err.Error())
}
}()
err = s.compressor.DecompressFileToDir(file, tmpDir, boshcmd.CompressorOptions{})
if err != nil {
return bosherr.WrapError(err, "Decompressing package files")
}
_, _, err = pkgBundle.Install(tmpDir)
if err != nil {
return bosherr.WrapError(err, "Installling package directory")
}
return nil
}
func (a SyncDNS) Run(blobID, digestString string, version uint64) (string, error) {
requestVersionStale, err := a.isLocalStateGreaterThanOrEqual(version)
if err != nil {
return "", bosherr.WrapError(err, "reading local DNS state")
}
if requestVersionStale {
return "synced", nil
}
digest, err := boshcrypto.ParseDigestString(digestString)
if err != nil {
return "", bosherr.WrapError(err, "Parsing blob digest")
}
filePath, err := a.blobstore.Get(blobID, digest)
if err != nil {
return "", bosherr.WrapErrorf(err, "getting %s from blobstore", blobID)
}
fs := a.platform.GetFs()
defer func() {
err = fs.RemoveAll(filePath)
if err != nil {
a.logger.Error(a.logTag, fmt.Sprintf("Failed to remove dns blob file at path '%s'", filePath))
}
}()
contents, err := fs.ReadFile(filePath)
if err != nil {
return "", bosherr.WrapErrorf(err, "reading %s from blobstore", filePath)
}
dnsRecords := boshsettings.DNSRecords{}
err = json.Unmarshal(contents, &dnsRecords)
if err != nil {
return "", bosherr.WrapError(err, "unmarshalling DNS records")
}
a.lock.Lock()
defer a.lock.Unlock()
localDNSState := state.LocalDNSState{}
syncDNSState := a.createSyncDNSState()
if syncDNSState.StateFileExists() {
localDNSState, err = syncDNSState.LoadState()
if err != nil {
return "", bosherr.WrapError(err, "loading local DNS state")
}
}
//Checking again since don't want to keep lock during blobstore operations
if localDNSState.Version >= version {
return "synced", nil
}
localDNSState.Version = version
err = syncDNSState.SaveState(localDNSState)
if err != nil {
return "", bosherr.WrapError(err, "saving local DNS state")
}
err = a.platform.SaveDNSRecords(dnsRecords, a.settingsService.GetSettings().AgentID)
if err != nil {
return "", bosherr.WrapError(err, "saving DNS records")
}
return "synced", nil
}