aws 2.1.13 → 2.2.0

data/README.markdown

@@ -8,7 +8,7 @@ The Appoxy AWS gem is a forked version of RightScale's AWS library.
 1. It didn't work with Ruby 1.9 - this version does
 1. RightScale doesn't have the source hosted for the community
 1. We needed fixes and changes for [http://code.google.com/p/simple-record/ SimpleRecord] and didn't want to wait for RightScale to do it.
-1. We needed Elastic Load Balancing support
+1. We needed support for new AWS services.
 
 ## Discussion Group
 
@@ -28,11 +28,6 @@ Published by Appoxy LLC, under the MIT License. Special thanks to RightScale fro
 
 ## INSTALL:
 
-ONE TIME: Be sure to add the new gemcutter source:
-
-    gem install gemcutter
-    gem tumble
-
 THEN (you should have http://gemcutter.org in your sources and it MUST be above rubyforge.org):
 
     gem install aws

data/lib/aws.rb

@@ -25,3 +25,5 @@ require 'sqs/right_sqs'
 require 'sdb/right_sdb_interface'
 require 'acf/right_acf_interface'
 require 'elb/elb_interface'
+require 'rds/rds'
+

data/lib/awsbase/right_awsbase.rb

@@ -27,6 +27,7 @@ module Aws
     require 'pp'
     require 'cgi'
     require 'uri'
+    require 'xmlsimple'
 
     class AwsUtils #:nodoc:
         @@digest1 = OpenSSL::Digest::Digest.new("sha1")
@@ -269,6 +270,120 @@ module Aws
             end
         end
 
+        # FROM SDB
+        def generate_request2(aws_access_key, aws_secret_key, action, api_version, lib_params, user_params={}) #:nodoc:
+            # remove empty params from request
+            user_params.delete_if {|key, value| value.nil? }
+            #params_string  = params.to_a.collect{|key,val| key + "=#{CGI::escape(val.to_s)}" }.join("&")
+            # prepare service data
+            service = lib_params[:service]
+#      puts 'service=' + service.to_s
+            service_hash = {"Action"         => action,
+                            "AWSAccessKeyId" => aws_access_key }
+            service_hash.update("Version" => api_version) if api_version
+            service_hash.update(user_params)
+            service_params = signed_service_params(aws_secret_key, service_hash, :get, lib_params[:server], lib_params[:service])
+            #
+            # use POST method if the length of the query string is too large
+            # see http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/MakingRESTRequests.html
+            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_key, service_hash, :post, lib_params[:server], 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("#{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   => lib_params[:server],
+              :port     => lib_params[:port],
+              :protocol => lib_params[:protocol] }
+        end
+
+        def get_conn(connection_name, lib_params, logger)
+            thread = lib_params[:multi_thread] ? Thread.current : Thread.main
+            thread[connection_name] ||= Rightscale::HttpConnection.new(:exception => Aws::AwsError, :logger => logger)
+            conn = thread[connection_name]
+            return conn
+        end
+
+        def request_info2(request, parser, lib_params, connection_name, logger, bench)
+            t = get_conn(connection_name, lib_params, logger)
+            request_info_impl(t, bench, request, parser)
+        end
+
+        # This is the direction we should head instead of writing our own parsers for everything, much simpler
+        def request_info_xml_simple(connection_name, lib_params, request, logger)
+
+            @connection = get_conn(connection_name, lib_params, logger)
+            @last_request = request[:request]
+            @last_response = nil
+            response=nil
+            blockexception = nil
+
+            response = @connection.request(request)
+#            benchblock.service.add!{ response = @connection.request(request) }
+            # check response for errors...
+            @last_response = response
+            if response.is_a?(Net::HTTPSuccess)
+                @error_handler = nil
+#                benchblock.xml.add! { parser.parse(response) }
+#                return parser.result
+                return XmlSimple.xml_in(response.body, {"KeyToSymbol"=>false, 'ForceArray' => false})
+            else
+                @error_handler = AWSErrorHandler.new(self, nil, :errors_list => self.class.amazon_problems) unless @error_handler
+                check_result = @error_handler.check(request)
+                if check_result
+                    @error_handler = nil
+                    return check_result
+                end
+                request_text_data = "#{request[:server]}:#{request[:port]}#{request[:request].path}"
+                raise AwsError2.new(@last_response.code, @last_request_id, request_text_data, @last_response.body)
+            end
+
+        end
+
+        # FROM ELB
+=begin
+ def generate_request2(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
+=end
+
         # Returns +true+ if the describe_xxx responses are being cached
         def caching?
             @params.key?(:cache) ? @params[:cache] : @@caching
@@ -443,11 +558,14 @@ module Aws
         # Raw request text data to AWS
         attr_reader :request_data
 
-        def initialize(errors=nil, http_code=nil, request_id=nil, request_data=nil)
+        attr_reader :response
+
+        def initialize(errors=nil, http_code=nil, request_id=nil, request_data=nil, response=nil)
             @errors = errors
             @request_id = request_id
             @http_code = http_code
             @request_data = request_data
+            @response = response
             msg = @errors.is_a?(Array) ? @errors.map{|code, msg| "#{code}: #{msg}"}.join("; ") : @errors.to_s
             msg += "\nREQUEST(#{@request_data})" unless @request_data.nil?
             super(msg)
@@ -479,6 +597,7 @@ module Aws
                 if options[:log]
                     request = aws.last_request ? aws.last_request.path : '-none-'
                     response = aws.last_response ? "#{aws.last_response.code} -- #{aws.last_response.message} -- #{aws.last_response.body}" : '-none-'
+                    @response = response
                     aws.logger.error error_text
                     aws.logger.error "Request was:  #{request}"
                     aws.logger.error "Response was: #{response}"
@@ -496,6 +615,42 @@ module Aws
 
     end
 
+    # Simplified version
+    class AwsError2 < RuntimeError
+        # Request id (if exists)
+        attr_reader :request_id
+
+        # Response HTTP error code
+        attr_reader :http_code
+
+        # Raw request text data to AWS
+        attr_reader :request_data
+
+        attr_reader :response
+
+        attr_reader :errors
+
+        def initialize(http_code=nil, request_id=nil, request_data=nil, response=nil)
+
+            @request_id = request_id
+            @http_code = http_code
+            @request_data = request_data
+            @response = response
+#            puts '@response=' + @response.inspect
+
+            if @response
+                ref = XmlSimple.xml_in(@response, { "ForceArray"=>false })
+#                puts "refxml=" + ref.inspect
+                msg = "#{ref['Error']['Code']}: #{ref['Error']['Message']}"
+            else
+                msg = "#{@http_code}: REQUEST(#{@request_data})"
+            end
+            super(msg)
+        end
+
+
+    end
+
 
     class AWSErrorHandler
         # 0-100 (%)

data/lib/ec2/right_ec2.rb

@@ -144,7 +144,7 @@ module Aws
           # 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 = Net::HTTP::Post.new(@params[:service])
         request.body = service_params
         request['Content-Type'] = 'application/x-www-form-urlencoded'
       else

data/lib/elb/elb_interface.rb

@@ -24,7 +24,7 @@ module Aws
         end
 
         # Current API version (sometimes we have to check it outside the GEM).
-        @@api = ENV['EC2_API_VERSION'] || API_VERSION
+        @@api = ENV['ELB_API_VERSION'] || API_VERSION
 
         def self.api
             @@api
@@ -44,42 +44,14 @@ module Aws
 
 
         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] }
+            generate_request2(@aws_access_key_id, @aws_secret_access_key, action, @@api, @params, params)
         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 => Aws::AwsError, :logger => @logger)
-            request_info_impl(thread[:elb_connection], @@bench, request, parser)
+            request_info2(request, parser, @params, :elb_connection, @logger, @@bench)
         end
 
 
@@ -309,7 +281,7 @@ module Aws
 #                puts 'tagstart ' + name + ' -- ' + @xmlpath
                 if (name == 'member' &&
                         (@xmlpath == 'RegisterInstancesWithLoadBalancerResponse/RegisterInstancesWithLoadBalancerResult/Instances' ||
-                        @xmlpath == 'DeregisterInstancesFromLoadBalancerResponse/DeregisterInstancesFromLoadBalancerResult/Instances')
+                                @xmlpath == 'DeregisterInstancesFromLoadBalancerResponse/DeregisterInstancesFromLoadBalancerResult/Instances')
                 )
                     @member = { }
                 end

data/lib/rds/rds.rb

@@ -0,0 +1,127 @@
+module Aws
+
+
+    require 'xmlsimple'
+
+    # API Reference: http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/
+    class Rds < AwsBase
+        include AwsBaseInterface
+
+
+        # Amazon API version being used
+        API_VERSION = nil
+        DEFAULT_HOST = "rds.amazonaws.com"
+        DEFAULT_PATH = '/'
+        DEFAULT_PROTOCOL = 'https'
+        DEFAULT_PORT = 443
+
+        @@api = ENV['RDS_API_VERSION'] || API_VERSION
+
+        def self.api
+            @@api
+        end
+
+        @@bench = AwsBenchmarkingBlock.new
+
+        def self.bench_xml
+            @@bench.xml
+        end
+
+        def self.bench_ec2
+            @@bench.service
+        end
+
+        def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
+            uri = ENV['RDS_URL'] ? URI.parse(ENV['RDS_URL']) : nil
+            init({ :name => 'RDS',
+                   :default_host => uri ? uri.host : DEFAULT_HOST,
+                   :default_port => uri ? uri.port : DEFAULT_PORT,
+                   :default_service => uri ? uri.path : DEFAULT_PATH,
+                   :default_protocol => uri ? uri.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={})
+            generate_request2(@aws_access_key_id, @aws_secret_access_key, action, @@api, @params, params)
+        end
+
+
+        #-----------------------------------------------------------------
+        #      REQUESTS
+        #-----------------------------------------------------------------
+
+        #
+        # identifier: db instance identifier. Must be unique per account per zone.
+        # instance_class: db.m1.small | db.m1.large | db.m1.xlarge | db.m2.2xlarge | db.m2.4xlarge
+        # See this for other values: http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/
+        #
+        # options:
+        #    db_name: if you want a database created at the same time as the instance, specify :db_name option.
+        #    availability_zone: default is random zone.
+        def create_db_instance(identifier, instance_class, allocated_storage, master_username, master_password, options={})
+            params = {}
+            params['DBInstanceIdentifier'] = identifier
+            params['DBInstanceClass'] = instance_class
+            params['AllocatedStorage'] = allocated_storage
+            params['MasterUsername'] = master_username
+            params['MasterUserPassword'] = master_password
+
+            params['Engine'] = options[:engine] || "MySQL5.1"
+            params['DBName'] = options[:db_name] if options[:db_name]
+            params['AvailabilityZone'] = options[:availability_zone] if options[:availability_zone]
+            params['PreferredMaintenanceWindow'] = options[:preferred_maintenance_window] if options[:preferred_maintenance_window]
+            params['BackupRetentionPeriod'] = options[:preferred_retention_period] if options[:preferred_retention_period]
+            params['PreferredBackupWindow'] = options[:preferred_backup_window] if options[:preferred_backup_window]
+
+            @logger.info("Creating DB Instance called #{identifier}")
+
+            link = generate_request("CreateDBInstance", params)
+            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+
+        rescue Exception
+            on_exception
+        end
+
+        # options:
+        #      DBInstanceIdentifier
+        #      MaxRecords
+        #      Marker
+        def describe_db_instances(options={})
+            params = {}
+            params['DBInstanceIdentifier'] = options[:DBInstanceIdentifier] if options[:DBInstanceIdentifier]
+            params['MaxRecords'] = options[:MaxRecords] if options[:MaxRecords]
+            params['Marker'] = options[:Marker] if options[:Marker]
+
+            link = generate_request("DescribeDBInstances", params)
+            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+
+        rescue Exception
+            on_exception
+        end
+
+
+        # identifier: identifier of db instance to delete.
+        # final_snapshot_identifier: if specified, RDS will crate a final snapshot before deleting so you can restore it later.
+        def delete_db_instance(identifier, final_snapshot_identifier=nil)
+            @logger.info("Deleting DB Instance - " + identifier.to_s)
+
+            params = {}
+            params['DBInstanceIdentifier'] = identifier
+            if final_snapshot_identifier
+                params['FinalDBSnapshotIdentifier'] = final_snapshot_identifier
+            else
+                params['SkipFinalSnapshot'] = true
+            end
+
+            link = generate_request("DeleteDBInstance", params)
+            resp = request_info_xml_simple(:rds_connection, @params, link, @logger)
+
+        rescue Exception
+            on_exception
+        end
+
+    end
+
+end

data/lib/sdb/right_sdb_interface.rb

@@ -82,38 +82,7 @@ module Aws
     #-----------------------------------------------------------------
     #      Requests
     #-----------------------------------------------------------------
-    def generate_request(action, params={}) #:nodoc:
-      # remove empty params from request
-      params.delete_if {|key,value| value.nil? }
-      #params_string  = params.to_a.collect{|key,val| key + "=#{CGI::escape(val.to_s)}" }.join("&")
-      # prepare service data
-        service = @params[:service]
-#      puts 'service=' + service.to_s
-      service_hash = {"Action"         => action,
-                      "AWSAccessKeyId" => @aws_access_key_id,
-                      "Version"        => API_VERSION }
-      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
-      # see http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/MakingRESTRequests.html
-      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], 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("#{service}?#{service_params}")
-      end
-      # 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

data/test/rds/test_rds.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/aws'
+require 'rds/rds'
+require 'pp'
+require File.dirname(__FILE__) + '/../test_credentials.rb'
+
+class TestElb < Test::Unit::TestCase
+
+    # Some of RightEc2 instance methods concerning instance launching and image registration
+    # are not tested here due to their potentially risk.
+
+    def setup
+        TestCredentials.get_credentials
+
+        @rds = Aws::Rds.new(TestCredentials.aws_access_key_id,
+                            TestCredentials.aws_secret_access_key)
+
+        @identifier = 'my-db-instance'
+         @identifier2 = 'my-db-instance2'
+
+    end
+
+    def test_01_create_db_instance
+
+
+        begin
+            db_instance2 = @rds.create_db_instance('right_ec2_awesome_test_key', "db.m1.small", 5, "master", "masterpass")
+        rescue => ex
+            puts "msg=" + ex.message
+            puts "response=" + ex.response
+            assert ex.message[0,"InvalidParameterValue".size] == "InvalidParameterValue"
+        end
+
+        db_instance = @rds.create_db_instance(@identifier, "db.m1.small", 5, "master", "masterpass")
+        puts 'db_instance=' + db_instance.inspect
+
+        db_instance2 = @rds.create_db_instance(@identifier2, "db.m1.small", 5, "master", "masterpass")
+        puts 'db_instance2=' + db_instance2.inspect
+
+        sleep 10
+        
+
+    end
+
+    def test_02_describe_db_instances
+        instances_result = @rds.describe_db_instances
+        puts "instances_result=" + instances_result.inspect
+        instances = instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"]
+        puts 'instances=' + instances.inspect
+        assert instances.size == 2
+    end
+
+    def test_06_delete_db_instance
+
+        @rds.delete_db_instance(@identifier)
+        @rds.delete_db_instance(@identifier2)
+
+        sleep 2
+
+        instances_result = @rds.describe_db_instances
+        puts "instances_result=" + instances_result.inspect
+        instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"].each do |i|
+            assert i["DBInstanceStatus"] == "deleting"
+        end
+#        assert instances_result["DescribeDBInstancesResult"]["DBInstances"]["DBInstance"].size == 0
+
+    end
+
+
+end

data/test/test_credentials.rb

@@ -42,10 +42,8 @@ class TestCredentials
             Dir.chdir(File.expand_path("~/.test-configs")) do
                 credentials = YAML::load(File.open("aws.yml"))
                 @@config = credentials
-                puts 'creds=' + credentials.inspect
                 self.aws_access_key_id = credentials["amazon"]["access_key"]
                 self.aws_secret_access_key = credentials["amazon"]["secret_key"]
-                puts 'akey=' + self.aws_access_key_id
             end
         rescue Exception => e
             puts "#{e.message}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aws
 version: !ruby/object:Gem::Version 
-  version: 2.1.13
+  version: 2.2.0
 platform: ruby
 authors: 
 - Travis Reeder
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-01 00:00:00 -08:00
+date: 2010-02-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,6 +34,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: AWS Ruby Library for interfacing with Amazon Web Services.
 email: travis@appoxy.com
 executables: []
@@ -51,6 +61,7 @@ files:
 - lib/ec2/right_ec2.rb
 - lib/ec2/right_mon_interface.rb
 - lib/elb/elb_interface.rb
+- lib/rds/rds.rb
 - lib/right_aws.rb
 - lib/s3/right_s3.rb
 - lib/s3/right_s3_interface.rb
@@ -95,6 +106,7 @@ test_files:
 - test/ec2/test_right_ec2.rb
 - test/elb/test_elb.rb
 - test/http_connection.rb
+- test/rds/test_rds.rb
 - test/s3/test_helper.rb
 - test/s3/test_right_s3.rb
 - test/s3/test_right_s3_stubbed.rb