func (s *AmazonServer) SetUp(c *check.C) {
auth, err := aws.EnvAuth()
if err != nil {
c.Fatal(err)
}
s.auth = auth
}
func ExampleV4Signer() {
// Get auth from env vars
auth, err := aws.EnvAuth()
if err != nil {
fmt.Println(err)
}
// Create a signer with the auth, name of the service, and aws region
signer := aws.NewV4Signer(auth, "dynamodb", aws.USEast)
// Create a request
req, err := http.NewRequest("POST", aws.USEast.DynamoDBEndpoint, strings.NewReader("sample_request"))
if err != nil {
fmt.Println(err)
}
// Date or x-amz-date header is required to sign a request
req.Header.Add("Date", time.Now().UTC().Format(http.TimeFormat))
// Sign the request
signer.Sign(req)
// Issue signed request
http.DefaultClient.Do(req)
}
func TestBasicGroupRequest(t *testing.T) {
var as *AutoScaling
awsAuth, err := aws.EnvAuth()
if err != nil {
mockTest = true
t.Log("Running mock tests as AWS environment variables are not set")
awsAuth := aws.Auth{AccessKey: "abc", SecretKey: "123"}
as = New(awsAuth, aws.Region{AutoScalingEndpoint: testServer.URL})
testServer.Start()
go testServer.WaitRequest()
testServer.Response(200, nil, astest.BasicGroupResponse)
} else {
as = New(awsAuth, aws.USWest2)
}
groupResp, err := as.DescribeAutoScalingGroups(nil)
if err != nil {
t.Fatal(err)
}
if len(groupResp.AutoScalingGroups) > 0 {
firstGroup := groupResp.AutoScalingGroups[0]
if len(firstGroup.AutoScalingGroupName) > 0 {
t.Logf("Found AutoScaling group %s\n",
firstGroup.AutoScalingGroupName)
}
}
testServer.Flush()
}
func (s *S) TestEnvAuthAlt(c *check.C) {
os.Clearenv()
os.Setenv("AWS_SECRET_KEY", "secret")
os.Setenv("AWS_ACCESS_KEY", "access")
auth, err := aws.EnvAuth()
c.Assert(err, check.IsNil)
c.Assert(auth, check.Equals, aws.Auth{SecretKey: "secret", AccessKey: "access"})
}
func InitBucket(name string) error {
auth, err := aws.EnvAuth()
if err != nil {
return err
}
s3 := s3.New(auth, aws.GetRegion("ap-southeast-1"))
Bucket = s3.Bucket(name)
return nil
}
func (s *LiveSuite) SetUpSuite(c *check.C) {
if !Amazon {
c.Skip("amazon tests not enabled (-amazon flag)")
}
auth, err := aws.EnvAuth()
if err != nil {
c.Fatal(err.Error())
}
s.auth = auth
}
func (s *SuiteI) SetUpSuite(c *check.C) {
if !*integration {
c.Skip("Integration tests not enabled (-i flag)")
}
auth, err := aws.EnvAuth()
if err != nil {
c.Fatal(err.Error())
}
s.auth = auth
}
func setUpAuth(c *check.C) {
if !*amazon {
c.Skip("Test against amazon not enabled.")
}
if *local {
c.Log("Using local server")
dynamodb_region = aws.Region{DynamoDBEndpoint: "http://127.0.0.1:8000"}
dynamodb_auth = aws.Auth{AccessKey: "DUMMY_KEY", SecretKey: "DUMMY_SECRET"}
} else {
c.Log("Using REAL AMAZON SERVER")
dynamodb_region = aws.USWest2
auth, err := aws.EnvAuth()
if err != nil {
c.Fatal(err)
}
dynamodb_auth = auth
}
}
func getDynamoServer(ctx *Context, region string) (*dynamodb.Server, error) {
Log(INFO, ctx, "getDynamoServer", "region", region)
// If we don't have real access keys, just try local. See
// ../local-dynamodb/. Otherwise go for real DynamoDB. ToDo:
// insist on using the real DynamoDB.
// ToDo: Combine with router/aws.go FindAWS()
if region == "local" {
r := aws.Region{DynamoDBEndpoint: "http://127.0.0.1:8000"}
auth := aws.Auth{AccessKey: "DUMMY_KEY", SecretKey: "DUMMY_SECRET"}
return dynamodb.New(auth, r), nil
} else if strings.HasPrefix(region, "http:") {
r := aws.Region{DynamoDBEndpoint: region}
auth, err := aws.GetAuth("", "", "", time.Now().Add(100000*time.Hour))
if err != nil {
Log(INFO, ctx, "router.FindAWS", "warning", err)
return nil, err
}
return dynamodb.New(auth, r), nil
} else {
auth, err := aws.EnvAuth()
if err != nil {
Log(INFO, ctx, "getDynamoServer", "warning", err, "when", "aws.EnvAuth")
// return nil, nil, err
// ToDo: Fix 100000 ...
auth, err = aws.GetAuth("", "", "", time.Now().Add(100000*time.Hour))
if err != nil {
Log(INFO, ctx, "router.FindAWS", "warning", err)
return nil, err
}
}
r, found := aws.Regions[region]
if !found {
err = fmt.Errorf("Bad region name '%s'", region)
Log(INFO, ctx, "getDynamoServer", "error", err)
return nil, err
}
return dynamodb.New(auth, r), nil
}
}
func TestAutoScalingGroup(t *testing.T) {
var as *AutoScaling
// Launch configuration test config
var lc LaunchConfiguration
lc.LaunchConfigurationName = "LConf1"
lc.ImageId = "ami-01146c31" // Debian squeeze amd64 ami
lc.KernelId = "aki-98e26fa8"
lc.KeyName = "testAWS" // Replace with valid key for your account
lc.InstanceType = "m1.small"
// AutoScalingGroup test config
var asg AutoScalingGroup
asg.AutoScalingGroupName = "ASGTest1"
asg.LaunchConfigurationName = lc.LaunchConfigurationName
asg.DefaultCooldown = 300
asg.HealthCheckGracePeriod = 300
asg.DesiredCapacity = 1
asg.MinSize = 1
asg.MaxSize = 5
asg.AvailabilityZones = []string{"us-west-2a"}
// Parameters for setting desired capacity to 1
var sp1 SetDesiredCapacityRequestParams
sp1.AutoScalingGroupName = asg.AutoScalingGroupName
sp1.DesiredCapacity = 1
// Parameters for setting desired capacity to 2
var sp2 SetDesiredCapacityRequestParams
sp2.AutoScalingGroupName = asg.AutoScalingGroupName
sp2.DesiredCapacity = 2
awsAuth, err := aws.EnvAuth()
if err != nil {
mockTest = true
t.Log("Running mock tests as AWS environment variables are not set")
awsAuth := aws.Auth{AccessKey: "abc", SecretKey: "123"}
as = New(awsAuth, aws.Region{AutoScalingEndpoint: testServer.URL})
} else {
as = New(awsAuth, aws.USWest2)
}
// Create the launch configuration
if mockTest {
testServer.Response(200, nil, astest.CreateLaunchConfigurationResponse)
}
_, err = as.CreateLaunchConfiguration(lc)
if err != nil {
t.Fatal(err)
}
// Check that we can get the launch configuration details
if mockTest {
testServer.Response(200, nil, astest.DescribeLaunchConfigurationResponse)
}
_, err = as.DescribeLaunchConfigurations([]string{lc.LaunchConfigurationName})
if err != nil {
t.Fatal(err)
}
// Create the AutoScalingGroup
if mockTest {
testServer.Response(200, nil, astest.CreateAutoScalingGroupResponse)
}
_, err = as.CreateAutoScalingGroup(asg)
if err != nil {
t.Fatal(err)
}
// Check that we can get the autoscaling group details
if mockTest {
testServer.Response(200, nil, astest.DescribeAutoScalingGroupResponse)
}
_, err = as.DescribeAutoScalingGroups(nil)
if err != nil {
t.Fatal(err)
}
// Suspend the scaling processes for the test AutoScalingGroup
if mockTest {
testServer.Response(200, nil, astest.SuspendProcessesResponse)
}
_, err = as.SuspendProcesses(asg, nil)
if err != nil {
t.Fatal(err)
}
// Resume scaling processes for the test AutoScalingGroup
if mockTest {
testServer.Response(200, nil, astest.ResumeProcessesResponse)
}
_, err = as.ResumeProcesses(asg, nil)
if err != nil {
t.Fatal(err)
}
// Change the desired capacity from 1 to 2. This will launch a second instance
if mockTest {
testServer.Response(200, nil, astest.SetDesiredCapacityResponse)
}
_, err = as.SetDesiredCapacity(sp2)
if err != nil {
t.Fatal(err)
}
// Change the desired capacity from 2 to 1. This will terminate one of the instances
if mockTest {
testServer.Response(200, nil, astest.SetDesiredCapacityResponse)
}
_, err = as.SetDesiredCapacity(sp1)
if err != nil {
t.Fatal(err)
}
// Update the max capacity for the scaling group
if mockTest {
testServer.Response(200, nil, astest.UpdateAutoScalingGroupResponse)
}
asg.MaxSize = 6
_, err = as.UpdateAutoScalingGroup(asg)
if err != nil {
t.Fatal(err)
}
// Add a scheduled action to the group
var psar PutScheduledActionRequestParams
psar.AutoScalingGroupName = asg.AutoScalingGroupName
psar.MaxSize = 4
psar.ScheduledActionName = "SATest1"
psar.Recurrence = "30 0 1 1,6,12 *"
if mockTest {
testServer.Response(200, nil, astest.PutScheduledUpdateGroupActionResponse)
}
_, err = as.PutScheduledUpdateGroupAction(psar)
if err != nil {
t.Fatal(err)
}
// List the scheduled actions for the group
var sar ScheduledActionsRequestParams
sar.AutoScalingGroupName = asg.AutoScalingGroupName
if mockTest {
testServer.Response(200, nil, astest.DescribeScheduledActionsResponse)
}
_, err = as.DescribeScheduledActions(sar)
if err != nil {
t.Fatal(err)
}
// Delete the test scheduled action from the group
var dsar DeleteScheduledActionRequestParams
dsar.AutoScalingGroupName = asg.AutoScalingGroupName
dsar.ScheduledActionName = psar.ScheduledActionName
if mockTest {
testServer.Response(200, nil, astest.DeleteScheduledActionResponse)
}
_, err = as.DeleteScheduledAction(dsar)
if err != nil {
t.Fatal(err)
}
testServer.Flush()
}
func (s *S) TestEnvAuthNoAccess(c *check.C) {
os.Clearenv()
os.Setenv("AWS_SECRET_ACCESS_KEY", "foo")
_, err := aws.EnvAuth()
c.Assert(err, check.ErrorMatches, "AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY not found in environment")
}
func (s *S) TestEnvAuthNoSecret(c *check.C) {
os.Clearenv()
_, err := aws.EnvAuth()
c.Assert(err, check.ErrorMatches, "AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY not found in environment")
}
func LoadAWSCredentials(profileName string) (aws.Auth, aws.Region, error) {
if profileName == "" {
if p := os.Getenv("AWS_DEFAULT_PROFILE"); p != "" {
profileName = p
} else {
profileName = AWSDefaultProfileName
}
}
var awsAuth aws.Auth
var awsRegion aws.Region
// load from File (~/.aws/config, ~/.aws/credentials)
configFile := os.Getenv("AWS_CONFIG_FILE")
if configFile == "" {
if dir, err := homedir.Dir(); err == nil {
configFile = filepath.Join(dir, ".aws", "config")
}
}
dir, _ := filepath.Split(configFile)
_profile := AWSDefaultProfileName
if profileName != AWSDefaultProfileName {
_profile = "profile " + profileName
}
auth, region, _ := loadAWSConfigFile(configFile, _profile)
if isValidAuth(auth) {
awsAuth = auth
}
if isValidRegion(region) {
awsRegion = region
}
credFile := filepath.Join(dir, "credentials")
auth, region, _ = loadAWSConfigFile(credFile, profileName)
if isValidAuth(auth) {
awsAuth = auth
}
if isValidRegion(region) {
awsRegion = region
}
// Override by environment valiable
if region := os.Getenv("AWS_DEFAULT_REGION"); region != "" {
awsRegion = aws.GetRegion(region)
}
if os.Getenv("AWS_ACCESS_KEY_ID") != "" && os.Getenv("AWS_SECRET_ACCESS_KEY") != "" {
if auth, _ := aws.EnvAuth(); isValidAuth(auth) {
awsAuth = auth
}
}
if isValidAuth(awsAuth) && isValidRegion(awsRegion) {
return awsAuth, awsRegion, nil
}
// Otherwise, use IAM Role
cred, err := aws.GetInstanceCredentials()
if err == nil {
exptdate, err := time.Parse("2006-01-02T15:04:05Z", cred.Expiration)
if err == nil {
auth := aws.NewAuth(cred.AccessKeyId, cred.SecretAccessKey, cred.Token, exptdate)
awsAuth = *auth
}
}
if isValidAuth(awsAuth) && isValidRegion(awsRegion) {
return awsAuth, awsRegion, nil
}
return awsAuth, awsRegion, errors.New("cannot detect valid credentials or region")
}
