func init() {
Describe("dummyInfrastructure", func() {
It("get settings", func() {
fs := fakefs.NewFakeFileSystem()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
platform := fakeplatform.NewFakePlatform()
fakeDevicePathResolver := boshdevicepathresolver.NewFakeDevicePathResolver(1*time.Millisecond, platform.GetFs())
settingsPath := filepath.Join(dirProvider.BoshDir(), "dummy-cpi-agent-env.json")
expectedSettings := boshsettings.Settings{
AgentId: "123-456-789",
Blobstore: boshsettings.Blobstore{
Type: boshsettings.BlobstoreTypeDummy,
},
Mbus: "nats://127.0.0.1:4222",
}
existingSettingsBytes, _ := json.Marshal(expectedSettings)
fs.WriteFile(settingsPath, existingSettingsBytes)
dummy := NewDummyInfrastructure(fs, dirProvider, platform, fakeDevicePathResolver)
settings, err := dummy.GetSettings()
Expect(err).ToNot(HaveOccurred())
assert.Equal(GinkgoT(), settings, boshsettings.Settings{
AgentId: "123-456-789",
Blobstore: boshsettings.Blobstore{Type: boshsettings.BlobstoreTypeDummy},
Mbus: "nats://127.0.0.1:4222",
})
})
It("get settings errs when settings file does not exist", func() {
fs := fakefs.NewFakeFileSystem()
dirProvider := boshdir.NewDirectoriesProvider("/var/vcap")
platform := fakeplatform.NewFakePlatform()
fakeDevicePathResolver := boshdevicepathresolver.NewFakeDevicePathResolver(1*time.Millisecond, platform.GetFs())
dummy := NewDummyInfrastructure(fs, dirProvider, platform, fakeDevicePathResolver)
_, err := dummy.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Read settings file"))
})
})
}
func NewFakePlatform() (platform *FakePlatform) {
platform = new(FakePlatform)
platform.Fs = fakesys.NewFakeFileSystem()
platform.Runner = &fakesys.FakeCmdRunner{}
platform.FakeStatsCollector = &fakestats.FakeStatsCollector{}
platform.FakeCompressor = fakecmd.NewFakeCompressor()
platform.FakeCopier = fakecmd.NewFakeCopier()
platform.FakeVitalsService = fakevitals.NewFakeService()
platform.FakeDiskManager = fakedisk.NewFakeDiskManager()
platform.DevicePathResolver = boshdevicepathresolver.NewFakeDevicePathResolver(1*time.Millisecond, platform.Fs)
platform.AddUserToGroupsGroups = make(map[string][]string)
platform.SetupSshPublicKeys = make(map[string]string)
platform.UserPasswords = make(map[string]string)
platform.ScsiDiskMap = make(map[string]string)
return
}
func init() {
Describe("vSphere Infrastructure", func() {
var (
logger boshlog.Logger
vsphere Infrastructure
platform *fakeplatform.FakePlatform
fakeDevicePathResolver *boshdevicepathresolver.FakeDevicePathResolver
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
fakeDevicePathResolver = boshdevicepathresolver.NewFakeDevicePathResolver(1*time.Millisecond, platform.GetFs())
logger = boshlog.NewLogger(boshlog.LEVEL_NONE)
})
JustBeforeEach(func() {
vsphere = NewVsphereInfrastructure(platform, fakeDevicePathResolver, logger)
})
Describe("GetSettings", func() {
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"))
})
})
Describe("SetupNetworking", func() {
It("vsphere setup networking", func() {
networks := boshsettings.Networks{"bosh": boshsettings.Network{}}
vsphere.SetupNetworking(networks)
Expect(platform.SetupManualNetworkingNetworks).To(Equal(networks))
})
})
Describe("GetEphemeralDiskPath", func() {
It("vsphere get ephemeral disk path", func() {
realPath, found := vsphere.GetEphemeralDiskPath("does not matter")
Expect(found).To(Equal(true))
Expect(realPath).To(Equal("/dev/sdb"))
})
})
Describe("MountPersistentDisk", func() {
BeforeEach(func() {
fakeDevicePathResolver.RealDevicePath = "fake-real-device-path"
})
It("creates the mount directory with the correct permissions", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
mountPoint := platform.Fs.GetFileTestStat("/mnt/point")
Expect(mountPoint.FileType).To(Equal(fakesys.FakeFileTypeDir))
Expect(mountPoint.FileMode).To(Equal(os.FileMode(0700)))
})
It("partitions the disk", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
Expect(platform.FakeDiskManager.FakePartitioner.PartitionDevicePath).To(Equal("fake-real-device-path"))
partitions := []boshdisk.Partition{
{Type: boshdisk.PartitionTypeLinux},
}
Expect(platform.FakeDiskManager.FakePartitioner.PartitionPartitions).To(Equal(partitions))
})
It("formats the disk", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
Expect(platform.FakeDiskManager.FakeFormatter.FormatPartitionPaths).To(Equal([]string{"fake-real-device-path1"}))
Expect(platform.FakeDiskManager.FakeFormatter.FormatFsTypes).To(Equal([]boshdisk.FileSystemType{boshdisk.FileSystemExt4}))
})
It("mounts the disk", func() {
vsphere.MountPersistentDisk("fake-volume-id", "/mnt/point")
Expect(platform.FakeDiskManager.FakeMounter.MountPartitionPaths).To(Equal([]string{"fake-real-device-path1"}))
Expect(platform.FakeDiskManager.FakeMounter.MountMountPoints).To(Equal([]string{"/mnt/point"}))
})
})
})
}
func init() {
var (
platform *fakeplatform.FakePlatform
fakeDevicePathResolver *boshdevicepathresolver.FakeDevicePathResolver
)
BeforeEach(func() {
platform = fakeplatform.NewFakePlatform()
fakeDevicePathResolver = boshdevicepathresolver.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() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = &fakesys.FakeCmdRunner{}
})
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"))
})
})
})
}