handle aws.Config.MaxRetries by --retry-count option

aws/autoscaling.go

@@ -1,30 +1,23 @@
 package aws
+
 import (
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/autoscaling"
 	"github.com/stormcat24/ecs-formation/util"
 )
 
-
 type AutoscalingApi struct {
-	Credentials *credentials.Credentials
-	Region      *string
+	service *autoscaling.AutoScaling
 }
 
 func (self *AutoscalingApi) DescribeAutoScalingGroups(groups []string) (map[string]*autoscaling.Group, error) {
 
-	svc := autoscaling.New(&aws.Config{
-		Region: self.Region,
-		Credentials: self.Credentials,
-	})
-
 	params := &autoscaling.DescribeAutoScalingGroupsInput{
 		AutoScalingGroupNames: util.ConvertPointerString(groups),
 	}
 
 	asgmap := map[string]*autoscaling.Group{}
-	result, err := svc.DescribeAutoScalingGroups(params)
+	result, err := self.service.DescribeAutoScalingGroups(params)
 	if err != nil {
 		return asgmap, err
 	}
@@ -38,17 +31,12 @@ func (self *AutoscalingApi) DescribeAutoScalingGroups(groups []string) (map[stri
 
 func (self *AutoscalingApi) DescribeLoadBalancerState(group string) (map[string]*autoscaling.LoadBalancerState, error) {
 
-	svc := autoscaling.New(&aws.Config{
-		Region: self.Region,
-		Credentials: self.Credentials,
-	})
-
 	params := &autoscaling.DescribeLoadBalancersInput{
 		AutoScalingGroupName: aws.String(group),
 	}
 
 	lbmap := map[string]*autoscaling.LoadBalancerState{}
-	result, err := svc.DescribeLoadBalancers(params)
+	result, err := self.service.DescribeLoadBalancers(params)
 	if err != nil {
 		return lbmap, err
 	}
@@ -62,30 +50,20 @@ func (self *AutoscalingApi) DescribeLoadBalancerState(group string) (map[string]
 
 func (self *AutoscalingApi) AttachLoadBalancers(group string, lb []string) (*autoscaling.AttachLoadBalancersOutput, error) {
 
-	svc := autoscaling.New(&aws.Config{
-		Region: self.Region,
-		Credentials: self.Credentials,
-	})
-
 	params := &autoscaling.AttachLoadBalancersInput{
 		AutoScalingGroupName: aws.String(group),
-		LoadBalancerNames: util.ConvertPointerString(lb),
+		LoadBalancerNames:    util.ConvertPointerString(lb),
 	}
 
-	return svc.AttachLoadBalancers(params)
+	return self.service.AttachLoadBalancers(params)
 }
 
 func (self *AutoscalingApi) DetachLoadBalancers(group string, lb []string) (*autoscaling.DetachLoadBalancersOutput, error) {
 
-	svc := autoscaling.New(&aws.Config{
-		Region: self.Region,
-		Credentials: self.Credentials,
-	})
-
 	params := &autoscaling.DetachLoadBalancersInput{
 		AutoScalingGroupName: aws.String(group),
-		LoadBalancerNames: util.ConvertPointerString(lb),
+		LoadBalancerNames:    util.ConvertPointerString(lb),
 	}
 
-	return svc.DetachLoadBalancers(params)
-}
+	return self.service.DetachLoadBalancers(params)
+}

aws/aws.go

@@ -1,13 +1,19 @@
 package aws
 
 import (
+	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/aws/credentials"
+	"github.com/aws/aws-sdk-go/service/autoscaling"
+	"github.com/aws/aws-sdk-go/service/ecs"
+	"github.com/aws/aws-sdk-go/service/elb"
+	"github.com/aws/aws-sdk-go/service/sns"
+	"github.com/stormcat24/ecs-formation/config"
 )
 
-
 type AwsManager struct {
 	credentials *credentials.Credentials
-	region *string
+	region      string
+	retryCount  int
 }
 
 func NewAwsManager(accessKey string, secretKey string, region string) *AwsManager {
@@ -16,50 +22,49 @@ func NewAwsManager(accessKey string, secretKey string, region string) *AwsManage
 
 	manager := &AwsManager{
 		credentials: cred,
-		region: &region,
+		region:      region,
+		retryCount:  config.AppConfig.RetryCount,
 	}
 
 	return manager
 }
 
-func (self *AwsManager) ClusterApi() *EcsClusterApi {
-	return &EcsClusterApi{
-		Credentials: self.credentials,
-		Region: self.region,
-	}
-}
-
-func (self *AwsManager) ServiceApi() *EcsServiceApi {
-	return &EcsServiceApi{
-		Credentials: self.credentials,
-		Region: self.region,
-	}
-}
-
-func (self *AwsManager) TaskApi() *EcsTaskApi {
-	return &EcsTaskApi{
-		Credentials: self.credentials,
-		Region: self.region,
+func (self *AwsManager) EcsApi() *EcsApi {
+	return &EcsApi{
+		service: ecs.New(&aws.Config{
+			Credentials: self.credentials,
+			Region:      &self.region,
+			MaxRetries:  &self.retryCount,
+		}),
 	}
 }
 
 func (self *AwsManager) ElbApi() *ElbApi {
 	return &ElbApi{
-		Credentials: self.credentials,
-		Region: self.region,
+		service: elb.New(&aws.Config{
+			Credentials: self.credentials,
+			Region:      &self.region,
+			MaxRetries:  &self.retryCount,
+		}),
 	}
 }
 
 func (self *AwsManager) AutoscalingApi() *AutoscalingApi {
 	return &AutoscalingApi{
-		Credentials: self.credentials,
-		Region: self.region,
+		service: autoscaling.New(&aws.Config{
+			Credentials: self.credentials,
+			Region:      &self.region,
+			MaxRetries:  &self.retryCount,
+		}),
 	}
 }
 
 func (self *AwsManager) SnsApi() *SnsApi {
 	return &SnsApi{
-		Credentials: self.credentials,
-		Region: self.region,
+		service: sns.New(&aws.Config{
+			Credentials: self.credentials,
+			Region:      &self.region,
+			MaxRetries:  &self.retryCount,
+		}),
 	}
-}
+}

aws/ecs_api.go

@@ -0,0 +1,165 @@
+package aws
+
+import (
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/ecs"
+)
+
+type EcsApi struct {
+	service *ecs.ECS
+}
+
+// Cluster API
+func (self *EcsApi) CreateCluster(clusterName string) (*ecs.CreateClusterOutput, error) {
+
+	params := &ecs.CreateClusterInput{
+		ClusterName: aws.String(clusterName),
+	}
+
+	return self.service.CreateCluster(params)
+}
+
+func (self *EcsApi) DeleteCluster(clusterName string) (*ecs.DeleteClusterOutput, error) {
+
+	params := &ecs.DeleteClusterInput{
+		Cluster: aws.String(clusterName),
+	}
+
+	return self.service.DeleteCluster(params)
+}
+
+func (self *EcsApi) DescribeClusters(clusterNames []*string) (*ecs.DescribeClustersOutput, error) {
+
+	params := &ecs.DescribeClustersInput{
+		Clusters: clusterNames,
+	}
+
+	return self.service.DescribeClusters(params)
+}
+
+func (self *EcsApi) ListClusters(maxResult int64) (*ecs.ListClustersOutput, error) {
+
+	params := &ecs.ListClustersInput{
+		MaxResults: &maxResult,
+	}
+
+	return self.service.ListClusters(params)
+}
+
+func (self *EcsApi) ListContainerInstances(cluster string) (*ecs.ListContainerInstancesOutput, error) {
+
+	params := &ecs.ListContainerInstancesInput{
+		Cluster: aws.String(cluster),
+	}
+
+	return self.service.ListContainerInstances(params)
+}
+
+// Service API
+func (self *EcsApi) CreateService(cluster string, service string, desiredCount int64, lb []*ecs.LoadBalancer, taskDef string, role string) (*ecs.CreateServiceOutput, error) {
+
+	params := &ecs.CreateServiceInput{
+		ServiceName:    aws.String(service),
+		Cluster:        aws.String(cluster),
+		DesiredCount:   &desiredCount,
+		LoadBalancers:  lb,
+		TaskDefinition: aws.String(taskDef),
+	}
+
+	if role != "" {
+		params.Role = aws.String(role)
+	}
+
+	return self.service.CreateService(params)
+}
+
+func (self *EcsApi) UpdateService(cluster string, service string, desiredCount int64, taskDef string) (*ecs.UpdateServiceOutput, error) {
+
+	params := &ecs.UpdateServiceInput{
+		Cluster:        aws.String(cluster),
+		Service:        aws.String(service),
+		DesiredCount:   &desiredCount,
+		TaskDefinition: aws.String(taskDef),
+	}
+
+	return self.service.UpdateService(params)
+}
+
+func (self *EcsApi) DescribeService(cluster string, services []*string) (*ecs.DescribeServicesOutput, error) {
+
+	params := &ecs.DescribeServicesInput{
+		Cluster:  aws.String(cluster),
+		Services: services,
+	}
+
+	return self.service.DescribeServices(params)
+}
+
+func (self *EcsApi) DeleteService(cluster string, service string) (*ecs.DeleteServiceOutput, error) {
+
+	params := &ecs.DeleteServiceInput{
+		Cluster: aws.String(cluster),
+		Service: aws.String(service),
+	}
+
+	return self.service.DeleteService(params)
+}
+
+func (self *EcsApi) ListServices(cluster string) (*ecs.ListServicesOutput, error) {
+
+	params := &ecs.ListServicesInput{
+		Cluster: aws.String(cluster),
+	}
+
+	return self.service.ListServices(params)
+}
+
+// TASK API
+func (self *EcsApi) DescribeTaskDefinition(defName string) (*ecs.DescribeTaskDefinitionOutput, error) {
+
+	params := &ecs.DescribeTaskDefinitionInput{
+		TaskDefinition: aws.String(defName),
+	}
+
+	return self.service.DescribeTaskDefinition(params)
+}
+
+func (self *EcsApi) RegisterTaskDefinition(taskName string, conDefs []*ecs.ContainerDefinition, volumes []*ecs.Volume) (*ecs.RegisterTaskDefinitionOutput, error) {
+
+	params := &ecs.RegisterTaskDefinitionInput{
+		ContainerDefinitions: conDefs,
+		Family:               aws.String(taskName),
+		Volumes:              volumes,
+	}
+
+	return self.service.RegisterTaskDefinition(params)
+}
+
+func (self *EcsApi) DeregisterTaskDefinition(taskName string) (*ecs.DeregisterTaskDefinitionOutput, error) {
+
+	params := &ecs.DeregisterTaskDefinitionInput{
+		TaskDefinition: aws.String(taskName),
+	}
+
+	return self.service.DeregisterTaskDefinition(params)
+}
+
+func (self *EcsApi) ListTasks(cluster string, service string) (*ecs.ListTasksOutput, error) {
+
+	params := &ecs.ListTasksInput{
+		Cluster:     aws.String(cluster),
+		ServiceName: aws.String(service),
+	}
+
+	return self.service.ListTasks(params)
+}
+
+func (self *EcsApi) DescribeTasks(cluster string, tasks []*string) (*ecs.DescribeTasksOutput, error) {
+
+	params := &ecs.DescribeTasksInput{
+		Cluster: aws.String(cluster),
+		Tasks:   tasks,
+	}
+
+	return self.service.DescribeTasks(params)
+}