runner *fakesys.FakeCmdRunner
searcher RoutesSearcher
)
BeforeEach(func() {
runner = fakesys.NewFakeCmdRunner()
searcher = NewCmdRoutesSearcher(runner)
})
Describe("SearchRoutes", func() {
Context("when running command succeeds", func() {
It("returns parsed routes information", func() {
runner.AddCmdResult("route -n", fakesys.FakeCmdResult{
Stdout: `Kernel IP routing table
Destination Gateway Genmask Flags Metric Ref Use Iface
172.16.79.0 0.0.0.0 255.255.255.0 U 0 0 0 eth0
169.254.0.0 0.0.0.0 255.255.0.0 U 1002 0 0 eth0
0.0.0.0 172.16.79.1 0.0.0.0 UG 0 0 0 eth0
`,
})
routes, err := searcher.SearchRoutes()
Expect(err).ToNot(HaveOccurred())
Expect(routes).To(Equal([]Route{
Route{Destination: "172.16.79.0", Gateway: "0.0.0.0", InterfaceName: "eth0"},
Route{Destination: "169.254.0.0", Gateway: "0.0.0.0", InterfaceName: "eth0"},
Route{Destination: "0.0.0.0", Gateway: "172.16.79.1", InterfaceName: "eth0"},
}))
})
It("ignores empty lines", func() {
runner.AddCmdResult("route -n", fakesys.FakeCmdResult{
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"}))
})
})
})
})
}
Expect(err).To(HaveOccurred())
})
})
})
Describe("Mount", func() {
var (
mountResults fakesys.FakeCmdResult
)
BeforeEach(func() {
mountResults = fakesys.FakeCmdResult{}
})
JustBeforeEach(func() {
runner.AddCmdResult("mount /dev/sr0 /fake/settings/path", mountResults)
})
It("runs the mount command", func() {
err := cd.Mount("/fake/settings/path")
Expect(err).NotTo(HaveOccurred())
Expect(runner.RunCommands).To(Equal([][]string{{"mount", "/dev/sr0", "/fake/settings/path"}}))
})
Context("when mount command errors", func() {
BeforeEach(func() {
mountResults = fakesys.FakeCmdResult{
Stderr: "failed to mount",
Error: errors.New("exit 1"),
}
})
Expect(actualCmd.WorkingDir).To(Equal("/fake-working-dir"))
})
It("returns an error if it fails to save output", func() {
fs.OpenFileErr = errors.New("fake-open-file-error")
_, err := runner.RunCommand("fake-log-dir-name", "fake-log-file-name", cmd)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-open-file-error"))
})
Context("when command succeeds", func() {
BeforeEach(func() {
cmdRunner.AddCmdResult("fake-cmd fake-args", fakesys.FakeCmdResult{
Stdout: "fake-stdout",
Stderr: "fake-stderr",
ExitStatus: 0,
})
})
It("returns correct result", func() {
expectedResult := &CmdResult{
IsStdoutTruncated: false,
Stdout: []byte("fake-stdout"),
Stderr: []byte("fake-stderr"),
ExitStatus: 0,
}
result, err := runner.RunCommand("fake-log-dir-name", "fake-log-file-name", cmd)
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal(expectedResult))
Expect(runner.RunCommands[1]).To(Equal([]string{"mount", "/dev/baz", "/mnt/bar"}))
})
It("returns error and does not try to unmount/mount anything when searching mounts fails", func() {
mountsSearcher.SearchMountsErr = errors.New("fake-search-mounts-err")
err := mounter.Remount("/mnt/foo", "/mnt/bar")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-search-mounts-err"))
Expect(0).To(Equal(len(runner.RunCommands)))
})
})
Describe("SwapOn", func() {
It("linux swap on", func() {
runner.AddCmdResult("swapon -s", fakesys.FakeCmdResult{Stdout: "Filename Type Size Used Priority\n"})
mounter.SwapOn("/dev/swap")
Expect(2).To(Equal(len(runner.RunCommands)))
Expect(runner.RunCommands[1]).To(Equal([]string{"swapon", "/dev/swap"}))
})
It("linux swap on when already on", func() {
runner.AddCmdResult("swapon -s", fakesys.FakeCmdResult{Stdout: swaponUsageOutput})
mounter.SwapOn("/dev/swap")
Expect(1).To(Equal(len(runner.RunCommands)))
Expect(runner.RunCommands[0]).To(Equal([]string{"swapon", "-s"}))
})
It("linux swap on when already on other device", func() {
Expect(fileName).To(BeEmpty())
})
It("external get errs when external cli errs", func() {
tempFile, err := fs.TempFile("bosh-blobstore-external-TestGetErrsWhenExternalCliErrs")
Expect(err).ToNot(HaveOccurred())
fs.ReturnTempFile = tempFile
defer fs.RemoveAll(tempFile.Name())
expectedCmd := []string{
"bosh-blobstore-fake-provider", "-c", configPath, "get",
"fake-blob-id",
tempFile.Name(),
}
runner.AddCmdResult(strings.Join(expectedCmd, " "), fakesys.FakeCmdResult{Error: 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())
Expect(fs.FileExists(tempFile.Name())).To(BeFalse())
})
})
Describe("CleanUp", func() {
It("external clean up", func() {
file, err := fs.TempFile("bosh-blobstore-external-TestCleanUp")
Expect(err).ToNot(HaveOccurred())
fileName := file.Name()
var (
runner *fakesys.FakeCmdRunner
searcher MountsSearcher
)
BeforeEach(func() {
runner = fakesys.NewFakeCmdRunner()
searcher = NewCmdMountsSearcher(runner)
})
Describe("SearchMounts", func() {
Context("when running command succeeds", func() {
It("returns parsed mount information", func() {
runner.AddCmdResult("mount", fakesys.FakeCmdResult{
Stdout: `devpts on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
tmpfs on /run type tmpfs (rw,noexec,nosuid,size=10%,mode=0755)
/dev/sda1 on /boot type ext2 (rw)
none on /tmp/warden/cgroup type tmpfs (rw)`,
})
mounts, err := searcher.SearchMounts()
Expect(err).ToNot(HaveOccurred())
Expect(mounts).To(Equal([]Mount{
Mount{PartitionPath: "devpts", MountPoint: "/dev/pts"},
Mount{PartitionPath: "tmpfs", MountPoint: "/run"},
Mount{PartitionPath: "/dev/sda1", MountPoint: "/boot"},
Mount{PartitionPath: "none", MountPoint: "/tmp/warden/cgroup"},
}))
})
It("ignores empty lines", func() {
runner.AddCmdResult("mount", fakesys.FakeCmdResult{
Describe("Run", func() {
var (
params fakeDrainParams
)
BeforeEach(func() {
params = fakeDrainParams{
jobChange: "job_shutdown",
hashChange: "hash_unchanged",
updatedPackages: []string{"foo", "bar"},
}
})
It("runs drain script", func() {
commandResult := fakesys.FakeCmdResult{Stdout: "1"}
runner.AddCmdResult("/fake/script job_shutdown hash_unchanged foo bar", commandResult)
_, err := drainScript.Run(params)
Expect(err).ToNot(HaveOccurred())
expectedCmd := boshsys.Command{
Name: "/fake/script",
Args: []string{"job_shutdown", "hash_unchanged", "foo", "bar"},
Env: map[string]string{
"PATH": "/usr/sbin:/usr/bin:/sbin:/bin",
},
}
Expect(len(runner.RunComplexCommands)).To(Equal(1))
Expect(runner.RunComplexCommands[0]).To(Equal(expectedCmd))
})
"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, nil)
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() {
