func init() {
Describe("ReleaseApplySpec", func() {
var (
platform *fakeplatform.FakePlatform
action ReleaseApplySpecAction
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
action = NewReleaseApplySpec(platform)
})
It("is synchronous", func() {
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
It("run", func() {
err := platform.GetFs().WriteFileString("/var/vcap/micro/apply_spec.json", `{"json":["objects"]}`)
Expect(err).ToNot(HaveOccurred())
value, err := action.Run()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(map[string]interface{}{"json": []interface{}{"objects"}}))
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
var (
vsphere Infrastructure
platform *fakeplatform.FakePlatform
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
})
JustBeforeEach(func() {
vsphere = NewVsphereInfrastructure(platform)
})
It("vsphere get settings", func() {
platform.GetFileContentsFromCDROMContents = []byte(`{"agent_id": "123"}`)
settings, err := vsphere.GetSettings()
Expect(err).NotTo(HaveOccurred())
Expect(platform.GetFileContentsFromCDROMPath).To(Equal("env"))
Expect(settings.AgentId).To(Equal("123"))
})
It("vsphere setup networking", func() {
networks := boshsettings.Networks{"bosh": boshsettings.Network{}}
vsphere.SetupNetworking(networks)
Expect(platform.SetupManualNetworkingNetworks).To(Equal(networks))
})
It("vsphere get ephemeral disk path", func() {
platform.NormalizeDiskPathRealPath = "/dev/sdb"
platform.NormalizeDiskPathFound = true
realPath, found := vsphere.GetEphemeralDiskPath("does not matter")
Expect(found).To(Equal(true))
Expect(realPath).To(Equal("/dev/sdb"))
Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb"))
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
var (
logger boshlog.Logger
platform *fakeplatform.FakePlatform
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
})
It("list disk should be synchronous", func() {
settings := &fakesettings.FakeSettingsService{}
action := NewListDisk(settings, platform, logger)
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
settings := &fakesettings.FakeSettingsService{}
action := NewListDisk(settings, platform, logger)
Expect(action.IsPersistent()).To(BeFalse())
})
It("list disk run", func() {
settings := &fakesettings.FakeSettingsService{
Disks: boshsettings.Disks{
Persistent: map[string]string{
"volume-1": "/dev/sda",
"volume-2": "/dev/sdb",
"volume-3": "/dev/sdc",
},
},
}
platform.MountedDevicePaths = []string{"/dev/sdb", "/dev/sdc"}
action := NewListDisk(settings, platform, logger)
value, err := action.Run()
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJsonString(GinkgoT(), value, `["volume-2","volume-3"]`)
})
})
}
func init() {
Describe("ListDisk", func() {
var (
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
logger boshlog.Logger
action ListDiskAction
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
action = NewListDisk(settingsService, platform, logger)
})
It("list disk should be synchronous", func() {
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
It("list disk run", func() {
platform.MountedDevicePaths = []string{"/dev/sdb", "/dev/sdc"}
settingsService.Settings.Disks = boshsettings.Disks{
Persistent: map[string]string{
"volume-1": "/dev/sda",
"volume-2": "/dev/sdb",
"volume-3": "/dev/sdc",
},
}
value, err := action.Run()
Expect(err).ToNot(HaveOccurred())
boshassert.MatchesJSONString(GinkgoT(), value, `["volume-2","volume-3"]`)
})
})
}
func init() {
Describe("concreteV1Service", func() {
var (
fs *fakesys.FakeFileSystem
platform *fakeplatform.FakePlatform
specPath = "/spec.json"
service V1Service
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
platform = fakeplatform.NewFakePlatform()
service = NewConcreteV1Service(fs, platform, specPath)
})
Describe("Get", func() {
Context("when filesystem has a spec file", func() {
BeforeEach(func() {
fs.WriteFileString(specPath, `{"deployment":"fake-deployment-name"}`)
})
It("reads spec from filesystem", func() {
spec, err := service.Get()
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{Deployment: "fake-deployment-name"}))
})
It("returns error if reading spec from filesystem errs", func() {
fs.ReadFileError = errors.New("fake-read-error")
spec, err := service.Get()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-read-error"))
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
Context("when filesystem does not have a spec file", func() {
It("reads spec from filesystem", func() {
spec, err := service.Get()
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
})
Describe("Set", func() {
newSpec := V1ApplySpec{Deployment: "fake-deployment-name"}
It("writes spec to filesystem", func() {
err := service.Set(newSpec)
Expect(err).ToNot(HaveOccurred())
specPathStats := fs.GetFileTestStat(specPath)
Expect(specPathStats).ToNot(BeNil())
boshassert.MatchesJSONBytes(GinkgoT(), newSpec, specPathStats.Content)
})
It("returns error if writing spec to filesystem errs", func() {
fs.WriteToFileError = errors.New("fake-write-error")
err := service.Set(newSpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-write-error"))
})
})
Describe("ResolveDynamicNetworks", func() {
Context("when there is are no dynamic networks", func() {
unresolvedSpec := V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{
"fake-net": NetworkSpec{
Fields: map[string]interface{}{"ip": "fake-net-ip"},
},
},
}
It("returns spec without modifying any networks", func() {
spec, err := service.ResolveDynamicNetworks(unresolvedSpec)
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{
"fake-net": NetworkSpec{
Fields: map[string]interface{}{"ip": "fake-net-ip"},
},
},
}))
})
})
Context("when there is one dynamic network", func() {
unresolvedSpec := V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{
"fake-net1": NetworkSpec{
Fields: map[string]interface{}{
"ip": "fake-net1-ip",
"netmask": "fake-net1-netmask",
"gateway": "fake-net1-gateway",
},
},
"fake-net2": NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": "fake-net2-ip",
"netmask": "fake-net2-netmask",
"gateway": "fake-net2-gateway",
},
},
},
}
Context("when default network can be retrieved", func() {
BeforeEach(func() {
platform.GetDefaultNetworkNetwork = boshsettings.Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
}
})
It("returns spec with modified dynamic network and keeping everything else the same", func() {
spec, err := service.ResolveDynamicNetworks(unresolvedSpec)
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{
"fake-net1": NetworkSpec{
Fields: map[string]interface{}{
"ip": "fake-net1-ip",
"netmask": "fake-net1-netmask",
"gateway": "fake-net1-gateway",
},
},
"fake-net2": NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": "fake-resolved-ip",
"netmask": "fake-resolved-netmask",
"gateway": "fake-resolved-gateway",
},
},
},
}))
})
})
Context("when default network fails to be retrieved", func() {
BeforeEach(func() {
platform.GetDefaultNetworkErr = errors.New("fake-get-default-network-err")
})
It("returns error", func() {
spec, err := service.ResolveDynamicNetworks(unresolvedSpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-default-network-err"))
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
})
Context("when there is are multiple dynamic networks", func() {
unresolvedSpec := V1ApplySpec{
NetworkSpecs: map[string]NetworkSpec{
"fake-net1": NetworkSpec{
Fields: map[string]interface{}{"type": NetworkSpecTypeDynamic},
},
"fake-net2": NetworkSpec{
Fields: map[string]interface{}{"type": NetworkSpecTypeDynamic},
},
},
}
It("returns error because multiple dynamic networks are not supported", func() {
spec, err := service.ResolveDynamicNetworks(unresolvedSpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Multiple dynamic networks are not supported"))
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
})
})
}
import (
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/infrastructure"
boshdpresolv "bosh/infrastructure/devicepathresolver"
boshlog "bosh/logger"
fakeplatform "bosh/platform/fakes"
)
var _ = Describe("Provider", func() {
var (
logger boshlog.Logger
platform *fakeplatform.FakePlatform
provider Provider
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
provider = NewProvider(logger, platform)
})
Describe("Get", func() {
It("returns aws infrastructure", func() {
metadataService := NewConcreteMetadataService(
"http://169.254.169.254",
NewDigDNSResolver(logger),
)
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
boshlog "bosh/logger"
. "bosh/mbus"
"bosh/micro"
fakeplatform "bosh/platform/fakes"
boshdir "bosh/settings/directories"
fakesettings "bosh/settings/fakes"
)
var _ = Describe("MbusHandlerProvider", func() {
var (
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
dirProvider boshdir.DirectoriesProvider
logger boshlog.Logger
provider MbusHandlerProvider
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
logger = boshlog.NewLogger(boshlog.LevelNone)
platform = fakeplatform.NewFakePlatform()
dirProvider = boshdir.NewDirectoriesProvider("/var/vcap")
provider = NewHandlerProvider(settingsService, logger)
})
Describe("Get", func() {
It("returns nats handler", func() {
settingsService.Settings.Mbus = "nats://lol"
func init() {
Describe("bootstrap", func() {
Describe("Run", func() {
var (
inf *fakeinf.FakeInfrastructure
platform *fakeplatform.FakePlatform
dirProvider boshdir.DirectoriesProvider
settingsServiceProvider *fakesettings.FakeSettingsServiceProvider
settingsService *fakesettings.FakeSettingsService
)
BeforeEach(func() {
inf = &fakeinf.FakeInfrastructure{
GetEphemeralDiskPathFound: true,
GetEphemeralDiskPathRealPath: "/dev/sdz",
}
platform = fakeplatform.NewFakePlatform()
dirProvider = boshdir.NewDirectoriesProvider("/var/vcap")
settingsServiceProvider = fakesettings.NewServiceProvider()
settingsService = settingsServiceProvider.NewServiceSettingsService
})
bootstrap := func() (boshsettings.Service, error) {
logger := boshlog.NewLogger(boshlog.LevelNone)
return New(inf, platform, dirProvider, settingsServiceProvider, logger).Run()
}
It("sets up runtime configuration", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupRuntimeConfigurationWasInvoked).To(BeTrue())
})
It("sets up ssh", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(inf.SetupSshUsername).To(Equal("vcap"))
})
It("sets up hostname", func() {
settingsService.Settings.AgentID = "foo-bar-baz-123"
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupHostnameHostname).To(Equal("foo-bar-baz-123"))
})
It("returns the settings service", func() {
settingsService, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(settingsService).To(Equal(settingsService))
Expect(settingsServiceProvider.NewServiceFs).To(Equal(platform.GetFs()))
Expect(settingsServiceProvider.NewServiceDir).To(Equal(dirProvider.BoshDir()))
fetchedSettings, err := settingsServiceProvider.NewServiceFetcher()
Expect(err).NotTo(HaveOccurred())
Expect(fetchedSettings).To(Equal(inf.Settings))
})
It("fetches initial settings", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(settingsService.SettingsWereLoaded).To(BeTrue())
})
It("returns error from loading initial settings", func() {
settingsService.LoadSettingsError = errors.New("fake-load-error")
_, err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-load-error"))
})
It("sets up networking", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{},
}
settingsService.Settings.Networks = networks
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(inf.SetupNetworkingNetworks).To(Equal(networks))
})
It("sets up ephemeral disk", func() {
settingsService.Disks = boshsettings.Disks{
Ephemeral: "fake-ephemeral-disk-setting",
}
inf.GetEphemeralDiskPathRealPath = "/dev/sda"
inf.GetEphemeralDiskPathFound = true
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupEphemeralDiskWithPathDevicePath).To(Equal("/dev/sda"))
Expect(inf.GetEphemeralDiskPathDevicePath).To(Equal("fake-ephemeral-disk-setting"))
})
It("returns error if setting ephemeral disk fails", func() {
platform.SetupEphemeralDiskWithPathErr = errors.New("fake-setup-ephemeral-disk-err")
_, err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-ephemeral-disk-err"))
})
It("sets up data dir", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupDataDirCalled).To(BeTrue())
})
It("returns error if set up of data dir fails", func() {
platform.SetupDataDirErr = errors.New("fake-setup-data-dir-err")
_, err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-data-dir-err"))
})
It("sets up tmp dir", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupTmpDirCalled).To(BeTrue())
})
It("returns error if set up of tmp dir fails", func() {
platform.SetupTmpDirErr = errors.New("fake-setup-tmp-dir-err")
_, err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-tmp-dir-err"))
})
It("mounts persistent disk", func() {
settingsService.Disks = boshsettings.Disks{
Persistent: map[string]string{"vol-123": "/dev/sdb"},
}
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.MountPersistentDiskDevicePath).To(Equal("/dev/sdb"))
Expect(platform.MountPersistentDiskMountPoint).To(Equal(dirProvider.StoreDir()))
})
It("errors if there is more than one persistent disk", func() {
settingsService.Disks = boshsettings.Disks{
Persistent: map[string]string{
"vol-123": "/dev/sdb",
"vol-456": "/dev/sdc",
},
}
_, err := bootstrap()
Expect(err).To(HaveOccurred())
})
It("does not try to mount when no persistent disk", func() {
settingsService.Disks = boshsettings.Disks{
Persistent: map[string]string{},
}
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.MountPersistentDiskDevicePath).To(Equal(""))
Expect(platform.MountPersistentDiskMountPoint).To(Equal(""))
})
It("sets root and vcap passwords", func() {
settingsService.Settings.Env.Bosh.Password = "******"
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(2).To(Equal(len(platform.UserPasswords)))
Expect("some-encrypted-password").To(Equal(platform.UserPasswords["root"]))
Expect("some-encrypted-password").To(Equal(platform.UserPasswords["vcap"]))
})
It("does not set password if not provided", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(0).To(Equal(len(platform.UserPasswords)))
})
It("sets ntp", func() {
settingsService.Settings.Ntp = []string{
"0.north-america.pool.ntp.org",
"1.north-america.pool.ntp.org",
}
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(2).To(Equal(len(platform.SetTimeWithNtpServersServers)))
Expect("0.north-america.pool.ntp.org").To(Equal(platform.SetTimeWithNtpServersServers[0]))
Expect("1.north-america.pool.ntp.org").To(Equal(platform.SetTimeWithNtpServersServers[1]))
})
It("setups up monit user", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupMonitUserSetup).To(BeTrue())
})
It("starts monit", func() {
_, err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.StartMonitStarted).To(BeTrue())
})
})
})
}
func init() {
Describe("concreteServiceProvider", func() {
var (
platform *fakeplatform.FakePlatform
)
Describe("NewService", func() {
It("returns service with settings.json as its settings path", func() {
// Cannot compare fetcher functions since function comparison is problematic
fs := fakesys.NewFakeFileSystem()
logger := boshlog.NewLogger(boshlog.LevelNone)
service := NewServiceProvider().NewService(fs, "/setting/path", nil, platform, logger)
Expect(service).To(Equal(NewService(fs, "/setting/path/settings.json", nil, platform, logger)))
})
})
})
Describe("concreteService", func() {
var (
fs *fakesys.FakeFileSystem
platform *fakeplatform.FakePlatform
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
platform = fakeplatform.NewFakePlatform()
})
buildService := func(fetcher SettingsFetcher) (Service, *fakesys.FakeFileSystem) {
logger := boshlog.NewLogger(boshlog.LevelNone)
service := NewService(fs, "/setting/path", fetcher, platform, logger)
return service, fs
}
Describe("LoadSettings", func() {
var (
fetchedSettings Settings
fetcherFuncErr error
service Service
)
BeforeEach(func() {
fetchedSettings = Settings{}
fetcherFuncErr = nil
})
JustBeforeEach(func() {
fetcherFunc := func() (Settings, error) { return fetchedSettings, fetcherFuncErr }
service, fs = buildService(fetcherFunc)
})
Context("when settings fetcher succeeds fetching settings", func() {
BeforeEach(func() {
fetchedSettings = Settings{AgentID: "some-new-agent-id"}
})
Context("when settings contain at most one dynamic network", func() {
BeforeEach(func() {
fetchedSettings.Networks = Networks{
"fake-net-1": Network{Type: NetworkTypeDynamic},
}
})
It("updates the service with settings from the fetcher", func() {
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
Expect(service.GetSettings().AgentID).To(Equal("some-new-agent-id"))
})
It("persists settings to the settings file", func() {
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
json, err := json.Marshal(fetchedSettings)
Expect(err).NotTo(HaveOccurred())
fileContent, err := fs.ReadFile("/setting/path")
Expect(err).NotTo(HaveOccurred())
Expect(fileContent).To(Equal(json))
})
It("returns any error from writing to the setting file", func() {
fs.WriteToFileError = errors.New("fs-write-file-error")
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-write-file-error"))
})
})
Context("when settings contain multiple dynamic networks", func() {
BeforeEach(func() {
fetchedSettings.Networks = Networks{
"fake-net-1": Network{Type: NetworkTypeDynamic},
"fake-net-2": Network{Type: NetworkTypeDynamic},
}
})
It("returns error because multiple dynamic networks are not supported", func() {
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Multiple dynamic networks are not supported"))
})
})
})
Context("when settings fetcher fails fetching settings", func() {
BeforeEach(func() {
fetcherFuncErr = errors.New("fake-fetch-error")
})
Context("when a settings file exists", func() {
Context("when settings contain at most one dynamic network", func() {
BeforeEach(func() {
fs.WriteFile("/setting/path", []byte(`{
"agent_id":"some-agent-id",
"networks": {"fake-net-1": {"type": "dynamic"}}
}`))
})
It("returns settings from the settings file", func() {
err := service.LoadSettings()
Expect(err).ToNot(HaveOccurred())
Expect(service.GetSettings()).To(Equal(Settings{
AgentID: "some-agent-id",
Networks: Networks{
"fake-net-1": Network{Type: NetworkTypeDynamic},
},
}))
})
})
Context("when settings contain multiple dynamic networks", func() {
BeforeEach(func() {
fs.WriteFile("/setting/path", []byte(`{
"agent_id":"some-agent-id",
"networks": {
"fake-net-1": {"type": "dynamic"},
"fake-net-2": {"type": "dynamic"}
}
}`))
})
It("returns error because multiple dynamic networks are not supported", func() {
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Multiple dynamic networks are not supported"))
})
})
})
Context("when non-unmarshallable settings file exists", func() {
It("returns any error from the fetcher", func() {
fs.WriteFile("/setting/path", []byte(`$%^&*(`))
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-fetch-error"))
Expect(service.GetSettings()).To(Equal(Settings{}))
})
})
Context("when no settings file exists", func() {
It("returns any error from the fetcher", func() {
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-fetch-error"))
Expect(service.GetSettings()).To(Equal(Settings{}))
})
})
})
})
Describe("InvalidateSettings", func() {
It("removes the settings file", func() {
service, fs := buildService(nil)
fs.WriteFile("/setting/path", []byte(`{}`))
err := service.InvalidateSettings()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("/setting/path")).To(BeFalse())
})
It("returns err if removing settings file errored", func() {
service, fs := buildService(nil)
fs.RemoveAllError = errors.New("fs-remove-all-error")
err := service.InvalidateSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-remove-all-error"))
})
})
Describe("GetSettings", func() {
var (
loadedSettings Settings
service Service
)
BeforeEach(func() {
loadedSettings = Settings{AgentID: "some-agent-id"}
})
JustBeforeEach(func() {
service, _ = buildService(func() (Settings, error) { return loadedSettings, nil })
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
})
Context("when there is are no dynamic networks", func() {
It("returns settings without modifying any networks", func() {
Expect(service.GetSettings()).To(Equal(loadedSettings))
})
It("does not try to determine default network", func() {
_ = service.GetSettings()
Expect(platform.GetDefaultNetworkCalled).To(BeFalse())
})
})
Context("when there is one dynamic network", func() {
BeforeEach(func() {
loadedSettings = Settings{
Networks: map[string]Network{
"fake-net1": Network{
IP: "fake-net1-ip",
Netmask: "fake-net1-netmask",
Gateway: "fake-net1-gateway",
},
"fake-net2": Network{
Type: "dynamic",
IP: "fake-net2-ip",
Netmask: "fake-net2-netmask",
Gateway: "fake-net2-gateway",
DNS: []string{"fake-net2-dns"},
},
},
}
})
Context("when default network can be retrieved", func() {
BeforeEach(func() {
platform.GetDefaultNetworkNetwork = Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
}
})
It("returns settings with resolved dynamic network ip, netmask, gateway and keeping everything else the same", func() {
settings := service.GetSettings()
Expect(settings).To(Equal(Settings{
Networks: map[string]Network{
"fake-net1": Network{
IP: "fake-net1-ip",
Netmask: "fake-net1-netmask",
Gateway: "fake-net1-gateway",
},
"fake-net2": Network{
Type: "dynamic",
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
DNS: []string{"fake-net2-dns"},
},
},
}))
})
})
Context("when default network fails to be retrieved", func() {
BeforeEach(func() {
platform.GetDefaultNetworkErr = errors.New("fake-get-default-network-err")
})
It("returns error", func() {
settings := service.GetSettings()
Expect(settings).To(Equal(loadedSettings))
})
})
})
})
})
}
package blobstore_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/blobstore"
fakeplatform "bosh/platform/fakes"
boshsettings "bosh/settings"
boshdir "bosh/settings/directories"
boshuuid "bosh/uuid"
)
var _ = Describe("Provider", func() {
var (
platform *fakeplatform.FakePlatform
provider Provider
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
provider = NewProvider(platform, dirProvider)
})
Describe("Get", func() {
It("get dummy", func() {
blobstore, err := provider.Get(boshsettings.Blobstore{
Type: boshsettings.BlobstoreTypeDummy,
})
Expect(err).ToNot(HaveOccurred())
Expect(blobstore).ToNot(BeNil())
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/infrastructure"
fakedpresolv "bosh/infrastructure/devicepathresolver/fakes"
boshlog "bosh/logger"
fakeplatform "bosh/platform/fakes"
boshsettings "bosh/settings"
)
var _ = Describe("vSphere Infrastructure", func() {
var (
logger boshlog.Logger
vsphere Infrastructure
platform *fakeplatform.FakePlatform
devicePathResolver *fakedpresolv.FakeDevicePathResolver
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
devicePathResolver = fakedpresolv.NewFakeDevicePathResolver()
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
vsphere = NewVsphereInfrastructure(platform, devicePathResolver, logger)
})
Describe("GetSettings", func() {
It("vsphere get settings", func() {
fakejobsuper "bosh/jobsupervisor/fakes"
boshlog "bosh/logger"
fakenotif "bosh/notification/fakes"
fakeplatform "bosh/platform/fakes"
boshntp "bosh/platform/ntp"
fakesettings "bosh/settings/fakes"
)
var _ = Describe("concreteFactory", func() {
var (
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
blobstore *fakeblobstore.FakeBlobstore
taskService *faketask.FakeService
notifier *fakenotif.FakeNotifier
applier *fakeappl.FakeApplier
compiler *fakecomp.FakeCompiler
jobSupervisor *fakejobsuper.FakeJobSupervisor
specService *fakeas.FakeV1Service
drainScriptProvider boshdrain.DrainScriptProvider
factory Factory
logger boshlog.Logger
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
blobstore = &fakeblobstore.FakeBlobstore{}
taskService = &faketask.FakeService{}
notifier = fakenotif.NewFakeNotifier()
applier = fakeappl.NewFakeApplier()
compiler = fakecomp.NewFakeCompiler()
import (
"errors"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/agent/action"
fakeplatform "bosh/platform/fakes"
fakesettings "bosh/settings/fakes"
)
var _ = Describe("prepareConfigureNetworks", func() {
var (
action PrepareConfigureNetworksAction
platform *fakeplatform.FakePlatform
settingsService *fakesettings.FakeSettingsService
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
settingsService = &fakesettings.FakeSettingsService{}
action = NewPrepareConfigureNetworks(platform, settingsService)
})
It("is synchronous", func() {
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
func init() {
var (
platform *fakeplatform.FakePlatform
fakeDevicePathResolver *fakedpresolv.FakeDevicePathResolver
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
fakeDevicePathResolver = fakedpresolv.NewFakeDevicePathResolver(
1*time.Millisecond,
platform.GetFs(),
)
})
Describe("AWS Infrastructure", func() {
Describe("SetupSsh", func() {
var (
ts *httptest.Server
aws Infrastructure
)
const expectedKey = "some public key"
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/meta-data/public-keys/0/openssh-key"))
w.Write([]byte(expectedKey))
})
ts = httptest.NewServer(handler)
})
AfterEach(func() {
ts.Close()
})
It("gets the public key and sets up ssh via the platform", func() {
aws = NewAwsInfrastructure(ts.URL, &FakeDNSResolver{}, platform, fakeDevicePathResolver)
err := aws.SetupSsh("vcap")
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupSshPublicKey).To(Equal(expectedKey))
Expect(platform.SetupSshUsername).To(Equal("vcap"))
})
})
Describe("GetSettings", func() {
var (
settingsJSON string
expectedSettings boshsettings.Settings
)
BeforeEach(func() {
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": "s3"
},
"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"
}
}`
settingsJSON = strings.Replace(settingsJSON, `"`, `\"`, -1)
settingsJSON = strings.Replace(settingsJSON, "\n", "", -1)
settingsJSON = strings.Replace(settingsJSON, "\t", "", -1)
settingsJSON = fmt.Sprintf(`{"settings": "%s"}`, settingsJSON)
expectedSettings = boshsettings.Settings{
AgentID: "my-agent-id",
Blobstore: boshsettings.Blobstore{
Options: map[string]string{
"bucket_name": "george",
"encryption_key": "optional encryption key",
"access_key_id": "optional access key id",
"secret_access_key": "optional secret access key",
},
Type: "s3",
},
Disks: boshsettings.Disks{
Ephemeral: "/dev/sdb",
Persistent: map[string]string{"vol-xxxxxx": "/dev/sdf"},
System: "/dev/sda1",
},
Env: boshsettings.Env{
Bosh: boshsettings.BoshEnv{
Password: "******",
},
},
Networks: boshsettings.Networks{
"netA": boshsettings.Network{
Default: []string{"dns", "gateway"},
IP: "ww.ww.ww.ww",
DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy"},
},
"netB": boshsettings.Network{
DNS: []string{"zz.zz.zz.zz"},
},
},
Mbus: "https://*****:*****@0.0.0.0:6868",
Ntp: []string{
"0.north-america.pool.ntp.org",
"1.north-america.pool.ntp.org",
},
VM: boshsettings.VM{
Name: "vm-abc-def",
},
}
})
Context("when a dns is not provided", func() {
It("aws get settings", func() {
boshRegistryHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/instances/123-456-789/settings"))
w.Write([]byte(settingsJSON))
})
registryTs := httptest.NewServer(boshRegistryHandler)
defer registryTs.Close()
expectedUserData := fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, registryTs.URL)
instanceID := "123-456-789"
awsMetaDataHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
Expect(r.Method).To(Equal("GET"))
switch r.URL.Path {
case "/latest/user-data":
w.Write([]byte(expectedUserData))
case "/latest/meta-data/instance-id":
w.Write([]byte(instanceID))
}
})
metadataTs := httptest.NewServer(awsMetaDataHandler)
defer metadataTs.Close()
platform := fakeplatform.NewFakePlatform()
aws := NewAwsInfrastructure(metadataTs.URL, &FakeDNSResolver{}, platform, fakeDevicePathResolver)
settings, err := aws.GetSettings()
Expect(err).NotTo(HaveOccurred())
Expect(settings).To(Equal(expectedSettings))
})
})
Context("when dns servers are provided", func() {
It("aws get settings", func() {
fakeDNSResolver := &FakeDNSResolver{
LookupHostIP: "127.0.0.1",
}
registryHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/instances/123-456-789/settings"))
w.Write([]byte(settingsJSON))
})
registryTs := httptest.NewServer(registryHandler)
registryURL, err := url.Parse(registryTs.URL)
Expect(err).NotTo(HaveOccurred())
registryTsPort := strings.Split(registryURL.Host, ":")[1]
defer registryTs.Close()
expectedUserData := fmt.Sprintf(`
{
"registry":{
"endpoint":"http://the.registry.name:%s"
},
"dns":{
"nameserver": ["8.8.8.8", "9.9.9.9"]
}
}`, registryTsPort)
instanceID := "123-456-789"
awsMetaDataHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
Expect(r.Method).To(Equal("GET"))
switch r.URL.Path {
case "/latest/user-data":
w.Write([]byte(expectedUserData))
case "/latest/meta-data/instance-id":
w.Write([]byte(instanceID))
}
})
metadataTs := httptest.NewServer(awsMetaDataHandler)
defer metadataTs.Close()
platform := fakeplatform.NewFakePlatform()
aws := NewAwsInfrastructure(metadataTs.URL, fakeDNSResolver, platform, fakeDevicePathResolver)
settings, err := aws.GetSettings()
Expect(err).NotTo(HaveOccurred())
Expect(settings).To(Equal(expectedSettings))
Expect(fakeDNSResolver.LookupHostHost).To(Equal("the.registry.name"))
Expect(fakeDNSResolver.LookupHostDNSServers).To(Equal([]string{"8.8.8.8", "9.9.9.9"}))
})
})
})
Describe("SetupNetworking", func() {
It("sets up DHCP on the platform", func() {
fakeDNSResolver := &FakeDNSResolver{}
platform := fakeplatform.NewFakePlatform()
aws := NewAwsInfrastructure("", fakeDNSResolver, platform, fakeDevicePathResolver)
networks := boshsettings.Networks{"bosh": boshsettings.Network{}}
aws.SetupNetworking(networks)
Expect(platform.SetupDhcpNetworks).To(Equal(networks))
})
})
Describe("GetEphemeralDiskPath", func() {
It("returns the real disk path given an AWS EBS hint", func() {
fakeDNSResolver := &FakeDNSResolver{}
platform := fakeplatform.NewFakePlatform()
aws := NewAwsInfrastructure("", fakeDNSResolver, platform, fakeDevicePathResolver)
platform.NormalizeDiskPathRealPath = "/dev/xvdb"
platform.NormalizeDiskPathFound = true
realPath, found := aws.GetEphemeralDiskPath("/dev/sdb")
Expect(found).To(Equal(true))
Expect(realPath).To(Equal("/dev/xvdb"))
Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb"))
})
})
Describe("MountPersistentDisk", func() {
It("mounts the persistent disk", func() {
fakePlatform := fakeplatform.NewFakePlatform()
fakeFormatter := fakePlatform.FakeDiskManager.FakeFormatter
fakePartitioner := fakePlatform.FakeDiskManager.FakePartitioner
fakeMounter := fakePlatform.FakeDiskManager.FakeMounter
fakePlatform.GetFs().WriteFile("/dev/vdf", []byte{})
fakeDNSResolver := &FakeDNSResolver{}
aws := NewAwsInfrastructure("", fakeDNSResolver, fakePlatform, fakeDevicePathResolver)
fakeDevicePathResolver.RealDevicePath = "/dev/vdf"
err := aws.MountPersistentDisk("/dev/sdf", "/mnt/point")
Expect(err).NotTo(HaveOccurred())
mountPoint := fakePlatform.Fs.GetFileTestStat("/mnt/point")
Expect(mountPoint.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(mountPoint.FileMode).To(Equal(os.FileMode(0700)))
partition := fakePartitioner.PartitionPartitions[0]
Expect(fakePartitioner.PartitionDevicePath).To(Equal("/dev/vdf"))
Expect(len(fakePartitioner.PartitionPartitions)).To(Equal(1))
Expect(partition.Type).To(Equal(boshdisk.PartitionTypeLinux))
Expect(len(fakeFormatter.FormatPartitionPaths)).To(Equal(1))
Expect(fakeFormatter.FormatPartitionPaths[0]).To(Equal("/dev/vdf1"))
Expect(len(fakeFormatter.FormatFsTypes)).To(Equal(1))
Expect(fakeFormatter.FormatFsTypes[0]).To(Equal(boshdisk.FileSystemExt4))
Expect(len(fakeMounter.MountMountPoints)).To(Equal(1))
Expect(fakeMounter.MountMountPoints[0]).To(Equal("/mnt/point"))
Expect(len(fakeMounter.MountPartitionPaths)).To(Equal(1))
Expect(fakeMounter.MountPartitionPaths[0]).To(Equal("/dev/vdf1"))
})
})
})
}
func init() {
Describe("vSphere Infrastructure", func() {
var (
logger boshlog.Logger
vsphere Infrastructure
platform *fakeplatform.FakePlatform
fakeDevicePathResolver *fakedpresolv.FakeDevicePathResolver
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
fakeDevicePathResolver = fakedpresolv.NewFakeDevicePathResolver(1*time.Millisecond, platform.GetFs())
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
vsphere = NewVsphereInfrastructure(platform, fakeDevicePathResolver, logger)
})
Describe("GetSettings", func() {
It("vsphere get settings", func() {
platform.GetFileContentsFromCDROMContents = []byte(`{"agent_id": "123"}`)
settings, err := vsphere.GetSettings()
Expect(err).NotTo(HaveOccurred())
Expect(platform.GetFileContentsFromCDROMPath).To(Equal("env"))
Expect(settings.AgentID).To(Equal("123"))
})
})
Describe("SetupNetworking", func() {
It("vsphere setup networking", func() {
networks := boshsettings.Networks{"bosh": boshsettings.Network{}}
vsphere.SetupNetworking(networks)
Expect(platform.SetupManualNetworkingNetworks).To(Equal(networks))
})
})
Describe("GetEphemeralDiskPath", func() {
It("vsphere get ephemeral disk path", func() {
realPath, found := vsphere.GetEphemeralDiskPath("does not matter")
Expect(found).To(Equal(true))
Expect(realPath).To(Equal("/dev/sdb"))
})
})
Describe("MountPersistentDisk", func() {
BeforeEach(func() {
fakeDevicePathResolver.RealDevicePath = "fake-real-device-path"
})
It("creates the mount directory with the correct permissions", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
mountPoint := platform.Fs.GetFileTestStat("/mnt/point")
Expect(mountPoint.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(mountPoint.FileMode).To(Equal(os.FileMode(0700)))
})
It("partitions the disk", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
Expect(platform.FakeDiskManager.FakePartitioner.PartitionDevicePath).To(Equal("fake-real-device-path"))
partitions := []boshdisk.Partition{
{Type: boshdisk.PartitionTypeLinux},
}
Expect(platform.FakeDiskManager.FakePartitioner.PartitionPartitions).To(Equal(partitions))
})
It("formats the disk", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
Expect(platform.FakeDiskManager.FakeFormatter.FormatPartitionPaths).To(Equal([]string{"fake-real-device-path1"}))
Expect(platform.FakeDiskManager.FakeFormatter.FormatFsTypes).To(Equal([]boshdisk.FileSystemType{boshdisk.FileSystemExt4}))
})
It("mounts the disk", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
Expect(platform.FakeDiskManager.FakeMounter.MountPartitionPaths).To(Equal([]string{"fake-real-device-path1"}))
Expect(platform.FakeDiskManager.FakeMounter.MountMountPoints).To(Equal([]string{"/mnt/point"}))
})
})
})
}
func init() {
Describe("concreteFactory", func() {
var (
settings *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
infrastructure *fakeinfrastructure.FakeInfrastructure
blobstore *fakeblobstore.FakeBlobstore
taskService *faketask.FakeService
notifier *fakenotif.FakeNotifier
applier *fakeappl.FakeApplier
compiler *fakecomp.FakeCompiler
jobSupervisor *fakejobsuper.FakeJobSupervisor
specService *fakeas.FakeV1Service
drainScriptProvider boshdrain.DrainScriptProvider
factory Factory
logger boshlog.Logger
)
BeforeEach(func() {
settings = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
infrastructure = fakeinfrastructure.NewFakeInfrastructure()
blobstore = &fakeblobstore.FakeBlobstore{}
taskService = &faketask.FakeService{}
notifier = fakenotif.NewFakeNotifier()
applier = fakeappl.NewFakeApplier()
compiler = fakecomp.NewFakeCompiler()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
specService = fakeas.NewFakeV1Service()
drainScriptProvider = boshdrain.NewConcreteDrainScriptProvider(nil, nil, platform.GetDirProvider())
logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
})
JustBeforeEach(func() {
factory = NewFactory(
settings,
platform,
infrastructure,
blobstore,
taskService,
notifier,
applier,
compiler,
jobSupervisor,
specService,
drainScriptProvider,
logger,
)
})
It("new factory", func() {
actions := []string{
"apply",
"drain",
"fetch_logs",
"get_task",
"get_state",
"list_disk",
"migrate_disk",
"mount_disk",
"ping",
"prepare_network_change",
"ssh",
"start",
"stop",
"unmount_disk",
"compile_package",
"release_apply_spec",
}
for _, actionName := range actions {
action, err := factory.Create(actionName)
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
}
action, err := factory.Create("gobberish")
Expect(err).To(HaveOccurred())
Expect(action).To(BeNil())
})
It("apply", func() {
action, err := factory.Create("apply")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewApply(applier, specService)).To(Equal(action))
})
It("drain", func() {
action, err := factory.Create("drain")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewDrain(notifier, specService, drainScriptProvider, jobSupervisor)).To(Equal(action))
})
It("fetch_logs", func() {
action, err := factory.Create("fetch_logs")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewLogs(platform.GetCompressor(), platform.GetCopier(), blobstore, platform.GetDirProvider())).To(Equal(action))
})
It("get_task", func() {
action, err := factory.Create("get_task")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewGetTask(taskService)).To(Equal(action))
})
It("get_state", func() {
ntpService := boshntp.NewConcreteService(platform.GetFs(), platform.GetDirProvider())
action, err := factory.Create("get_state")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewGetState(settings, specService, jobSupervisor, platform.GetVitalsService(), ntpService)).To(Equal(action))
})
It("list_disk", func() {
action, err := factory.Create("list_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewListDisk(settings, platform, logger)).To(Equal(action))
})
It("migrate_disk", func() {
action, err := factory.Create("migrate_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewMigrateDisk(platform, platform.GetDirProvider())).To(Equal(action))
})
It("mount_disk", func() {
action, err := factory.Create("mount_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewMountDisk(settings, infrastructure, platform, platform.GetDirProvider())).To(Equal(action))
})
It("prepare_network_change", func() {
action, err := factory.Create("prepare_network_change")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewPrepareNetworkChange(platform.GetFs(), settings)).To(Equal(action))
})
It("prepare_configure_networks", func() {
action, err := factory.Create("prepare_configure_networks")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewPrepareConfigureNetworks(platform.GetFs(), settings)).To(Equal(action))
})
It("configure_networks", func() {
action, err := factory.Create("configure_networks")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewConfigureNetworks()).To(Equal(action))
})
It("ssh", func() {
action, err := factory.Create("ssh")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewSsh(settings, platform, platform.GetDirProvider())).To(Equal(action))
})
It("start", func() {
action, err := factory.Create("start")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewStart(jobSupervisor)).To(Equal(action))
})
It("unmount_disk", func() {
action, err := factory.Create("unmount_disk")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewUnmountDisk(settings, platform)).To(Equal(action))
})
It("compile_package", func() {
action, err := factory.Create("compile_package")
Expect(err).NotTo(HaveOccurred())
Expect(action).ToNot(BeNil())
Expect(NewCompilePackage(compiler)).To(Equal(action))
})
})
}
import (
"errors"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/agent/action"
fakeplatform "bosh/platform/fakes"
boshdirs "bosh/settings/directories"
fakesettings "bosh/settings/fakes"
)
var _ = Describe("MountDiskAction", func() {
var (
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
action MountDiskAction
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
dirProvider := boshdirs.NewDirectoriesProvider("/fake-base-dir")
action = NewMountDisk(settingsService, platform, platform, dirProvider)
})
It("is asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
func init() {
Describe("awsInfrastructure", func() {
var (
metadataService *fakeinf.FakeMetadataService
registry *fakeinf.FakeRegistry
platform *fakeplatform.FakePlatform
devicePathResolver *fakedpresolv.FakeDevicePathResolver
aws Infrastructure
)
BeforeEach(func() {
metadataService = &fakeinf.FakeMetadataService{}
registry = &fakeinf.FakeRegistry{}
platform = fakeplatform.NewFakePlatform()
devicePathResolver = fakedpresolv.NewFakeDevicePathResolver()
logger := boshlog.NewLogger(boshlog.LevelNone)
aws = NewAwsInfrastructure(metadataService, registry, platform, devicePathResolver, logger)
})
Describe("SetupSSH", func() {
It("gets the public key and sets up ssh via the platform", func() {
metadataService.PublicKey = "fake-public-key"
err := aws.SetupSSH("vcap")
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupSSHPublicKey).To(Equal("fake-public-key"))
Expect(platform.SetupSSHUsername).To(Equal("vcap"))
})
It("returns error without configuring ssh on the platform if getting public key fails", func() {
metadataService.GetPublicKeyErr = errors.New("fake-get-public-key-err")
err := aws.SetupSSH("vcap")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-public-key-err"))
Expect(platform.SetupSSHCalled).To(BeFalse())
})
It("returns error if configuring ssh on the platform fails", func() {
platform.SetupSSHErr = errors.New("fake-setup-ssh-err")
err := aws.SetupSSH("vcap")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-ssh-err"))
})
})
Describe("GetSettings", func() {
It("gets settings", func() {
settings := boshsettings.Settings{AgentID: "fake-agent-id"}
registry.Settings = settings
settings, err := aws.GetSettings()
Expect(err).ToNot(HaveOccurred())
Expect(settings).To(Equal(settings))
})
It("returns an error when registry fails to get settings", func() {
registry.GetSettingsErr = errors.New("fake-get-settings-err")
settings, err := aws.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-settings-err"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
})
Describe("SetupNetworking", func() {
It("sets up DHCP on the platform", func() {
networks := boshsettings.Networks{"bosh": boshsettings.Network{}}
err := aws.SetupNetworking(networks)
Expect(err).ToNot(HaveOccurred())
Expect(platform.SetupDhcpNetworks).To(Equal(networks))
})
It("returns error if configuring DHCP fails", func() {
platform.SetupDhcpErr = errors.New("fake-setup-dhcp-err")
err := aws.SetupNetworking(boshsettings.Networks{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-dhcp-err"))
})
})
Describe("GetEphemeralDiskPath", func() {
It("returns the real disk path given an AWS EBS hint", func() {
platform.NormalizeDiskPathRealPath = "/dev/xvdb"
platform.NormalizeDiskPathFound = true
realPath, found := aws.GetEphemeralDiskPath("/dev/sdb")
Expect(found).To(Equal(true))
Expect(realPath).To(Equal("/dev/xvdb"))
Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb"))
})
It("returns false if path cannot be normalized", func() {
platform.NormalizeDiskPathRealPath = ""
platform.NormalizeDiskPathFound = false
realPath, found := aws.GetEphemeralDiskPath("/dev/sdb")
Expect(found).To(BeFalse())
Expect(realPath).To(Equal(""))
Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb"))
})
It("returns false if device path is empty because ephemeral storage should not be on root partition", func() {
realPath, found := aws.GetEphemeralDiskPath("")
Expect(found).To(BeFalse())
Expect(realPath).To(BeEmpty())
Expect(platform.NormalizeDiskPathCalled).To(BeFalse())
})
})
})
}
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "bosh/blobstore"
boshlog "bosh/logger"
fakeplatform "bosh/platform/fakes"
boshsettings "bosh/settings"
boshdir "bosh/settings/directories"
boshuuid "bosh/uuid"
)
var _ = Describe("Provider", func() {
var (
platform *fakeplatform.FakePlatform
logger boshlog.Logger
provider Provider
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
logger = boshlog.NewLogger(boshlog.LevelNone)
provider = NewProvider(platform, dirProvider, logger)
})
Describe("Get", func() {
It("get dummy", func() {
blobstore, err := provider.Get(boshsettings.Blobstore{
Type: boshsettings.BlobstoreTypeDummy,
})