/
load_balancer.rb
173 lines (148 loc) · 6.48 KB
/
load_balancer.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
require 'fog/core/model'
module Fog
module AWS
class ELB
class LoadBalancer < Fog::Model
identity :id, :aliases => 'LoadBalancerName'
attribute :availability_zones, :aliases => 'AvailabilityZones'
attribute :created_at, :aliases => 'CreatedTime'
attribute :dns_name, :aliases => 'DNSName'
attribute :health_check, :aliases => 'HealthCheck'
attribute :instances, :aliases => 'Instances'
attribute :source_group, :aliases => 'SourceSecurityGroup'
attribute :hosted_zone_name, :aliases => 'CanonicalHostedZoneName'
attribute :hosted_zone_name_id, :aliases => 'CanonicalHostedZoneNameID'
attribute :subnet_ids, :aliases => 'Subnets'
attribute :security_groups, :aliases => 'SecurityGroups'
attribute :scheme, :aliases => 'Scheme'
attribute :vpc_id, :aliases => 'VPCId'
def initialize(attributes={})
if attributes[:subnet_ids] ||= attributes['Subnets']
attributes[:availability_zones] ||= attributes['AvailabilityZones']
else
attributes[:availability_zones] ||= attributes['AvailabilityZones'] || %w(us-east-1a us-east-1b us-east-1c us-east-1d)
end
unless attributes['ListenerDescriptions']
new_listener = Fog::AWS::ELB::Listener.new
attributes['ListenerDescriptions'] = [{
'Listener' => new_listener.to_params,
'PolicyNames' => new_listener.policy_names
}]
end
attributes['Policies'] ||= {'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => []}
super
end
def register_instances(instances)
requires :id
data = connection.register_instances_with_load_balancer(instances, id).body['RegisterInstancesWithLoadBalancerResult']
data['Instances'].map!{|h| h['InstanceId']}
merge_attributes(data)
end
def deregister_instances(instances)
requires :id
data = connection.deregister_instances_from_load_balancer(instances, id).body['DeregisterInstancesFromLoadBalancerResult']
data['Instances'].map!{|h| h['InstanceId']}
merge_attributes(data)
end
def enable_availability_zones(zones)
requires :id
data = connection.enable_availability_zones_for_load_balancer(zones, id).body['EnableAvailabilityZonesForLoadBalancerResult']
merge_attributes(data)
end
def disable_availability_zones(zones)
requires :id
data = connection.disable_availability_zones_for_load_balancer(zones, id).body['DisableAvailabilityZonesForLoadBalancerResult']
merge_attributes(data)
end
def attach_subnets(subnet_ids)
requires :id
data = connection.attach_load_balancer_to_subnets(subnet_ids, id).body['AttachLoadBalancerToSubnetsResult']
merge_attributes(data)
end
def detach_subnets(subnet_ids)
requires :id
data = connection.detach_load_balancer_from_subnets(subnet_ids, id).body['DetachLoadBalancerFromSubnetsResult']
merge_attributes(data)
end
def apply_security_groups(security_groups)
requires :id
data = connection.apply_security_groups_to_load_balancer(security_groups, id).body['ApplySecurityGroupsToLoadBalancerResult']
merge_attributes(data)
end
def instance_health
requires :id
@instance_health ||= connection.describe_instance_health(id).body['DescribeInstanceHealthResult']['InstanceStates']
end
def instances_in_service
instance_health.select{|hash| hash['State'] == 'InService'}.map{|hash| hash['InstanceId']}
end
def instances_out_of_service
instance_health.select{|hash| hash['State'] == 'OutOfService'}.map{|hash| hash['InstanceId']}
end
def configure_health_check(health_check)
requires :id
data = connection.configure_health_check(id, health_check).body['ConfigureHealthCheckResult']['HealthCheck']
merge_attributes(:health_check => data)
end
def listeners
Fog::AWS::ELB::Listeners.new({
:data => attributes['ListenerDescriptions'],
:connection => connection,
:load_balancer => self
})
end
def policies
Fog::AWS::ELB::Policies.new({
:data => attributes['Policies'],
:connection => connection,
:load_balancer => self
})
end
def set_listener_policy(port, policy_name)
requires :id
policy_name = [policy_name].flatten
connection.set_load_balancer_policies_of_listener(id, port, policy_name)
reload
end
def set_listener_ssl_certificate(port, ssl_certificate_id)
requires :id
connection.set_load_balancer_listener_ssl_certificate(id, port, ssl_certificate_id)
reload
end
def unset_listener_policy(port)
set_listener_policy(port, [])
end
def ready?
# ELB requests are synchronous
true
end
def save
requires :id
requires :listeners
# with the VPC release, the ELB can have either availability zones or subnets
# if both are specified, the availability zones have preference
#requires :availability_zones
if (availability_zones || subnet_ids)
connection.create_load_balancer(availability_zones, id, listeners.map{|l| l.to_params}) if availability_zones
connection.create_load_balancer(nil, id, listeners.map{|l| l.to_params}, {:subnet_ids => subnet_ids, :security_groups => security_groups, :scheme => scheme}) if subnet_ids && !availability_zones
else
throw Fog::Errors::Error.new("No availability zones or subnet ids specified")
end
# reload instead of merge attributes b/c some attrs (like HealthCheck)
# may be set, but only the DNS name is returned in the create_load_balance
# API call
reload
end
def reload
super
@instance_health = nil
self
end
def destroy
requires :id
connection.delete_load_balancer(id)
end
end
end
end
end