func AbsolutifyPath(pathToManifest string, pathToFile string, fs boshsys.FileSystem) (string, error) {
if strings.HasPrefix(pathToFile, "http") {
return pathToFile, nil
}
if strings.HasPrefix(pathToFile, "file:///") || strings.HasPrefix(pathToFile, "/") {
return pathToFile, nil
}
if strings.HasPrefix(pathToFile, "file://~") {
return pathToFile, nil
}
if strings.HasPrefix(pathToFile, "~") {
return fs.ExpandPath(pathToFile)
}
var absPath string
if !strings.HasPrefix(pathToFile, "file://") {
absPath = filepath.Join(filepath.Dir(pathToManifest), pathToFile)
} else {
pathToFile = strings.Replace(pathToFile, "file://", "", 1)
absPath = filepath.Join(filepath.Dir(pathToManifest), pathToFile)
absPath = "file://" + absPath
}
return absPath, nil
}
func countFiles(fs system.FileSystem, dir string) (count int) {
fs.Walk(dir, func(path string, info os.FileInfo, err error) error {
count++
return nil
})
return
}
func mustCreateReposDir(config Config, fs boshsys.FileSystem, eventLog bpeventlog.Log) {
err := fs.MkdirAll(config.ReposDir, os.ModeDir)
if err != nil {
eventLog.WriteErr(bosherr.WrapError(err, "Creating repos dir"))
os.Exit(1)
}
}
func NewConfigFromPath(path string, fs boshsys.FileSystem) (Config, error) {
var config Config
bytes, err := fs.ReadFile(path)
if err != nil {
return config, bosherr.WrapErrorf(err, "Reading config %s", path)
}
config = DefaultConfig
err = json.Unmarshal(bytes, &config)
if err != nil {
return config, bosherr.WrapError(err, "Unmarshalling config")
}
if config.VMProvisioner.AgentProvisioner.Configuration == nil {
config.VMProvisioner.AgentProvisioner.Configuration = DefaultAgentConfiguration
}
err = config.validate()
if err != nil {
return config, bosherr.WrapError(err, "Validating config")
}
return config, nil
}
func NewManifestFromPath(path string, fs boshsys.FileSystem) (Manifest, error) {
bytes, err := fs.ReadFile(path)
if err != nil {
return Manifest{}, bosherr.WrapErrorf(err, "Reading manifest %s", path)
}
return NewManifestFromBytes(bytes)
}
// New returns a new logger (that writes to the specified file) & the open file handle
// All log levels >= the specified level are written to the specified file.
// User is responsible for closing the returned file handle, unless an error is returned.
func New(level boshlog.LogLevel, filePath string, fileMode os.FileMode, fs boshsys.FileSystem) (boshlog.Logger, boshsys.File, error) {
file, err := fs.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, fileMode)
if err != nil {
return nil, file, bosherr.WrapErrorf(err, "Failed to open log file '%s'", filePath)
}
return boshlog.NewWriterLogger(level, file, file), file, nil
}
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())
})
})
}
func deleteFiles(fs boshsys.FileSystem, path string, filenamePrefix string) (int, error) {
var deletedFilesCount int
files, err := fs.Glob(fmt.Sprintf("%s%s*", path, filenamePrefix))
if err != nil {
return deletedFilesCount, bosherr.WrapError(err, "Glob command failed")
}
for _, file := range files {
err = fs.RemoveAll(file)
if err != nil {
return deletedFilesCount, bosherr.WrapErrorf(err, "deleting %s failed", file)
}
deletedFilesCount++
}
return deletedFilesCount, err
}
func mustSetTmpDir(config Config, fs boshsys.FileSystem, eventLog bpeventlog.Log) {
// todo leaky abstraction?
if len(config.TmpDir) == 0 {
return
}
err := fs.MkdirAll(config.TmpDir, os.ModeDir)
if err != nil {
eventLog.WriteErr(bosherr.WrapError(err, "Creating tmp dir"))
os.Exit(1)
}
err = os.Setenv("TMPDIR", config.TmpDir)
if err != nil {
eventLog.WriteErr(bosherr.WrapError(err, "Setting TMPDIR"))
os.Exit(1)
}
}
func LoadConfigFromPath(fs boshsys.FileSystem, path string) (Config, error) {
var config Config
if path == "" {
return config, nil
}
bytes, err := fs.ReadFile(path)
if err != nil {
return config, bosherr.WrapError(err, "Reading file")
}
err = json.Unmarshal(bytes, &config)
if err != nil {
return config, bosherr.WrapError(err, "Loading file")
}
return config, nil
}
func NewConfig(fs boshsys.FileSystem) (*Config, error) {
path := os.Getenv("BOSH_INIT_CONFIG_PATH")
if path == "" {
return &Config{}, errors.New("Must provide config file via BOSH_INIT_CONFIG_PATH environment variable")
}
configContents, err := fs.ReadFile(path)
if err != nil {
return &Config{}, err
}
var config Config
err = json.Unmarshal(configContents, &config)
if err != nil {
return &Config{}, err
}
return &config, nil
}
func NewBootstrapState(fs boshsys.FileSystem, path string) (*BootstrapState, error) {
state := BootstrapState{fs: fs, path: path}
if !fs.FileExists(path) {
return &state, nil
}
bytes, err := fs.ReadFile(path)
if err != nil {
return nil, bosherr.WrapError(err, "Reading bootstrap state file")
}
err = json.Unmarshal(bytes, &state)
if err != nil {
return nil, bosherr.WrapError(err, "Unmarshalling bootstrap state")
}
return &state, nil
}
func NewConfigFromPath(path string, fs boshsys.FileSystem) (Config, error) {
var config Config
bytes, err := fs.ReadFile(path)
if err != nil {
return config, bosherr.WrapErrorf(err, "Reading config %s", path)
}
err = json.Unmarshal(bytes, &config)
if err != nil {
return config, bosherr.WrapError(err, "Unmarshalling config")
}
err = config.Validate()
if err != nil {
return config, bosherr.WrapError(err, "Validating config")
}
return config, nil
}
package crypto_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-utils/crypto"
boshsys "github.com/cloudfoundry/bosh-utils/system"
fakesys "github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("DigestProvider", func() {
var (
factory DigestProvider
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)
})
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: ?)"))
})
})
})
})
}
var _ = Describe("WindowsJobSupervisor", func() {
Context("add jobs and control services", func() {
BeforeEach(func() {
if runtime.GOOS != "windows" {
Skip("Pending on non-Windows")
}
})
var (
once sync.Once
fs boshsys.FileSystem
logger boshlog.Logger
basePath string
logDir string
exePath string
jobDir string
processConfigPath string
jobSupervisor JobSupervisor
runner boshsys.CmdRunner
logOut *bytes.Buffer
logErr *bytes.Buffer
)
BeforeEach(func() {
once.Do(func() { Expect(buildPipeExe()).To(Succeed()) })
const testExtPath = "testdata/job-service-wrapper"
logOut = bytes.NewBufferString("")
logErr = bytes.NewBufferString("")
func GenerateDeploymentManifest(deploymentManifestFilePath string, fs boshsys.FileSystem, manifestContents string) error {
return fs.WriteFileString(deploymentManifestFilePath, manifestContents)
}
"os"
"path/filepath"
. "github.com/cloudfoundry/bosh-utils/blobstore"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-utils/system"
boshsysfake "github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Blob Manager", func() {
var (
fs boshsys.FileSystem
logger boshlog.Logger
basePath string
blobPath string
blobId string
toWrite io.Reader
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
fs = boshsys.NewOsFileSystem(logger)
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()
)
const (
stageTimePattern = "\\(\\d{2}:\\d{2}:\\d{2}\\)"
stageFinishedPattern = "\\.\\.\\. Finished " + stageTimePattern + "$"
stageCompiledPackageSkippedPattern = "\\.\\.\\. Skipped \\[Package already compiled\\] " + stageTimePattern + "$"
)
var _ = Describe("bosh-init", func() {
var (
logger boshlog.Logger
fileSystem boshsys.FileSystem
sshCmdRunner CmdRunner
cmdEnv map[string]string
quietCmdEnv map[string]string
testEnv Environment
config *Config
instanceSSH InstanceSSH
instanceUsername = "******"
instancePassword = "******" // encrypted value must be in the manifest: resource_pool.env.bosh.password
instanceIP = "10.244.0.42"
)
var readLogFile = func(logPath string) (stdout string) {
stdout, _, exitCode, err := sshCmdRunner.RunCommand(cmdEnv, "cat", logPath)
Expect(err).ToNot(HaveOccurred())
Expect(exitCode).To(Equal(0))
return stdout
}
var deleteLogFile = func(logPath string) {
"path/filepath"
"runtime"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/stretchr/testify/assert"
. "github.com/cloudfoundry/bosh-utils/fileutil"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-utils/system"
)
var _ = Describe("cpCopier", func() {
var (
fs boshsys.FileSystem
cmdRunner boshsys.CmdRunner
cpCopier Copier
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs = boshsys.NewOsFileSystem(logger)
cmdRunner = boshsys.NewExecCmdRunner(logger)
cpCopier = NewCpCopier(cmdRunner, fs, logger)
if runtime.GOOS == "windows" {
Skip("Pending on Windows")
}
})
Describe("FilteredCopyToTemp", func() {
"os"
"path/filepath"
"runtime"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/stretchr/testify/assert"
. "github.com/cloudfoundry/bosh-utils/fileutil"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-utils/system"
)
var _ = Describe("genericCpCopier", func() {
var (
fs boshsys.FileSystem
cpCopier Copier
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs = boshsys.NewOsFileSystem(logger)
cpCopier = NewGenericCpCopier(fs, logger)
})
Describe("FilteredCopyToTemp", func() {
copierFixtureSrcDir := func() string {
pwd, err := os.Getwd()
Expect(err).ToNot(HaveOccurred())
return filepath.Join(pwd, "test_assets", "test_filtered_copy_to_temp")
}
filesInDir := func(dir string) []string {
var certThumbprints []string = []string{
"23AC7706D032651BE146388FA8DF7B0B2DD7CFA6",
"73C0BFD7BB53EC299B289CB86A010AE485F6D49B",
}
const getCertScript string = `
(Get-ChildItem Cert:\LocalMachine\Root | where { $_.Subject -eq "O=BOSH, S=BOSH, C=US" }).Length`
const removeCertScript string = `
if (Test-Path %[1]s) {
Remove-Item %[1]s
}`
var tempDir string
var dirProvider boshdir.Provider
var fs boshsys.FileSystem
BeforeEach(func() {
if runtime.GOOS != "windows" {
Skip("Only run on Windows")
}
fs = boshsys.NewOsFileSystem(log)
var err error
tempDir, err = fs.TempDir("")
Expect(err).To(BeNil())
dirProvider = boshdir.NewProvider(tempDir)
certManager = cert.NewWindowsCertManager(fs, boshsys.NewExecCmdRunner(log), dirProvider, log)
})
AfterEach(func() {
return natsURL
}
func blobstoreURI() string {
blobstoreURI := "http://172.31.180.3:25250"
vagrantProvider := os.Getenv("VAGRANT_PROVIDER")
if vagrantProvider == "aws" {
blobstoreURI = fmt.Sprintf("http://%s:25250", os.Getenv("NATS_ELASTIC_IP"))
}
return blobstoreURI
}
var _ = Describe("An Agent running on Windows", func() {
var (
fs boshsys.FileSystem
natsClient *NatsClient
blobstoreClient utils.BlobClient
)
BeforeEach(func() {
message := fmt.Sprintf(`{"method":"ping","arguments":[],"reply_to":"%s"}`, senderID)
blobstoreClient = utils.NewBlobstore(blobstoreURI())
logger := boshlog.NewLogger(boshlog.LevelNone)
cmdRunner := boshsys.NewExecCmdRunner(logger)
fs = boshsys.NewOsFileSystem(logger)
compressor := boshfileutil.NewTarballCompressor(cmdRunner, fs)
natsClient = NewNatsClient(compressor, blobstoreClient)
err := natsClient.Setup()
return dirInfo.IsDir(), nil
}
func (m beDirMatcher) FailureMessage(actual interface{}) string {
return fmt.Sprintf("Expected `%s' to be a directory", actual)
}
func (m beDirMatcher) NegatedFailureMessage(actual interface{}) string {
return fmt.Sprintf("Expected `%s' to not be a directory", actual)
}
var _ = Describe("tarballCompressor", func() {
var (
dstDir string
cmdRunner boshsys.CmdRunner
fs boshsys.FileSystem
compressor Compressor
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
cmdRunner = boshsys.NewExecCmdRunner(logger)
fs = boshsys.NewOsFileSystem(logger)
tmpDir, err := fs.TempDir("tarballCompressor-test")
Expect(err).NotTo(HaveOccurred())
dstDir = filepath.Join(tmpDir, "TestCompressor")
compressor = NewTarballCompressor(cmdRunner, fs)
})
BeforeEach(func() {
fs.MkdirAll(dstDir, os.ModePerm)
func init() {
Describe("ApplyAction", func() {
var (
applier *fakeappl.FakeApplier
specService *fakeas.FakeV1Service
settingsService *fakesettings.FakeSettingsService
dirProvider boshdir.Provider
action ApplyAction
fs boshsys.FileSystem
)
BeforeEach(func() {
applier = fakeappl.NewFakeApplier()
specService = fakeas.NewFakeV1Service()
settingsService = &fakesettings.FakeSettingsService{}
dirProvider = boshdir.NewProvider("/var/vcap")
fs = fakesys.NewFakeFileSystem()
action = NewApply(applier, specService, settingsService, dirProvider.InstanceDir(), fs)
})
It("apply should be asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
Describe("Run", func() {
settings := boshsettings.Settings{AgentID: "fake-agent-id"}
BeforeEach(func() {
settingsService.Settings = settings
})
Context("when desired spec has configuration hash", func() {
currentApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-current-config-hash"}
desiredApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash"}
populatedDesiredApplySpec := boshas.V1ApplySpec{
ConfigurationHash: "fake-populated-desired-config-hash",
}
Context("when current spec can be retrieved", func() {
BeforeEach(func() {
specService.Spec = currentApplySpec
})
It("populates dynamic networks in desired spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(specService.PopulateDHCPNetworksSpec).To(Equal(desiredApplySpec))
Expect(specService.PopulateDHCPNetworksSettings).To(Equal(settings))
})
Context("when resolving dynamic networks succeeds", func() {
BeforeEach(func() {
specService.PopulateDHCPNetworksResultSpec = populatedDesiredApplySpec
})
It("runs applier with populated desired spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(applier.Applied).To(BeTrue())
Expect(applier.ApplyCurrentApplySpec).To(Equal(currentApplySpec))
Expect(applier.ApplyDesiredApplySpec).To(Equal(populatedDesiredApplySpec))
})
Context("when applier succeeds applying desired spec", func() {
Context("when saving desires spec as current spec succeeds", func() {
It("returns 'applied' after setting populated desired spec as current spec", func() {
value, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("applied"))
Expect(specService.Spec).To(Equal(populatedDesiredApplySpec))
})
Context("desired spec has id, instance name, deployment name, and az", func() {
BeforeEach(func() {
desiredApplySpec = boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash", NodeID: "node-id01-123f-r2344", AvailabilityZone: "ex-az", Deployment: "deployment-name", Name: "instance-name"}
specService.PopulateDHCPNetworksResultSpec = desiredApplySpec
})
It("returns 'applied' and writes the id, instance name, deployment name, and az to files in the instance directory", func() {
value, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("applied"))
instanceDir := dirProvider.InstanceDir()
id, err := fs.ReadFileString(path.Join(instanceDir, "id"))
Expect(err).ToNot(HaveOccurred())
Expect(id).To(Equal(desiredApplySpec.NodeID))
az, err := fs.ReadFileString(path.Join(instanceDir, "az"))
Expect(err).ToNot(HaveOccurred())
Expect(az).To(Equal(desiredApplySpec.AvailabilityZone))
instanceName, err := fs.ReadFileString(path.Join(instanceDir, "name"))
Expect(err).ToNot(HaveOccurred())
Expect(instanceName).To(Equal(desiredApplySpec.Name))
deploymentName, err := fs.ReadFileString(path.Join(instanceDir, "deployment"))
Expect(err).ToNot(HaveOccurred())
Expect(deploymentName).To(Equal(desiredApplySpec.Deployment))
})
})
})
Context("when saving populated desires spec as current spec fails", func() {
It("returns error because agent was not able to remember that is converged to desired spec", func() {
specService.SetErr = errors.New("fake-set-error")
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-set-error"))
})
})
})
Context("when applier fails applying desired spec", func() {
BeforeEach(func() {
applier.ApplyError = errors.New("fake-apply-error")
})
It("returns error", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-error"))
})
It("does not save desired spec as current spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(specService.Spec).To(Equal(currentApplySpec))
})
})
})
Context("when resolving dynamic networks fails", func() {
BeforeEach(func() {
specService.PopulateDHCPNetworksErr = errors.New("fake-populate-dynamic-networks-err")
})
It("returns error", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err"))
})
It("does not apply desired spec as current spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(applier.Applied).To(BeFalse())
})
It("does not save desired spec as current spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(specService.Spec).To(Equal(currentApplySpec))
})
})
})
Context("when current spec cannot be retrieved", func() {
BeforeEach(func() {
specService.Spec = currentApplySpec
specService.GetErr = errors.New("fake-get-error")
})
It("returns error and does not apply desired spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-error"))
})
It("does not run applier with desired spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(applier.Applied).To(BeFalse())
})
It("does not save desired spec as current spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(specService.Spec).To(Equal(currentApplySpec))
})
})
})
Context("when desired spec does not have a configuration hash", func() {
desiredApplySpec := boshas.V1ApplySpec{
JobSpec: boshas.JobSpec{
Template: "fake-job-template",
},
}
populatedDesiredApplySpec := boshas.V1ApplySpec{
JobSpec: boshas.JobSpec{
Template: "fake-populated-job-template",
},
}
It("populates dynamic networks in desired spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(specService.PopulateDHCPNetworksSpec).To(Equal(desiredApplySpec))
Expect(specService.PopulateDHCPNetworksSettings).To(Equal(settings))
})
Context("when resolving dynamic networks succeeds", func() {
BeforeEach(func() {
specService.PopulateDHCPNetworksResultSpec = populatedDesiredApplySpec
})
Context("when saving desires spec as current spec succeeds", func() {
It("returns 'applied' after setting desired spec as current spec", func() {
value, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("applied"))
Expect(specService.Spec).To(Equal(populatedDesiredApplySpec))
})
It("does not try to apply desired spec since it does not have jobs and packages", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).ToNot(HaveOccurred())
Expect(applier.Applied).To(BeFalse())
})
})
Context("when saving desires spec as current spec fails", func() {
BeforeEach(func() {
specService.SetErr = errors.New("fake-set-error")
})
It("returns error because agent was not able to remember that is converged to desired spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-set-error"))
})
It("does not try to apply desired spec since it does not have jobs and packages", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(applier.Applied).To(BeFalse())
})
})
})
Context("when resolving dynamic networks fails", func() {
BeforeEach(func() {
specService.PopulateDHCPNetworksErr = errors.New("fake-populate-dynamic-networks-err")
})
It("returns error", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err"))
})
It("does not apply desired spec as current spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(applier.Applied).To(BeFalse())
})
It("does not save desired spec as current spec", func() {
_, err := action.Run(desiredApplySpec)
Expect(err).To(HaveOccurred())
Expect(specService.Spec).ToNot(Equal(desiredApplySpec))
})
})
})
})
})
}
package util_test
import (
"github.com/cloudfoundry/bosh-init/common/util"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-utils/system"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("AbsolutifyPath", func() {
var realfs boshsys.FileSystem
var fakeManifestPath, fakeFilePath string
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
realfs = boshsys.NewOsFileSystem(logger)
fakeManifestPath = "/fake/manifest/path/manifest.yml"
})
Context("File path is not a url", func() {
Context("File path is relative", func() {
Context("File path begins with a series of ../", func() {
It("joins file path to the manifest directory", func() {
fakeFilePath = "../fake/relative/path/file.tgz"
Expect(util.AbsolutifyPath(fakeManifestPath, fakeFilePath, realfs)).To(
Equal("/fake/manifest/fake/relative/path/file.tgz"))
})
})
Context("File is located in same directory as manifest or subdirectory", func() {
It("makes the file path relative to the manifest directory", func() {
import (
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-agent/infrastructure/devicepathresolver"
boshsettings "github.com/cloudfoundry/bosh-agent/settings"
boshsys "github.com/cloudfoundry/bosh-utils/system"
fakesys "github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("mappedDevicePathResolver", func() {
var (
fs boshsys.FileSystem
diskSettings boshsettings.DiskSettings
resolver DevicePathResolver
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
resolver = NewMappedDevicePathResolver(time.Second, fs)
diskSettings = boshsettings.DiskSettings{
Path: "/dev/sda",
}
})
Context("when a matching /dev/xvdX device is found", func() {
BeforeEach(func() {
fs.WriteFile("/dev/xvda", []byte{})
fs.WriteFile("/dev/vda", []byte{})
BeforeEach(func() {
outBuffer = bytes.NewBufferString("")
errBuffer = bytes.NewBufferString("")
logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuffer, errBuffer)
fakeSHA1Calculator = fakebicrypto.NewFakeSha1Calculator()
renderedJobList = NewRenderedJobList()
})
Describe("Compress", func() {
Context("with a real fs & compressor", func() {
var (
fs boshsys.FileSystem
cmdRunner boshsys.CmdRunner
compressor boshcmd.Compressor
)
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")
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))
})
})
})
}
"os"
"path/filepath"
. "github.com/cloudfoundry/bosh-utils/blobstore"
boshlog "github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-utils/system"
boshsysfake "github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Blob Manager", func() {
var (
fs boshsys.FileSystem
logger boshlog.Logger
basePath string
blobPath string
blobId string
toWrite io.Reader
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
fs = boshsys.NewOsFileSystem(logger)
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()