aws 1.11.9 → 1.11.36

data/lib/ec2/right_ec2.rb

@@ -71,8 +71,8 @@ module RightAws
     API_VERSION       = "2008-12-01"
     DEFAULT_HOST      = "ec2.amazonaws.com"
     DEFAULT_PATH      = '/'
-    DEFAULT_PROTOCOL  = 'https'
-    DEFAULT_PORT      = 443
+    DEFAULT_PROTOCOL  = 'http'
+    DEFAULT_PORT      = 80
     
     # Default addressing type (public=NAT, direct=no-NAT) used when launching instances.
     DEFAULT_ADDRESSING_TYPE =  'public'

data/lib/ec2/right_mon_interface.rb

@@ -0,0 +1,224 @@
+module RightAws
+
+    class Mon < RightAws::RightAwsBase
+        include RightAws::RightAwsBaseInterface
+
+
+        #Amazon EC2 API version being used
+        API_VERSION = "2009-05-15"
+        DEFAULT_HOST = "monitoring.amazonaws.com"
+        DEFAULT_PATH = '/'
+        DEFAULT_PROTOCOL = 'https'
+        DEFAULT_PORT = 443
+
+        # Available measures for EC2 instances:
+        # NetworkIn NetworkOut DiskReadOps DiskWriteOps DiskReadBytes DiskWriteBytes CPUUtilization
+        measures=%w(NetworkIn NetworkOut DiskReadOps DiskWriteOps DiskReadBytes DiskWriteBytes CPUUtilization)
+
+        @@bench = RightAws::AwsBenchmarkingBlock.new
+
+        def self.bench_xml
+            @@bench.xml
+        end
+
+        def self.bench_ec2
+            @@bench.service
+        end
+
+        # Current API version (sometimes we have to check it outside the GEM).
+        @@api = ENV['EC2_API_VERSION'] || API_VERSION
+
+        def self.api
+            @@api
+        end
+
+
+        def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+            init({ :name => 'MON',
+                   :default_host => ENV['MON_URL'] ? URI.parse(ENV['MON_URL']).host : DEFAULT_HOST,
+                   :default_port => ENV['MON_URL'] ? URI.parse(ENV['MON_URL']).port : DEFAULT_PORT,
+                   :default_service => ENV['MON_URL'] ? URI.parse(ENV['MON_URL']).path : DEFAULT_PATH,
+                   :default_protocol => ENV['MON_URL'] ? URI.parse(ENV['MON_URL']).scheme : DEFAULT_PROTOCOL },
+                 aws_access_key_id || ENV['AWS_ACCESS_KEY_ID'],
+                 aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
+                 params)
+        end
+
+
+        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
+
+
+        # Sends request to Amazon and parses the response
+        # Raises AwsError if any banana happened
+        def request_info(request, parser)
+            thread = @params[:multi_thread] ? Thread.current : Thread.main
+            thread[:elb_connection] ||= Rightscale::HttpConnection.new(:exception => RightAws::AwsError, :logger => @logger)
+            request_info_impl(thread[:elb_connection], @@bench, request, parser)
+        end
+
+        #-----------------------------------------------------------------
+        #      REQUESTS
+        #-----------------------------------------------------------------
+
+        def list_metrics
+
+            params = { }
+
+            @logger.info("list Metrics ")
+
+            link = generate_request("ListMetrics", params)
+            resp = request_info(link, QMonListMetrics.new(:logger => @logger))
+
+        rescue Exception
+            on_exception
+        end
+
+
+        # measureName:  CPUUtilization (Units: Percent), NetworkIn (Units: Bytes), NetworkOut (Units: Bytes), DiskWriteOps (Units: Count)
+        #               DiskReadBytes (Units: Bytes), DiskReadOps (Units: Count), DiskWriteBytes (Units: Bytes)
+        # stats: 	array containing one or more of Minimum, Maximum, Sum, Average, Samples
+        # startTime :   Timestamp to start
+        # endtime:      Timestamp to end
+        # unit: 	Either Seconds, Percent, Bytes, Bits, Count, Bytes, Bits/Second, Count/Second, and None
+        # period: 	Integer 60 or multiple of 60
+        # dimension:    Hash containing keys ImageId, AutoScalingGroupName, InstanceId, InstanceType
+        # customUnit:   nil. not supported currently.
+        # namespace:    AWS/EC2
+
+        def get_metric_statistics ( measure_name, stats, start_time, end_time, unit, period=60, dimensions=nil,  custom_unit=nil, namespace="AWS/EC2" )
+
+            params = {}
+            params['MeasureName'] = measure_name
+            i=1
+            stats.each do |s|
+                params['Statistics.member.'+i.to_s] = s
+                i = i+1
+            end
+            params['Period'] = period
+            if (dimensions != nil)
+                i = 1
+                dimensions.each do |k, v|
+                    params['Dimensions.member.'+i.to_s+".Name."+i.to_s] = k
+                    params['Dimensions.member.'+i.to_s+".Value."+i.to_s] = v
+                    i = i+1
+                end
+            end
+            params['StartTime'] = start_time
+            params['EndTime'] = end_time
+            params['Unit'] = unit
+            #params['CustomUnit'] = customUnit always nil
+            params['Namespace'] = namespace
+
+            @logger.info("get Metric Statistics ")
+
+            link = generate_request("GetMetricStatistics", params)
+            resp = request_info(link, QMonGetMetricStatistics.new(:logger => @logger))
+
+        rescue Exception
+            on_exception
+        end
+
+
+        #-----------------------------------------------------------------
+        #      PARSERS: Instances
+        #-----------------------------------------------------------------
+
+
+        class QMonGetMetricStatistics < RightAws::RightAWSParser
+
+            def reset
+                @result = []
+            end
+
+            def tagstart(name, attributes)
+                @metric = {} if name == 'member'
+            end
+
+            def tagend(name)
+                case name
+                    when 'Timestamp' then
+                        @metric[:timestamp] = @text
+                    when 'Samples' then
+                        @metric[:samples] = @text
+                    when 'Unit' then
+                        @metric[:unit] = @text
+                    when 'Average' then
+                        @metric[:average] = @text
+                    when 'Minimum' then
+                        @metric[:minimum] = @text
+                    when 'Maximum' then
+                        @metric[:maximum] = @text
+                    when 'Sum' then
+                        @metric[:sum] = @text
+                    when 'Value' then
+                        @metric[:value] = @text
+                    when 'member' then
+                        @result << @metric
+                end
+            end
+        end
+
+        class QMonListMetrics < RightAws::RightAWSParser
+
+            def reset
+                @result = []
+                @namespace = ""
+                @measure_name = ""
+            end
+
+            def tagstart(name, attributes)
+                @metric = {} if name == 'member'
+            end
+
+            def tagend(name)
+                case name
+                    when 'MeasureName' then
+                        @measure_name = @text
+                    when 'Namespace' then
+                        @namespace = @text
+                    when 'Name' then
+                        @metric[:name] = @text
+                    when 'Value' then
+                        @metric[:value] = @text
+                    when 'member' then
+                        @metric[:namespace] = @namespace
+                        @metric[:measure_name] = @measure_name
+                        @result << @metric
+                end
+            end
+        end
+
+
+    end
+
+
+end
+

data/lib/elb/right_elb_interface.rb

@@ -0,0 +1,189 @@
+module RightAws
+
+
+
+    class Elb < RightAwsBase
+        include RightAwsBaseInterface
+
+
+        #Amazon EC2 API version being used
+        API_VERSION       = "2008-12-01"
+        DEFAULT_HOST      = "elasticloadbalancing.amazonaws.com"
+        DEFAULT_PATH      = '/'
+        DEFAULT_PROTOCOL  = 'http'
+        DEFAULT_PORT      = 80
+
+
+        @@bench = AwsBenchmarkingBlock.new
+        def self.bench_xml
+            @@bench.xml
+        end
+        def self.bench_ec2
+            @@bench.service
+        end
+
+        # Current API version (sometimes we have to check it outside the GEM).
+        @@api = ENV['EC2_API_VERSION'] || API_VERSION
+        def self.api
+            @@api
+        end
+
+
+        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
+
+
+        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
+
+
+        # Sends request to Amazon and parses the response
+        # Raises AwsError if any banana happened
+        def request_info(request, parser)
+            thread = @params[:multi_thread] ? Thread.current : Thread.main
+            thread[:elb_connection] ||= Rightscale::HttpConnection.new(:exception => RightAws::AwsError, :logger => @logger)
+            request_info_impl(thread[:elb_connection], @@bench, request, parser)
+        end
+
+
+        #-----------------------------------------------------------------
+        #      REQUESTS
+        #-----------------------------------------------------------------
+
+
+        def register_instance_with_elb(instance_id, lparams={})
+            params = {}
+
+            params['LoadBalancerName']                  = lparams[:load_balancer_name]
+            params['Instances.member.1.InstanceId']     = instance_id
+
+            @logger.info("Registering Instance #{instance_id} with Load Balancer '#{params['LoadBalancerName']}'")
+
+            link = generate_request("RegisterInstancesWithLoadBalancer", params)
+            resp = request_info(link, QElbRegisterInstanceParser.new(:logger => @logger))
+
+        rescue Exception
+            on_exception
+        end
+
+
+
+
+
+
+        def describe_load_balancers
+            @logger.info("Describing Load Balancers")
+
+            params = {}
+
+            link = generate_request("DescribeLoadBalancers", params)
+
+            resp = request_info(link, QElbDescribeLoadBalancersParser.new(:logger => @logger))
+
+        rescue Exception
+            on_exception
+        end
+
+
+
+
+        #-----------------------------------------------------------------
+        #      PARSERS: Instances
+        #-----------------------------------------------------------------
+
+        class QElbDescribeLoadBalancersParser < RightAWSParser
+
+            def reset
+                @result = []
+            end
+
+
+            def tagend(name)
+                #case name
+                #    when 'LoadBalancerName' then
+                #        @result[:load_balancer_name]        = @text
+                #    when 'AvailabilityZones' then
+                #        @result[:availability_zones]        = @text
+                #    when 'CreatedTime' then
+                #        @result[:created_time] =            Time.parse(@text)
+                #    when 'DNSName' then
+                #        @result[:dns_name]                  = @text
+                #    when 'Instances' then
+                #        @result[:instances]                 = @text
+                #    when 'HealthCheck' then
+                #        @result[:health_check]              = @text
+                #    when 'Listeners' then
+                #        @result[:listeners]                  = @text
+                #end
+            end
+        end
+
+        class QElbRegisterInstanceParser < RightAWSParser
+
+            def reset
+                @result = []
+            end
+
+
+            def tagend(name)
+                #case name
+                #    when 'LoadBalancerName' then
+                #        @result[:load_balancer_name]        = @text
+                #    when 'AvailabilityZones' then
+                #        @result[:availability_zones]        = @text
+                #    when 'CreatedTime' then
+                #        @result[:created_time] =            Time.parse(@text)
+                #    when 'DNSName' then
+                #        @result[:dns_name]                  = @text
+                #    when 'Instances' then
+                #        @result[:instances]                 = @text
+                #    when 'HealthCheck' then
+                #        @result[:health_check]              = @text
+                #    when 'Listeners' then
+                #        @result[:listeners]                  = @text
+                #end
+            end
+        end
+
+
+
+
+    end
+
+
+end

data/lib/right_aws.rb

@@ -43,17 +43,16 @@ require 's3/right_s3_interface'
 require 's3/right_s3'
 require 'sqs/right_sqs_interface'
 require 'sqs/right_sqs'
-require 'sqs/right_sqs_gen2_interface'
-require 'sqs/right_sqs_gen2'
 require 'sdb/right_sdb_interface'
 require 'acf/right_acf_interface'
+require 'elb/right_elb_interface'
 
 
 module RightAws #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 11
-    TINY  = 9
+    TINY  = 30
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/s3/right_s3.rb

@@ -464,8 +464,8 @@ module RightAws
         # Retrieve object data and attributes from Amazon. 
         # Returns a +String+. 
         #
-      def get(headers={})
-        response = @bucket.s3.interface.get(@bucket.name, @name, headers)
+      def get(headers={}, &block)
+        response = @bucket.s3.interface.get(@bucket.name, @name, headers, &block)
         @data    = response[:object]
         @headers, @meta_headers = self.class.split_meta(response[:headers])
         refresh(false)