fog 1.5.0 → 1.6.0

data/lib/fog/aws/iam.rb

@@ -11,7 +11,7 @@ module Fog
       class ValidationError < Fog::AWS::IAM::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent
+      recognizes :host, :path, :port, :scheme, :persistent, :instrumentor, :instrumentor_name
 
       request_path 'fog/aws/requests/iam'
       request :add_user_to_group
@@ -70,15 +70,15 @@ module Fog
       request :update_user
       request :upload_server_certificate
       request :upload_signing_certificate
-      
+
       model_path 'fog/aws/models/iam'
       model       :user
       collection  :users
       model       :policy
-      collection  :policies      
+      collection  :policies
       model       :access_key
       collection  :access_keys
-      
+
 
       class Mock
         def self.data
@@ -151,6 +151,8 @@ module Fog
           @aws_access_key_id      = options[:aws_access_key_id]
           @aws_secret_access_key  = options[:aws_secret_access_key]
           @connection_options     = options[:connection_options] || {}
+          @instrumentor           = options[:instrumentor]
+          @instrumentor_name      = options[:instrumentor_name] || 'fog.aws.iam'
           @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
           @host       = options[:host]        || 'iam.amazonaws.com'
           @path       = options[:path]        || '/'
@@ -182,35 +184,39 @@ module Fog
             }
           )
 
-          begin
-            response = @connection.request({
-              :body       => body,
-              :expects    => 200,
-              :idempotent => idempotent,
-              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
-              :host       => @host,
-              :method     => 'POST',
-              :parser     => parser
-            })
-
-            response
-          rescue Excon::Errors::HTTPStatusError => error
-            if match = error.message.match(/<Code>(.*)<\/Code>(?:.*<Message>(.*)<\/Message>)?/m)
-              case match[1]
-              when 'CertificateNotFound', 'NoSuchEntity'
-                raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
-              when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
-                raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
-              else
-                raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
-                raise
-              end
+          if @instrumentor
+            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
+              _request(body, idempotent, parser)
+            end
+          else
+            _request(body, idempotent, parser)
+          end
+        end
+
+        def _request(body, idempotent, parser)
+          @connection.request({
+            :body       => body,
+            :expects    => 200,
+            :idempotent => idempotent,
+            :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+            :host       => @host,
+            :method     => 'POST',
+            :parser     => parser
+          })
+        rescue Excon::Errors::HTTPStatusError => error
+          if match = error.message.match(/<Code>(.*)<\/Code>(?:.*<Message>(.*)<\/Message>)?/m)
+            case match[1]
+            when 'CertificateNotFound', 'NoSuchEntity'
+              raise Fog::AWS::IAM::NotFound.slurp(error, match[2])
+            when 'EntityAlreadyExists', 'KeyPairMismatch', 'LimitExceeded', 'MalformedCertificate', 'ValidationError'
+              raise Fog::AWS::IAM.const_get(match[1]).slurp(error, match[2])
             else
+              raise Fog::AWS::IAM::Error.slurp(error, "#{match[1]} => #{match[2]}") if match[1]
               raise
             end
+          else
+            raise
           end
-
-
         end
 
       end

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

@@ -73,7 +73,7 @@ module Fog
         end
 
         def instances
-          Fog::AWS::AutoScaling::Instances.new(:connection => connection).load(attributes[:instance])
+          Fog::AWS::AutoScaling::Instances.new(:connection => connection).load(attributes[:instances])
         end
 
         def instances_in_service

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

@@ -9,6 +9,7 @@ module Fog
         { :bits => 0,  :cores =>   2,  :disk => 0,    :id =>  't1.micro',   :name => 'Micro Instance',       :ram => 613},
 
         { :bits => 32, :cores =>   1,  :disk => 160,  :id =>  'm1.small',   :name => 'Small Instance',       :ram => 1740.8},
+	{ :bits => 32, :cores =>   2,  :disk => 400,  :id =>  'm1.medium',  :name => 'Medium Instance',      :ram => 3750},
         { :bits => 64, :cores =>   4,  :disk => 850,  :id =>  'm1.large',   :name => 'Large Instance',       :ram => 7680},
         { :bits => 64, :cores =>   8,  :disk => 1690, :id =>  'm1.xlarge',  :name => 'Extra Large Instance', :ram => 15360},
 
@@ -19,6 +20,8 @@ module Fog
         { :bits => 64, :cores =>   13, :disk => 850,  :id =>  'm2.2xlarge', :name => 'High Memory Double Extra Large',    :ram => 35020.8},
         { :bits => 64, :cores =>   26, :disk => 1690, :id =>  'm2.4xlarge', :name => 'High Memory Quadruple Extra Large', :ram => 70041.6},
 
+        { :bits => 64, :cores =>   35, :disk => 2048, :id => "hi1.4xlarge", :name => "High I/O Quadruple Extra Large Instance", :ram => 61952},
+
         { :bits => 64, :cores => 33.5, :disk => 1690, :id => 'cc1.4xlarge', :name => 'Cluster Compute Quadruple Extra Large', :ram => 23552},
         { :bits => 64, :cores =>   88, :disk => 3370, :id => 'cc2.8xlarge', :name => 'Cluster Compute Eight Extra Large',     :ram => 61952},
         { :bits => 64, :cores => 33.5, :disk => 1690, :id => 'cg1.4xlarge', :name => 'Cluster GPU Quadruple Extra Large',     :ram => 22528}
@@ -56,6 +59,14 @@ module Fog
         #        ram=1740.8
         #      >,
         #      <Fog::AWS::Compute::Flavor
+        #        id="m1.medium",
+        #        bits=32,
+        #        cores=2,
+        #        disk=400,
+        #        name="Medium Instance",
+        #        ram=3750
+        #      >,
+        #      <Fog::AWS::Compute::Flavor
         #        id="m1.large",
         #        bits=64,
         #        cores=4,

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

@@ -10,6 +10,7 @@ module Fog
         attribute :description,     :aliases => 'groupDescription'
         attribute :group_id,        :aliases => 'groupId'
         attribute :ip_permissions,  :aliases => 'ipPermissions'
+        attribute :ip_permissions_egress,  :aliases => 'ipPermissionsEgress'
         attribute :owner_id,        :aliases => 'ownerId'
         attribute :vpc_id,          :aliases => 'vpcId'
 
@@ -40,7 +41,7 @@ module Fog
         #
 
         def authorize_group_and_owner(group, owner = nil)
-          Fog::Logger.deprecation("authorize_group_and_ownder is deprecated, use authorize_port_range with :group option instead")
+          Fog::Logger.deprecation("authorize_group_and_owner is deprecated, use authorize_port_range with :group option instead")
 
           requires_one :name, :group_id
 
@@ -242,11 +243,26 @@ module Fog
 
         private
 
-        def group_info(group_str)
-          account, group = group_str.split(":")
-
-          if account.empty? || group.nil? || group.empty?
-            raise ArgumentError, "group must be specified in form of \"<account id>:<group name or id>\", #{group_str} given"
+        #
+        # +group_arg+ may be a string or a hash with one key & value.
+        #
+        # If group_arg is a string, it is assumed to be the group name,
+        # and the UserId is assumed to be self.owner_id.
+        #
+        # The "account:group" form is deprecated.
+        #
+        # If group_arg is a hash, the key is the UserId and value is the group.
+        def group_info(group_arg)
+          if Hash === group_arg
+            account = group_arg.keys.first
+            group   = group_arg.values.first
+          elsif group_arg.match(/:/)
+            account, group = group_arg.split(':')
+            Fog::Logger.deprecation("'account:group' argument is deprecated. Use {account => group} or just group instead")
+          else
+            requires :owner_id
+            account = owner_id
+            group = group_arg
           end
 
           info = { 'UserId' => account }

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

@@ -17,6 +17,7 @@ module Fog
         attribute :network_interfaces,    :aliases => 'networkInterfaces'
         attribute :client_token,          :aliases => 'clientToken'
         attribute :dns_name,              :aliases => 'dnsName'
+        attribute :ebs_optimized,         :aliases => 'ebsOptimized'
         attribute :groups
         attribute :flavor_id,             :aliases => 'instanceType'
         attribute :iam_instance_profile,  :aliases => 'iamInstanceProfile'
@@ -62,6 +63,8 @@ module Fog
               'ami-f092eca2'
             when 'eu-west-1'
               'ami-3d1f2b49'
+            when 'sa-east-1'
+              'ami-d0429ccd'
             when 'us-east-1'
               'ami-3202f25b'
             when 'us-west-1'
@@ -150,6 +153,7 @@ module Fog
           options = {
             'BlockDeviceMapping'          => block_device_mapping,
             'ClientToken'                 => client_token,
+            'EbsOptimized'                => ebs_optimized,
             'IamInstanceProfile.Arn'      => @iam_instance_profile_arn,
             'IamInstanceProfile.Name'     => @iam_instance_profile_name,
             'InstanceInitiatedShutdownBehavior' => instance_initiated_shutdown_behavior,
@@ -170,7 +174,7 @@ module Fog
           options.delete_if {|key, value| value.nil?}
 
           # If subnet is defined then this is a Virtual Private Cloud.
-          # subnet & security group cannot co-exist. Attempting to specify 
+          # subnet & security group cannot co-exist. Attempting to specify
           # both subnet and groups will cause an error.  Instead please make
           # use of Security Group Ids when working in a VPC.
           if subnet_id

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

@@ -28,6 +28,7 @@ module Fog
         attribute :image_id,                   :aliases => 'LaunchSpecification.ImageId'
         attribute :monitoring,                 :aliases => 'LaunchSpecification.Monitoring'
         attribute :block_device_mapping,       :aliases => 'LaunchSpecification.BlockDeviceMapping'
+        attribute :subnet_id,                  :aliases => 'LaunchSpecification.SubnetId'
         attribute :tags,                       :aliases => 'tagSet'
         attribute :fault,                      :squash  => 'message'
         attribute :user_data
@@ -109,10 +110,21 @@ module Fog
             'LaunchSpecification.Placement.AvailabilityZone' => availability_zone,
             'LaunchSpecification.SecurityGroup'              => groups,
             'LaunchSpecification.UserData'                   => user_data,
+            'LaunchSpecification.SubnetId'                   => subnet_id,
             'Type'                                           => request_type,
             'ValidFrom'                                      => valid_from,
             'ValidUntil'                                     => valid_until }
           options.delete_if {|key, value| value.nil?}
+          
+          # If subnet is defined then this is a Virtual Private Cloud.
+          # subnet & security group cannot co-exist. Attempting to specify
+          # both subnet and groups will cause an error.  Instead please make
+          # use of Security Group Ids when working in a VPC.
+          if subnet_id
+            options.delete('LaunchSpecification.SecurityGroup')
+          else
+            options.delete('LaunchSpecification.SubnetId')
+          end
 
           data = connection.request_spot_instances(image_id, flavor_id, price, options).body
           spot_instance_request = data['spotInstanceRequestSet'].first

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

@@ -61,8 +61,7 @@ module Fog
           end
 
           spot_request.save
-          spot_request.wait_for(Fog.timeout, interval=4) { ready? }
-          Fog.wait_for { server = connection.servers.get(spot_request.reload.instance_id) }
+          Fog.wait_for { spot_request.reload.ready? rescue nil }
           server = connection.servers.get(spot_request.instance_id)
           if spot_request.tags
             for key, value in spot_request.tags

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

@@ -13,11 +13,13 @@ module Fog
         attribute :created_at,            :aliases => 'createTime'
         attribute :delete_on_termination, :aliases => 'deleteOnTermination'
         attribute :device
+        attribute :iops
         attribute :server_id,             :aliases => 'instanceId'
         attribute :size
         attribute :snapshot_id,           :aliases => 'snapshotId'
         attribute :state,                 :aliases => 'status'
         attribute :tags,                  :aliases => 'tagSet'
+        attribute :type,                  :aliases => 'volumeType'
 
         def initialize(attributes = {})
           # assign server first to prevent race condition with new_record?
@@ -41,7 +43,11 @@ module Fog
           requires :availability_zone
           requires_one :size, :snapshot_id
 
-          data = connection.create_volume(availability_zone, size, snapshot_id).body
+          if type == 'io1'
+            requires :iops
+          end
+
+          data = connection.create_volume(availability_zone, size, 'SnapshotId' => snapshot_id, 'VolumeType' => type, 'Iops' => iops).body
           new_attributes = data.reject {|key,value| key == 'requestId'}
           merge_attributes(new_attributes)
 

data/lib/fog/aws/models/glacier/archive.rb

@@ -0,0 +1,70 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Archive < Fog::Model
+
+        identity  :id
+        attribute :description
+        attribute :body
+
+        attr_accessor :multipart_chunk_size #must be a power of 2 multiple of 1MB
+
+        def vault
+          @vault
+        end
+
+        def save
+          requires :body, :vault
+
+          if multipart_chunk_size && body.respond_to?(:read)
+            self.id = multipart_save
+          else
+            data = connection.create_archive(vault.id, body, 'description' => description)
+            self.id = data.headers['x-amz-archive-id']
+          end
+          true
+        end
+        
+        def destroy
+          requires :id
+          connection.delete_archive(vault.id,id)
+        end
+
+        private
+
+        def vault=(new_vault)
+          @vault = new_vault
+        end
+
+        def multipart_save
+          # Initiate the upload
+          res = connection.initiate_multipart_upload vault.id, multipart_chunk_size, 'description' => description
+          upload_id = res.headers["x-amz-multipart-upload-id"]
+
+          hash = Fog::AWS::Glacier::TreeHash.new
+
+          body.rewind if body.respond_to?(:rewind)
+          offset = 0
+          while (chunk = body.read(multipart_chunk_size)) do
+            part_hash = hash.add_part(chunk)
+            part_upload = connection.upload_part(vault.id, upload_id, chunk, offset, part_hash  )
+            offset += chunk.bytesize
+          end
+
+        rescue
+          # Abort the upload & reraise
+          connection.abort_multipart_upload(vault.id, upload_id) if upload_id
+          raise
+        else
+          # Complete the upload
+          connection.complete_multipart_upload(vault.id, upload_id, offset, hash.hexdigest).headers['x-amz-archive-id']
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/glacier/archives.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/glacier/archive'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Archives < Fog::Collection
+
+        model Fog::AWS::Glacier::Archive
+        attribute :vault
+        #you can't list a vault's archives
+        def all
+          nil
+        end
+
+        def get(key)
+          new(:id => key)
+        end
+
+        def new(attributes = {})
+          requires :vault
+          super({ :vault => vault }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/models/glacier/job.rb

@@ -0,0 +1,65 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Glacier
+
+      class Job < Fog::Model
+
+        ARCHIVE = 'archive-retrieval'
+        INVENTORY = 'inventory-retrieval'
+
+        identity  :id,              :aliases => "JobId"
+        attribute :action,          :aliases => "Action"
+        attribute :archive_id,      :aliases => "ArchiveId"
+        attribute :archive_size,    :aliases => "ArchiveSizeInBytes", :type => :integer
+        attribute :completed,       :aliases => "Completed", :type => :boolean
+        attribute :completed_at,    :aliases => "CompletionDate", :type => :time
+        attribute :created_at,      :aliases => "CreationDate", :type => :time
+        attribute :inventory_size,  :aliases => "InventorySizeInBytes", :type => :integer
+        attribute :description,     :aliases=> "JobDescription"
+        attribute :tree_hash,       :aliases=> "SHA256TreeHash"
+        attribute :sns_topic,       :aliases => "SNSTopic"
+        attribute :status_code,     :aliases=> "StatusCode"
+        attribute :status_message,  :aliases=> "StatusMessage"
+        attribute :vault_arn,       :aliases=> "VaultARN"
+        attribute :format
+        attribute :type
+
+
+        def ready?
+          completed
+        end
+
+        def save
+          requires :vault, :type
+          specification = {'Type' => type, 'ArchiveId' => archive_id, 'Format' => format, 'Description' => description, 'SNSTopic' => sns_topic}.reject{|k,v| v.nil?}
+
+          data = connection.initiate_job(vault.id, specification)
+          self.id = data.headers['x-amz-job-id']
+          reload
+        end
+
+        def vault
+          @vault
+        end
+
+        #pass :range => 1..1234 to only retrieve those bytes
+        #pass :io => f to stream the response to that tio
+        def get_output(options={})
+          if io = options.delete(:io)
+            options = options.merge :response_block => lambda {|chunk, remaining_bytes, total_bytes| io.write chunk}
+          end
+          options['Range'] = options.delete :range
+          connection.get_job_output(vault.id, id, options)
+        end
+
+        private
+        def vault=(new_vault)
+          @vault = new_vault
+        end
+
+      end
+    end
+  end
+end