func newRealClient(url string) Client {
logger := boshlog.NewLogger(boshlog.LevelNone)
return NewHTTPClient(
url,
"fake-user",
"fake-pass",
http.DefaultClient,
http.DefaultClient,
logger,
)
}
func newFakeClient(shortClient, longClient *fakehttp.FakeClient) Client {
logger := boshlog.NewLogger(boshlog.LevelNone)
return NewHTTPClient(
"agent.example.com",
"fake-user",
"fake-pass",
shortClient,
longClient,
logger,
)
}
func describeDummyPlatform() {
var (
platform Platform
collector boshstats.Collector
fs boshsys.FileSystem
cmdRunner boshsys.CmdRunner
dirProvider boshdirs.Provider
devicePathResolver boshdpresolv.DevicePathResolver
logger boshlog.Logger
)
BeforeEach(func() {
collector = &fakestats.FakeCollector{}
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
dirProvider = boshdirs.NewProvider("/fake-dir")
devicePathResolver = fakedpresolv.NewFakeDevicePathResolver()
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
platform = NewDummyPlatform(
collector,
fs,
cmdRunner,
dirProvider,
devicePathResolver,
logger,
)
})
Describe("GetDefaultNetwork", func() {
It("returns the contents of dummy-defaults-network-settings.json since that's what the dummy cpi writes", func() {
settingsFilePath := "/fake-dir/bosh/dummy-default-network-settings.json"
fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`)
network, err := platform.GetDefaultNetwork()
Expect(err).NotTo(HaveOccurred())
Expect(network.IP).To(Equal("1.2.3.4"))
})
})
Describe("GetCertManager", func() {
It("returs a dummy cert manager", func() {
certManager := platform.GetCertManager()
Expect(certManager.UpdateCertificates("")).Should(BeNil())
})
})
}
func TestIntegration(t *testing.T) {
RegisterFailHandler(Fail)
BeforeSuite(func() {
logger := boshlog.NewLogger(boshlog.LevelDebug)
cmdRunner := boshsys.NewExecCmdRunner(logger)
testEnvironment = NewTestEnvironment(cmdRunner)
// Required for reverse-compatibility with older bosh-lite
// (remove once a new warden stemcell is built).
err := testEnvironment.ConfigureAgentForGenericInfrastructure()
Expect(err).ToNot(HaveOccurred())
})
RunSpecs(t, "Integration Suite")
}
func init() {
Describe("ListDisk", func() {
var (
settingsService *fakesettings.FakeSettingsService
platform *fakeplatform.FakePlatform
logger boshlog.Logger
action ListDiskAction
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{}
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
action = NewListDisk(settingsService, platform, logger)
})
It("list disk should be synchronous", func() {
Expect(action.IsAsynchronous()).To(BeFalse())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
It("list disk run", func() {
platform.MountedDevicePaths = []string{"/dev/sdb", "/dev/sdc"}
settingsService.Settings.Disks = boshsettings.Disks{
Persistent: map[string]interface{}{
"volume-1": "/dev/sda",
"volume-2": "/dev/sdb",
"volume-3": "/dev/sdc",
},
}
value, err := action.Run()
Expect(err).ToNot(HaveOccurred())
values, ok := value.([]string)
Expect(ok).To(BeTrue())
Expect(values).To(ContainElement("volume-2"))
Expect(values).To(ContainElement("volume-3"))
Expect(len(values)).To(Equal(2))
})
})
}
func main() {
logger := boshlog.NewLogger(boshlog.LevelDebug)
defer logger.HandlePanic("Main")
logger.Debug(mainLogTag, "Starting agent")
app := boshapp.New(logger)
err := app.Setup(os.Args)
if err != nil {
logger.Error(mainLogTag, "App setup %s", err.Error())
os.Exit(1)
}
err = app.Run()
if err != nil {
logger.Error(mainLogTag, "App run %s", err.Error())
os.Exit(1)
}
}
func main() {
logger := newSignalableLogger(boshlog.NewLogger(boshlog.LevelDebug))
defer logger.HandlePanic("Main")
logger.Debug(mainLogTag, "Starting agent")
fs := boshsys.NewOsFileSystem(logger)
app := boshapp.New(logger, fs)
err := app.Setup(os.Args)
if err != nil {
logger.Error(mainLogTag, "App setup %s", err.Error())
os.Exit(1)
}
err = app.Run()
if err != nil {
logger.Error(mainLogTag, "App run %s", err.Error())
os.Exit(1)
}
}
func main() {
user := flag.String("user", "user", "User")
password := flag.String("password", "password", "Password")
host := flag.String("host", "127.0.0.1", "Host")
port := flag.Int("port", 8080, "Port")
instance := flag.String("instance", "", "Instance ID")
settings := flag.String("settings", "", "Instance Settings")
flag.Parse()
logger := boshlog.NewLogger(boshlog.LevelDebug)
serverManager := bmregistry.NewServerManager(logger)
_, err := serverManager.Start(*user, *password, *host, *port)
if err != nil {
panic("Error starting registry")
}
if *instance != "" && *settings != "" {
request, err := http.NewRequest(
"PUT",
fmt.Sprintf("http://%s:%s@%s:%d/instances/%s/settings", *user, *password, *host, *port, *instance),
strings.NewReader(*settings),
)
if err != nil {
panic("Couldn't create request")
}
client := http.DefaultClient
_, err = client.Do(request)
if err != nil {
panic(fmt.Sprintf("Error sending request: %s", err.Error()))
}
}
select {}
}
func describeUbuntuNetManager() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
ipResolver *fakeip.FakeResolver
addressBroadcaster *fakearp.FakeAddressBroadcaster
netManager UbuntuNetManager
interfaceConfigurationCreator InterfaceConfigurationCreator
)
writeNetworkDevice := func(iface string, macAddress string, isPhysical bool) string {
interfacePath := fmt.Sprintf("/sys/class/net/%s", iface)
fs.WriteFile(interfacePath, []byte{})
if isPhysical {
fs.WriteFile(fmt.Sprintf("/sys/class/net/%s/device", iface), []byte{})
}
fs.WriteFileString(fmt.Sprintf("/sys/class/net/%s/address", iface), fmt.Sprintf("%s\n", macAddress))
return interfacePath
}
stubInterfacesWithVirtual := func(physicalInterfaces map[string]boshsettings.Network, virtualInterfaces []string) {
interfacePaths := []string{}
for iface, networkSettings := range physicalInterfaces {
interfacePaths = append(interfacePaths, writeNetworkDevice(iface, networkSettings.Mac, true))
}
for _, iface := range virtualInterfaces {
interfacePaths = append(interfacePaths, writeNetworkDevice(iface, "virtual", false))
}
fs.SetGlob("/sys/class/net/*", interfacePaths)
}
stubInterfaces := func(physicalInterfaces map[string]boshsettings.Network) {
stubInterfacesWithVirtual(physicalInterfaces, nil)
}
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
ipResolver = &fakeip.FakeResolver{}
logger := boshlog.NewLogger(boshlog.LevelNone)
interfaceConfigurationCreator = NewInterfaceConfigurationCreator(logger)
addressBroadcaster = &fakearp.FakeAddressBroadcaster{}
netManager = NewUbuntuNetManager(
fs,
cmdRunner,
ipResolver,
interfaceConfigurationCreator,
addressBroadcaster,
logger,
).(UbuntuNetManager)
})
Describe("ComputeNetworkConfig", func() {
Context("when there is one manual network and neither is marked as default for DNS", func() {
It("should use the manual network for DNS", func() {
networks := boshsettings.Networks{
"manual": factory.Network{DNS: &[]string{"8.8.8.8"}}.Build(),
}
stubInterfaces(networks)
_, _, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(dnsServers).To(Equal([]string{"8.8.8.8"}))
})
})
Context("when there is a vip network and a manual network and neither is marked as default for DNS", func() {
It("should use the manual network for DNS", func() {
networks := boshsettings.Networks{
"vip": boshsettings.Network{Type: "vip"},
"manual": factory.Network{Type: "manual", DNS: &[]string{"8.8.8.8"}}.Build(),
}
stubInterfaces(networks)
_, _, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(dnsServers).To(Equal([]string{"8.8.8.8"}))
})
})
Context("when there is a vip network and a manual network and the manual network is marked as default for DNS", func() {
It("should use the manual network for DNS", func() {
networks := boshsettings.Networks{
"vip": boshsettings.Network{Type: "vip"},
"manual": factory.Network{Type: "manual", DNS: &[]string{"8.8.8.8"}, Default: []string{"dns"}}.Build(),
}
stubInterfaces(networks)
_, _, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(dnsServers).To(Equal([]string{"8.8.8.8"}))
})
})
Context("when specified more than one DNS", func() {
It("extracts all DNS servers from the network configured as default DNS", func() {
networks := boshsettings.Networks{
"default": factory.Network{
IP: "10.10.0.32",
Netmask: "255.255.255.0",
Mac: "aa::bb::cc",
Default: []string{"dns", "gateway"},
DNS: &[]string{"54.209.78.6", "127.0.0.5"},
Gateway: "10.10.0.1",
}.Build(),
}
stubInterfaces(networks)
staticInterfaceConfigurations, dhcpInterfaceConfigurations, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(staticInterfaceConfigurations).To(Equal([]StaticInterfaceConfiguration{
{
Name: "default",
Address: "10.10.0.32",
Netmask: "255.255.255.0",
Network: "10.10.0.0",
Broadcast: "10.10.0.255",
Mac: "aa::bb::cc",
Gateway: "10.10.0.1",
},
}))
Expect(dhcpInterfaceConfigurations).To(BeEmpty())
Expect(dnsServers).To(Equal([]string{"54.209.78.6", "127.0.0.5"}))
})
})
})
Describe("SetupNetworking", func() {
var (
dhcpNetwork boshsettings.Network
staticNetwork boshsettings.Network
expectedNetworkConfigurationForStaticAndDhcp string
)
BeforeEach(func() {
dhcpNetwork = boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-dhcp-mac-address",
}
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
expectedNetworkConfigurationForStaticAndDhcp = `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethdhcp
iface ethdhcp inet dhcp
auto ethstatic
iface ethstatic inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
broadcast 1.2.3.255
gateway 3.4.5.6
dns-nameservers 8.8.8.8 9.9.9.9`
})
It("writes interfaces in /etc/network/interfaces in alphabetic order", func() {
anotherDHCPNetwork := boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-another-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
"ethdhcp1": dhcpNetwork,
"ethdhcp0": anotherDHCPNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{
"dhcp-network-1": dhcpNetwork,
"dhcp-network-2": anotherDHCPNetwork,
"static-network": staticNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
expectedNetworkConfigurationForStaticAndDhcp = `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethdhcp0
iface ethdhcp0 inet dhcp
auto ethdhcp1
iface ethdhcp1 inet dhcp
auto ethstatic
iface ethstatic inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
broadcast 1.2.3.255
gateway 3.4.5.6
dns-nameservers 8.8.8.8 9.9.9.9`
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
})
It("writes /etc/network/interfaces without dns-namservers if there are no dns servers", func() {
staticNetworkWithoutDNS := boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetworkWithoutDNS,
})
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetworkWithoutDNS}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(`# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethstatic
iface ethstatic inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
broadcast 1.2.3.255
gateway 3.4.5.6
`))
})
It("returns errors from glob /sys/class/net/", func() {
fs.GlobErr = errors.New("fs-glob-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-glob-error"))
})
It("returns errors from writing the network configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"dhcp": dhcpNetwork,
"static": staticNetwork,
})
fs.WriteFileError = errors.New("fs-write-file-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-write-file-error"))
})
It("returns errors when it can't creating network interface configurations", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
staticNetwork.Netmask = "not an ip" //will cause InterfaceConfigurationCreator to fail
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Creating interface configurations"))
})
It("writes a dhcp configuration if there are dhcp networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(`# 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 8.8.8.8, 9.9.9.9;
`))
})
It("writes a dhcp configuration without prepended dns servers if there are no dns servers specified", func() {
dhcpNetworkWithoutDNS := boshsettings.Network{
Type: "dynamic",
Mac: "fake-dhcp-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetworkWithoutDNS}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(`# 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;
`))
})
It("returns an error if it can't write a dhcp configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileErrors["/etc/dhcp/dhclient.conf"] = errors.New("dhclient.conf-write-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("dhclient.conf-write-error"))
})
It("doesn't write a dhcp configuration if there are no dhcp networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).To(BeNil())
})
It("restarts the networks if /etc/network/interfaces changes", func() {
initialDhcpConfig := `# 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 8.8.8.8, 9.9.9.9;
`
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/dhcp/dhclient.conf", initialDhcpConfig)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(5))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"pkill", "dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethdhcp.dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethstatic.dhclient"}))
Expect(cmdRunner.RunCommands[3]).To(Equal([]string{"ifdown", "-a", "--no-loopback"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"ifup", "-a", "--no-loopback"}))
})
It("doesn't restart the networks if /etc/network/interfaces and /etc/dhcp/dhclient.conf don't change", func() {
initialDhcpConfig := `# 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 8.8.8.8, 9.9.9.9;
`
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/network/interfaces", expectedNetworkConfigurationForStaticAndDhcp)
fs.WriteFileString("/etc/dhcp/dhclient.conf", initialDhcpConfig)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig.StringContents()).To(Equal(initialDhcpConfig))
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
It("restarts the networks if /etc/dhcp/dhclient.conf changes", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/network/interfaces", expectedNetworkConfigurationForStaticAndDhcp)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
Expect(len(cmdRunner.RunCommands)).To(Equal(5))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"pkill", "dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethdhcp.dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethstatic.dhclient"}))
Expect(cmdRunner.RunCommands[3]).To(Equal([]string{"ifdown", "-a", "--no-loopback"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"ifup", "-a", "--no-loopback"}))
})
It("broadcasts MAC addresses for all interfaces", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, errCh)
Expect(err).ToNot(HaveOccurred())
broadcastErr := <-errCh // wait for all arpings
Expect(broadcastErr).ToNot(HaveOccurred())
Expect(addressBroadcaster.BroadcastMACAddressesAddresses).To(Equal([]boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
boship.NewResolvingInterfaceAddress("ethdhcp", ipResolver),
}))
})
It("skips vip networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
vipNetwork := boshsettings.Network{
Type: "vip",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-vip-mac-address",
IP: "9.8.7.6",
}
err := netManager.SetupNetworking(boshsettings.Networks{
"dhcp-network": dhcpNetwork,
"static-network": staticNetwork,
"vip-network": vipNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
})
Context("when no MAC address is provided in the settings", func() {
It("configures network for single device", func() {
staticNetworkWithoutMAC := boshsettings.Network{
Type: "manual",
IP: "2.2.2.2",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
stubInterfaces(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
)
err := netManager.SetupNetworking(boshsettings.Networks{
"static-network": staticNetworkWithoutMAC,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
expectedNetworkConfiguration := `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethstatic
iface ethstatic inet static
address 2.2.2.2
network 2.2.2.0
netmask 255.255.255.0
broadcast 2.2.2.255
gateway 3.4.5.6
`
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfiguration))
})
It("configures network for a single physical device, when a virtual device is also present", func() {
staticNetworkWithoutMAC := boshsettings.Network{
Type: "manual",
IP: "2.2.2.2",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
stubInterfacesWithVirtual(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
[]string{"virtual"},
)
err := netManager.SetupNetworking(boshsettings.Networks{
"static-network": staticNetworkWithoutMAC,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
expectedNetworkConfiguration := `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethstatic
iface ethstatic inet static
address 2.2.2.2
network 2.2.2.0
netmask 255.255.255.0
broadcast 2.2.2.255
gateway 3.4.5.6
`
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfiguration))
})
})
})
Describe("GetConfiguredNetworkInterfaces", func() {
Context("when there are network devices", func() {
BeforeEach(func() {
interfacePaths := []string{}
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth0", "aa:bb", true))
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth1", "cc:dd", true))
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth2", "ee:ff", true))
fs.SetGlob("/sys/class/net/*", interfacePaths)
})
It("returns networks that are defined in /etc/network/interfaces", func() {
cmdRunner.AddCmdResult("ifup --no-act fake-eth0", fakesys.FakeCmdResult{
Stdout: "",
Stderr: "ifup: interface fake-eth0 already configured",
ExitStatus: 0,
})
cmdRunner.AddCmdResult("ifup --no-act fake-eth1", fakesys.FakeCmdResult{
Stdout: "",
Stderr: "Ignoring unknown interface fake-eth1=fake-eth1.",
ExitStatus: 0,
})
cmdRunner.AddCmdResult("ifup --no-act fake-eth2", fakesys.FakeCmdResult{
Stdout: "",
Stderr: "ifup: interface fake-eth2 already configured",
ExitStatus: 0,
})
interfaces, err := netManager.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(ConsistOf("fake-eth0", "fake-eth2"))
})
})
Context("when there are no network devices", func() {
It("returns empty list", func() {
interfaces, err := netManager.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(Equal([]string{}))
})
})
})
}
func init() {
Describe("actionDispatcher", func() {
var (
logger boshlog.Logger
taskService *faketask.FakeService
taskManager *faketask.FakeManager
actionFactory *fakeaction.FakeFactory
actionRunner *fakeaction.FakeRunner
dispatcher ActionDispatcher
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
taskService = faketask.NewFakeService()
taskManager = faketask.NewFakeManager()
actionFactory = fakeaction.NewFakeFactory()
actionRunner = &fakeaction.FakeRunner{}
dispatcher = NewActionDispatcher(logger, taskService, taskManager, actionFactory, actionRunner)
})
It("responds with exception when the method is unknown", func() {
actionFactory.RegisterActionErr("fake-action", errors.New("fake-create-error"))
req := boshhandler.NewRequest("fake-reply", "fake-action", []byte{})
resp := dispatcher.Dispatch(req)
boshassert.MatchesJSONString(GinkgoT(), resp, `{"exception":{"message":"unknown message fake-action"}}`)
})
Context("when action is synchronous", func() {
var (
req boshhandler.Request
)
BeforeEach(func() {
req = boshhandler.NewRequest("fake-reply", "fake-action", []byte("fake-payload"))
actionFactory.RegisterAction("fake-action", &fakeaction.TestAction{Asynchronous: false})
})
It("handles synchronous action", func() {
actionRunner.RunValue = "fake-value"
resp := dispatcher.Dispatch(req)
Expect(req.GetPayload()).To(Equal(actionRunner.RunPayload))
Expect(boshhandler.NewValueResponse("fake-value")).To(Equal(resp))
})
It("handles synchronous action when err", func() {
actionRunner.RunErr = errors.New("fake-run-error")
resp := dispatcher.Dispatch(req)
expectedJSON := fmt.Sprintf("{\"exception\":{\"message\":\"Action Failed %s: fake-run-error\"}}", req.Method)
boshassert.MatchesJSONString(GinkgoT(), resp, expectedJSON)
})
})
Context("when action is asynchronous", func() {
var (
req boshhandler.Request
action *fakeaction.TestAction
)
BeforeEach(func() {
req = boshhandler.NewRequest("fake-reply", "fake-action", []byte("fake-payload"))
action = &fakeaction.TestAction{Asynchronous: true}
actionFactory.RegisterAction("fake-action", action)
})
ItAllowsToCancelTask := func() {
It("allows task to be cancelled", func() {
dispatcher.Dispatch(req)
err := taskService.StartedTasks["fake-generated-task-id"].Cancel()
Expect(err).ToNot(HaveOccurred())
Expect(action.Canceled).To(BeTrue())
})
It("returns error from cancelling task if canceling task fails", func() {
action.CancelErr = errors.New("fake-cancel-err")
dispatcher.Dispatch(req)
err := taskService.StartedTasks["fake-generated-task-id"].Cancel()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-cancel-err"))
})
}
Context("when action is not persistent", func() {
BeforeEach(func() {
action.Persistent = false
})
It("responds with task id and state", func() {
resp := dispatcher.Dispatch(req)
boshassert.MatchesJSONString(GinkgoT(), resp,
`{"value":{"agent_task_id":"fake-generated-task-id","state":"running"}}`)
})
It("starts running created task", func() {
dispatcher.Dispatch(req)
Expect(len(taskService.StartedTasks)).To(Equal(1))
Expect(taskService.StartedTasks["fake-generated-task-id"]).ToNot(BeNil())
})
It("returns create task error", func() {
taskService.CreateTaskErr = errors.New("fake-create-task-error")
resp := dispatcher.Dispatch(req)
respJSON, err := json.Marshal(resp)
Expect(err).ToNot(HaveOccurred())
Expect(string(respJSON)).To(ContainSubstring("fake-create-task-error"))
})
It("return run value to the task", func() {
actionRunner.RunValue = "fake-value"
dispatcher.Dispatch(req)
value, err := taskService.StartedTasks["fake-generated-task-id"].Func()
Expect(value).To(Equal("fake-value"))
Expect(err).ToNot(HaveOccurred())
Expect(actionRunner.RunAction).To(Equal(action))
Expect(string(actionRunner.RunPayload)).To(Equal("fake-payload"))
})
It("returns run error to the task", func() {
actionRunner.RunErr = errors.New("fake-run-error")
dispatcher.Dispatch(req)
value, err := taskService.StartedTasks["fake-generated-task-id"].Func()
Expect(value).To(BeNil())
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-run-error"))
Expect(actionRunner.RunAction).To(Equal(action))
Expect(string(actionRunner.RunPayload)).To(Equal("fake-payload"))
})
ItAllowsToCancelTask()
It("does not add task to task manager since it should not be resumed if agent is restarted", func() {
dispatcher.Dispatch(req)
taskInfos, _ := taskManager.GetInfos()
Expect(taskInfos).To(BeEmpty())
})
It("does not do anything after task finishes", func() {
dispatcher.Dispatch(req)
Expect(taskService.StartedTasks["fake-generated-task-id"].EndFunc).To(BeNil())
})
})
Context("when action is persistent", func() {
BeforeEach(func() {
action.Persistent = true
})
It("responds with task id and state", func() {
resp := dispatcher.Dispatch(req)
boshassert.MatchesJSONString(GinkgoT(), resp,
`{"value":{"agent_task_id":"fake-generated-task-id","state":"running"}}`)
})
It("starts running created task", func() {
dispatcher.Dispatch(req)
Expect(len(taskService.StartedTasks)).To(Equal(1))
Expect(taskService.StartedTasks["fake-generated-task-id"]).ToNot(BeNil())
})
It("returns create task error", func() {
taskService.CreateTaskErr = errors.New("fake-create-task-error")
resp := dispatcher.Dispatch(req)
respJSON, err := json.Marshal(resp)
Expect(err).ToNot(HaveOccurred())
Expect(string(respJSON)).To(ContainSubstring("fake-create-task-error"))
})
It("return run value to the task", func() {
actionRunner.RunValue = "fake-value"
dispatcher.Dispatch(req)
value, err := taskService.StartedTasks["fake-generated-task-id"].Func()
Expect(value).To(Equal("fake-value"))
Expect(err).ToNot(HaveOccurred())
Expect(actionRunner.RunAction).To(Equal(action))
Expect(string(actionRunner.RunPayload)).To(Equal("fake-payload"))
})
It("returns run error to the task", func() {
actionRunner.RunErr = errors.New("fake-run-error")
dispatcher.Dispatch(req)
value, err := taskService.StartedTasks["fake-generated-task-id"].Func()
Expect(value).To(BeNil())
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-run-error"))
Expect(actionRunner.RunAction).To(Equal(action))
Expect(string(actionRunner.RunPayload)).To(Equal("fake-payload"))
})
ItAllowsToCancelTask()
It("adds task to task manager before task starts so that it could be resumed if agent is restarted", func() {
dispatcher.Dispatch(req)
taskInfos, _ := taskManager.GetInfos()
Expect(taskInfos).To(Equal([]boshtask.Info{
boshtask.Info{
TaskID: "fake-generated-task-id",
Method: "fake-action",
Payload: []byte("fake-payload"),
},
}))
})
It("removes task from task manager after task finishes", func() {
dispatcher.Dispatch(req)
taskService.StartedTasks["fake-generated-task-id"].EndFunc(boshtask.Task{ID: "fake-generated-task-id"})
taskInfos, _ := taskManager.GetInfos()
Expect(taskInfos).To(BeEmpty())
})
It("does not start running created task if task manager cannot add task", func() {
taskManager.AddInfoErr = errors.New("fake-add-task-info-error")
resp := dispatcher.Dispatch(req)
boshassert.MatchesJSONString(GinkgoT(), resp,
`{"exception":{"message":"Action Failed fake-action: fake-add-task-info-error"}}`)
Expect(len(taskService.StartedTasks)).To(Equal(0))
})
})
})
Describe("ResumePreviouslyDispatchedTasks", func() {
var firstAction, secondAction *fakeaction.TestAction
BeforeEach(func() {
err := taskManager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-1",
Method: "fake-action-1",
Payload: []byte("fake-task-payload-1"),
})
Expect(err).ToNot(HaveOccurred())
err = taskManager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-action-2",
Payload: []byte("fake-task-payload-2"),
})
Expect(err).ToNot(HaveOccurred())
firstAction = &fakeaction.TestAction{}
secondAction = &fakeaction.TestAction{}
})
It("calls resume on each task that was saved in a task manager", func() {
actionFactory.RegisterAction("fake-action-1", firstAction)
actionFactory.RegisterAction("fake-action-2", secondAction)
dispatcher.ResumePreviouslyDispatchedTasks()
Expect(len(taskService.StartedTasks)).To(Equal(2))
{ // Check that first task executes first action
actionRunner.ResumeValue = "fake-resume-value-1"
value, err := taskService.StartedTasks["fake-task-id-1"].Func()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("fake-resume-value-1"))
Expect(actionRunner.ResumeAction).To(Equal(firstAction))
Expect(string(actionRunner.ResumePayload)).To(Equal("fake-task-payload-1"))
}
{ // Check that second task executes second action
actionRunner.ResumeValue = "fake-resume-value-2"
value, err := taskService.StartedTasks["fake-task-id-2"].Func()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("fake-resume-value-2"))
Expect(actionRunner.ResumeAction).To(Equal(secondAction))
Expect(string(actionRunner.ResumePayload)).To(Equal("fake-task-payload-2"))
}
})
It("removes tasks from task manager after each task finishes", func() {
actionFactory.RegisterAction("fake-action-1", firstAction)
actionFactory.RegisterAction("fake-action-2", secondAction)
dispatcher.ResumePreviouslyDispatchedTasks()
Expect(len(taskService.StartedTasks)).To(Equal(2))
// Simulate all tasks ending
taskService.StartedTasks["fake-task-id-1"].EndFunc(boshtask.Task{ID: "fake-task-id-1"})
taskService.StartedTasks["fake-task-id-2"].EndFunc(boshtask.Task{ID: "fake-task-id-2"})
taskInfos, err := taskManager.GetInfos()
Expect(err).ToNot(HaveOccurred())
Expect(taskInfos).To(BeEmpty())
})
It("return resume error to each task", func() {
actionFactory.RegisterAction("fake-action-1", firstAction)
actionFactory.RegisterAction("fake-action-2", secondAction)
dispatcher.ResumePreviouslyDispatchedTasks()
Expect(len(taskService.StartedTasks)).To(Equal(2))
{ // Check that first task propagates its resume error
actionRunner.ResumeErr = errors.New("fake-resume-error-1")
value, err := taskService.StartedTasks["fake-task-id-1"].Func()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-resume-error-1"))
Expect(value).To(BeNil())
Expect(actionRunner.ResumeAction).To(Equal(firstAction))
Expect(string(actionRunner.ResumePayload)).To(Equal("fake-task-payload-1"))
}
{ // Check that second task propagates its resume error
actionRunner.ResumeErr = errors.New("fake-resume-error-2")
value, err := taskService.StartedTasks["fake-task-id-2"].Func()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-resume-error-2"))
Expect(value).To(BeNil())
Expect(actionRunner.ResumeAction).To(Equal(secondAction))
Expect(string(actionRunner.ResumePayload)).To(Equal("fake-task-payload-2"))
}
})
It("ignores actions that cannot be created and removes them from task manager", func() {
actionFactory.RegisterActionErr("fake-action-1", errors.New("fake-action-error-1"))
actionFactory.RegisterAction("fake-action-2", secondAction)
dispatcher.ResumePreviouslyDispatchedTasks()
Expect(len(taskService.StartedTasks)).To(Equal(1))
{ // Check that first action is removed from task manager
taskInfos, err := taskManager.GetInfos()
Expect(err).ToNot(HaveOccurred())
Expect(taskInfos).To(Equal([]boshtask.Info{
boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-action-2",
Payload: []byte("fake-task-payload-2"),
},
}))
}
{ // Check that second task executes second action
taskService.StartedTasks["fake-task-id-2"].Func()
Expect(actionRunner.ResumeAction).To(Equal(secondAction))
Expect(string(actionRunner.ResumePayload)).To(Equal("fake-task-payload-2"))
}
})
It("allows to cancel after resume", func() {
actionFactory.RegisterAction("fake-action-1", firstAction)
actionFactory.RegisterAction("fake-action-2", secondAction)
dispatcher.ResumePreviouslyDispatchedTasks()
err := taskService.StartedTasks["fake-task-id-1"].Cancel()
Expect(err).ToNot(HaveOccurred())
Expect(firstAction.Canceled).To(BeTrue())
Expect(secondAction.Canceled).To(BeFalse())
err = taskService.StartedTasks["fake-task-id-2"].Cancel()
Expect(err).ToNot(HaveOccurred())
Expect(secondAction.Canceled).To(BeTrue())
})
It("returns error from cancelling task when canceling resumed task fails", func() {
actionFactory.RegisterAction("fake-action-1", firstAction)
actionFactory.RegisterAction("fake-action-2", secondAction)
dispatcher.ResumePreviouslyDispatchedTasks()
firstAction.CancelErr = errors.New("fake-cancel-err-1")
secondAction.CancelErr = errors.New("fake-cancel-err-2")
err := taskService.StartedTasks["fake-task-id-1"].Cancel()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-cancel-err-1"))
err = taskService.StartedTasks["fake-task-id-2"].Cancel()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-cancel-err-2"))
})
})
})
}
func init() {
Describe("App", func() {
var (
baseDir string
agentConfPath string
agentConfJSON string
app App
)
BeforeEach(func() {
var err error
baseDir, err = ioutil.TempDir("", "go-agent-test")
Expect(err).ToNot(HaveOccurred())
err = os.Mkdir(filepath.Join(baseDir, "bosh"), os.ModePerm)
Expect(err).ToNot(HaveOccurred())
})
BeforeEach(func() {
agentConfPath = filepath.Join(baseDir, "bosh", "agent.json")
agentConfJSON = `{
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
settingsPath := filepath.Join(baseDir, "bosh", "settings.json")
settingsJSON := `{
"agent_id": "my-agent-id",
"blobstore": {
"options": {
"bucket_name": "george",
"encryption_key": "optional encryption key",
"access_key_id": "optional access key id",
"secret_access_key": "optional secret access key"
},
"provider": "dummy"
},
"disks": {
"ephemeral": "/dev/sdb",
"persistent": {
"vol-xxxxxx": "/dev/sdf"
},
"system": "/dev/sda1"
},
"env": {
"bosh": {
"password": "******"
}
},
"networks": {
"netA": {
"default": ["dns", "gateway"],
"ip": "ww.ww.ww.ww",
"dns": [
"xx.xx.xx.xx",
"yy.yy.yy.yy"
]
},
"netB": {
"dns": [
"zz.zz.zz.zz"
]
}
},
"Mbus": "https://*****:*****@0.0.0.0:6868",
"ntp": [
"0.north-america.pool.ntp.org",
"1.north-america.pool.ntp.org"
],
"vm": {
"name": "vm-abc-def"
}
}`
err := ioutil.WriteFile(settingsPath, []byte(settingsJSON), 0640)
Expect(err).ToNot(HaveOccurred())
})
JustBeforeEach(func() {
err := ioutil.WriteFile(agentConfPath, []byte(agentConfJSON), 0640)
Expect(err).ToNot(HaveOccurred())
logger := boshlog.NewLogger(boshlog.LevelNone)
fakefs := boshsys.NewOsFileSystem(logger)
app = New(logger, fakefs)
})
AfterEach(func() {
os.RemoveAll(baseDir)
})
It("Sets up device path resolver on platform specific to infrastructure", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(Equal(devicepathresolver.NewIdentityDevicePathResolver()))
})
Context("when DevicePathResolutionType is 'virtio'", func() {
BeforeEach(func() {
agentConfJSON = `{
"Platform": { "Linux": { "DevicePathResolutionType": "virtio" } },
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
})
It("uses a VirtioDevicePathResolver", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
logLevel, err := boshlog.Levelify("DEBUG")
Expect(err).NotTo(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(
BeAssignableToTypeOf(devicepathresolver.NewVirtioDevicePathResolver(nil, nil, boshlog.NewLogger(logLevel))))
})
})
Context("when DevicePathResolutionType is 'scsi'", func() {
BeforeEach(func() {
agentConfJSON = `{
"Platform": { "Linux": { "DevicePathResolutionType": "scsi" } },
"Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } }
}`
})
It("uses a VirtioDevicePathResolver", func() {
err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(err).ToNot(HaveOccurred())
Expect(app.GetPlatform().GetDevicePathResolver()).To(
BeAssignableToTypeOf(devicepathresolver.NewScsiDevicePathResolver(0, nil)))
})
})
Context("logging stemcell version and git sha", func() {
var (
logger boshlog.Logger
outBuf *bytes.Buffer
fakeFs boshsys.FileSystem
stemcellVersionFilePath string
stemcellSha1FilePath string
)
JustBeforeEach(func() {
outBuf = bytes.NewBufferString("")
errBuf := bytes.NewBufferString("")
logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuf, errBuf)
fakeFs = fakesys.NewFakeFileSystem()
dirProvider := boshdirs.NewProvider(baseDir)
stemcellVersionFilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_version")
stemcellSha1FilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_git_sha1")
app = New(logger, fakeFs)
})
Context("when stemcell version and sha files are present", func() {
It("should print out the stemcell version and sha in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: sha1-blah)"))
})
})
Context("when stemcell version file is NOT present", func() {
It("should print out the sha in the logs", func() {
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)"))
})
})
Context("when sha version file is NOT present", func() {
It("should print out the stemcell version in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)"))
})
})
Context("when stemcell version file is empty", func() {
It("should print out the sha in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "")
fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)"))
})
})
Context("when sha version file is empty", func() {
It("should print out the stemcell version in the logs", func() {
fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah")
fakeFs.WriteFileString(stemcellSha1FilePath, "")
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)"))
})
})
Context("when stemcell version and sha files are NOT present", func() {
It("should print unknown version and sha in the logs", func() {
app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir})
Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: ?)"))
})
})
})
})
}
func init() {
Describe("bootstrap", func() {
Describe("Run", func() {
var (
platform *fakeplatform.FakePlatform
dirProvider boshdir.Provider
settingsSource *fakeinf.FakeSettingsSource
settingsService *fakesettings.FakeSettingsService
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
dirProvider = boshdir.NewProvider("/var/vcap")
settingsSource = &fakeinf.FakeSettingsSource{}
settingsService = &fakesettings.FakeSettingsService{}
})
bootstrap := func() error {
logger := boshlog.NewLogger(boshlog.LevelNone)
return NewBootstrap(platform, dirProvider, settingsService, logger).Run()
}
It("sets up runtime configuration", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupRuntimeConfigurationWasInvoked).To(BeTrue())
})
Describe("SSH tunnel setup for registry", func() {
It("returns error without configuring ssh on the platform if getting public key fails", func() {
settingsService.PublicKeyErr = errors.New("fake-get-public-key-err")
err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-public-key-err"))
Expect(platform.SetupSSHCalled).To(BeFalse())
})
Context("when public key is not empty", func() {
BeforeEach(func() {
settingsService.PublicKey = "fake-public-key"
})
It("gets the public key and sets up ssh via the platform", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupSSHPublicKey).To(Equal("fake-public-key"))
Expect(platform.SetupSSHUsername).To(Equal("vcap"))
})
It("returns error if configuring ssh on the platform fails", func() {
platform.SetupSSHErr = errors.New("fake-setup-ssh-err")
err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-ssh-err"))
})
})
Context("when public key key is empty", func() {
BeforeEach(func() {
settingsSource.PublicKey = ""
})
It("gets the public key and does not setup SSH", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupSSHCalled).To(BeFalse())
})
})
})
It("sets up hostname", func() {
settingsService.Settings.AgentID = "foo-bar-baz-123"
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupHostnameHostname).To(Equal("foo-bar-baz-123"))
})
It("fetches initial settings", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(settingsService.SettingsWereLoaded).To(BeTrue())
})
It("returns error from loading initial settings", func() {
settingsService.LoadSettingsError = errors.New("fake-load-error")
err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-load-error"))
})
It("sets up networking", func() {
networks := boshsettings.Networks{
"bosh": boshsettings.Network{},
}
settingsService.Settings.Networks = networks
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupNetworkingNetworks).To(Equal(networks))
})
It("sets up ephemeral disk", func() {
settingsService.Settings.Disks = boshsettings.Disks{
Ephemeral: "fake-ephemeral-disk-setting",
}
platform.GetEphemeralDiskPathRealPath = "/dev/sda"
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupEphemeralDiskWithPathDevicePath).To(Equal("/dev/sda"))
Expect(platform.GetEphemeralDiskPathSettings).To(Equal(boshsettings.DiskSettings{
VolumeID: "fake-ephemeral-disk-setting",
Path: "fake-ephemeral-disk-setting",
}))
})
It("returns error if setting ephemeral disk fails", func() {
platform.SetupEphemeralDiskWithPathErr = errors.New("fake-setup-ephemeral-disk-err")
err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-ephemeral-disk-err"))
})
It("sets up data dir", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupDataDirCalled).To(BeTrue())
})
It("returns error if set up of data dir fails", func() {
platform.SetupDataDirErr = errors.New("fake-setup-data-dir-err")
err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-data-dir-err"))
})
It("sets up tmp dir", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupTmpDirCalled).To(BeTrue())
})
It("returns error if set up of tmp dir fails", func() {
platform.SetupTmpDirErr = errors.New("fake-setup-tmp-dir-err")
err := bootstrap()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-setup-tmp-dir-err"))
})
It("mounts persistent disk", func() {
settingsService.Settings.Disks = boshsettings.Disks{
Persistent: map[string]interface{}{
"vol-123": map[string]interface{}{
"volume_id": "2",
"path": "/dev/sdb",
},
},
}
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.MountPersistentDiskSettings).To(Equal(boshsettings.DiskSettings{
ID: "vol-123",
VolumeID: "2",
Path: "/dev/sdb",
}))
Expect(platform.MountPersistentDiskMountPoint).To(Equal(dirProvider.StoreDir()))
})
It("errors if there is more than one persistent disk", func() {
settingsService.Settings.Disks = boshsettings.Disks{
Persistent: map[string]interface{}{
"vol-123": "/dev/sdb",
"vol-456": "/dev/sdc",
},
}
err := bootstrap()
Expect(err).To(HaveOccurred())
})
It("does not try to mount when no persistent disk", func() {
settingsService.Settings.Disks = boshsettings.Disks{
Persistent: map[string]interface{}{},
}
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.MountPersistentDiskSettings).To(Equal(boshsettings.DiskSettings{}))
Expect(platform.MountPersistentDiskMountPoint).To(Equal(""))
})
It("sets root and vcap passwords", func() {
settingsService.Settings.Env.Bosh.Password = "******"
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(2).To(Equal(len(platform.UserPasswords)))
Expect("some-encrypted-password").To(Equal(platform.UserPasswords["root"]))
Expect("some-encrypted-password").To(Equal(platform.UserPasswords["vcap"]))
})
It("does not set password if not provided", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(0).To(Equal(len(platform.UserPasswords)))
})
It("sets ntp", func() {
settingsService.Settings.Ntp = []string{
"0.north-america.pool.ntp.org",
"1.north-america.pool.ntp.org",
}
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(2).To(Equal(len(platform.SetTimeWithNtpServersServers)))
Expect("0.north-america.pool.ntp.org").To(Equal(platform.SetTimeWithNtpServersServers[0]))
Expect("1.north-america.pool.ntp.org").To(Equal(platform.SetTimeWithNtpServersServers[1]))
})
It("setups up monit user", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.SetupMonitUserSetup).To(BeTrue())
})
It("starts monit", func() {
err := bootstrap()
Expect(err).NotTo(HaveOccurred())
Expect(platform.StartMonitStarted).To(BeTrue())
})
})
Describe("Network setup exercised by Run", func() {
var (
settingsJSON string
fs *fakesys.FakeFileSystem
platform boshplatform.Platform
boot Bootstrap
defaultNetworkResolver boshsettings.DefaultNetworkResolver
logger boshlog.Logger
dirProvider boshdirs.Provider
)
writeNetworkDevice := func(iface string, macAddress string, isPhysical bool) string {
interfacePath := fmt.Sprintf("/sys/class/net/%s", iface)
fs.WriteFile(interfacePath, []byte{})
if isPhysical {
fs.WriteFile(fmt.Sprintf("/sys/class/net/%s/device", iface), []byte{})
}
fs.WriteFileString(fmt.Sprintf("/sys/class/net/%s/address", iface), fmt.Sprintf("%s\n", macAddress))
return interfacePath
}
stubInterfaces := func(interfaces [][]string) {
var interfacePaths []string
for _, iface := range interfaces {
interfaceName := iface[0]
interfaceMAC := iface[1]
interfaceType := iface[2]
isPhysical := interfaceType == "physical"
interfacePaths = append(interfacePaths, writeNetworkDevice(interfaceName, interfaceMAC, isPhysical))
}
fs.SetGlob("/sys/class/net/*", interfacePaths)
}
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
runner := fakesys.NewFakeCmdRunner()
dirProvider = boshdirs.NewProvider("/var/vcap/bosh")
linuxOptions := boshplatform.LinuxOptions{
CreatePartitionIfNoEphemeralDisk: true,
}
logger = boshlog.NewLogger(boshlog.LevelNone)
diskManager := fakedisk.NewFakeDiskManager()
diskManager.FakeMountsSearcher.SearchMountsMounts = []boshdisk.Mount{
{MountPoint: "/", PartitionPath: "rootfs"},
{MountPoint: "/", PartitionPath: "/dev/vda1"},
}
runner.AddCmdResult(
"readlink -f /dev/vda1",
fakesys.FakeCmdResult{Stdout: "/dev/vda1"},
)
diskManager.FakeRootDevicePartitioner.GetDeviceSizeInBytesSizes["/dev/vda"] = 1024 * 1024 * 1024
udev := boshudev.NewConcreteUdevDevice(runner, logger)
linuxCdrom := boshcdrom.NewLinuxCdrom("/dev/sr0", udev, runner)
linuxCdutil := boshcdrom.NewCdUtil(dirProvider.SettingsDir(), fs, linuxCdrom, logger)
compressor := boshcmd.NewTarballCompressor(runner, fs)
copier := boshcmd.NewCpCopier(runner, fs, logger)
sigarCollector := boshsigar.NewSigarStatsCollector(&sigar.ConcreteSigar{})
vitalsService := boshvitals.NewService(sigarCollector, dirProvider)
ipResolver := boship.NewResolver(boship.NetworkInterfaceToAddrsFunc)
arping := bosharp.NewArping(runner, fs, logger, boshplatform.ArpIterations, boshplatform.ArpIterationDelay, boshplatform.ArpInterfaceCheckDelay)
interfaceConfigurationCreator := boshnet.NewInterfaceConfigurationCreator(logger)
ubuntuNetManager := boshnet.NewUbuntuNetManager(fs, runner, ipResolver, interfaceConfigurationCreator, arping, logger)
ubuntuCertManager := boshcert.NewUbuntuCertManager(fs, runner, logger)
monitRetryable := boshplatform.NewMonitRetryable(runner)
monitRetryStrategy := boshretry.NewAttemptRetryStrategy(10, 1*time.Second, monitRetryable, logger)
devicePathResolver := devicepathresolver.NewIdentityDevicePathResolver()
routesSearcher := boshnet.NewCmdRoutesSearcher(runner)
defaultNetworkResolver = boshnet.NewDefaultNetworkResolver(routesSearcher, ipResolver)
platform = boshplatform.NewLinuxPlatform(
fs,
runner,
sigarCollector,
compressor,
copier,
dirProvider,
vitalsService,
linuxCdutil,
diskManager,
ubuntuNetManager,
ubuntuCertManager,
monitRetryStrategy,
devicePathResolver,
500*time.Millisecond,
linuxOptions,
logger,
defaultNetworkResolver,
)
})
JustBeforeEach(func() {
settingsPath := filepath.Join("bosh", "settings.json")
var settings boshsettings.Settings
json.Unmarshal([]byte(settingsJSON), &settings)
settingsSource := fakeinf.FakeSettingsSource{
PublicKey: "123",
SettingsValue: settings,
}
settingsService := boshsettings.NewService(
platform.GetFs(),
settingsPath,
settingsSource,
platform,
logger,
)
boot = NewBootstrap(
platform,
dirProvider,
settingsService,
logger,
)
})
Context("when a single network configuration is provided, with a MAC address", func() {
BeforeEach(func() {
settingsJSON = `{
"networks": {
"netA": {
"default": ["dns", "gateway"],
"ip": "2.2.2.2",
"dns": [
"8.8.8.8",
"4.4.4.4"
],
"netmask": "255.255.255.0",
"gateway": "2.2.2.0",
"mac": "aa:bb:cc"
}
}
}`
})
Context("and no physical network interfaces exist", func() {
Context("and a single virtual network interface exists", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"lo", "aa:bb:cc", "virtual"}})
})
It("raises an error", func() {
err := boot.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Number of network settings '1' is greater than the number of network devices '0"))
})
})
})
Context("and a single physical network interface exists", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).NotTo(HaveOccurred())
})
})
Context("and extra physical network interfaces exist", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"eth1", "aa:bb:dd", "physical"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).NotTo(HaveOccurred())
})
})
Context("and extra virtual network interfaces exist", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"lo", "aa:bb:ee", "virtual"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).ToNot(HaveOccurred())
})
})
})
Context("when a single network configuration is provided, without a MAC address", func() {
BeforeEach(func() {
settingsJSON = `{
"networks": {
"netA": {
"default": ["dns", "gateway"],
"ip": "2.2.2.2",
"dns": [
"8.8.8.8",
"4.4.4.4"
],
"netmask": "255.255.255.0",
"gateway": "2.2.2.0"
}
}
}`
})
Context("and no physical network interfaces exist", func() {
Context("and a single virtual network interface exists", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"lo", "aa:bb:cc", "virtual"}})
})
It("raises an error", func() {
err := boot.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Number of network settings '1' is greater than the number of network devices '0"))
})
})
})
Context("and a single physical network interface exists", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).NotTo(HaveOccurred())
})
})
Context("and extra physical network interfaces exist", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"eth1", "aa:bb:dd", "physical"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).NotTo(HaveOccurred())
})
})
Context("and an extra virtual network interface exists", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"lo", "aa:bb:dd", "virtual"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).NotTo(HaveOccurred())
})
})
})
Context("when two network configurations are provided", func() {
BeforeEach(func() {
settingsJSON = `{
"networks": {
"netA": {
"default": ["dns", "gateway"],
"ip": "2.2.2.2",
"dns": [
"8.8.8.8",
"4.4.4.4"
],
"netmask": "255.255.255.0",
"gateway": "2.2.2.0",
"mac": "aa:bb:cc"
},
"netB": {
"default": ["dns", "gateway"],
"ip": "3.3.3.3",
"dns": [
"8.8.8.8",
"4.4.4.4"
],
"netmask": "255.255.255.0",
"gateway": "3.3.3.0",
"mac": ""
}
}
}`
})
Context("and a single physical network interface exists", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}})
})
It("raises an error", func() {
err := boot.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Number of network settings '2' is greater than the number of network devices '1"))
})
})
Context("and two physical network interfaces with matching MAC addresses exist", func() {
BeforeEach(func() {
stubInterfaces([][]string{[]string{"eth0", "aa:bb:cc", "physical"}, []string{"eth1", "aa:bb:dd", "physical"}})
})
It("succeeds", func() {
err := boot.Run()
Expect(err).ToNot(HaveOccurred())
})
})
})
})
})
}
func init() {
Describe("asyncTaskService", func() {
var (
uuidGen *fakeuuid.FakeGenerator
service Service
)
BeforeEach(func() {
uuidGen = &fakeuuid.FakeGenerator{}
service = NewAsyncTaskService(uuidGen, boshlog.NewLogger(boshlog.LevelNone))
})
Describe("StartTask", func() {
startAndWaitForTaskCompletion := func(task Task) Task {
service.StartTask(task)
for task.State == StateRunning {
time.Sleep(time.Nanosecond)
task, _ = service.FindTaskWithID(task.ID)
}
return task
}
It("sets return value on a successful task", func() {
runFunc := func() (interface{}, error) { return 123, nil }
task, err := service.CreateTask(runFunc, nil, nil)
Expect(err).ToNot(HaveOccurred())
task = startAndWaitForTaskCompletion(task)
Expect(task.State).To(BeEquivalentTo(StateDone))
Expect(task.Value).To(Equal(123))
Expect(task.Error).To(BeNil())
})
It("sets task error on a failing task", func() {
err := errors.New("fake-error")
runFunc := func() (interface{}, error) { return nil, err }
task, createErr := service.CreateTask(runFunc, nil, nil)
Expect(createErr).ToNot(HaveOccurred())
task = startAndWaitForTaskCompletion(task)
Expect(task.State).To(BeEquivalentTo(StateFailed))
Expect(task.Value).To(BeNil())
Expect(task.Error).To(Equal(err))
})
Describe("CreateTask", func() {
It("can run task created with CreateTask which does not have end func", func() {
ranFunc := false
runFunc := func() (interface{}, error) { ranFunc = true; return nil, nil }
task, err := service.CreateTask(runFunc, nil, nil)
Expect(err).ToNot(HaveOccurred())
startAndWaitForTaskCompletion(task)
Expect(ranFunc).To(BeTrue())
})
It("can run task created with CreateTask which has end func", func() {
ranFunc := false
runFunc := func() (interface{}, error) { ranFunc = true; return nil, nil }
ranEndFunc := false
endFunc := func(Task) { ranEndFunc = true }
task, err := service.CreateTask(runFunc, nil, endFunc)
Expect(err).ToNot(HaveOccurred())
startAndWaitForTaskCompletion(task)
Expect(ranFunc).To(BeTrue())
Expect(ranEndFunc).To(BeTrue())
})
It("returns an error if generate uuid fails", func() {
uuidGen.GenerateError = errors.New("fake-generate-uuid-error")
_, err := service.CreateTask(nil, nil, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-generate-uuid-error"))
})
})
Describe("CreateTaskWithID", func() {
It("can run task created with CreateTaskWithID which does not have end func", func() {
ranFunc := false
runFunc := func() (interface{}, error) { ranFunc = true; return nil, nil }
task := service.CreateTaskWithID("fake-task-id", runFunc, nil, nil)
startAndWaitForTaskCompletion(task)
Expect(ranFunc).To(BeTrue())
})
It("can run task created with CreateTaskWithID which has end func", func() {
ranFunc := false
runFunc := func() (interface{}, error) { ranFunc = true; return nil, nil }
ranEndFunc := false
endFunc := func(Task) { ranEndFunc = true }
task := service.CreateTaskWithID("fake-task-id", runFunc, nil, endFunc)
startAndWaitForTaskCompletion(task)
Expect(ranFunc).To(BeTrue())
Expect(ranEndFunc).To(BeTrue())
})
})
It("can process many tasks simultaneously", func() {
taskFunc := func() (interface{}, error) {
time.Sleep(10 * time.Millisecond)
return nil, nil
}
ids := []string{}
for id := 1; id < 200; id++ {
idStr := fmt.Sprintf("%d", id)
uuidGen.GeneratedUUID = idStr
ids = append(ids, idStr)
task, err := service.CreateTask(taskFunc, nil, nil)
Expect(err).ToNot(HaveOccurred())
go service.StartTask(task)
}
for {
allDone := true
for _, id := range ids {
task, _ := service.FindTaskWithID(id)
if task.State != StateDone {
allDone = false
break
}
}
if allDone {
break
}
time.Sleep(200 * time.Millisecond)
}
})
})
Describe("CreateTask", func() {
It("creates a task with auto-assigned id", func() {
uuidGen.GeneratedUUID = "fake-uuid"
runFuncCalled := false
runFunc := func() (interface{}, error) {
runFuncCalled = true
return nil, nil
}
cancelFuncCalled := false
cancelFunc := func(_ Task) error {
cancelFuncCalled = true
return nil
}
endFuncCalled := false
endFunc := func(_ Task) {
endFuncCalled = true
}
task, err := service.CreateTask(runFunc, cancelFunc, endFunc)
Expect(err).ToNot(HaveOccurred())
Expect(task.ID).To(Equal("fake-uuid"))
Expect(task.State).To(Equal(StateRunning))
task.Func()
Expect(runFuncCalled).To(BeTrue())
task.CancelFunc(task)
Expect(cancelFuncCalled).To(BeTrue())
task.EndFunc(task)
Expect(endFuncCalled).To(BeTrue())
})
})
Describe("CreateTaskWithID", func() {
It("creates a task with given id", func() {
runFuncCalled := false
runFunc := func() (interface{}, error) {
runFuncCalled = true
return nil, nil
}
cancelFuncCalled := false
cancelFunc := func(_ Task) error {
cancelFuncCalled = true
return nil
}
endFuncCalled := false
endFunc := func(_ Task) {
endFuncCalled = true
}
task := service.CreateTaskWithID("fake-task-id", runFunc, cancelFunc, endFunc)
Expect(task.ID).To(Equal("fake-task-id"))
Expect(task.State).To(Equal(StateRunning))
task.Func()
Expect(runFuncCalled).To(BeTrue())
task.CancelFunc(task)
Expect(cancelFuncCalled).To(BeTrue())
task.EndFunc(task)
Expect(endFuncCalled).To(BeTrue())
})
})
})
}
func init() {
Describe("settingsService", func() {
var (
fs *fakesys.FakeFileSystem
fakeDefaultNetworkResolver *fakenet.FakeDefaultNetworkResolver
fakeSettingsSource *fakes.FakeSettingsSource
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
fakeDefaultNetworkResolver = &fakenet.FakeDefaultNetworkResolver{}
fakeSettingsSource = &fakes.FakeSettingsSource{}
})
buildService := func() (Service, *fakesys.FakeFileSystem) {
logger := boshlog.NewLogger(boshlog.LevelNone)
service := NewService(fs, "/setting/path.json", fakeSettingsSource, fakeDefaultNetworkResolver, logger)
return service, fs
}
Describe("LoadSettings", func() {
var (
fetchedSettings Settings
fetcherFuncErr error
service Service
)
BeforeEach(func() {
fetchedSettings = Settings{}
fetcherFuncErr = nil
})
JustBeforeEach(func() {
fakeSettingsSource.SettingsValue = fetchedSettings
fakeSettingsSource.SettingsErr = fetcherFuncErr
service, fs = buildService()
})
Context("when settings fetcher succeeds fetching settings", func() {
BeforeEach(func() {
fetchedSettings = Settings{AgentID: "some-new-agent-id"}
})
Context("when settings contain at most one dynamic network", func() {
BeforeEach(func() {
fetchedSettings.Networks = Networks{
"fake-net-1": Network{Type: NetworkTypeDynamic},
}
})
It("updates the service with settings from the fetcher", func() {
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
Expect(service.GetSettings().AgentID).To(Equal("some-new-agent-id"))
})
It("persists settings to the settings file", func() {
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
json, err := json.Marshal(fetchedSettings)
Expect(err).NotTo(HaveOccurred())
fileContent, err := fs.ReadFile("/setting/path.json")
Expect(err).NotTo(HaveOccurred())
Expect(fileContent).To(Equal(json))
})
It("returns any error from writing to the setting file", func() {
fs.WriteFileError = errors.New("fs-write-file-error")
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-write-file-error"))
})
})
})
Context("when settings fetcher fails fetching settings", func() {
BeforeEach(func() {
fetcherFuncErr = errors.New("fake-fetch-error")
})
Context("when a settings file exists", func() {
Context("when settings contain at most one dynamic network", func() {
BeforeEach(func() {
fs.WriteFile("/setting/path.json", []byte(`{
"agent_id":"some-agent-id",
"networks": {"fake-net-1": {"type": "dynamic"}}
}`))
fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
}
})
It("returns settings from the settings file with resolved network", func() {
err := service.LoadSettings()
Expect(err).ToNot(HaveOccurred())
Expect(service.GetSettings()).To(Equal(Settings{
AgentID: "some-agent-id",
Networks: Networks{
"fake-net-1": Network{
Type: NetworkTypeDynamic,
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
Resolved: true,
},
},
}))
})
})
})
Context("when non-unmarshallable settings file exists", func() {
It("returns any error from the fetcher", func() {
fs.WriteFile("/setting/path.json", []byte(`$%^&*(`))
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-fetch-error"))
Expect(service.GetSettings()).To(Equal(Settings{}))
})
})
Context("when no settings file exists", func() {
It("returns any error from the fetcher", func() {
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-fetch-error"))
Expect(service.GetSettings()).To(Equal(Settings{}))
})
})
})
})
Describe("InvalidateSettings", func() {
It("removes the settings file", func() {
fakeSettingsSource.SettingsValue = Settings{}
fakeSettingsSource.SettingsErr = nil
service, fs := buildService()
fs.WriteFile("/setting/path.json", []byte(`{}`))
err := service.InvalidateSettings()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("/setting/path.json")).To(BeFalse())
})
It("returns err if removing settings file errored", func() {
fakeSettingsSource.SettingsValue = Settings{}
fakeSettingsSource.SettingsErr = nil
service, fs := buildService()
fs.RemoveAllError = errors.New("fs-remove-all-error")
err := service.InvalidateSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-remove-all-error"))
})
})
Describe("GetSettings", func() {
var (
loadedSettings Settings
service Service
)
BeforeEach(func() {
loadedSettings = Settings{AgentID: "some-agent-id"}
})
JustBeforeEach(func() {
fakeSettingsSource.SettingsValue = loadedSettings
fakeSettingsSource.SettingsErr = nil
service, _ = buildService()
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
})
Context("when there is are no dynamic networks", func() {
It("returns settings without modifying any networks", func() {
Expect(service.GetSettings()).To(Equal(loadedSettings))
})
It("does not try to determine default network", func() {
_ = service.GetSettings()
Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalled).To(BeFalse())
})
})
Context("when there is network that needs to be resolved (ip, netmask, or mac are not set)", func() {
BeforeEach(func() {
loadedSettings = Settings{
Networks: map[string]Network{
"fake-net1": Network{
IP: "fake-net1-ip",
Netmask: "fake-net1-netmask",
Mac: "fake-net1-mac",
Gateway: "fake-net1-gateway",
},
"fake-net2": Network{
Gateway: "fake-net2-gateway",
DNS: []string{"fake-net2-dns"},
},
},
}
})
Context("when default network can be retrieved", func() {
BeforeEach(func() {
fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
}
})
It("returns settings with resolved dynamic network ip, netmask, gateway and keeping everything else the same", func() {
settings := service.GetSettings()
Expect(settings).To(Equal(Settings{
Networks: map[string]Network{
"fake-net1": Network{
IP: "fake-net1-ip",
Netmask: "fake-net1-netmask",
Mac: "fake-net1-mac",
Gateway: "fake-net1-gateway",
},
"fake-net2": Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
DNS: []string{"fake-net2-dns"},
Resolved: true,
},
},
}))
})
})
Context("when default network fails to be retrieved", func() {
BeforeEach(func() {
fakeDefaultNetworkResolver.GetDefaultNetworkErr = errors.New("fake-get-default-network-err")
})
It("returns error", func() {
settings := service.GetSettings()
Expect(settings).To(Equal(loadedSettings))
})
})
})
})
})
}
func init() {
Describe("renderedJobApplier", func() {
var (
jobsBc *fakebc.FakeBundleCollection
jobSupervisor *fakejobsuper.FakeJobSupervisor
packageApplierProvider *fakepackages.FakeApplierProvider
blobstore *fakeblob.FakeBlobstore
compressor *fakecmd.FakeCompressor
fs *fakesys.FakeFileSystem
applier Applier
)
BeforeEach(func() {
jobsBc = fakebc.NewFakeBundleCollection()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
packageApplierProvider = fakepackages.NewFakeApplierProvider()
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) {
BeforeEach(func() {
fs.TempDirDir = "/fake-tmp-dir"
})
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() {
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 walking the tree of files fails", func() {
fs.WalkErr = errors.New("fake-walk-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-walk-error"))
})
It("installs bundle from decompressed tmp path of a job template", func() {
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 the bin and config directories", func() {
var binDirStats, configDirStats *fakesys.FakeFileStats
compressor.DecompressFileToDirCallBack = func() {
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/bin/blarg", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/blarg.yml", []byte{})
}
bundle.InstallCallBack = func() {
binDirStats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/bin")
configDirStats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config")
}
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(int(binDirStats.FileMode)).To(Equal(0755))
Expect(int(configDirStats.FileMode)).To(Equal(0755))
})
It("sets executable bit for files in bin", func() {
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))
})
It("sets 644 permissions for files in config", func() {
compressor.DecompressFileToDirCallBack = func() {
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/config1", []byte{})
fs.WriteFile("/fake-tmp-dir/fake-path-in-archive/config/config2", []byte{})
}
fs.SetGlob("/fake-tmp-dir/fake-path-in-archive/config/*", []string{
"/fake-tmp-dir/fake-path-in-archive/config/config1",
"/fake-tmp-dir/fake-path-in-archive/config/config2",
})
var config1Stats, config2Stats *fakesys.FakeFileStats
bundle.InstallCallBack = func() {
config1Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config/config1")
config2Stats = fs.GetFileTestStat("/fake-tmp-dir/fake-path-in-archive/config/config2")
}
err := act()
Expect(err).ToNot(HaveOccurred())
// permission for config files should be readable by all
Expect(int(config1Stats.FileMode)).To(Equal(0644))
Expect(int(config2Stats.FileMode)).To(Equal(0644))
})
}
ItUpdatesPackages := func(act func() error) {
var packageApplier *fakepackages.FakeApplier
BeforeEach(func() {
packageApplier = fakepackages.NewFakeApplier()
packageApplierProvider.JobSpecificAppliers[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(len(jobSupervisor.AddJobArgs)).To(Equal(2))
Expect(jobSupervisor.AddJobArgs[0]).To(Equal(fakejobsuper.AddJobArgs{
Name: job.Name,
Index: 0,
ConfigPath: "/path/to/job/monit",
}))
Expect(jobSupervisor.AddJobArgs[1]).To(Equal(fakejobsuper.AddJobArgs{
Name: job.Name + "_subjob",
Index: 0,
ConfigPath: "/path/to/job/subjob.monit",
}))
})
It("does not require monit script", func() {
job, bundle := buildJob(jobsBc)
fs := fakesys.NewFakeFileSystem()
bundle.GetDirFs = fs
err := applier.Configure(job, 0)
Expect(err).ToNot(HaveOccurred())
Expect(len(jobSupervisor.AddJobArgs)).To(Equal(0))
})
})
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() {
Describe("DrainAction", func() {
var (
notifier *fakenotif.FakeNotifier
specService *fakeas.FakeV1Service
drainScriptProvider *fakedrain.FakeScriptProvider
jobSupervisor *fakejobsuper.FakeJobSupervisor
action DrainAction
logger boshlog.Logger
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
notifier = fakenotif.NewFakeNotifier()
specService = fakeas.NewFakeV1Service()
drainScriptProvider = fakedrain.NewFakeScriptProvider()
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
action = NewDrain(notifier, specService, drainScriptProvider, jobSupervisor, logger)
})
BeforeEach(func() {
drainScriptProvider.NewScriptScript.ExistsBool = true
})
It("is asynchronous", func() {
Expect(action.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(action.IsPersistent()).To(BeFalse())
})
Context("when drain update is requested", func() {
act := func() (int, error) { return action.Run(DrainTypeUpdate, boshas.V1ApplySpec{}) }
Context("when current agent has a job spec template", func() {
var currentSpec boshas.V1ApplySpec
BeforeEach(func() {
currentSpec = boshas.V1ApplySpec{}
currentSpec.JobSpec.Template = "foo"
specService.Spec = currentSpec
})
It("unmonitors services so that drain scripts can kill processes on their own", func() {
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(jobSupervisor.Unmonitored).To(BeTrue())
})
Context("when unmonitoring services succeeds", func() {
It("does not notify of job shutdown", func() {
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(notifier.NotifiedShutdown).To(BeFalse())
})
Context("when new apply spec is provided", func() {
newSpec := boshas.V1ApplySpec{
PackageSpecs: map[string]boshas.PackageSpec{
"foo": boshas.PackageSpec{
Name: "foo",
Sha1: "foo-sha1-new",
},
},
}
Context("when drain script exists", func() {
It("runs drain script with job_shutdown param", func() {
value, err := action.Run(DrainTypeUpdate, newSpec)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(drainScriptProvider.NewScriptTemplateName).To(Equal("foo"))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeTrue())
params := drainScriptProvider.NewScriptScript.RunParams
Expect(params).To(Equal(boshdrain.NewUpdateParams(currentSpec, newSpec)))
})
Context("when drain script runs and errs", func() {
It("returns error", func() {
drainScriptProvider.NewScriptScript.RunError = errors.New("fake-drain-run-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-drain-run-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when drain script does not exist", func() {
It("returns 0", func() {
drainScriptProvider.NewScriptScript.ExistsBool = false
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(0))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeFalse())
})
})
})
Context("when apply spec is not provided", func() {
It("returns error", func() {
value, err := action.Run(DrainTypeUpdate)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Drain update requires new spec"))
Expect(value).To(Equal(0))
})
})
})
Context("when unmonitoring services fails", func() {
It("returns error", func() {
jobSupervisor.UnmonitorErr = errors.New("fake-unmonitor-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-unmonitor-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when current agent spec does not have a job spec template", func() {
It("returns 0 and does not run drain script", func() {
specService.Spec = boshas.V1ApplySpec{}
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(0))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeFalse())
})
})
})
Context("when drain shutdown is requested", func() {
act := func() (int, error) { return action.Run(DrainTypeShutdown) }
Context("when current agent has a job spec template", func() {
var currentSpec boshas.V1ApplySpec
BeforeEach(func() {
currentSpec = boshas.V1ApplySpec{}
currentSpec.JobSpec.Template = "foo"
specService.Spec = currentSpec
})
It("unmonitors services so that drain scripts can kill processes on their own", func() {
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(jobSupervisor.Unmonitored).To(BeTrue())
})
Context("when unmonitoring services succeeds", func() {
It("notifies that job is about to shutdown", func() {
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(notifier.NotifiedShutdown).To(BeTrue())
})
Context("when job shutdown notification succeeds", func() {
Context("when drain script exists", func() {
It("runs drain script with job_shutdown param passing no apply spec", func() {
value, err := action.Run(DrainTypeShutdown)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(drainScriptProvider.NewScriptTemplateName).To(Equal("foo"))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeTrue())
params := drainScriptProvider.NewScriptScript.RunParams
Expect(params).To(Equal(boshdrain.NewShutdownParams(currentSpec, nil)))
})
It("runs drain script with job_shutdown param passing in first apply spec", func() {
newSpec := boshas.V1ApplySpec{}
newSpec.JobSpec.Template = "fake-updated-template"
value, err := action.Run(DrainTypeShutdown, newSpec)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(drainScriptProvider.NewScriptTemplateName).To(Equal("foo"))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeTrue())
params := drainScriptProvider.NewScriptScript.RunParams
Expect(params).To(Equal(boshdrain.NewShutdownParams(currentSpec, &newSpec)))
})
Context("when drain script runs and errs", func() {
It("returns error", func() {
drainScriptProvider.NewScriptScript.RunError = errors.New("fake-drain-run-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-drain-run-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when drain script does not exist", func() {
It("returns 0", func() {
drainScriptProvider.NewScriptScript.ExistsBool = false
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(0))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeFalse())
})
})
})
Context("when job shutdown notification fails", func() {
It("returns error if job shutdown notifications errs", func() {
notifier.NotifyShutdownErr = errors.New("fake-shutdown-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-shutdown-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when unmonitoring services fails", func() {
It("returns error", func() {
jobSupervisor.UnmonitorErr = errors.New("fake-unmonitor-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-unmonitor-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when current agent spec does not have a job spec template", func() {
It("returns 0 and does not run drain script", func() {
specService.Spec = boshas.V1ApplySpec{}
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(0))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeFalse())
})
})
})
Context("when drain status is requested", func() {
act := func() (int, error) { return action.Run(DrainTypeStatus) }
Context("when current agent has a job spec template", func() {
var currentSpec boshas.V1ApplySpec
BeforeEach(func() {
currentSpec = boshas.V1ApplySpec{}
currentSpec.JobSpec.Template = "foo"
specService.Spec = currentSpec
})
It("unmonitors services so that drain scripts can kill processes on their own", func() {
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(jobSupervisor.Unmonitored).To(BeTrue())
})
It("does not notify of job shutdown", func() {
value, err := act()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(notifier.NotifiedShutdown).To(BeFalse())
})
Context("when unmonitoring services succeeds", func() {
Context("when drain script exists", func() {
It("runs drain script with job_check_status param passing no apply spec", func() {
value, err := action.Run(DrainTypeStatus)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(drainScriptProvider.NewScriptTemplateName).To(Equal("foo"))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeTrue())
params := drainScriptProvider.NewScriptScript.RunParams
Expect(params).To(Equal(boshdrain.NewStatusParams(currentSpec, nil)))
})
It("runs drain script with job_check_status param passing in first apply spec", func() {
newSpec := boshas.V1ApplySpec{}
newSpec.JobSpec.Template = "fake-updated-template"
value, err := action.Run(DrainTypeStatus, newSpec)
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal(1))
Expect(drainScriptProvider.NewScriptTemplateName).To(Equal("foo"))
Expect(drainScriptProvider.NewScriptScript.DidRun).To(BeTrue())
params := drainScriptProvider.NewScriptScript.RunParams
Expect(params).To(Equal(boshdrain.NewStatusParams(currentSpec, &newSpec)))
})
Context("when drain script runs and errs", func() {
It("returns error if drain script errs", func() {
drainScriptProvider.NewScriptScript.RunError = errors.New("fake-drain-run-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-drain-run-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when drain script does not exist", func() {
It("returns error because drain status must be called after starting draining", func() {
drainScriptProvider.NewScriptScript.ExistsBool = false
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Check Status on Drain action requires a valid drain script"))
Expect(value).To(Equal(0))
})
})
})
Context("when unmonitoring services fails", func() {
It("returns error if unmonitoring services errs", func() {
jobSupervisor.UnmonitorErr = errors.New("fake-unmonitor-error")
value, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-unmonitor-error"))
Expect(value).To(Equal(0))
})
})
})
Context("when current agent spec does not have a job spec template", func() {
It("returns error because drain status should only be called after starting draining", func() {
specService.Spec = boshas.V1ApplySpec{}
value, err := action.Run(DrainTypeStatus)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Check Status on Drain action requires job spec"))
Expect(value).To(Equal(0))
})
})
})
})
}
func init() {
Describe("natsHandler", func() {
var (
settingsService *fakesettings.FakeSettingsService
client *fakeyagnats.FakeYagnats
logger boshlog.Logger
handler boshhandler.Handler
)
BeforeEach(func() {
settingsService = &fakesettings.FakeSettingsService{
Settings: boshsettings.Settings{
AgentID: "my-agent-id",
Mbus: "nats://*****:*****@127.0.0.1:1234",
},
}
logger = boshlog.NewLogger(boshlog.LevelNone)
client = fakeyagnats.New()
handler = NewNatsHandler(settingsService, client, logger)
})
Describe("Start", func() {
It("starts", func() {
var receivedRequest boshhandler.Request
handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) {
receivedRequest = req
return boshhandler.NewValueResponse("expected value")
})
defer handler.Stop()
Expect(client.ConnectedConnectionProvider()).ToNot(BeNil())
Expect(client.SubscriptionCount()).To(Equal(1))
subscriptions := client.Subscriptions("agent.my-agent-id")
Expect(len(subscriptions)).To(Equal(1))
expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`)
subscription := subscriptions[0]
subscription.Callback(&yagnats.Message{
Subject: "agent.my-agent-id",
Payload: expectedPayload,
})
Expect(receivedRequest).To(Equal(boshhandler.Request{
ReplyTo: "reply to me!",
Method: "ping",
Payload: expectedPayload,
}))
Expect(client.PublishedMessageCount()).To(Equal(1))
messages := client.PublishedMessages("reply to me!")
Expect(len(messages)).To(Equal(1))
Expect(messages[0].Payload).To(Equal([]byte(`{"value":"expected value"}`)))
})
It("does not respond if the response is nil", func() {
err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) {
return nil
})
Expect(err).ToNot(HaveOccurred())
defer handler.Stop()
subscription := client.Subscriptions("agent.my-agent-id")[0]
subscription.Callback(&yagnats.Message{
Subject: "agent.my-agent-id",
Payload: []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "reply to me!"}`),
})
Expect(client.PublishedMessageCount()).To(Equal(0))
})
It("responds with an error if the response is bigger than 1MB", func() {
err := handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) {
// gets inflated by json.Marshal when enveloping
size := 0
switch req.Method {
case "small":
size = 1024*1024 - 12
case "big":
size = 1024 * 1024
default:
panic("unknown request size")
}
chars := make([]byte, size)
for i := range chars {
chars[i] = 'A'
}
return boshhandler.NewValueResponse(string(chars))
})
Expect(err).ToNot(HaveOccurred())
defer handler.Stop()
subscription := client.Subscriptions("agent.my-agent-id")[0]
subscription.Callback(&yagnats.Message{
Subject: "agent.my-agent-id",
Payload: []byte(`{"method":"small","arguments":[], "reply_to": "fake-reply-to"}`),
})
subscription.Callback(&yagnats.Message{
Subject: "agent.my-agent-id",
Payload: []byte(`{"method":"big","arguments":[], "reply_to": "fake-reply-to"}`),
})
Expect(client.PublishedMessageCount()).To(Equal(1))
messages := client.PublishedMessages("fake-reply-to")
Expect(len(messages)).To(Equal(2))
Expect(messages[0].Payload).To(MatchRegexp("value"))
Expect(messages[1].Payload).To(Equal([]byte(
`{"exception":{"message":"Response exceeded maximum allowed length"}}`)))
})
It("can add additional handler funcs to receive requests", func() {
var firstHandlerReq, secondHandlerRequest boshhandler.Request
handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) {
firstHandlerReq = req
return boshhandler.NewValueResponse("first-handler-resp")
})
defer handler.Stop()
handler.RegisterAdditionalFunc(func(req boshhandler.Request) (resp boshhandler.Response) {
secondHandlerRequest = req
return boshhandler.NewValueResponse("second-handler-resp")
})
expectedPayload := []byte(`{"method":"ping","arguments":["foo","bar"], "reply_to": "fake-reply-to"}`)
subscription := client.Subscriptions("agent.my-agent-id")[0]
subscription.Callback(&yagnats.Message{
Subject: "agent.my-agent-id",
Payload: expectedPayload,
})
// Expected requests received by both handlers
Expect(firstHandlerReq).To(Equal(boshhandler.Request{
ReplyTo: "fake-reply-to",
Method: "ping",
Payload: expectedPayload,
}))
Expect(secondHandlerRequest).To(Equal(boshhandler.Request{
ReplyTo: "fake-reply-to",
Method: "ping",
Payload: expectedPayload,
}))
// Bosh handler responses were sent
Expect(client.PublishedMessageCount()).To(Equal(1))
messages := client.PublishedMessages("fake-reply-to")
Expect(len(messages)).To(Equal(2))
Expect(messages[0].Payload).To(Equal([]byte(`{"value":"first-handler-resp"}`)))
Expect(messages[1].Payload).To(Equal([]byte(`{"value":"second-handler-resp"}`)))
})
It("has the correct connection info", func() {
err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return })
Expect(err).ToNot(HaveOccurred())
defer handler.Stop()
Expect(client.ConnectedConnectionProvider()).To(Equal(&yagnats.ConnectionInfo{
Addr: "127.0.0.1:1234",
Username: "******",
Password: "******",
}))
})
It("does not err when no username and password", func() {
settingsService.Settings.Mbus = "nats://127.0.0.1:1234"
handler = NewNatsHandler(settingsService, client, logger)
err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return })
Expect(err).ToNot(HaveOccurred())
defer handler.Stop()
})
It("errs when has username without password", func() {
settingsService.Settings.Mbus = "nats://[email protected]:1234"
handler = NewNatsHandler(settingsService, client, logger)
err := handler.Start(func(req boshhandler.Request) (res boshhandler.Response) { return })
Expect(err).To(HaveOccurred())
defer handler.Stop()
})
})
Describe("Send", func() {
It("sends the message over nats to a subject that includes the target and topic", func() {
errCh := make(chan error, 1)
payload := map[string]string{"key1": "value1", "keyA": "valueA"}
go func() {
errCh <- handler.Send(boshhandler.HealthMonitor, boshhandler.Heartbeat, payload)
}()
var err error
select {
case err = <-errCh:
}
Expect(err).ToNot(HaveOccurred())
Expect(client.PublishedMessageCount()).To(Equal(1))
messages := client.PublishedMessages("hm.agent.heartbeat.my-agent-id")
Expect(messages).To(HaveLen(1))
Expect(messages[0].Payload).To(Equal(
[]byte("{\"key1\":\"value1\",\"keyA\":\"valueA\"}"),
))
})
})
})
}
func describeInterfaceConfigurationCreator() {
var (
interfaceConfigurationCreator InterfaceConfigurationCreator
staticNetwork boshsettings.Network
staticNetworkWithoutMAC boshsettings.Network
dhcpNetwork boshsettings.Network
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
interfaceConfigurationCreator = NewInterfaceConfigurationCreator(logger)
dhcpNetwork = boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-dhcp-mac-address",
}
staticNetwork = boshsettings.Network{
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
staticNetworkWithoutMAC = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
})
Describe("CreateInterfaceConfigurations", func() {
var networks boshsettings.Networks
var interfacesByMAC map[string]string
BeforeEach(func() {
networks = boshsettings.Networks{}
interfacesByMAC = map[string]string{}
})
Context("One network", func() {
Context("And the network has a MAC address", func() {
BeforeEach(func() {
networks["foo"] = staticNetwork
})
Context("And the MAC address matches an interface", func() {
BeforeEach(func() {
interfacesByMAC[staticNetwork.Mac] = "static-interface-name"
})
It("creates an interface configuration when matching interface exists", func() {
staticInterfaceConfigurations, dhcpInterfaceConfigurations, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).ToNot(HaveOccurred())
Expect(staticInterfaceConfigurations).To(Equal([]StaticInterfaceConfiguration{
StaticInterfaceConfiguration{
Name: "static-interface-name",
Address: "1.2.3.4",
Netmask: "255.255.255.0",
Network: "1.2.3.0",
Broadcast: "1.2.3.255",
Mac: "fake-static-mac-address",
Gateway: "3.4.5.6",
},
}))
Expect(len(dhcpInterfaceConfigurations)).To(Equal(0))
})
})
Context("And the MAC address has no matching an interface", func() {
BeforeEach(func() {
interfacesByMAC["some-other-mac"] = "static-interface-name"
})
It("retuns an error", func() {
_, _, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("No device found"))
Expect(err.Error()).To(ContainSubstring(staticNetwork.Mac))
Expect(err.Error()).To(ContainSubstring("foo"))
})
})
})
Context("Does not have a MAC address", func() {
BeforeEach(func() {
networks["foo"] = staticNetworkWithoutMAC
})
Context("And at least one device is available", func() {
BeforeEach(func() {
interfacesByMAC["fake-any-mac-address"] = "any-interface-name"
})
It("creates an interface configuration even with the MAC address from first interface with device", func() {
staticInterfaceConfigurations, dhcpInterfaceConfigurations, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).ToNot(HaveOccurred())
Expect(staticInterfaceConfigurations).To(Equal([]StaticInterfaceConfiguration{
StaticInterfaceConfiguration{
Name: "any-interface-name",
Address: "1.2.3.4",
Netmask: "255.255.255.0",
Network: "1.2.3.0",
Broadcast: "1.2.3.255",
Mac: "fake-any-mac-address",
Gateway: "3.4.5.6",
},
}))
Expect(len(dhcpInterfaceConfigurations)).To(Equal(0))
})
})
Context("And there are no network devices", func() {
BeforeEach(func() {
interfacesByMAC = map[string]string{}
})
It("retuns an error", func() {
_, _, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Number of network settings '1' is greater than the number of network devices '0'"))
})
})
})
})
Context("Multiple networks", func() {
Context("when the number of networks matches the number of devices", func() {
Context("and every interface has a matching networks, by MAC address", func() {
BeforeEach(func() {
networks["foo"] = staticNetwork
networks["bar"] = dhcpNetwork
interfacesByMAC[staticNetwork.Mac] = "static-interface-name"
interfacesByMAC[dhcpNetwork.Mac] = "dhcp-interface-name"
})
It("creates interface configurations for each network when matching interfaces exist", func() {
staticInterfaceConfigurations, dhcpInterfaceConfigurations, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).ToNot(HaveOccurred())
Expect(staticInterfaceConfigurations).To(Equal([]StaticInterfaceConfiguration{
StaticInterfaceConfiguration{
Name: "static-interface-name",
Address: "1.2.3.4",
Netmask: "255.255.255.0",
Network: "1.2.3.0",
Broadcast: "1.2.3.255",
Mac: "fake-static-mac-address",
Gateway: "3.4.5.6",
},
}))
Expect(dhcpInterfaceConfigurations).To(Equal([]DHCPInterfaceConfiguration{
DHCPInterfaceConfiguration{
Name: "dhcp-interface-name",
},
}))
})
})
Context("and some networks have no MAC address", func() {
BeforeEach(func() {
networks["foo"] = staticNetworkWithoutMAC
networks["bar"] = dhcpNetwork
interfacesByMAC["some-other-mac"] = "other-interface-name"
interfacesByMAC[dhcpNetwork.Mac] = "dhcp-interface-name"
})
It("creates interface configurations for each network when matching interfaces exist, and sets non-matching interfaces as DHCP", func() {
staticInterfaceConfigurations, dhcpInterfaceConfigurations, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).ToNot(HaveOccurred())
Expect(staticInterfaceConfigurations).To(BeEmpty())
Expect(dhcpInterfaceConfigurations).To(ConsistOf(
DHCPInterfaceConfiguration{
Name: "dhcp-interface-name",
},
DHCPInterfaceConfiguration{
Name: "other-interface-name",
},
))
})
})
Context("and some networks MAC addresses that don't match", func() {
BeforeEach(func() {
networks["foo"] = staticNetwork
networks["bar"] = dhcpNetwork
interfacesByMAC["some-other-mac"] = "static-interface-name"
interfacesByMAC[dhcpNetwork.Mac] = "dhcp-interface-name"
})
It("retuns an error", func() {
_, _, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).To(HaveOccurred())
})
})
})
})
Context("when the number of networks does not match the number of devices", func() {
BeforeEach(func() {
networks["foo"] = staticNetwork
networks["bar"] = dhcpNetwork
networks["baz"] = staticNetworkWithoutMAC
interfacesByMAC["some-other-mac"] = "static-interface-name"
interfacesByMAC[dhcpNetwork.Mac] = "dhcp-interface-name"
})
It("retuns an error", func() {
_, _, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMAC)
Expect(err).To(HaveOccurred())
})
})
})
It("wraps errors calculating Network and Broadcast addresses", func() {
invalidNetwork := boshsettings.Network{
Type: "manual",
IP: "not an ip",
Netmask: "not a valid mask",
Mac: "invalid-network-mac-address",
}
interfacesByMAC := map[string]string{
"invalid-network-mac-address": "static-interface-name",
}
_, _, err := interfaceConfigurationCreator.CreateInterfaceConfigurations(boshsettings.Networks{"foo": invalidNetwork}, interfacesByMAC)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Invalid ip or netmask"))
})
}
func describeHTTPMetadataService() {
var (
dnsResolver *fakeinf.FakeDNSResolver
platform *fakeplat.FakePlatform
logger boshlog.Logger
metadataService MetadataService
)
BeforeEach(func() {
dnsResolver = &fakeinf.FakeDNSResolver{}
platform = fakeplat.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
metadataService = NewHTTPMetadataService("fake-metadata-host", dnsResolver, platform, logger)
})
ItEnsuresMinimalNetworkSetup := func(subject func() (string, error)) {
Context("when no networks are configured", func() {
BeforeEach(func() {
platform.GetConfiguredNetworkInterfacesInterfaces = []string{}
})
It("sets up DHCP network", func() {
_, err := subject()
Expect(err).ToNot(HaveOccurred())
Expect(platform.SetupNetworkingCalled).To(BeTrue())
Expect(platform.SetupNetworkingNetworks).To(Equal(boshsettings.Networks{
"eth0": boshsettings.Network{
Type: "dynamic",
},
}))
})
Context("when setting up DHCP fails", func() {
BeforeEach(func() {
platform.SetupNetworkingErr = errors.New("fake-network-error")
})
It("returns an error", func() {
_, err := subject()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-network-error"))
})
})
})
}
Describe("IsAvailable", func() {
It("returns true", func() {
Expect(metadataService.IsAvailable()).To(BeTrue())
})
})
Describe("GetPublicKey", func() {
var (
ts *httptest.Server
)
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/meta-data/public-keys/0/openssh-key"))
w.Write([]byte("fake-public-key"))
})
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetPublicKey()
})
It("returns fetched public key", func() {
publicKey, err := metadataService.GetPublicKey()
Expect(err).NotTo(HaveOccurred())
Expect(publicKey).To(Equal("fake-public-key"))
})
})
Describe("GetInstanceID", func() {
var (
ts *httptest.Server
)
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/meta-data/instance-id"))
w.Write([]byte("fake-instance-id"))
})
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetInstanceID()
})
It("returns fetched instance id", func() {
publicKey, err := metadataService.GetInstanceID()
Expect(err).NotTo(HaveOccurred())
Expect(publicKey).To(Equal("fake-instance-id"))
})
})
Describe("GetServerName", func() {
var (
ts *httptest.Server
serverName *string
)
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/user-data"))
var jsonStr string
if serverName == nil {
jsonStr = `{}`
} else {
jsonStr = fmt.Sprintf(`{"server":{"name":"%s"}}`, *serverName)
}
w.Write([]byte(jsonStr))
}
BeforeEach(func() {
serverName = nil
handler := http.HandlerFunc(handlerFunc)
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
Context("when the server name is present in the JSON", func() {
BeforeEach(func() {
name := "fake-server-name"
serverName = &name
})
It("returns the server name", func() {
name, err := metadataService.GetServerName()
Expect(err).ToNot(HaveOccurred())
Expect(name).To(Equal("fake-server-name"))
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetServerName()
})
})
Context("when the server name is not present in the JSON", func() {
BeforeEach(func() {
serverName = nil
})
It("returns an error", func() {
name, err := metadataService.GetServerName()
Expect(err).To(HaveOccurred())
Expect(name).To(BeEmpty())
})
})
})
Describe("GetRegistryEndpoint", func() {
var (
ts *httptest.Server
registryURL *string
dnsServer *string
)
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/user-data"))
var jsonStr string
if dnsServer == nil {
jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL)
} else {
jsonStr = fmt.Sprintf(`{
"registry":{"endpoint":"%s"},
"dns":{"nameserver":["%s"]}
}`, *registryURL, *dnsServer)
}
w.Write([]byte(jsonStr))
}
BeforeEach(func() {
url := "http://fake-registry.com"
registryURL = &url
dnsServer = nil
handler := http.HandlerFunc(handlerFunc)
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetRegistryEndpoint()
})
Context("when metadata contains a dns server", func() {
BeforeEach(func() {
server := "fake-dns-server-ip"
dnsServer = &server
})
Context("when registry endpoint is successfully resolved", func() {
BeforeEach(func() {
dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{
DNSServers: []string{"fake-dns-server-ip"},
Host: "http://fake-registry.com",
IP: "http://fake-registry-ip",
})
})
It("returns the successfully resolved registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry-ip"))
})
})
Context("when registry endpoint is not successfully resolved", func() {
BeforeEach(func() {
dnsResolver.LookupHostErr = errors.New("fake-lookup-host-err")
})
It("returns error because it failed to resolve registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err"))
Expect(endpoint).To(BeEmpty())
})
})
})
Context("when metadata does not contain dns servers", func() {
It("returns fetched registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).NotTo(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry.com"))
})
})
})
Describe("GetNetworks", func() {
It("returns nil networks, since you don't need them for bootstrapping since your network must be set up before you can get the metadata", func() {
Expect(metadataService.GetNetworks()).To(BeNil())
})
})
}
func init() {
Describe("Agent", func() {
var (
logger boshlog.Logger
handler *fakembus.FakeHandler
platform *fakeplatform.FakePlatform
actionDispatcher *fakeagent.FakeActionDispatcher
jobSupervisor *fakejobsuper.FakeJobSupervisor
specService *fakeas.FakeV1Service
syslogServer *fakesyslog.FakeServer
settingsService *fakesettings.FakeSettingsService
uuidGenerator *fakeuuid.FakeGenerator
timeService *fakeclock.FakeClock
agent Agent
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
handler = &fakembus.FakeHandler{}
platform = fakeplatform.NewFakePlatform()
actionDispatcher = &fakeagent.FakeActionDispatcher{}
jobSupervisor = fakejobsuper.NewFakeJobSupervisor()
specService = fakeas.NewFakeV1Service()
syslogServer = &fakesyslog.FakeServer{}
settingsService = &fakesettings.FakeSettingsService{}
uuidGenerator = &fakeuuid.FakeGenerator{}
timeService = fakeclock.NewFakeClock(time.Now())
agent = New(
logger,
handler,
platform,
actionDispatcher,
jobSupervisor,
specService,
syslogServer,
5*time.Millisecond,
settingsService,
uuidGenerator,
timeService,
)
})
Describe("Run", func() {
It("lets dispatcher handle requests arriving via handler", func() {
err := agent.Run()
Expect(err).ToNot(HaveOccurred())
expectedResp := boshhandler.NewValueResponse("pong")
actionDispatcher.DispatchResp = expectedResp
req := boshhandler.NewRequest("fake-reply", "fake-action", []byte("fake-payload"))
resp := handler.RunFunc(req)
Expect(actionDispatcher.DispatchReq).To(Equal(req))
Expect(resp).To(Equal(expectedResp))
})
It("resumes persistent actions *before* dispatching new requests", func() {
resumedBeforeStartingToDispatch := false
handler.RunCallBack = func() {
resumedBeforeStartingToDispatch = actionDispatcher.ResumedPreviouslyDispatchedTasks
}
err := agent.Run()
Expect(err).ToNot(HaveOccurred())
Expect(resumedBeforeStartingToDispatch).To(BeTrue())
})
Context("when heartbeats can be sent", func() {
BeforeEach(func() {
handler.KeepOnRunning()
})
BeforeEach(func() {
jobName := "fake-job"
jobIndex := 1
specService.Spec = boshas.V1ApplySpec{
JobSpec: boshas.JobSpec{Name: &jobName},
Index: &jobIndex,
}
jobSupervisor.StatusStatus = "fake-state"
platform.FakeVitalsService.GetVitals = boshvitals.Vitals{
Load: []string{"a", "b", "c"},
}
})
expectedJobName := "fake-job"
expectedJobIndex := 1
expectedHb := Heartbeat{
Job: &expectedJobName,
Index: &expectedJobIndex,
JobState: "fake-state",
Vitals: boshvitals.Vitals{Load: []string{"a", "b", "c"}},
}
It("sends initial heartbeat", func() {
// Configure periodic heartbeat every 5 hours
// so that we are sure that we will not receive it
agent = New(
logger,
handler,
platform,
actionDispatcher,
jobSupervisor,
specService,
syslogServer,
5*time.Hour,
settingsService,
uuidGenerator,
timeService,
)
// Immediately exit after sending initial heartbeat
handler.SendErr = errors.New("stop")
err := agent.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("stop"))
Expect(handler.SendInputs()).To(Equal([]fakembus.SendInput{
{
Target: boshhandler.HealthMonitor,
Topic: boshhandler.Heartbeat,
Message: expectedHb,
},
}))
})
It("sends periodic heartbeats", func() {
sentRequests := 0
handler.SendCallback = func(_ fakembus.SendInput) {
sentRequests++
if sentRequests == 3 {
handler.SendErr = errors.New("stop")
}
}
err := agent.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("stop"))
Expect(handler.SendInputs()).To(Equal([]fakembus.SendInput{
{
Target: boshhandler.HealthMonitor,
Topic: boshhandler.Heartbeat,
Message: expectedHb,
},
{
Target: boshhandler.HealthMonitor,
Topic: boshhandler.Heartbeat,
Message: expectedHb,
},
{
Target: boshhandler.HealthMonitor,
Topic: boshhandler.Heartbeat,
Message: expectedHb,
},
}))
})
})
Context("when the agent fails to get job spec for a heartbeat", func() {
BeforeEach(func() {
specService.GetErr = errors.New("fake-spec-service-error")
handler.KeepOnRunning()
})
It("returns the error", func() {
err := agent.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-spec-service-error"))
})
})
Context("when the agent fails to get vitals for a heartbeat", func() {
BeforeEach(func() {
platform.FakeVitalsService.GetErr = errors.New("fake-vitals-service-error")
handler.KeepOnRunning()
})
It("returns the error", func() {
err := agent.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-vitals-service-error"))
})
})
It("sends job monitoring alerts to health manager", func() {
handler.KeepOnRunning()
monitAlert := boshalert.MonitAlert{
ID: "fake-monit-alert",
Service: "fake-service",
Event: "fake-event",
Action: "fake-action",
Date: "Sun, 22 May 2011 20:07:41 +0500",
Description: "fake-description",
}
jobSupervisor.JobFailureAlert = &monitAlert
// Fail the first time handler.Send is called for an alert (ignore heartbeats)
handler.SendCallback = func(input fakembus.SendInput) {
if input.Topic == boshhandler.Alert {
handler.SendErr = errors.New("stop")
}
}
err := agent.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("stop"))
expectedAlert := boshalert.Alert{
ID: "fake-monit-alert",
Severity: boshalert.SeverityDefault,
Title: "fake-service - fake-event - fake-action",
Summary: "fake-description",
CreatedAt: int64(1306076861),
}
Expect(handler.SendInputs()).To(ContainElement(fakembus.SendInput{
Target: boshhandler.HealthMonitor,
Topic: boshhandler.Alert,
Message: expectedAlert,
}))
})
It("sends ssh alerts to health manager", func() {
handler.KeepOnRunning()
syslogMsg := boshsyslog.Msg{Content: "disconnected by user"}
syslogServer.StartFirstSyslogMsg = &syslogMsg
uuidGenerator.GeneratedUUID = "fake-uuid"
// Fail the first time handler.Send is called for an alert (ignore heartbeats)
handler.SendCallback = func(input fakembus.SendInput) {
if input.Topic == boshhandler.Alert {
handler.SendErr = errors.New("stop")
}
}
err := agent.Run()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("stop"))
expectedAlert := boshalert.Alert{
ID: "fake-uuid",
Severity: boshalert.SeverityWarning,
Title: "SSH Logout",
Summary: "disconnected by user",
CreatedAt: timeService.Now().Unix(),
}
Expect(handler.SendInputs()).To(ContainElement(fakembus.SendInput{
Target: boshhandler.HealthMonitor,
Topic: boshhandler.Alert,
Message: expectedAlert,
}))
})
})
})
}
func init() {
Describe("execCmdRunner", func() {
var (
runner CmdRunner
)
BeforeEach(func() {
runner = NewExecCmdRunner(boshlog.NewLogger(boshlog.LevelNone))
})
Describe("RunComplexCommand", func() {
It("run complex command with working directory", func() {
cmd := Command{
Name: "ls",
Args: []string{"-l"},
WorkingDir: ".",
}
stdout, stderr, status, err := runner.RunComplexCommand(cmd)
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(ContainSubstring("exec_cmd_runner_fixtures"))
Expect(stdout).To(ContainSubstring("total"))
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
})
It("run complex command with env", func() {
cmd := Command{
Name: "env",
Env: map[string]string{
"FOO": "BAR",
},
}
stdout, stderr, status, err := runner.RunComplexCommand(cmd)
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(ContainSubstring("FOO=BAR"))
Expect(stdout).To(ContainSubstring("PATH="))
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
})
It("runs complex command with specific env", func() {
cmd := Command{
Name: "env",
Env: map[string]string{
"FOO": "BAR",
},
UseIsolatedEnv: true,
}
stdout, stderr, status, err := runner.RunComplexCommand(cmd)
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(ContainSubstring("FOO=BAR"))
Expect(stdout).ToNot(ContainSubstring("PATH="))
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
})
It("run complex command with stdin", func() {
input := "This is STDIN\nWith another line."
cmd := Command{
Name: "cat",
Args: []string{"/dev/stdin"},
Stdin: strings.NewReader(input),
}
stdout, stderr, status, err := runner.RunComplexCommand(cmd)
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(Equal(input))
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
})
It("prints stdout/stderr to provided I/O object", func() {
fs := fakesys.NewFakeFileSystem()
stdoutFile, err := fs.OpenFile("/fake-stdout-path", os.O_RDWR, os.FileMode(0644))
Expect(err).ToNot(HaveOccurred())
stderrFile, err := fs.OpenFile("/fake-stderr-path", os.O_RDWR, os.FileMode(0644))
Expect(err).ToNot(HaveOccurred())
cmd := Command{
Name: "bash",
Args: []string{"-c", "echo fake-out >&1; echo fake-err >&2"},
Stdout: stdoutFile,
Stderr: stderrFile,
}
stdout, stderr, status, err := runner.RunComplexCommand(cmd)
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(BeEmpty())
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
stdoutContents := make([]byte, 1024)
_, err = stdoutFile.Read(stdoutContents)
Expect(err).ToNot(HaveOccurred())
Expect(string(stdoutContents)).To(ContainSubstring("fake-out"))
stderrContents := make([]byte, 1024)
_, err = stderrFile.Read(stderrContents)
Expect(err).ToNot(HaveOccurred())
Expect(string(stderrContents)).To(ContainSubstring("fake-err"))
})
})
Describe("RunComplexCommandAsync", func() {
It("populates stdout and stderr", func() {
cmd := Command{Name: "ls"}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
result := <-process.Wait()
Expect(result.Error).ToNot(HaveOccurred())
Expect(result.ExitStatus).To(Equal(0))
})
It("populates stdout and stderr", func() {
cmd := Command{Name: "bash", Args: []string{"-c", "echo stdout >&1; echo stderr >&2"}}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
result := <-process.Wait()
Expect(result.Error).ToNot(HaveOccurred())
Expect(result.Stdout).To(Equal("stdout\n"))
Expect(result.Stderr).To(Equal("stderr\n"))
})
It("returns error and sets status to exit status of comamnd if it command exits with non-0 status", func() {
cmd := Command{Name: "bash", Args: []string{"-c", "exit 10"}}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
result := <-process.Wait()
Expect(result.Error).To(HaveOccurred())
Expect(result.ExitStatus).To(Equal(10))
})
It("allows setting custom env variable in addition to inheriting process env variables", func() {
cmd := Command{
Name: "env",
Env: map[string]string{
"FOO": "BAR",
},
}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
result := <-process.Wait()
Expect(result.Error).ToNot(HaveOccurred())
Expect(result.Stdout).To(ContainSubstring("FOO=BAR"))
Expect(result.Stdout).To(ContainSubstring("PATH="))
})
It("changes working dir", func() {
cmd := Command{Name: "bash", Args: []string{"-c", "echo $PWD"}, WorkingDir: "/tmp"}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
result := <-process.Wait()
Expect(result.Error).ToNot(HaveOccurred())
Expect(result.Stdout).To(ContainSubstring("/tmp"))
})
})
Describe("RunCommand", func() {
It("run command", func() {
stdout, stderr, status, err := runner.RunCommand("echo", "Hello World!")
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(Equal("Hello World!\n"))
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
})
It("run command with error output", func() {
stdout, stderr, status, err := runner.RunCommand("bash", "-c", "echo error-output >&2")
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(BeEmpty())
Expect(stderr).To(ContainSubstring("error-output"))
Expect(status).To(Equal(0))
})
It("run command with non-0 exit status", func() {
stdout, stderr, status, err := runner.RunCommand("bash", "-c", "exit 14")
Expect(err).To(HaveOccurred())
Expect(stdout).To(BeEmpty())
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(14))
})
It("run command with error", func() {
stdout, stderr, status, err := runner.RunCommand("false")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("Running command: 'false', stdout: '', stderr: '': exit status 1"))
Expect(stderr).To(BeEmpty())
Expect(stdout).To(BeEmpty())
Expect(status).To(Equal(1))
})
It("run command with error with args", func() {
stdout, stderr, status, err := runner.RunCommand("false", "second arg")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("Running command: 'false second arg', stdout: '', stderr: '': exit status 1"))
Expect(stderr).To(BeEmpty())
Expect(stdout).To(BeEmpty())
Expect(status).To(Equal(1))
})
It("run command with cmd not found", func() {
stdout, stderr, status, err := runner.RunCommand("something that does not exist")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("not found"))
Expect(stderr).To(BeEmpty())
Expect(stdout).To(BeEmpty())
Expect(status).To(Equal(-1))
})
})
Describe("CommandExists", func() {
It("run command with input", func() {
stdout, stderr, status, err := runner.RunCommandWithInput("foo\nbar\nbaz", "grep", "ba")
Expect(err).ToNot(HaveOccurred())
Expect(stdout).To(Equal("bar\nbaz\n"))
Expect(stderr).To(BeEmpty())
Expect(status).To(Equal(0))
})
})
Describe("CommandExists", func() {
It("command exists", func() {
Expect(runner.CommandExists("env")).To(BeTrue())
Expect(runner.CommandExists("absolutely-does-not-exist-ever-please-unicorns")).To(BeFalse())
})
})
})
Describe("execProcess", func() {
var (
runner CmdRunner
)
BeforeEach(func() {
runner = NewExecCmdRunner(boshlog.NewLogger(boshlog.LevelNone))
})
Describe("TerminateNicely", func() {
var (
buildDir string
)
hasProcessesFromBuildDir := func() (bool, string) {
// Make sure to show all processes on the system
output, err := exec.Command("ps", "-A", "-o", "pid,args").Output()
Expect(err).ToNot(HaveOccurred())
// Cannot check for PID existence directly because
// PID could have been recycled by the OS; make sure it's not the same process
for _, line := range strings.Split(strings.TrimSpace(string(output)), "\n") {
if strings.Contains(line, buildDir) {
return true, line
}
}
return false, ""
}
expectProcessesToNotExist := func() {
exists, ps := hasProcessesFromBuildDir()
Expect(exists).To(BeFalse(), "Expected following process to not exist %s", ps)
}
BeforeEach(func() {
var (
err error
)
buildDir, err = ioutil.TempDir("", "TerminateNicely")
Expect(err).ToNot(HaveOccurred())
exesToCompile := []string{
"exe_exits",
"child_ignore_term",
"child_term",
"parent_ignore_term",
"parent_term",
}
for _, exe := range exesToCompile {
dst := filepath.Join(buildDir, exe)
src := filepath.Join("exec_cmd_runner_fixtures", exe+".go")
err := exec.Command("go", "build", "-o", dst, src).Run()
Expect(err).ToNot(HaveOccurred())
}
})
AfterEach(func() {
os.RemoveAll(buildDir)
})
Context("when parent and child terminate after receiving SIGTERM", func() {
It("sends term signal to the whole group and returns with exit status that parent exited", func() {
cmd := Command{Name: filepath.Join(buildDir, "parent_term")}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
// Wait for script to start and output pids
time.Sleep(2 * time.Second)
waitCh := process.Wait()
err = process.TerminateNicely(1 * time.Minute)
Expect(err).ToNot(HaveOccurred())
result := <-waitCh
Expect(result.Error).To(HaveOccurred())
// Parent exit code is returned
// bash adds 128 to signal status as exit code
Expect(result.ExitStatus).To(Equal(13))
// Term signal was sent to all processes in the group
Expect(result.Stdout).To(ContainSubstring("Parent received SIGTERM"))
Expect(result.Stdout).To(ContainSubstring("Child received SIGTERM"))
// All processes are gone
expectProcessesToNotExist()
})
})
Context("when parent and child do not exit after receiving SIGTERM in small amount of time", func() {
It("sends kill signal to the whole group and returns with ? exit status", func() {
cmd := Command{Name: filepath.Join(buildDir, "parent_ignore_term")}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
// Wait for script to start and output pids
time.Sleep(2 * time.Second)
waitCh := process.Wait()
err = process.TerminateNicely(2 * time.Second)
Expect(err).ToNot(HaveOccurred())
result := <-waitCh
Expect(result.Error).To(HaveOccurred())
// Parent exit code is returned
Expect(result.ExitStatus).To(Equal(128 + 9))
// Term signal was sent to all processes in the group before kill
Expect(result.Stdout).To(ContainSubstring("Parent received SIGTERM"))
Expect(result.Stdout).To(ContainSubstring("Child received SIGTERM"))
// Parent and child are killed
expectProcessesToNotExist()
})
})
Context("when parent and child already exited before calling TerminateNicely", func() {
It("returns without an error since all processes are gone", func() {
cmd := Command{Name: filepath.Join(buildDir, "exe_exits")}
process, err := runner.RunComplexCommandAsync(cmd)
Expect(err).ToNot(HaveOccurred())
// Wait for script to exit
for i := 0; i < 20; i++ {
if exists, _ := hasProcessesFromBuildDir(); !exists {
break
}
if i == 19 {
Fail("Expected process did not exit fast enough")
}
time.Sleep(500 * time.Millisecond)
}
waitCh := process.Wait()
err = process.TerminateNicely(2 * time.Second)
Expect(err).ToNot(HaveOccurred())
result := <-waitCh
Expect(result.Error).ToNot(HaveOccurred())
Expect(result.Stdout).To(Equal(""))
Expect(result.Stderr).To(Equal(""))
Expect(result.ExitStatus).To(Equal(0))
})
})
})
})
Describe("ExecError", func() {
Describe("Error", func() {
It("returns error message with full stdout and full stderr to aid debugging", func() {
execErr := NewExecError("fake-cmd", "fake-stdout", "fake-stderr")
expectedMsg := "Running command: 'fake-cmd', stdout: 'fake-stdout', stderr: 'fake-stderr'"
Expect(execErr.Error()).To(Equal(expectedMsg))
})
})
Describe("ShortError", func() {
buildLines := func(start, stop int, suffix string) string {
var result []string
for i := start; i <= stop; i++ {
result = append(result, fmt.Sprintf("%d %s", i, suffix))
}
return strings.Join(result, "\n")
}
Context("when stdout and stderr contains more than 100 lines", func() {
It("returns error message with truncated stdout and stderr to 100 lines", func() {
fullStdout101 := buildLines(1, 101, "stdout")
truncatedStdout100 := buildLines(2, 101, "stdout")
fullStderr101 := buildLines(1, 101, "stderr")
truncatedStderr100 := buildLines(2, 101, "stderr")
execErr := NewExecError("fake-cmd", fullStdout101, fullStderr101)
expectedMsg := fmt.Sprintf(
"Running command: 'fake-cmd', stdout: '%s', stderr: '%s'",
truncatedStdout100, truncatedStderr100,
)
Expect(execErr.ShortError()).To(Equal(expectedMsg))
})
})
Context("when stdout and stderr contains exactly 100 lines", func() {
It("returns error message with full lines", func() {
stdout100 := buildLines(1, 100, "stdout")
stderr100 := buildLines(1, 100, "stderr")
execErr := NewExecError("fake-cmd", stdout100, stderr100)
expectedMsg := fmt.Sprintf("Running command: 'fake-cmd', stdout: '%s', stderr: '%s'", stdout100, stderr100)
Expect(execErr.ShortError()).To(Equal(expectedMsg))
})
})
Context("when stdout and stderr contains less than 100 lines", func() {
It("returns error message with full lines", func() {
stdout99 := buildLines(1, 99, "stdout")
stderr99 := buildLines(1, 99, "stderr")
execErr := NewExecError("fake-cmd", stdout99, stderr99)
expectedMsg := fmt.Sprintf("Running command: 'fake-cmd', stdout: '%s', stderr: '%s'", stdout99, stderr99)
Expect(execErr.ShortError()).To(Equal(expectedMsg))
})
})
})
})
}
func describeCentosNetManager() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
ipResolver *fakeip.FakeResolver
addressBroadcaster *fakearp.FakeAddressBroadcaster
netManager Manager
interfaceConfigurationCreator InterfaceConfigurationCreator
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
ipResolver = &fakeip.FakeResolver{}
logger := boshlog.NewLogger(boshlog.LevelNone)
interfaceConfigurationCreator = NewInterfaceConfigurationCreator(logger)
addressBroadcaster = &fakearp.FakeAddressBroadcaster{}
netManager = NewCentosNetManager(
fs,
cmdRunner,
ipResolver,
interfaceConfigurationCreator,
addressBroadcaster,
logger,
)
})
writeNetworkDevice := func(iface string, macAddress string, isPhysical bool) string {
interfacePath := fmt.Sprintf("/sys/class/net/%s", iface)
fs.WriteFile(interfacePath, []byte{})
if isPhysical {
fs.WriteFile(fmt.Sprintf("/sys/class/net/%s/device", iface), []byte{})
}
fs.WriteFileString(fmt.Sprintf("/sys/class/net/%s/address", iface), fmt.Sprintf("%s\n", macAddress))
return interfacePath
}
Describe("SetupNetworking", func() {
var (
dhcpNetwork boshsettings.Network
staticNetwork boshsettings.Network
expectedNetworkConfigurationForStatic string
expectedNetworkConfigurationForDHCP string
expectedDhclientConfiguration string
)
BeforeEach(func() {
dhcpNetwork = boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-dhcp-mac-address",
}
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
expectedNetworkConfigurationForStatic = `DEVICE=ethstatic
BOOTPROTO=static
IPADDR=1.2.3.4
NETMASK=255.255.255.0
BROADCAST=1.2.3.255
GATEWAY=3.4.5.6
ONBOOT=yes
PEERDNS=no
DNS1=8.8.8.8
DNS2=9.9.9.9
`
expectedNetworkConfigurationForDHCP = `DEVICE=ethdhcp
BOOTPROTO=dhcp
ONBOOT=yes
PEERDNS=yes
`
expectedDhclientConfiguration = `# 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 8.8.8.8, 9.9.9.9;
`
})
stubInterfacesWithVirtual := func(physicalInterfaces map[string]boshsettings.Network, virtualInterfaces []string) {
interfacePaths := []string{}
for iface, networkSettings := range physicalInterfaces {
interfacePaths = append(interfacePaths, writeNetworkDevice(iface, networkSettings.Mac, true))
}
for _, iface := range virtualInterfaces {
interfacePaths = append(interfacePaths, writeNetworkDevice(iface, "virtual", false))
}
fs.SetGlob("/sys/class/net/*", interfacePaths)
}
stubInterfaces := func(physicalInterfaces map[string]boshsettings.Network) {
stubInterfacesWithVirtual(physicalInterfaces, nil)
}
It("writes a network script for static and dynamic interfaces", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
staticConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(staticConfig).ToNot(BeNil())
Expect(staticConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic))
dhcpConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethdhcp")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedNetworkConfigurationForDHCP))
})
It("returns errors from glob /sys/class/net/", func() {
fs.GlobErr = errors.New("fs-glob-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-glob-error"))
})
It("returns errors from writing the network configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"dhcp": dhcpNetwork,
"static": staticNetwork,
})
fs.WriteFileError = errors.New("fs-write-file-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-write-file-error"))
})
It("returns errors when it can't create network interface configurations", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
staticNetwork.Netmask = "not an ip" //will cause InterfaceConfigurationCreator to fail
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Creating interface configurations"))
})
It("wrtites a dhcp configuration if there are dhcp networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(expectedDhclientConfiguration))
dhcpConfigSymlink := fs.GetFileTestStat("/etc/dhcp/dhclient-ethdhcp.conf")
Expect(dhcpConfigSymlink).ToNot(BeNil())
Expect(dhcpConfigSymlink.SymlinkTarget).To(Equal("/etc/dhcp/dhclient.conf"))
})
It("writes a dhcp configuration without prepended dns servers if there are no dns servers specified", func() {
dhcpNetworkWithoutDNS := boshsettings.Network{
Type: "dynamic",
Mac: "fake-dhcp-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetworkWithoutDNS}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(`# 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;
`))
dhcpConfigSymlink := fs.GetFileTestStat("/etc/dhcp/dhclient-ethdhcp.conf")
Expect(dhcpConfigSymlink).ToNot(BeNil())
Expect(dhcpConfigSymlink.SymlinkTarget).To(Equal("/etc/dhcp/dhclient.conf"))
})
It("returns an error if it can't write a dhcp configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileErrors["/etc/dhcp/dhclient.conf"] = errors.New("dhclient.conf-write-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("dhclient.conf-write-error"))
})
It("returns an error if it can't symlink a dhcp configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.SymlinkError = errors.New("dhclient-ethdhcp.conf-symlink-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("dhclient-ethdhcp.conf-symlink-error"))
})
It("doesn't write a dhcp configuration if there are no dhcp networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient-ethdhcp.conf")
Expect(dhcpConfig).To(BeNil())
})
It("restarts the networks if any ifconfig file changes", func() {
changingStaticNetwork := boshsettings.Network{
Type: "manual",
IP: "1.2.3.5",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "ethstatict-that-changes",
}
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic-that-changes": changingStaticNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethstatic", expectedNetworkConfigurationForStatic)
fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedDhclientConfiguration)
err := netManager.SetupNetworking(boshsettings.Networks{
"dhcp-network": dhcpNetwork,
"changing-static-network": changingStaticNetwork,
"static-network": staticNetwork,
},
nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
It("doesn't restart the networks if ifcfg and /etc/dhcp/dhclient.conf don't change", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethstatic", expectedNetworkConfigurationForStatic)
fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethdhcp", expectedNetworkConfigurationForDHCP)
fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedDhclientConfiguration)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic))
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig.StringContents()).To(Equal(expectedDhclientConfiguration))
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
It("restarts the networks if /etc/dhcp/dhclient.conf changes", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethstatic", expectedNetworkConfigurationForStatic)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic))
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"}))
})
It("broadcasts MAC addresses for all interfaces", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, errCh)
Expect(err).ToNot(HaveOccurred())
broadcastErr := <-errCh // wait for all arpings
Expect(broadcastErr).ToNot(HaveOccurred())
Expect(addressBroadcaster.BroadcastMACAddressesAddresses).To(Equal([]boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
boship.NewResolvingInterfaceAddress("ethdhcp", ipResolver),
}))
})
It("skips vip networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
vipNetwork := boshsettings.Network{
Type: "vip",
Default: []string{"dns"},
DNS: []string{"4.4.4.4", "5.5.5.5"},
Mac: "fake-vip-mac-address",
IP: "9.8.7.6",
}
err := netManager.SetupNetworking(boshsettings.Networks{
"dhcp-network": dhcpNetwork,
"static-network": staticNetwork,
"vip-network": vipNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic))
})
It("doesn't use vip networks dns", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
vipNetwork := boshsettings.Network{
Type: "vip",
Default: []string{"dns"},
DNS: []string{"4.4.4.4", "5.5.5.5"},
Mac: "fake-vip-mac-address",
IP: "9.8.7.6",
}
err := netManager.SetupNetworking(boshsettings.Networks{
"vip-network": vipNetwork,
"static-network": staticNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).ToNot(ContainSubstring("4.4.4.4"))
Expect(networkConfig.StringContents()).ToNot(ContainSubstring("5.5.5.5"))
})
Context("when no MAC address is provided in the settings", func() {
var staticNetworkWithoutMAC boshsettings.Network
BeforeEach(func() {
staticNetworkWithoutMAC = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
DNS: []string{"8.8.8.8", "9.9.9.9"},
Default: []string{"dns"},
}
})
It("configures network for single device", func() {
stubInterfaces(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
)
err := netManager.SetupNetworking(boshsettings.Networks{
"static-network": staticNetworkWithoutMAC,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic))
})
It("configures network for single device, when a virtual device is also present", func() {
stubInterfacesWithVirtual(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
[]string{"virtual"},
)
err := netManager.SetupNetworking(boshsettings.Networks{
"static-network": staticNetworkWithoutMAC,
}, nil)
Expect(err).ToNot(HaveOccurred())
physicalNetworkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic")
Expect(physicalNetworkConfig).ToNot(BeNil())
Expect(physicalNetworkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic))
virtualNetworkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-virtual")
Expect(virtualNetworkConfig).To(BeNil())
})
})
})
Describe("GetConfiguredNetworkInterfaces", func() {
Context("when there are network devices", func() {
BeforeEach(func() {
interfacePaths := []string{}
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth0", "aa:bb", true))
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth1", "cc:dd", true))
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth2", "ee:ff", true))
fs.SetGlob("/sys/class/net/*", interfacePaths)
})
writeIfcgfFile := func(iface string) {
fs.WriteFileString(fmt.Sprintf("/etc/sysconfig/network-scripts/ifcfg-%s", iface), "fake-config")
}
It("returns networks that have ifcfg config present", func() {
writeIfcgfFile("fake-eth0")
writeIfcgfFile("fake-eth2")
interfaces, err := netManager.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(ConsistOf("fake-eth0", "fake-eth2"))
})
})
Context("when there are no network devices", func() {
It("returns empty list", func() {
interfaces, err := netManager.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(Equal([]string{}))
})
})
})
}
func describeLinuxPlatform() {
var (
collector *fakestats.FakeCollector
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
diskManager *fakedisk.FakeDiskManager
dirProvider boshdirs.Provider
devicePathResolver *fakedpresolv.FakeDevicePathResolver
platform Platform
cdutil *fakedevutil.FakeDeviceUtil
compressor boshcmd.Compressor
copier boshcmd.Copier
vitalsService boshvitals.Service
netManager *fakenet.FakeManager
certManager *fakecert.FakeManager
monitRetryStrategy *fakeretry.FakeRetryStrategy
fakeDefaultNetworkResolver *fakenet.FakeDefaultNetworkResolver
options LinuxOptions
logger boshlog.Logger
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
collector = &fakestats.FakeCollector{}
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
diskManager = fakedisk.NewFakeDiskManager()
dirProvider = boshdirs.NewProvider("/fake-dir")
cdutil = fakedevutil.NewFakeDeviceUtil()
compressor = boshcmd.NewTarballCompressor(cmdRunner, fs)
copier = boshcmd.NewCpCopier(cmdRunner, fs, logger)
vitalsService = boshvitals.NewService(collector, dirProvider)
netManager = &fakenet.FakeManager{}
certManager = new(fakecert.FakeManager)
monitRetryStrategy = fakeretry.NewFakeRetryStrategy()
devicePathResolver = fakedpresolv.NewFakeDevicePathResolver()
fakeDefaultNetworkResolver = &fakenet.FakeDefaultNetworkResolver{}
options = LinuxOptions{}
fs.SetGlob("/sys/bus/scsi/devices/*:0:0:0/block/*", []string{
"/sys/bus/scsi/devices/0:0:0:0/block/sr0",
"/sys/bus/scsi/devices/6:0:0:0/block/sdd",
"/sys/bus/scsi/devices/fake-host-id:0:0:0/block/sda",
})
fs.SetGlob("/sys/bus/scsi/devices/fake-host-id:0:fake-disk-id:0/block/*", []string{
"/sys/bus/scsi/devices/fake-host-id:0:fake-disk-id:0/block/sdf",
})
})
JustBeforeEach(func() {
platform = NewLinuxPlatform(
fs,
cmdRunner,
collector,
compressor,
copier,
dirProvider,
vitalsService,
cdutil,
diskManager,
netManager,
certManager,
monitRetryStrategy,
devicePathResolver,
5*time.Millisecond,
options,
logger,
fakeDefaultNetworkResolver,
)
})
Describe("SetupRuntimeConfiguration", func() {
It("setups runtime configuration", func() {
err := platform.SetupRuntimeConfiguration()
Expect(err).NotTo(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"bosh-agent-rc"}))
})
})
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",
}
err := platform.CreateUser("foo-user", "", "/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}))
})
})
Describe("AddUserToGroups", func() {
It("adds user to groups", func() {
err := platform.AddUserToGroups("foo-user", []string{"group1", "group2", "group3"})
Expect(err).NotTo(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
usermod := []string{"usermod", "-G", "group1,group2,group3", "foo-user"}
Expect(cmdRunner.RunCommands[0]).To(Equal(usermod))
})
})
Describe("DeleteEphemeralUsersMatching", func() {
It("deletes users with prefix and regex", func() {
passwdFile := `bosh_foo:...
bosh_bar:...
foo:...
bar:...
foobar:...
bosh_foobar:...`
fs.WriteFileString("/etc/passwd", passwdFile)
err := platform.DeleteEphemeralUsersMatching("bar$")
Expect(err).NotTo(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(2))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"userdel", "-r", "bosh_bar"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"userdel", "-r", "bosh_foobar"}))
})
})
Describe("SetupSSH", func() {
It("setup ssh", func() {
fs.HomeDirHomePath = "/some/home/dir"
platform.SetupSSH("some public key", "vcap")
sshDirPath := "/some/home/dir/.ssh"
sshDirStat := fs.GetFileTestStat(sshDirPath)
Expect("vcap").To(Equal(fs.HomeDirUsername))
Expect(sshDirStat).NotTo(BeNil())
Expect(sshDirStat.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(os.FileMode(0700)).To(Equal(sshDirStat.FileMode))
Expect("vcap").To(Equal(sshDirStat.Username))
authKeysStat := fs.GetFileTestStat(filepath.Join(sshDirPath, "authorized_keys"))
Expect(authKeysStat).NotTo(BeNil())
Expect(fakesys.FakeFileTypeFile).To(Equal(authKeysStat.FileType))
Expect(os.FileMode(0600)).To(Equal(authKeysStat.FileMode))
Expect("vcap").To(Equal(authKeysStat.Username))
Expect("some public key").To(Equal(authKeysStat.StringContents()))
})
})
Describe("SetUserPassword", func() {
It("set user password", func() {
platform.SetUserPassword("my-user", "my-encrypted-password")
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"usermod", "-p", "my-encrypted-password", "my-user"}))
})
})
Describe("SetupHostname", func() {
const expectedEtcHosts = `127.0.0.1 localhost foobar.local
# The following lines are desirable for IPv6 capable hosts
::1 localhost ip6-localhost ip6-loopback foobar.local
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
ff02::3 ip6-allhosts
`
It("sets up hostname", func() {
platform.SetupHostname("foobar.local")
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"hostname", "foobar.local"}))
hostnameFileContent, err := fs.ReadFileString("/etc/hostname")
Expect(err).NotTo(HaveOccurred())
Expect(hostnameFileContent).To(Equal("foobar.local"))
hostsFileContent, err := fs.ReadFileString("/etc/hosts")
Expect(err).NotTo(HaveOccurred())
Expect(hostsFileContent).To(Equal(expectedEtcHosts))
})
})
Describe("SetupLogrotate", func() {
const expectedEtcLogrotate = `# Generated by bosh-agent
fake-base-path/data/sys/log/*.log fake-base-path/data/sys/log/*/*.log fake-base-path/data/sys/log/*/*/*.log {
missingok
rotate 7
compress
delaycompress
copytruncate
size=fake-size
}
`
It("sets up logrotate", func() {
platform.SetupLogrotate("fake-group-name", "fake-base-path", "fake-size")
logrotateFileContent, err := fs.ReadFileString("/etc/logrotate.d/fake-group-name")
Expect(err).NotTo(HaveOccurred())
Expect(logrotateFileContent).To(Equal(expectedEtcLogrotate))
})
})
Describe("SetTimeWithNtpServers", func() {
It("sets 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")
Expect(ntpConfig.StringContents()).To(Equal("0.north-america.pool.ntp.org 1.north-america.pool.ntp.org"))
Expect(ntpConfig.FileType).To(Equal(fakesys.FakeFileTypeFile))
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"ntpdate"}))
})
It("sets time with ntp servers is noop when no ntp server provided", func() {
platform.SetTimeWithNtpServers([]string{})
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
ntpConfig := fs.GetFileTestStat("/fake-dir/bosh/etc/ntpserver")
Expect(ntpConfig).To(BeNil())
})
})
Describe("SetupEphemeralDiskWithPath", func() {
var (
partitioner *fakedisk.FakePartitioner
formatter *fakedisk.FakeFormatter
mounter *fakedisk.FakeMounter
)
BeforeEach(func() {
partitioner = diskManager.FakePartitioner
formatter = diskManager.FakeFormatter
mounter = diskManager.FakeMounter
})
itSetsUpEphemeralDisk := func(act func() error) {
It("sets up ephemeral disk with path", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
dataDir := fs.GetFileTestStat("/fake-dir/data")
Expect(dataDir.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(dataDir.FileMode).To(Equal(os.FileMode(0750)))
})
It("creates new partition even if the data directory is not empty", func() {
fs.SetGlob(path.Join("/fake-dir", "data", "*"), []string{"something"})
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(partitioner.PartitionCalled).To(BeTrue())
Expect(formatter.FormatCalled).To(BeTrue())
Expect(mounter.MountCalled).To(BeTrue())
})
}
Context("when ephemeral disk path is provided", func() {
act := func() error { return platform.SetupEphemeralDiskWithPath("/dev/xvda") }
itSetsUpEphemeralDisk(act)
It("returns error if creating data dir fails", func() {
fs.MkdirAllError = errors.New("fake-mkdir-all-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-all-err"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("returns err when the data directory cannot be globbed", func() {
fs.GlobErr = errors.New("fake-glob-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Globbing ephemeral disk mount point `/fake-dir/data/*'"))
Expect(err.Error()).To(ContainSubstring("fake-glob-err"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("returns err when mem stats are unavailable", func() {
collector.MemStatsErr = errors.New("fake-memstats-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Calculating partition sizes"))
Expect(err.Error()).To(ContainSubstring("fake-memstats-error"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("returns an error when partitioning fails", func() {
partitioner.PartitionErr = errors.New("fake-partition-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Partitioning ephemeral disk `/dev/xvda'"))
Expect(err.Error()).To(ContainSubstring("fake-partition-error"))
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("formats swap and data partitions", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(len(formatter.FormatPartitionPaths)).To(Equal(2))
Expect(formatter.FormatPartitionPaths[0]).To(Equal("/dev/xvda1"))
Expect(formatter.FormatPartitionPaths[1]).To(Equal("/dev/xvda2"))
Expect(len(formatter.FormatFsTypes)).To(Equal(2))
Expect(formatter.FormatFsTypes[0]).To(Equal(boshdisk.FileSystemSwap))
Expect(formatter.FormatFsTypes[1]).To(Equal(boshdisk.FileSystemExt4))
})
It("mounts swap and data partitions", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(len(mounter.MountMountPoints)).To(Equal(1))
Expect(mounter.MountMountPoints[0]).To(Equal("/fake-dir/data"))
Expect(len(mounter.MountPartitionPaths)).To(Equal(1))
Expect(mounter.MountPartitionPaths[0]).To(Equal("/dev/xvda2"))
Expect(len(mounter.SwapOnPartitionPaths)).To(Equal(1))
Expect(mounter.SwapOnPartitionPaths[0]).To(Equal("/dev/xvda1"))
})
It("creates swap the size of the memory and the rest for data when disk is bigger than twice the memory", func() {
memSizeInBytes := uint64(1024 * 1024 * 1024)
diskSizeInBytes := 2*memSizeInBytes + 64
fakePartitioner := partitioner
fakePartitioner.GetDeviceSizeInBytesSizes["/dev/xvda"] = diskSizeInBytes
collector.MemStats.Total = memSizeInBytes
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(fakePartitioner.PartitionPartitions).To(Equal([]boshdisk.Partition{
{SizeInBytes: memSizeInBytes, Type: boshdisk.PartitionTypeSwap},
{SizeInBytes: diskSizeInBytes - memSizeInBytes, Type: boshdisk.PartitionTypeLinux},
}))
})
It("creates equal swap and data partitions when disk is twice the memory or smaller", func() {
memSizeInBytes := uint64(1024 * 1024 * 1024)
diskSizeInBytes := 2*memSizeInBytes - 64
fakePartitioner := partitioner
fakePartitioner.GetDeviceSizeInBytesSizes["/dev/xvda"] = diskSizeInBytes
collector.MemStats.Total = memSizeInBytes
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(fakePartitioner.PartitionPartitions).To(Equal([]boshdisk.Partition{
{SizeInBytes: diskSizeInBytes / 2, Type: boshdisk.PartitionTypeSwap},
{SizeInBytes: diskSizeInBytes / 2, Type: boshdisk.PartitionTypeLinux},
}))
})
})
Context("when ephemeral disk path is not provided", func() {
act := func() error { return platform.SetupEphemeralDiskWithPath("") }
Context("when agent should partition ephemeral disk on root disk", func() {
BeforeEach(func() {
partitioner = diskManager.FakeRootDevicePartitioner
options.CreatePartitionIfNoEphemeralDisk = true
})
Context("when root device fails to be determined", func() {
BeforeEach(func() {
diskManager.FakeMountsSearcher.SearchMountsErr = errors.New("fake-mounts-searcher-error")
})
It("returns an error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Finding root partition device"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
})
Context("when root partition is not the first partition", func() {
BeforeEach(func() {
diskManager.FakeMountsSearcher.SearchMountsMounts = []boshdisk.Mount{
{MountPoint: "/", PartitionPath: "/dev/vda2"},
}
})
It("returns an error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Root partition is not the first partition"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
})
Context("when root device is determined", func() {
BeforeEach(func() {
diskManager.FakeMountsSearcher.SearchMountsMounts = []boshdisk.Mount{
{MountPoint: "/", PartitionPath: "rootfs"},
{MountPoint: "/", PartitionPath: "/dev/vda1"},
}
})
Context("when getting absolute path fails", func() {
BeforeEach(func() {
cmdRunner.AddCmdResult(
"readlink -f /dev/vda1",
fakesys.FakeCmdResult{Error: errors.New("fake-readlink-error")},
)
})
It("returns an error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-readlink-error"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
})
Context("when getting absolute path suceeds", func() {
BeforeEach(func() {
cmdRunner.AddCmdResult(
"readlink -f /dev/vda1",
fakesys.FakeCmdResult{Stdout: "/dev/vda1"},
)
})
Context("when root device has insufficient space for ephemeral partitions", func() {
BeforeEach(func() {
partitioner.GetDeviceSizeInBytesSizes["/dev/vda"] = 1024*1024*1024 - 1
collector.MemStats.Total = 8
})
It("returns an error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Insufficient remaining disk"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
})
Context("when root device has sufficient space for ephemeral partitions", func() {
BeforeEach(func() {
partitioner.GetDeviceSizeInBytesSizes["/dev/vda"] = 1024 * 1024 * 1024
collector.MemStats.Total = 256 * 1024 * 1024
})
itSetsUpEphemeralDisk(act)
It("returns err when mem stats are unavailable", func() {
collector.MemStatsErr = errors.New("fake-memstats-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Calculating partition sizes"))
Expect(err.Error()).To(ContainSubstring("fake-memstats-error"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("returns an error when partitioning fails", func() {
partitioner.PartitionErr = errors.New("fake-partition-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Partitioning root device `/dev/vda'"))
Expect(err.Error()).To(ContainSubstring("fake-partition-error"))
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("formats swap and data partitions", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(len(formatter.FormatPartitionPaths)).To(Equal(2))
Expect(formatter.FormatPartitionPaths[0]).To(Equal("/dev/vda2"))
Expect(formatter.FormatPartitionPaths[1]).To(Equal("/dev/vda3"))
Expect(len(formatter.FormatFsTypes)).To(Equal(2))
Expect(formatter.FormatFsTypes[0]).To(Equal(boshdisk.FileSystemSwap))
Expect(formatter.FormatFsTypes[1]).To(Equal(boshdisk.FileSystemExt4))
})
It("mounts swap and data partitions", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(len(mounter.MountMountPoints)).To(Equal(1))
Expect(mounter.MountMountPoints[0]).To(Equal("/fake-dir/data"))
Expect(len(mounter.MountPartitionPaths)).To(Equal(1))
Expect(mounter.MountPartitionPaths[0]).To(Equal("/dev/vda3"))
Expect(len(mounter.SwapOnPartitionPaths)).To(Equal(1))
Expect(mounter.SwapOnPartitionPaths[0]).To(Equal("/dev/vda2"))
})
It("creates swap the size of the memory and the rest for data when disk is bigger than twice the memory", func() {
memSizeInBytes := uint64(1024 * 1024 * 1024)
diskSizeInBytes := 2*memSizeInBytes + 64
partitioner.GetDeviceSizeInBytesSizes["/dev/vda"] = diskSizeInBytes
collector.MemStats.Total = memSizeInBytes
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(partitioner.PartitionDevicePath).To(Equal("/dev/vda"))
Expect(partitioner.PartitionPartitions).To(ContainElement(
boshdisk.Partition{
SizeInBytes: memSizeInBytes,
Type: boshdisk.PartitionTypeSwap,
}),
)
Expect(partitioner.PartitionPartitions).To(ContainElement(
boshdisk.Partition{
SizeInBytes: diskSizeInBytes - memSizeInBytes,
Type: boshdisk.PartitionTypeLinux,
}),
)
})
It("creates equal swap and data partitions when disk is twice the memory or smaller", func() {
memSizeInBytes := uint64(1024 * 1024 * 1024)
diskSizeInBytes := 2*memSizeInBytes - 64
partitioner.GetDeviceSizeInBytesSizes["/dev/vda"] = diskSizeInBytes
collector.MemStats.Total = memSizeInBytes
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(partitioner.PartitionDevicePath).To(Equal("/dev/vda"))
Expect(partitioner.PartitionPartitions).To(ContainElement(
boshdisk.Partition{
SizeInBytes: diskSizeInBytes / 2,
Type: boshdisk.PartitionTypeSwap,
}),
)
Expect(partitioner.PartitionPartitions).To(ContainElement(
boshdisk.Partition{
SizeInBytes: diskSizeInBytes / 2,
Type: boshdisk.PartitionTypeLinux,
}),
)
})
})
Context("when getting root device remaining size fails", func() {
BeforeEach(func() {
partitioner.GetDeviceSizeInBytesErr = errors.New("fake-get-remaining-size-error")
})
It("returns an error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Getting root device remaining size"))
Expect(err.Error()).To(ContainSubstring("fake-get-remaining-size-error"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
})
})
})
It("returns error if creating data dir fails", func() {
fs.MkdirAllError = errors.New("fake-mkdir-all-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-all-err"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
It("returns err when the data directory cannot be globbed", func() {
fs.GlobErr = errors.New("fake-glob-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Globbing ephemeral disk mount point `/fake-dir/data/*'"))
Expect(err.Error()).To(ContainSubstring("fake-glob-err"))
Expect(partitioner.PartitionCalled).To(BeFalse())
Expect(formatter.FormatCalled).To(BeFalse())
Expect(mounter.MountCalled).To(BeFalse())
})
})
Context("when agent should not partition ephemeral disk on root disk", func() {
BeforeEach(func() {
options.CreatePartitionIfNoEphemeralDisk = false
})
It("returns an error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("cannot use root partition as ephemeral disk"))
})
It("does not try to partition anything", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(partitioner.PartitionCalled).To(BeFalse())
})
It("does not try to format anything", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(formatter.FormatCalled).To(BeFalse())
})
It("does not try to mount anything", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(mounter.MountCalled).To(BeFalse())
})
})
})
})
Describe("SetupDataDir", func() {
var mounter *fakedisk.FakeMounter
BeforeEach(func() {
mounter = diskManager.FakeMounter
})
Context("when sys/run is already mounted", func() {
BeforeEach(func() {
mounter.IsMountPointResult = true
})
It("creates sys/log directory in data directory", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
sysLogStats := fs.GetFileTestStat("/fake-dir/data/sys/log")
Expect(sysLogStats).ToNot(BeNil())
Expect(sysLogStats.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(sysLogStats.FileMode).To(Equal(os.FileMode(0750)))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"chown", "root:vcap", "/fake-dir/data/sys"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"chown", "root:vcap", "/fake-dir/data/sys/log"}))
})
It("creates symlink from sys to data/sys", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
sysStats := fs.GetFileTestStat("/fake-dir/sys")
Expect(sysStats).ToNot(BeNil())
Expect(sysStats.FileType).To(Equal(fakesys.FakeFileTypeSymlink))
Expect(sysStats.SymlinkTarget).To(Equal("/fake-dir/data/sys"))
})
It("does not create new sys/run dir", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
sysRunStats := fs.GetFileTestStat("/fake-dir/data/sys/run")
Expect(sysRunStats).To(BeNil())
})
It("does not mount tmpfs again", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
Expect(len(mounter.MountPartitionPaths)).To(Equal(0))
})
})
Context("when sys/run is not yet mounted", func() {
BeforeEach(func() {
mounter.IsMountPointResult = false
})
It("creates sys/log directory in data directory", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
sysLogStats := fs.GetFileTestStat("/fake-dir/data/sys/log")
Expect(sysLogStats).ToNot(BeNil())
Expect(sysLogStats.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(sysLogStats.FileMode).To(Equal(os.FileMode(0750)))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"chown", "root:vcap", "/fake-dir/data/sys"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"chown", "root:vcap", "/fake-dir/data/sys/log"}))
})
It("creates symlink from sys to data/sys", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
sysStats := fs.GetFileTestStat("/fake-dir/sys")
Expect(sysStats).ToNot(BeNil())
Expect(sysStats.FileType).To(Equal(fakesys.FakeFileTypeSymlink))
Expect(sysStats.SymlinkTarget).To(Equal("/fake-dir/data/sys"))
})
It("creates new sys/run dir", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
sysRunStats := fs.GetFileTestStat("/fake-dir/data/sys/run")
Expect(sysRunStats).ToNot(BeNil())
Expect(sysRunStats.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(sysRunStats.FileMode).To(Equal(os.FileMode(0750)))
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"chown", "root:vcap", "/fake-dir/data/sys/run"}))
})
It("mounts tmpfs to sys/run", func() {
err := platform.SetupDataDir()
Expect(err).NotTo(HaveOccurred())
Expect(len(mounter.MountPartitionPaths)).To(Equal(1))
Expect(mounter.MountPartitionPaths[0]).To(Equal("tmpfs"))
Expect(mounter.MountMountPoints[0]).To(Equal("/fake-dir/data/sys/run"))
Expect(mounter.MountMountOptions[0]).To(Equal([]string{"-t", "tmpfs", "-o", "size=1m"}))
})
It("returns an error if creation of mount point fails", func() {
fs.MkdirAllError = errors.New("fake-mkdir-error")
err := platform.SetupDataDir()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-error"))
})
It("returns an error if mounting tmpfs fails", func() {
mounter.MountErr = errors.New("fake-mount-error")
err := platform.SetupDataDir()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mount-error"))
})
})
})
Describe("SetupTmpDir", func() {
act := func() error { return platform.SetupTmpDir() }
var mounter *fakedisk.FakeMounter
BeforeEach(func() {
mounter = diskManager.FakeMounter
})
It("changes permissions on /tmp", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"chown", "root:vcap", "/tmp"}))
Expect(cmdRunner.RunCommands[1]).To(Equal([]string{"chmod", "0770", "/tmp"}))
Expect(cmdRunner.RunCommands[2]).To(Equal([]string{"chmod", "0700", "/var/tmp"}))
})
It("creates new temp dir", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
fileStats := fs.GetFileTestStat("/fake-dir/data/tmp")
Expect(fileStats).NotTo(BeNil())
Expect(fileStats.FileType).To(Equal(fakesys.FakeFileType(fakesys.FakeFileTypeDir)))
Expect(fileStats.FileMode).To(Equal(os.FileMode(0755)))
})
It("returns error if creating new temp dir errs", func() {
fs.MkdirAllError = errors.New("fake-mkdir-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-error"))
})
It("sets TMPDIR environment variable so that children of this process will use new temp dir", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(os.Getenv("TMPDIR")).To(Equal("/fake-dir/data/tmp"))
})
It("returns error if setting TMPDIR errs", func() {
// uses os package; no way to trigger err
})
ItDoesNotTryToUseLoopDevice := func() {
It("does not create new tmp filesystem", func() {
act()
for _, cmd := range cmdRunner.RunCommands {
Expect(cmd[0]).ToNot(Equal("truncate"))
Expect(cmd[0]).ToNot(Equal("mke2fs"))
}
})
It("does not try to mount anything /tmp", func() {
act()
Expect(len(mounter.MountPartitionPaths)).To(Equal(0))
})
}
Context("when UseDefaultTmpDir option is set to false", func() {
BeforeEach(func() {
options.UseDefaultTmpDir = false
})
Context("when /tmp is not a mount point", func() {
BeforeEach(func() {
mounter.IsMountPointResult = false
})
It("creates new tmp filesystem of 128MB placed in data dir", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(cmdRunner.RunCommands[3]).To(Equal([]string{"truncate", "-s", "128M", "/fake-dir/data/root_tmp"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"chmod", "0700", "/fake-dir/data/root_tmp"}))
Expect(cmdRunner.RunCommands[5]).To(Equal([]string{"mke2fs", "-t", "ext4", "-m", "1", "-F", "/fake-dir/data/root_tmp"}))
})
It("mounts the new tmp filesystem over /tmp", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(len(mounter.MountPartitionPaths)).To(Equal(1))
Expect(mounter.MountPartitionPaths[0]).To(Equal("/fake-dir/data/root_tmp"))
Expect(mounter.MountMountPoints[0]).To(Equal("/tmp"))
Expect(mounter.MountMountOptions[0]).To(Equal([]string{"-t", "ext4", "-o", "loop"}))
})
It("returns error if mounting the new tmp filesystem fails", func() {
mounter.MountErr = errors.New("fake-mount-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mount-error"))
})
It("changes permissions on /tmp again because it is a new mount", func() {
err := act()
Expect(err).NotTo(HaveOccurred())
Expect(cmdRunner.RunCommands[6]).To(Equal([]string{"chown", "root:vcap", "/tmp"}))
Expect(cmdRunner.RunCommands[7]).To(Equal([]string{"chmod", "0770", "/tmp"}))
})
})
Context("when /tmp is a mount point", func() {
BeforeEach(func() {
mounter.IsMountPointResult = true
})
It("returns without an error", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
})
ItDoesNotTryToUseLoopDevice()
})
Context("when /tmp cannot be determined if it is a mount point", func() {
BeforeEach(func() {
mounter.IsMountPointErr = errors.New("fake-is-mount-point-error")
})
It("returns error", func() {
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-mount-point-error"))
})
ItDoesNotTryToUseLoopDevice()
})
})
Context("when UseDefaultTmpDir option is set to true", func() {
BeforeEach(func() {
options.UseDefaultTmpDir = true
})
It("returns without an error", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
})
ItDoesNotTryToUseLoopDevice()
})
})
Describe("MountPersistentDisk", func() {
act := func() error {
return platform.MountPersistentDisk(
boshsettings.DiskSettings{Path: "fake-volume-id"},
"/mnt/point",
)
}
var (
partitioner *fakedisk.FakePartitioner
formatter *fakedisk.FakeFormatter
mounter *fakedisk.FakeMounter
)
BeforeEach(func() {
partitioner = diskManager.FakePartitioner
formatter = diskManager.FakeFormatter
mounter = diskManager.FakeMounter
})
Context("when device path is successfully resolved", func() {
BeforeEach(func() {
devicePathResolver.RealDevicePath = "fake-real-device-path"
})
Context("when UsePreformattedPersistentDisk set to false", func() {
It("creates the mount directory with the correct permissions", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
mountPoint := fs.GetFileTestStat("/mnt/point")
Expect(mountPoint.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(mountPoint.FileMode).To(Equal(os.FileMode(0700)))
})
It("returns error when creating mount directory fails", func() {
fs.MkdirAllError = errors.New("fake-mkdir-all-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-all-err"))
})
It("partitions the disk", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
partitions := []boshdisk.Partition{{Type: boshdisk.PartitionTypeLinux}}
Expect(partitioner.PartitionDevicePath).To(Equal("fake-real-device-path"))
Expect(partitioner.PartitionPartitions).To(Equal(partitions))
})
It("formats the disk", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(formatter.FormatPartitionPaths).To(Equal([]string{"fake-real-device-path1"}))
Expect(formatter.FormatFsTypes).To(Equal([]boshdisk.FileSystemType{boshdisk.FileSystemExt4}))
})
It("mounts the disk", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(mounter.MountPartitionPaths).To(Equal([]string{"fake-real-device-path1"}))
Expect(mounter.MountMountPoints).To(Equal([]string{"/mnt/point"}))
Expect(mounter.MountMountOptions).To(Equal([][]string{nil}))
})
})
Context("when UsePreformattedPersistentDisk set to true", func() {
BeforeEach(func() {
options.UsePreformattedPersistentDisk = true
})
It("creates the mount directory with the correct permissions", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
mountPoint := fs.GetFileTestStat("/mnt/point")
Expect(mountPoint.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(mountPoint.FileMode).To(Equal(os.FileMode(0700)))
})
It("returns error when creating mount directory fails", func() {
fs.MkdirAllError = errors.New("fake-mkdir-all-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-all-err"))
})
It("mounts volume at mount point", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(len(mounter.MountPartitionPaths)).To(Equal(1))
Expect(mounter.MountPartitionPaths).To(Equal([]string{"fake-real-device-path"})) // no '1' because no partition
Expect(mounter.MountMountPoints).To(Equal([]string{"/mnt/point"}))
Expect(mounter.MountMountOptions).To(Equal([][]string{nil}))
})
It("returns error when mounting fails", func() {
mounter.MountErr = errors.New("fake-mount-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mount-err"))
})
It("does not partition the disk", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(partitioner.PartitionCalled).To(BeFalse())
})
It("does not format the disk", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(formatter.FormatCalled).To(BeFalse())
})
})
})
Context("when device path is not successfully resolved", func() {
It("return an error", func() {
devicePathResolver.GetRealDevicePathErr = errors.New("fake-get-real-device-path-err")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-real-device-path-err"))
})
})
})
Describe("UnmountPersistentDisk", func() {
act := func() (bool, error) {
return platform.UnmountPersistentDisk(boshsettings.DiskSettings{Path: "fake-device-path"})
}
var mounter *fakedisk.FakeMounter
BeforeEach(func() {
mounter = diskManager.FakeMounter
})
Context("when device path can be resolved", func() {
BeforeEach(func() {
devicePathResolver.RealDevicePath = "fake-real-device-path"
})
ItUnmountsPersistentDisk := func(expectedUnmountMountPoint string) {
It("returs true without an error if unmounting succeeded", func() {
mounter.UnmountDidUnmount = true
didUnmount, err := act()
Expect(err).NotTo(HaveOccurred())
Expect(didUnmount).To(BeTrue())
Expect(mounter.UnmountPartitionPathOrMountPoint).To(Equal(expectedUnmountMountPoint))
})
It("returs false without an error if was already unmounted", func() {
mounter.UnmountDidUnmount = false
didUnmount, err := act()
Expect(err).NotTo(HaveOccurred())
Expect(didUnmount).To(BeFalse())
Expect(mounter.UnmountPartitionPathOrMountPoint).To(Equal(expectedUnmountMountPoint))
})
It("returns error if unmounting fails", func() {
mounter.UnmountDidUnmount = false
mounter.UnmountErr = errors.New("fake-unmount-err")
didUnmount, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-unmount-err"))
Expect(didUnmount).To(BeFalse())
Expect(mounter.UnmountPartitionPathOrMountPoint).To(Equal(expectedUnmountMountPoint))
})
}
Context("UsePreformattedPersistentDisk is set to false", func() {
ItUnmountsPersistentDisk("fake-real-device-path1") // note partition '1'
})
Context("UsePreformattedPersistentDisk is set to true", func() {
BeforeEach(func() {
options.UsePreformattedPersistentDisk = true
})
ItUnmountsPersistentDisk("fake-real-device-path") // note no '1'; no partitions
})
})
Context("when device path cannot be resolved", func() {
BeforeEach(func() {
devicePathResolver.GetRealDevicePathErr = errors.New("fake-get-real-device-path-err")
devicePathResolver.GetRealDevicePathTimedOut = false
})
It("returns error", func() {
isMounted, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-real-device-path-err"))
Expect(isMounted).To(BeFalse())
})
})
Context("when device path cannot be resolved due to timeout", func() {
BeforeEach(func() {
devicePathResolver.GetRealDevicePathErr = errors.New("fake-get-real-device-path-err")
devicePathResolver.GetRealDevicePathTimedOut = true
})
It("does not return error", func() {
isMounted, err := act()
Expect(err).NotTo(HaveOccurred())
Expect(isMounted).To(BeFalse())
})
})
})
Describe("GetFileContentsFromCDROM", func() {
It("delegates to cdutil", func() {
cdutil.GetFilesContentsContents = [][]byte{[]byte("fake-contents")}
filename := "fake-env"
contents, err := platform.GetFileContentsFromCDROM(filename)
Expect(err).NotTo(HaveOccurred())
Expect(cdutil.GetFilesContentsFileNames[0]).To(Equal(filename))
Expect(contents).To(Equal([]byte("fake-contents")))
})
})
Describe("GetFilesContentsFromDisk", func() {
It("delegates to diskutil", func() {
diskManager.FakeDiskUtil.GetFilesContentsContents = [][]byte{
[]byte("fake-contents-1"),
[]byte("fake-contents-2"),
}
contents, err := platform.GetFilesContentsFromDisk(
"fake-disk-path",
[]string{"fake-file-path-1", "fake-file-path-2"},
)
Expect(err).NotTo(HaveOccurred())
Expect(diskManager.DiskUtilDiskPath).To(Equal("fake-disk-path"))
Expect(diskManager.FakeDiskUtil.GetFilesContentsFileNames).To(Equal(
[]string{"fake-file-path-1", "fake-file-path-2"},
))
Expect(contents).To(Equal([][]byte{
[]byte("fake-contents-1"),
[]byte("fake-contents-2"),
}))
})
})
Describe("GetEphemeralDiskPath", func() {
Context("when device path is an empty string", func() {
It("returns an empty string", func() {
devicePathResolver.RealDevicePath = "non-desired-device-path"
diskSettings := boshsettings.DiskSettings{
ID: "fake-id",
VolumeID: "fake-volume-id",
Path: "",
}
Expect(platform.GetEphemeralDiskPath(diskSettings)).To(BeEmpty())
})
})
Context("when real device path was resolved without an error", func() {
It("returns real device path and true", func() {
devicePathResolver.RealDevicePath = "fake-real-device-path"
realPath := platform.GetEphemeralDiskPath(boshsettings.DiskSettings{Path: "fake-device-path"})
Expect(realPath).To(Equal("fake-real-device-path"))
})
})
Context("when real device path was not resolved without an error", func() {
It("returns real device path and true", func() {
devicePathResolver.GetRealDevicePathErr = errors.New("fake-get-real-device-path-err")
realPath := platform.GetEphemeralDiskPath(boshsettings.DiskSettings{Path: "fake-device-path"})
Expect(realPath).To(Equal(""))
})
})
})
Describe("MigratePersistentDisk", func() {
var mounter *fakedisk.FakeMounter
BeforeEach(func() {
mounter = diskManager.FakeMounter
})
It("migrate persistent disk", func() {
err := platform.MigratePersistentDisk("/from/path", "/to/path")
Expect(err).ToNot(HaveOccurred())
Expect(mounter.RemountAsReadonlyPath).To(Equal("/from/path"))
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"sh", "-c", "(tar -C /from/path -cf - .) | (tar -C /to/path -xpf -)"}))
Expect(mounter.UnmountPartitionPathOrMountPoint).To(Equal("/from/path"))
Expect(mounter.RemountFromMountPoint).To(Equal("/to/path"))
Expect(mounter.RemountToMountPoint).To(Equal("/from/path"))
})
})
Describe("IsPersistentDiskMounted", func() {
act := func() (bool, error) {
return platform.IsPersistentDiskMounted(boshsettings.DiskSettings{Path: "fake-device-path"})
}
var mounter *fakedisk.FakeMounter
BeforeEach(func() {
mounter = diskManager.FakeMounter
})
Context("when device path can be resolved", func() {
BeforeEach(func() {
devicePathResolver.RealDevicePath = "fake-real-device-path"
})
ItChecksPersistentDiskMountPoint := func(expectedCheckedMountPoint string) {
Context("when checking persistent disk mount point succeeds", func() {
It("returns true if mount point exists", func() {
mounter.IsMountedResult = true
isMounted, err := act()
Expect(err).NotTo(HaveOccurred())
Expect(isMounted).To(BeTrue())
Expect(mounter.IsMountedDevicePathOrMountPoint).To(Equal(expectedCheckedMountPoint))
})
It("returns false if mount point does not exist", func() {
mounter.IsMountedResult = false
isMounted, err := act()
Expect(err).NotTo(HaveOccurred())
Expect(isMounted).To(BeFalse())
Expect(mounter.IsMountedDevicePathOrMountPoint).To(Equal(expectedCheckedMountPoint))
})
})
Context("checking persistent disk mount points fails", func() {
It("returns error", func() {
mounter.IsMountedResult = false
mounter.IsMountedErr = errors.New("fake-is-mounted-err")
isMounted, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-is-mounted-err"))
Expect(isMounted).To(BeFalse())
Expect(mounter.IsMountedDevicePathOrMountPoint).To(Equal(expectedCheckedMountPoint))
})
})
}
Context("UsePreformattedPersistentDisk is set to false", func() {
ItChecksPersistentDiskMountPoint("fake-real-device-path1") // note partition '1'
})
Context("UsePreformattedPersistentDisk is set to true", func() {
BeforeEach(func() {
options.UsePreformattedPersistentDisk = true
})
ItChecksPersistentDiskMountPoint("fake-real-device-path") // note no '1'; no partitions
})
})
Context("when device path cannot be resolved", func() {
BeforeEach(func() {
devicePathResolver.GetRealDevicePathErr = errors.New("fake-get-real-device-path-err")
devicePathResolver.GetRealDevicePathTimedOut = false
})
It("returns error", func() {
isMounted, err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-real-device-path-err"))
Expect(isMounted).To(BeFalse())
})
})
Context("when device path cannot be resolved due to timeout", func() {
BeforeEach(func() {
devicePathResolver.GetRealDevicePathErr = errors.New("fake-get-real-device-path-err")
devicePathResolver.GetRealDevicePathTimedOut = true
})
It("does not return error", func() {
isMounted, err := act()
Expect(err).NotTo(HaveOccurred())
Expect(isMounted).To(BeFalse())
})
})
})
Describe("StartMonit", func() {
It("creates a symlink between /etc/service/monit and /etc/sv/monit", func() {
err := platform.StartMonit()
Expect(err).NotTo(HaveOccurred())
target, _ := fs.ReadLink(filepath.Join("/etc", "service", "monit"))
Expect(target).To(Equal(filepath.Join("/etc", "sv", "monit")))
})
It("retries to start monit", func() {
err := platform.StartMonit()
Expect(err).NotTo(HaveOccurred())
Expect(monitRetryStrategy.TryCalled).To(BeTrue())
})
It("returns error if retrying to start monit fails", func() {
monitRetryStrategy.TryErr = errors.New("fake-retry-monit-error")
err := platform.StartMonit()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-retry-monit-error"))
})
})
Describe("SetupMonitUser", func() {
It("setup monit user if file does not exist", func() {
err := platform.SetupMonitUser()
Expect(err).NotTo(HaveOccurred())
monitUserFileStats := fs.GetFileTestStat("/fake-dir/monit/monit.user")
Expect(monitUserFileStats).ToNot(BeNil())
Expect(monitUserFileStats.StringContents()).To(Equal("vcap:random-password"))
})
It("setup monit user if file does exist", func() {
fs.WriteFileString("/fake-dir/monit/monit.user", "vcap:other-random-password")
err := platform.SetupMonitUser()
Expect(err).NotTo(HaveOccurred())
monitUserFileStats := fs.GetFileTestStat("/fake-dir/monit/monit.user")
Expect(monitUserFileStats).ToNot(BeNil())
Expect(monitUserFileStats.StringContents()).To(Equal("vcap:other-random-password"))
})
})
Describe("GetMonitCredentials", func() {
It("get monit credentials reads monit file from disk", func() {
fs.WriteFileString("/fake-dir/monit/monit.user", "fake-user:fake-random-password")
username, password, err := platform.GetMonitCredentials()
Expect(err).NotTo(HaveOccurred())
Expect(username).To(Equal("fake-user"))
Expect(password).To(Equal("fake-random-password"))
})
It("get monit credentials errs when invalid file format", func() {
fs.WriteFileString("/fake-dir/monit/monit.user", "fake-user")
_, _, err := platform.GetMonitCredentials()
Expect(err).To(HaveOccurred())
})
It("get monit credentials leaves colons in password intact", func() {
fs.WriteFileString("/fake-dir/monit/monit.user", "fake-user:fake:random:password")
username, password, err := platform.GetMonitCredentials()
Expect(err).NotTo(HaveOccurred())
Expect(username).To(Equal("fake-user"))
Expect(password).To(Equal("fake:random:password"))
})
})
Describe("PrepareForNetworkingChange", func() {
It("removes the network persistent rules file", func() {
fs.WriteFile("/etc/udev/rules.d/70-persistent-net.rules", []byte{})
err := platform.PrepareForNetworkingChange()
Expect(err).NotTo(HaveOccurred())
Expect(fs.FileExists("/etc/udev/rules.d/70-persistent-net.rules")).To(BeFalse())
})
It("returns error if removing persistent rules file fails", func() {
fs.RemoveAllError = errors.New("fake-remove-all-error")
err := platform.PrepareForNetworkingChange()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-remove-all-error"))
})
})
Describe("SetupNetworking", func() {
It("delegates to the NetManager", func() {
networks := boshsettings.Networks{}
err := platform.SetupNetworking(networks)
Expect(err).ToNot(HaveOccurred())
Expect(netManager.SetupNetworkingNetworks).To(Equal(networks))
})
})
Describe("GetConfiguredNetworkInterfaces", func() {
It("delegates to the NetManager", func() {
netmanagerInterfaces := []string{"fake-eth0", "fake-eth1"}
netManager.GetConfiguredNetworkInterfacesInterfaces = netmanagerInterfaces
interfaces, err := platform.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(Equal(netmanagerInterfaces))
})
})
Describe("GetDefaultNetwork", func() {
It("delegates to the defaultNetworkResolver", func() {
defaultNetwork := boshsettings.Network{IP: "1.2.3.4"}
fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork
network, err := platform.GetDefaultNetwork()
Expect(err).ToNot(HaveOccurred())
Expect(network).To(Equal(defaultNetwork))
})
})
}
func init() {
Describe("Testing with Ginkgo", func() {
It("home dir", func() {
osFs, _ := createOsFs()
homeDir, err := osFs.HomeDir("root")
Expect(err).ToNot(HaveOccurred())
Expect(homeDir).To(ContainSubstring("/root"))
})
It("expand path", func() {
osFs, _ := createOsFs()
expandedPath, err := osFs.ExpandPath("~/fake-dir/fake-file.txt")
Expect(err).ToNot(HaveOccurred())
currentUser, err := osuser.Current()
Expect(err).ToNot(HaveOccurred())
Expect(expandedPath).To(Equal(currentUser.HomeDir + "/fake-dir/fake-file.txt"))
expandedPath, err = osFs.ExpandPath("/fake-dir//fake-file.txt")
Expect(err).ToNot(HaveOccurred())
Expect(expandedPath).To(Equal("/fake-dir/fake-file.txt"))
expandedPath, err = osFs.ExpandPath("./fake-file.txt")
Expect(err).ToNot(HaveOccurred())
currentDir, err := os.Getwd()
Expect(err).ToNot(HaveOccurred())
Expect(expandedPath).To(Equal(currentDir + "/fake-file.txt"))
})
It("mkdir all", func() {
osFs, _ := createOsFs()
tmpPath := os.TempDir()
testPath := filepath.Join(tmpPath, "MkdirAllTestDir", "bar", "baz")
defer os.RemoveAll(filepath.Join(tmpPath, "MkdirAllTestDir"))
_, err := os.Stat(testPath)
Expect(err).To(HaveOccurred())
Expect(os.IsNotExist(err)).To(BeTrue())
fileMode := os.FileMode(0700)
err = osFs.MkdirAll(testPath, fileMode)
Expect(err).ToNot(HaveOccurred())
stat, err := os.Stat(testPath)
Expect(err).ToNot(HaveOccurred())
Expect(stat.IsDir()).To(BeTrue())
Expect(stat.Mode().Perm()).To(Equal(fileMode))
err = osFs.MkdirAll(testPath, fileMode)
Expect(err).ToNot(HaveOccurred())
})
It("chown", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "ChownTestDir")
err := os.Mkdir(testPath, os.FileMode(0700))
Expect(err).ToNot(HaveOccurred())
defer os.RemoveAll(testPath)
err = osFs.Chown(testPath, "garbage-foo")
Expect(err).To(HaveOccurred())
})
It("chmod", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "ChmodTestDir")
_, err := os.Create(testPath)
Expect(err).ToNot(HaveOccurred())
defer os.Remove(testPath)
os.Chmod(testPath, os.FileMode(0666))
err = osFs.Chmod(testPath, os.FileMode(0644))
Expect(err).ToNot(HaveOccurred())
fileStat, err := os.Stat(testPath)
Expect(err).ToNot(HaveOccurred())
Expect(fileStat.Mode()).To(Equal(os.FileMode(0644)))
})
It("opens file", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "OpenFileTestFile")
file, err := osFs.OpenFile(testPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, os.FileMode(0644))
defer os.Remove(testPath)
Expect(err).ToNot(HaveOccurred())
file.Write([]byte("testing new file"))
file.Close()
createdFile, err := os.Open(testPath)
Expect(err).ToNot(HaveOccurred())
defer createdFile.Close()
Expect(readFile(createdFile)).To(Equal("testing new file"))
})
Context("the file already exists and is not write only", func() {
It("writes to file", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "subDir", "ConvergeFileContentsTestFile")
_, err := os.Stat(testPath)
Expect(err).To(HaveOccurred())
written, err := osFs.ConvergeFileContents(testPath, []byte("initial write"))
Expect(err).ToNot(HaveOccurred())
Expect(written).To(BeTrue())
defer os.Remove(testPath)
file, err := os.Open(testPath)
Expect(err).ToNot(HaveOccurred())
defer file.Close()
Expect(readFile(file)).To(Equal("initial write"))
written, err = osFs.ConvergeFileContents(testPath, []byte("second write"))
Expect(err).ToNot(HaveOccurred())
Expect(written).To(BeTrue())
file.Close()
file, err = os.Open(testPath)
Expect(err).ToNot(HaveOccurred())
Expect(readFile(file)).To(Equal("second write"))
file.Close()
file, err = os.Open(testPath)
written, err = osFs.ConvergeFileContents(testPath, []byte("second write"))
Expect(err).ToNot(HaveOccurred())
Expect(written).To(BeFalse())
Expect(readFile(file)).To(Equal("second write"))
})
})
Context("the file already exists and is write only", func() {
It("writes to file", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "subDir", "ConvergeFileContentsTestFile")
_, err := os.OpenFile(testPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(0200))
Expect(err).ToNot(HaveOccurred())
defer os.Remove(testPath)
err = osFs.WriteFile(testPath, []byte("test"))
Expect(err).ToNot(HaveOccurred())
})
})
Context("the file parent fir does not exist", func() {
BeforeEach(func() {
err := os.RemoveAll(filepath.Join(os.TempDir(), "subDirNew"))
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
err := os.RemoveAll(filepath.Join(os.TempDir(), "subDirNew"))
Expect(err).ToNot(HaveOccurred())
})
It("writes to file", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "subDirNew", "ConvergeFileContentsTestFile")
err := osFs.WriteFile(testPath, []byte("test"))
Expect(err).ToNot(HaveOccurred())
})
})
It("read file", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "ReadFileTestFile")
osFs.WriteFileString(testPath, "some contents")
defer os.Remove(testPath)
content, err := osFs.ReadFile(testPath)
Expect(err).ToNot(HaveOccurred())
Expect("some contents").To(Equal(string(content)))
})
It("file exists", func() {
osFs, _ := createOsFs()
testPath := filepath.Join(os.TempDir(), "FileExistsTestFile")
Expect(osFs.FileExists(testPath)).To(BeFalse())
osFs.WriteFileString(testPath, "initial write")
defer os.Remove(testPath)
Expect(osFs.FileExists(testPath)).To(BeTrue())
})
It("rename", func() {
osFs, _ := createOsFs()
tempDir := os.TempDir()
oldPath := filepath.Join(tempDir, "old")
oldFilePath := filepath.Join(oldPath, "test.txt")
newPath := filepath.Join(tempDir, "new")
os.Mkdir(oldPath, os.ModePerm)
_, err := os.Create(oldFilePath)
Expect(err).ToNot(HaveOccurred())
err = osFs.Rename(oldPath, newPath)
Expect(err).ToNot(HaveOccurred())
Expect(osFs.FileExists(newPath)).To(BeTrue())
newFilePath := filepath.Join(newPath, "test.txt")
Expect(osFs.FileExists(newFilePath)).To(BeTrue())
})
It("symlink", func() {
osFs, _ := createOsFs()
filePath := filepath.Join(os.TempDir(), "SymlinkTestFile")
containingDir := filepath.Join(os.TempDir(), "SubDir")
os.Remove(containingDir)
symlinkPath := filepath.Join(containingDir, "SymlinkTestSymlink")
osFs.WriteFileString(filePath, "some content")
defer os.Remove(filePath)
osFs.Symlink(filePath, symlinkPath)
defer os.Remove(containingDir)
symlinkStats, err := os.Lstat(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect(os.ModeSymlink).To(Equal(os.ModeSymlink & symlinkStats.Mode()))
symlinkFile, err := os.Open(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect("some content").To(Equal(readFile(symlinkFile)))
})
It("symlink when link already exists and links to the intended path", func() {
osFs, _ := createOsFs()
filePath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1File")
symlinkPath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1Symlink")
osFs.WriteFileString(filePath, "some content")
defer os.Remove(filePath)
osFs.Symlink(filePath, symlinkPath)
defer os.Remove(symlinkPath)
firstSymlinkStats, err := os.Lstat(symlinkPath)
Expect(err).ToNot(HaveOccurred())
err = osFs.Symlink(filePath, symlinkPath)
Expect(err).ToNot(HaveOccurred())
secondSymlinkStats, err := os.Lstat(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect(firstSymlinkStats.ModTime()).To(Equal(secondSymlinkStats.ModTime()))
})
It("symlink when link already exists and does not link to the intended path", func() {
osFs, _ := createOsFs()
filePath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1File")
otherFilePath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1OtherFile")
symlinkPath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1Symlink")
osFs.WriteFileString(filePath, "some content")
defer os.Remove(filePath)
osFs.WriteFileString(otherFilePath, "other content")
defer os.Remove(otherFilePath)
err := osFs.Symlink(otherFilePath, symlinkPath)
Expect(err).ToNot(HaveOccurred())
err = osFs.Symlink(filePath, symlinkPath)
Expect(err).ToNot(HaveOccurred())
defer os.Remove(symlinkPath)
symlinkStats, err := os.Lstat(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect(os.ModeSymlink).To(Equal(os.ModeSymlink & symlinkStats.Mode()))
symlinkFile, err := os.Open(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect("some content").To(Equal(readFile(symlinkFile)))
})
It("symlink when a file exists at intended path", func() {
osFs, _ := createOsFs()
filePath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1File")
symlinkPath := filepath.Join(os.TempDir(), "SymlinkTestIdempotent1Symlink")
osFs.WriteFileString(filePath, "some content")
defer os.Remove(filePath)
osFs.WriteFileString(symlinkPath, "some other content")
defer os.Remove(symlinkPath)
err := osFs.Symlink(filePath, symlinkPath)
Expect(err).ToNot(HaveOccurred())
defer os.Remove(symlinkPath)
symlinkStats, err := os.Lstat(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect(os.ModeSymlink).To(Equal(os.ModeSymlink & symlinkStats.Mode()))
symlinkFile, err := os.Open(symlinkPath)
Expect(err).ToNot(HaveOccurred())
Expect("some content").To(Equal(readFile(symlinkFile)))
})
It("read link", func() {
osFs, _ := createOsFs()
filePath := filepath.Join(os.TempDir(), "SymlinkTestFile")
containingDir := filepath.Join(os.TempDir(), "SubDir")
os.Remove(containingDir)
symlinkPath := filepath.Join(containingDir, "SymlinkTestSymlink")
osFs.WriteFileString(filePath, "some content")
defer os.Remove(filePath)
err := osFs.Symlink(filePath, symlinkPath)
Expect(err).ToNot(HaveOccurred())
defer os.Remove(containingDir)
actualFilePath, err := osFs.ReadLink(symlinkPath)
Expect(err).ToNot(HaveOccurred())
// on Mac OS /var -> private/var
absPath, err := filepath.EvalSymlinks(filePath)
Expect(err).ToNot(HaveOccurred())
Expect(actualFilePath).To(Equal(absPath))
})
It("temp file", func() {
osFs, _ := createOsFs()
file1, err := osFs.TempFile("fake-prefix")
Expect(err).ToNot(HaveOccurred())
assert.NotEmpty(GinkgoT(), file1)
defer os.Remove(file1.Name())
file2, err := osFs.TempFile("fake-prefix")
Expect(err).ToNot(HaveOccurred())
assert.NotEmpty(GinkgoT(), file2)
defer os.Remove(file2.Name())
assert.NotEqual(GinkgoT(), file1.Name(), file2.Name())
})
It("temp dir", func() {
osFs, _ := createOsFs()
path1, err := osFs.TempDir("fake-prefix")
Expect(err).ToNot(HaveOccurred())
assert.NotEmpty(GinkgoT(), path1)
defer os.Remove(path1)
path2, err := osFs.TempDir("fake-prefix")
Expect(err).ToNot(HaveOccurred())
assert.NotEmpty(GinkgoT(), path2)
defer os.Remove(path2)
assert.NotEqual(GinkgoT(), path1, path2)
})
Describe("Temporary directories and files", func() {
var (
osFs FileSystem
testTempDir string
)
BeforeEach(func() {
osFs, _ = createOsFs()
var err error
testTempDir, err = ioutil.TempDir("", "os_filesystem_test")
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
os.Remove(testTempDir)
})
Context("a temp root is set", func() {
BeforeEach(func() {
osFs.ChangeTempRoot(testTempDir)
})
It("creates temp files under that root", func() {
file, err := osFs.TempFile("some-file-prefix")
Expect(err).ToNot(HaveOccurred())
Expect(file.Name()).To(HavePrefix(filepath.Join(testTempDir, "some-file-prefix")))
})
It("creates temp directories under that root", func() {
dirName, err := osFs.TempDir("some-dir-prefix")
Expect(err).ToNot(HaveOccurred())
Expect(dirName).To(HavePrefix(filepath.Join(testTempDir, "some-dir-prefix")))
})
})
Context("no temp root is set and was initialized as a strict temp root", func() {
BeforeEach(func() {
osFs = NewOsFileSystemWithStrictTempRoot(boshlog.NewLogger(boshlog.LevelNone))
})
It("should eror", func() {
_, err := osFs.TempFile("some-prefix")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("ChangeTempRoot"))
_, err = osFs.TempDir("some-prefix")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("ChangeTempRoot"))
})
})
})
Describe("CopyFile", func() {
It("copies file", func() {
osFs, _ := createOsFs()
srcPath := "test_assets/test_copy_dir_entries/foo.txt"
dstFile, err := osFs.TempFile("CopyFileTestFile")
Expect(err).ToNot(HaveOccurred())
defer os.Remove(dstFile.Name())
err = osFs.CopyFile(srcPath, dstFile.Name())
fooContent, err := osFs.ReadFileString(dstFile.Name())
Expect(err).ToNot(HaveOccurred())
Expect(fooContent).To(Equal("foo\n"))
})
It("does not leak file descriptors", func() {
osFs, _ := createOsFs()
srcFile, err := osFs.TempFile("srcPath")
Expect(err).ToNot(HaveOccurred())
err = srcFile.Close()
Expect(err).ToNot(HaveOccurred())
dstFile, err := osFs.TempFile("dstPath")
Expect(err).ToNot(HaveOccurred())
err = dstFile.Close()
Expect(err).ToNot(HaveOccurred())
err = osFs.CopyFile(srcFile.Name(), dstFile.Name())
Expect(err).ToNot(HaveOccurred())
runner := NewExecCmdRunner(boshlog.NewLogger(boshlog.LevelNone))
stdout, _, _, err := runner.RunCommand("lsof")
Expect(err).ToNot(HaveOccurred())
for _, line := range strings.Split(stdout, "\n") {
if strings.Contains(line, srcFile.Name()) {
Fail(fmt.Sprintf("CopyFile did not close: srcFile: %s", srcFile.Name()))
}
if strings.Contains(line, dstFile.Name()) {
Fail(fmt.Sprintf("CopyFile did not close: dstFile: %s", dstFile.Name()))
}
}
os.Remove(srcFile.Name())
os.Remove(dstFile.Name())
})
})
Describe("CopyDir", func() {
var fixtureFiles = []string{
"foo.txt",
"bar/bar.txt",
"bar/baz/.gitkeep",
}
It("recursively copies directory contents", func() {
osFs, _ := createOsFs()
srcPath := "test_assets/test_copy_dir_entries"
dstPath, err := osFs.TempDir("CopyDirTestDir")
Expect(err).ToNot(HaveOccurred())
defer osFs.RemoveAll(dstPath)
err = osFs.CopyDir(srcPath, dstPath)
Expect(err).ToNot(HaveOccurred())
for _, fixtureFile := range fixtureFiles {
srcContents, err := osFs.ReadFile(filepath.Join(srcPath, fixtureFile))
Expect(err).ToNot(HaveOccurred())
dstContents, err := osFs.ReadFile(filepath.Join(dstPath, fixtureFile))
Expect(err).ToNot(HaveOccurred())
Expect(srcContents).To(Equal(dstContents), "Copied file does not match source file: '%s", fixtureFile)
}
})
It("does not leak file descriptors", func() {
osFs, _ := createOsFs()
srcPath := "test_assets/test_copy_dir_entries"
dstPath, err := osFs.TempDir("CopyDirTestDir")
Expect(err).ToNot(HaveOccurred())
defer osFs.RemoveAll(dstPath)
err = osFs.CopyDir(srcPath, dstPath)
Expect(err).ToNot(HaveOccurred())
runner := NewExecCmdRunner(boshlog.NewLogger(boshlog.LevelNone))
stdout, _, _, err := runner.RunCommand("lsof")
Expect(err).ToNot(HaveOccurred())
// lsof uses absolute paths
srcPath, err = filepath.Abs(srcPath)
Expect(err).ToNot(HaveOccurred())
for _, line := range strings.Split(stdout, "\n") {
for _, fixtureFile := range fixtureFiles {
srcFilePath := filepath.Join(srcPath, fixtureFile)
if strings.Contains(line, srcFilePath) {
Fail(fmt.Sprintf("CopyDir did not close source file: %s", srcFilePath))
}
srcFileDirPath := filepath.Dir(srcFilePath)
if strings.Contains(line, srcFileDirPath) {
Fail(fmt.Sprintf("CopyDir did not close source dir: %s", srcFileDirPath))
}
dstFilePath := filepath.Join(dstPath, fixtureFile)
if strings.Contains(line, dstFilePath) {
Fail(fmt.Sprintf("CopyDir did not close destination file: %s", dstFilePath))
}
dstFileDirPath := filepath.Dir(dstFilePath)
if strings.Contains(line, dstFileDirPath) {
Fail(fmt.Sprintf("CopyDir did not close destination dir: %s", dstFileDirPath))
}
}
}
})
})
It("remove all", func() {
osFs, _ := createOsFs()
dstFile, err := osFs.TempFile("CopyFileTestFile")
Expect(err).ToNot(HaveOccurred())
defer os.Remove(dstFile.Name())
err = osFs.RemoveAll(dstFile.Name())
Expect(err).ToNot(HaveOccurred())
_, err = os.Stat(dstFile.Name())
Expect(os.IsNotExist(err)).To(BeTrue())
})
})
}
"github.com/cloudfoundry/bosh-agent/agent/action"
"github.com/cloudfoundry/bosh-agent/internal/github.com/cloudfoundry/bosh-utils/logger"
"github.com/cloudfoundry/bosh-agent/platform/cert/fakes"
boshsettings "github.com/cloudfoundry/bosh-agent/settings"
)
var _ = Describe("UpdateSettings", func() {
var (
updateAction action.UpdateSettingsAction
certManager *fakes.FakeManager
log logger.Logger
)
BeforeEach(func() {
log = logger.NewLogger(logger.LevelNone)
certManager = new(fakes.FakeManager)
updateAction = action.NewUpdateSettings(certManager, log)
})
It("is asynchronous", func() {
Expect(updateAction.IsAsynchronous()).To(BeTrue())
})
It("is not persistent", func() {
Expect(updateAction.IsPersistent()).To(BeFalse())
})
It("returns 'updated' on success", func() {
newSettings := boshsettings.Settings{}
result, err := updateAction.Run(newSettings)
func init() {
Describe("compiledPackageApplier", func() {
var (
packagesBc *fakebc.FakeBundleCollection
blobstore *fakeblob.FakeBlobstore
compressor *fakecmd.FakeCompressor
fs *fakesys.FakeFileSystem
logger boshlog.Logger
applier Applier
)
BeforeEach(func() {
packagesBc = fakebc.NewFakeBundleCollection()
blobstore = fakeblob.NewFakeBlobstore()
compressor = fakecmd.NewFakeCompressor()
fs = fakesys.NewFakeFileSystem()
logger = boshlog.NewLogger(boshlog.LevelNone)
applier = NewCompiledPackageApplier(packagesBc, true, blobstore, compressor, fs, logger)
})
Describe("Prepare & Apply", func() {
var (
pkg models.Package
bundle *fakebc.FakeBundle
)
BeforeEach(func() {
pkg, bundle = buildPkg(packagesBc)
})
ItInstallsPkg := func(act func() error) {
It("returns error when installing package 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 package 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 package 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 package 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 package blob fails", func() {
compressor.DecompressFileToDirErr = errors.New("fake-decompress-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-decompress-error"))
})
It("installs bundle from decompressed tmp path of a package blob", 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"))
})
}
Describe("Prepare", func() {
act := func() error { return applier.Prepare(pkg) }
It("return an error if getting file bundle fails", func() {
packagesBc.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 package installation 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 package 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 package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
})
Context("when package is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs package (but does not enable it)", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install"}))
})
ItInstallsPkg(act)
})
})
Describe("Apply", func() {
act := func() error { return applier.Apply(pkg) }
It("return an error if getting file bundle fails", func() {
packagesBc.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 package installation 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 package is already installed", func() {
BeforeEach(func() {
bundle.Installed = true
})
It("does not install but only enables package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Enable"})) // no Install
})
It("returns error when package 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 package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.GetBlobIDs).To(BeNil())
})
})
Context("when package is not installed", func() {
BeforeEach(func() {
bundle.Installed = false
})
It("installs and enables package", func() {
err := act()
Expect(err).ToNot(HaveOccurred())
Expect(bundle.ActionsCalled).To(Equal([]string{"Install", "Enable"}))
})
It("returns error when package enable fails", func() {
bundle.EnableError = errors.New("fake-enable-error")
err := act()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-enable-error"))
})
ItInstallsPkg(act)
})
})
})
Describe("KeepOnly", func() {
ItReturnsErrors := func() {
It("returns error when bundle collection fails to return list of installed bundles", func() {
packagesBc.ListErr = errors.New("fake-bc-list-error")
err := applier.KeepOnly([]models.Package{})
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 package", func() {
pkg1, bundle1 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1}
packagesBc.GetErr = errors.New("fake-bc-get-error")
err := applier.KeepOnly([]models.Package{pkg1})
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 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.DisableErr = errors.New("fake-bc-disable-error")
err := applier.KeepOnly([]models.Package{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-disable-error"))
})
}
Context("when operating on packages as a package owner", func() {
BeforeEach(func() {
applier = NewCompiledPackageApplier(packagesBc, true, blobstore, compressor, fs, logger)
})
It("first disables and then uninstalls packages that are not in keeponly list", func() {
_, bundle1 := buildPkg(packagesBc)
pkg2, bundle2 := buildPkg(packagesBc)
_, bundle3 := buildPkg(packagesBc)
pkg4, bundle4 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1, bundle2, bundle3, bundle4}
err := applier.KeepOnly([]models.Package{pkg4, pkg2})
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{}))
})
ItReturnsErrors()
It("returns error when at least one bundle cannot be uninstalled", func() {
_, bundle1 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1}
bundle1.UninstallErr = errors.New("fake-bc-uninstall-error")
err := applier.KeepOnly([]models.Package{})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-bc-uninstall-error"))
})
})
Context("when operating on packages not as a package owner", func() {
BeforeEach(func() {
applier = NewCompiledPackageApplier(packagesBc, false, blobstore, compressor, fs, logger)
})
It("disables and but does not uninstall packages that are not in keeponly list", func() {
_, bundle1 := buildPkg(packagesBc)
pkg2, bundle2 := buildPkg(packagesBc)
_, bundle3 := buildPkg(packagesBc)
pkg4, bundle4 := buildPkg(packagesBc)
packagesBc.ListBundles = []boshbc.Bundle{bundle1, bundle2, bundle3, bundle4}
err := applier.KeepOnly([]models.Package{pkg4, pkg2})
Expect(err).ToNot(HaveOccurred())
Expect(bundle1.ActionsCalled).To(Equal([]string{"Disable"})) // no Uninstall
Expect(bundle2.ActionsCalled).To(Equal([]string{}))
Expect(bundle3.ActionsCalled).To(Equal([]string{"Disable"})) // no Uninstall
Expect(bundle4.ActionsCalled).To(Equal([]string{}))
})
ItReturnsErrors()
})
})
})
}
func createOsFs() (fs FileSystem, runner CmdRunner) {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs = NewOsFileSystem(logger)
return
}
func init() {
Describe("provider", func() {
var (
platform *fakeplatform.FakePlatform
client *fakemonit.FakeMonitClient
logger boshlog.Logger
dirProvider boshdir.Provider
jobFailuresServerPort int
handler *fakembus.FakeHandler
provider Provider
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
client = fakemonit.NewFakeMonitClient()
logger = boshlog.NewLogger(boshlog.LevelNone)
dirProvider = boshdir.NewProvider("/fake-base-dir")
jobFailuresServerPort = 2825
handler = &fakembus.FakeHandler{}
provider = NewProvider(
platform,
client,
logger,
dirProvider,
handler,
)
})
It("provides a monit job supervisor", func() {
actualSupervisor, err := provider.Get("monit")
Expect(err).ToNot(HaveOccurred())
expectedSupervisor := NewMonitJobSupervisor(
platform.Fs,
platform.Runner,
client,
logger,
dirProvider,
jobFailuresServerPort,
MonitReloadOptions{
MaxTries: 3,
MaxCheckTries: 6,
DelayBetweenCheckTries: 5 * time.Second,
},
)
Expect(actualSupervisor).To(Equal(expectedSupervisor))
})
It("provides a dummy job supervisor", func() {
actualSupervisor, err := provider.Get("dummy")
Expect(err).ToNot(HaveOccurred())
expectedSupervisor := NewDummyJobSupervisor()
Expect(actualSupervisor).To(Equal(expectedSupervisor))
})
It("provides a dummy nats job supervisor", func() {
actualSupervisor, err := provider.Get("dummy-nats")
Expect(err).NotTo(HaveOccurred())
expectedSupervisor := NewDummyNatsJobSupervisor(handler)
Expect(actualSupervisor).To(Equal(expectedSupervisor))
})
It("returns an error when the supervisor is not found", func() {
_, err := provider.Get("does-not-exist")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("does-not-exist could not be found"))
})
})
}
boshblob "github.com/cloudfoundry/bosh-agent/internal/github.com/cloudfoundry/bosh-utils/blobstore"
fakeblob "github.com/cloudfoundry/bosh-agent/internal/github.com/cloudfoundry/bosh-utils/blobstore/fakes"
bosherr "github.com/cloudfoundry/bosh-agent/internal/github.com/cloudfoundry/bosh-utils/errors"
boshlog "github.com/cloudfoundry/bosh-agent/internal/github.com/cloudfoundry/bosh-utils/logger"
)
var _ = Describe("retryableBlobstore", func() {
var (
innerBlobstore *fakeblob.FakeBlobstore
logger boshlog.Logger
retryableBlobstore boshblob.Blobstore
)
BeforeEach(func() {
innerBlobstore = &fakeblob.FakeBlobstore{}
logger = boshlog.NewLogger(boshlog.LevelNone)
retryableBlobstore = boshblob.NewRetryableBlobstore(innerBlobstore, 3, logger)
})
Describe("Get", func() {
Context("when inner blobstore succeeds before maximum number of get tries (first time)", func() {
It("returns path without an error", func() {
innerBlobstore.GetFileName = "fake-path"
path, err := retryableBlobstore.Get("fake-blob-id", "fake-fingerprint")
Expect(err).ToNot(HaveOccurred())
Expect(path).To(Equal("fake-path"))
Expect(innerBlobstore.GetBlobIDs).To(Equal([]string{"fake-blob-id"}))
Expect(innerBlobstore.GetFingerprints).To(Equal([]string{"fake-fingerprint"}))
})
func describeConfigDriveMetadataService() {
var (
metadataService MetadataService
resolver *fakeinf.FakeDNSResolver
platform *fakeplatform.FakePlatform
logger boshlog.Logger
)
updateMetadata := func(metadataContents MetadataContentsType) {
metadataJSON, err := json.Marshal(metadataContents)
Expect(err).ToNot(HaveOccurred())
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", metadataJSON, nil)
Expect(metadataService.IsAvailable()).To(BeTrue())
}
updateUserdata := func(userdataContents string) {
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte(userdataContents), nil)
Expect(metadataService.IsAvailable()).To(BeTrue())
}
BeforeEach(func() {
resolver = &fakeinf.FakeDNSResolver{}
platform = fakeplatform.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
diskPaths := []string{
"/fake-disk-path-1",
"/fake-disk-path-2",
}
metadataService = NewConfigDriveMetadataService(
resolver,
platform,
diskPaths,
"fake-metadata-path",
"fake-userdata-path",
logger,
)
userdataContents := fmt.Sprintf(`{"server":{"name":"fake-server-name"},"registry":{"endpoint":"fake-registry-endpoint"}}`)
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte(userdataContents), nil)
metadata := MetadataContentsType{
PublicKeys: map[string]PublicKeyType{
"0": PublicKeyType{
"openssh-key": "fake-openssh-key",
},
},
InstanceID: "fake-instance-id",
}
updateMetadata(metadata)
})
Describe("GetNetworks", func() {
It("returns the network settings", func() {
userdataContents := `
{
"networks": {
"network_1": {"type": "manual", "ip": "1.2.3.4", "netmask": "2.3.4.5", "gateway": "3.4.5.6", "default": ["dns"], "dns": ["8.8.8.8"], "mac": "fake-mac-address-1"},
"network_2": {"type": "dynamic", "default": ["dns"], "dns": ["8.8.8.8"], "mac": "fake-mac-address-2"}
}
}`
updateUserdata(userdataContents)
networks, err := metadataService.GetNetworks()
Expect(err).ToNot(HaveOccurred())
Expect(networks).To(Equal(boshsettings.Networks{
"network_1": boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "2.3.4.5",
Gateway: "3.4.5.6",
Default: []string{"dns"},
DNS: []string{"8.8.8.8"},
Mac: "fake-mac-address-1",
},
"network_2": boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8"},
Mac: "fake-mac-address-2",
},
}))
})
It("returns a nil Networks if the settings are missing (from an old CPI version)", func() {
userdataContents := `{}`
updateUserdata(userdataContents)
networks, err := metadataService.GetNetworks()
Expect(err).ToNot(HaveOccurred())
Expect(networks).To(BeNil())
})
})
Describe("IsAvailable", func() {
It("return true when it can load successfully", func() {
Expect(metadataService.IsAvailable()).To(BeTrue())
})
It("returns an error if it fails to read meta-data.json from disk", func() {
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte{}, errors.New("fake-read-disk-error"))
Expect(metadataService.IsAvailable()).To(BeFalse())
})
It("tries to load meta-data.json from potential disk locations", func() {
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte{}, errors.New("fake-read-disk-error"))
Expect(metadataService.IsAvailable()).To(BeFalse())
Expect(platform.GetFileContentsFromDiskDiskPaths).To(ContainElement("/fake-disk-path-1"))
Expect(platform.GetFileContentsFromDiskDiskPaths).To(ContainElement("/fake-disk-path-2"))
})
It("returns an error if it fails to parse meta-data.json contents", func() {
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-metadata-path", []byte("broken"), nil)
Expect(metadataService.IsAvailable()).To(BeFalse())
})
It("returns an error if it fails to read user_data from disk", func() {
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte{}, errors.New("fake-read-disk-error"))
Expect(metadataService.IsAvailable()).To(BeFalse())
})
It("returns an error if it fails to parse user_data contents", func() {
platform.SetGetFilesContentsFromDisk("/fake-disk-path-1/fake-userdata-path", []byte("broken"), nil)
Expect(metadataService.IsAvailable()).To(BeFalse())
})
Context("when disk paths are not given", func() {
It("returns false", func() {
metadataService = NewConfigDriveMetadataService(
resolver,
platform,
[]string{},
"fake-metadata-path",
"fake-userdata-path",
logger,
)
Expect(metadataService.IsAvailable()).To(BeFalse())
})
})
})
Describe("GetPublicKey", func() {
It("returns public key", func() {
value, err := metadataService.GetPublicKey()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("fake-openssh-key"))
})
It("returns an error if it fails to get ssh key", func() {
updateMetadata(MetadataContentsType{})
value, err := metadataService.GetPublicKey()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Failed to load openssh-key from config drive metadata service"))
Expect(value).To(Equal(""))
})
})
Describe("GetInstanceID", func() {
It("returns instance id", func() {
value, err := metadataService.GetInstanceID()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("fake-instance-id"))
})
It("returns an error if it fails to get instance id", func() {
updateMetadata(MetadataContentsType{})
value, err := metadataService.GetInstanceID()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Failed to load instance-id from config drive metadata service"))
Expect(value).To(Equal(""))
})
})
Describe("GetServerName", func() {
It("returns server name", func() {
value, err := metadataService.GetServerName()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("fake-server-name"))
})
It("returns an error if it fails to get server name", func() {
updateUserdata("{}")
value, err := metadataService.GetServerName()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Failed to load server name from config drive metadata service"))
Expect(value).To(Equal(""))
})
})
Describe("GetRegistryEndpoint", func() {
It("returns an error if it fails to get registry endpoint", func() {
updateUserdata("{}")
value, err := metadataService.GetRegistryEndpoint()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Failed to load registry endpoint from config drive metadata service"))
Expect(value).To(Equal(""))
})
Context("when user_data does not contain a dns server", func() {
It("returns registry endpoint", func() {
value, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(HaveOccurred())
Expect(value).To(Equal("fake-registry-endpoint"))
})
})
Context("when user_data contains a dns server", func() {
BeforeEach(func() {
userdataContents := fmt.Sprintf(
`{"server":{"name":"%s"},"registry":{"endpoint":"%s"},"dns":{"nameserver":["%s"]}}`,
"fake-server-name",
"http://fake-registry.com",
"fake-dns-server-ip",
)
updateUserdata(userdataContents)
})
Context("when registry endpoint is successfully resolved", func() {
BeforeEach(func() {
resolver.RegisterRecord(fakeinf.FakeDNSRecord{
DNSServers: []string{"fake-dns-server-ip"},
Host: "http://fake-registry.com",
IP: "http://fake-registry-ip",
})
})
It("returns the successfully resolved registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry-ip"))
})
})
Context("when registry endpoint is not successfully resolved", func() {
BeforeEach(func() {
resolver.LookupHostErr = errors.New("fake-lookup-host-err")
})
It("returns error because it failed to resolve registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err"))
Expect(endpoint).To(BeEmpty())
})
})
})
})
}