kunley-amazon-ec2 0.3.4 → 0.3.8

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 0.3.8 2009-04-16
+ * Applied patch, fixing an issue with EU Signature version 2 creation (delano).
+
+=== 0.3.7 2009-03-09
+ * Applied patch, with updated tests to fix issue with base64 encoded user data (rsanheim).
+
+=== 0.3.6 2009-03-02
+ * You can now specify any arbitrary SSL tcp port to connect to (kerryb)
+ * Added rake target to quickly install the gem without docs
+
+=== 0.3.5 2009-02-26
+ * Honor the EC2_URL env var if provided in the main lib
+ * Some minor modifications to the exceptions raised when unknown
+
 === 0.3.4 2009-01-31
  * Added support in the helper binaries for EC2_URL server url for Euro servers
  * AWS Signature v2 support

data/Rakefile

@@ -16,6 +16,11 @@ task :install => [:package] do
   sh %{sudo gem install pkg/#{GEM}-#{VER}}
 end
 
+desc "Package and then install the gem locally omitting documentation"
+task :install_nodoc => [:package] do
+  sh %{sudo gem install --no-ri --no-rdoc pkg/#{GEM}-#{VER}}
+end
+
 Rake::TestTask.new do |t|
   t.libs << "test"
   t.test_files = FileList['test/test*.rb']
@@ -28,3 +33,5 @@ Rake::RDocTask.new do |rd|
   rd.rdoc_dir = 'doc'
   rd.options = spec.rdoc_options
 end
+
+task :default => :test

data/bin/ec2-gem-example.rb

@@ -30,7 +30,16 @@ if ACCESS_KEY_ID.nil? || ACCESS_KEY_ID.empty?
   exit
 end
 
-ec2 = EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY )
+# us-east-1.ec2.amazonaws.com == ec2.amazonaws.com
+# eu-west-1.ec2.amazonaws.com for the european region
+# test different servers by running something like:
+# export EC2_URL='https://ec2.amazonaws.com';./bin/ec2-gem-example.rb
+if ENV['EC2_URL']
+  ec2 = EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY, :server => URI.parse(ENV['EC2_URL']).host )
+else
+  # default server is US ec2.amazonaws.com
+  ec2 = EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY )
+end
 
 puts "----- ec2.methods.sort -----"
 p ec2.methods.sort

data/bin/setup.rb

@@ -20,7 +20,6 @@ if ENV['AMAZON_ACCESS_KEY_ID'] && ENV['AMAZON_SECRET_ACCESS_KEY']
   @ec2 = EC2::Base.new(opts)
 end
 
-puts "Current Options:"
-pp opts
+puts "EC2 Server: #{opts[:server]}"
 
 include EC2

data/lib/EC2.rb

@@ -19,7 +19,19 @@ Dir[File.join(File.dirname(__FILE__), 'EC2/**/*.rb')].sort.each { |lib| require
 module EC2
 
   # Which host FQDN will we connect to for all API calls to AWS?
-  DEFAULT_HOST = 'ec2.amazonaws.com'
+  # If EC2_URL is defined in the users ENV we can use that. It is
+  # expected that this var is set with something like:
+  #   export EC2_URL='https://ec2.amazonaws.com'
+  #
+  if ENV['EC2_URL']
+    EC2_URL = ENV['EC2_URL']
+    VALID_HOSTS = ['https://ec2.amazonaws.com', 'https://us-east-1.ec2.amazonaws.com', 'https://eu-west-1.ec2.amazonaws.com']
+    raise ArgumentError, "Invalid EC2_URL environment variable : #{EC2_URL}" unless VALID_HOSTS.include?(EC2_URL)
+    DEFAULT_HOST = URI.parse(EC2_URL).host
+  else
+    # default US host
+    DEFAULT_HOST = 'ec2.amazonaws.com'
+  end
 
   # This is the version of the API as defined by Amazon Web Services
   API_VERSION = '2008-12-01'
@@ -32,7 +44,7 @@ module EC2
     # Sort, and encode parameters into a canonical string.
     sorted_params = params.sort {|x,y| x[0] <=> y[0]}
     encoded_params = sorted_params.collect do |p|
-      encoded = (CGI::escape(p[0].to_s) + 
+      encoded = (CGI::escape(p[0].to_s) +
                  "=" + CGI::escape(p[1].to_s))
       # Ensure spaces are encoded as '%20', not '+'
       encoded.gsub('+', '%20')
@@ -40,10 +52,10 @@ module EC2
     sigquery = encoded_params.join("&")
 
     # Generate the request description string
-    req_desc = 
-      method + "\n" + 
-      host + "\n" + 
-      base + "\n" + 
+    req_desc =
+      method + "\n" +
+      host + "\n" +
+      base + "\n" +
       sigquery
 
   end
@@ -106,14 +118,14 @@ module EC2
       raise ArgumentError, "No :use_ssl value provided" if options[:use_ssl].nil?
       raise ArgumentError, "Invalid :use_ssl value provided, only 'true' or 'false' allowed" unless options[:use_ssl] == true || options[:use_ssl] == false
       raise ArgumentError, "No :server provided" if options[:server].nil? || options[:server].empty?
-
-
-      # based on the :use_ssl boolean, determine which port we should connect to
-      case @use_ssl
-      when true
+      
+      if options[:port]
+        # user-specified port
+        @port = options[:port]
+      elsif @use_ssl
         # https
         @port = 443
-      when false
+      else
         # http
         @port = 80
       end
@@ -170,7 +182,7 @@ module EC2
                           "Version" => API_VERSION,
                           "Timestamp"=>Time.now.getutc.iso8601} )
 
-          sig = get_aws_auth_param(params, @secret_access_key)
+          sig = get_aws_auth_param(params, @secret_access_key, @server)
 
           query = params.sort.collect do |param|
             CGI::escape(param[0]) + "=" + CGI::escape(param[1])
@@ -193,8 +205,8 @@ module EC2
       end
 
       # Set the Authorization header using AWS signed header authentication
-      def get_aws_auth_param(params, secret_access_key)
-        canonical_string =  EC2.canonical_string(params)
+      def get_aws_auth_param(params, secret_access_key, server)
+        canonical_string =  EC2.canonical_string(params, server)
         encoded_canonical = EC2.encode(secret_access_key, canonical_string)
       end
 
@@ -248,7 +260,7 @@ module EC2
         if EC2.const_defined?(error_code)
           raise EC2.const_get(error_code), error_message
         else
-          raise Error, "This is an undefined error code which needs to be added to exceptions.rb : error_code => #{error_code} : error_message => #{error_message}"
+          raise EC2::Error, error_message
         end
 
       end

data/lib/EC2/exceptions.rb

@@ -32,6 +32,14 @@ module EC2
   class AuthFailure < Error #:nodoc:
   end
 
+  # Invalid AWS Account
+  class InvalidClientTokenId < Error #:nodoc:
+  end
+
+  # Invalid Parameters for Value
+  class InvalidParameterValue < Error #:nodoc:
+  end
+
   # Specified AMI has an unparsable manifest.
   class InvalidManifest < Error #:nodoc:
   end
@@ -133,4 +141,7 @@ module EC2
   class Unavailable < Error #:nodoc:
   end
 
+  class SignatureDoesNotMatch < Error #:nodoc:
+  end
+
 end

data/lib/EC2/instances.rb

@@ -90,18 +90,7 @@ module EC2
       raise ArgumentError, ":instance_type must be 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', or 'c1.xlarge'" unless options[:instance_type] == "m1.small" || options[:instance_type] == "m1.large" || options[:instance_type] == "m1.xlarge" || options[:instance_type] == "c1.medium" || options[:instance_type] == "c1.xlarge"
       raise ArgumentError, ":base64_encoded must be 'true' or 'false'" unless options[:base64_encoded] == true || options[:base64_encoded] == false
 
-      # If :user_data is passed in then URL escape and Base64 encode it
-      # as needed.  Need for URL Escape + Base64 encoding is determined
-      # by :base64_encoded param.
-      if options[:user_data]
-        if options[:base64_encoded]
-          user_data = options[:user_data]
-        else
-          user_data = Base64.encode64(options[:user_data]).gsub(/\n/,"").strip()
-        end
-      else
-        user_data = nil
-      end
+      user_data = extract_user_data(options)
 
       params = {
         "ImageId"  => options[:image_id],
@@ -119,6 +108,20 @@ module EC2
       return response_generator(:action => "RunInstances", :params => params)
 
     end
+    
+    # If :user_data is passed in then URL escape and Base64 encode it
+    # as needed.  Need for URL Escape + Base64 encoding is determined
+    # by :base64_encoded param.
+    def extract_user_data(options)
+      return unless options[:user_data]
+      if options[:user_data]
+        if options[:base64_encoded]
+          Base64.encode64(options[:user_data]).gsub(/\n/,"").strip()
+        else
+          options[:user_data]
+        end
+      end
+    end
 
 
     #Amazon Developer Guide Docs:

data/test/test_EC2.rb

@@ -17,31 +17,47 @@ context "The EC2 method " do
 
   specify "EC2::Base attribute readers should be available" do
     @ec2 = EC2::Base.new( :access_key_id => "not a key",
-                                       :secret_access_key => "not a secret",
-                                       :use_ssl => true,
-                                       :server => "foo.example.com" )
+                          :secret_access_key => "not a secret",
+                          :use_ssl => true,
+                          :server => "foo.example.com" )
 
     @ec2.use_ssl.should.equal true
     @ec2.port.should.equal 443
     @ec2.server.should.equal "foo.example.com"
   end
 
-
   specify "EC2::Base should work with insecure connections as well" do
     @ec2 = EC2::Base.new( :access_key_id => "not a key",
-                                       :secret_access_key => "not a secret",
-                                       :use_ssl => false,
-                                       :server => "foo.example.com" )
+                          :secret_access_key => "not a secret",
+                          :use_ssl => false,
+                          :server => "foo.example.com" )
 
     @ec2.use_ssl.should.equal false
     @ec2.port.should.equal 80
     @ec2.server.should.equal "foo.example.com"
   end
 
+  specify "EC2::Base should allow specification of port" do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key",
+                          :secret_access_key => "not a secret",
+                          :use_ssl => true,
+                          :server => "foo.example.com",
+                          :port => 8443 )
+
+    @ec2.use_ssl.should.equal true
+    @ec2.port.should.equal 8443
+    @ec2.server.should.equal "foo.example.com"
+  end
 
   specify "EC2.canonical_string(path) should conform to Amazon's requirements " do
     path = {"name1" => "value1", "name2" => "value2", "name3" => "value3"}
-    EC2.canonical_string(path).should.equal "POST\nec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    if ENV['EC2_URL'].nil? || ENV['EC2_URL'] == 'https://ec2.amazonaws.com'
+      EC2.canonical_string(path).should.equal "POST\nec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    elsif ENV['EC2_URL'] == 'https://us-east-1.ec2.amazonaws.com'
+      EC2.canonical_string(path).should.equal "POST\nus-east-1.ec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    elsif ENV['EC2_URL'] == 'https://eu-west-1.ec2.amazonaws.com'
+      EC2.canonical_string(path).should.equal "POST\neu-west-1.ec2.amazonaws.com\n/\nname1=value1&name2=value2&name3=value3"
+    end
   end
 
   specify "EC2.encode should return the expected string" do

data/test/test_EC2_instances.rb

@@ -221,28 +221,40 @@ context "EC2 instances " do
 
 
   specify "should be able specify an availability_zone" do
-    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "Placement.AvailabilityZone" => "zone123", "UserData" => "foo", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "Placement.AvailabilityZone" => "zone123", "UserData" => "Zm9v", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
       returns stub(:body => @run_instances_response_body, :is_a? => true)
     @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :availability_zone => "zone123", :group_id => [], :user_data => "foo", :base64_encoded => true ).should.be.an.instance_of Hash
   end
 
   specify "should be able to call run_instances with :user_data and :base64_encoded => true (default is false)" do
-    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "UserData" => "foo", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "UserData" => "Zm9v", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
       returns stub(:body => @run_instances_response_body, :is_a? => true)
     @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :group_id => [], :user_data => "foo", :base64_encoded => true ).should.be.an.instance_of Hash
   end
 
   specify "should be able specify an kernel_id" do
-    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "Placement.AvailabilityZone" => "zone123", "UserData" => "foo", "AddressingType" => 'public', 'InstanceType' => 'm1.small', 'KernelId' => 'kernfoo').
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "Placement.AvailabilityZone" => "zone123", "UserData" => "Zm9v", "AddressingType" => 'public', 'InstanceType' => 'm1.small', 'KernelId' => 'kernfoo').
       returns stub(:body => @run_instances_response_body, :is_a? => true)
     @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :availability_zone => "zone123", :group_id => [], :user_data => "foo", :base64_encoded => true, :kernel_id => 'kernfoo' ).should.be.an.instance_of Hash
   end
 
   specify "should be able to call run_instances with :user_data and :base64_encoded => false" do
-    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "UserData" => "Zm9v", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
+    @ec2.stubs(:make_request).with('RunInstances', "ImageId" => "ami-60a54009", "MinCount" => '1', "MaxCount" => '1', "UserData" => "foo", "AddressingType" => 'public', 'InstanceType' => 'm1.small').
       returns stub(:body => @run_instances_response_body, :is_a? => true)
     @ec2.run_instances( :image_id => "ami-60a54009", :min_count => 1, :max_count => 1, :group_id => [], :user_data => "foo", :base64_encoded => false ).should.be.an.instance_of Hash
   end
+  
+  specify "should get no user data for when options has no user_data key" do
+    @ec2.extract_user_data({}).should == nil
+  end
+  
+  specify "should get plain string user data when options has user_data and no base64 key" do
+    @ec2.extract_user_data({:user_data => "foo\nbar"}).should == "foo\nbar"
+  end
+  
+  specify "should strip new lines and base64 encode when options has both user_data and base64" do
+    @ec2.extract_user_data({:user_data => "binary\ndata\nhere\n", :base64_encoded => true}).should == "YmluYXJ5CmRhdGEKaGVyZQo="
+  end
 
 
   specify "should be able to be described and return the correct Ruby response class" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kunley-amazon-ec2
 version: !ruby/object:Gem::Version 
-  version: 0.3.4
+  version: 0.3.8
 platform: ruby
 authors: 
 - Glenn Rempe
@@ -9,11 +9,12 @@ autorequire: EC2
 bindir: bin
 cert_chain: []
 
-date: 2009-01-11 00:00:00 -08:00
+date: 2009-04-08 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: xml-simple
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -22,7 +23,7 @@ dependencies:
         version: 1.0.11
     version: 
 description: An interface library that allows Ruby applications to easily connect to the HTTP 'Query API' for the Amazon Web Services Elastic Compute Cloud (EC2) and manipulate cloud servers.
-email: glenn.rempe@gmail.com
+email: glenn@rempe.us
 executables: 
 - ec2-gem-example.rb
 - ec2sh