func describeDummyPlatform() {
var (
platform Platform
collector boshstats.Collector
fs boshsys.FileSystem
cmdRunner boshsys.CmdRunner
dirProvider boshdirs.Provider
devicePathResolver boshdpresolv.DevicePathResolver
logger boshlog.Logger
)
BeforeEach(func() {
collector = &fakestats.FakeCollector{}
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
dirProvider = boshdirs.NewProvider("/fake-dir")
devicePathResolver = fakedpresolv.NewFakeDevicePathResolver()
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
platform = NewDummyPlatform(
collector,
fs,
cmdRunner,
dirProvider,
devicePathResolver,
logger,
)
})
Describe("GetDefaultNetwork", func() {
It("returns the contents of dummy-defaults-network-settings.json since that's what the dummy cpi writes", func() {
settingsFilePath := "/fake-dir/bosh/dummy-default-network-settings.json"
fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`)
network, err := platform.GetDefaultNetwork()
Expect(err).NotTo(HaveOccurred())
Expect(network.IP).To(Equal("1.2.3.4"))
})
})
Describe("GetCertManager", func() {
It("returs a dummy cert manager", func() {
certManager := platform.GetCertManager()
Expect(certManager.UpdateCertificates("")).Should(BeNil())
})
})
}
blobId = "105d33ae-655c-493d-bf9f-1df5cf3ca847"
basePath = os.TempDir()
blobPath = filepath.Join(basePath, blobId)
toWrite = bytes.NewReader([]byte("new data"))
})
readFile := func(fileIO boshsys.File) []byte {
fileStat, _ := fileIO.Stat()
fileBytes := make([]byte, fileStat.Size())
fileIO.Read(fileBytes)
return fileBytes
}
It("fetches", func() {
blobManager := NewBlobManager(fs, basePath)
fs.WriteFileString(blobPath, "some data")
readOnlyFile, err, _ := blobManager.Fetch(blobId)
defer fs.RemoveAll(readOnlyFile.Name())
Expect(err).ToNot(HaveOccurred())
fileBytes := readFile(readOnlyFile)
Expect(string(fileBytes)).To(Equal("some data"))
})
It("writes", func() {
blobManager := NewBlobManager(fs, basePath)
fs.WriteFileString(blobPath, "some data")
defer fs.RemoveAll(blobPath)
Expect(cmdRunner.RunCommands[0]).To(Equal(
[]string{
"tar", "--same-owner",
"-xzvf", tarballPath,
"-C", dstDir,
},
))
})
})
Describe("CleanUp", func() {
It("removes tarball path", func() {
fs := fakesys.NewFakeFileSystem()
compressor := NewTarballCompressor(cmdRunner, fs)
err := fs.WriteFileString("/fake-tarball.tar", "")
Expect(err).ToNot(HaveOccurred())
err = compressor.CleanUp("/fake-tarball.tar")
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("/fake-tarball.tar")).To(BeFalse())
})
It("returns error if removing tarball path fails", func() {
fs := fakesys.NewFakeFileSystem()
compressor := NewTarballCompressor(cmdRunner, fs)
fs.RemoveAllStub = func(_ string) error {
return errors.New("fake-remove-all-err")
}
func init() {
Describe("App", func() {
var (
baseDir string
agentConfPath string
agentConfJSON string
app App
)
BeforeEach(func() {
var err error
baseDir, err = ioutil.TempDir("", "go-agent-test")
Expect(err).ToNot(HaveOccurred())
err = os.Mkdir(filepath.Join(baseDir, "bosh"), os.ModePerm)
Expect(err).ToNot(HaveOccurred())
})
BeforeEach(func() {
agentConfPath = filepath.Join(baseDir, "bosh", "agent.json")
agentConfJSON = `{
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
settingsPath := filepath.Join(baseDir, "bosh", "settings.json")
settingsJSON := `{
"agent_id": "my-agent-id",
"blobstore": {
"options": {
"bucket_name": "george",
"encryption_key": "optional encryption key",
"access_key_id": "optional access key id",
"secret_access_key": "optional secret access key"
},
"provider": "dummy"
},
"disks": {
"ephemeral": "/dev/sdb",
"persistent": {
"vol-xxxxxx": "/dev/sdf"
},
"system": "/dev/sda1"
},
"env": {
"bosh": {
"password": "******"
}
},
"networks": {
"netA": {
"default": ["dns", "gateway"],
"ip": "ww.ww.ww.ww",
"dns": [
"xx.xx.xx.xx",
"yy.yy.yy.yy"
]
},
"netB": {
"dns": [
"zz.zz.zz.zz"
]
}
},
"Mbus": "https://*****:*****@0.0.0.0:6868",
"ntp": [
"0.north-america.pool.ntp.org",
"1.north-america.pool.ntp.org"
],
"vm": {
"name": "vm-abc-def"
}
}`
err := ioutil.WriteFile(settingsPath, []byte(settingsJSON), 0640)
Expect(err).ToNot(HaveOccurred())
})
JustBeforeEach(func() {
err := ioutil.WriteFile(agentConfPath, []byte(agentConfJSON), 0640)
Expect(err).ToNot(HaveOccurred())
logger := boshlog.NewLogger(boshlog.LevelNone)
fakefs := boshsys.NewOsFileSystem(logger)
app = New(logger, fakefs)
})
AfterEach(func() {
os.RemoveAll(baseDir)
})
It("Sets up device path resolver on platform specific to infrastructure", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(Equal(devicepathresolver.NewIdentityDevicePathResolver()))
})
Context("when DevicePathResolutionType is 'virtio'", func() {
BeforeEach(func() {
agentConfJSON = `{
"Platform": { "Linux": { "DevicePathResolutionType": "virtio" } },
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
})
It("uses a VirtioDevicePathResolver", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
logLevel, err := boshlog.Levelify("DEBUG")
Expect(err).NotTo(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(
BeAssignableToTypeOf(devicepathresolver.NewVirtioDevicePathResolver(nil, nil, boshlog.NewLogger(logLevel))))
})
})
Context("when DevicePathResolutionType is 'scsi'", func() {
BeforeEach(func() {
agentConfJSON = `{
"Platform": { "Linux": { "DevicePathResolutionType": "scsi" } },
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
})
It("uses a VirtioDevicePathResolver", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(
BeAssignableToTypeOf(devicepathresolver.NewScsiDevicePathResolver(nil, nil, nil)))
})
})
Context("logging stemcell version and git sha", func() {
var (
logger boshlog.Logger
outBuf *bytes.Buffer
fakeFs boshsys.FileSystem
stemcellVersionFilePath string
stemcellSha1FilePath string
)
JustBeforeEach(func() {
outBuf = bytes.NewBufferString("")
errBuf := bytes.NewBufferString("")
logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuf, errBuf)
fakeFs = fakesys.NewFakeFileSystem()
dirProvider := boshdirs.NewProvider(baseDir)
stemcellVersionFilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_version")
stemcellSha1FilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_git_sha1")
app = New(logger, fakeFs)
})
Context("when stemcell version and sha files are present", func() {
It("should print out the stemcell version and sha in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: sha1-blah)"))
})
})
Context("when stemcell version file is NOT present", func() {
It("should print out the sha in the logs", func() {
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)"))
})
})
Context("when sha version file is NOT present", func() {
It("should print out the stemcell version in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)"))
})
})
Context("when stemcell version file is empty", func() {
It("should print out the sha in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "")
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)"))
})
})
Context("when sha version file is empty", func() {
It("should print out the stemcell version in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
fakeFs.WriteFileString(stemcellSha1FilePath, "")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)"))
})
})
Context("when stemcell version and sha files are NOT present", func() {
It("should print unknown version and sha in the logs", func() {
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: ?)"))
})
})
})
})
}
Describe("AddJob", func() {
It("creates a service with vcap description", func() {
conf, err := AddJob("say-hello")
Expect(err).ToNot(HaveOccurred())
for _, proc := range conf.Processes {
stdout, _, _, err := runner.RunCommand("powershell", "/C", "get-service", proc.Name)
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(ContainSubstring(proc.Name))
Expect(stdout).To(ContainSubstring("Stopped"))
}
})
Context("when monit file is empty", func() {
BeforeEach(func() {
Expect(fs.WriteFileString(processConfigPath, "")).To(Succeed())
})
It("does not return an error", func() {
_, err := AddJob("say-hello")
Expect(err).ToNot(HaveOccurred())
})
})
})
Describe("Start", func() {
var conf WindowsProcessConfig
BeforeEach(func() {
var err error
conf, err = AddJob("say-hello")
Expect(err).ToNot(HaveOccurred())
BeforeEach(func() {
fs = boshsys.NewOsFileSystem(logger)
cmdRunner = boshsys.NewExecCmdRunner(logger)
compressor = boshcmd.NewTarballCompressor(cmdRunner, fs)
renderedJobListCompressor = NewRenderedJobListCompressor(fs, compressor, fakeSHA1Calculator, logger)
})
It("copies rendered jobs into a new temp dir, compresses the temp dir, and wraps it in a RenderedJobListArchive", func() {
// create rendered job with 2 rendered scripts
renderedJobDir0, err := fs.TempDir("RenderedJobListCompressorTest")
Expect(err).ToNot(HaveOccurred())
renderedJob0 := NewRenderedJob(bireljob.Job{Name: "fake-job-name-0"}, renderedJobDir0, fs, logger)
defer func() { err := renderedJob0.Delete(); Expect(err).ToNot(HaveOccurred()) }()
err = fs.WriteFileString(filepath.Join(renderedJobDir0, "script-0"), "fake-rendered-job-0-script-0-content")
Expect(err).ToNot(HaveOccurred())
err = fs.WriteFileString(filepath.Join(renderedJobDir0, "script-1"), "fake-rendered-job-0-script-1-content")
Expect(err).ToNot(HaveOccurred())
renderedJobList.Add(renderedJob0)
// create another rendered job with 1 rendered script
renderedJobDir1, err := fs.TempDir("RenderedJobListCompressorTest")
Expect(err).ToNot(HaveOccurred())
renderedJob1 := NewRenderedJob(bireljob.Job{Name: "fake-job-name-1"}, renderedJobDir1, fs, logger)
defer func() { err := renderedJob1.Delete(); Expect(err).ToNot(HaveOccurred()) }()
err = fs.WriteFileString(filepath.Join(renderedJobDir1, "script-0"), "fake-rendered-job-1-script-0-content")
Expect(err).ToNot(HaveOccurred())
renderedJobList.Add(renderedJob1)
// compress
blobId = "105d33ae-655c-493d-bf9f-1df5cf3ca847"
basePath = os.TempDir()
blobPath = filepath.Join(basePath, blobId)
toWrite = bytes.NewReader([]byte("new data"))
})
readFile := func(fileIO boshsys.File) []byte {
fileStat, _ := fileIO.Stat()
fileBytes := make([]byte, fileStat.Size())
fileIO.Read(fileBytes)
return fileBytes
}
It("fetches", func() {
blobManager := NewBlobManager(fs, basePath)
fs.WriteFileString(blobPath, "some data")
readOnlyFile, err, _ := blobManager.Fetch(blobId)
defer fs.RemoveAll(readOnlyFile.Name())
Expect(err).ToNot(HaveOccurred())
fileBytes := readFile(readOnlyFile)
Expect(string(fileBytes)).To(Equal("some data"))
})
It("writes", func() {
blobManager := NewBlobManager(fs, basePath)
fs.WriteFileString(blobPath, "some data")
defer fs.RemoveAll(blobPath)
func GenerateDeploymentManifest(deploymentManifestFilePath string, fs boshsys.FileSystem, manifestContents string) error {
return fs.WriteFileString(deploymentManifestFilePath, manifestContents)
}
fs boshsys.FileSystem
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
factory = NewDigestProvider(fs)
})
Describe("CreateFromFile", func() {
const (
filePath = "/file.txt"
fileContents = "something different"
)
BeforeEach(func() {
fs.WriteFileString(filePath, fileContents)
})
Context("sha1", func() {
It("opens a file and returns a digest", func() {
expectedDigest, err := factory.CreateFromFile(filePath, DigestAlgorithmSHA1)
Expect(err).ToNot(HaveOccurred())
Expect(expectedDigest.Digest()).To(Equal("da7102c07515effc353226eac2be923c916c5c94"))
})
})
Context("sha256", func() {
It("opens a file and returns a digest", func() {
expectedDigest, err := factory.CreateFromFile(filePath, DigestAlgorithmSHA256)
Expect(err).ToNot(HaveOccurred())
Expect(expectedDigest.Digest()).To(Equal("73af606b33433fa3a699134b39d5f6bce1ab4a6d9ca3263d3300f31fc5776b12"))
func describeDummyPlatform() {
var (
platform Platform
collector boshstats.Collector
fs boshsys.FileSystem
cmdRunner boshsys.CmdRunner
dirProvider boshdirs.Provider
devicePathResolver boshdpresolv.DevicePathResolver
logger boshlog.Logger
)
BeforeEach(func() {
collector = &fakestats.FakeCollector{}
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
dirProvider = boshdirs.NewProvider("/fake-dir")
devicePathResolver = fakedpresolv.NewFakeDevicePathResolver()
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
platform = NewDummyPlatform(
collector,
fs,
cmdRunner,
dirProvider,
devicePathResolver,
logger,
)
})
Describe("GetDefaultNetwork", func() {
It("returns the contents of dummy-defaults-network-settings.json since that's what the dummy cpi writes", func() {
settingsFilePath := "/fake-dir/bosh/dummy-default-network-settings.json"
fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`)
network, err := platform.GetDefaultNetwork()
Expect(err).NotTo(HaveOccurred())
Expect(network.IP).To(Equal("1.2.3.4"))
})
})
Describe("GetCertManager", func() {
It("returs a dummy cert manager", func() {
certManager := platform.GetCertManager()
Expect(certManager.UpdateCertificates("")).Should(BeNil())
})
})
Describe("UnmountPersistentDisk", func() {
Context("when there are two mounted persistent disks in the mounts json", func() {
BeforeEach(func() {
var mounts []mount
mounts = append(mounts, mount{MountDir: "dir1", DiskCid: "cid1"})
mounts = append(mounts, mount{MountDir: "dir2", DiskCid: "cid2"})
mountsJSON, _ := json.Marshal(mounts)
mountsPath := path.Join(dirProvider.BoshDir(), "mounts.json")
fs.WriteFile(mountsPath, mountsJSON)
})
It("removes one of the disks from the mounts json", func() {
unmounted, err := platform.UnmountPersistentDisk(settings.DiskSettings{ID: "cid1"})
Expect(err).NotTo(HaveOccurred())
Expect(unmounted).To(Equal(true))
Expect(platform.IsMountPoint("dir1")).To(Equal(false))
Expect(platform.IsMountPoint("dir2")).To(Equal(true))
})
})
})
}