package disk_test
import (
"errors"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/platform/disk"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("procMountsSearcher", func() {
var (
fs *fakesys.FakeFileSystem
searcher MountsSearcher
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
searcher = NewProcMountsSearcher(fs)
})
Describe("SearchMounts", func() {
Context("when reading /proc/mounts succeeds", func() {
It("returns parsed mount information", func() {
fs.WriteFileString(
"/proc/mounts",
`none /run/lock tmpfs rw,nosuid,nodev,noexec,relatime,size=5120k 0 0
none /run/shm tmpfs rw,nosuid,nodev,relatime 0 0
/dev/sda1 /boot ext2 rw,relatime,errors=continue 0 0
"errors"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/release"
fakecmd "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/fileutil/fakes"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
bireljob "github.com/cloudfoundry/bosh-init/release/job"
birelpkg "github.com/cloudfoundry/bosh-init/release/pkg"
)
var _ = Describe("tarReader", func() {
var (
reader Reader
fakeFs *fakesys.FakeFileSystem
compressor *fakecmd.FakeCompressor
)
BeforeEach(func() {
fakeFs = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
reader = NewReader("/some/release.tgz", "/extracted/release", fakeFs, compressor)
})
Describe("Read", func() {
Context("when the given release archive is a valid tar", func() {
Context("when the release manifest is valid", func() {
BeforeEach(func() {
fakeFs.WriteFileString(
"/extracted/release/release.MF",
var ( fs *fakesys.FakeFileSystem logger boshlog.Logger releaseManager birel.Manager mockCpiInstaller *mock_install.MockInstaller mockCpiUninstaller *mock_install.MockUninstaller mockInstallerFactory *mock_install.MockInstallerFactory mockCloudFactory *mock_cloud.MockFactory mockReleaseExtractor *mock_release.MockExtractor fakeUUIDGenerator *fakeuuid.FakeGenerator setupDeploymentStateService biconfig.DeploymentStateService fakeInstallation *fakecmd.FakeInstallation fakeUI *fakeui.FakeUI mockBlobstoreFactory *mock_blobstore.MockFactory mockBlobstore *mock_blobstore.MockBlobstore mockDeploymentManagerFactory *mock_deployment.MockManagerFactory mockDeploymentManager *mock_deployment.MockManager mockDeployment *mock_deployment.MockDeployment mockAgentClient *mock_agentclient.MockAgentClient mockAgentClientFactory *mock_httpagent.MockAgentClientFactory mockCloud *mock_cloud.MockCloud fakeStage *fakebiui.FakeStage directorID string deploymentManifestPath = "/deployment-dir/fake-deployment-manifest.yml" deploymentStatePath string expectCPIExtractRelease *gomock.Call expectCPIInstall *gomock.Call expectNewCloud *gomock.Call mbusURL = "http://*****:*****@fake-mbus-endpoint" )
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{}))
})
})
})
}
var (
fs *fakesys.FakeFileSystem
logger boshlog.Logger
registryServerManager biregistry.ServerManager
releaseManager birel.Manager
mockInstaller *mock_install.MockInstaller
mockInstallerFactory *mock_install.MockInstallerFactory
mockCloudFactory *mock_cloud.MockFactory
mockCloud *mock_cloud.MockCloud
mockAgentClient *mock_agentclient.MockAgentClient
mockAgentClientFactory *mock_httpagent.MockAgentClientFactory
mockReleaseExtractor *mock_release.MockExtractor
mockStateBuilderFactory *mock_instance_state.MockBuilderFactory
mockStateBuilder *mock_instance_state.MockBuilder
mockState *mock_instance_state.MockState
mockBlobstoreFactory *mock_blobstore.MockFactory
mockBlobstore *mock_blobstore.MockBlobstore
fakeStemcellExtractor *fakebistemcell.FakeExtractor
fakeUUIDGenerator *fakeuuid.FakeGenerator
fakeRegistryUUIDGenerator *fakeuuid.FakeGenerator
fakeRepoUUIDGenerator *fakeuuid.FakeGenerator
fakeAgentIDGenerator *fakeuuid.FakeGenerator
fakeSHA1Calculator *fakebicrypto.FakeSha1Calculator
legacyDeploymentStateMigrator biconfig.LegacyDeploymentStateMigrator
deploymentStateService biconfig.DeploymentStateService
vmRepo biconfig.VMRepo
diskRepo biconfig.DiskRepo
stemcellRepo biconfig.StemcellRepo
deploymentRepo biconfig.DeploymentRepo
releaseRepo biconfig.ReleaseRepo
sshTunnelFactory bisshtunnel.Factory
diskManagerFactory bidisk.ManagerFactory
diskDeployer bivm.DiskDeployer
stdOut *gbytes.Buffer
stdErr *gbytes.Buffer
fakeStage *fakebiui.FakeStage
stemcellManagerFactory bistemcell.ManagerFactory
vmManagerFactory bivm.ManagerFactory
applySpec bias.ApplySpec
directorID string
stemcellTarballPath = "/fake-stemcell-release.tgz"
deploymentManifestPath = "/deployment-dir/fake-deployment-manifest.yml"
deploymentStatePath = "/deployment-dir/fake-deployment-manifest-state.json"
stemcellImagePath = "fake-stemcell-image-path"
stemcellCID = "fake-stemcell-cid"
stemcellCloudProperties = biproperty.Map{}
vmCloudProperties = biproperty.Map{}
vmEnv = biproperty.Map{}
diskCloudProperties = biproperty.Map{}
networkInterfaces = map[string]biproperty.Map{
"network-1": biproperty.Map{
"type": "dynamic",
"default": []bideplmanifest.NetworkDefault{"dns", "gateway"},
"cloud_properties": biproperty.Map{},
},
}
agentRunningState = biagentclient.AgentState{JobState: "running"}
mbusURL = "http://fake-mbus-url"
expectHasVM1 *gomock.Call
expectDeleteVM1 *gomock.Call
sshConfig *SSHConfig
)
package release_test
import (
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
bireljob "github.com/cloudfoundry/bosh-init/release/job"
birelpkg "github.com/cloudfoundry/bosh-init/release/pkg"
. "github.com/cloudfoundry/bosh-init/release"
)
var _ = Describe("Release", func() {
var (
release Release
expectedJob bireljob.Job
fakeFS *fakesys.FakeFileSystem
)
BeforeEach(func() {
expectedJob = bireljob.Job{
Name: "fake-job-name",
}
fakeFS = fakesys.NewFakeFileSystem()
release = NewRelease(
"fake-release-name",
"fake-release-version",
[]bireljob.Job{expectedJob},
[]*birelpkg.Package{},
"fake-extracted-path",
fakeFS,
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
bireljob "github.com/cloudfoundry/bosh-init/release/job"
bierbrenderer "github.com/cloudfoundry/bosh-init/templatescompiler/erbrenderer"
fakebirender "github.com/cloudfoundry/bosh-init/templatescompiler/erbrenderer/fakes"
. "github.com/cloudfoundry/bosh-init/templatescompiler"
)
var _ = Describe("JobRenderer", func() {
var (
jobRenderer JobRenderer
fakeERBRenderer *fakebirender.FakeERBRenderer
job bireljob.Job
context bierbrenderer.TemplateEvaluationContext
fs *fakesys.FakeFileSystem
jobProperties biproperty.Map
globalProperties biproperty.Map
srcPath string
dstPath string
)
BeforeEach(func() {
srcPath = "fake-src-path"
dstPath = "fake-dst-path"
jobProperties = biproperty.Map{
"fake-property-key": "fake-job-property-value",
}
globalProperties = biproperty.Map{
"fake-property-key": "fake-global-property-value",
import (
"errors"
biindex "github.com/cloudfoundry/bosh-init/index"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
birelpkg "github.com/cloudfoundry/bosh-init/release/pkg"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/state/pkg"
)
var _ = Describe("CompiledPackageRepo", func() {
var (
index biindex.Index
compiledPackageRepo CompiledPackageRepo
fakeFS *fakesys.FakeFileSystem
)
BeforeEach(func() {
fakeFS = fakesys.NewFakeFileSystem()
index = biindex.NewFileIndex("/index_file", fakeFS)
compiledPackageRepo = NewCompiledPackageRepo(index)
})
Context("Save and Find", func() {
var (
record CompiledPackageRecord
dependency birelpkg.Package
pkg birelpkg.Package
)
import (
"encoding/json"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
boshsettings "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/settings"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/infrastructure"
)
var _ = Describe("FileRegistry", func() {
var (
fs *fakesys.FakeFileSystem
fileRegistry Registry
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
fileRegistry = NewFileRegistry("/fake-registry-file-path", fs)
})
Describe("GetSettings", func() {
Context("when the registry file exists", func() {
var (
expectedSettings boshsettings.Settings
)
BeforeEach(func() {
expectedSettings = boshsettings.Settings{
package crypto_test
import (
"errors"
"os"
. "github.com/cloudfoundry/bosh-init/crypto"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
)
var _ = Describe("Sha1Calculator", func() {
var (
fs *fakesys.FakeFileSystem
sha1Calculator SHA1Calculator
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
sha1Calculator = NewSha1Calculator(fs)
})
Describe("Calculate", func() {
Context("when path is directory", func() {
BeforeEach(func() {
fs.RegisterOpenFile("/fake-templates-dir", &fakesys.FakeFile{
Stats: &fakesys.FakeFileStats{FileType: fakesys.FakeFileTypeDir},
})
fs.RegisterOpenFile("/fake-templates-dir/file-1", &fakesys.FakeFile{
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
boshdevutil "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/platform/deviceutil"
fakedisk "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/platform/disk/fakes"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/platform/disk"
)
var _ = Describe("Diskutil", func() {
var (
diskUtil boshdevutil.DeviceUtil
mounter *fakedisk.FakeMounter
fs *fakesys.FakeFileSystem
)
BeforeEach(func() {
mounter = &fakedisk.FakeMounter{}
fs = fakesys.NewFakeFileSystem()
logger := boshlog.NewLogger(boshlog.LevelNone)
diskUtil = NewDiskUtil("fake-disk-path", mounter, fs, logger)
})
Describe("GetFileContents", func() {
Context("when disk path does not exist", func() {
It("returns an error if diskpath does not exist", func() {
_, err := diskUtil.GetFilesContents([]string{"fake-file-path-1"})
Expect(err).To(HaveOccurred())
import (
"errors"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/templatescompiler/erbrenderer"
fakebierbrenderer "github.com/cloudfoundry/bosh-init/templatescompiler/erbrenderer/fakes"
)
var _ = Describe("ErbRenderer", func() {
var (
fs *fakesys.FakeFileSystem
runner *fakesys.FakeCmdRunner
erbRenderer ERBRenderer
context *fakebierbrenderer.FakeTemplateEvaluationContext
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs = fakesys.NewFakeFileSystem()
runner = fakesys.NewFakeCmdRunner()
context = &fakebierbrenderer.FakeTemplateEvaluationContext{}
erbRenderer = NewERBRenderer(fs, runner, logger)
fs.TempDirDir = "fake-temp-dir"
})
It("constructs ruby erb rendering command", func() {
err := erbRenderer.Render("fake-src-path", "fake-dst-path", context)
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
birelmanifest "github.com/cloudfoundry/bosh-init/release/manifest"
"github.com/cloudfoundry/bosh-init/release/set/manifest"
"github.com/cloudfoundry/bosh-init/release/set/manifest/fakes"
)
var _ = Describe("Parser", func() {
comboManifestPath := "/path/to/manifest/fake-deployment-manifest"
var (
fakeFs *fakesys.FakeFileSystem
parser manifest.Parser
fakeValidator *fakes.FakeValidator
)
BeforeEach(func() {
fakeFs = fakesys.NewFakeFileSystem()
logger := boshlog.NewLogger(boshlog.LevelNone)
fakeValidator = fakes.NewFakeValidator()
fakeValidator.SetValidateBehavior([]fakes.ValidateOutput{
{Err: nil},
})
parser = manifest.NewParser(fakeFs, logger, fakeValidator)
fakeFs.WriteFileString(comboManifestPath, `
---
releases:
- name: fake-release-name-1
})
It("returns an empty slice for an empty string", func() {
result := cert.SplitCerts("")
Expect(len(result)).To(Equal(0))
})
It("returns an empty slice for an non-empty string that does not contain any certificates", func() {
result := cert.SplitCerts("abcdefghij")
Expect(len(result)).To(Equal(0))
})
})
Describe("DeleteFile()", func() {
var (
fakeFs *fakesys.FakeFileSystem
)
BeforeEach(func() {
fakeFs = fakesys.NewFakeFileSystem()
})
It("only deletes the files with the given prefix", func() {
fakeFs.WriteFileString("/path/to/delete/stuff/in/delete_me_1.foo", "goodbye")
fakeFs.WriteFileString("/path/to/delete/stuff/in/delete_me_2.foo", "goodbye")
fakeFs.WriteFileString("/path/to/delete/stuff/in/different_file_1.bar", "goodbye")
fakeFs.SetGlob("/path/to/delete/stuff/in/delete_me_*", []string{
"/path/to/delete/stuff/in/delete_me_1.foo",
"/path/to/delete/stuff/in/delete_me_2.foo",
})
count, err := cert.DeleteFiles(fakeFs, "/path/to/delete/stuff/in/", "delete_me_")
package infrastructure_test
import (
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/infrastructure"
boshsettings "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/settings"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("FileMetadataService", func() {
var (
fs *fakesys.FakeFileSystem
metadataService MetadataService
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
logger := boshlog.NewLogger(boshlog.LevelNone)
metadataService = NewFileMetadataService(
"fake-metadata-file-path",
"fake-userdata-file-path",
"fake-settings-file-path",
fs,
logger,
)
})
Describe("GetInstanceID", func() {
bosherr "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/errors"
fakecmd "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/fileutil/fakes"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
bireljob "github.com/cloudfoundry/bosh-init/release/job"
birelpkg "github.com/cloudfoundry/bosh-init/release/pkg"
fakebirel "github.com/cloudfoundry/bosh-init/release/fakes"
)
var _ = Describe("Extractor", func() {
var (
fakeFS *fakesys.FakeFileSystem
compressor *fakecmd.FakeCompressor
fakeReleaseValidator *fakebirel.FakeValidator
releaseExtractor Extractor
)
BeforeEach(func() {
fakeFS = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
fakeReleaseValidator = fakebirel.NewFakeValidator()
logger := boshlog.NewLogger(boshlog.LevelNone)
releaseExtractor = NewExtractor(fakeFS, compressor, fakeReleaseValidator, logger)
})
Describe("Extract", func() {
var (
releaseTarballPath string
)
var mockCtrl *gomock.Controller
BeforeEach(func() {
mockCtrl = gomock.NewController(GinkgoT())
})
AfterEach(func() {
mockCtrl.Finish()
})
Describe("Run", func() {
var (
mockDeploymentDeleter *mock_cmd.MockDeploymentDeleter
fs *fakesys.FakeFileSystem
logger boshlog.Logger
fakeUI *fakeui.FakeUI
fakeStage *fakebiui.FakeStage
deploymentManifestPath = "/deployment-dir/fake-deployment-manifest.yml"
)
var newDeleteCmd = func() bicmd.Cmd {
doGetFunc := func(deploymentManifestPath string) (bicmd.DeploymentDeleter, error) {
Expect(deploymentManifestPath).To(Equal(deploymentManifestPath))
return mockDeploymentDeleter, nil
}
return bicmd.NewDeleteCmd(fakeUI, fs, logger, doGetFunc)
}
var writeDeploymentManifest = func() {
. "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger/file"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
boshsys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system"
fakeboshsys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
func expectedLogFormat(tag, msg string) string {
return fmt.Sprintf("\\[%s\\] [0-9]{4}/[0-9]{2}/[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2} %s\n", tag, msg)
}
var _ = Describe("NewFileLogger", func() {
var (
fs *fakeboshsys.FakeFileSystem
logFile boshsys.File
)
BeforeEach(func() {
fs = fakeboshsys.NewFakeFileSystem()
var err error
logFile, err = fs.TempFile("file-logger-test")
Expect(err).ToNot(HaveOccurred())
err = logFile.Close()
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
logFile.Close()
fs.RemoveAll(logFile.Name())
})
bidisk "github.com/cloudfoundry/bosh-init/deployment/disk"
bideplmanifest "github.com/cloudfoundry/bosh-init/deployment/manifest"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
biproperty "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/property"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
fakeuuid "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/uuid/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
fakebiui "github.com/cloudfoundry/bosh-init/ui/fakes"
)
var _ = Describe("Manager", func() {
var (
manager Manager
fakeCloud *fakebicloud.FakeCloud
fakeFs *fakesys.FakeFileSystem
fakeUUIDGenerator *fakeuuid.FakeGenerator
diskRepo biconfig.DiskRepo
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fakeFs = fakesys.NewFakeFileSystem()
fakeUUIDGenerator = &fakeuuid.FakeGenerator{}
deploymentStateService := biconfig.NewFileSystemDeploymentStateService(fakeFs, fakeUUIDGenerator, logger, "/fake/path")
diskRepo = biconfig.NewDiskRepo(deploymentStateService, fakeUUIDGenerator)
managerFactory := NewManagerFactory(diskRepo, logger)
fakeCloud = fakebicloud.NewFakeCloud()
manager = managerFactory.NewManager(fakeCloud)
fakeUUIDGenerator.GeneratedUUID = "fake-uuid"
})
package tarball_test
import (
. "github.com/cloudfoundry/bosh-init/installation/tarball"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
)
var _ = Describe("Cache", func() {
var (
cache Cache
fs *fakesys.FakeFileSystem
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs = fakesys.NewFakeFileSystem()
cache = NewCache(
"/fake-base-path",
fs,
logger,
)
})
It("is a cache hit when the tarball with that url and sha1 has been downloaded", func() {
fs.WriteFileString("source-path", "")
err := cache.Save("source-path", &fakeSource{
sha1: "fake-sha1",
BeforeEach(func() {
mockCtrl = gomock.NewController(GinkgoT())
})
AfterEach(func() {
mockCtrl.Finish()
})
var (
logger boshlog.Logger
compiler bistatepkg.Compiler
runner *fakesys.FakeCmdRunner
pkg *birelpkg.Package
fs *fakesys.FakeFileSystem
compressor *fakecmd.FakeCompressor
packagesDir string
blobstore *fakeblobstore.FakeBlobstore
mockCompiledPackageRepo *mock_state_package.MockCompiledPackageRepo
fakeExtractor *fakeblobextract.FakeExtractor
dependency1 *birelpkg.Package
dependency2 *birelpkg.Package
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
packagesDir = "fake-packages-dir"
runner = fakesys.NewFakeCmdRunner()
fs = fakesys.NewFakeFileSystem()
compressor = fakecmd.NewFakeCompressor()
fakeblobstore "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/blobstore/fakes"
fakecmd "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/fileutil/fakes"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
)
var _ = Describe("Extractor", func() {
var (
extractor Extractor
blobstore *fakeblobstore.FakeBlobstore
targetDir string
compressor *fakecmd.FakeCompressor
logger boshlog.Logger
fs *fakesys.FakeFileSystem
blobID string
blobSHA1 string
fileName string
fakeError error
)
BeforeEach(func() {
blobstore = fakeblobstore.NewFakeBlobstore()
targetDir = "fake-target-dir"
compressor = fakecmd.NewFakeCompressor()
logger = boshlog.NewLogger(boshlog.LevelNone)
fs = fakesys.NewFakeFileSystem()
blobID = "fake-blob-id"
blobSHA1 = "fake-sha1"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/stemcell"
biproperty "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/property"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
fakebistemcell "github.com/cloudfoundry/bosh-init/stemcell/fakes"
)
var _ = Describe("Manager", func() {
var (
extractor Extractor
fs *fakesys.FakeFileSystem
reader *fakebistemcell.FakeStemcellReader
stemcellTarballPath string
stemcellExtractionDir string
expectedExtractedStemcell ExtractedStemcell
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
reader = fakebistemcell.NewFakeReader()
stemcellTarballPath = "/stemcell/tarball/path"
stemcellExtractionDir = "/path/to/dest"
fs.TempDirDir = stemcellExtractionDir
extractor = NewExtractor(reader, fs)
expectedExtractedStemcell = NewExtractedStemcell(
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))
})
})
})
})
})
}
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
"os"
bosherr "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/errors"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
bireljob "github.com/cloudfoundry/bosh-init/release/job"
fakeboshsys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("RenderedJobList", func() {
var (
outBuffer *bytes.Buffer
errBuffer *bytes.Buffer
logger boshlog.Logger
fs *fakeboshsys.FakeFileSystem
renderedJobList RenderedJobList
)
BeforeEach(func() {
outBuffer = bytes.NewBufferString("")
errBuffer = bytes.NewBufferString("")
logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuffer, errBuffer)
fs = fakeboshsys.NewFakeFileSystem()
renderedJobList = NewRenderedJobList()
})
Describe("All", func() {
import (
"errors"
. "github.com/cloudfoundry/bosh-init/deployment/manifest"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
biproperty "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/property"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("Parser", func() {
var (
comboManifestPath string
fakeFs *fakesys.FakeFileSystem
parser Parser
)
BeforeEach(func() {
comboManifestPath = "fake-deployment-path"
fakeFs = fakesys.NewFakeFileSystem()
logger := boshlog.NewLogger(boshlog.LevelNone)
parser = NewParser(fakeFs, logger)
})
Context("when combo manifest path does not exist", func() {
BeforeEach(func() {
err := fakeFs.RemoveAll(comboManifestPath)
Expect(err).ToNot(HaveOccurred())
})
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
"encoding/json"
"errors"
boshlog "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/logger"
biproperty "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/property"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
fakeuuid "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/uuid/fakes"
)
var _ = Describe("fileSystemDeploymentStateService", func() {
var (
service DeploymentStateService
deploymentStatePath string
fakeFs *fakesys.FakeFileSystem
fakeUUIDGenerator *fakeuuid.FakeGenerator
)
BeforeEach(func() {
fakeFs = fakesys.NewFakeFileSystem()
deploymentStatePath = "/some/deployment.json"
logger := boshlog.NewLogger(boshlog.LevelNone)
fakeUUIDGenerator = fakeuuid.NewFakeGenerator()
service = NewFileSystemDeploymentStateService(fakeFs, fakeUUIDGenerator, logger, deploymentStatePath)
})
Describe("DeploymentStatePath", func() {
It("is based on the manifest path and name", func() {
Expect(DeploymentStatePath("/path/to/some-manifest.yml")).To(Equal("/path/to/some-manifest-state.json"))
Expect(DeploymentStatePath("/path/to/some-manifesty.yaml")).To(Equal("/path/to/some-manifesty-state.json"))
import (
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/release/job"
bosherr "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/errors"
fakecmd "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/fileutil/fakes"
biproperty "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/property"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("Reader", func() {
var (
compressor *fakecmd.FakeCompressor
fakeFs *fakesys.FakeFileSystem
reader Reader
)
BeforeEach(func() {
compressor = fakecmd.NewFakeCompressor()
fakeFs = fakesys.NewFakeFileSystem()
reader = NewReader("/some/job/archive", "/extracted/job", compressor, fakeFs)
})
Context("when the job archive is a valid tar", func() {
Context("when the job manifest is valid", func() {
BeforeEach(func() {
fakeFs.WriteFileString(
"/extracted/job/job.MF",
`---
name: fake-job
)
type failingInterfaceAddress struct{}
func (ia failingInterfaceAddress) GetInterfaceName() string { return "eth0" }
func (ia failingInterfaceAddress) GetIP() (string, error) {
return "", errors.New("fake-get-ip-err")
}
var _ = Describe("arping", func() {
const arpingIterations = 6
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
arping AddressBroadcaster
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
logger := boshlog.NewLogger(boshlog.LevelNone)
arping = NewArping(cmdRunner, fs, logger, arpingIterations, 0, 0)
})
Describe("BroadcastMACAddresses", func() {
BeforeEach(func() {
fs.WriteFile("/sys/class/net/eth0", []byte{})
fs.WriteFile("/sys/class/net/eth1", []byte{})
})
Expect(err).ToNot(HaveOccurred())
Expect(content).To(Equal("fake-rendered-job-0-script-0-content"))
content, err = fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-0", "script-1"))
Expect(err).ToNot(HaveOccurred())
Expect(content).To(Equal("fake-rendered-job-0-script-1-content"))
// verify that archive contained rendered scripts from job 1
content, err = fs.ReadFileString(filepath.Join(renderedJobListDir, "fake-job-name-1", "script-0"))
Expect(err).ToNot(HaveOccurred())
Expect(content).To(Equal("fake-rendered-job-1-script-0-content"))
})
})
Context("with a fake fs & compressor", func() {
var (
fakeFS *fakeboshsys.FakeFileSystem
fakeCompressor *fakeboshcmd.FakeCompressor
)
BeforeEach(func() {
fakeFS = fakeboshsys.NewFakeFileSystem()
fakeCompressor = fakeboshcmd.NewFakeCompressor()
renderedJobListCompressor = NewRenderedJobListCompressor(fakeFS, fakeCompressor, fakeSHA1Calculator, logger)
})
It("calculates the fingerprint of the rendered", func() {
fakeFS.TempDirDir = "fake-rendered-job-list-path"
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-rendered-job-list-path": fakebicrypto.CalculateInput{Sha1: "fake-sha1"},
