BeforeEach(func() {
mockCtrl = gomock.NewController(GinkgoT())
})
AfterEach(func() {
mockCtrl.Finish()
})
var (
logger boshlog.Logger
compiler bistatepkg.Compiler
runner *fakesys.FakeCmdRunner
pkg *birelpkg.Package
fs *fakesys.FakeFileSystem
compressor *fakecmd.FakeCompressor
packagesDir string
blobstore *fakeblobstore.FakeBlobstore
mockCompiledPackageRepo *mock_state_package.MockCompiledPackageRepo
fakeExtractor *fakeblobextract.FakeExtractor
dependency1 *birelpkg.Package
dependency2 *birelpkg.Package
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
packagesDir = "fake-packages-dir"
runner = fakesys.NewFakeCmdRunner()
fs = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
func init() {
Describe("concreteCompiler", func() {
var (
compiler Compiler
compressor *fakecmd.FakeCompressor
blobstore *fakeblobstore.FakeBlobstore
fs *fakesys.FakeFileSystem
runner *fakecmdrunner.FakeFileLoggingCmdRunner
packageApplier *fakepackages.FakeApplier
packagesBc *fakebc.FakeBundleCollection
)
BeforeEach(func() {
compressor = fakecmd.NewFakeCompressor()
blobstore = &fakeblobstore.FakeBlobstore{}
fs = fakesys.NewFakeFileSystem()
runner = fakecmdrunner.NewFakeFileLoggingCmdRunner()
packageApplier = fakepackages.NewFakeApplier()
packagesBc = fakebc.NewFakeBundleCollection()
compiler = NewConcreteCompiler(
compressor,
blobstore,
fs,
runner,
FakeCompileDirProvider{Dir: "/fake-compile-dir"},
packageApplier,
packagesBc,
)
})
BeforeEach(func() {
fs.MkdirAll("/fake-compile-dir", os.ModePerm)
})
Describe("Compile", func() {
var (
bundle *fakebc.FakeBundle
pkg Package
pkgDeps []boshmodels.Package
)
BeforeEach(func() {
bundle = packagesBc.FakeGet(boshmodels.Package{
Name: "pkg_name",
Version: "pkg_version",
})
bundle.InstallPath = "/fake-dir/data/packages/pkg_name/pkg_version"
bundle.EnablePath = "/fake-dir/packages/pkg_name"
compressor.CompressFilesInDirTarballPath = "/tmp/compressed-compiled-package"
pkg, pkgDeps = getCompileArgs()
})
It("returns blob id and sha1 of created compiled package", func() {
blobstore.CreateBlobID = "fake-blob-id"
blobstore.CreateFingerprint = "fake-blob-sha1"
blobID, sha1, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(blobID).To(Equal("fake-blob-id"))
Expect(sha1).To(Equal("fake-blob-sha1"))
})
It("cleans up all packages before and after applying dependent packages", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.ActionsCalled).To(Equal([]string{"KeepOnly", "Apply", "Apply", "KeepOnly"}))
Expect(packageApplier.KeptOnlyPackages).To(BeEmpty())
})
It("returns an error if cleaning up packages fails", func() {
packageApplier.KeepOnlyErr = errors.New("fake-keep-only-error")
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-error"))
})
It("fetches source package from blobstore without checking SHA1 by default because of Director bug", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("blobstore_id"))
Expect(blobstore.GetFingerprints[0]).To(Equal(""))
})
PIt("(Pending Tracker Story: <https://www.pivotaltracker.com/story/show/94524232>) fetches source package from blobstore and checks SHA1 by default in future", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("blobstore_id"))
Expect(blobstore.GetFingerprints[0]).To(Equal("sha1"))
})
It("returns an error if removing compile target directory during uncompression fails", func() {
fs.RemoveAllStub = func(path string) error {
if path == "/fake-compile-dir/pkg_name" {
return errors.New("fake-remove-error")
}
return nil
}
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-error"))
})
It("returns an error if creating compile target directory during uncompression fails", func() {
fs.RemoveAllStub = func(path string) error {
if path == "/fake-compile-dir/pkg_name" {
return errors.New("fake-mkdir-error")
}
return nil
}
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-error"))
})
It("returns an error if removing temporary compile target directory during uncompression fails", func() {
fs.RemoveAllStub = func(path string) error {
if path == "/fake-compile-dir/pkg_name-bosh-agent-unpack" {
return errors.New("fake-remove-error")
}
return nil
}
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-error"))
})
It("returns an error if creating temporary compile target directory during uncompression fails", func() {
fs.RegisterMkdirAllError("/fake-compile-dir/pkg_name-bosh-agent-unpack", errors.New("fake-mkdir-error"))
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-error"))
})
It("returns an error if target directory is empty during uncompression", func() {
pkg.BlobstoreID = ""
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Blobstore ID for package '%s' is empty", pkg.Name))
})
It("installs dependent packages", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.AppliedPackages).To(Equal(pkgDeps))
})
It("cleans up the compile directory", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("/fake-compile-dir/pkg_name")).To(BeFalse())
})
It("installs, enables and later cleans up bundle", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{
"InstallWithoutContents",
"Enable",
"Disable",
"Uninstall",
}))
})
It("returns an error if removing the compile directory fails", func() {
callCount := 0
fs.RemoveAllStub = func(path string) error {
if path == "/fake-compile-dir/pkg_name" {
callCount++
if callCount > 1 {
return errors.New("fake-remove-error")
}
}
return nil
}
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-error"))
})
Context("when packaging script exists", func() {
const packagingScriptContents = "hi"
BeforeEach(func() {
compressor.DecompressFileToDirCallBack = func() {
filename := "/fake-compile-dir/pkg_name/" + PackagingScriptName
fs.WriteFileString(filename, packagingScriptContents)
}
})
It("runs packaging script ", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
expectedCmd := boshsys.Command{
Env: map[string]string{
"BOSH_COMPILE_TARGET": "/fake-compile-dir/pkg_name",
"BOSH_INSTALL_TARGET": "/fake-dir/packages/pkg_name",
"BOSH_PACKAGE_NAME": "pkg_name",
"BOSH_PACKAGE_VERSION": "pkg_version",
},
WorkingDir: "/fake-compile-dir/pkg_name",
}
cmd := runner.RunCommands[0]
if runtime.GOOS == "windows" {
expectedCmd.Name = "powershell"
expectedCmd.Args = []string{"-command", fmt.Sprintf(`"iex (get-content -raw %s)"`, PackagingScriptName)}
} else {
expectedCmd.Name = "bash"
expectedCmd.Args = []string{"-x", PackagingScriptName}
}
Expect(cmd).To(Equal(expectedCmd))
Expect(len(runner.RunCommands)).To(Equal(1))
Expect(runner.RunCommandJobName).To(Equal("compilation"))
Expect(runner.RunCommandTaskName).To(Equal(PackagingScriptName))
})
It("propagates the error from packaging script", func() {
runner.RunCommandErr = errors.New("fake-packaging-error")
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-packaging-error"))
})
})
It("does not run packaging script when script does not exist", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(runner.RunCommands).To(BeEmpty())
})
It("compresses compiled package", func() {
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
// archive was downloaded from the blobstore and decompress to this temp dir
Expect(compressor.DecompressFileToDirDirs[0]).To(Equal("/fake-compile-dir/pkg_name-bosh-agent-unpack"))
Expect(compressor.DecompressFileToDirTarballPaths[0]).To(Equal(blobstore.GetFileName))
// contents were moved from the temp dir to the install/enable dir
Expect(fs.RenameOldPaths[0]).To(Equal("/fake-compile-dir/pkg_name-bosh-agent-unpack"))
Expect(fs.RenameNewPaths[0]).To(Equal("/fake-compile-dir/pkg_name"))
// install path, presumably with your packaged code, was compressed
installPath := "/fake-dir/data/packages/pkg_name/pkg_version"
Expect(compressor.CompressFilesInDirDir).To(Equal(installPath))
})
It("uploads compressed package to blobstore", func() {
compressor.CompressFilesInDirTarballPath = "/tmp/compressed-compiled-package"
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.CreateFileNames[0]).To(Equal("/tmp/compressed-compiled-package"))
})
It("returs error if uploading compressed package fails", func() {
blobstore.CreateErr = errors.New("fake-create-err")
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-create-err"))
})
It("cleans up compressed package after uploading it to blobstore", func() {
var beforeCleanUpTarballPath, afterCleanUpTarballPath string
blobstore.CreateCallBack = func() {
beforeCleanUpTarballPath = compressor.CleanUpTarballPath
}
_, _, err := compiler.Compile(pkg, pkgDeps)
Expect(err).ToNot(HaveOccurred())
// Compressed package is not cleaned up before blobstore upload
Expect(beforeCleanUpTarballPath).To(Equal(""))
// Deleted after it was uploaded
afterCleanUpTarballPath = compressor.CleanUpTarballPath
Expect(afterCleanUpTarballPath).To(Equal("/tmp/compressed-compiled-package"))
})
})
})
}
fakeblobstore "github.com/cloudfoundry/bosh-utils/blobstore/fakes"
fakecmd "github.com/cloudfoundry/bosh-utils/fileutil/fakes"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Extractor", func() {
var (
extractor Extractor
blobstore *fakeblobstore.FakeBlobstore
targetDir string
compressor *fakecmd.FakeCompressor
logger boshlog.Logger
fs *fakesys.FakeFileSystem
blobID string
blobSHA1 string
fileName string
fakeError error
)
BeforeEach(func() {
blobstore = fakeblobstore.NewFakeBlobstore()
targetDir = "fake-target-dir"
compressor = fakecmd.NewFakeCompressor()
logger = boshlog.NewLogger(boshlog.LevelNone)
fs = fakesys.NewFakeFileSystem()
blobID = "fake-blob-id"
blobSHA1 = "fake-sha1"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-agent/agent/action"
boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories"
boshassert "github.com/cloudfoundry/bosh-utils/assert"
fakeblobstore "github.com/cloudfoundry/bosh-utils/blobstore/fakes"
fakecmd "github.com/cloudfoundry/bosh-utils/fileutil/fakes"
)
var _ = Describe("FetchLogsAction", func() {
var (
compressor *fakecmd.FakeCompressor
copier *fakecmd.FakeCopier
blobstore *fakeblobstore.FakeBlobstore
dirProvider boshdirs.Provider
action FetchLogsAction
)
BeforeEach(func() {
compressor = fakecmd.NewFakeCompressor()
blobstore = &fakeblobstore.FakeBlobstore{}
dirProvider = boshdirs.NewProvider("/fake/dir")
copier = fakecmd.NewFakeCopier()
action = NewFetchLogs(compressor, copier, blobstore, dirProvider)
})
It("logs should be asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
bireljob "github.com/cloudfoundry/bosh-init/release/job"
birelpkg "github.com/cloudfoundry/bosh-init/release/pkg"
bosherr "github.com/cloudfoundry/bosh-utils/errors"
fakecmd "github.com/cloudfoundry/bosh-utils/fileutil/fakes"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-utils/system/fakes"
fakebirel "github.com/cloudfoundry/bosh-init/release/fakes"
)
var _ = Describe("Extractor", func() {
var (
fakeFS *fakesys.FakeFileSystem
compressor *fakecmd.FakeCompressor
fakeReleaseValidator *fakebirel.FakeValidator
releaseExtractor Extractor
)
BeforeEach(func() {
fakeFS = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
fakeReleaseValidator = fakebirel.NewFakeValidator()
logger := boshlog.NewLogger(boshlog.LevelNone)
releaseExtractor = NewExtractor(fakeFS, compressor, fakeReleaseValidator, logger)
})
Describe("Extract", func() {
var (
releaseTarballPath string
)
Expect(err).ToNot(HaveOccurred())
Expect(content).To(Equal("fake-rendered-job-0-script-0-content"))
content, err = fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-0", "script-1"))
Expect(err).ToNot(HaveOccurred())
Expect(content).To(Equal("fake-rendered-job-0-script-1-content"))
// verify that archive contained rendered scripts from job 1
content, err = fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-1", "script-0"))
Expect(err).ToNot(HaveOccurred())
Expect(content).To(Equal("fake-rendered-job-1-script-0-content"))
})
})
Context("with a fake fs & compressor", func() {
var (
fakeFS *fakeboshsys.FakeFileSystem
fakeCompressor *fakeboshcmd.FakeCompressor
)
BeforeEach(func() {
fakeFS = fakeboshsys.NewFakeFileSystem()
fakeCompressor = fakeboshcmd.NewFakeCompressor()
renderedJobListCompressor = NewRenderedJobListCompressor(fakeFS, fakeCompressor, fakeSHA1Calculator, logger)
})
It("calculates the fingerprint of the rendered", func() {
fakeFS.TempDirDir = "fake-rendered-job-list-path"
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-rendered-job-list-path": fakebicrypto.CalculateInput{Sha1: "fake-sha1"},
func init() {
Describe("compiledPackageApplier", func() {
var (
packagesBc *fakebc.FakeBundleCollection
blobstore *fakeblob.FakeBlobstore
compressor *fakecmd.FakeCompressor
fs *fakesys.FakeFileSystem
logger boshlog.Logger
applier Applier
)
BeforeEach(func() {
packagesBc = fakebc.NewFakeBundleCollection()
blobstore = fakeblob.NewFakeBlobstore()
compressor = fakecmd.NewFakeCompressor()
fs = fakesys.NewFakeFileSystem()
logger = boshlog.NewLogger(boshlog.LevelNone)
applier = NewCompiledPackageApplier(packagesBc, true, blobstore, compressor, fs, logger)
})
Describe("Prepare & Apply", func() {
var (
pkg models.Package
bundle *fakebc.FakeBundle
)
BeforeEach(func() {
pkg, bundle = buildPkg(packagesBc)
})
ItInstallsPkg := func(act func() error) {
It("returns error when installing package fails", func() {
bundle.InstallError = errors.New("fake-install-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-install-error"))
})
It("downloads and later cleans up downloaded package blob", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("fake-blobstore-id"))
Expect(blobstore.GetFingerprints[0]).To(Equal("fake-blob-sha1"))
// downloaded file is cleaned up
Expect(blobstore.CleanUpFileName).To(Equal("/fake-blobstore-file-name"))
})
It("returns error when downloading package blob fails", func() {
blobstore.GetError = errors.New("fake-get-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-error"))
})
It("decompresses package blob to tmp path and later cleans it up", func() {
fs.TempDirDir = "/fake-tmp-dir"
blobstore.GetFileName = "/fake-blobstore-file-name"
var tmpDirExistsBeforeInstall bool
bundle.InstallCallBack = func() {
tmpDirExistsBeforeInstall = true
}
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(compressor.DecompressFileToDirTarballPaths[0]).To(Equal("/fake-blobstore-file-name"))
Expect(compressor.DecompressFileToDirDirs[0]).To(Equal("/fake-tmp-dir"))
// tmp dir exists before bundle install
Expect(tmpDirExistsBeforeInstall).To(BeTrue())
// tmp dir is cleaned up after install
Expect(fs.FileExists(fs.TempDirDir)).To(BeFalse())
})
It("returns error when temporary directory creation fails", func() {
fs.TempDirError = errors.New("fake-filesystem-tempdir-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-filesystem-tempdir-error"))
})
It("returns error when decompressing package blob fails", func() {
compressor.DecompressFileToDirErr = errors.New("fake-decompress-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-decompress-error"))
})
It("installs bundle from decompressed tmp path of a package blob", func() {
fs.TempDirDir = "/fake-tmp-dir"
var installedBeforeDecompression bool
compressor.DecompressFileToDirCallBack = func() {
installedBeforeDecompression = bundle.Installed
}
err := act()
Expect(err).ToNot(HaveOccurred())
// bundle installation did not happen before decompression
Expect(installedBeforeDecompression).To(BeFalse())
// make sure that bundle install happened after decompression
Expect(bundle.InstallSourcePath).To(Equal("/fake-tmp-dir"))
})
}
Describe("Prepare", func() {
act := func() error { return applier.Prepare(pkg) }
It("return an error if getting file bundle fails", func() {
packagesBc.GetErr = errors.New("fake-get-bundle-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-bundle-error"))
})
It("returns an error if checking for package installation fails", func() {
bundle.IsInstalledErr = errors.New("fake-is-installed-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-installed-error"))
})
Context("when package is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{})) // no Install
})
It("does not download the package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
})
Context("when package is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs package (but does not enable it)", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install"}))
})
ItInstallsPkg(act)
})
})
Describe("Apply", func() {
act := func() error { return applier.Apply(pkg) }
It("return an error if getting file bundle fails", func() {
packagesBc.GetErr = errors.New("fake-get-bundle-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-bundle-error"))
})
It("returns an error if checking for package installation fails", func() {
bundle.IsInstalledErr = errors.New("fake-is-installed-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-installed-error"))
})
Context("when package is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install but only enables package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Enable"})) // no Install
})
It("returns error when package enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
It("does not download the package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
})
Context("when package is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs and enables package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install", "Enable"}))
})
It("returns error when package enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
ItInstallsPkg(act)
})
})
})
Describe("KeepOnly", func() {
ItReturnsErrors := func() {
It("returns error when bundle collection fails to return list of installed bundles", func() {
packagesBc.ListErr = errors.New("fake-bc-list-error")
err := applier.KeepOnly([]models.Package{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-list-error"))
})
It("returns error when bundle collection cannot retrieve bundle for keep-only package", func() {
pkg1, bundle1 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1}
packagesBc.GetErr = errors.New("fake-bc-get-error")
err := applier.KeepOnly([]models.Package{pkg1})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-get-error"))
})
It("returns error when at least one bundle cannot be disabled", func() {
_, bundle1 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.DisableErr = errors.New("fake-bc-disable-error")
err := applier.KeepOnly([]models.Package{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-disable-error"))
})
}
Context("when operating on packages as a package owner", func() {
BeforeEach(func() {
applier = NewCompiledPackageApplier(packagesBc, true, blobstore, compressor, fs, logger)
})
It("first disables and then uninstalls packages that are not in keeponly list", func() {
_, bundle1 := buildPkg(packagesBc)
pkg2, bundle2 := buildPkg(packagesBc)
_, bundle3 := buildPkg(packagesBc)
pkg4, bundle4 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1, bundle2, bundle3, bundle4}
err := applier.KeepOnly([]models.Package{pkg4, pkg2})
Expect(err).ToNot(HaveOccurred())
Expect(bundle1.ActionsCalled).To(Equal([]string{"Disable", "Uninstall"}))
Expect(bundle2.ActionsCalled).To(Equal([]string{}))
Expect(bundle3.ActionsCalled).To(Equal([]string{"Disable", "Uninstall"}))
Expect(bundle4.ActionsCalled).To(Equal([]string{}))
})
ItReturnsErrors()
It("returns error when at least one bundle cannot be uninstalled", func() {
_, bundle1 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.UninstallErr = errors.New("fake-bc-uninstall-error")
err := applier.KeepOnly([]models.Package{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-uninstall-error"))
})
})
Context("when operating on packages not as a package owner", func() {
BeforeEach(func() {
applier = NewCompiledPackageApplier(packagesBc, false, blobstore, compressor, fs, logger)
})
It("disables and but does not uninstall packages that are not in keeponly list", func() {
_, bundle1 := buildPkg(packagesBc)
pkg2, bundle2 := buildPkg(packagesBc)
_, bundle3 := buildPkg(packagesBc)
pkg4, bundle4 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1, bundle2, bundle3, bundle4}
err := applier.KeepOnly([]models.Package{pkg4, pkg2})
Expect(err).ToNot(HaveOccurred())
Expect(bundle1.ActionsCalled).To(Equal([]string{"Disable"})) // no Uninstall
Expect(bundle2.ActionsCalled).To(Equal([]string{}))
Expect(bundle3.ActionsCalled).To(Equal([]string{"Disable"})) // no Uninstall
Expect(bundle4.ActionsCalled).To(Equal([]string{}))
})
ItReturnsErrors()
})
})
})
}
import (
"errors"
. "github.com/cloudfoundry/bosh-init/stemcell"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
fakecmd "github.com/cloudfoundry/bosh-utils/fileutil/fakes"
biproperty "github.com/cloudfoundry/bosh-utils/property"
fakesys "github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("Reader", func() {
var (
compressor *fakecmd.FakeCompressor
stemcellReader Reader
fs *fakesys.FakeFileSystem
)
BeforeEach(func() {
compressor = fakecmd.NewFakeCompressor()
fs = fakesys.NewFakeFileSystem()
stemcellReader = NewReader(compressor, fs)
manifestContents := `
---
name: fake-stemcell-name
version: '2690'
cloud_properties:
infrastructure: aws
ami:
func init() {
Describe("renderedJobApplier", func() {
var (
jobsBc *fakebc.FakeBundleCollection
jobSupervisor *fakejobsuper.FakeJobSupervisor
packageApplierProvider *fakepackages.FakeApplierProvider
blobstore *fakeblob.FakeBlobstore
compressor *fakecmd.FakeCompressor
fs *fakesys.FakeFileSystem
applier Applier
)
BeforeEach(func() {
jobsBc = fakebc.NewFakeBundleCollection()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
packageApplierProvider = fakepackages.NewFakeApplierProvider()
blobstore = fakeblob.NewFakeBlobstore()
fs = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
logger := boshlog.NewLogger(boshlog.LevelNone)
applier = NewRenderedJobApplier(
jobsBc,
jobSupervisor,
packageApplierProvider,
blobstore,
compressor,
fs,
logger,
)
})
Describe("Prepare & Apply", func() {
var (
job models.Job
bundle *fakebc.FakeBundle
)
BeforeEach(func() {
job, bundle = buildJob(jobsBc)
})
ItInstallsJob := func(act func() error) {
BeforeEach(func() {
fs.TempDirDir = "/fake-tmp-dir"
})
It("returns error when installing job fails", func() {
bundle.InstallError = errors.New("fake-install-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-install-error"))
})
It("downloads and later cleans up downloaded job template blob", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("fake-blobstore-id"))
Expect(blobstore.GetFingerprints[0]).To(Equal(boshcrypto.NewDigest("sha1", "fake-blob-sha1")))
// downloaded file is cleaned up
Expect(blobstore.CleanUpFileName).To(Equal("/fake-blobstore-file-name"))
})
It("returns error when downloading job template blob fails", func() {
blobstore.GetError = errors.New("fake-get-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-error"))
})
It("decompresses job template blob to tmp path and later cleans it up", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
var tmpDirExistsBeforeInstall bool
bundle.InstallCallBack = func() {
tmpDirExistsBeforeInstall = true
}
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(compressor.DecompressFileToDirTarballPaths[0]).To(Equal("/fake-blobstore-file-name"))
Expect(compressor.DecompressFileToDirDirs[0]).To(Equal("/fake-tmp-dir"))
// tmp dir exists before bundle install
Expect(tmpDirExistsBeforeInstall).To(BeTrue())
// tmp dir is cleaned up after install
Expect(fs.FileExists(fs.TempDirDir)).To(BeFalse())
})
It("returns error when temporary directory creation fails", func() {
fs.TempDirError = errors.New("fake-filesystem-tempdir-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-filesystem-tempdir-error"))
})
It("can process sha1 checksums in the new format", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
job.Source.Sha1 = "sha1:fake-blob-sha1"
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("fake-blobstore-id"))
Expect(blobstore.GetFingerprints[0]).To(Equal(boshcrypto.NewDigest("sha1", "fake-blob-sha1")))
})
It("can process sha2 checksums", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
job.Source.Sha1 = "sha256:fake-blob-sha256"
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("fake-blobstore-id"))
Expect(blobstore.GetFingerprints[0]).To(Equal(boshcrypto.NewDigest("sha256", "fake-blob-sha256")))
})
It("returns error when given and unsupported fingerprint", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
job.Source.Sha1 = "unsupported:checksum"
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Parsing job blob digest"))
})
It("returns error when decompressing job template fails", func() {
compressor.DecompressFileToDirErr = errors.New("fake-decompress-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-decompress-error"))
})
It("returns error when walking the tree of files fails", func() {
fs.WalkErr = errors.New("fake-walk-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-walk-error"))
})
It("installs bundle from decompressed tmp path of a job template", func() {
var installedBeforeDecompression bool
compressor.DecompressFileToDirCallBack = func() {
installedBeforeDecompression = bundle.Installed
}
err := act()
Expect(err).ToNot(HaveOccurred())
// bundle installation did not happen before decompression
Expect(installedBeforeDecompression).To(BeFalse())
// make sure that bundle install happened after decompression
Expect(bundle.InstallSourcePath).To(Equal("/fake-tmp-dir/fake-path-in-archive"))
})
It("sets executable bit for the bin and config directories", func() {
var binDirStats, configDirStats *fakesys.FakeFileStats
compressor.DecompressFileToDirCallBack = func() {
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/bin/blarg", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/blarg.yml", []byte{})
}
bundle.InstallCallBack = func() {
binDirStats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/bin")
configDirStats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config")
}
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(int(binDirStats.FileMode)).To(Equal(0755))
Expect(int(configDirStats.FileMode)).To(Equal(0755))
})
It("sets executable bit for files in bin", func() {
compressor.DecompressFileToDirCallBack = func() {
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/bin/test1", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/bin/test2", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/test", []byte{})
}
fs.SetGlob("/fake-tmp-dir/fake-path-in-archive/bin/*", []string{
"/fake-tmp-dir/fake-path-in-archive/bin/test1",
"/fake-tmp-dir/fake-path-in-archive/bin/test2",
})
var binTest1Stats, binTest2Stats, configTestStats *fakesys.FakeFileStats
bundle.InstallCallBack = func() {
binTest1Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/bin/test1")
binTest2Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/bin/test2")
configTestStats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config/test")
}
err := act()
Expect(err).ToNot(HaveOccurred())
// bin files are executable
Expect(int(binTest1Stats.FileMode)).To(Equal(0755))
Expect(int(binTest2Stats.FileMode)).To(Equal(0755))
// non-bin files are not made executable
Expect(int(configTestStats.FileMode)).ToNot(Equal(0755))
})
It("sets 644 permissions for files in config", func() {
compressor.DecompressFileToDirCallBack = func() {
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/config1", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/config2", []byte{})
}
fs.SetGlob("/fake-tmp-dir/fake-path-in-archive/config/*", []string{
"/fake-tmp-dir/fake-path-in-archive/config/config1",
"/fake-tmp-dir/fake-path-in-archive/config/config2",
})
var config1Stats, config2Stats *fakesys.FakeFileStats
bundle.InstallCallBack = func() {
config1Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config/config1")
config2Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config/config2")
}
err := act()
Expect(err).ToNot(HaveOccurred())
// permission for config files should be readable by all
Expect(int(config1Stats.FileMode)).To(Equal(0644))
Expect(int(config2Stats.FileMode)).To(Equal(0644))
})
}
ItUpdatesPackages := func(act func() error) {
var packageApplier *fakepackages.FakeApplier
BeforeEach(func() {
packageApplier = fakepackages.NewFakeApplier()
packageApplierProvider.JobSpecificAppliers[job.Name] = packageApplier
})
It("applies each package that job depends on and then cleans up packages", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.ActionsCalled).To(Equal([]string{"Apply", "Apply", "KeepOnly"}))
Expect(len(packageApplier.AppliedPackages)).To(Equal(2)) // present
Expect(packageApplier.AppliedPackages).To(Equal(job.Packages))
})
It("returns error when applying package that job depends on fails", func() {
packageApplier.ApplyError = errors.New("fake-apply-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-err"))
})
It("keeps only currently required packages but does not completely uninstall them", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(len(packageApplier.KeptOnlyPackages)).To(Equal(2)) // present
Expect(packageApplier.KeptOnlyPackages).To(Equal(job.Packages))
})
It("returns error when keeping only currently required packages fails", func() {
packageApplier.KeepOnlyErr = errors.New("fake-keep-only-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-err"))
})
}
Describe("Prepare", func() {
act := func() error { return applier.Prepare(job) }
It("return an error if getting file bundle fails", func() {
jobsBc.GetErr = errors.New("fake-get-bundle-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-bundle-error"))
})
It("returns an error if checking for installed path fails", func() {
bundle.IsInstalledErr = errors.New("fake-is-installed-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-installed-error"))
})
Context("when job is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{})) // no Install
})
It("does not download the job template", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
})
Context("when job is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs job (but does not enable)", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install"}))
})
ItInstallsJob(act)
})
})
Describe("Apply", func() {
act := func() error { return applier.Apply(job) }
It("return an error if getting file bundle fails", func() {
jobsBc.GetErr = errors.New("fake-get-bundle-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-bundle-error"))
})
It("returns an error if checking for installed path fails", func() {
bundle.IsInstalledErr = errors.New("fake-is-installed-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-installed-error"))
})
Context("when job is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install but only enables job", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Enable"})) // no Install
})
It("returns error when job enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
It("does not download the job template", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
ItUpdatesPackages(act)
})
Context("when job is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs and enables job", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install", "Enable"}))
})
It("returns error when job enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
ItInstallsJob(act)
ItUpdatesPackages(act)
})
})
})
Describe("Configure", func() {
It("adds job to the job supervisor", func() {
job, bundle := buildJob(jobsBc)
fs := fakesys.NewFakeFileSystem()
fs.WriteFileString("/path/to/job/monit", "some conf")
fs.SetGlob("/path/to/job/*.monit", []string{"/path/to/job/subjob.monit"})
bundle.GetDirPath = "/path/to/job"
bundle.GetDirFs = fs
err := applier.Configure(job, 0)
Expect(err).ToNot(HaveOccurred())
Expect(len(jobSupervisor.AddJobArgs)).To(Equal(2))
Expect(jobSupervisor.AddJobArgs[0]).To(Equal(fakejobsuper.AddJobArgs{
Name: job.Name,
Index: 0,
ConfigPath: "/path/to/job/monit",
}))
Expect(jobSupervisor.AddJobArgs[1]).To(Equal(fakejobsuper.AddJobArgs{
Name: job.Name + "_subjob",
Index: 0,
ConfigPath: "/path/to/job/subjob.monit",
}))
})
It("does not require monit script", func() {
job, bundle := buildJob(jobsBc)
fs := fakesys.NewFakeFileSystem()
bundle.GetDirFs = fs
err := applier.Configure(job, 0)
Expect(err).ToNot(HaveOccurred())
Expect(len(jobSupervisor.AddJobArgs)).To(Equal(0))
})
})
Describe("KeepOnly", func() {
It("first disables and then uninstalls jobs that are not in keeponly list", func() {
_, bundle1 := buildJob(jobsBc)
job2, bundle2 := buildJob(jobsBc)
_, bundle3 := buildJob(jobsBc)
job4, bundle4 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1, bundle2, bundle3, bundle4}
err := applier.KeepOnly([]models.Job{job4, job2})
Expect(err).ToNot(HaveOccurred())
Expect(bundle1.ActionsCalled).To(Equal([]string{"Disable", "Uninstall"}))
Expect(bundle2.ActionsCalled).To(Equal([]string{}))
Expect(bundle3.ActionsCalled).To(Equal([]string{"Disable", "Uninstall"}))
Expect(bundle4.ActionsCalled).To(Equal([]string{}))
})
It("returns error when bundle collection fails to return list of installed bundles", func() {
jobsBc.ListErr = errors.New("fake-bc-list-error")
err := applier.KeepOnly([]models.Job{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-list-error"))
})
It("returns error when bundle collection cannot retrieve bundle for keep-only job", func() {
job1, bundle1 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1}
jobsBc.GetErr = errors.New("fake-bc-get-error")
err := applier.KeepOnly([]models.Job{job1})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-get-error"))
})
It("returns error when at least one bundle cannot be disabled", func() {
_, bundle1 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.DisableErr = errors.New("fake-bc-disable-error")
err := applier.KeepOnly([]models.Job{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-disable-error"))
})
It("returns error when at least one bundle cannot be uninstalled", func() {
_, bundle1 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.UninstallErr = errors.New("fake-bc-uninstall-error")
err := applier.KeepOnly([]models.Job{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-uninstall-error"))
})
})
})
}
AfterEach(func() {
mockCtrl.Finish()
})
var (
mockJobListRenderer *mock_template.MockJobListRenderer
fakeCompressor *fakeboshcmd.FakeCompressor
fakeBlobstore *fakeboshblob.FakeBlobstore
fakeFS *fakeboshsys.FakeFileSystem
logger boshlog.Logger
renderer installation.JobRenderer
releaseJob bireljob.Job
releaseJobs []bireljob.Job
manifest biinstallmanifest.Manifest
fakeStage *fakebiui.FakeStage
releasePackage1 *birelpkg.Package
releasePackage2 *birelpkg.Package
renderedJobList bitemplate.RenderedJobList
)
BeforeEach(func() {
mockJobListRenderer = mock_template.NewMockJobListRenderer(mockCtrl)
fakeCompressor = fakeboshcmd.NewFakeCompressor()
fakeBlobstore = fakeboshblob.NewFakeBlobstore()
"errors"
. "github.com/cloudfoundry/bosh-init/release"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
bireljob "github.com/cloudfoundry/bosh-init/release/job"
birelpkg "github.com/cloudfoundry/bosh-init/release/pkg"
fakecmd "github.com/cloudfoundry/bosh-utils/fileutil/fakes"
fakesys "github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("tarReader", func() {
var (
reader Reader
fakeFs *fakesys.FakeFileSystem
compressor *fakecmd.FakeCompressor
)
BeforeEach(func() {
fakeFs = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
reader = NewReader("/some/release.tgz", "/extracted/release", fakeFs, compressor)
})
Describe("Read", func() {
Context("when the given release archive is a valid tar", func() {
Context("when the release manifest is valid", func() {
BeforeEach(func() {
fakeFs.WriteFileString(
"/extracted/release/release.MF",