localDNSState, err := syncDNSState.LoadState()
Expect(err).ToNot(HaveOccurred())
Expect(localDNSState.Version).To(Equal(uint64(1234)))
})
})
})
Describe("#SaveState", func() {
Context("when there are failures", func() {
BeforeEach(func() {
localDNSState = LocalDNSState{}
})
Context("when saving the marshalled DNS state", func() {
It("fails saving the DNS state", func() {
fakeFileSystem.WriteFileError = errors.New("fake fail saving error")
err = syncDNSState.SaveState(localDNSState)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("writing the blobstore DNS state"))
})
})
})
Context("when there are no failures", func() {
BeforeEach(func() {
localDNSState = LocalDNSState{
Version: 1234,
}
})
Context("when creating disk fails", func() {
BeforeEach(func() {
fakeCloud.CreateDiskErr = errors.New("fake-create-error")
})
It("returns an error", func() {
_, err := manager.Create(diskPool, "fake-vm-cid")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-create-error"))
})
})
Context("when updating disk record fails", func() {
BeforeEach(func() {
fakeFs.WriteFileError = errors.New("fake-write-error")
})
It("returns an error", func() {
_, err := manager.Create(diskPool, "fake-vm-cid")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-write-error"))
})
})
})
Describe("FindCurrent", func() {
Context("when disk already exists in disk repo", func() {
BeforeEach(func() {
diskRecord, err := diskRepo.Save("fake-existing-disk-cid", 1024, biproperty.Map{})
Expect(err).ToNot(HaveOccurred())
Expect(err).NotTo(HaveOccurred())
Expect(fakeFs.FileExists(fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath))).To(BeTrue())
Expect(fakeFs.FileExists(fmt.Sprintf("%s/bosh-trusted-cert-2.crt", certBasePath))).To(BeTrue())
Expect(countFiles(fakeFs, certBasePath)).To(Equal(2))
fakeFs.SetGlob(fmt.Sprintf("%s/bosh-trusted-cert-*", certBasePath), []string{
fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath),
fmt.Sprintf("%s/bosh-trusted-cert-2.crt", certBasePath),
})
certManager.UpdateCertificates(cert1)
Expect(fakeFs.FileExists(fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath))).To(BeTrue())
Expect(countFiles(fakeFs, certBasePath)).To(Equal(1))
})
It("returns an error when writing new cert files fails", func() {
fakeFs.WriteFileError = errors.New("NOT ALLOW")
err := certManager.UpdateCertificates(cert1)
Expect(err).To(HaveOccurred())
})
It("returns an error when deleting old certs fails", func() {
fakeFs.RemoveAllError = errors.New("NOT ALLOW")
fakeFs.WriteFileString(fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath), "goodbye")
fakeFs.SetGlob(fmt.Sprintf("%s/bosh-trusted-cert-*", certBasePath), []string{
fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath),
})
err := certManager.UpdateCertificates("")
Expect(err).To(HaveOccurred())
})
}
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))
})
})
})
})
})
}
Expect(string(contents)).To(Equal(`{"Linux":{"hosts_configured":true}}`))
})
It("saves the state file with the properties passed in", func() {
s.Linux = platform.LinuxState{HostsConfigured: true}
s.SaveState()
contents, readerr := fs.ReadFile(path)
Expect(readerr).ToNot(HaveOccurred())
Expect(string(contents)).To(Equal(`{"Linux":{"hosts_configured":true}}`))
})
It("returns an error when it can't write the file", func() {
s.Linux = platform.LinuxState{HostsConfigured: true}
fs.WriteFileError = errors.New("ENXIO: disk failed")
saveerr := s.SaveState()
Expect(saveerr.Error()).To(ContainSubstring("disk failed"))
})
It("does not return an error when it tries to save an empty object", func() {
s.Linux = platform.LinuxState{}
saveerr := s.SaveState()
Expect(saveerr).ToNot(HaveOccurred())
})
})
Describe("NewState", func() {
Context("When the agent's state file cannot be found", func() {
func describeUbuntuNetManager() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
ipResolver *fakeip.FakeResolver
addressBroadcaster *fakearp.FakeAddressBroadcaster
interfaceAddrsProvider *fakeip.FakeInterfaceAddressesProvider
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{}
interfaceAddrsProvider = &fakeip.FakeInterfaceAddressesProvider{}
interfaceAddrsValidator := boship.NewInterfaceAddressesValidator(interfaceAddrsProvider)
dnsValidator := NewDNSValidator(fs)
netManager = NewUbuntuNetManager(
fs,
cmdRunner,
ipResolver,
interfaceConfigurationCreator,
interfaceAddrsValidator,
dnsValidator,
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",
IsDefaultForGateway: true,
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",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
}
fs.WriteFileString("/etc/resolv.conf", `
nameserver 8.8.8.8
nameserver 9.9.9.9
`)
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("configures gateway, broadcast and dns for default network only", func() {
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",
}
secondStaticNetwork := boshsettings.Network{
Type: "manual",
IP: "5.6.7.8",
Netmask: "255.255.255.0",
Gateway: "6.7.8.9",
Mac: "second-fake-static-mac-address",
DNS: []string{"8.8.8.8"},
Default: []string{"gateway", "dns"},
}
stubInterfaces(map[string]boshsettings.Network{
"eth0": staticNetwork,
"eth1": secondStaticNetwork,
})
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("eth0", "1.2.3.4"),
boship.NewSimpleInterfaceAddress("eth1", "5.6.7.8"),
}
err := netManager.SetupNetworking(boshsettings.Networks{
"static-1": staticNetwork,
"static-2": secondStaticNetwork,
}, 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 eth0
iface eth0 inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
auto eth1
iface eth1 inet static
address 5.6.7.8
network 5.6.7.0
netmask 255.255.255.0
broadcast 5.6.7.255
gateway 6.7.8.9
dns-nameservers 8.8.8.8`))
})
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",
Default: []string{"gateway"},
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", "--force", "ethdhcp", "ethstatic"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"ifup", "--force", "ethdhcp", "ethstatic"}))
})
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", "--force", "ethdhcp", "ethstatic"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"ifup", "--force", "ethdhcp", "ethstatic"}))
})
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 manual networks were not configured with proper IP addresses", func() {
BeforeEach(func() {
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.5"),
}
})
It("fails", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, errCh)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Validating static network configuration"))
})
})
Context("when dns is not properly configured", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/resolv.conf", "")
})
It("fails", func() {
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Default: []string{"dns"},
DNS: []string{"8.8.8.8"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, errCh)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Validating dns configuration"))
})
})
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",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
stubInterfaces(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
)
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "2.2.2.2"),
}
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",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
stubInterfacesWithVirtual(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
[]string{"virtual"},
)
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "2.2.2.2"),
}
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 describeCentosNetManager() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
ipResolver *fakeip.FakeResolver
interfaceAddrsProvider *fakeip.FakeInterfaceAddressesProvider
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)
interfaceAddrsProvider = &fakeip.FakeInterfaceAddressesProvider{}
interfaceAddrsValidator := boship.NewInterfaceAddressesValidator(interfaceAddrsProvider)
dnsValidator := NewDNSValidator(fs)
addressBroadcaster = &fakearp.FakeAddressBroadcaster{}
netManager = NewCentosNetManager(
fs,
cmdRunner,
ipResolver,
interfaceConfigurationCreator,
interfaceAddrsValidator,
dnsValidator,
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",
}
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
}
fs.WriteFileString("/etc/resolv.conf", `
nameserver 8.8.8.8
nameserver 9.9.9.9
`)
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,
})
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
boship.NewSimpleInterfaceAddress("ethstatic-that-changes", "1.2.3.5"),
}
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"}))
})
Context("when manual networks were not configured with proper IP addresses", func() {
BeforeEach(func() {
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.5"),
}
})
It("fails", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, errCh)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Validating static network configuration"))
})
})
Context("when dns is not properly configured", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/resolv.conf", "")
})
It("fails", func() {
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Default: []string{"dns"},
DNS: []string{"8.8.8.8"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, errCh)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Validating dns configuration"))
})
})
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 rootDesc() {
var (
repo ReleaseRepo
deploymentStateService DeploymentStateService
fs *fakesys.FakeFileSystem
fakeUUIDGenerator *fakeuuid.FakeGenerator
)
BeforeEach(func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs = fakesys.NewFakeFileSystem()
fakeUUIDGenerator = &fakeuuid.FakeGenerator{}
fakeUUIDGenerator.GeneratedUUID = "fake-uuid"
deploymentStateService = NewFileSystemDeploymentStateService(fs, fakeUUIDGenerator, logger, "/fake/path")
deploymentStateService.Load()
repo = NewReleaseRepo(deploymentStateService, fakeUUIDGenerator)
})
Describe("List", func() {
Context("when a current release exists", func() {
BeforeEach(func() {
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
conf.Releases = []ReleaseRecord{
ReleaseRecord{ID: "fake-guid-a", Name: "fake-name-a", Version: "fake-version-a"},
ReleaseRecord{ID: "fake-guid-b", Name: "fake-name-b", Version: "fake-version-b"},
}
err = deploymentStateService.Save(conf)
Expect(err).ToNot(HaveOccurred())
})
It("returns existing release", func() {
records, err := repo.List()
Expect(err).ToNot(HaveOccurred())
Expect(records).To(Equal([]ReleaseRecord{
{
ID: "fake-guid-a",
Name: "fake-name-a",
Version: "fake-version-a",
},
{
ID: "fake-guid-b",
Name: "fake-name-b",
Version: "fake-version-b",
},
}))
})
})
Context("when there are no releases recorded", func() {
It("returns not found", func() {
records, err := repo.List()
Expect(err).ToNot(HaveOccurred())
Expect(records).To(HaveLen(0))
})
})
Context("when the config service fails to load", func() {
BeforeEach(func() {
fs.ReadFileError = errors.New("kaboom")
})
It("returns an error", func() {
_, err := repo.List()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Loading existing config"))
})
})
})
Describe("Update", func() {
Context("when there are no existing releases", func() {
It("saves the provided releases to the config file", func() {
err := repo.Update([]release.Release{
fakerelease.New("name1", "1"),
fakerelease.New("name2", "2"),
})
Expect(err).ToNot(HaveOccurred())
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
Expect(conf.Releases).To(ConsistOf(
ReleaseRecord{ID: "fake-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "fake-uuid", Name: "name2", Version: "2"},
))
})
})
Context("when the existing releases exactly match the provided releases", func() {
BeforeEach(func() {
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
conf.Releases = []ReleaseRecord{
ReleaseRecord{ID: "old-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "old-uuid", Name: "name2", Version: "2"},
}
err = deploymentStateService.Save(conf)
Expect(err).ToNot(HaveOccurred())
})
})
Context("when existing versions differ from the provided release versions", func() {
BeforeEach(func() {
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
conf.Releases = []ReleaseRecord{
ReleaseRecord{ID: "old-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "old-uuid", Name: "name2", Version: "3"},
}
err = deploymentStateService.Save(conf)
Expect(err).ToNot(HaveOccurred())
})
It("saves the provided releases to the config file", func() {
err := repo.Update([]release.Release{
fakerelease.New("name1", "1"),
fakerelease.New("name2", "2"),
})
Expect(err).ToNot(HaveOccurred())
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
Expect(conf.Releases).To(ConsistOf(
ReleaseRecord{ID: "fake-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "fake-uuid", Name: "name2", Version: "2"},
))
})
})
Context("when existing names differ from the provided release names", func() {
BeforeEach(func() {
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
conf.Releases = []ReleaseRecord{
ReleaseRecord{ID: "old-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "old-uuid", Name: "other-name", Version: "2"},
}
err = deploymentStateService.Save(conf)
Expect(err).ToNot(HaveOccurred())
})
It("saves the provided releases to the config file", func() {
err := repo.Update([]release.Release{
fakerelease.New("name1", "1"),
fakerelease.New("name2", "2"),
})
Expect(err).ToNot(HaveOccurred())
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
Expect(conf.Releases).To(ConsistOf(
ReleaseRecord{ID: "fake-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "fake-uuid", Name: "name2", Version: "2"},
))
})
})
Context("when a release is removed", func() {
BeforeEach(func() {
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
conf.Releases = []ReleaseRecord{
ReleaseRecord{ID: "old-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "old-uuid", Name: "name2", Version: "2"},
ReleaseRecord{ID: "old-uuid", Name: "name3", Version: "3"},
}
err = deploymentStateService.Save(conf)
Expect(err).ToNot(HaveOccurred())
})
It("saves the provided releases to the config file", func() {
err := repo.Update([]release.Release{
fakerelease.New("name1", "1"),
fakerelease.New("name2", "2"),
})
Expect(err).ToNot(HaveOccurred())
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
Expect(conf.Releases).To(ConsistOf(
ReleaseRecord{ID: "fake-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "fake-uuid", Name: "name2", Version: "2"},
))
})
})
Context("when a release is added", func() {
BeforeEach(func() {
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
conf.Releases = []ReleaseRecord{
ReleaseRecord{ID: "old-uuid", Name: "name1", Version: "1"},
}
err = deploymentStateService.Save(conf)
Expect(err).ToNot(HaveOccurred())
})
It("saves the provided releases to the config file", func() {
err := repo.Update([]release.Release{
fakerelease.New("name1", "1"),
fakerelease.New("name2", "2"),
})
Expect(err).ToNot(HaveOccurred())
conf, err := deploymentStateService.Load()
Expect(err).ToNot(HaveOccurred())
Expect(conf.Releases).To(ConsistOf(
ReleaseRecord{ID: "fake-uuid", Name: "name1", Version: "1"},
ReleaseRecord{ID: "fake-uuid", Name: "name2", Version: "2"},
))
})
})
Context("when the config service fails to save", func() {
BeforeEach(func() {
fs.WriteFileError = errors.New("kaboom")
})
It("returns an error", func() {
err := repo.Update([]release.Release{
fakerelease.New("name1", "1"),
fakerelease.New("name2", "2"),
})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("kaboom"))
})
})
})
}
Expect(fs.FileExists("/fake-temp-file.fake-ext")).To(BeFalse())
})
Context("filesystem errors", func() {
Context("when creating Tempfile fails", func() {
It("errors out", func() {
fs.TempFileError = errors.New("boo")
_, _, err := scriptRunner.Run("")
Expect(err.Error()).To(Equal("Creating tempfile: boo"))
})
})
Context("when writing to the Tempfile fails", func() {
It("errors out", func() {
fs.WriteFileError = errors.New("foo")
_, _, err := scriptRunner.Run("")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("Writing to tempfile: foo"))
})
})
Context("when closing Tempfile fails", func() {
It("errors out", func() {
tempFile := fs.ReturnTempFile.(*fakesys.FakeFile)
tempFile.CloseErr = errors.New("fake-close-error")
_, _, err := scriptRunner.Run("")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("Closing tempfile: fake-close-error"))
fakeBlobstore.GetFileName = "fake-blobstore-file-path"
stateFilePath = filepath.Join(fakePlatform.GetDirProvider().BaseDir(), "local_dns_state.json")
})
Context("when local DNS state version is >= Run's version", func() {
BeforeEach(func() {
fakeBlobstore.GetError = errors.New("fake-blobstore-get-error")
})
Context("when the version equals the Run's version", func() {
BeforeEach(func() {
err := fakeFileSystem.WriteFileString(stateFilePath, `{"version": 2}`)
Expect(err).ToNot(HaveOccurred())
fakeFileSystem.WriteFileError = errors.New("fake-write-error")
})
It("returns with no error and does no writes and no gets to blobstore", func() {
_, err := action.Run("fake-blobstore-id", "fake-fingerprint", 2)
Expect(err).ToNot(HaveOccurred())
})
})
Context("when the version > the Run's version", func() {
BeforeEach(func() {
err := fakeFileSystem.WriteFileString(stateFilePath, `{"version": 3}`)
Expect(err).ToNot(HaveOccurred())
fakeFileSystem.WriteFileError = errors.New("fake-write-error")
})
}))
})
It("when the upload fails, prints failed uploading ui stage", func() {
fakeCloud.CreateStemcellErr = errors.New("fake-create-error")
_, err := manager.Upload(expectedExtractedStemcell, fakeStage)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-create-error"))
Expect(fakeStage.PerformCalls[0].Name).To(Equal("Uploading stemcell 'fake-stemcell-name/fake-stemcell-version'"))
Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())
Expect(fakeStage.PerformCalls[0].Error.Error()).To(Equal("creating stemcell (fake-stemcell-name fake-stemcell-version): fake-create-error"))
})
It("when the stemcellRepo save fails, logs uploading start and failure events to the eventLogger", func() {
fs.WriteFileError = errors.New("fake-save-error")
_, err := manager.Upload(expectedExtractedStemcell, fakeStage)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-save-error"))
Expect(fakeStage.PerformCalls[0].Name).To(Equal("Uploading stemcell 'fake-stemcell-name/fake-stemcell-version'"))
Expect(fakeStage.PerformCalls[0].Error).To(HaveOccurred())
Expect(fakeStage.PerformCalls[0].Error.Error()).To(MatchRegexp("Finding existing stemcell record in repo: .*fake-save-error.*"))
})
Context("when the stemcell record exists in the stemcellRepo (having been previously uploaded)", func() {
var (
foundStemcellRecord biconfig.StemcellRecord
)
BeforeEach(func() {
func init() {
Describe("concreteManagerProvider", func() {
Describe("NewManager", func() {
It("returns manager with tasks.json as its tasks path", func() {
logger := boshlog.NewLogger(boshlog.LevelNone)
fs := fakesys.NewFakeFileSystem()
taskInfo := boshtask.Info{
TaskID: "fake-task-id",
Method: "fake-method",
Payload: []byte("fake-payload"),
}
manager := boshtask.NewManagerProvider().NewManager(logger, fs, "/dir/path")
err := manager.AddInfo(taskInfo)
Expect(err).ToNot(HaveOccurred())
// Check expected file location with another manager
otherManager := boshtask.NewManager(logger, fs, "/dir/path/tasks.json")
taskInfos, err := otherManager.GetInfos()
Expect(err).ToNot(HaveOccurred())
Expect(taskInfos).To(Equal([]boshtask.Info{taskInfo}))
})
})
})
Describe("concreteManager", func() {
var (
logger boshlog.Logger
fs *fakesys.FakeFileSystem
manager boshtask.Manager
)
BeforeEach(func() {
logger = boshlog.NewLogger(boshlog.LevelNone)
fs = fakesys.NewFakeFileSystem()
manager = boshtask.NewManager(logger, fs, "/dir/path")
})
Describe("GetInfos", func() {
It("can load multiple tasks", func() {
err := manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-1",
Method: "fake-method-1",
Payload: []byte("fake-payload-1"),
})
Expect(err).ToNot(HaveOccurred())
err = manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
})
Expect(err).ToNot(HaveOccurred())
// Make sure we are not getting cached copy of taskInfos
reloadedManager := boshtask.NewManager(logger, fs, "/dir/path")
taskInfos, err := reloadedManager.GetInfos()
Expect(err).ToNot(HaveOccurred())
Expect(taskInfos).To(ConsistOf([]boshtask.Info{
boshtask.Info{
TaskID: "fake-task-id-1",
Method: "fake-method-1",
Payload: []byte("fake-payload-1"),
},
boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
},
}))
})
It("succeeds when there is no tasks (file is not present)", func() {
taskInfos, err := manager.GetInfos()
Expect(err).ToNot(HaveOccurred())
Expect(len(taskInfos)).To(Equal(0))
})
It("returns an error when failing to load tasks from the file that exists", func() {
err := manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
})
Expect(err).ToNot(HaveOccurred())
fs.ReadFileError = errors.New("fake-read-error")
_, err = manager.GetInfos()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-read-error"))
})
})
Describe("AddInfo", func() {
It("can add multiple tasks", func() {
err := manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-1",
Method: "fake-method-1",
Payload: []byte("fake-payload-1"),
})
Expect(err).ToNot(HaveOccurred())
err = manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
})
Expect(err).ToNot(HaveOccurred())
content, err := fs.ReadFile("/dir/path")
Expect(err).ToNot(HaveOccurred())
var decodedMap map[string]boshtask.Info
err = json.Unmarshal(content, &decodedMap)
Expect(err).ToNot(HaveOccurred())
Expect(decodedMap).To(Equal(map[string]boshtask.Info{
"fake-task-id-1": boshtask.Info{
TaskID: "fake-task-id-1",
Method: "fake-method-1",
Payload: []byte("fake-payload-1"),
},
"fake-task-id-2": boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
},
}))
})
It("returns an error when failing to save task", func() {
fs.WriteFileError = errors.New("fake-write-error")
err := manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id",
Method: "fake-method",
Payload: []byte("fake-payload"),
})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-write-error"))
})
})
Describe("RemoveInfo", func() {
BeforeEach(func() {
err := manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-1",
Method: "fake-method-1",
Payload: []byte("fake-payload-1"),
})
Expect(err).ToNot(HaveOccurred())
err = manager.AddInfo(boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
})
Expect(err).ToNot(HaveOccurred())
})
It("removes the task", func() {
err := manager.RemoveInfo("fake-task-id-1")
Expect(err).ToNot(HaveOccurred())
content, err := fs.ReadFile("/dir/path")
Expect(err).ToNot(HaveOccurred())
var decodedMap map[string]boshtask.Info
err = json.Unmarshal(content, &decodedMap)
Expect(err).ToNot(HaveOccurred())
Expect(decodedMap).To(Equal(map[string]boshtask.Info{
"fake-task-id-2": boshtask.Info{
TaskID: "fake-task-id-2",
Method: "fake-method-2",
Payload: []byte("fake-payload-2"),
},
}))
})
It("does not return error when removing task that does not exist", func() {
err := manager.RemoveInfo("fake-unknown-task-id")
Expect(err).ToNot(HaveOccurred())
})
It("returns an error when failing to remove task", func() {
fs.WriteFileError = errors.New("fake-write-error")
err := manager.RemoveInfo("fake-task-id")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-write-error"))
})
})
})
}
func init() {
Describe("concreteV1Service", func() {
var (
fs *fakesys.FakeFileSystem
specPath = "/spec.json"
service V1Service
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
service = NewConcreteV1Service(fs, specPath)
})
Describe("Get", func() {
Context("when filesystem has a spec file", func() {
BeforeEach(func() {
fs.WriteFileString(specPath, `{"deployment":"fake-deployment-name"}`)
})
It("reads spec from filesystem", func() {
spec, err := service.Get()
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{Deployment: "fake-deployment-name"}))
})
It("returns error if reading spec from filesystem errs", func() {
fs.ReadFileError = errors.New("fake-read-error")
spec, err := service.Get()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-read-error"))
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
Context("when filesystem does not have a spec file", func() {
It("reads spec from filesystem", func() {
spec, err := service.Get()
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
})
Describe("Set", func() {
newSpec := V1ApplySpec{Deployment: "fake-deployment-name"}
It("writes spec to filesystem", func() {
err := service.Set(newSpec)
Expect(err).ToNot(HaveOccurred())
specPathStats := fs.GetFileTestStat(specPath)
Expect(specPathStats).ToNot(BeNil())
boshassert.MatchesJSONBytes(GinkgoT(), newSpec, specPathStats.Content)
})
It("returns error if writing spec to filesystem errs", func() {
fs.WriteFileError = errors.New("fake-write-error")
err := service.Set(newSpec)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-write-error"))
})
})
Describe("PopulateDHCPNetworks", func() {
var settings boshsettings.Settings
var unresolvedSpec V1ApplySpec
var staticSpec NetworkSpec
var dhcpSpec NetworkSpec
var manualSetting boshsettings.Network
var dynamicSetting boshsettings.Network
BeforeEach(func() {
settings = boshsettings.Settings{
Networks: boshsettings.Networks{},
}
manualSetting = boshsettings.Network{
Type: "manual",
IP: "fake-manual-ip",
Netmask: "fake-manual-netmask",
Gateway: "fake-manual-gateway",
Mac: "fake-manual-mac",
}
dynamicSetting = boshsettings.Network{
Type: "dynamic",
IP: "fake-dynamic-ip",
Netmask: "fake-dynamic-netmask",
Gateway: "fake-dynamic-gateway",
}
unresolvedSpec = V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{},
}
staticSpec = NetworkSpec{
Fields: map[string]interface{}{
"ip": "fake-net1-ip",
"netmask": "fake-net1-netmask",
"gateway": "fake-net1-gateway",
"mac": "fake-net1-mac",
},
}
dhcpSpec = NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": "fake-net2-ip",
"netmask": "fake-net2-netmask",
"gateway": "fake-net2-gateway",
},
}
})
Context("when associated network is in settings", func() {
Context("when there are no networks configured with DHCP", func() {
BeforeEach(func() {
settings.Networks["fake-net"] = manualSetting
unresolvedSpec.NetworkSpecs["fake-net"] = staticSpec
})
It("returns spec without modifying any networks", func() {
spec, err := service.PopulateDHCPNetworks(unresolvedSpec, settings)
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(unresolvedSpec))
})
})
Context("when there is network with name 'local' and ip 127.0.0.1", func() {
BeforeEach(func() {
unresolvedSpec.NetworkSpecs["local"] = NetworkSpec{
Fields: map[string]interface{}{"ip": "127.0.0.1"},
}
})
It("returns spec without modifying any networks", func() {
spec, err := service.PopulateDHCPNetworks(unresolvedSpec, settings)
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(unresolvedSpec))
})
})
Context("when there are networks configured with DHCP", func() {
BeforeEach(func() {
settings.Networks["static-net1"] = manualSetting
settings.Networks["dhcp-net2"] = dynamicSetting
unresolvedSpec.NetworkSpecs["static-net1"] = staticSpec
unresolvedSpec.NetworkSpecs["dhcp-net2"] = dhcpSpec
})
It("returns spec with networks modified via DHCP and keeps everything else the same", func() {
spec, err := service.PopulateDHCPNetworks(unresolvedSpec, settings)
Expect(err).ToNot(HaveOccurred())
Expect(spec).To(Equal(V1ApplySpec{
Deployment: "fake-deployment",
NetworkSpecs: map[string]NetworkSpec{
"static-net1": staticSpec,
"dhcp-net2": NetworkSpec{
Fields: map[string]interface{}{
"type": NetworkSpecTypeDynamic,
"ip": dynamicSetting.IP,
"netmask": dynamicSetting.Netmask,
"gateway": dynamicSetting.Gateway,
},
},
},
}))
})
})
})
Context("when associated network cannot be found in settings", func() {
BeforeEach(func() {
settings.Networks["net-present-in-settings"] = manualSetting
unresolvedSpec.NetworkSpecs["net-present-in-settings"] = staticSpec
unresolvedSpec.NetworkSpecs["net-not-present-in-settings"] = dhcpSpec
})
It("returns error", func() {
spec, err := service.PopulateDHCPNetworks(unresolvedSpec, settings)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Network 'net-not-present-in-settings' is not found in settings"))
Expect(spec).To(Equal(V1ApplySpec{}))
})
})
})
})
}
Expect(err).ToNot(HaveOccurred())
_, found, err := compiledPackageRepo.Find(pkg)
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
transitive.Fingerprint = "new-fake-dependency-fingerprint"
_, found, err = compiledPackageRepo.Find(pkg)
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeFalse())
})
Context("when saving to index fails", func() {
It("returns error", func() {
fakeFS.WriteFileError = errors.New("Could not save")
record := CompiledPackageRecord{
BlobID: "fake-blob-id",
BlobSHA1: "fake-sha1",
}
pkg := birelpkg.Package{
Name: "fake-package-name",
}
err := compiledPackageRepo.Save(pkg, record)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Saving compiled package"))
})
})
