right_aws-yodal 1.10.7 → 1.10.10

data/lib/awsbase/right_awsbase.rb

@@ -23,7 +23,8 @@
 
 # Test
 module RightAws
-  require 'md5'
+#  require 'md5'
+  require 'digest/md5'
   require 'pp'
   
   class AwsUtils #:nodoc:
@@ -32,6 +33,13 @@ module RightAws
     if OpenSSL::OPENSSL_VERSION_NUMBER > 0x00908000
       @@digest256 = OpenSSL::Digest::Digest.new("sha256") rescue nil # Some installation may not support sha256
     end
+
+    def self.utc_iso8601(time)
+      if    time.is_a?(Fixnum) then time = Time::at(time)
+      elsif time.is_a?(String) then time = Time::parse(time)
+      end
+      time.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+    end
     
     def self.sign(aws_secret_access_key, auth_string)
       Base64.encode64(OpenSSL::HMAC.digest(@@digest1, aws_secret_access_key, auth_string)).strip
@@ -47,7 +55,7 @@ module RightAws
 
     # Set a timestamp and a signature version
     def self.fix_service_params(service_hash, signature)
-      service_hash["Timestamp"] ||= Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z") unless service_hash["Expires"]
+      service_hash["Timestamp"] ||= utc_iso8601(Time.now) unless service_hash["Expires"]
       service_hash["SignatureVersion"] = signature
       service_hash
     end
@@ -124,7 +132,7 @@ module RightAws
     end
 
     def self.split_items_and_params(array)
-      items  = array.to_a.flatten.compact
+      items  = Array(array).flatten.compact
       params = items.last.kind_of?(Hash) ? items.pop : {}
       [items, params]
     end
@@ -235,15 +243,13 @@ module RightAws
         @params[:service]  ||= service_info[:default_service]
         @params[:protocol] ||= service_info[:default_protocol]
       end
-#      @params[:multi_thread] ||= defined?(AWS_DAEMON)
-      @params[:connections] ||= :shared # || :dedicated
       @params[:max_connections] ||= 10
       @params[:connection_lifetime] ||= 20*60
       @params[:api_version]  ||= service_info[:default_api_version]
       @logger = @params[:logger]
       @logger = RAILS_DEFAULT_LOGGER if !@logger && defined?(RAILS_DEFAULT_LOGGER)
       @logger = Logger.new(STDOUT)   if !@logger
-      @logger.info "New #{self.class.name} using #{@params[:connections]} connections mode"
+      @logger.info "New #{self.class.name}"
       @error_handler = nil
       @cache = {}
       @signature_version = (params[:signature_version] || DEFAULT_SIGNATURE_VERSION).to_s
@@ -341,7 +347,7 @@ module RightAws
       when 'POST'
         request      = Net::HTTP::Post.new(@params[:service])
         request.body = service_params
-        request['Content-Type'] = 'application/x-www-form-urlencoded'
+        request['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
       else
         raise "Unsupported HTTP verb #{verb.inspect}!"
       end
@@ -380,6 +386,21 @@ module RightAws
       @connections_storage[server_url][:connection]
     end
 
+    def destroy_connection(aws_service, request)
+      connections = get_connections_storage aws_service
+      url         = get_server_url request
+      connections[url][:connection].finish('destroyed') if connections[url]
+      connections[url] = nil
+    end
+
+    def get_connections_storage(aws_service)
+      @connections_storage = (Thread.current[aws_service] ||= {})
+    end
+
+    def get_server_url(request)
+      "#{request[:protocol]}://#{request[:server]}:#{request[:port]}}"
+    end
+
     # All services uses this guy.
     def request_info_impl(aws_service, benchblock, request, parser, &block) #:nodoc:
       @connection    = get_connection(aws_service, request)
@@ -437,6 +458,7 @@ module RightAws
           benchblock.xml.add! { parser.parse(response) }
           return parser.result
         else
+          destroy_connection aws_service, request
           @error_handler = AWSErrorHandler.new(self, parser, :errors_list => self.class.amazon_problems) unless @error_handler
           check_result   = @error_handler.check(request)
           if check_result
@@ -498,11 +520,11 @@ module RightAws
     #     "Filter.2.Value.2"=>"bb"}
     def amazonize_list(masks, list) #:nodoc:
       groups = {}
-      list.to_a.each_with_index do |list_item, i|
-        masks.to_a.each_with_index do |mask, mask_idx|
+      Array(list).each_with_index do |list_item, i|
+        Array(masks).each_with_index do |mask, mask_idx|
           key = mask[/\?/] ? mask.dup : mask.dup + '.?'
           key.sub!('?', (i+1).to_s)
-          value = list_item.to_a[mask_idx]
+          value = Array(list_item)[mask_idx]
           if value.is_a?(Array)
             groups.merge!(amazonize_list(key, value))
           else
@@ -512,6 +534,32 @@ module RightAws
       end
       groups
     end
+
+    BLOCK_DEVICE_KEY_MAPPING = {                                                           # :nodoc:
+      :device_name               => 'DeviceName',
+      :virtual_name              => 'VirtualName',
+      :no_device                 => 'NoDevice',
+      :ebs_snapshot_id           => 'Ebs.SnapshotId',
+      :ebs_volume_size           => 'Ebs.VolumeSize',
+      :ebs_delete_on_termination => 'Ebs.DeleteOnTermination' }
+
+    def amazonize_block_device_mappings(block_device_mappings, key = 'BlockDeviceMapping') # :nodoc:
+      result = {}
+      unless block_device_mappings.blank?
+        block_device_mappings = [block_device_mappings] unless block_device_mappings.is_a?(Array)
+        block_device_mappings.each_with_index do |b, idx|
+          BLOCK_DEVICE_KEY_MAPPING.each do |local_name, remote_name|
+            value = b[local_name]
+            case local_name
+            when :no_device then value = value ? '' : nil   # allow to pass :no_device as boolean
+            end
+            result["#{key}.#{idx+1}.#{remote_name}"] = value unless value.nil?
+          end
+        end
+      end
+      result
+    end
+
   end
 
 
@@ -847,8 +895,13 @@ module RightAws
         # Parse the xml text
       case @xml_lib
       when 'libxml'  
-        xml        = XML::SaxParser.new 
-        xml.string = xml_text 
+        if XML::Parser::VERSION >= '0.9.9'
+          # avoid warning on every usage
+          xml        = XML::SaxParser.string(xml_text)
+        else
+          xml        = XML::SaxParser.new 
+          xml.string = xml_text 
+        end
         # check libxml-ruby version 
         if XML::Parser::VERSION >= '0.5.1.0'
           xml.callbacks = RightSaxParserCallback.new(self) 
@@ -929,5 +982,11 @@ module RightAws
     end
   end
 
+  class RightBoolResponseParser < RightAWSParser #:nodoc:
+    def tagend(name)
+      @result = (@text=='true') if name == 'return'
+    end
+  end
+
 end
 

data/lib/ec2/right_ec2.rb

@@ -68,7 +68,7 @@ module RightAws
     include RightAwsBaseInterface
     
     # Amazon EC2 API version being used
-    API_VERSION       = "2009-10-31"
+    API_VERSION       = "2009-11-30"
     DEFAULT_HOST      = "ec2.amazonaws.com"
     DEFAULT_PATH      = '/'
     DEFAULT_PROTOCOL  = 'https'
@@ -81,7 +81,7 @@ module RightAws
     # Amazon EC2 Instance Types : http://www.amazon.com/b?ie=UTF8&node=370375011
     # Default EC2 instance type (platform) 
     DEFAULT_INSTANCE_TYPE   =  'm1.small' 
-    INSTANCE_TYPES          = ['m1.small','c1.medium','m1.large','m1.xlarge','c1.xlarge', 'm2.2xlarge', 'm2.4xlarge']
+    INSTANCE_TYPES          = ['m1.small','c1.medium','m1.large','m1.xlarge','c1.xlarge', 'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge']
     
     @@bench = AwsBenchmarkingBlock.new
     def self.bench_xml
@@ -123,6 +123,10 @@ module RightAws
            aws_access_key_id    || ENV['AWS_ACCESS_KEY_ID'] , 
            aws_secret_access_key|| ENV['AWS_SECRET_ACCESS_KEY'],
            params)
+      # Eucalyptus supports some yummy features but Amazon does not
+      if @params[:eucalyptus]
+        @params[:port_based_group_ingress] = true unless @params.has_key?(:port_based_group_ingress)
+      end
     end
 
     def generate_request(action, params={}) #:nodoc:
@@ -135,153 +139,6 @@ module RightAws
       request_info_impl(:ec2_connection, @@bench, request, parser)
     end
 
-  #-----------------------------------------------------------------
-  #      Security groups
-  #-----------------------------------------------------------------
-
-      # Retrieve Security Group information. If +list+ is omitted the returns the whole list of groups.
-      #
-      #  ec2.describe_security_groups #=>
-      #    [{:aws_group_name  => "default-1",
-      #      :aws_owner       => "000000000888",
-      #      :aws_description => "Default allowing SSH, HTTP, and HTTPS ingress",
-      #      :aws_perms       =>
-      #        [{:owner => "000000000888", :group => "default"},
-      #         {:owner => "000000000888", :group => "default-1"},
-      #         {:to_port => "-1",  :protocol => "icmp", :from_port => "-1",  :cidr_ips => "0.0.0.0/0"},
-      #         {:to_port => "22",  :protocol => "tcp",  :from_port => "22",  :cidr_ips => "0.0.0.0/0"},
-      #         {:to_port => "80",  :protocol => "tcp",  :from_port => "80",  :cidr_ips => "0.0.0.0/0"},
-      #         {:to_port => "443", :protocol => "tcp",  :from_port => "443", :cidr_ips => "0.0.0.0/0"}]},
-      #    ..., {...}]
-      #
-    def describe_security_groups(list=[])
-      link = generate_request("DescribeSecurityGroups", amazonize_list('GroupName',list.to_a))
-      request_cache_or_info( :describe_security_groups, link,  QEc2DescribeSecurityGroupsParser, @@bench, list.blank?) do |parser|
-        result = []     
-        parser.result.each do |item|
-          perms = []
-          item.ipPermissions.each do |perm|
-            perm.groups.each do |ngroup|
-              perms << {:group => ngroup.groupName,
-                        :owner => ngroup.userId}
-            end
-            perm.ipRanges.each do |cidr_ip|
-              perms << {:from_port => perm.fromPort, 
-                        :to_port   => perm.toPort, 
-                        :protocol  => perm.ipProtocol,
-                        :cidr_ips  => cidr_ip}
-            end
-          end
-
-             # delete duplication
-          perms.each_index do |i|
-            (0...i).each do |j|
-              if perms[i] == perms[j] then perms[i] = nil; break; end
-            end
-          end
-          perms.compact!
-
-          result << {:aws_owner       => item.ownerId, 
-                     :aws_group_name  => item.groupName, 
-                     :aws_description => item.groupDescription,
-                     :aws_perms       => perms}
-        
-        end
-        result
-      end
-    rescue Exception
-      on_exception
-    end
-    
-      # Create new Security Group. Returns +true+ or an exception.
-      #
-      #  ec2.create_security_group('default-1',"Default allowing SSH, HTTP, and HTTPS ingress") #=> true
-      #
-    def create_security_group(name, description)
-      # EC2 doesn't like an empty description...
-      description = " " if description.blank?
-      link = generate_request("CreateSecurityGroup", 
-                              'GroupName'        => name.to_s,
-                              'GroupDescription' => description.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
-      # Remove Security Group. Returns +true+ or an exception.
-      #
-      #  ec2.delete_security_group('default-1') #=> true
-      #
-    def delete_security_group(name)
-      link = generate_request("DeleteSecurityGroup", 
-                              'GroupName' => name.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Authorize named ingress for security group. Allows instances that are member of someone
-      # else's security group to open connections to instances in my group.
-      #
-      #  ec2.authorize_security_group_named_ingress('my_awesome_group', '7011-0219-8268', 'their_group_name') #=> true
-      #
-    def authorize_security_group_named_ingress(name, owner, group)
-      link = generate_request("AuthorizeSecurityGroupIngress", 
-                              'GroupName'                  => name.to_s,
-                                'SourceSecurityGroupName'    => group.to_s,
-                              'SourceSecurityGroupOwnerId' => owner.to_s.gsub(/-/,''))
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Revoke named ingress for security group.
-      #
-      #  ec2.revoke_security_group_named_ingress('my_awesome_group', aws_user_id, 'another_group_name') #=> true
-      #
-    def revoke_security_group_named_ingress(name, owner, group)
-      link = generate_request("RevokeSecurityGroupIngress", 
-                              'GroupName'                  => name.to_s,
-                              'SourceSecurityGroupName'    => group.to_s,
-                              'SourceSecurityGroupOwnerId' => owner.to_s.gsub(/-/,''))
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Add permission to a security group. Returns +true+ or an exception. +protocol+ is one of :'tcp'|'udp'|'icmp'.
-      #
-      #  ec2.authorize_security_group_IP_ingress('my_awesome_group', 80, 82, 'udp', '192.168.1.0/8') #=> true
-      #  ec2.authorize_security_group_IP_ingress('my_awesome_group', -1, -1, 'icmp') #=> true
-      #
-    def authorize_security_group_IP_ingress(name, from_port, to_port, protocol='tcp', cidr_ip='0.0.0.0/0')
-      link = generate_request("AuthorizeSecurityGroupIngress", 
-                              'GroupName'  => name.to_s,
-                              'IpProtocol' => protocol.to_s,
-                              'FromPort'   => from_port.to_s,
-                              'ToPort'     => to_port.to_s,
-                              'CidrIp'     => cidr_ip.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-    
-      # Remove permission from a security group. Returns +true+ or an exception. +protocol+ is one of :'tcp'|'udp'|'icmp' ('tcp' is default). 
-      #
-      #  ec2.revoke_security_group_IP_ingress('my_awesome_group', 80, 82, 'udp', '192.168.1.0/8') #=> true
-      #
-    def revoke_security_group_IP_ingress(name, from_port, to_port, protocol='tcp', cidr_ip='0.0.0.0/0')
-      link = generate_request("RevokeSecurityGroupIngress", 
-                              'GroupName'  => name.to_s,
-                              'IpProtocol' => protocol.to_s,
-                              'FromPort'   => from_port.to_s,
-                              'ToPort'     => to_port.to_s,
-                              'CidrIp'     => cidr_ip.to_s)
-      request_info(link, RightBoolResponseParser.new(:logger => @logger))
-    rescue Exception
-      on_exception
-    end
-
   #-----------------------------------------------------------------
   #      Keys
   #-----------------------------------------------------------------
@@ -294,9 +151,10 @@ module RightAws
       #     {:aws_fingerprint=> "1e:29:30:47:58:6d:7b:8c:9f:08:11:20:3c:44:52:69:74:80:97:08", :aws_key_name=>"key-2"},
       #      ..., {...} ]
       #
-    def describe_key_pairs(list=[])
-      link = generate_request("DescribeKeyPairs", amazonize_list('KeyName',list.to_a))
-      request_cache_or_info :describe_key_pairs, link,  QEc2DescribeKeyPairParser, @@bench, list.blank?
+    def describe_key_pairs(*key_pairs)
+      key_pairs = key_pairs.flatten
+      link = generate_request("DescribeKeyPairs", amazonize_list('KeyName', key_pairs))
+      request_cache_or_info :describe_key_pairs, link,  QEc2DescribeKeyPairParser, @@bench, key_pairs.blank?
     rescue Exception
       on_exception
     end
@@ -366,10 +224,10 @@ module RightAws
     #
     #  ec2.describe_addresses('75.101.154.140') #=> [{:instance_id=>"i-d630cbbf", :public_ip=>"75.101.154.140"}]
     #
-    def describe_addresses(list=[])
-      link = generate_request("DescribeAddresses", 
-                              amazonize_list('PublicIp',list.to_a))
-      request_cache_or_info :describe_addresses, link,  QEc2DescribeAddressesParser, @@bench, list.blank?
+    def describe_addresses(*addresses)
+      addresses = addresses.flatten
+      link = generate_request("DescribeAddresses", amazonize_list('PublicIp', addresses))
+      request_cache_or_info :describe_addresses, link,  QEc2DescribeAddressesParser, @@bench, addresses.blank?
     rescue Exception
       on_exception
     end
@@ -415,10 +273,10 @@ module RightAws
     #                                                      :zone_state=>"available",
     #                                                      :zone_name=>"us-east-1c"}]
     #
-    def describe_availability_zones(list=[])
-      link = generate_request("DescribeAvailabilityZones", 
-                              amazonize_list('ZoneName',list.to_a))
-      request_cache_or_info :describe_availability_zones, link,  QEc2DescribeAvailabilityZonesParser, @@bench, list.blank?
+    def describe_availability_zones(*availability_zones)
+      availability_zones = availability_zones.flatten
+      link = generate_request("DescribeAvailabilityZones", amazonize_list('ZoneName', availability_zones))
+      request_cache_or_info :describe_availability_zones, link,  QEc2DescribeAvailabilityZonesParser, @@bench, availability_zones.blank?
     rescue Exception
       on_exception
     end
@@ -431,24 +289,14 @@ module RightAws
     #
     #  ec2.describe_regions  #=> ["eu-west-1", "us-east-1"]
     #
-    def describe_regions(list=[])
-      link = generate_request("DescribeRegions",
-                              amazonize_list('RegionName',list.to_a))
-      request_cache_or_info :describe_regions, link,  QEc2DescribeRegionsParser, @@bench, list.blank?
+    def describe_regions(*regions)
+      regions = regions.flatten
+      link = generate_request("DescribeRegions", amazonize_list('RegionName', regions))
+      request_cache_or_info :describe_regions, link,  QEc2DescribeRegionsParser, @@bench, regions.blank?
     rescue Exception
       on_exception
     end
 
-  #-----------------------------------------------------------------
-  #      PARSERS: Boolean Response Parser
-  #-----------------------------------------------------------------
-    
-    class RightBoolResponseParser < RightAWSParser #:nodoc:
-      def tagend(name)
-        @result = @text=='true' ? true : false if name == 'return'
-      end
-    end
-
   #-----------------------------------------------------------------
   #      PARSERS: Key Pair
   #-----------------------------------------------------------------
@@ -482,76 +330,6 @@ module RightAws
       end
     end
 
-  #-----------------------------------------------------------------
-  #      PARSERS: Security Groups
-  #-----------------------------------------------------------------
-
-    class QEc2UserIdGroupPairType #:nodoc:
-      attr_accessor :userId
-      attr_accessor :groupName
-    end
-
-    class QEc2IpPermissionType #:nodoc:
-      attr_accessor :ipProtocol
-      attr_accessor :fromPort
-      attr_accessor :toPort
-      attr_accessor :groups
-      attr_accessor :ipRanges
-    end
-
-    class QEc2SecurityGroupItemType #:nodoc:
-      attr_accessor :groupName
-      attr_accessor :groupDescription
-      attr_accessor :ownerId
-      attr_accessor :ipPermissions
-    end
-
-    class QEc2DescribeSecurityGroupsParser < RightAWSParser #:nodoc:
-      def tagstart(name, attributes)
-        case name
-          when 'item' 
-            if @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo'
-              @group = QEc2SecurityGroupItemType.new 
-              @group.ipPermissions = []
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions'
-              @perm = QEc2IpPermissionType.new
-              @perm.ipRanges = []
-              @perm.groups   = []
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions/item/groups'
-              @sgroup = QEc2UserIdGroupPairType.new
-            end
-        end
-      end
-      def tagend(name)
-        case name
-          when 'ownerId'          then @group.ownerId   = @text
-          when 'groupDescription' then @group.groupDescription = @text
-          when 'groupName'
-            if @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item'
-              @group.groupName  = @text 
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions/item/groups/item'
-              @sgroup.groupName = @text 
-            end
-          when 'ipProtocol'       then @perm.ipProtocol = @text
-          when 'fromPort'         then @perm.fromPort   = @text
-          when 'toPort'           then @perm.toPort     = @text
-          when 'userId'           then @sgroup.userId   = @text
-          when 'cidrIp'           then @perm.ipRanges  << @text
-          when 'item'
-            if @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions/item/groups'
-              @perm.groups << @sgroup
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo/item/ipPermissions'
-              @group.ipPermissions << @perm
-            elsif @xmlpath=='DescribeSecurityGroupsResponse/securityGroupInfo'
-              @result << @group
-            end
-        end
-      end
-      def reset
-        @result = []
-      end
-    end
-
   #-----------------------------------------------------------------
   #      PARSERS: Elastic IPs
   #-----------------------------------------------------------------