func init() { Describe("Testing with Ginkgo", func() { var ( vsphere Infrastructure platform *fakeplatform.FakePlatform ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() }) JustBeforeEach(func() { vsphere = NewVsphereInfrastructure(platform) }) It("vsphere get settings", func() { platform.GetFileContentsFromCDROMContents = []byte(`{"agent_id": "123"}`) settings, err := vsphere.GetSettings() Expect(err).NotTo(HaveOccurred()) Expect(platform.GetFileContentsFromCDROMPath).To(Equal("env")) Expect(settings.AgentId).To(Equal("123")) }) It("vsphere setup networking", func() { networks := boshsettings.Networks{"bosh": boshsettings.Network{}} vsphere.SetupNetworking(networks) Expect(platform.SetupManualNetworkingNetworks).To(Equal(networks)) }) It("vsphere get ephemeral disk path", func() { platform.NormalizeDiskPathRealPath = "/dev/sdb" platform.NormalizeDiskPathFound = true realPath, found := vsphere.GetEphemeralDiskPath("does not matter") Expect(found).To(Equal(true)) Expect(realPath).To(Equal("/dev/sdb")) Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb")) }) }) }
func init() { Describe("awsInfrastructure", func() { var ( metadataService *fakeinf.FakeMetadataService registry *fakeinf.FakeRegistry platform *fakeplatform.FakePlatform devicePathResolver *fakedpresolv.FakeDevicePathResolver aws Infrastructure ) BeforeEach(func() { metadataService = &fakeinf.FakeMetadataService{} registry = &fakeinf.FakeRegistry{} platform = fakeplatform.NewFakePlatform() devicePathResolver = fakedpresolv.NewFakeDevicePathResolver() logger := boshlog.NewLogger(boshlog.LevelNone) aws = NewAwsInfrastructure(metadataService, registry, platform, devicePathResolver, logger) }) Describe("SetupSSH", func() { It("gets the public key and sets up ssh via the platform", func() { metadataService.PublicKey = "fake-public-key" err := aws.SetupSSH("vcap") Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupSSHPublicKey).To(Equal("fake-public-key")) Expect(platform.SetupSSHUsername).To(Equal("vcap")) }) It("returns error without configuring ssh on the platform if getting public key fails", func() { metadataService.GetPublicKeyErr = errors.New("fake-get-public-key-err") err := aws.SetupSSH("vcap") Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-public-key-err")) Expect(platform.SetupSSHCalled).To(BeFalse()) }) It("returns error if configuring ssh on the platform fails", func() { platform.SetupSSHErr = errors.New("fake-setup-ssh-err") err := aws.SetupSSH("vcap") Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-ssh-err")) }) }) Describe("GetSettings", func() { It("gets settings", func() { settings := boshsettings.Settings{AgentID: "fake-agent-id"} registry.Settings = settings settings, err := aws.GetSettings() Expect(err).ToNot(HaveOccurred()) Expect(settings).To(Equal(settings)) }) It("returns an error when registry fails to get settings", func() { registry.GetSettingsErr = errors.New("fake-get-settings-err") settings, err := aws.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-settings-err")) Expect(settings).To(Equal(boshsettings.Settings{})) }) }) Describe("SetupNetworking", func() { It("sets up DHCP on the platform", func() { networks := boshsettings.Networks{"bosh": boshsettings.Network{}} err := aws.SetupNetworking(networks) Expect(err).ToNot(HaveOccurred()) Expect(platform.SetupDhcpNetworks).To(Equal(networks)) }) It("returns error if configuring DHCP fails", func() { platform.SetupDhcpErr = errors.New("fake-setup-dhcp-err") err := aws.SetupNetworking(boshsettings.Networks{}) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-setup-dhcp-err")) }) }) Describe("GetEphemeralDiskPath", func() { It("returns the real disk path given an AWS EBS hint", func() { platform.NormalizeDiskPathRealPath = "/dev/xvdb" platform.NormalizeDiskPathFound = true realPath, found := aws.GetEphemeralDiskPath("/dev/sdb") Expect(found).To(Equal(true)) Expect(realPath).To(Equal("/dev/xvdb")) Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb")) }) It("returns false if path cannot be normalized", func() { platform.NormalizeDiskPathRealPath = "" platform.NormalizeDiskPathFound = false realPath, found := aws.GetEphemeralDiskPath("/dev/sdb") Expect(found).To(BeFalse()) Expect(realPath).To(Equal("")) Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb")) }) It("returns false if device path is empty because ephemeral storage should not be on root partition", func() { realPath, found := aws.GetEphemeralDiskPath("") Expect(found).To(BeFalse()) Expect(realPath).To(BeEmpty()) Expect(platform.NormalizeDiskPathCalled).To(BeFalse()) }) }) }) }
func init() { var ( platform *fakeplatform.FakePlatform fakeDevicePathResolver *fakedpresolv.FakeDevicePathResolver ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() fakeDevicePathResolver = fakedpresolv.NewFakeDevicePathResolver( 1*time.Millisecond, platform.GetFs(), ) }) Describe("AWS Infrastructure", func() { Describe("SetupSsh", func() { var ( ts *httptest.Server aws Infrastructure ) const expectedKey = "some public key" BeforeEach(func() { handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/latest/meta-data/public-keys/0/openssh-key")) w.Write([]byte(expectedKey)) }) ts = httptest.NewServer(handler) }) AfterEach(func() { ts.Close() }) It("gets the public key and sets up ssh via the platform", func() { aws = NewAwsInfrastructure(ts.URL, &FakeDNSResolver{}, platform, fakeDevicePathResolver) err := aws.SetupSsh("vcap") Expect(err).NotTo(HaveOccurred()) Expect(platform.SetupSshPublicKey).To(Equal(expectedKey)) Expect(platform.SetupSshUsername).To(Equal("vcap")) }) }) Describe("GetSettings", func() { var ( settingsJSON string expectedSettings boshsettings.Settings ) BeforeEach(func() { settingsJSON = `{ "agent_id": "my-agent-id", "blobstore": { "options": { "bucket_name": "george", "encryption_key": "optional encryption key", "access_key_id": "optional access key id", "secret_access_key": "optional secret access key" }, "provider": "s3" }, "disks": { "ephemeral": "/dev/sdb", "persistent": { "vol-xxxxxx": "/dev/sdf" }, "system": "/dev/sda1" }, "env": { "bosh": { "password": "******" } }, "networks": { "netA": { "default": ["dns", "gateway"], "ip": "ww.ww.ww.ww", "dns": [ "xx.xx.xx.xx", "yy.yy.yy.yy" ] }, "netB": { "dns": [ "zz.zz.zz.zz" ] } }, "mbus": "https://*****:*****@0.0.0.0:6868", "ntp": [ "0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org" ], "vm": { "name": "vm-abc-def" } }` settingsJSON = strings.Replace(settingsJSON, `"`, `\"`, -1) settingsJSON = strings.Replace(settingsJSON, "\n", "", -1) settingsJSON = strings.Replace(settingsJSON, "\t", "", -1) settingsJSON = fmt.Sprintf(`{"settings": "%s"}`, settingsJSON) expectedSettings = boshsettings.Settings{ AgentID: "my-agent-id", Blobstore: boshsettings.Blobstore{ Options: map[string]string{ "bucket_name": "george", "encryption_key": "optional encryption key", "access_key_id": "optional access key id", "secret_access_key": "optional secret access key", }, Type: "s3", }, Disks: boshsettings.Disks{ Ephemeral: "/dev/sdb", Persistent: map[string]string{"vol-xxxxxx": "/dev/sdf"}, System: "/dev/sda1", }, Env: boshsettings.Env{ Bosh: boshsettings.BoshEnv{ Password: "******", }, }, Networks: boshsettings.Networks{ "netA": boshsettings.Network{ Default: []string{"dns", "gateway"}, IP: "ww.ww.ww.ww", DNS: []string{"xx.xx.xx.xx", "yy.yy.yy.yy"}, }, "netB": boshsettings.Network{ DNS: []string{"zz.zz.zz.zz"}, }, }, Mbus: "https://*****:*****@0.0.0.0:6868", Ntp: []string{ "0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org", }, VM: boshsettings.VM{ Name: "vm-abc-def", }, } }) Context("when a dns is not provided", func() { It("aws get settings", func() { boshRegistryHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/instances/123-456-789/settings")) w.Write([]byte(settingsJSON)) }) registryTs := httptest.NewServer(boshRegistryHandler) defer registryTs.Close() expectedUserData := fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, registryTs.URL) instanceID := "123-456-789" awsMetaDataHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Expect(r.Method).To(Equal("GET")) switch r.URL.Path { case "/latest/user-data": w.Write([]byte(expectedUserData)) case "/latest/meta-data/instance-id": w.Write([]byte(instanceID)) } }) metadataTs := httptest.NewServer(awsMetaDataHandler) defer metadataTs.Close() platform := fakeplatform.NewFakePlatform() aws := NewAwsInfrastructure(metadataTs.URL, &FakeDNSResolver{}, platform, fakeDevicePathResolver) settings, err := aws.GetSettings() Expect(err).NotTo(HaveOccurred()) Expect(settings).To(Equal(expectedSettings)) }) }) Context("when dns servers are provided", func() { It("aws get settings", func() { fakeDNSResolver := &FakeDNSResolver{ LookupHostIP: "127.0.0.1", } registryHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Expect(r.Method).To(Equal("GET")) Expect(r.URL.Path).To(Equal("/instances/123-456-789/settings")) w.Write([]byte(settingsJSON)) }) registryTs := httptest.NewServer(registryHandler) registryURL, err := url.Parse(registryTs.URL) Expect(err).NotTo(HaveOccurred()) registryTsPort := strings.Split(registryURL.Host, ":")[1] defer registryTs.Close() expectedUserData := fmt.Sprintf(` { "registry":{ "endpoint":"http://the.registry.name:%s" }, "dns":{ "nameserver": ["8.8.8.8", "9.9.9.9"] } }`, registryTsPort) instanceID := "123-456-789" awsMetaDataHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Expect(r.Method).To(Equal("GET")) switch r.URL.Path { case "/latest/user-data": w.Write([]byte(expectedUserData)) case "/latest/meta-data/instance-id": w.Write([]byte(instanceID)) } }) metadataTs := httptest.NewServer(awsMetaDataHandler) defer metadataTs.Close() platform := fakeplatform.NewFakePlatform() aws := NewAwsInfrastructure(metadataTs.URL, fakeDNSResolver, platform, fakeDevicePathResolver) settings, err := aws.GetSettings() Expect(err).NotTo(HaveOccurred()) Expect(settings).To(Equal(expectedSettings)) Expect(fakeDNSResolver.LookupHostHost).To(Equal("the.registry.name")) Expect(fakeDNSResolver.LookupHostDNSServers).To(Equal([]string{"8.8.8.8", "9.9.9.9"})) }) }) }) Describe("SetupNetworking", func() { It("sets up DHCP on the platform", func() { fakeDNSResolver := &FakeDNSResolver{} platform := fakeplatform.NewFakePlatform() aws := NewAwsInfrastructure("", fakeDNSResolver, platform, fakeDevicePathResolver) networks := boshsettings.Networks{"bosh": boshsettings.Network{}} aws.SetupNetworking(networks) Expect(platform.SetupDhcpNetworks).To(Equal(networks)) }) }) Describe("GetEphemeralDiskPath", func() { It("returns the real disk path given an AWS EBS hint", func() { fakeDNSResolver := &FakeDNSResolver{} platform := fakeplatform.NewFakePlatform() aws := NewAwsInfrastructure("", fakeDNSResolver, platform, fakeDevicePathResolver) platform.NormalizeDiskPathRealPath = "/dev/xvdb" platform.NormalizeDiskPathFound = true realPath, found := aws.GetEphemeralDiskPath("/dev/sdb") Expect(found).To(Equal(true)) Expect(realPath).To(Equal("/dev/xvdb")) Expect(platform.NormalizeDiskPathPath).To(Equal("/dev/sdb")) }) }) Describe("MountPersistentDisk", func() { It("mounts the persistent disk", func() { fakePlatform := fakeplatform.NewFakePlatform() fakeFormatter := fakePlatform.FakeDiskManager.FakeFormatter fakePartitioner := fakePlatform.FakeDiskManager.FakePartitioner fakeMounter := fakePlatform.FakeDiskManager.FakeMounter fakePlatform.GetFs().WriteFile("/dev/vdf", []byte{}) fakeDNSResolver := &FakeDNSResolver{} aws := NewAwsInfrastructure("", fakeDNSResolver, fakePlatform, fakeDevicePathResolver) fakeDevicePathResolver.RealDevicePath = "/dev/vdf" err := aws.MountPersistentDisk("/dev/sdf", "/mnt/point") Expect(err).NotTo(HaveOccurred()) mountPoint := fakePlatform.Fs.GetFileTestStat("/mnt/point") Expect(mountPoint.FileType).To(Equal(fakesys.FakeFileTypeDir)) Expect(mountPoint.FileMode).To(Equal(os.FileMode(0700))) partition := fakePartitioner.PartitionPartitions[0] Expect(fakePartitioner.PartitionDevicePath).To(Equal("/dev/vdf")) Expect(len(fakePartitioner.PartitionPartitions)).To(Equal(1)) Expect(partition.Type).To(Equal(boshdisk.PartitionTypeLinux)) Expect(len(fakeFormatter.FormatPartitionPaths)).To(Equal(1)) Expect(fakeFormatter.FormatPartitionPaths[0]).To(Equal("/dev/vdf1")) Expect(len(fakeFormatter.FormatFsTypes)).To(Equal(1)) Expect(fakeFormatter.FormatFsTypes[0]).To(Equal(boshdisk.FileSystemExt4)) Expect(len(fakeMounter.MountMountPoints)).To(Equal(1)) Expect(fakeMounter.MountMountPoints[0]).To(Equal("/mnt/point")) Expect(len(fakeMounter.MountPartitionPaths)).To(Equal(1)) Expect(fakeMounter.MountPartitionPaths[0]).To(Equal("/dev/vdf1")) }) }) }) }