func testUbuntuSetupDhcp(
t *testing.T,
fakeStats *fakestats.FakeStatsCollector,
fakeFs *fakesys.FakeFileSystem,
fakeCmdRunner *fakesys.FakeCmdRunner,
fakeDiskManager fakedisk.FakeDiskManager,
fakeCompressor *fakedisk.FakeCompressor,
) {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
Dns: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
Dns: []string{"aa.aa.aa.aa"},
},
}
ubuntu := newUbuntuPlatform(fakeStats, fakeFs, fakeCmdRunner, fakeDiskManager, fakeCompressor)
ubuntu.SetupDhcp(networks)
dhcpConfig := fakeFs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
assert.NotNil(t, dhcpConfig)
assert.Equal(t, dhcpConfig.Content, EXPECTED_DHCP_CONFIG)
}
func init() {
Describe("renderedJobApplier", func() {
var (
jobsBc *fakebc.FakeBundleCollection
jobSupervisor *fakejobsuper.FakeJobSupervisor
packageApplierProvider *fakepa.FakePackageApplierProvider
blobstore *fakeblob.FakeBlobstore
compressor *fakecmd.FakeCompressor
fs *fakesys.FakeFileSystem
applier JobApplier
)
BeforeEach(func() {
jobsBc = fakebc.NewFakeBundleCollection()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
packageApplierProvider = fakepa.NewFakePackageApplierProvider()
blobstore = fakeblob.NewFakeBlobstore()
fs = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
logger := boshlog.NewLogger(boshlog.LevelNone)
applier = NewRenderedJobApplier(
jobsBc,
jobSupervisor,
packageApplierProvider,
blobstore,
compressor,
fs,
logger,
)
})
Describe("Prepare & Apply", func() {
var (
job models.Job
bundle *fakebc.FakeBundle
)
BeforeEach(func() {
job, bundle = buildJob(jobsBc)
})
ItInstallsJob := func(act func() error) {
It("returns error when installing job fails", func() {
bundle.InstallError = errors.New("fake-install-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-install-error"))
})
It("downloads and later cleans up downloaded job template blob", func() {
blobstore.GetFileName = "/fake-blobstore-file-name"
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs[0]).To(Equal("fake-blobstore-id"))
Expect(blobstore.GetFingerprints[0]).To(Equal("fake-blob-sha1"))
// downloaded file is cleaned up
Expect(blobstore.CleanUpFileName).To(Equal("/fake-blobstore-file-name"))
})
It("returns error when downloading job template blob fails", func() {
blobstore.GetError = errors.New("fake-get-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-error"))
})
It("decompresses job template blob to tmp path and later cleans it up", func() {
fs.TempDirDir = "/fake-tmp-dir"
blobstore.GetFileName = "/fake-blobstore-file-name"
var tmpDirExistsBeforeInstall bool
bundle.InstallCallBack = func() {
tmpDirExistsBeforeInstall = true
}
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(compressor.DecompressFileToDirTarballPaths[0]).To(Equal("/fake-blobstore-file-name"))
Expect(compressor.DecompressFileToDirDirs[0]).To(Equal("/fake-tmp-dir"))
// tmp dir exists before bundle install
Expect(tmpDirExistsBeforeInstall).To(BeTrue())
// tmp dir is cleaned up after install
Expect(fs.FileExists(fs.TempDirDir)).To(BeFalse())
})
It("returns error when temporary directory creation fails", func() {
fs.TempDirError = errors.New("fake-filesystem-tempdir-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-filesystem-tempdir-error"))
})
It("returns error when decompressing job template fails", func() {
compressor.DecompressFileToDirErr = errors.New("fake-decompress-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-decompress-error"))
})
It("returns error when getting the list of bin files fails", func() {
fs.GlobErr = errors.New("fake-glob-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-glob-error"))
})
It("returns error when changing permissions on bin files fails", func() {
fs.TempDirDir = "/fake-tmp-dir"
fs.SetGlob("/fake-tmp-dir/fake-path-in-archive/bin/*", []string{
"/fake-tmp-dir/fake-path-in-archive/bin/test",
})
fs.ChmodErr = errors.New("fake-chmod-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-chmod-error"))
})
It("installs bundle from decompressed tmp path of a job template", func() {
fs.TempDirDir = "/fake-tmp-dir"
var installedBeforeDecompression bool
compressor.DecompressFileToDirCallBack = func() {
installedBeforeDecompression = bundle.Installed
}
err := act()
Expect(err).ToNot(HaveOccurred())
// bundle installation did not happen before decompression
Expect(installedBeforeDecompression).To(BeFalse())
// make sure that bundle install happened after decompression
Expect(bundle.InstallSourcePath).To(Equal("/fake-tmp-dir/fake-path-in-archive"))
})
It("sets executable bit for files in bin", func() {
fs.TempDirDir = "/fake-tmp-dir"
compressor.DecompressFileToDirCallBack = func() {
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/bin/test1", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/bin/test2", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/test", []byte{})
}
fs.SetGlob("/fake-tmp-dir/fake-path-in-archive/bin/*", []string{
"/fake-tmp-dir/fake-path-in-archive/bin/test1",
"/fake-tmp-dir/fake-path-in-archive/bin/test2",
})
var binTest1Stats, binTest2Stats, configTestStats *fakesys.FakeFileStats
bundle.InstallCallBack = func() {
binTest1Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/bin/test1")
binTest2Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/bin/test2")
configTestStats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config/test")
}
err := act()
Expect(err).ToNot(HaveOccurred())
// bin files are executable
Expect(int(binTest1Stats.FileMode)).To(Equal(0755))
Expect(int(binTest2Stats.FileMode)).To(Equal(0755))
// non-bin files are not made executable
Expect(int(configTestStats.FileMode)).ToNot(Equal(0755))
})
}
ItUpdatesPackages := func(act func() error) {
var packageApplier *fakepa.FakePackageApplier
BeforeEach(func() {
packageApplier = fakepa.NewFakePackageApplier()
packageApplierProvider.JobSpecificPackageAppliers[job.Name] = packageApplier
})
It("applies each package that job depends on and then cleans up packages", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(packageApplier.ActionsCalled).To(Equal([]string{"Apply", "Apply", "KeepOnly"}))
Expect(len(packageApplier.AppliedPackages)).To(Equal(2)) // present
Expect(packageApplier.AppliedPackages).To(Equal(job.Packages))
})
It("returns error when applying package that job depends on fails", func() {
packageApplier.ApplyError = errors.New("fake-apply-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-apply-err"))
})
It("keeps only currently required packages but does not completely uninstall them", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(len(packageApplier.KeptOnlyPackages)).To(Equal(2)) // present
Expect(packageApplier.KeptOnlyPackages).To(Equal(job.Packages))
})
It("returns error when keeping only currently required packages fails", func() {
packageApplier.KeepOnlyErr = errors.New("fake-keep-only-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-keep-only-err"))
})
}
Describe("Prepare", func() {
act := func() error { return applier.Prepare(job) }
It("return an error if getting file bundle fails", func() {
jobsBc.GetErr = errors.New("fake-get-bundle-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-bundle-error"))
})
It("returns an error if checking for installed path fails", func() {
bundle.IsInstalledErr = errors.New("fake-is-installed-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-installed-error"))
})
Context("when job is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{})) // no Install
})
It("does not download the job template", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
})
Context("when job is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs job (but does not enable)", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install"}))
})
ItInstallsJob(act)
})
})
Describe("Apply", func() {
act := func() error { return applier.Apply(job) }
It("return an error if getting file bundle fails", func() {
jobsBc.GetErr = errors.New("fake-get-bundle-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-bundle-error"))
})
It("returns an error if checking for installed path fails", func() {
bundle.IsInstalledErr = errors.New("fake-is-installed-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-installed-error"))
})
Context("when job is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install but only enables job", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Enable"})) // no Install
})
It("returns error when job enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
It("does not download the job template", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
ItUpdatesPackages(act)
})
Context("when job is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs and enables job", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install", "Enable"}))
})
It("returns error when job enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
ItInstallsJob(act)
ItUpdatesPackages(act)
})
})
})
Describe("Configure", func() {
It("adds job to the job supervisor", func() {
job, bundle := buildJob(jobsBc)
fs := fakesys.NewFakeFileSystem()
fs.WriteFileString("/path/to/job/monit", "some conf")
fs.SetGlob("/path/to/job/*.monit", []string{"/path/to/job/subjob.monit"})
bundle.GetDirPath = "/path/to/job"
bundle.GetDirFs = fs
err := applier.Configure(job, 0)
Expect(err).ToNot(HaveOccurred())
Expect(2).To(Equal(len(jobSupervisor.AddJobArgs)))
firstArgs := fakejobsuper.AddJobArgs{
Name: job.Name,
Index: 0,
ConfigPath: "/path/to/job/monit",
}
secondArgs := fakejobsuper.AddJobArgs{
Name: job.Name + "_subjob",
Index: 0,
ConfigPath: "/path/to/job/subjob.monit",
}
Expect(firstArgs).To(Equal(jobSupervisor.AddJobArgs[0]))
Expect(secondArgs).To(Equal(jobSupervisor.AddJobArgs[1]))
})
})
Describe("KeepOnly", func() {
It("first disables and then uninstalls jobs that are not in keeponly list", func() {
_, bundle1 := buildJob(jobsBc)
job2, bundle2 := buildJob(jobsBc)
_, bundle3 := buildJob(jobsBc)
job4, bundle4 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1, bundle2, bundle3, bundle4}
err := applier.KeepOnly([]models.Job{job4, job2})
Expect(err).ToNot(HaveOccurred())
Expect(bundle1.ActionsCalled).To(Equal([]string{"Disable", "Uninstall"}))
Expect(bundle2.ActionsCalled).To(Equal([]string{}))
Expect(bundle3.ActionsCalled).To(Equal([]string{"Disable", "Uninstall"}))
Expect(bundle4.ActionsCalled).To(Equal([]string{}))
})
It("returns error when bundle collection fails to return list of installed bundles", func() {
jobsBc.ListErr = errors.New("fake-bc-list-error")
err := applier.KeepOnly([]models.Job{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-list-error"))
})
It("returns error when bundle collection cannot retrieve bundle for keep-only job", func() {
job1, bundle1 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1}
jobsBc.GetErr = errors.New("fake-bc-get-error")
err := applier.KeepOnly([]models.Job{job1})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-get-error"))
})
It("returns error when at least one bundle cannot be disabled", func() {
_, bundle1 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.DisableErr = errors.New("fake-bc-disable-error")
err := applier.KeepOnly([]models.Job{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-disable-error"))
})
It("returns error when at least one bundle cannot be uninstalled", func() {
_, bundle1 := buildJob(jobsBc)
jobsBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.UninstallErr = errors.New("fake-bc-uninstall-error")
err := applier.KeepOnly([]models.Job{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-uninstall-error"))
})
})
})
}
func init() {
const expectedUbuntuDHCPConfig = `# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers zz.zz.zz.zz;
prepend domain-name-servers yy.yy.yy.yy;
prepend domain-name-servers xx.xx.xx.xx;
`
Describe("ubuntu", func() {
var (
collector *fakestats.FakeStatsCollector
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
diskManager *fakedisk.FakeDiskManager
dirProvider boshdirs.DirectoriesProvider
platform Platform
cdutil *fakecd.FakeCdUtil
compressor boshcmd.Compressor
copier boshcmd.Copier
vitalsService boshvitals.Service
logger boshlog.Logger
)
BeforeEach(func() {
collector = &fakestats.FakeStatsCollector{}
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
diskManager = fakedisk.NewFakeDiskManager()
dirProvider = boshdirs.NewDirectoriesProvider("/fake-dir")
cdutil = fakecd.NewFakeCdUtil()
compressor = boshcmd.NewTarballCompressor(cmdRunner, fs)
copier = boshcmd.NewCpCopier(cmdRunner, fs)
vitalsService = boshvitals.NewService(collector, dirProvider)
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
netManager := boshnet.NewUbuntuNetManager(fs, cmdRunner, 1*time.Millisecond)
platform = NewLinuxPlatform(
fs,
cmdRunner,
collector,
compressor,
copier,
dirProvider,
vitalsService,
cdutil,
diskManager,
netManager,
1*time.Millisecond,
logger,
)
})
Describe("SetupDhcp", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
DNS: []string{"aa.aa.aa.aa"},
},
}
Context("when dhcp was not previously configured", func() {
It("updates dhclient.conf", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedUbuntuDHCPConfig))
})
It("restarts dhclient", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(2))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"pkill", "dhclient3"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"/etc/init.d/networking", "restart"}))
})
})
Context("when dhcp was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp3/dhclient.conf", "fake-other-configuration")
})
It("sets up dhcp and restarts dhclient", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedUbuntuDHCPConfig))
})
It("sets up dhcp and restarts dhclient", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(2))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"pkill", "dhclient3"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"/etc/init.d/networking", "restart"}))
})
})
Context("when dhcp was previously configured with the same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp3/dhclient.conf", expectedUbuntuDHCPConfig)
})
It("does not restart dhclient", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedUbuntuDHCPConfig))
})
It("does not restart dhclient", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
})
})
Describe("SetupManualNetworking", func() {
BeforeEach(func() {
// For mac addr to interface resolution
fs.WriteFile("/sys/class/net/eth0", []byte{})
fs.WriteFileString("/sys/class/net/eth0/address", "22:00:0a:1f:ac:2a\n")
fs.SetGlob("/sys/class/net/*", []string{"/sys/class/net/eth0"})
})
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns", "gateway"},
IP: "192.168.195.6",
Netmask: "255.255.255.0",
Gateway: "192.168.195.1",
Mac: "22:00:0a:1f:ac:2a",
DNS: []string{"10.80.130.2", "10.80.130.1"},
},
}
Context("when manual networking was not previously configured", func() {
It("writes /etc/network/interfaces", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedUbuntuNetworkInterfaces))
})
It("restarts networking", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands) >= 2).To(BeTrue())
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network-interface", "stop", "INTERFACE=eth0"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"service", "network-interface", "start", "INTERFACE=eth0"}))
})
It("updates dns", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedUbuntuResolvConf))
})
It("starts sending arping", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
time.Sleep(100 * time.Millisecond)
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[7]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
Context("when manual networking was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/network/interfaces", "fake-manual-config")
})
It("updates /etc/network/interfaces", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedUbuntuNetworkInterfaces))
})
It("restarts networking", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands) >= 2).To(BeTrue())
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network-interface", "stop", "INTERFACE=eth0"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"service", "network-interface", "start", "INTERFACE=eth0"}))
})
It("updates dns", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedUbuntuResolvConf))
})
It("starts sending arping", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
time.Sleep(100 * time.Millisecond)
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[7]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
Context("when manual networking was previously configured with same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/network/interfaces", expectedUbuntuNetworkInterfaces)
})
It("keeps same /etc/network/interfaces", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedUbuntuNetworkInterfaces))
})
It("does not restart networking because configuration did not change", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
for _, cmd := range cmdRunner.RunCommands {
Expect(cmd[0]).ToNot(Equal("service"))
}
})
It("updates /etc/resolv.conf for DNS", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedUbuntuResolvConf))
})
It("starts sending 6 arp ping", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
time.Sleep(100 * time.Millisecond)
Expect(len(cmdRunner.RunCommands)).To(Equal(6))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[5]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
})
})
}
func init() {
const expectedUbuntuDHCPConfig = `# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers zz.zz.zz.zz, yy.yy.yy.yy, xx.xx.xx.xx;
`
Describe("ubuntuNetManager", func() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
defaultNetworkResolver *fakenet.FakeDefaultNetworkResolver
netManager NetManager
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
defaultNetworkResolver = &fakenet.FakeDefaultNetworkResolver{}
logger := boshlog.NewLogger(boshlog.LevelNone)
netManager = NewUbuntuNetManager(fs, cmdRunner, defaultNetworkResolver, 1*time.Millisecond, logger)
})
Describe("SetupDhcp", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
DNS: []string{"aa.aa.aa.aa"},
},
}
ItRestartsDhcp := func() {
Context("when ifconfig version is 0.7", func() {
BeforeEach(func() {
cmdRunner.AddCmdResult("ifup --version", fakesys.FakeCmdResult{
Stdout: "ifup version 0.7.47",
})
})
It("restarts dhclient", func() {
err := netManager.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(3))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"ifdown", "-a", "--no-loopback"}))
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"ifup", "-a", "--no-loopback"}))
})
})
Context("when ifconfig version is 0.6", func() {
BeforeEach(func() {
cmdRunner.AddCmdResult("ifup --version", fakesys.FakeCmdResult{
Stdout: "ifup version 0.6.0",
})
})
It("restarts dhclient", func() {
err := netManager.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(3))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"ifdown", "-a", "--exclude=lo"}))
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"ifup", "-a", "--exclude=lo"}))
})
})
}
ItUpdatesDhcp3Config := func() {
It("updates /etc/dhcp3/dhclient.conf", func() {
err := netManager.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedUbuntuDHCPConfig))
})
}
ItUpdatesDhcpConfig := func() {
It("updates /etc/dhcp/dhclient.conf", func() {
err := netManager.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedUbuntuDHCPConfig))
})
}
ItDoesNotRestartDhcp := func() {
It("does not restart dhclient", func() {
err := netManager.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
}
Context("when dhclient3 is installed on the system", func() {
BeforeEach(func() { cmdRunner.CommandExistsValue = true })
Context("when dhcp was not previously configured", func() {
ItUpdatesDhcp3Config()
ItRestartsDhcp()
})
Context("when dhcp was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp3/dhclient.conf", "fake-other-configuration")
})
ItUpdatesDhcp3Config()
ItRestartsDhcp()
})
Context("when dhcp was previously configured with the same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp3/dhclient.conf", expectedUbuntuDHCPConfig)
})
ItUpdatesDhcp3Config()
ItDoesNotRestartDhcp()
})
})
Context("when dhclient3 is not installed on the system", func() {
BeforeEach(func() { cmdRunner.CommandExistsValue = false })
Context("when dhcp was not previously configured", func() {
ItUpdatesDhcpConfig()
ItRestartsDhcp()
})
Context("when dhcp was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp/dhclient.conf", "fake-other-configuration")
})
ItUpdatesDhcpConfig()
ItRestartsDhcp()
})
Context("when dhcp was previously configured with the same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedUbuntuDHCPConfig)
})
ItUpdatesDhcpConfig()
ItDoesNotRestartDhcp()
})
})
})
Describe("SetupManualNetworking", func() {
var errCh chan error
BeforeEach(func() {
errCh = make(chan error)
})
BeforeEach(func() {
// For mac addr to interface resolution
fs.WriteFile("/sys/class/net/eth0", []byte{})
fs.WriteFileString("/sys/class/net/eth0/address", "22:00:0a:1f:ac:2a\n")
fs.SetGlob("/sys/class/net/*", []string{"/sys/class/net/eth0"})
})
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns", "gateway"},
IP: "192.168.195.6",
Netmask: "255.255.255.0",
Gateway: "192.168.195.1",
Mac: "22:00:0a:1f:ac:2a",
DNS: []string{"10.80.130.2", "10.80.130.1"},
},
}
Context("when manual networking was not previously configured", func() {
It("writes /etc/network/interfaces", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedUbuntuNetworkInterfaces))
})
It("restarts networking", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
Expect(len(cmdRunner.RunCommands) >= 2).To(BeTrue())
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network-interface", "stop", "INTERFACE=eth0"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"service", "network-interface", "start", "INTERFACE=eth0"}))
})
It("updates dns", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedUbuntuResolvConf))
})
It("starts sending arping", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[7]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
Context("when manual networking was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/network/interfaces", "fake-manual-config")
})
It("updates /etc/network/interfaces", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedUbuntuNetworkInterfaces))
})
It("restarts networking", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
Expect(len(cmdRunner.RunCommands) >= 2).To(BeTrue())
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network-interface", "stop", "INTERFACE=eth0"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"service", "network-interface", "start", "INTERFACE=eth0"}))
})
It("updates dns", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedUbuntuResolvConf))
})
It("starts sending 6 arp pings", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[7]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
Context("when manual networking was previously configured with same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/network/interfaces", expectedUbuntuNetworkInterfaces)
})
It("keeps same /etc/network/interfaces", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedUbuntuNetworkInterfaces))
})
It("does not restart networking because configuration did not change", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
for _, cmd := range cmdRunner.RunCommands {
Expect(cmd[0]).ToNot(Equal("service"))
}
})
It("updates /etc/resolv.conf for DNS", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedUbuntuResolvConf))
})
It("starts sending 6 arp ping", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
Expect(len(cmdRunner.RunCommands)).To(Equal(6))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[5]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
})
})
}
It("returns an error if creation of parent directory fails", func() {
fs.MkdirAllError = errors.New("fake-mkdir-error")
_, _, err := fileBundle.Install(sourcePath)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-error"))
})
It("sets correct permissions on install path", func() {
fs.Chmod(sourcePath, os.FileMode(0700))
_, _, err := fileBundle.Install(sourcePath)
Expect(err).NotTo(HaveOccurred())
fileStats := fs.GetFileTestStat(installPath)
Expect(fileStats).ToNot(BeNil())
Expect(fileStats.FileType).To(Equal(fakesys.FakeFileType(fakesys.FakeFileTypeDir)))
Expect(fileStats.FileMode).To(Equal(os.FileMode(0755)))
})
It("is idempotent", func() {
actualFs, path, err := fileBundle.Install(sourcePath)
Expect(err).NotTo(HaveOccurred())
Expect(actualFs).To(Equal(fs))
Expect(path).To(Equal(installPath))
otherSourcePath := createSourcePath()
actualFs, path, err = fileBundle.Install(otherSourcePath)
Expect(err).NotTo(HaveOccurred())
Describe("CreateUser", func() {
It("creates user", func() {
expectedUseradd := []string{
"useradd",
"-m",
"-b", "/some/path/to/home",
"-s", "/bin/bash",
"-p", "bar-pwd",
"foo-user",
}
err := platform.CreateUser("foo-user", "bar-pwd", "/some/path/to/home")
Expect(err).NotTo(HaveOccurred())
basePathStat := fs.GetFileTestStat("/some/path/to/home")
Expect(basePathStat.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(basePathStat.FileMode).To(Equal(os.FileMode(0755)))
Expect(cmdRunner.RunCommands).To(Equal([][]string{expectedUseradd}))
})
It("creates user with an empty password", func() {
expectedUseradd := []string{
"useradd",
"-m",
"-b", "/some/path/to/home",
"-s", "/bin/bash",
"foo-user",
}
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{}))
})
})
})
})
}
func init() {
const expectedCentosDHCPConfig = `# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers zz.zz.zz.zz;
prepend domain-name-servers yy.yy.yy.yy;
prepend domain-name-servers xx.xx.xx.xx;
`
const expectedCentosIfcfg = `DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.195.6
NETMASK=255.255.255.0
BROADCAST=192.168.195.255
GATEWAY=192.168.195.1
ONBOOT=yes`
Describe("centos", func() {
var (
collector *fakestats.FakeStatsCollector
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
diskManager *fakedisk.FakeDiskManager
dirProvider boshdirs.DirectoriesProvider
platform Platform
cdutil *fakecd.FakeCdUtil
compressor boshcmd.Compressor
copier boshcmd.Copier
vitalsService boshvitals.Service
logger boshlog.Logger
)
BeforeEach(func() {
collector = &fakestats.FakeStatsCollector{}
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
diskManager = fakedisk.NewFakeDiskManager()
dirProvider = boshdirs.NewDirectoriesProvider("/fake-dir")
cdutil = fakecd.NewFakeCdUtil()
compressor = boshcmd.NewTarballCompressor(cmdRunner, fs)
copier = boshcmd.NewCpCopier(cmdRunner, fs)
vitalsService = boshvitals.NewService(collector, dirProvider)
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
netManager := boshnet.NewCentosNetManager(fs, cmdRunner, 1*time.Millisecond)
platform = NewLinuxPlatform(
fs,
cmdRunner,
collector,
compressor,
copier,
dirProvider,
vitalsService,
cdutil,
diskManager,
netManager,
1*time.Millisecond,
logger,
)
})
Describe("SetupDhcp", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
DNS: []string{"aa.aa.aa.aa"},
},
}
Context("when dhcp was not previously configured", func() {
It("writes dhcp configuration", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedCentosDHCPConfig))
})
It("restarts network", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
})
Context("when dhcp was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp/dhclient.conf", "fake-other-configuration")
})
It("updates dhcp configuration", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedCentosDHCPConfig))
})
It("restarts network", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
})
Context("when dhcp was previously configured with same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedCentosDHCPConfig)
})
It("keeps dhcp configuration", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedCentosDHCPConfig))
})
It("does not restart network", func() {
err := platform.SetupDhcp(networks)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
})
})
Describe("SetupManualNetworking", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns", "gateway"},
IP: "192.168.195.6",
Netmask: "255.255.255.0",
Gateway: "192.168.195.1",
Mac: "22:00:0a:1f:ac:2a",
DNS: []string{"10.80.130.2", "10.80.130.1"},
},
}
BeforeEach(func() {
fs.WriteFile("/sys/class/net/eth0", []byte{})
fs.WriteFileString("/sys/class/net/eth0/address", "22:00:0a:1f:ac:2a\n")
fs.SetGlob("/sys/class/net/*", []string{"/sys/class/net/eth0"})
})
It("sets up centos expected ifconfig", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedCentosIfcfg))
})
It("sets up centos /etc/resolv.conf", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedCentosResolvConf))
})
It("restarts networking", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0")
fs.GetFileTestStat("/etc/resolv.conf")
time.Sleep(100 * time.Millisecond)
Expect(len(cmdRunner.RunCommands)).To(Equal(7))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
It("runs arping commands", func() {
err := platform.SetupManualNetworking(networks)
Expect(err).ToNot(HaveOccurred())
fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0")
fs.GetFileTestStat("/etc/resolv.conf")
time.Sleep(100 * time.Millisecond)
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
Expect(cmdRunner.RunCommands[6]).To(Equal([]string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"}))
})
})
})
}
enablePath = "/enable-path"
})
JustBeforeEach(func() {
fileBundle = NewFileBundle(installPath, enablePath, fs)
})
Describe("#Install", func() {
It("Installs the bundle at the given path with the correct permissions", func() {
actualFs, path, err := fileBundle.Install()
Expect(err).NotTo(HaveOccurred())
Expect(actualFs).To(Equal(fs))
Expect(path).To(Equal(installPath))
Expect(actualFs.FileExists(installPath)).To(BeTrue())
fileStats := fs.GetFileTestStat(installPath)
Expect(fileStats).ToNot(BeNil())
Expect(fileStats.FileType).To(Equal(fakesys.FakeFileType(fakesys.FakeFileTypeDir)))
Expect(os.FileMode(0755)).To(Equal(fileStats.FileMode))
})
It("Errors when bundle cannot be installed", func() {
fs.MkdirAllError = errors.New("fake-mkdirall-error")
_, _, err := fileBundle.Install()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdirall-error"))
})
})
func init() {
Describe("Testing with Ginkgo", func() {
var (
collector *fakestats.FakeStatsCollector
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
diskManager fakedisk.FakeDiskManager
dirProvider boshdirs.DirectoriesProvider
diskWaitTimeout time.Duration
platform Platform
cdutil *fakecd.FakeCdUtil
compressor boshcmd.Compressor
copier boshcmd.Copier
vitalsService boshvitals.Service
)
BeforeEach(func() {
collector = &fakestats.FakeStatsCollector{}
fs = &fakesys.FakeFileSystem{}
cmdRunner = &fakesys.FakeCmdRunner{}
diskManager = fakedisk.NewFakeDiskManager(cmdRunner)
dirProvider = boshdirs.NewDirectoriesProvider("/fake-dir")
diskWaitTimeout = 1 * time.Millisecond
cdutil = fakecd.NewFakeCdUtil()
compressor = boshcmd.NewTarballCompressor(cmdRunner, fs)
copier = boshcmd.NewCpCopier(cmdRunner, fs)
vitalsService = boshvitals.NewService(collector, dirProvider)
})
JustBeforeEach(func() {
netManager := boshnet.NewUbuntuNetManager(fs, cmdRunner, 1*time.Millisecond)
platform = NewLinuxPlatform(
fs,
cmdRunner,
collector,
compressor,
copier,
dirProvider,
vitalsService,
cdutil,
diskManager,
diskWaitTimeout,
netManager,
)
})
It("ubuntu setup runtime configuration", func() {
err := platform.SetupRuntimeConfiguration()
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"bosh-agent-rc"}, cmdRunner.RunCommands[0])
})
It("ubuntu create user", func() {
expectedUseradd := []string{
"useradd",
"-m",
"-b", "/some/path/to/home",
"-s", "/bin/bash",
"-p", "bar-pwd",
"foo-user",
}
password := "******"
err := platform.CreateUser("foo-user", password, "/some/path/to/home")
assert.NoError(GinkgoT(), err)
basePathStat := fs.GetFileTestStat("/some/path/to/home")
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, basePathStat.FileType)
assert.Equal(GinkgoT(), os.FileMode(0755), basePathStat.FileMode)
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), expectedUseradd, cmdRunner.RunCommands[0])
})
It("ubuntu create user with an empty password", func() {
expectedUseradd := []string{
"useradd",
"-m",
"-b", "/some/path/to/home",
"-s", "/bin/bash",
"foo-user",
}
password := ""
err := platform.CreateUser("foo-user", password, "/some/path/to/home")
assert.NoError(GinkgoT(), err)
basePathStat := fs.GetFileTestStat("/some/path/to/home")
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, basePathStat.FileType)
assert.Equal(GinkgoT(), os.FileMode(0755), basePathStat.FileMode)
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), expectedUseradd, cmdRunner.RunCommands[0])
})
It("ubuntu add user to groups", func() {
err := platform.AddUserToGroups("foo-user", []string{"group1", "group2", "group3"})
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
usermod := []string{"usermod", "-G", "group1,group2,group3", "foo-user"}
assert.Equal(GinkgoT(), usermod, cmdRunner.RunCommands[0])
})
It("ubuntu delete users with prefix and regex", func() {
passwdFile := fmt.Sprintf(`%sfoo:...
%sbar:...
foo:...
bar:...
foobar:...
%sfoobar:...`,
boshsettings.EPHEMERAL_USER_PREFIX, boshsettings.EPHEMERAL_USER_PREFIX, boshsettings.EPHEMERAL_USER_PREFIX,
)
fs.WriteToFile("/etc/passwd", passwdFile)
err := platform.DeleteEphemeralUsersMatching("bar$")
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), 2, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"userdel", "-r", "bosh_bar"}, cmdRunner.RunCommands[0])
assert.Equal(GinkgoT(), []string{"userdel", "-r", "bosh_foobar"}, cmdRunner.RunCommands[1])
})
It("ubuntu setup ssh", func() {
fs.HomeDirHomePath = "/some/home/dir"
platform.SetupSsh("some public key", "vcap")
sshDirPath := "/some/home/dir/.ssh"
sshDirStat := fs.GetFileTestStat(sshDirPath)
assert.Equal(GinkgoT(), fs.HomeDirUsername, "vcap")
assert.NotNil(GinkgoT(), sshDirStat)
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, sshDirStat.FileType)
assert.Equal(GinkgoT(), sshDirStat.FileMode, os.FileMode(0700))
assert.Equal(GinkgoT(), sshDirStat.Username, "vcap")
authKeysStat := fs.GetFileTestStat(filepath.Join(sshDirPath, "authorized_keys"))
assert.NotNil(GinkgoT(), authKeysStat)
assert.Equal(GinkgoT(), authKeysStat.FileType, fakesys.FakeFileTypeFile)
assert.Equal(GinkgoT(), authKeysStat.FileMode, os.FileMode(0600))
assert.Equal(GinkgoT(), authKeysStat.Username, "vcap")
assert.Equal(GinkgoT(), authKeysStat.Content, "some public key")
})
It("ubuntu set user password", func() {
platform.SetUserPassword("my-user", "my-encrypted-password")
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"usermod", "-p", "my-encrypted-password", "my-user"}, cmdRunner.RunCommands[0])
})
It("ubuntu setup hostname", func() {
platform.SetupHostname("foobar.local")
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"hostname", "foobar.local"}, cmdRunner.RunCommands[0])
hostnameFileContent, err := fs.ReadFile("/etc/hostname")
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), "foobar.local", hostnameFileContent)
hostsFileContent, err := fs.ReadFile("/etc/hosts")
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), UBUNTU_EXPECTED_ETC_HOSTS, hostsFileContent)
})
It("ubuntu setup dhcp", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
Dns: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
Dns: []string{"aa.aa.aa.aa"},
},
}
platform.SetupDhcp(networks)
dhcpConfig := fs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
assert.NotNil(GinkgoT(), dhcpConfig)
assert.Equal(GinkgoT(), dhcpConfig.Content, UBUNTU_EXPECTED_DHCP_CONFIG)
assert.Equal(GinkgoT(), len(cmdRunner.RunCommands), 2)
assert.Equal(GinkgoT(), cmdRunner.RunCommands[0], []string{"pkill", "dhclient3"})
assert.Equal(GinkgoT(), cmdRunner.RunCommands[1], []string{"/etc/init.d/networking", "restart"})
})
It("ubuntu setup dhcp with pre existing configuration", func() {
fs.WriteToFile("/etc/dhcp3/dhclient.conf", UBUNTU_EXPECTED_DHCP_CONFIG)
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
Dns: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
Dns: []string{"aa.aa.aa.aa"},
},
}
platform.SetupDhcp(networks)
dhcpConfig := fs.GetFileTestStat("/etc/dhcp3/dhclient.conf")
assert.NotNil(GinkgoT(), dhcpConfig)
assert.Equal(GinkgoT(), dhcpConfig.Content, UBUNTU_EXPECTED_DHCP_CONFIG)
assert.Equal(GinkgoT(), len(cmdRunner.RunCommands), 0)
})
It("ubuntu setup manual networking", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns", "gateway"},
Ip: "192.168.195.6",
Netmask: "255.255.255.0",
Gateway: "192.168.195.1",
Mac: "22:00:0a:1f:ac:2a",
Dns: []string{"10.80.130.2", "10.80.130.1"},
},
}
fs.WriteToFile("/sys/class/net/eth0", "")
fs.WriteToFile("/sys/class/net/eth0/address", "22:00:0a:1f:ac:2a\n")
fs.GlobPaths = []string{"/sys/class/net/eth0"}
platform.SetupManualNetworking(networks)
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
assert.NotNil(GinkgoT(), networkConfig)
assert.Equal(GinkgoT(), networkConfig.Content, UBUNTU_EXPECTED_NETWORK_INTERFACES)
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
assert.NotNil(GinkgoT(), resolvConf)
assert.Equal(GinkgoT(), resolvConf.Content, UBUNTU_EXPECTED_RESOLV_CONF)
time.Sleep(100 * time.Millisecond)
assert.Equal(GinkgoT(), len(cmdRunner.RunCommands), 8)
assert.Equal(GinkgoT(), cmdRunner.RunCommands[0], []string{"service", "network-interface", "stop", "INTERFACE=eth0"})
assert.Equal(GinkgoT(), cmdRunner.RunCommands[1], []string{"service", "network-interface", "start", "INTERFACE=eth0"})
assert.Equal(GinkgoT(), cmdRunner.RunCommands[2], []string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"})
assert.Equal(GinkgoT(), cmdRunner.RunCommands[7], []string{"arping", "-c", "1", "-U", "-I", "eth0", "192.168.195.6"})
})
It("ubuntu setup logrotate", func() {
platform.SetupLogrotate("fake-group-name", "fake-base-path", "fake-size")
logrotateFileContent, err := fs.ReadFile("/etc/logrotate.d/fake-group-name")
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), UBUNTU_EXPECTED_ETC_LOGROTATE, logrotateFileContent)
})
It("ubuntu set time with ntp servers", func() {
platform.SetTimeWithNtpServers([]string{"0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org"})
ntpConfig := fs.GetFileTestStat("/fake-dir/bosh/etc/ntpserver")
assert.Equal(GinkgoT(), "0.north-america.pool.ntp.org 1.north-america.pool.ntp.org", ntpConfig.Content)
assert.Equal(GinkgoT(), fakesys.FakeFileTypeFile, ntpConfig.FileType)
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"ntpdate"}, cmdRunner.RunCommands[0])
})
It("ubuntu set time with ntp servers is noop when no ntp server provided", func() {
platform.SetTimeWithNtpServers([]string{})
assert.Equal(GinkgoT(), 0, len(cmdRunner.RunCommands))
ntpConfig := fs.GetFileTestStat("/fake-dir/bosh/etc/ntpserver")
assert.Nil(GinkgoT(), ntpConfig)
})
It("ubuntu setup ephemeral disk with path", func() {
fakeFormatter := diskManager.FakeFormatter
fakePartitioner := diskManager.FakePartitioner
fakeMounter := diskManager.FakeMounter
fakePartitioner.GetDeviceSizeInMbSizes = map[string]uint64{"/dev/xvda": uint64(1024 * 1024 * 1024)}
fs.WriteToFile("/dev/xvda", "")
err := platform.SetupEphemeralDiskWithPath("/dev/xvda")
assert.NoError(GinkgoT(), err)
dataDir := fs.GetFileTestStat("/fake-dir/data")
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, dataDir.FileType)
assert.Equal(GinkgoT(), os.FileMode(0750), dataDir.FileMode)
assert.Equal(GinkgoT(), "/dev/xvda", fakePartitioner.PartitionDevicePath)
assert.Equal(GinkgoT(), 2, len(fakePartitioner.PartitionPartitions))
swapPartition := fakePartitioner.PartitionPartitions[0]
ext4Partition := fakePartitioner.PartitionPartitions[1]
assert.Equal(GinkgoT(), "swap", swapPartition.Type)
assert.Equal(GinkgoT(), "linux", ext4Partition.Type)
assert.Equal(GinkgoT(), 2, len(fakeFormatter.FormatPartitionPaths))
assert.Equal(GinkgoT(), "/dev/xvda1", fakeFormatter.FormatPartitionPaths[0])
assert.Equal(GinkgoT(), "/dev/xvda2", fakeFormatter.FormatPartitionPaths[1])
assert.Equal(GinkgoT(), 2, len(fakeFormatter.FormatFsTypes))
assert.Equal(GinkgoT(), boshdisk.FileSystemSwap, fakeFormatter.FormatFsTypes[0])
assert.Equal(GinkgoT(), boshdisk.FileSystemExt4, fakeFormatter.FormatFsTypes[1])
assert.Equal(GinkgoT(), 1, len(fakeMounter.MountMountPoints))
assert.Equal(GinkgoT(), "/fake-dir/data", fakeMounter.MountMountPoints[0])
assert.Equal(GinkgoT(), 1, len(fakeMounter.MountPartitionPaths))
assert.Equal(GinkgoT(), "/dev/xvda2", fakeMounter.MountPartitionPaths[0])
assert.Equal(GinkgoT(), 1, len(fakeMounter.SwapOnPartitionPaths))
assert.Equal(GinkgoT(), "/dev/xvda1", fakeMounter.SwapOnPartitionPaths[0])
sysLogStats := fs.GetFileTestStat("/fake-dir/data/sys/log")
assert.NotNil(GinkgoT(), sysLogStats)
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, sysLogStats.FileType)
assert.Equal(GinkgoT(), os.FileMode(0750), sysLogStats.FileMode)
assert.Equal(GinkgoT(), []string{"chown", "root:vcap", "/fake-dir/data/sys"}, cmdRunner.RunCommands[0])
assert.Equal(GinkgoT(), []string{"chown", "root:vcap", "/fake-dir/data/sys/log"}, cmdRunner.RunCommands[1])
sysRunStats := fs.GetFileTestStat("/fake-dir/data/sys/run")
assert.NotNil(GinkgoT(), sysRunStats)
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, sysRunStats.FileType)
assert.Equal(GinkgoT(), os.FileMode(0750), sysRunStats.FileMode)
assert.Equal(GinkgoT(), []string{"chown", "root:vcap", "/fake-dir/data/sys/run"}, cmdRunner.RunCommands[2])
})
It("setup tmp dir", func() {
err := platform.SetupTmpDir()
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), 2, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"chown", "root:vcap", "/tmp"}, cmdRunner.RunCommands[0])
assert.Equal(GinkgoT(), []string{"chmod", "0770", "/tmp"}, cmdRunner.RunCommands[1])
})
It("ubuntu mount persistent disk", func() {
fakeFormatter := diskManager.FakeFormatter
fakePartitioner := diskManager.FakePartitioner
fakeMounter := diskManager.FakeMounter
fs.WriteToFile("/dev/vdf", "")
err := platform.MountPersistentDisk("/dev/sdf", "/mnt/point")
assert.NoError(GinkgoT(), err)
mountPoint := fs.GetFileTestStat("/mnt/point")
assert.Equal(GinkgoT(), fakesys.FakeFileTypeDir, mountPoint.FileType)
assert.Equal(GinkgoT(), os.FileMode(0700), mountPoint.FileMode)
partition := fakePartitioner.PartitionPartitions[0]
assert.Equal(GinkgoT(), "/dev/vdf", fakePartitioner.PartitionDevicePath)
assert.Equal(GinkgoT(), 1, len(fakePartitioner.PartitionPartitions))
assert.Equal(GinkgoT(), "linux", partition.Type)
assert.Equal(GinkgoT(), 1, len(fakeFormatter.FormatPartitionPaths))
assert.Equal(GinkgoT(), "/dev/vdf1", fakeFormatter.FormatPartitionPaths[0])
assert.Equal(GinkgoT(), 1, len(fakeFormatter.FormatFsTypes))
assert.Equal(GinkgoT(), boshdisk.FileSystemExt4, fakeFormatter.FormatFsTypes[0])
assert.Equal(GinkgoT(), 1, len(fakeMounter.MountMountPoints))
assert.Equal(GinkgoT(), "/mnt/point", fakeMounter.MountMountPoints[0])
assert.Equal(GinkgoT(), 1, len(fakeMounter.MountPartitionPaths))
assert.Equal(GinkgoT(), "/dev/vdf1", fakeMounter.MountPartitionPaths[0])
})
Context("when not mounted", func() {
It("does not unmount persistent disk", func() {
fakeMounter := diskManager.FakeMounter
fakeMounter.UnmountDidUnmount = false
fs.WriteToFile("/dev/vdx", "")
didUnmount, err := platform.UnmountPersistentDisk("/dev/sdx")
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), didUnmount, false)
assert.Equal(GinkgoT(), "/dev/vdx1", fakeMounter.UnmountPartitionPath)
})
})
Context("when already mounted", func() {
It("unmounts persistent disk", func() {
fakeMounter := diskManager.FakeMounter
fakeMounter.UnmountDidUnmount = true
fs.WriteToFile("/dev/vdx", "")
didUnmount, err := platform.UnmountPersistentDisk("/dev/sdx")
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), didUnmount, true)
assert.Equal(GinkgoT(), "/dev/vdx1", fakeMounter.UnmountPartitionPath)
})
})
It("ubuntu normalize disk path", func() {
fs.WriteToFile("/dev/xvda", "")
path, found := platform.NormalizeDiskPath("/dev/sda")
assert.Equal(GinkgoT(), path, "/dev/xvda")
assert.True(GinkgoT(), found)
fs.RemoveAll("/dev/xvda")
fs.WriteToFile("/dev/vda", "")
path, found = platform.NormalizeDiskPath("/dev/sda")
assert.Equal(GinkgoT(), path, "/dev/vda")
assert.True(GinkgoT(), found)
fs.RemoveAll("/dev/vda")
fs.WriteToFile("/dev/sda", "")
path, found = platform.NormalizeDiskPath("/dev/sda")
assert.Equal(GinkgoT(), path, "/dev/sda")
assert.True(GinkgoT(), found)
})
Describe("GetFileContentsFromCDROM", func() {
It("delegates to cdutil", func() {
cdutil.GetFileContentsContents = []byte("fake-contents")
filename := "fake-env"
contents, err := platform.GetFileContentsFromCDROM(filename)
Expect(err).NotTo(HaveOccurred())
Expect(cdutil.GetFileContentsFilename).To(Equal(filename))
Expect(contents).To(Equal(cdutil.GetFileContentsContents))
})
})
It("ubuntu get real device path with multiple possible devices", func() {
fs.WriteToFile("/dev/xvda", "")
fs.WriteToFile("/dev/vda", "")
realPath, found := platform.NormalizeDiskPath("/dev/sda")
assert.True(GinkgoT(), found)
assert.Equal(GinkgoT(), "/dev/xvda", realPath)
})
Context("within timeout", func() {
BeforeEach(func() {
diskWaitTimeout = 1 * time.Second
})
It("ubuntu get real device path with delay", func() {
time.AfterFunc(time.Second, func() {
fs.WriteToFile("/dev/xvda", "")
})
realPath, found := platform.NormalizeDiskPath("/dev/sda")
assert.True(GinkgoT(), found)
assert.Equal(GinkgoT(), "/dev/xvda", realPath)
})
})
It("ubuntu get real device path with delay beyond timeout", func() {
time.AfterFunc(2*time.Second, func() {
fs.WriteToFile("/dev/xvda", "")
})
_, found := platform.NormalizeDiskPath("/dev/sda")
assert.False(GinkgoT(), found)
})
It("ubuntu calculate ephemeral disk partition sizes when disk is bigger than twice the memory", func() {
totalMemInMb := uint64(1024)
diskSizeInMb := totalMemInMb*2 + 64
expectedSwap := totalMemInMb
collector.MemStats.Total = totalMemInMb * uint64(1024*1024)
fakePartitioner := diskManager.FakePartitioner
fakePartitioner.GetDeviceSizeInMbSizes = map[string]uint64{
"/dev/hda": diskSizeInMb,
}
err := platform.SetupEphemeralDiskWithPath("/dev/hda")
assert.NoError(GinkgoT(), err)
expectedPartitions := []boshdisk.Partition{
{SizeInMb: expectedSwap, Type: boshdisk.PartitionTypeSwap},
{SizeInMb: diskSizeInMb - expectedSwap, Type: boshdisk.PartitionTypeLinux},
}
assert.Equal(GinkgoT(), fakePartitioner.PartitionPartitions, expectedPartitions)
})
It("ubuntu calculate ephemeral disk partition sizes when disk twice the memory or smaller", func() {
totalMemInMb := uint64(1024)
diskSizeInMb := totalMemInMb*2 - 64
expectedSwap := diskSizeInMb / 2
collector.MemStats.Total = totalMemInMb * uint64(1024*1024)
fakePartitioner := diskManager.FakePartitioner
fakePartitioner.GetDeviceSizeInMbSizes = map[string]uint64{
"/dev/hda": diskSizeInMb,
}
err := platform.SetupEphemeralDiskWithPath("/dev/hda")
assert.NoError(GinkgoT(), err)
expectedPartitions := []boshdisk.Partition{
{SizeInMb: expectedSwap, Type: boshdisk.PartitionTypeSwap},
{SizeInMb: diskSizeInMb - expectedSwap, Type: boshdisk.PartitionTypeLinux},
}
assert.Equal(GinkgoT(), fakePartitioner.PartitionPartitions, expectedPartitions)
})
It("ubuntu migrate persistent disk", func() {
fakeMounter := diskManager.FakeMounter
platform.MigratePersistentDisk("/from/path", "/to/path")
assert.Equal(GinkgoT(), fakeMounter.RemountAsReadonlyPath, "/from/path")
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"sh", "-c", "(tar -C /from/path -cf - .) | (tar -C /to/path -xpf -)"}, cmdRunner.RunCommands[0])
assert.Equal(GinkgoT(), fakeMounter.UnmountPartitionPath, "/from/path")
assert.Equal(GinkgoT(), fakeMounter.RemountFromMountPoint, "/to/path")
assert.Equal(GinkgoT(), fakeMounter.RemountToMountPoint, "/from/path")
})
It("ubuntu is device path mounted", func() {
fs.WriteToFile("/dev/xvda", "")
fakeMounter := diskManager.FakeMounter
fakeMounter.IsMountedResult = true
result, err := platform.IsDevicePathMounted("/dev/sda")
assert.NoError(GinkgoT(), err)
assert.True(GinkgoT(), result)
assert.Equal(GinkgoT(), fakeMounter.IsMountedDevicePathOrMountPoint, "/dev/xvda1")
})
It("ubuntu start monit", func() {
err := platform.StartMonit()
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), 1, len(cmdRunner.RunCommands))
assert.Equal(GinkgoT(), []string{"sv", "up", "monit"}, cmdRunner.RunCommands[0])
})
It("ubuntu setup monit user if file does not exist", func() {
err := platform.SetupMonitUser()
assert.NoError(GinkgoT(), err)
monitUserFileStats := fs.GetFileTestStat("/fake-dir/monit/monit.user")
assert.NotNil(GinkgoT(), monitUserFileStats)
assert.Equal(GinkgoT(), "vcap:random-password", monitUserFileStats.Content)
})
It("ubuntu setup monit user if file does exist", func() {
fs.WriteToFile("/fake-dir/monit/monit.user", "vcap:other-random-password")
err := platform.SetupMonitUser()
assert.NoError(GinkgoT(), err)
monitUserFileStats := fs.GetFileTestStat("/fake-dir/monit/monit.user")
assert.NotNil(GinkgoT(), monitUserFileStats)
assert.Equal(GinkgoT(), "vcap:other-random-password", monitUserFileStats.Content)
})
It("ubuntu get monit credentials reads monit file from disk", func() {
fs.WriteToFile("/fake-dir/monit/monit.user", "fake-user:fake-random-password")
username, password, err := platform.GetMonitCredentials()
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), "fake-user", username)
assert.Equal(GinkgoT(), "fake-random-password", password)
})
It("ubuntu get monit credentials errs when invalid file format", func() {
fs.WriteToFile("/fake-dir/monit/monit.user", "fake-user")
_, _, err := platform.GetMonitCredentials()
assert.Error(GinkgoT(), err)
})
It("ubuntu get monit credentials leaves colons in password intact", func() {
fs.WriteToFile("/fake-dir/monit/monit.user", "fake-user:fake:random:password")
username, password, err := platform.GetMonitCredentials()
assert.NoError(GinkgoT(), err)
assert.Equal(GinkgoT(), "fake-user", username)
assert.Equal(GinkgoT(), "fake:random:password", password)
})
})
}
})
Describe("Get", func() {
It("local get", func() {
fs.WriteFileString(fakeBlobstorePath+"/fake-blob-id", "fake contents")
tempFile, err := fs.TempFile("bosh-blobstore-local-TestLocalGet")
Expect(err).ToNot(HaveOccurred())
fs.ReturnTempFile = tempFile
defer fs.RemoveAll(tempFile.Name())
_, err = blobstore.Get("fake-blob-id", "")
Expect(err).ToNot(HaveOccurred())
fileStats := fs.GetFileTestStat(tempFile.Name())
Expect(fileStats).ToNot(BeNil())
Expect("fake contents").To(Equal(fileStats.StringContents()))
})
It("local get errs when temp file create errs", func() {
fs.TempFileError = errors.New("fake-error")
fileName, err := blobstore.Get("fake-blob-id", "")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-error"))
Expect(fileName).To(BeEmpty())
})
It("local get errs when copy file errs", func() {
func init() {
Describe("concreteV1Service", func() {
var (
fs *fakesys.FakeFileSystem
specPath = "/spec.json"
service V1Service
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
service = NewConcreteV1Service(fs, 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("PopulateDynamicNetworks", func() {
Context("when there 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.PopulateDynamicNetworks(unresolvedSpec, boshsettings.Settings{})
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 are dynamic networks", 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",
},
},
"fake-net3": NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": "fake-net3-ip",
"netmask": "fake-net3-netmask",
"gateway": "fake-net3-gateway",
},
},
},
}
Context("when associated network is in settings", func() {
settings := boshsettings.Settings{
Networks: boshsettings.Networks{
"fake-net1": boshsettings.Network{
IP: "fake-resolved1-ip",
Netmask: "fake-resolved1-netmask",
Gateway: "fake-resolved1-gateway",
},
"fake-net2": boshsettings.Network{
IP: "fake-resolved2-ip",
Netmask: "fake-resolved2-netmask",
Gateway: "fake-resolved2-gateway",
},
"fake-net3": boshsettings.Network{
IP: "fake-resolved3-ip",
Netmask: "fake-resolved3-netmask",
Gateway: "fake-resolved3-gateway",
},
},
}
It("returns spec with modified dynamic networks and keeping everything else the same", func() {
spec, err := service.PopulateDynamicNetworks(unresolvedSpec, settings)
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{
"fake-net1": NetworkSpec{
Fields: map[string]interface{}{ // ip info not replaced
"ip": "fake-net1-ip",
"netmask": "fake-net1-netmask",
"gateway": "fake-net1-gateway",
},
},
"fake-net2": NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": "fake-resolved2-ip",
"netmask": "fake-resolved2-netmask",
"gateway": "fake-resolved2-gateway",
},
},
"fake-net3": NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": "fake-resolved3-ip",
"netmask": "fake-resolved3-netmask",
"gateway": "fake-resolved3-gateway",
},
},
},
}))
})
})
Context("when associated network cannot be found in settings", func() {
It("returns error", func() {
spec, err := service.PopulateDynamicNetworks(unresolvedSpec, boshsettings.Settings{})
Expect(err).To(Equal(errors.New("Network fake-net2 is not found in settings")))
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
})
})
})
}
func init() {
Describe("concreteV1Service", func() {
var (
fs *fakesys.FakeFileSystem
specPath string
service V1Service
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
specPath = "/spec.json"
service = NewConcreteV1Service(fs, 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"))
})
})
})
}
Expect(addressBroadcaster.BroadcastMACAddressesAddresses).To(Equal(
[]boship.InterfaceAddress{
// Resolve IP address because IP may not be known
boship.NewResolvingInterfaceAddress("eth0", ipResolver),
},
))
})
}
ItUpdatesDhcpConfig := func() {
It("writes dhcp configuration", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat(dhcpConfPath)
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedDHCPConfig))
})
It("writes out DNS servers in order that was provided by the network because *single* DHCP prepend command is used", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat(dhcpConfPath)
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(ContainSubstring(`
prepend domain-name-servers xx.xx.xx.xx, yy.yy.yy.yy, zz.zz.zz.zz;
`))
})
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(3))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"ifdown", "-a", "--exclude=lo"}))
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"ifup", "-a", "--exclude=lo"}))
})
})
}
ItUpdatesDhcpConfig := func(dhcpConfPath string) {
It("writes dhcp configuration", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat(dhcpConfPath)
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedDHCPConfig))
})
It("writes out DNS servers in order that was provided by the network because *single* DHCP prepend command is used", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat(dhcpConfPath)
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(ContainSubstring(`
prepend domain-name-servers xx.xx.xx.xx, yy.yy.yy.yy, zz.zz.zz.zz;
`))
})
func init() {
const expectedCentosDHCPConfig = `# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers xx.xx.xx.xx;
prepend domain-name-servers yy.yy.yy.yy;
prepend domain-name-servers zz.zz.zz.zz;
`
const expectedCentosIfcfg = `DEVICE=eth0
BOOTPROTO=static
IPADDR=192.168.195.6
NETMASK=255.255.255.0
BROADCAST=192.168.195.255
GATEWAY=192.168.195.1
ONBOOT=yes`
Describe("centos", func() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
defaultNetworkResolver *fakenet.FakeDefaultNetworkResolver
ipResolver *fakeip.FakeIPResolver
addressBroadcaster *fakearp.FakeAddressBroadcaster
netManager NetManager
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
defaultNetworkResolver = &fakenet.FakeDefaultNetworkResolver{}
ipResolver = &fakeip.FakeIPResolver{}
addressBroadcaster = &fakearp.FakeAddressBroadcaster{}
logger := boshlog.NewLogger(boshlog.LevelNone)
netManager = NewCentosNetManager(
fs,
cmdRunner,
defaultNetworkResolver,
ipResolver,
addressBroadcaster,
logger,
)
})
Describe("SetupDhcp", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns"},
DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy", "zz.zz.zz.zz"},
},
"vip": boshsettings.Network{
Default: []string{},
DNS: []string{"aa.aa.aa.aa"},
},
}
ItBroadcastsMACAddresses := func() {
It("starts broadcasting the MAC addresses", func() {
errCh := make(chan error)
err := netManager.SetupDhcp(networks, errCh)
Expect(err).ToNot(HaveOccurred())
<-errCh // wait for all arpings
Expect(addressBroadcaster.BroadcastMACAddressesAddresses).To(Equal(
[]boship.InterfaceAddress{
// Resolve IP address because IP may not be known
boship.NewResolvingInterfaceAddress("eth0", ipResolver),
},
))
})
}
Context("when dhcp was not previously configured", func() {
It("writes dhcp configuration", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedCentosDHCPConfig))
})
It("restarts network", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
ItBroadcastsMACAddresses()
})
Context("when dhcp was previously configured with different configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp/dhclient.conf", "fake-other-configuration")
})
It("updates dhcp configuration", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedCentosDHCPConfig))
})
It("restarts network", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
ItBroadcastsMACAddresses()
})
Context("when dhcp was previously configured with same configuration", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedCentosDHCPConfig)
})
It("keeps dhcp configuration", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedCentosDHCPConfig))
})
It("does not restart network", func() {
err := netManager.SetupDhcp(networks, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
ItBroadcastsMACAddresses()
})
})
Describe("SetupManualNetworking", func() {
var errCh chan error
BeforeEach(func() {
errCh = make(chan error)
})
BeforeEach(func() {
fs.WriteFileString("/sys/class/net/eth0/address", "22:00:0a:1f:ac:2a\n")
fs.SetGlob("/sys/class/net/*", []string{"/sys/class/net/eth0"})
})
networks := boshsettings.Networks{
"bosh": boshsettings.Network{
Default: []string{"dns", "gateway"},
IP: "192.168.195.6",
Netmask: "255.255.255.0",
Gateway: "192.168.195.1",
Mac: "22:00:0a:1f:ac:2a",
DNS: []string{"10.80.130.1", "10.80.130.2"},
},
}
It("sets up centos expected ifconfig", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedCentosIfcfg))
})
It("sets up centos /etc/resolv.conf", func() {
err := netManager.SetupManualNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
resolvConf := fs.GetFileTestStat("/etc/resolv.conf")
Expect(resolvConf).ToNot(BeNil())
Expect(resolvConf.StringContents()).To(Equal(expectedCentosResolvConf))
})
It("restarts networking", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0")
fs.GetFileTestStat("/etc/resolv.conf")
<-errCh // wait for all arpings
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
It("starts broadcasting the MAC addresses", func() {
err := netManager.SetupManualNetworking(networks, errCh)
Expect(err).ToNot(HaveOccurred())
fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0")
fs.GetFileTestStat("/etc/resolv.conf")
<-errCh // wait for all arpings
Expect(addressBroadcaster.BroadcastMACAddressesAddresses).To(Equal([]boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("eth0", "192.168.195.6"),
}))
})
})
})
}