amazon-ec2 0.1.0 → 0.2.0

data/lib/EC2/security_groups.rb

@@ -1,139 +1,231 @@
-# Amazon Web Services EC2 Query API Ruby Library
-# This library has been packaged as a Ruby Gem 
-# by Glenn Rempe ( grempe @nospam@ rubyforge.org ).
-# 
-# Source code and gem hosted on RubyForge
-# under the Ruby License as of 12/14/2006:
-# http://amazon-ec2.rubyforge.org
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
 
 module EC2
   
-  class AWSAuthConnection
+  class Base
     
-    # The CreateSecurityGroup operation creates a new security group.
-    #
-    # Every instance is launched in a security group. If none is specified 
-    # as part of the launch request then instances are launched in the 
-    # default security group. Instances within the same security group 
-    # have unrestricted network access to one another. Instances will reject 
-    # network access attempts from other instances in a different security 
-    # group. As the owner of instances you may grant or revoke specific 
-    # permissions using the AuthorizeSecurityGroupIngress and 
-    # RevokeSecurityGroupIngress operations.
-    def create_security_group(groupName, groupDescription)
+    
+    #Amazon Developer Guide Docs:
+    #
+    # The CreateSecurityGroup operation creates a new security group. Every instance is launched 
+    # in a security group. If none is specified as part of the launch request then instances 
+    # are launched in the default security group. Instances within the same security group have 
+    # unrestricted network access to one another. Instances will reject network access attempts from other 
+    # instances in a different security group. As the owner of instances you may grant or revoke specific 
+    # permissions using the AuthorizeSecurityGroupIngress and RevokeSecurityGroupIngress operations.
+    #
+    #Required Arguments:
+    #
+    # :group_name => String (default : "")
+    # :group_description => String (default : "")
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def create_security_group( options = {} )
+      
+      options = {:group_name => "",
+                 :group_description => ""
+                 }.merge(options)
+      
+      raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+      raise ArgumentError, "No :group_description provided" if options[:group_description].nil? || options[:group_description].empty?
+      
       params = {
-        "GroupName" => groupName,
-        "GroupDescription" => groupDescription
+        "GroupName" => options[:group_name],
+        "GroupDescription" => options[:group_description]
       }
-      CreateSecurityGroupResponse.new(make_request("CreateSecurityGroup", params))
-    end
-    
-    # Maintain backward compatibility.  Changed method name from create_securitygroup
-    # to more consistent name.
-    alias create_securitygroup create_security_group
-    
-    # The DescribeSecurityGroups operation returns information about security 
-    # groups owned by the user making the request.
-    # 
-    # An optional list of security group names may be provided to request 
-    # information for those security groups only. If no security group 
-    # names are provided, information of all security groups will be returned. 
-    # If a group is specified that does not exist a fault is returned.
-    def describe_security_groups(groupNames=[])
-      params = pathlist("GroupName", groupNames)
-      DescribeSecurityGroupsResponse.new(make_request("DescribeSecurityGroups", params))
+      
+      return response_generator(:action => "CreateSecurityGroup", :params => params)
+      
     end
     
-    # Maintain backward compatibility.  Changed method name from describe_securitygroups
-    # to more consistent name.
-    alias describe_securitygroups describe_security_groups
     
-    # The DeleteSecurityGroup operation deletes a security group.
-    # 
-    # If an attempt is made to delete a security group and any 
-    # instances exist that are members of that group a fault is 
-    # returned.
-    def delete_security_group(groupName)
-      params = { "GroupName" => groupName }
-      DeleteSecurityGroupResponse.new(make_request("DeleteSecurityGroup", params))
+    #Amazon Developer Guide Docs:
+    #
+    # The DescribeSecurityGroups operation returns information about security groups owned by the 
+    # user making the request. 
+    #
+    # An optional list of security group names may be provided to request information for those security 
+    # groups only. If no security group names are provided, information of all security groups will be 
+    # returned. If a group is specified that does not exist a fault is returned.
+    #
+    #Required Arguments:
+    #
+    # none
+    #
+    #Optional Arguments:
+    #
+    # :group_name => Array (default : [])
+    #
+    def describe_security_groups( options = {} )
+      
+      options = { :group_name => [] }.merge(options)
+      
+      params = pathlist("GroupName", options[:group_name] )
+      
+      return response_generator(:action => "DescribeSecurityGroups", :params => params)
+      
     end
     
-    # Maintain backward compatibility.  Changed method name from delete_securitygroup
-    # to more consistent name.
-    alias delete_securitygroup delete_security_group
     
-    # The AuthorizeSecurityGroupIngress operation adds permissions to a security 
-    # group.
-    #
-    # Permissions are specified in terms of the IP protocol (TCP, UDP or ICMP), 
-    # the source of the request (by IP range or an Amazon EC2 user-group pair), 
-    # source and destination port ranges (for TCP and UDP), and ICMP codes and 
-    # types (for ICMP). When authorizing ICMP, -1 may be used as a wildcard in 
-    # the type and code fields.
-    #
-    # Permission changes are propagated to instances within the security group 
-    # being modified as quickly as possible. However, a small delay is likely, 
-    # depending on the number of instances that are members of the indicated group.
-    #
-    # When authorizing a user/group pair permission, GroupName, 
-    # SourceSecurityGroupName and SourceSecurityGroupOwnerId must be specified. 
-    # When authorizing a CIDR IP permission, GroupName, IpProtocol, FromPort, 
-    # ToPort and CidrIp must be specified. Mixing these two types of parameters 
-    # is not allowed.
-    def authorize_security_group_ingress(*args)
-      params = auth_revoke_impl(*args)
-      AuthorizeSecurityGroupIngressResponse.new(make_request("AuthorizeSecurityGroupIngress", params))
+    #Amazon Developer Guide Docs:
+    #
+    # The DeleteSecurityGroup operation deletes a security group. 
+    #
+    # If an attempt is made to delete a security group and any instances exist that are members of that group a 
+    # fault is returned.
+    #
+    #Required Arguments:
+    #
+    # :group_name => String (default : "")
+    #
+    #Optional Arguments:
+    #
+    # none
+    #
+    def delete_security_group( options = {} )
+      
+      options = { :group_name => "" }.merge(options)
+      
+      raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+      
+      params = { "GroupName" => options[:group_name] }
+      
+      return response_generator(:action => "DeleteSecurityGroup", :params => params)
+      
     end
     
-    # Maintain backward compatibility.  Changed method name from authorize
-    # to more consistent name.
-    alias authorize authorize_security_group_ingress
     
-    # The RevokeSecurityGroupIngress operation revokes existing permissions 
-    # that were previously granted to a security group. The permissions to 
-    # revoke must be specified using the same values originally used to grant 
-    # the permission.
-    #
-    # Permissions are specified in terms of the IP protocol (TCP, UDP or ICMP), 
-    # the source of the request (by IP range or an Amazon EC2 user-group pair), 
-    # source and destination port ranges (for TCP and UDP), and ICMP codes and 
-    # types (for ICMP). When authorizing ICMP, -1 may be used as a wildcard 
-    # in the type and code fields.
-    #
-    # Permission changes are propagated to instances within the security group 
-    # being modified as quickly as possible. However, a small delay is likely, 
-    # depending on the number of instances that are members of the indicated group.
-    #
-    # When revoking a user/group pair permission, GroupName, SourceSecurityGroupName 
-    # and SourceSecurityGroupOwnerId must be specified. When authorizing a CIDR IP 
-    # permission, GroupName, IpProtocol, FromPort, ToPort and CidrIp must be 
-    # specified. Mixing these two types of parameters is not allowed.
-    def revoke_security_group_ingress(*args)
-      params = auth_revoke_impl(*args)
-      RevokeSecurityGroupIngressResponse.new(make_request("RevokeSecurityGroupIngress", params))
+    #Amazon Developer Guide Docs:
+    #
+    # The AuthorizeSecurityGroupIngress operation adds permissions to a security group. 
+    # 
+    # Permissions are specified in terms of the IP protocol (TCP, UDP or ICMP), the source of the request (by 
+    # IP range or an Amazon EC2 user-group pair), source and destination port ranges (for TCP and UDP), 
+    # and ICMP codes and types (for ICMP). When authorizing ICMP, -1 may be used as a wildcard in the 
+    # type and code fields.
+    # 
+    # Permission changes are propagated to instances within the security group being modified as quickly as 
+    # possible. However, a small delay is likely, depending on the number of instances that are members of
+    # the indicated group.
+    # 
+    # When authorizing a user/group pair permission, GroupName, SourceSecurityGroupName and 
+    # SourceSecurityGroupOwnerId must be specified. When authorizing a CIDR IP permission, 
+    # GroupName, IpProtocol, FromPort, ToPort and CidrIp must be specified. Mixing these two types 
+    # of parameters is not allowed.
+    #
+    #Required Arguments:
+    #
+    # :group_name => String (default : "")
+    #
+    #Optional Arguments:
+    #
+    # :ip_protocol => String (default : nil) : Required when authorizing CIDR IP permission
+    # :from_port => Integer (default : nil) : Required when authorizing CIDR IP permission
+    # :to_port => Integer (default : nil) : Required when authorizing CIDR IP permission
+    # :cidr_ip => String (default : nil): Required when authorizing CIDR IP permission
+    # :source_security_group_name => String (default : nil) : Required when authorizing user group pair permissions
+    # :source_security_group_owner_id => String (default : nil) : Required when authorizing user group pair permissions
+    #
+    def authorize_security_group_ingress( options = {} )
+      
+      # defaults
+      options = { :group_name => nil,
+                  :ip_protocol => nil,
+                  :from_port => nil, 
+                  :to_port => nil, 
+                  :cidr_ip => nil, 
+                  :source_security_group_name => nil,
+                  :source_security_group_owner_id => nil }.merge(options)
+      
+      # lets not validate the rest of the possible permutations of required params and instead let
+      # EC2 sort it out on the server side.  We'll only require :group_name as that is always needed.
+      raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+      
+      params = { "GroupName" => options[:group_name],
+                 "IpProtocol" => options[:ip_protocol],
+                 "FromPort" => options[:from_port].to_s,
+                 "ToPort" => options[:to_port].to_s, 
+                 "CidrIp" => options[:cidr_ip], 
+                 "SourceSecurityGroupName" => options[:source_security_group_name],
+                 "SourceSecurityGroupOwnerId" => options[:source_security_group_owner_id]
+                 }
+      
+      return response_generator(:action => "AuthorizeSecurityGroupIngress", :params => params)
+      
     end
     
-    # Maintain backward compatibility.  Changed method name from revoke
-    # to more consistent name.
-    alias revoke revoke_security_group_ingress
     
-    private
+    #Amazon Developer Guide Docs:
+    #
+    # The RevokeSecurityGroupIngress operation revokes existing permissions that were previously 
+    # granted to a security group. The permissions to revoke must be specified using the same values 
+    # originally used to grant the permission.
+    #
+    # Permissions are specified in terms of the IP protocol (TCP, UDP or ICMP), the source of the request (by 
+    # IP range or an Amazon EC2 user-group pair), source and destination port ranges (for TCP and UDP), 
+    # and ICMP codes and types (for ICMP). When authorizing ICMP, -1 may be used as a wildcard in the 
+    # type and code fields.
+    #
+    # Permission changes are propagated to instances within the security group being modified as quickly as 
+    # possible. However, a small delay is likely, depending on the number of instances that are members of 
+    # the indicated group.
+    #
+    # When revoking a user/group pair permission, GroupName, SourceSecurityGroupName and 
+    # SourceSecurityGroupOwnerId must be specified. When authorizing a CIDR IP permission, 
+    # GroupName, IpProtocol, FromPort, ToPort and CidrIp must be specified. Mixing these two types 
+    # of parameters is not allowed.
+    #
+    #Required Arguments:
+    #
+    # :group_name => String (default : "")
+    #
+    #Optional Arguments:
+    #
+    # :ip_protocol => String (default : nil) : Required when revoking CIDR IP permission
+    # :from_port => Integer (default : nil) : Required when revoking CIDR IP permission
+    # :to_port => Integer (default : nil) : Required when revoking CIDR IP permission
+    # :cidr_ip => String (default : nil): Required when revoking CIDR IP permission
+    # :source_security_group_name => String (default : nil) : Required when revoking user group pair permissions
+    # :source_security_group_owner_id => String (default : nil) : Required when revoking user group pair permissions
+    #
+    def revoke_security_group_ingress( options = {} )
     
-      def auth_revoke_impl(groupName, kwargs={})
-        in_params = { :ipProtocol=>nil, :fromPort=>nil, :toPort=>nil, :cidrIp=>nil, :sourceSecurityGroupName=>nil,
-          :sourceSecurityGroupOwnerId=>nil}
-        in_params.merge! kwargs
-        
-        { "GroupName" => in_params[:groupName] ,
-          "IpProtocol" => in_params[:ipProtocol],
-          "FromPort" => in_params[:fromPort].to_s,
-          "ToPort" => in_params[:toPort].to_s, 
-          "CidrIp" => in_params[:cidrIp], 
-          "SourceSecurityGroupName" => in_params[:sourceSecurityGroupName],
-          "SourceSecurityGroupOwnerId" => in_params[:sourceSecurityGroupOwnerId],
-        }.reject { |key, value| value.nil? or value.empty?}
-        
-      end
+      # defaults
+      options = { :group_name => nil,
+                  :ip_protocol => nil,
+                  :from_port => nil, 
+                  :to_port => nil, 
+                  :cidr_ip => nil, 
+                  :source_security_group_name => nil,
+                  :source_security_group_owner_id => nil }.merge(options)
+      
+      # lets not validate the rest of the possible permutations of required params and instead let
+      # EC2 sort it out on the server side.  We'll only require :group_name as that is always needed.
+      raise ArgumentError, "No :group_name provided" if options[:group_name].nil? || options[:group_name].empty?
+      
+      params = { "GroupName" => options[:group_name],
+                 "IpProtocol" => options[:ip_protocol],
+                 "FromPort" => options[:from_port].to_s,
+                 "ToPort" => options[:to_port].to_s, 
+                 "CidrIp" => options[:cidr_ip], 
+                 "SourceSecurityGroupName" => options[:source_security_group_name],
+                 "SourceSecurityGroupOwnerId" => options[:source_security_group_owner_id]
+                 }
+      
+      return response_generator(:action => "RevokeSecurityGroupIngress", :params => params)
+      
+    end
     
   end
   

data/lib/EC2/version.rb

@@ -1,9 +1,18 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
 module EC2 #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
-
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/test_EC2.rb

@@ -1,21 +1,52 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
 require File.dirname(__FILE__) + '/test_helper.rb'
 
-class TestEC2 < Test::Unit::TestCase
+context "The EC2 method " do
   
-  def setup
-    @conn = EC2::AWSAuthConnection.new('not a key', 'not a secret')
+  setup do
   end
   
-  def test_reboot_instances
-    body = <<-RESPONSE
-    <RebootInstancesResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-03/">
-        <return>true</return>
-    </RebootInstancesResponse>
-    RESPONSE
+  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" )
+    
+    @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" )
     
-    @conn.expects(:make_request).with('RebootInstances', {"InstanceId.1"=>"i-2ea64347", "InstanceId.2"=>"i-21a64348"}).
-          returns stub(:body => body, :is_a? => true)
-    assert_equal true, @conn.reboot_instances('i-2ea64347', 'i-21a64348').parse
+    @ec2.use_ssl.should.equal false
+    @ec2.port.should.equal 80
+    @ec2.server.should.equal "foo.example.com"
+  end
+  
+  
+  specify "EC2.canonical_string(path) should data that is stripped of ?,&,= " do
+    path = "?name1=value1&name2=value2&name3=value3"
+    EC2.canonical_string(path).should.equal "name1value1name2value2name3value3"
+  end
+  
+  specify "EC2.encode should return the expected string" do
+    EC2.encode("secretaccesskey", "foobar123", urlencode=true).should.equal "e3jeuDc3DIX2mW8cVqWiByj4j5g%3D"
+    EC2.encode("secretaccesskey", "foobar123", urlencode=false).should.equal "e3jeuDc3DIX2mW8cVqWiByj4j5g="
   end
   
-end
+end

data/test/test_EC2_console.rb

@@ -0,0 +1,54 @@
+#--
+# Amazon Web Services EC2 Query API Ruby library
+#
+# Ruby Gem Name::  amazon-ec2
+# Author::    Glenn Rempe  (mailto:glenn@elasticworkbench.com)
+# Copyright:: Copyright (c) 2007 Glenn Rempe
+# License::   Distributes under the same terms as Ruby
+# Home::      http://amazon-ec2.rubyforge.org
+#++
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "The EC2 console " do
+  
+  setup do
+    @ec2 = EC2::Base.new( :access_key_id => "not a key", :secret_access_key => "not a secret" )
+    
+    @get_console_output_response_body = <<-RESPONSE
+    <GetConsoleOutputResponse xmlns="http://ec2.amazonaws.com/doc/2007-01-19">
+      <instanceId>i-28a64341</instanceId>
+      <timestamp>2007-01-03 15:00:00</timestamp>
+      <output>
+        YyB2ZXJzaW9uIDQuMC4xIDIwMDUwNzI3IChSZWQgSGF0IDQuMC4xLTUpKSAjMSBTTVAgVGh1IE9j 
+        dCAyNiAwODo0MToyNiBTQVNUIDIwMDYKQklPUy1wcm92aWRlZCBwaHlzaWNhbCBSQU0gbWFwOgpY 
+        ZW46IDAwMDAwMDAwMDAwMDAwMDAgLSAwMDAwMDAwMDZhNDAwMDAwICh1c2FibGUpCjk4ME1CIEhJ 
+        R0hNRU0gYXZhaWxhYmxlLgo3MjdNQiBMT1dNRU0gYXZhaWxhYmxlLgpOWCAoRXhlY3V0ZSBEaXNh 
+        YmxlKSBwcm90ZWN0aW9uOiBhY3RpdmUKSVJRIGxvY2t1cCBkZXRlY3Rpb24gZGlzYWJsZWQKQnVp 
+        bHQgMSB6b25lbGlzdHMKS2VybmVsIGNvbW1hbmQgbGluZTogcm9vdD0vZGV2L3NkYTEgcm8gNApF 
+        bmFibGluZyBmYXN0IEZQVSBzYXZlIGFuZCByZXN0b3JlLi4uIGRvbmUuCg==
+        </output>
+    </GetConsoleOutputResponse>
+    RESPONSE
+    
+  end
+  
+  
+  specify "should return info written to a specific instances console" do
+    @ec2.stubs(:make_request).with('GetConsoleOutput', {"InstanceId"=>"i-2ea64347"}).
+       returns stub(:body => @get_console_output_response_body, :is_a? => true)
+    @ec2.get_console_output( :instance_id => "i-2ea64347" ).should.be.an.instance_of EC2::Response
+    response = @ec2.get_console_output( :instance_id => "i-2ea64347" )
+    response.instanceId.should.equal "i-28a64341"
+    response.timestamp.should.equal "2007-01-03 15:00:00"
+  end
+  
+  
+  specify "method get_console_output should raise an exception when called without nil/empty string arguments" do
+    lambda { @ec2.get_console_output() }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.get_console_output(:instance_id => nil) }.should.raise(EC2::ArgumentError)
+    lambda { @ec2.get_console_output(:instance_id => "") }.should.raise(EC2::ArgumentError)
+  end
+  
+  
+end