fog 1.1.1 → 1.1.2

data/lib/fog/aws/elb.rb

@@ -120,6 +120,8 @@ module Fog
             '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

data/lib/fog/aws/models/cloud_watch/metric_statistic.rb

@@ -25,7 +25,6 @@ module Fog
 
           put_opts = {'MetricName' => metric_name, 'Unit' => unit}
           put_opts.merge!('Dimensions' => dimensions) if dimensions
-          put_opts.merge!('Timestamp' => dimensions) if timestamp
           if value
             put_opts.merge!('Value' => value)
           else
@@ -43,4 +42,4 @@ module Fog
       end
     end
   end
-end
+end

data/lib/fog/aws/models/compute/security_group.rb

@@ -7,8 +7,8 @@ module Fog
       class SecurityGroup < Fog::Model
 
         identity  :name,            :aliases => 'groupName'
-
         attribute :description,     :aliases => 'groupDescription'
+        attribute :group_id,        :aliases => 'groupId'
         attribute :ip_permissions,  :aliases => 'ipPermissions'
         attribute :owner_id,        :aliases => 'ownerId'
 

data/lib/fog/aws/models/compute/server.rb

@@ -34,6 +34,7 @@ module Fog
         attribute :reason
         attribute :root_device_name,      :aliases => 'rootDeviceName'
         attribute :root_device_type,      :aliases => 'rootDeviceType'
+        attribute :security_group_ids,    :aliases => 'securityGroupIds'
         attribute :state,                 :aliases => 'instanceState', :squash => 'name'
         attribute :state_reason,          :aliases => 'stateReason'
         attribute :subnet_id,             :aliases => 'subnetId'
@@ -45,7 +46,7 @@ module Fog
         attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
 
         def initialize(attributes={})
-          self.groups     ||= ["default"] unless attributes[:subnet_id]
+          self.groups     ||= ["default"] unless (attributes[:subnet_id] || attributes[:security_group_ids])
           self.flavor_id  ||= 't1.micro'
           self.image_id   ||= begin
             self.username = 'ubuntu'
@@ -152,6 +153,7 @@ module Fog
             'Placement.Tenancy'           => tenancy,
             'RamdiskId'                   => ramdisk_id,
             'SecurityGroup'               => groups,
+            'SecurityGroupId'             => security_group_ids,
             'SubnetId'                    => subnet_id,
             'UserData'                    => user_data
           }

data/lib/fog/aws/models/dns/records.rb

@@ -20,9 +20,9 @@ module Fog
 
         def all(options = {})
           requires :zone
-          options['MaxItems'] ||= max_items
-          options['Name']     ||= name
-          options['Type']     ||= type
+          options['maxitems'] ||= max_items
+          options['name']     ||= name
+          options['type']     ||= type
           data = connection.list_resource_record_sets(zone.id, options).body
           merge_attributes(data.reject {|key, value| !['IsTruncated', 'MaxItems', 'NextRecordName', 'NextRecordType'].include?(key)})
           # leave out the default, read only records

data/lib/fog/aws/models/elb/load_balancer.rb

@@ -96,6 +96,12 @@ module Fog
           reload
         end
 
+        def set_listener_ssl_certificate(port, ssl_certificate_id)
+          requires :id
+          connection.set_load_balancer_listener_ssl_certificate(id, port, ssl_certificate_id)
+          reload
+        end
+
         def unset_listener_policy(port)
           set_listener_policy(port, [])
         end

data/lib/fog/aws/models/storage/file.rb

@@ -123,9 +123,9 @@ module Fog
           true
         end
 
-        def url(expires)
+        def url(expires, options = {})
           requires :key
-          collection.get_https_url(key, expires)
+          collection.get_https_url(key, expires, options)
         end
 
         private

data/lib/fog/aws/models/storage/files.rb

@@ -78,14 +78,14 @@ module Fog
           end
         end
 
-        def get_http_url(key, expires)
+        def get_http_url(key, expires, options = {})
           requires :directory
-          connection.get_object_http_url(directory.key, key, expires)
+          connection.get_object_http_url(directory.key, key, expires, options)
         end
 
-        def get_https_url(key, expires)
+        def get_https_url(key, expires, options = {})
           requires :directory
-          connection.get_object_https_url(directory.key, key, expires)
+          connection.get_object_https_url(directory.key, key, expires, options)
         end
 
         def head(key, options = {})

data/lib/fog/aws/parsers/compute/describe_instance_status.rb

@@ -0,0 +1,64 @@
+module Fog
+  module Parsers
+    module Compute
+      module AWS
+        class DescribeInstanceStatus < Fog::Parsers::Base
+
+          def new_instance
+            @instance = { 'eventsSet' => [], 'instanceState' => {} }
+          end
+
+          def new_event
+            @event = {}
+          end
+
+          def reset
+            @instance_status = {}
+            @response = { 'instanceStatusSet' => [] }
+            @in_events_set = false
+            new_event
+            new_instance
+          end
+
+          def start_element(name, attrs=[])
+            super
+            case name
+            when 'eventsSet'
+              @in_events_set = true
+            end
+          end
+
+
+          def end_element(name)
+            if @in_events_set
+              case name
+              when 'code', 'description'
+                @event[name] = value
+              when 'notAfter', 'notBefore'
+                @event[name] = Time.parse(value)
+              when 'item'
+                @instance['eventsSet'] << @event
+                new_event
+              when 'eventsSet'
+                @in_events_set = false
+              end
+            else
+              case name
+              when 'instanceId', 'availabilityZone'
+                @instance[name] = value
+              when 'name', 'code'
+                @instance['instanceState'][name] = value
+              when 'item'
+                @response['instanceStatusSet'] << @instance
+                new_instance
+              when 'requestId'
+                @response[name] = value
+
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/compute/describe_security_groups.rb

@@ -40,7 +40,7 @@ module Fog
               end
             when 'groups'
               @in_groups = false
-            when 'groupDescription', 'ownerId'
+            when 'groupDescription', 'ownerId', 'groupId'
               @security_group[name] = value
             when 'groupName'
               if @in_groups

data/lib/fog/aws/parsers/sqs/receive_message.rb

@@ -24,7 +24,7 @@ module Fog
             when 'Value'
               case @current_attribute_name
               when 'ApproximateFirstReceiveTimestamp', 'SentTimestamp'
-                @message['Attributes'][@current_attribute_name] = Time.at(@value.to_i)
+                @message['Attributes'][@current_attribute_name] = Time.at(@value.to_i / 1000.0)
               when 'ApproximateReceiveCount'
                 @message['Attributes'][@current_attribute_name] = @value.to_i
               else

data/lib/fog/aws/parsers/sts/get_session_token.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Parsers
+    module AWS
+      module STS
+
+        class GetSessionToken < Fog::Parsers::Base
+					# http://docs.amazonwebservices.com/IAM/latest/UserGuide/index.html?CreatingFedTokens.html
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'SessionToken', 'SecretAccessKey', 'Expiration', 'AccessKeyId'
+              @response[name] = @value.strip
+            when 'Arn', 'FederatedUserId'
+              @response[name] = @value
+            when 'PackedPolicySize'
+              @response[name] = @value
+            when 'RequestId'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/rds.rb

@@ -57,9 +57,42 @@ module Fog
 
       class Mock
 
+        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] = {
+                :servers => {}
+              }
+            end
+          end
+        end
+        
+        def self.reset
+          @data = nil
+        end
+        
         def initialize(options={})
-          Fog::Mock.not_implemented
+        
+          @aws_access_key_id = options[:aws_access_key_id]
+        
+          @region = options[:region] || 'us-east-1'
+        
+          unless ['ap-northeast-1', 'ap-southeast-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2'].include?(@region)
+            raise ArgumentError, "Unknown region: #{@region.inspect}"
+          end
+        
+        end
+        
+        def data
+          self.class.data[@region][@aws_access_key_id]
+        end
+        
+        def reset_data
+          self.class.data[@region].delete(@aws_access_key_id)
         end
+        
+        
 
       end
 
@@ -103,6 +136,8 @@ module Fog
             'rds.us-west-1.amazonaws.com'
           when 'us-west-2'
             'rds.us-west-2.amazonaws.com'
+          when 'sa-east-1'
+            'rds.sa-east-1.amazonaws.com'
           else
             raise ArgumentError, "Unknown region: #{options[:region].inspect}"
           end

data/lib/fog/aws/requests/compute/describe_availability_zones.rb

@@ -57,6 +57,9 @@ module Fog
 
             {"messageSet" => [], "regionName" => "us-west-2", "zoneName" => "us-west-2a", "zoneState" => "available"},
             {"messageSet" => [], "regionName" => "us-west-2", "zoneName" => "us-west-2b", "zoneState" => "available"},
+            
+            {"messageSet" => [], "regionName" => "sa-east-1", "zoneName" => "sa-east-1a", "zoneState" => "available"},
+            {"messageSet" => [], "regionName" => "sa-east-1", "zoneName" => "sa-east-1b", "zoneState" => "available"},
 
             {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1a", "zoneState" => "available"},
             {"messageSet" => [], "regionName" => "eu-west-1", "zoneName" => "eu-west-1b", "zoneState" => "available"},

data/lib/fog/aws/requests/compute/describe_instance_status.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_instance_status'
+
+        def describe_instance_status(filters = {})
+          raise ArgumentError.new("Filters must be a hash, but is a #{filters.class}.") unless filters.is_a?(Hash)
+
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeInstanceStatus',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeInstanceStatus.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_instance_status(filters = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'instanceStatusSet' => [],
+            'requestId' => Fog::AWS::Mock.request_id
+          }
+
+          response
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/compute/describe_security_groups.rb

@@ -16,6 +16,7 @@ module Fog
         #     * 'requestId'<~String> - Id of request
         #     * 'securityGroupInfo'<~Array>:
         #       * 'groupDescription'<~String> - Description of security group
+        #       * 'groupId'<~String> - ID of the security group.
         #       * 'groupName'<~String> - Name of security group
         #       * 'ipPermissions'<~Array>:
         #         * 'fromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
@@ -59,6 +60,7 @@ module Fog
           aliases = {
             'description' => 'groupDescription',
             'group-name'  => 'groupName',
+            'group-id'    => 'groupId',
             'owner-id'    => 'ownerId'
           }
           permission_aliases = {

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

@@ -34,6 +34,33 @@ module Fog
       end
 
       class Mock
+        def set_load_balancer_listener_ssl_certificate(lb_name, load_balancer_port, ssl_certificate_id)
+          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
+
+          certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
+          if !certificate_ids.include? ssl_certificate_id
+            raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
+          end
+
+          response = Excon::Response.new
+
+          unless listener = load_balancer['ListenerDescriptions'].find { |listener| listener['Listener']['LoadBalancerPort'] == load_balancer_port }
+            response.status = 400
+            response.body = "<?xml version=\"1.0\"?><Response><Errors><Error><Code>ListenerNotFound</Code><Message>LoadBalancer does not have a listnener configured at the given port.</Message></Error></Errors><RequestID>#{Fog::AWS::Mock.request_id}</RequestId></Response>"
+            raise Excon::Errors.status_error({:expects => 200}, response)
+          end
+
+          listener['Listener']['SSLCertificateId'] = ssl_certificate_id
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata" => {
+              "RequestId" => Fog::AWS::Mock.request_id
+            }
+          }
+
+          response
+        end
       end
     end
   end

data/lib/fog/aws/requests/rds/create_db_instance.rb

@@ -47,7 +47,70 @@ module Fog
       class Mock
 
         def create_db_instance(db_name, options={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          if self.data[:servers] and self.data[:servers][db_name]
+            # I don't know how to raise an exception that contains the excon data
+            #response.status = 400
+            #response.body = {
+            #  'Code' => 'DBInstanceAlreadyExists',
+            #  'Message' => "DB Instance already exists"
+            #}
+            #return response
+            raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
+          end
+          
+          # These are the required parameters according to the API
+          required_params = %w{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
+          required_params.each do |key|
+            unless options.has_key?(key) and options[key] and !options[key].to_s.empty?
+              #response.status = 400
+              #response.body = {
+              #  'Code' => 'MissingParameter',
+              #  'Message' => "The request must contain the parameter #{key}"
+              #}
+              #return response
+              raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
+            end
+          end
+          
+          data =
+              {
+                 "DBInstanceIdentifier"=> db_name,
+                 "DBName" => options["DBName"],
+                 "created_at" => nil,
+                 "AutoMinorVersionUpgrade"=>true,
+                 "Endpoint"=>{},
+                 "ReadReplicaDBInstanceIdentifiers"=>[],
+                 "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
+                 "Engine"=> options["Engine"],
+                 "EngineVersion"=> options["EngineVersion"] || "5.1.57",
+                 "PendingModifiedValues"=>{"MasterUserPassword"=>"****"}, # This clears when is available
+                 "MultiAZ"=>false,
+                 "MasterUsername"=> options["MasterUsername"],
+                 "DBInstanceClass"=> options["DBInstanceClass"],
+                 "DBInstanceStatus"=>"creating",
+                 "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
+                 "AllocatedStorage"=> options["AllocatedStorage"],
+                 "DBParameterGroups"=> # I think groups shoul be in the self.data method
+                          [{"DBParameterGroupName"=>"default.mysql5.1",
+                            "ParameterApplyStatus"=>"in-sync"}],
+                 "DBSecurityGroups"=>
+                          [{"Status"=>"active", 
+                            "DBSecurityGroupName"=>"default"}],
+                 "LicenseModel"=>"general-public-license",
+                 "PreferredBackupWindow"=>"08:00-08:30"
+             }
+           
+          
+          self.data[:servers][db_name] = data
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "CreateDBInstanceResult"=> {"DBInstance"=> data}
+          }
+          response.status = 200
+          # This values aren't showed at creating time but at available time
+          self.data[:servers][db_name]["created_at"] = Time.now
+          response
         end
 
       end