Class: Aws::Elb

Inherits:
AwsBase show all
Includes:
AwsBaseInterface
Defined in:
lib/elb/elb_interface.rb

Defined Under Namespace

Classes: QElbCreateParser, QElbDeleteParser, QElbDescribeInstancesHealthParser, QElbDescribeLoadBalancersParser, QElbRegisterInstancesParser

Constant Summary collapse

API_VERSION =

Amazon ELB API version being used

"2009-05-15"
DEFAULT_HOST = 
"elasticloadbalancing.amazonaws.com"
DEFAULT_PATH = 
'/'
DEFAULT_PROTOCOL = 
'https'
DEFAULT_PORT = 
443
@@bench = 
AwsBenchmarkingBlock.new
@@api =

Current API version (sometimes we have to check it outside the GEM).

ENV['EC2_API_VERSION'] || API_VERSION

Constants included from AwsBaseInterface

AwsBaseInterface::DEFAULT_SIGNATURE_VERSION

Constants inherited from AwsBase

AwsBase::AMAZON_PROBLEMS

Instance Attribute Summary

Attributes included from AwsBaseInterface

#aws_access_key_id, #cache, #connection, #last_errors, #last_request, #last_request_id, #last_response, #logger, #params, #signature_version

Class Method Summary collapse

Instance Method Summary collapse

Methods included from AwsBaseInterface

#cache_hits?, caching, caching=, #caching?, #hash_params, #init, #multi_thread, #on_exception, #request_cache_or_info, #request_info_impl, #signed_service_params, #update_cache

Methods inherited from AwsBase

amazon_problems, amazon_problems=

Constructor Details

#initialize(aws_access_key_id = nil, aws_secret_access_key = nil, params = {}) ⇒ Elb

Returns a new instance of Elb.



34
35
36
37
38
39
40
41
42
43
 
# File 'lib/elb/elb_interface.rb', line 34

def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
    init({ :name => 'ELB',
           :default_host => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).host : DEFAULT_HOST,
           :default_port => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).port : DEFAULT_PORT,
           :default_service => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).path : DEFAULT_PATH,
           :default_protocol => ENV['ELB_URL'] ? URI.parse(ENV['ELB_URL']).scheme : DEFAULT_PROTOCOL },
         aws_access_key_id || ENV['AWS_ACCESS_KEY_ID'],
         aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
         params)
end

Class Method Details

.api ⇒ Object 



29
30
31
 
# File 'lib/elb/elb_interface.rb', line 29

def self.api
    @@api
end

.bench_ec2 ⇒ Object 



22
23
24
 
# File 'lib/elb/elb_interface.rb', line 22

def self.bench_ec2
    @@bench.service
end

.bench_xml ⇒ Object 



18
19
20
 
# File 'lib/elb/elb_interface.rb', line 18

def self.bench_xml
    @@bench.xml
end

Instance Method Details

#create_load_balancer(name, availability_zones, listeners) ⇒ Object

name: name of load balancer availability_zones: array of zones listeners: array of hashes containing :load_balancer_port, :instance_port, :protocol

eg: {:load_balancer_port=>80, :instance_port=>8080, :protocol=>"HTTP"}



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/elb/elb_interface.rb', line 95

def create_load_balancer(name, availability_zones, listeners)
    params = hash_params('AvailabilityZones.member', availability_zones)
    i = 1
    listeners.each do |l|
        params["Listeners.member.#{i}.Protocol"] = "#{l[:protocol]}"
        params["Listeners.member.#{i}.LoadBalancerPort"] = "#{l[:load_balancer_port]}"
        params["Listeners.member.#{i}.InstancePort"] = "#{l[:instance_port]}"
        i += 1
    end
    params['LoadBalancerName'] = name

    @logger.info("Creating LoadBalancer called #{params['LoadBalancerName']}")

    link = generate_request("CreateLoadBalancer", params)
    resp = request_info(link, QElbCreateParser.new(:logger => @logger))

rescue Exception
    on_exception
end

#delete_load_balancer(name) ⇒ Object 



195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/elb/elb_interface.rb', line 195

def delete_load_balancer(name)
    @logger.info("Deleting Load Balancer - " + name.to_s)

    params = {}
    params['LoadBalancerName'] = name

    link = generate_request("DeleteLoadBalancer", params)

    resp = request_info(link, QElbDeleteParser.new(:logger => @logger))

rescue Exception
    on_exception
end

#deregister_instances_from_load_balancer(name, instance_ids) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/elb/elb_interface.rb', line 137

def deregister_instances_from_load_balancer(name, instance_ids)
    params = {}
    params['LoadBalancerName'] = name

    i = 1
    instance_ids.each do |l|
        params["Instances.member.#{i}.InstanceId"] = "#{l}"
        i += 1
    end

    @logger.info("Deregistering Instances #{instance_ids.join(',')} from Load Balancer '#{name}'")

    link = generate_request("DeregisterInstancesFromLoadBalancer", params) # Same response as register I believe
    resp = request_info(link, QElbRegisterInstancesParser.new(:logger => @logger))

rescue Exception
    on_exception
end

#describe_instance_health(name, instance_ids) ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/elb/elb_interface.rb', line 172

def describe_instance_health(name, instance_ids)
    instance_ids = [instance_ids] if instance_ids.is_a?(String)
#            @logger.info("Describing Instance Health")
    params = {}
    params['LoadBalancerName'] = name

    i = 1
    instance_ids.each do |l|
        params["Instances.member.#{i}.InstanceId"] = "#{l}"
        i += 1
    end

    @logger.info("Describing Instances Health #{instance_ids.join(',')} with Load Balancer '#{name}'")

    link = generate_request("DescribeInstanceHealth", params)
    resp = request_info(link, QElbDescribeInstancesHealthParser.new(:logger => @logger))


rescue Exception
    on_exception
end

#describe_load_balancers(lparams = {}) ⇒ Object 



157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/elb/elb_interface.rb', line 157

def describe_load_balancers(lparams={})
    @logger.info("Describing Load Balancers")

    params = {}
    params.update( hash_params('LoadBalancerNames.member', lparams[:names]) ) if lparams[:names]

    link = generate_request("DescribeLoadBalancers", params)

    resp = request_info(link, QElbDescribeLoadBalancersParser.new(:logger => @logger))

rescue Exception
    on_exception
end

#generate_request(action, params = {}) ⇒ Object 



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
 
# File 'lib/elb/elb_interface.rb', line 46

def generate_request(action, params={})
    service_hash = {"Action" => action,
                    "AWSAccessKeyId" => @aws_access_key_id,
                    "Version" => @@api }
    service_hash.update(params)
    service_params = signed_service_params(@aws_secret_access_key, service_hash, :get, @params[:server], @params[:service])

    # use POST method if the length of the query string is too large
    if service_params.size > 2000
        if signature_version == '2'
            # resign the request because HTTP verb is included into signature
            service_params = signed_service_params(@aws_secret_access_key, service_hash, :post, @params[:server], @params[:service])
        end
        request = Net::HTTP::Post.new(service)
        request.body = service_params
        request['Content-Type'] = 'application/x-www-form-urlencoded'
    else
        request = Net::HTTP::Get.new("#{@params[:service]}?#{service_params}")
    end

    #puts "\n\n --------------- QUERY REQUEST TO AWS -------------- \n\n"
    #puts "#{@params[:service]}?#{service_params}\n\n"

    # prepare output hash
    { :request => request,
      :server => @params[:server],
      :port => @params[:port],
      :protocol => @params[:protocol] }
end

#register_instances_with_load_balancer(name, instance_ids) ⇒ Object

name: name of load balancer instance_ids: array of instance_id’s to add to load balancer



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/elb/elb_interface.rb', line 118

def register_instances_with_load_balancer(name, instance_ids)
    params = {}
    params['LoadBalancerName'] = name

    i = 1
    instance_ids.each do |l|
        params["Instances.member.#{i}.InstanceId"] = "#{l}"
        i += 1
    end

    @logger.info("Registering Instances #{instance_ids.join(',')} with Load Balancer '#{name}'")

    link = generate_request("RegisterInstancesWithLoadBalancer", params)
    resp = request_info(link, QElbRegisterInstancesParser.new(:logger => @logger))

rescue Exception
    on_exception
end

#request_info(request, parser) ⇒ Object

Sends request to Amazon and parses the response Raises AwsError if any banana happened



79
80
81
82
83
 
# File 'lib/elb/elb_interface.rb', line 79

def request_info(request, parser)
    thread = @params[:multi_thread] ? Thread.current : Thread.main
    thread[:elb_connection] ||= Rightscale::HttpConnection.new(:exception => Aws::AwsError, :logger => @logger)
    request_info_impl(thread[:elb_connection], @@bench, request, parser)
end