func describeHTTPMetadataService() {
var (
dnsResolver *fakeinf.FakeDNSResolver
platform *fakeplat.FakePlatform
logger boshlog.Logger
metadataService MetadataService
)
BeforeEach(func() {
dnsResolver = &fakeinf.FakeDNSResolver{}
platform = fakeplat.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
metadataService = NewHTTPMetadataService("fake-metadata-host", dnsResolver, platform, logger)
})
ItEnsuresMinimalNetworkSetup := func(subject func() (string, error)) {
Context("when no networks are configured", func() {
BeforeEach(func() {
platform.GetConfiguredNetworkInterfacesInterfaces = []string{}
})
It("sets up DHCP network", func() {
_, err := subject()
Expect(err).ToNot(HaveOccurred())
Expect(platform.SetupNetworkingCalled).To(BeTrue())
Expect(platform.SetupNetworkingNetworks).To(Equal(boshsettings.Networks{
"eth0": boshsettings.Network{
Type: "dynamic",
},
}))
})
Context("when setting up DHCP fails", func() {
BeforeEach(func() {
platform.SetupNetworkingErr = errors.New("fake-network-error")
})
It("returns an error", func() {
_, err := subject()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-network-error"))
})
})
})
}
Describe("IsAvailable", func() {
It("returns true", func() {
Expect(metadataService.IsAvailable()).To(BeTrue())
})
})
Describe("GetPublicKey", func() {
var (
ts *httptest.Server
)
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/meta-data/public-keys/0/openssh-key"))
w.Write([]byte("fake-public-key"))
})
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetPublicKey()
})
It("returns fetched public key", func() {
publicKey, err := metadataService.GetPublicKey()
Expect(err).NotTo(HaveOccurred())
Expect(publicKey).To(Equal("fake-public-key"))
})
})
Describe("GetInstanceID", func() {
var (
ts *httptest.Server
)
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/meta-data/instance-id"))
w.Write([]byte("fake-instance-id"))
})
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetInstanceID()
})
It("returns fetched instance id", func() {
publicKey, err := metadataService.GetInstanceID()
Expect(err).NotTo(HaveOccurred())
Expect(publicKey).To(Equal("fake-instance-id"))
})
})
Describe("GetServerName", func() {
var (
ts *httptest.Server
serverName *string
)
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/user-data"))
var jsonStr string
if serverName == nil {
jsonStr = `{}`
} else {
jsonStr = fmt.Sprintf(`{"server":{"name":"%s"}}`, *serverName)
}
w.Write([]byte(jsonStr))
}
BeforeEach(func() {
serverName = nil
handler := http.HandlerFunc(handlerFunc)
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
Context("when the server name is present in the JSON", func() {
BeforeEach(func() {
name := "fake-server-name"
serverName = &name
})
It("returns the server name", func() {
name, err := metadataService.GetServerName()
Expect(err).ToNot(HaveOccurred())
Expect(name).To(Equal("fake-server-name"))
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetServerName()
})
})
Context("when the server name is not present in the JSON", func() {
BeforeEach(func() {
serverName = nil
})
It("returns an error", func() {
name, err := metadataService.GetServerName()
Expect(err).To(HaveOccurred())
Expect(name).To(BeEmpty())
})
})
})
Describe("GetRegistryEndpoint", func() {
var (
ts *httptest.Server
registryURL *string
dnsServer *string
)
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/latest/user-data"))
var jsonStr string
if dnsServer == nil {
jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL)
} else {
jsonStr = fmt.Sprintf(`{
"registry":{"endpoint":"%s"},
"dns":{"nameserver":["%s"]}
}`, *registryURL, *dnsServer)
}
w.Write([]byte(jsonStr))
}
BeforeEach(func() {
url := "http://fake-registry.com"
registryURL = &url
dnsServer = nil
handler := http.HandlerFunc(handlerFunc)
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetRegistryEndpoint()
})
Context("when metadata contains a dns server", func() {
BeforeEach(func() {
server := "fake-dns-server-ip"
dnsServer = &server
})
Context("when registry endpoint is successfully resolved", func() {
BeforeEach(func() {
dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{
DNSServers: []string{"fake-dns-server-ip"},
Host: "http://fake-registry.com",
IP: "http://fake-registry-ip",
})
})
It("returns the successfully resolved registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry-ip"))
})
})
Context("when registry endpoint is not successfully resolved", func() {
BeforeEach(func() {
dnsResolver.LookupHostErr = errors.New("fake-lookup-host-err")
})
It("returns error because it failed to resolve registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err"))
Expect(endpoint).To(BeEmpty())
})
})
})
Context("when metadata does not contain dns servers", func() {
It("returns fetched registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).NotTo(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry.com"))
})
})
})
Describe("GetNetworks", func() {
It("returns nil networks, since you don't need them for bootstrapping since your network must be set up before you can get the metadata", func() {
Expect(metadataService.GetNetworks()).To(BeNil())
})
})
}
func describeHTTPRegistry() {
var (
metadataService *fakeinf.FakeMetadataService
registry Registry
platform *fakeplat.FakePlatform
)
BeforeEach(func() {
metadataService = &fakeinf.FakeMetadataService{}
platform = &fakeplat.FakePlatform{}
registry = NewHTTPRegistry(metadataService, platform, false)
})
Describe("GetSettings", func() {
var (
ts *httptest.Server
settingsJSON string
)
BeforeEach(func() {
boshRegistryHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/instances/fake-identifier/settings"))
w.Write([]byte(settingsJSON))
})
ts = httptest.NewServer(boshRegistryHandler)
})
AfterEach(func() {
ts.Close()
})
Describe("Network bootstrapping", func() {
BeforeEach(func() {
settingsJSON = `{"settings": "{\"agent_id\":\"my-agent-id\"}"}`
metadataService.InstanceID = "fake-identifier"
metadataService.RegistryEndpoint = ts.URL
registry = NewHTTPRegistry(metadataService, platform, false)
})
Context("when the metadata has Networks information", func() {
It("configures the network with those settings before hitting the registry", func() {
networkSettings := boshsettings.Networks{
"net1": boshsettings.Network{IP: "1.2.3.4"},
"net2": boshsettings.Network{IP: "2.3.4.5"},
}
metadataService.Networks = networkSettings
_, err := registry.GetSettings()
Expect(err).ToNot(HaveOccurred())
Expect(platform.SetupNetworkingCalled).To(BeTrue())
Expect(platform.SetupNetworkingNetworks).To(Equal(networkSettings))
})
})
Context("when the metadata has no Networks information", func() {
It("does no network configuration for now (the stemcell set up dhcp already)", func() {
metadataService.Networks = boshsettings.Networks{}
_, err := registry.GetSettings()
Expect(err).ToNot(HaveOccurred())
Expect(platform.SetupNetworkingCalled).To(BeFalse())
})
})
Context("when the metadata service fails to get Networks information", func() {
It("wraps the error", func() {
metadataService.Networks = boshsettings.Networks{}
metadataService.NetworksErr = errors.New("fake-get-networks-err")
_, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("Getting networks: fake-get-networks-err"))
})
})
Context("when the SetupNetworking fails", func() {
It("wraps the error", func() {
networkSettings := boshsettings.Networks{
"net1": boshsettings.Network{IP: "1.2.3.4"},
"net2": boshsettings.Network{IP: "2.3.4.5"},
}
metadataService.Networks = networkSettings
platform.SetupNetworkingErr = errors.New("fake-setup-networking-error")
_, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(Equal("Setting up networks: fake-setup-networking-error"))
})
})
})
Context("when registry is configured to not use server name as id", func() {
BeforeEach(func() {
registry = NewHTTPRegistry(metadataService, platform, false)
metadataService.InstanceID = "fake-identifier"
metadataService.RegistryEndpoint = ts.URL
})
It("returns settings fetched from http server based on instance id", func() {
settingsJSON = `{"settings": "{\"agent_id\":\"my-agent-id\"}"}`
settings, err := registry.GetSettings()
Expect(err).ToNot(HaveOccurred())
Expect(settings).To(Equal(boshsettings.Settings{AgentID: "my-agent-id"}))
})
It("returns error if registry settings wrapper cannot be parsed", func() {
settingsJSON = "invalid-json"
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Unmarshalling settings wrapper"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
It("returns error if registry settings wrapper contains invalid json", func() {
settingsJSON = `{"settings": "invalid-json"}`
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Unmarshalling wrapped settings"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
It("returns error if metadata service fails to return instance id", func() {
metadataService.GetInstanceIDErr = errors.New("fake-get-instance-id-err")
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-instance-id-err"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
It("returns error if metadata service fails to return registry endpoint", func() {
metadataService.GetRegistryEndpointErr = errors.New("fake-get-registry-endpoint-err")
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-registry-endpoint-err"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
Describe("setting fields", func() {
It("unmarshalls JSON properly", 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",
"port": 443
},
"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{
Type: "s3",
Options: map[string]interface{}{
"bucket_name": "george",
"encryption_key": "optional encryption key",
"access_key_id": "optional access key id",
"secret_access_key": "optional secret access key",
"port": 443.0,
},
},
Disks: boshsettings.Disks{
Ephemeral: "/dev/sdb",
Persistent: map[string]interface{}{"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",
},
}
metadataService.InstanceID = "fake-identifier"
metadataService.RegistryEndpoint = ts.URL
settings, err := registry.GetSettings()
Expect(err).ToNot(HaveOccurred())
Expect(settings).To(Equal(expectedSettings))
})
})
})
Context("when registry is configured to use server name as id", func() {
BeforeEach(func() {
registry = NewHTTPRegistry(metadataService, platform, true)
metadataService.ServerName = "fake-identifier"
metadataService.RegistryEndpoint = ts.URL
})
It("returns settings fetched from http server based on server name", func() {
settingsJSON = `{"settings": "{\"agent_id\":\"my-agent-id\"}"}`
settings, err := registry.GetSettings()
Expect(err).ToNot(HaveOccurred())
Expect(settings).To(Equal(boshsettings.Settings{AgentID: "my-agent-id"}))
})
It("returns error if registry settings wrapper cannot be parsed", func() {
settingsJSON = "invalid-json"
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Unmarshalling settings wrapper"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
It("returns error if registry settings wrapper contains invalid json", func() {
settingsJSON = `{"settings": "invalid-json"}`
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Unmarshalling wrapped settings"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
It("returns error if metadata service fails to return server name", func() {
metadataService.GetServerNameErr = errors.New("fake-get-server-name-err")
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-server-name-err"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
It("returns error if metadata service fails to return registry endpoint", func() {
metadataService.GetRegistryEndpointErr = errors.New("fake-get-registry-endpoint-err")
settings, err := registry.GetSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-get-registry-endpoint-err"))
Expect(settings).To(Equal(boshsettings.Settings{}))
})
})
})
}
func describeHTTPMetadataService() {
var (
metadataHeaders map[string]string
dnsResolver *fakeinf.FakeDNSResolver
platform *fakeplat.FakePlatform
logger boshlog.Logger
metadataService MetadataService
)
BeforeEach(func() {
metadataHeaders = make(map[string]string)
metadataHeaders["key"] = "value"
dnsResolver = &fakeinf.FakeDNSResolver{}
platform = fakeplat.NewFakePlatform()
logger = boshlog.NewLogger(boshlog.LevelNone)
metadataService = NewHTTPMetadataService("fake-metadata-host", metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger)
})
ItEnsuresMinimalNetworkSetup := func(subject func() (string, error)) {
Context("when no networks are configured", func() {
BeforeEach(func() {
platform.GetConfiguredNetworkInterfacesInterfaces = []string{}
})
It("sets up DHCP network", func() {
_, err := subject()
Expect(err).ToNot(HaveOccurred())
Expect(platform.SetupNetworkingCalled).To(BeTrue())
Expect(platform.SetupNetworkingNetworks).To(Equal(boshsettings.Networks{
"eth0": boshsettings.Network{
Type: "dynamic",
},
}))
})
Context("when setting up DHCP fails", func() {
BeforeEach(func() {
platform.SetupNetworkingErr = errors.New("fake-network-error")
})
It("returns an error", func() {
_, err := subject()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-network-error"))
})
})
})
}
Describe("IsAvailable", func() {
It("returns true", func() {
Expect(metadataService.IsAvailable()).To(BeTrue())
})
})
Describe("GetPublicKey", func() {
var (
ts *httptest.Server
sshKeysPath string
)
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/ssh-keys"))
Expect(r.Header.Get("key")).To(Equal("value"))
w.Write([]byte("fake-public-key"))
})
ts = httptest.NewServer(handler)
})
AfterEach(func() {
ts.Close()
})
Context("when the ssh keys path is present", func() {
BeforeEach(func() {
sshKeysPath = "/ssh-keys"
metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", sshKeysPath, dnsResolver, platform, logger)
})
It("returns fetched public key", func() {
publicKey, err := metadataService.GetPublicKey()
Expect(err).NotTo(HaveOccurred())
Expect(publicKey).To(Equal("fake-public-key"))
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetPublicKey()
})
})
Context("when the ssh keys path is not present", func() {
BeforeEach(func() {
sshKeysPath = ""
metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", sshKeysPath, dnsResolver, platform, logger)
})
It("returns an empty ssh key", func() {
publicKey, err := metadataService.GetPublicKey()
Expect(err).NotTo(HaveOccurred())
Expect(publicKey).To(BeEmpty())
})
})
})
Describe("GetInstanceID", func() {
var (
ts *httptest.Server
instanceIDPath string
)
BeforeEach(func() {
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/instanceid"))
Expect(r.Header.Get("key")).To(Equal("value"))
w.Write([]byte("fake-instance-id"))
})
ts = httptest.NewServer(handler)
})
AfterEach(func() {
ts.Close()
})
Context("when the instance ID path is present", func() {
BeforeEach(func() {
instanceIDPath = "/instanceid"
metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", instanceIDPath, "/ssh-keys", dnsResolver, platform, logger)
})
It("returns fetched instance id", func() {
instanceID, err := metadataService.GetInstanceID()
Expect(err).NotTo(HaveOccurred())
Expect(instanceID).To(Equal("fake-instance-id"))
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetInstanceID()
})
})
Context("when the instance ID path is not present", func() {
BeforeEach(func() {
instanceIDPath = ""
metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", instanceIDPath, "/ssh-keys", dnsResolver, platform, logger)
})
It("returns an empty instance ID", func() {
instanceID, err := metadataService.GetInstanceID()
Expect(err).NotTo(HaveOccurred())
Expect(instanceID).To(BeEmpty())
})
})
})
Describe("GetServerName", func() {
var (
ts *httptest.Server
serverName *string
)
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
defer GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/user-data"))
Expect(r.Header.Get("key")).To(Equal("value"))
var jsonStr string
if serverName == nil {
jsonStr = `{}`
} else {
jsonStr = fmt.Sprintf(`{"server":{"name":"%s"}}`, *serverName)
}
w.Write([]byte(jsonStr))
}
BeforeEach(func() {
serverName = nil
handler := http.HandlerFunc(handlerFunc)
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
Context("when the server name is present in the JSON", func() {
BeforeEach(func() {
name := "fake-server-name"
serverName = &name
})
It("returns the server name", func() {
name, err := metadataService.GetServerName()
Expect(err).ToNot(HaveOccurred())
Expect(name).To(Equal("fake-server-name"))
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetServerName()
})
})
Context("when the server name is not present in the JSON", func() {
BeforeEach(func() {
serverName = nil
})
It("returns an error", func() {
name, err := metadataService.GetServerName()
Expect(err).To(HaveOccurred())
Expect(name).To(BeEmpty())
})
})
})
Describe("GetRegistryEndpoint", func() {
var (
ts *httptest.Server
registryURL *string
dnsServer *string
)
handlerFunc := func(w http.ResponseWriter, r *http.Request) {
defer GinkgoRecover()
Expect(r.Method).To(Equal("GET"))
Expect(r.URL.Path).To(Equal("/user-data"))
Expect(r.Header.Get("key")).To(Equal("value"))
var jsonStr string
if dnsServer == nil {
jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL)
} else {
jsonStr = fmt.Sprintf(`{
"registry":{"endpoint":"%s"},
"dns":{"nameserver":["%s"]}
}`, *registryURL, *dnsServer)
}
w.Write([]byte(jsonStr))
}
BeforeEach(func() {
url := "http://fake-registry.com"
registryURL = &url
dnsServer = nil
handler := http.HandlerFunc(handlerFunc)
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataService(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger)
})
AfterEach(func() {
ts.Close()
})
ItEnsuresMinimalNetworkSetup(func() (string, error) {
return metadataService.GetRegistryEndpoint()
})
Context("when metadata contains a dns server", func() {
BeforeEach(func() {
server := "fake-dns-server-ip"
dnsServer = &server
})
Context("when registry endpoint is successfully resolved", func() {
BeforeEach(func() {
dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{
DNSServers: []string{"fake-dns-server-ip"},
Host: "http://fake-registry.com",
IP: "http://fake-registry-ip",
})
})
It("returns the successfully resolved registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry-ip"))
})
})
Context("when registry endpoint is not successfully resolved", func() {
BeforeEach(func() {
dnsResolver.LookupHostErr = errors.New("fake-lookup-host-err")
})
It("returns error because it failed to resolve registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-lookup-host-err"))
Expect(endpoint).To(BeEmpty())
})
})
})
Context("when metadata does not contain dns servers", func() {
It("returns fetched registry endpoint", func() {
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).NotTo(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry.com"))
})
})
})
Describe("GetNetworks", func() {
It("returns nil networks, since you don't need them for bootstrapping since your network must be set up before you can get the metadata", func() {
Expect(metadataService.GetNetworks()).To(BeNil())
})
})
Describe("Retryable Metadata Service Request", func() {
var (
ts *httptest.Server
registryURL *string
dnsServer *string
)
createHandlerFunc := func(count int) func(http.ResponseWriter, *http.Request) {
initialCount := 0
return func(w http.ResponseWriter, r *http.Request) {
if initialCount < count {
initialCount++
http.Error(w, http.StatusText(500), 500)
return
}
var jsonStr string
if dnsServer == nil {
jsonStr = fmt.Sprintf(`{"registry":{"endpoint":"%s"}}`, *registryURL)
} else {
jsonStr = fmt.Sprintf(`{
"registry":{"endpoint":"%s"},
"dns":{"nameserver":["%s"]}
}`, *registryURL, *dnsServer)
}
w.Write([]byte(jsonStr))
}
}
BeforeEach(func() {
url := "http://fake-registry.com"
registryURL = &url
dnsServer = nil
})
AfterEach(func() {
ts.Close()
})
Context("when server returns an HTTP Response with status code ==2xx (as defined by the request retryable) within 10 retries", func() {
BeforeEach(func() {
dnsResolver.RegisterRecord(fakeinf.FakeDNSRecord{
DNSServers: []string{"fake-dns-server-ip"},
Host: "http://fake-registry.com",
IP: "http://fake-registry-ip",
})
})
It("returns the successfully resolved registry endpoint", func() {
handler := http.HandlerFunc(createHandlerFunc(9))
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataServiceWithCustomRetryDelay(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger, 0*time.Second)
endpoint, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(HaveOccurred())
Expect(endpoint).To(Equal("http://fake-registry.com"))
})
})
Context("when server returns an HTTP Response with status code !=2xx (as defined by the request retryable) more than 10 times", func() {
It("returns an error containing the HTTP Response", func() {
handler := http.HandlerFunc(createHandlerFunc(10))
ts = httptest.NewServer(handler)
metadataService = NewHTTPMetadataServiceWithCustomRetryDelay(ts.URL, metadataHeaders, "/user-data", "/instanceid", "/ssh-keys", dnsResolver, platform, logger, 0*time.Second)
_, err := metadataService.GetRegistryEndpoint()
Expect(err).ToNot(BeNil())
Expect(err.Error()).To(Equal(fmt.Sprintf("Getting user data: Getting user data from url %s/user-data: Request failed, response: Response{ StatusCode: 500, Status: '500 Internal Server Error' }", ts.URL)))
})
})
})
}
