fog-aws 1.4.1 → 3.27.0

data/lib/fog/aws/glacier.rb

@@ -4,7 +4,7 @@ module Fog
       extend Fog::AWS::CredentialFetcher::ServiceMethods
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name, :sts_endpoint
 
       request_path 'fog/aws/requests/glacier'
 
@@ -39,52 +39,114 @@ module Fog
           new.add_part(body)
         end
 
-        def reduce_digests(digests)
-          while digests.length > 1
-            digests = digests.each_slice(2).map do |pair|
-              if pair.length == 2
-                OpenSSL::Digest::SHA256.digest(pair[0]+pair[1])
-              else
-                pair.first
-              end
+        def initialize
+          @last_chunk_digest = nil	# Digest OBJECT for last chunk (Digest::SHA256)
+          @last_chunk_digest_temp = nil	# Digest VALUE for last chunk
+          @last_chunk_length = 0	# Length of last chunk, always smaller than 1MB.
+          @digest_stack = []
+          # First position on stack corresponds to 1MB, second 2MB, third 4MB, fourt 8MB and so on.
+          # In any time, the size of all already added parts is equal to sum of all existing (non-nil)
+          # positions multiplied by that number, plus last_chunk_length for the remainder smaller than
+          # one megabyte. So, if last_chunk_length is half megabyte, stack[0] is filled, stack[1] and 
+          # stack[2] empty and stack[3] filled, the size is 0.5MB + 1x1MB + 0x2MB + 0x4MB + 1x8MB = 9.5MB.
+        end
+
+        def update_digest_stack(digest, stack)
+          stack.each_with_index{|s,i|
+            if s
+              digest = Digest::SHA256.digest(s + digest)
+              stack[i] = nil
+            else
+              stack[i] = digest # Update this position with value obtained in previous run of cycle.
+              digest = nil
+              break
             end
-          end
-          digests.first
+          }
+          stack << digest if digest
         end
 
-        def initialize
-          @digests = []
+        def reduce_digest_stack(digest, stack)
+          stack.each_with_index{|s,i|
+            unless digest
+              digest = stack[i]
+              next
+            end
+            if stack[i]
+              digest = Digest::SHA256.digest(stack[i] + digest)
+            end
+          }
+          digest
         end
 
         def add_part(bytes)
           part = self.digest_for_part(bytes)
-          @digests << part
           part.unpack('H*').first
         end
 
-        def digest_for_part(body)
-          chunk_count = [body.bytesize / MEGABYTE + (body.bytesize % MEGABYTE > 0 ? 1 : 0), 1].max
+        def prepare_body_for_slice(body)
           if body.respond_to? :byteslice
-            digests_for_part = chunk_count.times.map {|chunk_index| OpenSSL::Digest::SHA256.digest(body.byteslice(chunk_index * MEGABYTE, MEGABYTE))}
+            r = yield(body, :byteslice)
           else
             if body.respond_to? :encoding
               old_encoding = body.encoding
               body.force_encoding('BINARY')
             end
-            digests_for_part = chunk_count.times.map {|chunk_index| OpenSSL::Digest::SHA256.digest(body.slice(chunk_index * MEGABYTE, MEGABYTE))}
+            r = yield(body, :slice)
             if body.respond_to? :encoding
               body.force_encoding(old_encoding)
             end
           end
-          reduce_digests(digests_for_part)
+          r
         end
 
-        def hexdigest
-          digest.unpack('H*').first
+        def digest_for_part(body)
+          part_stack = []
+          part_temp = nil
+          body_size = body.bytesize
+          prepare_body_for_slice(body) {|body, slice|
+            start_offset = 0
+            if @last_chunk_length != 0
+              start_offset = MEGABYTE - @last_chunk_length
+              @last_chunk_hash.update(body.send(slice, 0, start_offset))
+              hash = @last_chunk_hash.digest
+              @last_chunk_digest_temp = hash
+              if body_size > start_offset
+                @last_chunk_length = 0
+                @last_chunk_hash = nil
+                @last_chunk_digest_temp = nil
+                update_digest_stack(hash, @digest_stack)
+              else
+                part_temp = hash
+                @last_chunk_digest_temp = hash
+                @last_chunk_length += body_size
+                next
+              end
+            end
+            whole_chunk_count = (body_size - start_offset) / MEGABYTE
+            whole_chunk_count.times.each {|chunk_index|
+              hash = Digest::SHA256.digest(body.send(slice, start_offset + chunk_index * MEGABYTE, MEGABYTE))
+              update_digest_stack(hash, part_stack)
+              update_digest_stack(hash, @digest_stack)
+            }
+            rest_size = body_size - start_offset - whole_chunk_count * MEGABYTE
+            if rest_size > 0 || whole_chunk_count == 0
+              @last_chunk_hash = Digest::SHA256.new
+              @last_chunk_length = rest_size
+              @last_chunk_hash.update(body.send(slice, start_offset + whole_chunk_count * MEGABYTE, rest_size))
+              hash = @last_chunk_hash.digest
+              @last_chunk_digest_temp = hash
+              part_temp = hash
+            end
+          }
+          reduce_digest_stack(part_temp, part_stack)
         end
 
         def digest
-          reduce_digests(@digests)
+          reduce_digest_stack(@last_chunk_digest_temp, @digest_stack)
+        end
+
+        def hexdigest
+          digest.unpack('H*').first
         end
       end
 

data/lib/fog/aws/iam.rb

@@ -10,7 +10,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, :instrumentor, :instrumentor_name, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at, :region
+      recognizes :host, :path, :port, :scheme, :persistent, :instrumentor, :instrumentor_name, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at, :region, :sts_endpoint
 
       request_path 'fog/aws/requests/iam'
       request :add_user_to_group

data/lib/fog/aws/kinesis.rb

@@ -12,7 +12,7 @@ module Fog
       class ProvisionedThroughputExceeded < Fog::Errors::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :instrumentor, :instrumentor_name, :sts_endpoint
 
       request_path 'fog/aws/requests/kinesis'
 
@@ -125,23 +125,26 @@ module Fog
       end
 
       class Mock
-        def self.mutex
-          @mutex ||= Mutex.new
-        end
-        def mutex; self.class.mutex; end
+        @mutex = Mutex.new
 
         def self.data
-          @data ||= Hash.new do |hash, region|
-            hash[region] = Hash.new do |region_hash, key|
-              region_hash[key] = {
-                :kinesis_streams => {}
-              }
+          @mutex.synchronize do
+            @data ||= Hash.new do |hash, region|
+              hash[region] = Hash.new do |region_hash, key|
+                region_hash[key] = {
+                  :kinesis_streams => {}
+                }
+              end
             end
+            
+            yield @data if block_given?
           end
         end
 
         def self.reset
-          @data = nil
+          @mutex.synchronize do
+            @data = nil
+          end
         end
 
         def initialize(options={})
@@ -153,31 +156,36 @@ module Fog
         end
 
         def data
-          self.class.data[@region][@aws_access_key_id]
+          self.class.data do |data|
+            data[@region][@aws_access_key_id]
+          end
         end
 
         def reset_data
-          self.class.data[@region].delete(@aws_access_key_id)
+          self.class.data do |data|
+            data[@region].delete(@aws_access_key_id)
+          end
         end
 
         def self.next_sequence_number
-          mutex.synchronize do
+          @mutex.synchronize do
             @sequence_number ||= -1
             @sequence_number += 1
             @sequence_number.to_s
           end
         end
+        
         def next_sequence_number; self.class.next_sequence_number; end
 
         def self.next_shard_id
-          mutex.synchronize do
+          @mutex.synchronize do
             @shard_id ||= -1
             @shard_id += 1
             "shardId-#{@shard_id.to_s.rjust(12, "0")}"
           end
         end
+        
         def next_shard_id; self.class.next_shard_id; end
-
       end
 
     end

data/lib/fog/aws/kms.rb

@@ -14,7 +14,7 @@ module Fog
       NotFoundException                = Class.new(Fog::Errors::Error)
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :instrumentor, :instrumentor_name
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :instrumentor, :instrumentor_name, :aws_credentials_expire_at, :sts_endpoint
 
       request_path 'fog/aws/requests/kms'
       request :list_keys

data/lib/fog/aws/lambda.rb

@@ -4,7 +4,7 @@ module Fog
       extend Fog::AWS::CredentialFetcher::ServiceMethods
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent, :region, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :version, :instrumentor, :instrumentor_name
+      recognizes :host, :path, :port, :scheme, :persistent, :region, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :version, :instrumentor, :instrumentor_name, :sts_endpoint
 
       request_path 'fog/aws/requests/lambda'
       request :create_function

data/lib/fog/aws/mock.rb

@@ -145,6 +145,9 @@ module Fog
       def self.zone_id
         "zone-#{Fog::Mock.random_hex(8)}"
       end
+      def self.route_table_id
+        "rtb-#{Fog::Mock.random_hex(8)}"
+      end
       def self.change_id
         Fog::Mock.random_letters_and_numbers(14)
       end
@@ -181,6 +184,11 @@ module Fog
           'SUSE Linux'
         ]
       end
+
+      def self.default_vpc_for(region)
+        @default_vpcs ||= {}
+        @default_vpcs[region] ||= vpc_id
+      end
     end
   end
 end

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

@@ -99,6 +99,16 @@ module Fog
           reload
         end
 
+        def set_instance_protection(instance_ids, protected_from_scale_in)
+          requires :id
+          service.set_instance_protection(
+            id,
+            'InstanceIds' => instance_ids,
+            'ProtectedFromScaleIn' => protected_from_scale_in
+          )
+          reload
+        end
+
         def instances
           Fog::AWS::AutoScaling::Instances.new(:service => service).load(attributes[:instances])
         end

data/lib/fog/aws/models/cdn/distribution.rb

@@ -2,10 +2,10 @@ require 'fog/aws/models/cdn/invalidations'
 require 'fog/aws/models/cdn/distribution_helper'
 
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       class Distribution < Fog::Model
-        include Fog::CDN::AWS::DistributionHelper
+        include Fog::AWS::CDN::DistributionHelper
 
         identity :id,                 :aliases => 'Id'
 
@@ -33,7 +33,7 @@ module Fog
 
         def invalidations
           @invalidations ||= begin
-            Fog::CDN::AWS::Invalidations.new(
+            Fog::AWS::CDN::Invalidations.new(
               :distribution => self,
               :service => service
             )

data/lib/fog/aws/models/cdn/distribution_helper.rb

@@ -1,6 +1,6 @@
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       module DistributionHelper
         def destroy
           requires :identity, :etag, :caller_reference

data/lib/fog/aws/models/cdn/distributions.rb

@@ -2,12 +2,12 @@ require 'fog/aws/models/cdn/distribution'
 require 'fog/aws/models/cdn/distributions_helper'
 
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       class Distributions < Fog::Collection
-        include Fog::CDN::AWS::DistributionsHelper
+        include Fog::AWS::CDN::DistributionsHelper
 
-        model Fog::CDN::AWS::Distribution
+        model Fog::AWS::CDN::Distribution
 
         attribute :marker,    :aliases => 'Marker'
         attribute :max_items, :aliases => 'MaxItems'

data/lib/fog/aws/models/cdn/distributions_helper.rb

@@ -1,6 +1,6 @@
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       module DistributionsHelper
 
         def all(options = {})

data/lib/fog/aws/models/cdn/invalidation.rb

@@ -1,6 +1,6 @@
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       class Invalidation < Fog::Model
         identity :id,                :aliases => 'Id'
 

data/lib/fog/aws/models/cdn/invalidations.rb

@@ -1,8 +1,8 @@
 require 'fog/aws/models/cdn/invalidation'
 
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       class Invalidations < Fog::Collection
         attribute :is_truncated,            :aliases => ['IsTruncated']
         attribute :max_items,               :aliases => ['MaxItems']
@@ -11,7 +11,7 @@ module Fog
 
         attribute :distribution
 
-        model Fog::CDN::AWS::Invalidation
+        model Fog::AWS::CDN::Invalidation
 
         def all(options = {})
           requires :distribution

data/lib/fog/aws/models/cdn/streaming_distribution.rb

@@ -2,10 +2,10 @@ require 'fog/aws/models/cdn/invalidations'
 require 'fog/aws/models/cdn/distribution_helper'
 
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       class StreamingDistribution < Fog::Model
-        include Fog::CDN::AWS::DistributionHelper
+        include Fog::AWS::CDN::DistributionHelper
 
         identity :id,                 :aliases => 'Id'
 

data/lib/fog/aws/models/cdn/streaming_distributions.rb

@@ -2,12 +2,12 @@ require 'fog/aws/models/cdn/streaming_distribution'
 require 'fog/aws/models/cdn/distributions_helper'
 
 module Fog
-  module CDN
-    class AWS
+  module AWS
+    class CDN
       class StreamingDistributions < Fog::Collection
-        include Fog::CDN::AWS::DistributionsHelper
+        include Fog::AWS::CDN::DistributionsHelper
 
-        model Fog::CDN::AWS::StreamingDistribution
+        model Fog::AWS::CDN::StreamingDistribution
 
         attribute :marker,    :aliases => 'Marker'
         attribute :max_items, :aliases => 'MaxItems'

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

@@ -1,14 +1,16 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Address < Fog::Model
         identity  :public_ip,                  :aliases => 'publicIp'
 
+        attribute :private_ip_address,         :aliases => 'privateIpAddress'
         attribute :allocation_id,              :aliases => 'allocationId'
         attribute :association_id,             :aliases => 'associationId'
         attribute :server_id,                  :aliases => 'instanceId'
         attribute :network_interface_id,       :aliases => 'networkInterfaceId'
         attribute :network_interface_owner_id, :aliases => 'networkInterfaceOwnerId'
+        attribute :tags,                       :aliases => 'tagSet'
         attribute :domain
 
         def initialize(attributes = {})

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

@@ -1,13 +1,13 @@
 require 'fog/aws/models/compute/address'
 
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Addresses < Fog::Collection
         attribute :filters
         attribute :server
 
-        model Fog::Compute::AWS::Address
+        model Fog::AWS::Compute::Address
 
         # Used to create an IP address
         #

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class DhcpOption < Fog::Model
         identity  :id,                          :aliases => 'dhcpOptionsId'
         attribute :dhcp_configuration_set,      :aliases => 'dhcpConfigurationSet'
@@ -10,7 +10,7 @@ module Fog
           super
         end
 
-        # Associates an existing dhcp configration set with a VPC
+        # Associates an existing dhcp configuration set with a VPC
         #
         # dhcp_option.attach(dopt-id, vpc-id)
         #

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

@@ -1,12 +1,12 @@
 require 'fog/aws/models/compute/dhcp_option'
 
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class DhcpOptions < Fog::Collection
         attribute :filters
 
-        model Fog::Compute::AWS::DhcpOption
+        model Fog::AWS::Compute::DhcpOption
 
         # Creates a new dhcp option
         #
@@ -17,7 +17,7 @@ module Fog
         # Returns the details of the new DHCP options
         #
         #>> AWS.dhcp_options.new
-        #=>   <Fog::Compute::AWS::DhcpOption
+        #=>   <Fog::AWS::Compute::DhcpOption
         #id=nil,
         #dhcp_configuration_set=nil,
         #tag_set=nil
@@ -38,10 +38,10 @@ module Fog
         # Returns an array of all DhcpOptions
         #
         #>> AWS.dhcp_options.all
-        #<Fog::Compute::AWS::DhcpOptions
+        #<Fog::AWS::Compute::DhcpOptions
         #filters={}
         #[
-        #<Fog::Compute::AWS::DhcpOption
+        #<Fog::AWS::Compute::DhcpOption
         #id="dopt-some-id",
         #dhcp_configuration_set={"vpcId"=>"vpc-some-id", "state"=>"available"},
         #tag_set={}
@@ -68,7 +68,7 @@ module Fog
         # ==== Returns
         #
         #>> AWS.dhcp_options.get("dopt-12345678")
-        #=>   <Fog::Compute::AWS::DhcpOption
+        #=>   <Fog::AWS::Compute::DhcpOption
         #id="dopt-12345678",
         #dhcp_configuration_set={"vpcId"=>"vpc-12345678", "state"=>"available"},
         #tag_set={}

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

@@ -1,6 +1,6 @@
 module Fog
-  module Compute
-    class AWS
+  module AWS
+    class Compute
       class Flavor < Fog::Model
         identity :id