125 lines
3.2 KiB
Go
125 lines
3.2 KiB
Go
package aws
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"github.com/hashicorp/terraform/helper/multierror"
|
|
"github.com/mitchellh/goamz/autoscaling"
|
|
"github.com/mitchellh/goamz/aws"
|
|
"github.com/mitchellh/goamz/ec2"
|
|
"github.com/mitchellh/goamz/elb"
|
|
"github.com/mitchellh/goamz/rds"
|
|
"github.com/mitchellh/goamz/route53"
|
|
"github.com/mitchellh/goamz/s3"
|
|
)
|
|
|
|
type Config struct {
|
|
AccessKey string
|
|
SecretKey string
|
|
Region string
|
|
}
|
|
|
|
type AWSClient struct {
|
|
ec2conn *ec2.EC2
|
|
elbconn *elb.ELB
|
|
autoscalingconn *autoscaling.AutoScaling
|
|
s3conn *s3.S3
|
|
rdsconn *rds.Rds
|
|
route53 *route53.Route53
|
|
}
|
|
|
|
// Client configures and returns a fully initailized AWSClient
|
|
func (c *Config) Client() (interface{}, error) {
|
|
var client AWSClient
|
|
|
|
// Get the auth and region. This can fail if keys/regions were not
|
|
// specified and we're attempting to use the environment.
|
|
var errs []error
|
|
log.Println("[INFO] Building AWS auth structure")
|
|
auth, err := c.AWSAuth()
|
|
if err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
|
|
log.Println("[INFO] Building AWS region structure")
|
|
region, err := c.AWSRegion()
|
|
if err != nil {
|
|
errs = append(errs, err)
|
|
}
|
|
|
|
if len(errs) == 0 {
|
|
log.Println("[INFO] Initializing EC2 connection")
|
|
client.ec2conn = ec2.New(auth, region)
|
|
log.Println("[INFO] Initializing ELB connection")
|
|
client.elbconn = elb.New(auth, region)
|
|
log.Println("[INFO] Initializing AutoScaling connection")
|
|
client.autoscalingconn = autoscaling.New(auth, region)
|
|
log.Println("[INFO] Initializing S3 connection")
|
|
client.s3conn = s3.New(auth, region)
|
|
log.Println("[INFO] Initializing RDS connection")
|
|
client.rdsconn = rds.New(auth, region)
|
|
log.Println("[INFO] Initializing Route53 connection")
|
|
client.route53 = route53.New(auth, region)
|
|
}
|
|
|
|
if len(errs) > 0 {
|
|
return nil, &multierror.Error{Errors: errs}
|
|
}
|
|
|
|
return &client, nil
|
|
}
|
|
|
|
// AWSAuth returns a valid aws.Auth object for access to AWS services, or
|
|
// an error if the authentication couldn't be resolved.
|
|
//
|
|
// TODO(mitchellh): Test in some way.
|
|
func (c *Config) AWSAuth() (aws.Auth, error) {
|
|
auth, err := aws.GetAuth(c.AccessKey, c.SecretKey)
|
|
if err == nil {
|
|
// Store the accesskey and secret that we got...
|
|
c.AccessKey = auth.AccessKey
|
|
c.SecretKey = auth.SecretKey
|
|
}
|
|
|
|
return auth, err
|
|
}
|
|
|
|
// IsValidRegion returns true if the configured region is a valid AWS
|
|
// region and false if it's not
|
|
func (c *Config) IsValidRegion() bool {
|
|
var regions = [11]string{"us-east-1", "us-west-2", "us-west-1", "eu-west-1",
|
|
"eu-central-1", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1",
|
|
"sa-east-1", "cn-north-1", "us-gov-west-1"}
|
|
|
|
for _, valid := range regions {
|
|
if c.Region == valid {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// AWSRegion returns the configured region.
|
|
//
|
|
// TODO(mitchellh): Test in some way.
|
|
func (c *Config) AWSRegion() (aws.Region, error) {
|
|
if c.Region != "" {
|
|
if c.IsValidRegion() {
|
|
return aws.Regions[c.Region], nil
|
|
} else {
|
|
return aws.Region{}, fmt.Errorf("Not a valid region: %s", c.Region)
|
|
}
|
|
}
|
|
|
|
md, err := aws.GetMetaData("placement/availability-zone")
|
|
if err != nil {
|
|
return aws.Region{}, err
|
|
}
|
|
|
|
region := strings.TrimRightFunc(string(md), unicode.IsLetter)
|
|
return aws.Regions[region], nil
|
|
}
|