right_aws 2.0.0 → 2.1.0

data/lib/ec2/right_ec2_windows_mobility.rb

@@ -0,0 +1,84 @@
+#
+# Copyright (c) 2010 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+module RightAws
+
+  class Ec2
+
+    def describe_licenses(*license_ids)
+      link = generate_request("DescribeLicenses", amazonize_list('LicenseId', license_ids))
+      request_info(link, QEc2DescribeLicensesParser.new(:logger => @logger))
+    end
+
+    def activate_license(license_id, capacity)
+      link = generate_request("ActivateLicense", 'LicenseId' => license_id,
+                                                 'Capacity'  => capacity)
+      request_info(link, RightBoolResponseParser.new(:logger => @logger))
+    end
+
+#    def get_license_capacity(license_id)
+#      link = generate_request("GetLicenseCapacity", 'LicenseId' => license_id)
+#      request_info(link, RightBoolResponseParser.new(:logger => @logger))
+#    end
+
+    def deactivate_license(license_id, capacity)
+      link = generate_request("DeactivateLicense", 'LicenseId' => license_id,
+                                                   'Capacity'  => capacity)
+      request_info(link, RightBoolResponseParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      PARSERS: Images
+    #-----------------------------------------------------------------
+
+    class QEc2DescribeLicensesParser < RightAWSParser #:nodoc:
+      def tagstart(name, attributes)
+        case full_tag_name
+        when %r{/licenseSet/item$}  then @item          = { :capacities => [] }
+        when %r{/capacitySet/item$} then @capacity_item = {}
+        end
+      end
+      def tagend(name)
+        case name
+        when 'licenseId'        then @item[:license_id] = @text
+        when 'type'             then @item[:type]       = @text
+        when 'pool'             then @item[:pool]       = @text
+        when 'capacity'         then @capacity_item[:capacity]          = @text.to_i
+        when 'instanceCapacity' then @capacity_item[:instance_capacity] = @text.to_i
+        when 'state'            then @capacity_item[:state]             = @text
+        when 'earliestAllowedDeactivationTime' then @capacity_item[:earliest_allowed_deactivation_time] = @text
+        else
+          case full_tag_name
+          when %r{/capacitySet/item$} then @item[:capacities] << @capacity_item
+          when %r{/licenseSet/item$}  then @result            << @item
+          end
+        end
+      end
+      def reset
+        @result = []
+      end
+    end
+
+  end
+  
+end

data/lib/elb/right_elb_interface.rb

@@ -62,12 +62,14 @@ module RightAws
     include RightAwsBaseInterface
 
     # Amazon ELB API version being used
-    API_VERSION       = "2009-11-25"
+    API_VERSION       = "2010-07-01"
     DEFAULT_HOST      = "elasticloadbalancing.amazonaws.com"
     DEFAULT_PATH      = '/'
     DEFAULT_PROTOCOL  = 'https'
     DEFAULT_PORT      = 443
 
+    LISTENER_PROTOCOLS = [ 'HTTP', 'HTTPS', 'TCP', 'SSL' ]
+
     @@bench = AwsBenchmarkingBlock.new
     def self.bench_xml
       @@bench.xml
@@ -83,7 +85,6 @@ module RightAws
     # * <tt>:server</tt>: ELB service host, default: DEFAULT_HOST
     # * <tt>:port</tt>: ELB service port, default: DEFAULT_PORT
     # * <tt>:protocol</tt>: 'http' or 'https', default: DEFAULT_PROTOCOL
-    # * <tt>:multi_thread</tt>: true=HTTP connection per thread, false=per process
     # * <tt>:logger</tt>: for log messages, default: RAILS_DEFAULT_LOGGER else STDOUT
     # * <tt>:signature_version</tt>:  The signature version : '0','1' or '2'(default)
     # * <tt>:cache</tt>: true/false(default): caching works for: describe_load_balancers
@@ -166,35 +167,33 @@ module RightAws
       load_balancers = load_balancers.flatten.compact
       request_hash = amazonize_list("LoadBalancerNames.member", load_balancers)
       link = generate_request("DescribeLoadBalancers", request_hash)
-      request_cache_or_info(:describe_load_balancers, link,  DescribeLoadBalancersParser, @@bench, load_balancers.blank?)
+      request_cache_or_info(:describe_load_balancers, link,  DescribeLoadBalancersParser, @@bench, load_balancers.right_blank?)
     end
 
     # Create new load balancer.
     # Returns a new load balancer DNS name.
     #
-    #  lb = elb.create_load_balancer( 'test-kd1',
-    #                                ['us-east-1a', 'us-east-1b'],
-    #                                [ { :protocol => :http, :load_balancer_port => 80,  :instance_port => 80 },
-		#						                    	 { :protocol => :tcp,  :load_balancer_port => 443, :instance_port => 443 } ])
-    #	 puts lb #=> "test-kd1-1519253964.us-east-1.elb.amazonaws.com"
+    # Listener options: :protocol, :load_balancer_port, :instance_port and :ssl_certificate_id
+    # Protocols: :tcp, :http, :https or :ssl
+    # 
+    #  elb.create_load_balancer( 'test-kd1',
+    #                            ['us-east-1a', 'us-east-1b'],
+    #                            [ { :protocol => :http,  :load_balancer_port => 80,  :instance_port => 80 },
+		#                              { :protocol => :https, :load_balancer_port => 443, :instance_port => 443,
+    #                                :ssl_certificate_id => 'arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob' } ])
+    #                                #=> "test-kd1-1519253964.us-east-1.elb.amazonaws.com"
     #
     def create_load_balancer(load_balancer_name, availability_zones=[], listeners=[])
       request_hash = { 'LoadBalancerName' => load_balancer_name }
       # merge zones
       request_hash.merge!( amazonize_list("AvailabilityZones.member", availability_zones) )
       # merge listeners
-      if listeners.blank?
+      if listeners.right_blank?
         listeners = { :protocol           => :http,
                       :load_balancer_port => 80,
                       :instance_port      => 80 }
       end
-      listeners = [listeners] unless listeners.is_a?(Array)
-      request_hash.merge!( amazonize_list( ['Listeners.member.?.Protocol',
-                                            'Listeners.member.?.LoadBalancerPort',
-                                            'Listeners.member.?.InstancePort'],
-                                             listeners.map{|i| [ (i[:protocol] || 'HTTP').to_s.upcase,
-                                                                 (i[:load_balancer_port] || 80),
-                                                                 (i[:instance_port] || 80) ] } ) )
+      request_hash = merge_listeners_into_request_hash(request_hash, listeners)
       link = generate_request("CreateLoadBalancer", request_hash)
       request_info(link, CreateLoadBalancerParser.new(:logger => @logger))
     end
@@ -212,6 +211,37 @@ module RightAws
       request_info(link, DeleteLoadBalancerParser.new(:logger => @logger))
     end
 
+    # Creates one or more new listeners on a LoadBalancer for the specified port. If a listener with the given
+    # port does not already exist, it will be created; otherwise, the properties of the new listener must match
+    # the the properties of the existing listener.
+    #
+    # Listener options: :protocol, :load_balancer_port, :instance_port and :ssl_certificate_id
+    # Protocols: :tcp, :http, :https or :ssl
+    #
+    #  elb.create_load_balancer_listeners( 'test-kd1',
+    #                                      [ { :protocol => :http,  :load_balancer_port => 80,  :instance_port => 80 },
+		#                                        { :protocol => :https, :load_balancer_port => 443, :instance_port => 443,
+    #                                          :ssl_certificate_id => 'arn:aws:iam::123456789012:user/division_abc/subdivision_xyz/Bob' } ]) #=> true
+    #
+    def create_load_balancer_listeners(load_balancer_name, listeners)
+      request_hash = { 'LoadBalancerName' => load_balancer_name }
+      request_hash = merge_listeners_into_request_hash(request_hash, listeners)
+      link = generate_request("CreateLoadBalancerListeners", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Removes listeners from the load balancer for the specified port number.
+    #
+    #  elb.delete_load_balancer_listeners( 'kd_test', 80, 443) #=> true
+    #
+    def delete_load_balancer_listeners(load_balancer_name, *load_balancer_ports)
+      load_balancer_ports.flatten!
+      request_hash = { 'LoadBalancerName' => load_balancer_name }
+      request_hash.merge!( amazonize_list("LoadBalancerPorts.member", load_balancer_ports ) )
+      link = generate_request("DeleteLoadBalancerListeners", request_hash )
+      request_info(link, DeleteLoadBalancerParser.new(:logger => @logger))
+    end
+
     # Add one or more zones to a load balancer.
     # Returns a list of updated availability zones for the load balancer.
     #
@@ -251,7 +281,7 @@ module RightAws
     #
     def configure_health_check(load_balancer_name, health_check)
       request_hash = { 'LoadBalancerName' => load_balancer_name }
-      health_check.each{ |key, value| request_hash["HealthCheck.#{key.to_s.camelize}"] = value }
+      health_check.each{ |key, value| request_hash["HealthCheck.#{key.to_s.right_camelize}"] = value }
       link = generate_request("ConfigureHealthCheck", request_hash)
       request_info(link, HealthCheckParser.new(:logger => @logger))
     end
@@ -348,11 +378,55 @@ module RightAws
       policy_names.flatten!
       request_hash = { 'LoadBalancerName' => load_balancer_name,
                        'LoadBalancerPort' => load_balancer_port }
-      request_hash.merge!(amazonize_list('PolicyNames.member', policy_names))
+      if policy_names.right_blank?
+        request_hash['PolicyNames'] = ''
+      else
+        request_hash.merge!(amazonize_list('PolicyNames.member', policy_names))
+      end
       link = generate_request("SetLoadBalancerPoliciesOfListener", request_hash)
       request_info(link, RightHttp2xxParser.new(:logger => @logger))
     end
 
+    # Deletes a policy from the load balancer. The specified policy must not be enabled for any listeners.
+    #
+    #  elb.delete_load_balancer_policy('my-load-balancer', 'MyLoadBalancerPolicy') #=> true
+    #
+    def delete_load_balancer_policy(load_balancer_name, policy_name)
+      request_hash = { 'LoadBalancerName'        => load_balancer_name,
+                       'PolicyName'              => policy_name }
+      link = generate_request("DeleteLoadBalancerPolicy", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    def set_load_balancer_listener_ssl_certificate(load_balancer_name, load_balancer_port, ssl_sertificate_id)
+      request_hash = { 'LoadBalancerName' => load_balancer_name,
+                       'LoadBalancerPort' => load_balancer_port,
+                       'SSLCertificateId' => ssl_sertificate_id }
+      link = generate_request("SetLoadBalancerListenerSSLCertificate", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      Helpers
+    #-----------------------------------------------------------------
+
+    def merge_listeners_into_request_hash(request_hash, listeners) # :nodoc:
+      listeners = [listeners] unless listeners.is_a?(Array)
+      request_hash.merge(amazonize_list( ['Listeners.member.?.Protocol',
+                                          'Listeners.member.?.LoadBalancerPort',
+                                          'Listeners.member.?.InstancePort',
+                                          'Listeners.member.?.SSLCertificateId'],
+                                          listeners.map{ |i|
+                                            [ (i[:protocol]           || 'HTTP').to_s.upcase,
+                                               i[:load_balancer_port] || 80,
+                                               i[:instance_port]      || 80,
+                                               i[:ssl_certificate_id]]
+                                          },
+                                          :default => :skip_nils
+                                       )
+                        )
+    end
+
     #-----------------------------------------------------------------
     #      PARSERS: Load Balancers
     #-----------------------------------------------------------------
@@ -385,6 +459,7 @@ module RightAws
         when 'Protocol'           then @listener[:protocol]           = @text
         when 'LoadBalancerPort'   then @listener[:load_balancer_port] = @text
         when 'InstancePort'       then @listener[:instance_port]      = @text
+        when 'SSLCertificateId'   then @listener[:ssl_certificate_id] = @text
         end
         case full_tag_name
         when %r{AvailabilityZones/member$}    then @item[:availability_zones] << @text

data/lib/iam/right_iam_access_keys.rb

@@ -0,0 +1,71 @@
+module RightAws
+
+  class IamInterface < RightAwsBase
+
+    #-----------------------------------------------------------------
+    #      Access Keys
+    #-----------------------------------------------------------------
+
+    # Returns information about the Access Key IDs associated with the specified User.
+    #
+    # Options: :user_name, :max_items, :marker
+    #
+    #  iam.list_access_keys #=>
+    #    [{:create_date=>"2007-01-09T06:16:30Z",
+    #      :status=>"Active",
+    #      :access_key_id=>"00000000000000000000"}]
+    #
+    def list_access_keys(options={}, &block)
+      incrementally_list_iam_resources('ListAccessKeys', options, &block)
+    end
+
+    # Creates a new AWS Secret Access Key and corresponding AWS Access Key ID for the specified User.
+    #
+    # Options: :user_name
+    #
+    #  iam.create_access_key(:user_name => 'kd1') #=>
+    #    {:access_key_id=>"AK0000000000000000ZQ",
+    #     :status=>"Active",
+    #     :secret_access_key=>"QXN0000000000000000000000000000000000Ioj",
+    #     :create_date=>"2010-10-29T07:16:32.210Z",
+    #     :user_name=>"kd1"}
+    #
+    def create_access_key(options={})
+      request_hash = {}
+      request_hash['UserName'] = options[:user_name] unless options[:user_name].right_blank?
+      link = generate_request("CreateAccessKey", request_hash)
+      request_info(link, CreateAccessKeyParser.new(:logger => @logger))
+    end
+
+    # Deletes the access key associated with the specified User.
+    #
+    # Options: :user_name
+    #
+    #  iam.delete_access_key('AK00000000000000006A', :user_name => 'kd1') #=> true
+    #
+    def delete_access_key(access_key_id, options={})
+      request_hash = { 'AccessKeyId' => access_key_id }
+      request_hash['UserName'] = options[:user_name] unless options[:user_name].right_blank?
+      link = generate_request("DeleteAccessKey", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      PARSERS
+    #-----------------------------------------------------------------
+
+    class ListAccessKeysParser < BasicIamListParser #:nodoc:
+      def reset
+        @expected_tags = %w{ AccessKeyId CreateDate Status UserName }
+      end
+    end
+
+    class CreateAccessKeyParser < BasicIamParser #:nodoc:
+      def reset
+        @expected_tags = %w{ AccessKeyId CreateDate SecretAccessKey Status UserName }
+      end
+    end
+
+  end
+
+end

data/lib/iam/right_iam_groups.rb

@@ -0,0 +1,195 @@
+module RightAws
+
+  class IamInterface < RightAwsBase
+
+    #-----------------------------------------------------------------
+    #      Groups
+    #-----------------------------------------------------------------
+
+    # Lists the groups that have the specified path prefix.
+    #
+    # Options: :path_prefix, :max_items, :marker
+    #
+    #  iam.list_groups #=>
+    #    [{:group_id=>"AGP000000000000000UTY",
+    #      :arn=>"arn:aws:iam::640000000037:group/kd_test",
+    #      :path=>"/",
+    #      :group_name=>"kd_test"}]
+    #
+    def list_groups(options={}, &block)
+      incrementally_list_iam_resources('ListGroups', options, &block)
+    end
+
+    # Creates a new group.
+    #
+    #  iam.create_group('kd_group') #=>
+    #    {:group_id=>"AGP000000000000000UTY",
+    #     :arn=>"arn:aws:iam::640000000037:group/kd_test",
+    #     :path=>"/",
+    #     :group_name=>"kd_test"}
+    #
+    #  iam.create_group('kd_test_3', '/kd/') #=>
+    #    {:group_id=>"AGP000000000000000G6Q",
+    #     :arn=>"arn:aws:iam::640000000037:group/kd/kd_test_3",
+    #     :path=>"/kd/",
+    #     :group_name=>"kd_test_3"}
+    #
+    def create_group(group_name, path=nil)
+      request_hash = { 'GroupName' => group_name }
+      request_hash['Path'] = path unless path.right_blank?
+      link = generate_request("CreateGroup", request_hash)
+      request_info(link, CreateGroupParser.new(:logger => @logger))
+    end
+
+    # Updates the name and/or the path of the specified group
+    #
+    # Options: :new_group_name, :new_path
+    #
+    #  iam.update_group('kd_test', :new_group_name => 'kd_test_1', :new_path => '/kd1/') #=> true
+    #
+    def update_group(group_name, options={})
+      request_hash = { 'GroupName' => group_name}
+      request_hash['NewGroupName'] = options[:new_group_name] unless options[:new_group_name].right_blank?
+      request_hash['NewPath']      = options[:new_path]       unless options[:new_path].right_blank?
+      link = generate_request("UpdateGroup", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    # Returns a list of Users that are in the specified group.
+    #
+    # Options: :max_items, :marker
+    #
+    #  iam.get_group('kd_test') #=>
+    #    {:arn=>"arn:aws:iam::640000000037:group/kd1/kd_test_1",
+    #      :users=>
+    #        [{:arn=>"arn:aws:iam::640000000037:user/kd",
+    #          :path=>"/",
+    #          :user_name=>"kd",
+    #          :user_id=>"AID000000000000000WZ2"}],
+    #      :group_name=>"kd_test_1",
+    #      :group_id=>"AGP000000000000000UTY",
+    #      :path=>"/kd1/"}
+    #
+    def get_group(group_name, options={}, &block)
+      options[:group_name] = group_name
+      incrementally_list_iam_resources('GetGroup', options, :items => :users, :except => [:marker, :is_truncated], &block)
+    end
+
+    # Deletes the specified group. The group must not contain any Users or have any attached policies.
+    #
+    #  iam.delete_group('kd_test_3') #=> true
+    #
+    def delete_group(group_name)
+      request_hash = { 'GroupName' => group_name }
+      link = generate_request("DeleteGroup", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      Group Policies
+    #-----------------------------------------------------------------
+
+    # Lists the names of the policies associated with the specified group.
+    #
+    # Options: :max_items, :marker
+    #
+    #  iam.list_group_policies('kd_test') #=> ["kd_policy_1"]
+    #
+    def list_group_policies(group_name, options={}, &block)
+      options[:group_name] = group_name
+      incrementally_list_iam_resources('ListGroupPolicies', options, :parser => BasicIamListParser, &block)
+    end
+
+    # Adds (or updates) a policy document associated with the specified group.
+    #
+    #  iam.put_group_policy('kd_test', 'kd_policy_1', %Q({"Statement":[{"Effect":"Allow","Action":"*","Resource":"*"}]})) #=> true
+    #
+    def put_group_policy(group_name, policy_name, policy_document)
+      request_hash = { 'GroupName'      => group_name,
+                       'PolicyDocument' => policy_document,
+                       'PolicyName'     => policy_name }
+      link = generate_request_impl(:post, "PutGroupPolicy", request_hash)
+      result = request_info(link, RightHttp2xxParser.new(:logger => @logger))
+      result[:policy_document] = URI::decode(result[:policy_document])
+      result
+    end
+
+    # Retrieves the specified policy document for the specified group.
+    #
+    #  iam.get_group_policy('kd_test', 'kd_policy_1') #=>
+    #    {:policy_name=>"kd_policy_1",
+    #     :policy_document=>"{\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\"*\",\"Resource\":\"*\"}]}",
+    #     :group_name=>"kd_test"}
+    #
+    def get_group_policy(group_name, policy_name)
+      request_hash = { 'GroupName'  => group_name,
+                       'PolicyName' => policy_name }
+      link = generate_request("GetGroupPolicy", request_hash)
+      request_info(link, GetGroupPolicyParser.new(:logger => @logger))
+    end
+
+    # Deletes the specified policy that is associated with the specified group
+    #
+    #  iam.delete_group_policy('kd_test', 'kd_policy_1') #=> true
+    #
+    def delete_group_policy(group_name, policy_name)
+      request_hash = { 'GroupName'  => group_name,
+                       'PolicyName' => policy_name }
+      link = generate_request("DeleteGroupPolicy", request_hash)
+      request_info(link, RightHttp2xxParser.new(:logger => @logger))
+    end
+
+    #-----------------------------------------------------------------
+    #      PARSERS:
+    #-----------------------------------------------------------------
+
+    class ListGroupsParser < BasicIamListParser #:nodoc:
+      def reset
+        @expected_tags = %w{ Arn GroupId GroupName Path }
+      end
+    end
+
+    class CreateGroupParser < BasicIamParser #:nodoc:
+      def reset
+        @expected_tags = %w{ Arn GroupId GroupName Path }
+      end
+    end
+
+    class GetGroupParser < RightAWSParser #:nodoc:
+      def tagstart(name, attributes)
+        @item = {} if name == 'member'
+      end
+      def tagend(name)
+        case name
+        when 'Marker'      then @result[:marker]       = @text
+        when 'IsTruncated' then @result[:is_truncated] = @text == 'true'
+
+        when 'GroupName' then @result[:group_name] = @text
+        when 'GroupId'   then @result[:group_id]   = @text
+        when 'UserName'  then @item[:user_name]    = @text
+        when 'UserId'    then @item[:user_id]      = @text
+        when 'member'    then @result[:users]     << @item
+        else
+          case full_tag_name
+          when %r{/Group/Path$}  then @result[:path] = @text
+          when %r{/Group/Arn$}   then @result[:arn]  = @text
+          when %r{/member/Path$} then @item[:path]   = @text
+          when %r{/member/Arn$}  then @item[:arn]    = @text
+          end
+        end
+      end
+      def reset
+        @result = { :users => [] }
+      end
+    end
+
+    class GetGroupPolicyParser < BasicIamParser #:nodoc:
+      def reset
+        @expected_tags = %w{ GroupName PolicyDocument PolicyName }
+      end
+    end
+
+  end
+  
+end
+