func init() {
Describe("concreteBuilder", func() {
var (
settingsService *fakesettings.FakeSettingsService
builder Builder
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LEVEL_NONE)
settingsService = &fakesettings.FakeSettingsService{}
builder = NewBuilder(settingsService, logger)
})
Describe("Build", func() {
It("builds alert with id, severity and other monit related info", func() {
builtAlert, err := builder.Build(buildMonitAlert())
Expect(err).ToNot(HaveOccurred())
expectedAlert := Alert{
Id: "some random id",
Severity: SEVERITY_ALERT,
Title: "nats - does not exist - restart",
Summary: "process is not running",
CreatedAt: 1306076861,
}
Expect(builtAlert).To(Equal(expectedAlert))
})
It("sets the severity based on event", func() {
alerts := map[string]SeverityLevel{
"action done": SEVERITY_IGNORED,
"Action done": SEVERITY_IGNORED,
"action Done": SEVERITY_IGNORED,
}
for event, expectedSeverity := range alerts {
inputAlert := buildMonitAlert()
inputAlert.Event = event
builtAlert, _ := builder.Build(inputAlert)
Expect(builtAlert.Severity).To(Equal(expectedSeverity))
}
})
It("sets default severity to critical", func() {
inputAlert := buildMonitAlert()
inputAlert.Event = "some unknown event"
builtAlert, _ := builder.Build(inputAlert)
Expect(builtAlert.Severity).To(Equal(SEVERITY_CRITICAL))
})
It("sets created at", func() {
inputAlert := buildMonitAlert()
inputAlert.Date = "Thu, 02 May 2013 20:07:41 +0500"
builtAlert, _ := builder.Build(inputAlert)
Expect(int(builtAlert.CreatedAt)).To(Equal(int(1367507261)))
})
It("defaults created at to now on parse error", func() {
inputAlert := buildMonitAlert()
inputAlert.Date = "Thu, 02 May 2013 20:07:0"
builtAlert, _ := builder.Build(inputAlert)
createdAt := time.Unix(builtAlert.CreatedAt, 0)
now := time.Now()
assert.WithinDuration(GinkgoT(), now, createdAt, 1*time.Second)
})
It("sets the title with ips", func() {
inputAlert := buildMonitAlert()
settingsService.Ips = []string{"192.168.0.1", "10.0.0.1"}
builtAlert, _ := builder.Build(inputAlert)
Expect(builtAlert.Title).To(Equal("nats (10.0.0.1, 192.168.0.1) - does not exist - restart"))
})
})
})
}
func init() {
Describe("prepareNetworkChange", func() {
var (
action PrepareNetworkChangeAction
fs *fakesys.FakeFileSystem
settingsService *fakesettings.FakeSettingsService
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
settingsService = &fakesettings.FakeSettingsService{}
action = NewPrepareNetworkChange(fs, settingsService)
})
It("is synchronous", func() {
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
It("invalidates settings so that load settings cannot fall back on old settings", func() {
resp, err := action.Run()
Expect(err).NotTo(HaveOccurred())
Expect(resp).To(Equal("ok"))
Expect(settingsService.SettingsWereInvalidated).To(BeTrue())
})
Context("when settings invalidation succeeds", func() {
Context("when the network rules file can be removed", func() {
It("removes the network rules file", func() {
fs.WriteFile("/etc/udev/rules.d/70-persistent-net.rules", []byte{})
resp, err := action.Run()
Expect(err).NotTo(HaveOccurred())
Expect(resp).To(Equal("ok"))
Expect(fs.FileExists("/etc/udev/rules.d/70-persistent-net.rules")).To(BeFalse())
})
})
Context("when the network rules file cannot be removed", func() {
BeforeEach(func() {
fs.RemoveAllError = errors.New("fake-remove-all-error")
})
It("returns error from removing the network rules file", func() {
resp, err := action.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-all-error"))
Expect(resp).To(BeNil())
})
})
})
Context("when settings invalidation fails", func() {
BeforeEach(func() {
settingsService.InvalidateSettingsError = errors.New("fake-invalidate-error")
})
It("returns error early if settings err invalidating", func() {
resp, err := action.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-invalidate-error"))
Expect(resp).To(BeNil())
})
It("does not remove the network rules file", func() {
fs.WriteFile("/etc/udev/rules.d/70-persistent-net.rules", []byte{})
action.Run()
Expect(fs.FileExists("/etc/udev/rules.d/70-persistent-net.rules")).To(BeTrue())
})
})
})
}
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())
})
})
})
}
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("ApplyAction", func() {
var (
applier *fakeappl.FakeApplier
specService *fakeas.FakeV1Service
settingsService *fakesettings.FakeSettingsService
action ApplyAction
)
BeforeEach(func() {
applier = fakeappl.NewFakeApplier()
specService = fakeas.NewFakeV1Service()
settingsService = &fakesettings.FakeSettingsService{}
action = NewApply(applier, specService, settingsService)
})
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.PopulateDynamicNetworksSpec).To(Equal(desiredApplySpec))
Expect(specService.PopulateDynamicNetworksSettings).To(Equal(settings))
})
Context("when resolving dynamic networks succeeds", func() {
BeforeEach(func() {
specService.PopulateDynamicNetworksResultSpec = 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("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.PopulateDynamicNetworksErr = 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.PopulateDynamicNetworksSpec).To(Equal(desiredApplySpec))
Expect(specService.PopulateDynamicNetworksSettings).To(Equal(settings))
})
Context("when resolving dynamic networks succeeds", func() {
BeforeEach(func() {
specService.PopulateDynamicNetworksResultSpec = 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.PopulateDynamicNetworksErr = 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))
})
})
})
})
})
}
fakeas "bosh/agent/applier/applyspec/fakes"
boshassert "bosh/assert"
fakejobsuper "bosh/jobsupervisor/fakes"
boshntp "bosh/platform/ntp"
fakentp "bosh/platform/ntp/fakes"
boshvitals "bosh/platform/vitals"
fakevitals "bosh/platform/vitals/fakes"
boshsettings "bosh/settings"
fakesettings "bosh/settings/fakes"
)
var _ = Describe("GetState", func() {
var (
settings *fakesettings.FakeSettingsService
specService *fakeas.FakeV1Service
jobSupervisor *fakejobsuper.FakeJobSupervisor
vitalsService *fakevitals.FakeService
action GetStateAction
)
BeforeEach(func() {
settings = &fakesettings.FakeSettingsService{}
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
specService = fakeas.NewFakeV1Service()
vitalsService = fakevitals.NewFakeService()
action = NewGetState(settings, specService, jobSupervisor, vitalsService, &fakentp.FakeService{
GetOffsetNTPOffset: boshntp.NTPInfo{
Offset: "0.34958",
Timestamp: "12 Oct 17:37:58",
},
})
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())