fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/aws/requests/elb/describe_load_balancer_attributes.rb

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/describe_load_balancer_attributes'
+
+        # Describe the load balancer attributes
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DescribeLoadBalancerAttributes.html
+        # ==== Parameters
+        # * lb_name<~String> - The mnemonic name associated with the LoadBalancer. 
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancerAttributesResult'<~Hash>:
+        #       * 'LoadBalancerAttributes'<~Hash>
+        #         * 'CrossZoneLoadBalancing'<~Hash>
+        #           * 'Enabled'<~Boolean> - whether crosszone load balancing is enabled
+        def describe_load_balancer_attributes(lb_name)
+          request({
+            'Action'  => 'DescribeLoadBalancerAttributes',
+            'LoadBalancerName' => lb_name,
+            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancerAttributes.new
+          })
+        end
+
+      end
+
+      class Mock
+        def describe_load_balancer_attributes(lb_name = nil, names = [])
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+          attributes = load_balancer['LoadBalancerAttributes']
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancerAttributesResult' => {
+              'LoadBalancerAttributes' => attributes
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/modify_load_balancer_attributes.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/empty'
+
+
+        # Sets attributes of the load balancer
+        #
+        # Currently the only attribute that can be set is whether CrossZoneLoadBalancing
+        # is enabled
+        #
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_ModifyLoadBalancerAttributes.html
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * options<~Hash>
+        #   * 'CrossZoneLoadBalancing'<~Hash>:
+        #     * 'Enabled'<~Boolean> whether to enable cross zone load balancing
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def modify_load_balancer_attributes(lb_name, options)
+          attributes = Fog::AWS.serialize_keys 'LoadBalancerAttributes', options
+          request(attributes.merge(
+            'Action'           => 'ModifyLoadBalancerAttributes',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::Empty.new
+          ))
+        end
+
+      end
+
+      class Mock
+        def modify_load_balancer_attributes(lb_name, attributes)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          if attributes['CrossZoneLoadBalancing']
+            load_balancer['LoadBalancerAttributes'].merge! attributes
+          end
+          
+          response = Excon::Response.new
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata" => {
+              "RequestId" => Fog::AWS::Mock.request_id
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/create_access_key.rb

@@ -36,23 +36,30 @@ module Fog
         def create_access_key(options)
           #FIXME: Not 100% correct as AWS will use the signing credentials when there is no 'UserName' in the options hash
           #       Also doesn't raise an error when there are too many keys
-          user_name = options['UserName']
-          if data[:users].has_key? user_name
-            key = { 'SecretAccessKey' => Fog::Mock.random_base64(40),
-                    'Status' => 'Active',
-                    'AccessKeyId' => Fog::AWS::Mock.key_id(20),
-                    'UserName' => user_name
-                  }
-
-            data[:users][user_name][:access_keys] << key
-
-            Excon::Response.new.tap do |response|
-              response.status = 200
-              response.body = { 'AccessKey' => key,
-                                'RequestId' => Fog::AWS::Mock.request_id } 
+          if user = options['UserName']
+            if data[:users].has_key? user
+              access_keys_data = data[:users][user][:access_keys]
+            else
+              raise Fog::AWS::IAM::NotFound.new('The user with name #{user_name} cannot be found.')
             end
           else
-            raise Fog::AWS::IAM::NotFound.new('The user with name booboboboob cannot be found.')
+            access_keys_data = data[:access_keys]
+          end
+
+          key = { 'SecretAccessKey' => Fog::Mock.random_base64(40),
+                  'Status' => 'Active',
+                  'AccessKeyId' => Fog::AWS::Mock.key_id(20),
+                }
+          if user
+            key["UserName"] = user
+          end
+
+          access_keys_data << key
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = { 'AccessKey' => key,
+                              'RequestId' => Fog::AWS::Mock.request_id }
           end
         end
       end

data/lib/fog/aws/requests/iam/get_group_policy.rb

@@ -6,7 +6,7 @@ module Fog
         require 'fog/aws/parsers/iam/get_group_policy'
 
         # Get Group Policy
-        # 
+        #
         # ==== Parameters
         # * 'PolicyName'<~String>: Name of the policy to get
         # * 'GroupName'<~String>: Name of the Group who the policy is associated with.
@@ -31,6 +31,23 @@ module Fog
         end
 
       end
+      class Mock
+        def get_group_policy(policy_name, group_name)
+          raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.") unless self.data[:groups].key?(group_name)
+          raise Fog::AWS::IAM::NotFound.new("The policy with name #{policy_name} cannot be found.") unless self.data[:groups][group_name][:policies].key?(policy_name)
+          Excon::Response.new.tap do |response|
+            response.body = { 'Policy' =>  {
+                                'PolicyName' => policy_name,
+                                'GroupName' => group_name,
+                                'PolicyDocument' => data[:groups][group_name][:policies][policy_name]
+                              },
+                              'IsTruncated' => false,
+                              'RequestId'   => Fog::AWS::Mock.request_id
+                            }
+            response.status = 200
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/get_user_policy.rb

@@ -6,7 +6,7 @@ module Fog
         require 'fog/aws/parsers/iam/get_user_policy'
 
         # Get User Policy
-        # 
+        #
         # ==== Parameters
         # * 'PolicyName'<~String>: Name of the policy to get
         # * 'UserName'<~String>: Name of the User who the policy is associated with.
@@ -33,16 +33,16 @@ module Fog
       end
       class Mock
         def get_user_policy(policy_name, user_name)
-          raise Fog::AWS::IAM::NotFound.new("The user with name #{user} cannot be found.") unless self.data[:users].key?(user_name)
+          raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.") unless self.data[:users].key?(user_name)
           raise Fog::AWS::IAM::NotFound.new("The policy with name #{policy_name} cannot be found.") unless self.data[:users][user_name][:policies].key?(policy_name)
           Excon::Response.new.tap do |response|
-            response.body = { 'Policy' =>  { 
+            response.body = { 'Policy' =>  {
                                 'PolicyName' => policy_name,
                                 'UserName' => user_name,
                                 'PolicyDocument' => data[:users][user_name][:policies][policy_name]
                               },
                               'IsTruncated' => false,
-                              'RequestId'   => Fog::AWS::Mock.request_id 
+                              'RequestId'   => Fog::AWS::Mock.request_id
                             }
             response.status = 200
           end

data/lib/fog/aws/requests/iam/list_access_keys.rb

@@ -40,19 +40,23 @@ module Fog
 
         def list_access_keys(options = {})
           #FIXME: Doesn't do anything with options, aside from UserName
-          user = options['UserName']
-
-          if data[:users].has_key? user
-            Excon::Response.new.tap do |response|
-              response.body = { 'AccessKeys' => data[:users][user][:access_keys].map do |akey|
-                                                  {'Status' => akey['Status'], 'AccessKeyId' => akey['AccessKeyId']}
-                                                end,
-                                 'IsTruncated' => false,
-                                 'RequestId' => Fog::AWS::Mock.request_id }
-              response.status = 200
+          if user = options['UserName']
+            if data[:users].has_key? user
+              access_keys_data = data[:users][user][:access_keys]
+            else
+              raise Fog::AWS::IAM::NotFound.new("The user with name #{user} cannot be found.")
             end
           else
-            raise Fog::AWS::IAM::NotFound.new("The user with name #{user} cannot be found.")
+            access_keys_data = data[:access_keys]
+          end
+
+          Excon::Response.new.tap do |response|
+            response.body = { 'AccessKeys' => access_keys_data.map do |akey|
+                                                {'Status' => akey['Status'], 'AccessKeyId' => akey['AccessKeyId']}
+                                              end,
+                               'IsTruncated' => false,
+                               'RequestId' => Fog::AWS::Mock.request_id }
+            response.status = 200
           end
         end
       end

data/lib/fog/aws/requests/iam/put_group_policy.rb

@@ -6,7 +6,7 @@ module Fog
         require 'fog/aws/parsers/iam/basic'
 
         # Add or update a policy for a group
-        # 
+        #
         # ==== Parameters
         # * group_name<~String>: name of the group
         # * policy_name<~String>: name of policy document
@@ -31,6 +31,22 @@ module Fog
         end
 
       end
+      class Mock
+        #FIXME: You can't actually use the credentials for anything elsewhere in Fog
+        #FIXME: Doesn't do any validation on the policy
+        def put_group_policy(group_name, policy_name, policy_document)
+          if data[:groups].has_key? group_name
+            data[:groups][group_name][:policies][policy_name] = policy_document
+
+            Excon::Response.new.tap do |response|
+              response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          end
+        end
+      end
     end
   end
 end

data/lib/fog/aws/requests/iam/put_user_policy.rb

@@ -6,7 +6,7 @@ module Fog
         require 'fog/aws/parsers/iam/basic'
 
         # Add or update a policy for a user
-        # 
+        #
         # ==== Parameters
         # * user_name<~String>: name of the user
         # * policy_name<~String>: name of policy document

data/lib/fog/aws/requests/iam/update_access_key.rb

@@ -31,6 +31,28 @@ module Fog
         end
 
       end
+
+      class Mock
+        def update_access_key(access_key_id, status, options = {})
+          if user = options['UserName']
+            if data[:users].has_key? user
+              access_keys_data = data[:users][user][:access_keys]
+            else
+              raise Fog::AWS::IAM::NotFound.new('The user with name #{user_name} cannot be found.')
+            end
+          else
+            access_keys_data = data[:access_keys]
+          end
+          key = access_keys_data.detect{|k| k["AccessKeyId"] == access_key_id}
+          key["Status"] = status
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = { 'AccessKey' => key,
+                              'RequestId' => Fog::AWS::Mock.request_id }
+          end
+        end
+      end
+
     end
   end
 end

data/lib/fog/aws/requests/storage/delete_bucket_tagging.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+
+        # Delete tagging for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete tagging from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketDELETEtagging.html
+
+        def delete_bucket_tagging(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :bucket_name => bucket_name,
+            :method   => 'DELETE',
+            :query    => {'tagging' => nil}
+          })
+        end
+
+      end
+
+      class Mock # :nodoc:all
+
+        def delete_bucket_tagging(bucket_name)
+          response = Excon::Response.new
+          if self.data[:buckets][bucket_name]
+            self.data[:bucket_tagging].delete(bucket_name)
+            response.status = 204
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          end
+
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/storage/get_bucket_tagging.rb

@@ -0,0 +1,53 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/storage/get_bucket_tagging'
+
+        # Get tags for an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to get tags for
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * BucketTagging [Hash]:
+        #       * Key [String] - tag key
+        #       * Value [String] - tag value
+        # @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketGETtagging.html
+
+        def get_bucket_tagging(bucket_name)
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          request({
+            :expects    => 200,
+            :headers    => {},
+            :bucket_name => bucket_name,
+            :idempotent => true,
+            :method     => 'GET',
+            :parser     => Fog::Parsers::Storage::AWS::GetBucketTagging.new,
+            :query      => {'tagging' => nil}
+          })
+        end
+
+      end
+
+      class Mock # :nodoc:all
+
+        def get_bucket_tagging(bucket_name)
+          response = Excon::Response.new
+          if self.data[:buckets][bucket_name] && self.data[:bucket_tagging][bucket_name]
+            response.status = 200
+            response.body = {'BucketTagging' => self.data[:bucket_tagging][bucket_name]}
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/storage/post_object_restore.rb

@@ -29,7 +29,7 @@ module Fog
 
           request({
             :headers  => headers,
-            :host     => "#{bucket_name}.#{@host}",
+            :bucket_name => bucket_name,
             :expects  => [200, 202, 409],
             :body     => data,
             :method   => 'POST',

data/lib/fog/aws/requests/storage/put_bucket_tagging.rb

@@ -0,0 +1,60 @@
+module Fog
+  module Storage
+    class AWS
+      class Real
+
+        # Change tag set for an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to modify
+        # @param tags [Hash]:
+        #   * Key [String]: tag key
+        #   * Value [String]: tag value
+        #
+        # @see http://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTtagging.html
+
+        def put_bucket_tagging(bucket_name, tags)
+          tagging = tags.map do |k,v|
+            "<Tag><Key>#{k}</Key><Value>#{v}</Value></Tag>"
+          end.join("\n")
+          data =
+<<-DATA
+<Tagging xmlns="http://doc.s3.amazonaws.com/2006-03-01" >
+  <TagSet>
+    #{tagging}
+  </TagSet>
+</Tagging>
+DATA
+
+          request({
+            :body     => data,
+            :expects  => 204,
+            :headers  => {'Content-MD5' => Base64.encode64(Digest::MD5.digest(data)).chomp!, 'Content-Type' => 'application/xml'},
+            :bucket_name => bucket_name,
+            :method   => 'PUT',
+            :query    => {'tagging' => nil}
+          })
+        end
+
+      end
+
+      class Mock # :nodoc:all
+
+        def put_bucket_tagging(bucket_name, tags)
+          response = Excon::Response.new
+
+          if self.data[:buckets][bucket_name]
+            self.data[:bucket_tagging][bucket_name] = tags
+            response.status = 204
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          end
+
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/simpledb.rb

@@ -182,7 +182,6 @@ module Fog
             :body       => body,
             :expects    => 200,
             :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded; charset=utf-8' },
-            :host       => @host,
             :idempotent => idempotent,
             :method     => 'POST',
             :parser     => parser

data/lib/fog/aws/sqs.rb

@@ -111,6 +111,8 @@ module Fog
         end
 
         def request(params)
+          refresh_credentials_if_expired
+
           idempotent  = params.delete(:idempotent)
           parser      = params.delete(:parser)
           path        = params.delete(:path)