Class: Miasma::Models::LoadBalancer::Aws

Inherits:
Miasma::Models::LoadBalancer show all
Includes:
Contrib::AwsApiCore::ApiCommon, Contrib::AwsApiCore::RequestUtils
Defined in:
lib/miasma/contrib/aws/load_balancer.rb

Constant Summary collapse

API_SERVICE =

Service name of API

'elasticloadbalancing'
API_VERSION =

Supported version of the ELB API

'2012-06-01'

Instance Method Summary collapse

Methods included from Contrib::AwsApiCore::RequestUtils

#all_result_pages

Methods included from Contrib::AwsApiCore::ApiCommon

#api_for, #connect, #connection, #endpoint, included, #make_request, #update_request, #uri_escape

Methods inherited from Miasma::Models::LoadBalancer

#balancers

Methods inherited from Types::Api

#api_for, #connect, #connection, #endpoint, #format_response, #initialize, #make_request, #provider, #request

Methods included from Utils::Memoization

#_memo, #clear_memoizations!, #memoize, #unmemoize

Methods included from Utils::Lazy

included

Constructor Details

This class inherits a constructor from Miasma::Types::Api

Instance Method Details

#balancer_all(options = {}) ⇒ Array<Models::LoadBalancer::Balancer>

Return all load balancers

Parameters:

  • options (Hash) (defaults to: {}) —

    filter

Returns:



161
162
163
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 161

def balancer_all(options={})
  load_balancer_data
end

#balancer_destroy(balancer) ⇒ TrueClass, FalseClass

Delete load balancer

Parameters:

Returns:

  • (TrueClass, FalseClass) 


139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 139

def balancer_destroy(balancer)
  if(balancer.persisted?)
    request(
      :path => '/',
      :params => Smash.new(
        'Action' => 'DeleteLoadBalancer',
        'LoadBalancerName' => balancer.name
      )
    )
    balancer.state = :pending
    balancer.status = 'DELETE_IN_PROGRESS'
    balancer.valid_state
    true
  else
    false
  end
end

#balancer_health_check(balancer) ⇒ Models::LoadBalancer::Balancer

Save the load balancer health check

Parameters:

Returns:



76
77
78
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 76

def balancer_health_check(balancer)
  balancer
end

#balancer_reload(balancer) ⇒ Models::LoadBalancer::Balancer

Reload the balancer data from the API

Parameters:

Returns:



92
93
94
95
96
97
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 92

def balancer_reload(balancer)
  if(balancer.persisted?)
    load_balancer_data(balancer)
  end
  balancer
end

#balancer_save(balancer) ⇒ Models::LoadBalancer::Balancer

Save load balancer

Parameters:

Returns:



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 20

def balancer_save(balancer)
  unless(balancer.persisted?)
    params = Smash.new(
      'LoadBalancerName' => balancer.name
    )
    availability_zones.each_with_index do |az, i|
      params["AvailabilityZones.member.#{i+1}"] = az
    end
    if(balancer.listeners)
      balancer.listeners.each_with_index do |listener, i|
        key = "Listeners.member.#{i + 1}"
        params["#{key}.Protocol"] = listener.protocol
        params["#{key}.InstanceProtocol"] = listener.instance_protocol
        params["#{key}.LoadBalancerPort"] = listener.load_balancer_port
        params["#{key}.InstancePort"] = listener.instance_port
        if(listener.ssl_certificate_id)
          params["#{key}.SSLCertificateId"] = listener.ssl_certificate_id
        end
      end
    end
    result = request(
      :path => '/',
      :params => params.merge(
        Smash.new(
          'Action' => 'CreateLoadBalancer'
        )
      )
    )
    balancer.public_addresses = [
      :address => result.get(:body, 'CreateLoadBalancerResponse', 'CreateLoadBalancerResult', 'DNSName')
    ]
    balancer.load_data(:id => balancer.name).valid_state
    if(balancer.health_check)
      balancer_health_check(balancer)
    end
    if(balancer.servers && !balancer.servers.empty?)
      balancer_set_instances(balancer)
    end
  else
    if(balancer.dirty?)
      if(balancer.dirty?(:health_check))
        balancer_health_check(balancer)
      end
      if(balancer.dirty?(:servers))
        balancer_set_instances(balancer)
      end
      balancer.reload
    end
    balancer
  end
end

#balancer_set_instances(balancer) ⇒ Models::LoadBalancer::Balancer

Save the load balancer attached servers

Parameters:

Returns:



84
85
86
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 84

def balancer_set_instances(balancer)
  balancer
end

#load_balancer_data(balancer = nil) ⇒ Array<Models::LoadBalancer::Balancer>

Fetch balancers or update provided balancer data

Parameters:

Returns:



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/miasma/contrib/aws/load_balancer.rb', line 103

def load_balancer_data(balancer=nil)
  params = Smash.new('Action' => 'DescribeLoadBalancers')
  if(balancer)
    params.merge('LoadBalancerNames.member.1' => balancer.id || balancer.name)
  end
  result = all_result_pages(nil, :body, 'DescribeAutoScalingGroupsResponse', 'DescribeAutoScalingGroupsResult', 'AutoScalingGroups', 'member') do |options|
    request(
      :path => '/',
      :params => options.merge(params)
    )
  end
  [result.get(:body, 'DescribeLoadBalancersResponse', 'DescribeLoadBalancersResult', 'LoadBalancerDescriptions', 'member')].flatten.compact.map do |blr|
    (balancer || Balancer.new(self)).load_data(
      :id => blr['LoadBalancerName'],
      :name => blr['LoadBalancerName'],
      :state => :active,
      :status => 'ACTIVE',
      :created => blr['CreatedTime'],
      :updated => blr['CreatedTime'],
      :public_addresses => [
        Balancer::Address.new(
          :address => blr['DNSName'],
          :version => 4
        )
      ],
      :servers => [blr.get('Instances', 'member')].flatten(1).compact.map{|i|
        Balancer::Server.new(self.api_for(:compute), :id => i['InstanceId'])
      }
    ).valid_state
  end
end