brightbox-cli 0.17.1 → 0.17.2

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_instances.rb

@@ -33,8 +33,63 @@ module Fog
       class Mock
 
         def describe_db_instances(identifier=nil, opts={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          server_set = []
+          if identifier   
+            if server = self.data[:servers][identifier]
+              server_set << server
+            else
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
+            end
+          else
+            server_set = self.data[:servers].values
+          end
+          
+          server_set.each do |server|
+             case server["DBInstanceStatus"]
+             when "creating"
+                 if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
+                   region = "us-east-1"
+                   server["DBInstanceStatus"] = "available"
+                   server["AvailabilityZone"] = region + 'a'
+                   server["Endpoint"] = {"Port"=>3306, 
+                                         "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
+                   server["PendingModifiedValues"] = {}
+                 end
+              when "rebooting" # I don't know how to show rebooting just once before it changes to available
+                # it applies pending modified values
+                if server["PendingModifiedValues"]
+                  server.merge!(server["PendingModifiedValues"])
+                  server["PendingModifiedValues"] = {}
+                  self.data[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                  if self.data[:tmp] <= Time.now
+                    server["DBInstanceStatus"] = 'available'
+                    self.data.delete(:tmp)
+                  end
+                end
+              when "modifying"
+                # TODO there are some fields that only applied after rebooting
+                if server["PendingModifiedValues"]
+                  server.merge!(server["PendingModifiedValues"])
+                  server["PendingModifiedValues"] = {}
+                  server["DBInstanceStatus"] = 'available'
+                end
+              when "available" # I'm not sure if amazon does this
+                if server["PendingModifiedValues"]
+                  server["DBInstanceStatus"] = 'modifying'
+                end
+                  
+             end 
+          end
+          
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBInstancesResult" => { "DBInstances" => server_set }
+          }
+          response
         end
+        
 
       end
     end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_reserved_instances.rb

@@ -32,7 +32,7 @@ module Fog
 
       class Mock
 
-        def describe_db_instances(identifier=nil, opts={})
+        def describe_db_reserved_instances(identifier=nil, opts={})
           Fog::Mock.not_implemented
         end
 

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/describe_db_security_groups.rb

@@ -28,8 +28,50 @@ module Fog
 
       class Mock
 
-        def describe_db_security_group(opts={})
-          Fog::Mock.not_implemented
+        def describe_db_security_groups(opts={})          
+          response = Excon::Response.new
+          sec_group_set = []
+          if opts.is_a?(String)
+            sec_group_name = opts   
+            if sec_group = self.data[:security_groups][sec_group_name]
+              sec_group_set << sec_group
+            else
+              raise Fog::AWS::RDS::NotFound.new("Security Group #{sec_group_name} not found")
+            end
+          else
+            sec_group_set = self.data[:security_groups].values
+          end
+          
+          sec_group_set.each do |sec_group|
+            sec_group["IPRanges"].each do |iprange|
+              if iprange["Status"] == "authorizing" || iprange["Status"] == "revoking"
+                iprange[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                if iprange[:tmp] <= Time.now
+                  iprange["Status"] = "authorized" if iprange["Status"] == "authorizing"
+                  iprange.delete(:tmp)
+                  sec_group["IPRanges"].delete(iprange) if iprange["Status"] == "revoking"
+                end
+              end
+            end
+            
+            sec_group["EC2SecurityGroups"].each do |ec2_secg|
+              if ec2_secg["Status"] == "authorizing" || iprange["Status"] == "revoking"
+                ec2_secg[:tmp] ||= Time.now + Fog::Mock.delay * 2
+                if ec2_secg[:tmp] <= Time.now
+                  ec2_secg["Status"] = "authorized" if ec2_secg["Status"] == "authorizing"
+                  ec2_secg.delete(:tmp)
+                  sec_group["EC2SecurityGroups"].delete(ec2_secg) if ec2_secg["Status"] == "revoking"
+                end
+              end
+            end
+          end
+          
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeDBSecurityGroupsResult" => { "DBSecurityGroups" => sec_group_set }
+          }
+          response
         end
 
       end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/modify_db_instance.rb

@@ -45,7 +45,32 @@ module Fog
       class Mock
 
         def modify_db_instance(db_name, apply_immediately, options={})
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          if self.data[:servers][db_name]
+            if self.data[:servers][db_name]["DBInstanceStatus"] != "available"
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
+            else
+              # TODO verify the params options
+              # if apply_immediately is false, all the options go to pending_modified_values and then apply and clear after either 
+              # a reboot or the maintainance window
+              #if apply_immediately
+              #  modified_server = server.merge(options)
+              #else
+              #  modified_server = server["PendingModifiedValues"].merge!(options) # it appends
+              #end
+              self.data[:servers][db_name]["PendingModifiedValues"].merge!(options) # it appends
+              #self.data[:servers][db_name]["DBInstanceStatus"] = "modifying"
+              response.status = 200
+              response.body = {
+                "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+                "ModifyDBInstanceResult" => { "DBInstance" => self.data[:servers][db_name] }
+              }
+              response
+              
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
+          end
         end
 
       end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/reboot_db_instance.rb

@@ -25,7 +25,23 @@ module Fog
       class Mock
 
         def reboot_db_instance(instance_identifier)
-          Fog::Mock.not_implemented
+          response = Excon::Response.new
+          if self.data[:servers][instance_identifier]
+            if self.data[:servers][instance_identifier]["DBInstanceStatus"] != "available"
+              raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not available for rebooting")
+            else
+              self.data[:servers][instance_identifier]["DBInstanceStatus"] = 'rebooting'
+              response.status = 200
+              response.body = {
+                "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+                "RebootDBInstanceResult" => { "DBInstance" => self.data[:servers][instance_identifier] }
+              }
+              response
+              
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not found")
+          end
         end
 
       end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/rds/revoke_db_security_group_ingress.rb

@@ -33,7 +33,33 @@ module Fog
       class Mock
 
         def revoke_db_security_group_ingress(name, opts = {})
-          Fog::Mock.not_implemented
+          unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
+            raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
+          end
+          
+          response = Excon::Response.new
+          
+          if sec_group = self.data[:security_groups][name]
+            if opts.key?('CIDRIP')
+              sec_group['IPRanges'].each do |iprange|
+                iprange['Status']= 'revoking' if iprange['CIDRIP'] == opts['CIDRIP']
+              end
+            else
+              sec_group['EC2SecurityGroups'].each do |ec2_secg|
+                ec2_secg['Status']= 'revoking' if ec2_secg['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']
+              end
+            end
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
+              'RevokeDBSecurityGroupIngressResult' => {          
+                'DBSecurityGroup' => sec_group
+              }
+            }
+            response
+          else
+            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
+          end
         end
 
       end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/sqs/change_message_visibility.rb

@@ -34,7 +34,7 @@ module Fog
           Excon::Response.new.tap do |response|
             if (queue = data[:queues][queue_url])
               message_id, _ = queue[:receipt_handles].find { |message_id, receipts|
-                receipts.keys.include?(receipt_handle)
+                receipts.has_key?(receipt_handle)
               }
               
               if message_id

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/sqs/delete_message.rb

@@ -32,7 +32,7 @@ module Fog
           Excon::Response.new.tap do |response|
             if (queue = data[:queues][queue_url])
               message_id, _ = queue[:receipt_handles].find { |msg_id, receipts|
-                receipts.keys.include?(receipt_handle)
+                receipts.has_key?(receipt_handle)
               }
 
               if message_id

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/sqs/receive_message.rb

@@ -37,37 +37,36 @@ module Fog
               max_number_of_messages = options['MaxNumberOfMessages'] || 1
               now = Time.now
               
-              keys = queue[:messages].keys[0, max_number_of_messages]
-              
-              messages = queue[:messages].values_at(*keys).map do |m|
+              messages = []
+
+              queue[:messages].values.each do |m|
                 message_id = m['MessageId']
-                
+
                 invisible = if (received_handles = queue[:receipt_handles][message_id])
                   visibility_timeout = m['Attributes']['VisibilityTimeout'] || queue['Attributes']['VisibilityTimeout']
                   received_handles.any? { |handle, time| now < time + visibility_timeout }
                 else
                   false
                 end
-                
-                if invisible
-                  nil
-                else
+
+                unless invisible
                   receipt_handle = Fog::Mock.random_base64(300)
-                  
+
                   queue[:receipt_handles][message_id] ||= {}
                   queue[:receipt_handles][message_id][receipt_handle] = now
-                  
+
                   m['Attributes'].tap do |attrs|
                     attrs['ApproximateFirstReceiveTimestamp'] ||= now
                     attrs['ApproximateReceiveCount'] = (attrs['ApproximateReceiveCount'] || 0) + 1
                   end
-                  
-                  m.merge({
+
+                  messages << m.merge({
                     'ReceiptHandle' => receipt_handle
                   })
+                  break if messages.size >= max_number_of_messages
                 end
-              end.compact
-              
+              end
+
               response.body = {
                 'ResponseMetadata' => {
                   'RequestId' => Fog::AWS::Mock.request_id

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/storage/copy_object.rb

@@ -48,19 +48,27 @@ module Fog
         def copy_object(source_bucket_name, source_object_name, target_bucket_name, target_object_name, options = {})
           response = Excon::Response.new
           source_bucket = self.data[:buckets][source_bucket_name]
-          source_object = source_bucket && source_bucket[:objects][source_object_name]
+          source_object = source_bucket && source_bucket[:objects][source_object_name] && source_bucket[:objects][source_object_name].first
           target_bucket = self.data[:buckets][target_bucket_name]
 
+          acl = options['x-amz-acl'] || 'private'
+          if !['private', 'public-read', 'public-read-write', 'authenticated-read'].include?(acl)
+            raise Excon::Errors::BadRequest.new('invalid x-amz-acl')
+          else
+            self.data[:acls][:object][target_bucket_name] ||= {}
+            self.data[:acls][:object][target_bucket_name][target_object_name] = self.class.acls(acl)
+          end
+
           if source_object && target_bucket
             response.status = 200
             target_object = source_object.dup
-            target_object.merge!({
-              'Key' => target_object_name
-            })
+            target_object.each do |version|
+              version.merge!({'Key' => target_object_name})
+            end
             target_bucket[:objects][target_object_name] = target_object
             response.body = {
-              'ETag'          => target_object['ETag'],
-              'LastModified'  => Time.parse(target_object['Last-Modified'])
+              'ETag'          => target_object.last['ETag'],
+              'LastModified'  => Time.parse(target_object.last['Last-Modified'])
             }
           else
             response.status = 404

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/storage/delete_object.rb

@@ -17,6 +17,12 @@ module Fog
         # http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectDELETE.html
 
         def delete_object(bucket_name, object_name, options = {})
+          if version_id = options.delete('versionId')
+            path = "#{CGI.escape(object_name)}?versionId=#{CGI.escape(version_id)}"
+          else
+            path = CGI.escape(object_name)
+          end
+
           headers = options
           request({
             :expects    => 204,
@@ -24,7 +30,7 @@ module Fog
             :host       => "#{bucket_name}.#{@host}",
             :idempotent => true,
             :method     => 'DELETE',
-            :path       => CGI.escape(object_name)
+            :path       => path
           })
         end
 
@@ -36,7 +42,57 @@ module Fog
           response = Excon::Response.new
           if bucket = self.data[:buckets][bucket_name]
             response.status = 204
-            bucket[:objects].delete(object_name)
+
+            version_id = options.delete('versionId')
+
+            if bucket[:versioning]
+              bucket[:objects][object_name] ||= []
+
+              if version_id
+                version = bucket[:objects][object_name].find { |object| object['VersionId'] == version_id}
+
+                # S3 special cases the 'null' value to not error out if no such version exists.
+                if version || (version_id == 'null')
+                  bucket[:objects][object_name].delete(version)
+                  bucket[:objects].delete(object_name) if bucket[:objects][object_name].empty?
+
+                  response.headers['x-amz-delete-marker'] = 'true' if version[:delete_marker]
+                  response.headers['x-amz-version-id'] = version_id
+                else
+                  response.status = 400
+                  response.body = invalid_version_id_payload(version_id)
+                  raise(Excon::Errors.status_error({:expects => 200}, response))
+                end
+              else
+                delete_marker = {
+                  :delete_marker    => true,
+                  'Key'             => object_name,
+                  'VersionId'       => bucket[:versioning] == 'Enabled' ? Fog::Mock.random_base64(32) : 'null',
+                  'Last-Modified'   => Fog::Time.now.to_date_header
+                }
+
+                # When versioning is suspended, a delete marker is placed if the last object ID is not the value 'null',
+                # otherwise the last object is replaced.
+                if bucket[:versioning] == 'Suspended' && bucket[:objects][object_name].first['VersionId'] == 'null'
+                  bucket[:objects][object_name].shift
+                end
+
+                bucket[:objects][object_name].unshift(delete_marker)
+
+                response.headers['x-amz-delete-marker'] = 'true'
+                response.headers['x-amz-version-id'] = delete_marker['VersionId']
+              end
+            else
+              if version_id && version_id != 'null'
+                response.status = 400
+                response.body = invalid_version_id_payload(version_id)
+                raise(Excon::Errors.status_error({:expects => 200}, response))
+              else
+                bucket[:objects].delete(object_name)
+
+                response.headers['x-amz-version-id'] = 'null'
+              end
+            end
           else
             response.status = 404
             raise(Excon::Errors.status_error({:expects => 204}, response))
@@ -44,6 +100,21 @@ module Fog
           response
         end
 
+        private
+
+        def invalid_version_id_payload(version_id)
+          {
+            'Error' => {
+              'Code' => 'InvalidArgument',
+              'Message' => 'Invalid version id specified',
+              'ArgumentValue' => version_id,
+              'ArgumentName' => 'versionId',
+              'RequestId' => Fog::Mock.random_hex(16),
+              'HostId' => Fog::Mock.random_base64(65)
+            }
+          }
+        end
+
       end
     end
   end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/requests/storage/get_bucket.rb

@@ -69,11 +69,12 @@ module Fog
           end
           response = Excon::Response.new
           if bucket = self.data[:buckets][bucket_name]
-            contents = bucket[:objects].values.sort {|x,y| x['Key'] <=> y['Key']}.reject do |object|
+            contents = bucket[:objects].values.collect(&:last).sort {|x,y| x['Key'] <=> y['Key']}.reject do |object|
                 (prefix    && object['Key'][0...prefix.length] != prefix) ||
                 (marker    && object['Key'] <= marker) ||
                 (delimiter && object['Key'][(prefix ? prefix.length : 0)..-1].include?(delimiter) \
-                           && common_prefixes << object['Key'].sub(/^(#{prefix}[^#{delimiter}]+.).*/, '\1'))
+                           && common_prefixes << object['Key'].sub(/^(#{prefix}[^#{delimiter}]+.).*/, '\1')) ||
+                object.has_key?(:delete_marker)
               end.map do |object|
                 data = object.reject {|key, value| !['ETag', 'Key', 'StorageClass'].include?(key)}
                 data.merge!({