fog 1.1.2 → 1.2.0

data/lib/fog/aws/dns.rb

@@ -89,7 +89,7 @@ module Fog
           @persistent = options[:persistent]  || true
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'
-          @version    = options[:version]     || '2010-10-01'
+          @version    = options[:version]     || '2011-05-05'
 
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
         end
@@ -104,7 +104,7 @@ module Fog
           params[:headers] ||= {}
           params[:headers]['Date'] = Fog::Time.now.to_date_header
           params[:headers]['X-Amzn-Authorization'] = "AWS3-HTTPS AWSAccessKeyId=#{@aws_access_key_id},Algorithm=HmacSHA1,Signature=#{signature(params)}"
-          params[:path] = "/#{@version}/#{params[:path]}" 
+          params[:path] = "/#{@version}/#{params[:path]}"
           @connection.request(params, &block)
         end
 

data/lib/fog/aws/dynamodb.rb

@@ -0,0 +1,162 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'aws'))
+
+module Fog
+  module AWS
+    class DynamoDB < Fog::Service
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :aws_session_token, :host, :path, :port, :scheme, :persistent, :region
+
+      request_path 'fog/aws/requests/dynamodb'
+      request :batch_get_item
+      request :create_table
+      request :delete_item
+      request :delete_table
+      request :describe_table
+      request :get_item
+      request :list_tables
+      request :put_item
+      request :query
+      request :scan
+      request :update_item
+      request :update_table
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :domains => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @aws_access_key_id = options[:aws_access_key_id]
+        end
+
+        def data
+          self.class.data[@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data.delete(@aws_access_key_id)
+        end
+
+      end
+
+      class Real
+
+        # Initialize connection to DynamoDB
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   ddb = DynamoDB.new(
+        #     :aws_access_key_id => your_aws_access_key_id,
+        #     :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * DynamoDB object with connection to aws
+        def initialize(options={})
+          require 'multi_json'
+
+          if options[:aws_session_token]
+            @aws_access_key_id      = options[:aws_access_key_id]
+            @aws_secret_access_key  = options[:aws_secret_access_key]
+            @aws_session_token      = options[:aws_session_token]
+          else
+            sts = Fog::AWS::STS.new(
+              :aws_access_key_id      => options[:aws_access_key_id],
+              :aws_secret_access_key  => options[:aws_secret_access_key]
+            )
+            session_data = sts.get_session_token.body
+
+            @aws_access_key_id      = session_data['AccessKeyId']
+            @aws_secret_access_key  = session_data['SecretAccessKey']
+            @aws_session_token      = session_data['SessionToken']
+          end
+          @connection_options     = options[:connection_options] || {}
+          @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || "dynamodb.#{options[:region]}.amazonaws.com"
+          @path       = options[:path]        || '/'
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || '80' #443
+          @scheme     = options[:scheme]      || 'http' #'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+        end
+
+        private
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          idempotent = params.delete(:idempotent)
+
+          now = Fog::Time.now
+          headers = {
+            'Content-Type'          => 'application/x-amz-json-1.0',
+            'x-amz-date'            => Fog::Time.now.to_date_header,
+            'x-amz-security-token'  => @aws_session_token
+          }.merge(params[:headers])
+          headers['x-amzn-authorization']  = signed_authorization_header(params, headers)
+
+          response = @connection.request({
+            :body       => params[:body],
+            :expects    => 200,
+            :headers    => headers,
+            :host       => @host,
+            :idempotent => idempotent,
+            :method     => 'POST',
+          })
+
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+
+          response
+        end
+
+        def signed_authorization_header(params, headers)
+          string_to_sign = "POST\n/\n\nhost:#{@host}:#{@port}\n"
+
+          amz_headers, canonical_amz_headers = {}, ''
+          for key, value in headers
+            if key[0..5] == 'x-amz-'
+              amz_headers[key] = value
+            end
+          end
+          amz_headers = amz_headers.sort {|x, y| x[0] <=> y[0]}
+          for key, value in amz_headers
+            canonical_amz_headers << "#{key}:#{value}\n"
+          end
+          string_to_sign << canonical_amz_headers
+          string_to_sign << "\n"
+          string_to_sign << (params[:body] || '')
+
+          string_to_sign = OpenSSL::Digest::SHA256.digest(string_to_sign)
+
+          signed_string = @hmac.sign(string_to_sign)
+          signature = Base64.encode64(signed_string).chomp!
+
+          "AWS3 AWSAccessKeyId=#{@aws_access_key_id},Algorithm=HmacSHA256,Signature=#{signature}"
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/elasticache.rb

@@ -54,20 +54,7 @@ module Fog
           @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
 
           options[:region] ||= 'us-east-1'
-          @host = options[:host] || case options[:region]
-          when 'us-east-1'
-            'elasticache.us-east-1.amazonaws.com'
-          when 'us-west-1'
-            'elasticache.us-west-1.amazonaws.com'
-          when 'eu-west-1'
-            'elasticache.eu-west-1.amazonaws.com'
-          when 'ap-southeast-1'
-            'elasticache.ap-southeast-1.amazonaws.com'
-          when 'ap-northeast-1'
-            'elasticache.ap-northeast-1.amazonaws.com'
-          else
-            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
-          end
+          @host = options[:host] || "elasticache.#{options[:region]}.amazonaws.com"
           @path       = options[:path]      || '/'
           @port       = options[:port]      || 443
           @scheme     = options[:scheme]    || 'https'

data/lib/fog/aws/elb.rb

@@ -4,9 +4,15 @@ module Fog
   module AWS
     class ELB < Fog::Service
 
-      class IdentifierTaken < Fog::Errors::Error; end
-      class InvalidInstance < Fog::Errors::Error; end
-      class Throttled       < Fog::Errors::Error; end
+      class DuplicatePolicyName         < Fog::Errors::Error; end
+      class IdentifierTaken             < Fog::Errors::Error; end
+      class InvalidInstance             < Fog::Errors::Error; end
+      class InvalidConfigurationRequest < Fog::Errors::Error; end
+      class PolicyNotFound              < Fog::Errors::Error; end
+      class PolicyTypeNotFound          < Fog::Errors::Error; end
+      class Throttled                   < Fog::Errors::Error; end
+      class TooManyPolicies             < Fog::Errors::Error; end
+      class ValidationError             < Fog::Errors::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
       recognizes :region, :host, :path, :port, :scheme, :persistent
@@ -17,12 +23,15 @@ module Fog
       request :create_lb_cookie_stickiness_policy
       request :create_load_balancer
       request :create_load_balancer_listeners
+      request :create_load_balancer_policy
       request :delete_load_balancer
       request :delete_load_balancer_listeners
       request :delete_load_balancer_policy
       request :deregister_instances_from_load_balancer
       request :describe_instance_health
       request :describe_load_balancers
+      request :describe_load_balancer_policies
+      request :describe_load_balancer_policy_types
       request :disable_availability_zones_for_load_balancer
       request :enable_availability_zones_for_load_balancer
       request :register_instances_with_load_balancer
@@ -39,13 +48,16 @@ module Fog
 
       class Mock
 
+        require 'fog/aws/elb/policy_types'
+
         def self.data
           @data ||= Hash.new do |hash, region|
             owner_id = Fog::AWS::Mock.owner_id
             hash[region] = Hash.new do |region_hash, key|
               region_hash[key] = {
                 :owner_id => owner_id,
-                :load_balancers => {}
+                :load_balancers => {},
+                :policy_types => Fog::AWS::ELB::Mock::POLICY_TYPES
               }
             end
           end
@@ -94,7 +106,7 @@ module Fog
         #
         # ==== Parameters
         # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'ap-northeast-1', 'ap-southeast-1']
+        #   * region<~String> - optional region to use. For instance, 'eu-west-1', 'us-east-1', etc.
         #
         # ==== Returns
         # * ELB object with connection to AWS.
@@ -107,24 +119,7 @@ module Fog
           @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
 
           options[:region] ||= 'us-east-1'
-          @host = options[:host] || case options[:region]
-          when 'ap-northeast-1'
-            'elasticloadbalancing.ap-northeast-1.amazonaws.com'
-          when 'ap-southeast-1'
-            'elasticloadbalancing.ap-southeast-1.amazonaws.com'
-          when 'eu-west-1'
-            'elasticloadbalancing.eu-west-1.amazonaws.com'
-          when 'us-east-1'
-            'elasticloadbalancing.us-east-1.amazonaws.com'
-          when 'us-west-1'
-            'elasticloadbalancing.us-west-1.amazonaws.com'
-          when 'us-west-2'
-            'elasticloadbalancing.us-west-2.amazonaws.com'
-          when 'sa-east-1'
-            'elasticloadbalancing.sa-east-1.amazonaws.com'
-          else
-            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
-          end
+          @host = options[:host] || "elasticloadbalancing.#{options[:region]}.amazonaws.com"
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
           @port       = options[:port]        || 443
@@ -150,7 +145,7 @@ module Fog
               :host               => @host,
               :path               => @path,
               :port               => @port,
-              :version            => '2011-04-05'
+              :version            => '2011-11-15'
           }
           )
 
@@ -168,14 +163,27 @@ module Fog
             case match[1]
             when 'CertificateNotFound'
               raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
-            when 'LoadBalancerNotFound'
-              raise Fog::AWS::ELB::NotFound.slurp(error, match[2])
             when 'DuplicateLoadBalancerName'
               raise Fog::AWS::ELB::IdentifierTaken.slurp(error, match[2])
+            when 'DuplicatePolicyName'
+              raise Fog::AWS::ELB::DuplicatePolicyName.slurp(error, match[2])
             when 'InvalidInstance'
               raise Fog::AWS::ELB::InvalidInstance.slurp(error, match[2])
+            when 'InvalidConfigurationRequest'
+              # when do they fucking use this shit?
+              raise Fog::AWS::ELB::InvalidConfigurationRequest.slurp(error, match[2])
+            when 'LoadBalancerNotFound'
+              raise Fog::AWS::ELB::NotFound.slurp(error, match[2])
+            when 'PolicyNotFound'
+              raise Fog::AWS::ELB::PolicyNotFound.slurp(error, match[2])
+            when 'PolicyTypeNotFound'
+              raise Fog::AWS::ELB::PolicyTypeNotFound.slurp(error, match[2])
             when 'Throttling'
               raise Fog::AWS::ELB::Throttled.slurp(error, match[2])
+            when 'TooManyPolicies'
+              raise Fog::AWS::ELB::TooManyPolicies.slurp(error, match[2])
+            when 'ValidationError'
+              raise Fog::AWS::ELB::ValidationError.slurp(error, match[2])
             else
               raise
             end

data/lib/fog/aws/elb/policy_types.rb

@@ -0,0 +1,35 @@
+class Fog::AWS::ELB::Mock
+  POLICY_TYPES = [{
+    "Description" => "",
+    "PolicyAttributeTypeDescriptions" => [{
+      "AttributeName"=>"CookieName",
+      "AttributeType"=>"String",
+      "Cardinality"=>"ONE",
+      "DefaultValue"=>"",
+      "Description"=>""
+    }],
+    "PolicyTypeName"=>"AppCookieStickinessPolicyType"
+  },
+  {
+    "Description" => "",
+    "PolicyAttributeTypeDescriptions" => [{
+      "AttributeName"=>"CookieExpirationPeriod",
+      "AttributeType"=>"String",
+      "Cardinality"=>"ONE",
+      "DefaultValue"=>"",
+      "Description"=>""
+    }],
+    "PolicyTypeName"=>"LBCookieStickinessPolicyType"
+  },
+  {
+    "Description" => "Policy containing a list of public keys to accept when authenticating the back-end server(s). This policy cannot be applied directly to back-end servers or listeners but must be part of a BackendServerAuthenticationPolicyType.",
+    "PolicyAttributeTypeDescriptions" => [{
+      "AttributeName"=>"PublicKey",
+      "AttributeType"=>"String",
+      "Cardinality"=>"ONE",
+      "DefaultValue"=>"",
+      "Description"=>""
+    }],
+    "PolicyTypeName"=>"PublicKeyPolicyType"
+  }]
+end

data/lib/fog/aws/emr.rb

@@ -26,10 +26,10 @@ module Fog
       # collection  :snapshots
       # model       :parameter_group
       # collection  :parameter_groups
-      # 
+      #
       # model       :parameter
       # collection  :parameters
-      # 
+      #
       # model       :security_group
       # collection  :security_groups
 
@@ -57,7 +57,7 @@ module Fog
         #
         # ==== Parameters
         # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #   * region<~String> - optional region to use, in ['eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'ap-southeast-1']
+        #   * region<~String> - optional region to use. For instance, in 'eu-west-1', 'us-east-1' and etc.
         #
         # ==== Returns
         # * EMR object with connection to AWS.
@@ -68,12 +68,13 @@ module Fog
           @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
 
           options[:region] ||= 'us-east-1'
-          @host = options[:host] || 'elasticmapreduce.amazonaws.com'
+          @host = options[:host] || "elasticmapreduce.#{options[:region]}.amazonaws.com"
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+          @region = options[:region]
         end
 
         def reload

data/lib/fog/aws/iam.rb

@@ -61,7 +61,22 @@ module Fog
           @data ||= Hash.new do |hash, key|
             hash[key] = {
               :owner_id => Fog::AWS::Mock.owner_id,
-              :server_certificates => {}
+              :server_certificates => {},
+              :users => Hash.new do |uhash, ukey|
+                uhash[ukey] = {
+                  :user_id     => Fog::AWS::Mock.key_id,
+                  :arn         => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:user/#{ukey}",
+                  :access_keys => [],
+                  :policies    => {}
+                }
+              end,
+              :groups => Hash.new do |ghash, gkey|
+                ghash[gkey] = {
+                  :group_id   => Fog::AWS::Mock.key_id,
+                  :arn        => "arn:aws:iam::#{Fog::AWS::Mock.owner_id}:group/#{gkey}",
+                  :members    => []
+                }
+              end
             }
           end
         end

data/lib/fog/aws/models/auto_scaling/activity.rb

@@ -9,7 +9,7 @@ module Fog
         attribute :auto_scaling_group_name, :aliases => 'AutoScalingGroupName'
         attribute :cause,                   :aliases => 'Cause'
         attribute :description,             :aliases => 'Description'
-	attribute :end_time,                :aliases => 'EndTime'
+        attribute :end_time,                :aliases => 'EndTime'
         attribute :progress,                :aliases => 'Progress'
         attribute :start_time,              :aliases => 'StartTime'
         attribute :status_code,             :aliases => 'StatusCode'

data/lib/fog/aws/models/auto_scaling/group.rb

@@ -65,9 +65,9 @@ module Fog
           reload
         end
 
-        def enable_metrics_collection(metrics = {})
+        def enable_metrics_collection(granularity = '1Minute', metrics = {})
           requires :id
-          connection.enable_metrics_collection(id, 'Metrics' => metrics)
+          connection.enable_metrics_collection(id, granularity, 'Metrics' => metrics)
           reload
         end
 

data/lib/fog/aws/models/beanstalk/application.rb

@@ -0,0 +1,62 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class ElasticBeanstalk
+
+      class Application < Fog::Model
+        identity :name, :aliases => 'ApplicationName'
+        attribute :template_names, :aliases => 'ConfigurationTemplates'
+        attribute :created_at, :aliases => 'DateCreated'
+        attribute :updated_at, :aliases => 'DateUpdated'
+        attribute :description, :aliases => 'Description'
+        attribute :version_names, :aliases => 'Versions'
+
+        def initialize(attributes={})
+          super
+        end
+
+        def environments
+          requires :name
+          connection.environments.all({'ApplicationName' => name})
+        end
+
+        def events
+          requires :name
+          connection.events.all({'ApplicationName' => name})
+        end
+
+        def templates
+          requires :name
+          connection.templates.all({'ApplicationName' => name})
+        end
+
+        def versions
+          requires :name
+          connection.versions.all({'ApplicationName' => name})
+        end
+
+        def destroy
+          requires :name
+          connection.delete_application(name)
+          true
+        end
+
+        def save
+          requires :name
+
+          options = {
+              'ApplicationName' => name
+          }
+          options['Description'] = description unless description.nil?
+
+          data = connection.create_application(options).body['CreateApplicationResult']['Application']
+          merge_attributes(data)
+          true
+        end
+
+      end
+
+    end
+  end
+end