From 6deabe8a2f2dd16f032861872ca38f43ab0c77ea Mon Sep 17 00:00:00 2001 From: Nick Jones Date: Sun, 8 Oct 2017 16:37:41 +0100 Subject: [PATCH] [OpenStack] Metadata service support This commit adds support for retrieving instance metadata on OpenStack public clouds. Signed-off-by: Nick Jones --- pkg/metadata/main.go | 8 +- pkg/metadata/provider_aws.go | 5 -- pkg/metadata/provider_openstack.go | 134 +++++++++++++++++++++++++++++ 3 files changed, 141 insertions(+), 6 deletions(-) create mode 100644 pkg/metadata/provider_openstack.go diff --git a/pkg/metadata/main.go b/pkg/metadata/main.go index 1e1689392..37745f429 100644 --- a/pkg/metadata/main.go +++ b/pkg/metadata/main.go @@ -19,6 +19,10 @@ const ( // SSH is the path where sshd configuration from the provider is stored SSH = "ssh" + + // Standard AWS-compatible Metadata URLs + userDataURL = "http://169.254.169.254/latest/user-data" + metaDataURL = "http://169.254.169.254/latest/meta-data" ) // Provider is a generic interface for metadata/userdata providers. @@ -41,7 +45,7 @@ var netProviders []Provider var cdromProviders []Provider func main() { - providers := []string{"aws", "gcp", "vultr", "packet", "cdrom"} + providers := []string{"aws", "gcp", "openstack", "vultr", "packet", "cdrom"} if len(os.Args) > 1 { providers = os.Args[1:] } @@ -51,6 +55,8 @@ func main() { netProviders = append(netProviders, NewAWS()) case "gcp": netProviders = append(netProviders, NewGCP()) + case "openstack": + netProviders = append(netProviders, NewOpenstack()) case "packet": netProviders = append(netProviders, NewPacket()) case "vultr": diff --git a/pkg/metadata/provider_aws.go b/pkg/metadata/provider_aws.go index 37d68b47b..0b731b31d 100644 --- a/pkg/metadata/provider_aws.go +++ b/pkg/metadata/provider_aws.go @@ -10,11 +10,6 @@ import ( "time" ) -const ( - userDataURL = "http://169.254.169.254/latest/user-data" - metaDataURL = "http://169.254.169.254/latest/meta-data/" -) - // ProviderAWS is the type implementing the Provider interface for AWS type ProviderAWS struct { } diff --git a/pkg/metadata/provider_openstack.go b/pkg/metadata/provider_openstack.go new file mode 100644 index 000000000..8bba1e0af --- /dev/null +++ b/pkg/metadata/provider_openstack.go @@ -0,0 +1,134 @@ +package main + +import ( + "fmt" + "io/ioutil" + "log" + "net/http" + "os" + "path" + "time" +) + +// ProviderOpenstack is the type implementing the Provider interface for OpenStack +type ProviderOpenstack struct { +} + +// NewOpenstack returns a new ProviderOpenstack +func NewOpenstack() *ProviderOpenstack { + return &ProviderOpenstack{} +} + +func (p *ProviderOpenstack) String() string { + return "openstack" +} + +// Probe checks if we are running on OpenStack +func (p *ProviderOpenstack) Probe() bool { + // Getting the hostname should always work... + _, err := openstackGet(metaDataURL + "hostname") + return (err == nil) +} + +// Extract gets both the OpenStack specific and generic userdata +func (p *ProviderOpenstack) Extract() ([]byte, error) { + // Get host name. This must not fail + hostname, err := openstackGet(metaDataURL + "hostname") + if err != nil { + return nil, err + } + err = ioutil.WriteFile(path.Join(ConfigPath, Hostname), hostname, 0644) + if err != nil { + return nil, fmt.Errorf("OpenStack: Failed to write hostname: %s", err) + } + + // public ipv4 + openstackMetaGet("public-ipv4", "public_ipv4", 0644) + + // private ipv4 + openstackMetaGet("local-ipv4", "local_ipv4", 0644) + + // availability zone + openstackMetaGet("placement/availability-zone", "availability_zone", 0644) + + // instance type + openstackMetaGet("instance-type", "instance_type", 0644) + + // instance-id + openstackMetaGet("instance-id", "instance_id", 0644) + + // local-hostname + openstackMetaGet("local-hostname", "local_hostname", 0644) + + // ssh + if err := p.handleSSH(); err != nil { + log.Printf("OpenStack: Failed to get ssh data: %s", err) + } + + // Generic userdata + userData, err := openstackGet(userDataURL) + if err != nil { + log.Printf("OpenStack: Failed to get user-data: %s", err) + // This is not an error + return nil, nil + } + return userData, nil +} + +// lookup a value (lookupName) in OpenStack's metaservice and store in given fileName +func openstackMetaGet(lookupName string, fileName string, fileMode os.FileMode) { + if lookupValue, err := openstackGet(metaDataURL + lookupName); err == nil { + // we got a value from the metadata server, now save to filesystem + err = ioutil.WriteFile(path.Join(ConfigPath, fileName), lookupValue, fileMode) + if err != nil { + // we couldn't save the file for some reason + log.Printf("OpenStack: Failed to write %s:%s %s", fileName, lookupValue, err) + } + } else { + // we did not get a value back from the metadata server + log.Printf("OpenStack: Failed to get %s: %s", lookupName, err) + } +} + +// openstackGet requests and extracts the requested URL +func openstackGet(url string) ([]byte, error) { + var client = &http.Client{ + Timeout: time.Second * 2, + } + + req, err := http.NewRequest("", url, nil) + if err != nil { + return nil, fmt.Errorf("OpenStack: http.NewRequest failed: %s", err) + } + + resp, err := client.Do(req) + if err != nil { + return nil, fmt.Errorf("OpenStack: Could not contact metadata service: %s", err) + } + if resp.StatusCode != 200 { + return nil, fmt.Errorf("OpenStack: Status not ok: %d", resp.StatusCode) + } + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return nil, fmt.Errorf("OpenStack: Failed to read http response: %s", err) + } + return body, nil +} + +// SSH keys: +func (p *ProviderOpenstack) handleSSH() error { + sshKeys, err := openstackGet(metaDataURL + "public-keys/0/openssh-key") + if err != nil { + return fmt.Errorf("Failed to get sshKeys: %s", err) + } + + if err := os.Mkdir(path.Join(ConfigPath, SSH), 0755); err != nil { + return fmt.Errorf("Failed to create %s: %s", SSH, err) + } + + err = ioutil.WriteFile(path.Join(ConfigPath, SSH, "authorized_keys"), sshKeys, 0600) + if err != nil { + return fmt.Errorf("Failed to write ssh keys: %s", err) + } + return nil +}