github.com/awslabs/fargate@v0.2.3/elbv2/load_balancer.go (about)

     1  package elbv2
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/aws/aws-sdk-go/aws"
     7  	awselbv2 "github.com/aws/aws-sdk-go/service/elbv2"
     8  	"github.com/jpignata/fargate/console"
     9  )
    10  
    11  type LoadBalancer struct {
    12  	DNSName          string
    13  	Name             string
    14  	State            string
    15  	StateReason      string
    16  	Arn              string
    17  	Type             string
    18  	HostedZoneId     string
    19  	SecurityGroupIds []string
    20  	SubnetIds        []string
    21  	VpcId            string
    22  }
    23  
    24  type DescribeLoadBalancersInput struct {
    25  	Names []string
    26  	Arns  []string
    27  }
    28  
    29  type CreateLoadBalancerInput struct {
    30  	Name             string
    31  	SubnetIds        []string
    32  	Type             string
    33  	SecurityGroupIds []string
    34  }
    35  
    36  func (elbv2 *ELBV2) CreateLoadBalancer(i *CreateLoadBalancerInput) string {
    37  	console.Debug("Creating ELB load balancer")
    38  	input := &awselbv2.CreateLoadBalancerInput{
    39  		Name:    aws.String(i.Name),
    40  		Subnets: aws.StringSlice(i.SubnetIds),
    41  		Type:    aws.String(i.Type),
    42  	}
    43  
    44  	if i.Type == awselbv2.LoadBalancerTypeEnumApplication {
    45  		input.SetSecurityGroups(aws.StringSlice(i.SecurityGroupIds))
    46  	}
    47  
    48  	resp, err := elbv2.svc.CreateLoadBalancer(input)
    49  
    50  	if err != nil || len(resp.LoadBalancers) != 1 {
    51  		console.ErrorExit(err, "Could not create ELB load balancer")
    52  	}
    53  
    54  	return aws.StringValue(resp.LoadBalancers[0].LoadBalancerArn)
    55  }
    56  
    57  func (elbv2 *ELBV2) DescribeLoadBalancer(lbName string) LoadBalancer {
    58  	loadBalancers := elbv2.DescribeLoadBalancers(
    59  		DescribeLoadBalancersInput{
    60  			Names: []string{lbName},
    61  		},
    62  	)
    63  
    64  	if len(loadBalancers) == 0 {
    65  		console.ErrorExit(fmt.Errorf("%s not found", lbName), "Could not find ELB load balancer")
    66  	}
    67  
    68  	return loadBalancers[0]
    69  }
    70  
    71  func (elbv2 *ELBV2) DescribeLoadBalancerByArn(lbArn string) LoadBalancer {
    72  	loadBalancers := elbv2.DescribeLoadBalancers(
    73  		DescribeLoadBalancersInput{
    74  			Arns: []string{lbArn},
    75  		},
    76  	)
    77  
    78  	if len(loadBalancers) == 0 {
    79  		console.ErrorExit(fmt.Errorf("%s not found", lbArn), "Could not find ELB load balancer")
    80  	}
    81  
    82  	return loadBalancers[0]
    83  }
    84  
    85  func (elbv2 *ELBV2) DeleteLoadBalancer(lbName string) {
    86  	loadBalancer := elbv2.DescribeLoadBalancer(lbName)
    87  	_, err := elbv2.svc.DeleteLoadBalancer(
    88  		&awselbv2.DeleteLoadBalancerInput{
    89  			LoadBalancerArn: aws.String(loadBalancer.Arn),
    90  		},
    91  	)
    92  
    93  	if err != nil {
    94  		console.ErrorExit(err, "Could not destroy ELB load balancer")
    95  	}
    96  }
    97  
    98  func (elbv2 *ELBV2) DescribeLoadBalancers(i DescribeLoadBalancersInput) []LoadBalancer {
    99  	var loadBalancers []LoadBalancer
   100  
   101  	input := &awselbv2.DescribeLoadBalancersInput{}
   102  
   103  	if len(i.Names) > 0 {
   104  		input.SetNames(aws.StringSlice(i.Names))
   105  	}
   106  
   107  	if len(i.Arns) > 0 {
   108  		input.SetLoadBalancerArns(aws.StringSlice(i.Arns))
   109  	}
   110  
   111  	err := elbv2.svc.DescribeLoadBalancersPages(
   112  		input,
   113  		func(resp *awselbv2.DescribeLoadBalancersOutput, lastPage bool) bool {
   114  			for _, loadBalancer := range resp.LoadBalancers {
   115  				var subnetIds []string
   116  
   117  				for _, availabilityZone := range loadBalancer.AvailabilityZones {
   118  					subnetIds = append(subnetIds, aws.StringValue(availabilityZone.SubnetId))
   119  				}
   120  
   121  				loadBalancers = append(loadBalancers,
   122  					LoadBalancer{
   123  						Arn:              aws.StringValue(loadBalancer.LoadBalancerArn),
   124  						DNSName:          aws.StringValue(loadBalancer.DNSName),
   125  						HostedZoneId:     aws.StringValue(loadBalancer.CanonicalHostedZoneId),
   126  						VpcId:            aws.StringValue(loadBalancer.VpcId),
   127  						Name:             aws.StringValue(loadBalancer.LoadBalancerName),
   128  						SecurityGroupIds: aws.StringValueSlice(loadBalancer.SecurityGroups),
   129  						State:            aws.StringValue(loadBalancer.State.Code),
   130  						StateReason:      aws.StringValue(loadBalancer.State.Reason),
   131  						SubnetIds:        subnetIds,
   132  						Type:             aws.StringValue(loadBalancer.Type),
   133  					},
   134  				)
   135  			}
   136  
   137  			return true
   138  		},
   139  	)
   140  
   141  	if err != nil {
   142  		console.ErrorExit(err, "Could not describe ELB load balancers")
   143  	}
   144  
   145  	return loadBalancers
   146  }