fog-internet-archive 0.0.1

data/lib/fog/internet_archive/requests/storage/delete_bucket_policy.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        # Delete policy for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete policy from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEpolicy.html
+
+        def delete_bucket_policy(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :host     => "#{bucket_name}.#{@host}",
+            :method   => 'DELETE',
+            :query    => {'policy' => nil}
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/delete_bucket_website.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        # Delete website configuration for a bucket
+        #
+        # @param bucket_name [String] name of bucket to delete website configuration from
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketDELETEwebsite.html
+
+        def delete_bucket_website(bucket_name)
+          request({
+            :expects  => 204,
+            :headers  => {},
+            :host     => "#{bucket_name}.#{@host}",
+            :method   => 'DELETE',
+            :query    => {'website' => nil}
+          })
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/delete_multiple_objects.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        require 'fog/internet_archive/parsers/storage/delete_multiple_objects'
+
+        # Delete multiple objects from S3
+        # @note For versioned deletes, options should include a version_ids hash, which
+        #     maps from filename to an array of versions.
+        #     The semantics are that for each (object_name, version) tuple, the
+        #     caller must insert the object_name and an associated version (if
+        #     desired), so for n versions, the object must be inserted n times.
+        #
+        # @param bucket_name [String] Name of bucket containing object to delete
+        # @param object_names [Array]  Array of object names to delete
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * DeleteResult [Array]:
+        #       * Deleted [Hash]:
+        #         * Key [String] - Name of the object that was deleted
+        #         * VersionId [String] - ID for the versioned onject in case of a versioned delete
+        #         * DeleteMarker [Boolean] - Indicates if the request accessed a delete marker
+        #         * DeleteMarkerVersionId [String] - Version ID of the delete marker accessed
+        #       * Error [Hash]:
+        #         * Key [String] - Name of the object that failed to be deleted
+        #         * VersionId [String] - ID of the versioned object that was attempted to be deleted
+        #         * Code [String] - Status code for the result of the failed delete
+        #         * Message [String] - Error description
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/multiobjectdeleteapi.html
+
+        def delete_multiple_objects(bucket_name, object_names, options = {})
+          data = "<Delete>"
+          data << "<Quiet>true</Quiet>" if options.delete(:quiet)
+          object_names.each do |object_name|
+            data << "<Object>"
+            data << "<Key>#{CGI.escapeHTML(object_name)}</Key>"
+            data << "</Object>"
+          end
+          data << "</Delete>"
+
+          headers = options
+          headers['Content-Length'] = data.length
+          headers['Content-MD5'] = Base64.encode64(Digest::MD5.digest(data)).
+                                   gsub("\n", '')
+
+          request({
+            :body       => data,
+            :expects    => 200,
+            :headers    => headers,
+            :host       => "#{bucket_name}.#{@host}",
+            :method     => 'POST',
+            :parser     => Fog::Parsers::Storage::InternetArchive::DeleteMultipleObjects.new,
+            :query      => {'delete' => nil}
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def delete_multiple_objects(bucket_name, object_names, options = {})
+          response = Excon::Response.new
+          if bucket = self.data[:buckets][bucket_name]
+            response.status = 200
+            response.body = { 'DeleteResult' => [] }
+            object_names.each do |object_name|
+              response.body['DeleteResult'] << delete_object_helper(bucket,
+                                                                object_name)
+            end
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+        private
+
+        def delete_object_helper(bucket, object_name)
+          response = { 'Deleted' => {} }
+          bucket[:objects].delete(object_name)
+          response['Deleted'] = { 'Key' => object_name }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/delete_object.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        # Delete an object from S3
+        #
+        # @param bucket_name [String] Name of bucket containing object to delete
+        # @param object_name [String] Name of object to delete
+        #
+        # @return [Excon::Response] response:
+        #   * status [Integer] - 204
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTObjectDELETE.html
+
+        def delete_object(bucket_name, object_name, options = {})
+          path = CGI.escape(object_name)
+
+          headers = options
+          request({
+            :expects    => 204,
+            :headers    => headers,
+            :host       => "#{bucket_name}.#{@host}",
+            :idempotent => true,
+            :method     => 'DELETE',
+            :path       => path
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def delete_object(bucket_name, object_name, options = {})
+          response = Excon::Response.new
+          if bucket = self.data[:buckets][bucket_name]
+            response.status = 204
+
+            bucket[:objects].delete(object_name)
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 204}, response))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/get_bucket.rb

@@ -0,0 +1,108 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        require 'fog/internet_archive/parsers/storage/get_bucket'
+
+        # List information about objects in an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to list object keys from
+        # @param options [Hash] config arguments for list.  Defaults to {}.
+        # @option options delimiter [String] causes keys with the same string between the prefix
+        #     value and the first occurence of delimiter to be rolled up
+        # @option options marker [String] limits object keys to only those that appear
+        #     lexicographically after its value.
+        # @option options max-keys [Integer] limits number of object keys returned
+        # @option options prefix [String] limits object keys to those beginning with its value.
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * Delimeter [String] - Delimiter specified for query
+        #     * IsTruncated [Boolean] - Whether or not the listing is truncated
+        #     * Marker [String]- Marker specified for query
+        #     * MaxKeys [Integer] - Maximum number of keys specified for query
+        #     * Name [String] - Name of the bucket
+        #     * Prefix [String] - Prefix specified for query
+        #     * CommonPrefixes [Array] - Array of strings for common prefixes
+        #     * Contents [Array]:
+        #       * ETag [String] - Etag of object
+        #       * Key [String] - Name of object
+        #       * LastModified [String] - Timestamp of last modification of object
+        #       * Owner [Hash]:
+        #         * DisplayName [String] - Display name of object owner
+        #         * ID [String] - Id of object owner
+        #       * Size [Integer] - Size of object
+        #       * StorageClass [String] - Storage class of object
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGET.html
+
+        def get_bucket(bucket_name, options = {})
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          request({
+            :expects  => 200,
+            :headers  => {},
+            :host     => "#{bucket_name}.#{@host}",
+            :idempotent => true,
+            :method   => 'GET',
+            :parser   => Fog::Parsers::Storage::InternetArchive::GetBucket.new,
+            :query    => options
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        def get_bucket(bucket_name, options = {})
+          prefix, marker, delimiter, max_keys = \
+            options['prefix'], options['marker'], options['delimiter'], options['max-keys']
+          common_prefixes = []
+
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          response = Excon::Response.new
+          if bucket = self.data[:buckets][bucket_name]
+            contents = bucket[:objects].values.map(&:first).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')) ||
+                object.key?(:delete_marker)
+              end.map do |object|
+                data = object.reject {|key, value| !['ETag', 'Key', 'StorageClass'].include?(key)}
+                data.merge!({
+                  'LastModified' => Time.parse(object['Last-Modified']),
+                  'Owner'        => bucket['Owner'],
+                  'Size'         => object['Content-Length'].to_i
+                })
+              data
+            end
+            max_keys = max_keys || 1000
+            size = [max_keys, 1000].min
+            truncated_contents = contents[0...size]
+
+            response.status = 200
+            response.body = {
+              'CommonPrefixes'  => common_prefixes.uniq,
+              'Contents'        => truncated_contents,
+              'IsTruncated'     => truncated_contents.size != contents.size,
+              'Marker'          => marker,
+              'MaxKeys'         => max_keys,
+              'Name'            => bucket['Name'],
+              'Prefix'          => prefix
+            }
+            if max_keys && max_keys < response.body['Contents'].length
+                response.body['IsTruncated'] = true
+                response.body['Contents'] = response.body['Contents'][0...max_keys]
+            end
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/get_bucket_acl.rb

@@ -0,0 +1,65 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        require 'fog/internet_archive/parsers/storage/access_control_list'
+
+        # Get access control list for an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to get access control list for
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * AccessControlPolicy [Hash]:
+        #       * Owner [Hash]:
+        #         * DisplayName [String] - Display name of object owner
+        #         * ID [String] - Id of object owner
+        #       * AccessControlList [Array]:
+        #         * Grant [Hash]:
+        #           * Grantee [Hash]:
+        #             * DisplayName [String] - Display name of grantee
+        #             * ID [String] - Id of grantee
+        #             or
+        #             * URI [String] - URI of group to grant access for
+        #           * Permission [String] - Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETacl.html
+
+        def get_bucket_acl(bucket_name)
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          request({
+            :expects    => 200,
+            :headers    => {},
+            :host       => "#{bucket_name}.#{@host}",
+            :idempotent => true,
+            :method     => 'GET',
+            :parser     => Fog::Parsers::Storage::InternetArchive::AccessControlList.new,
+            :query      => {'acl' => nil}
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        require 'fog/internet_archive/requests/storage/acl_utils'
+
+        def get_bucket_acl(bucket_name)
+          response = Excon::Response.new
+          if acl = self.data[:acls][:bucket][bucket_name]
+            response.status = 200
+            if acl.is_a?(String)
+              response.body = Fog::Storage::InternetArchive.acl_to_hash(acl)
+            else
+              response.body = acl
+            end
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/get_bucket_cors.rb

@@ -0,0 +1,61 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        require 'fog/internet_archive/parsers/storage/cors_configuration'
+
+        # Gets the CORS configuration for an S3 bucket
+        #
+        # @param bucket_name [String] name of bucket to get access control list for
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * CORSConfiguration [Array]:
+        #       * CORSRule [Hash]:
+        #         * AllowedHeader [String] - Which headers are allowed in a pre-flight OPTIONS request through the Access-Control-Request-Headers header.
+        #         * AllowedMethod [String] - Identifies an HTTP method that the domain/origin specified in the rule is allowed to execute.
+        #         * AllowedOrigin [String] - One or more response headers that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
+        #         * ExposeHeader [String] - One or more headers in the response that you want customers to be able to access from their applications (for example, from a JavaScript XMLHttpRequest object).
+        #         * ID [String] - An optional unique identifier for the rule. The ID value can be up to 255 characters long. The IDs help you find a rule in the configuration.
+        #         * MaxAgeSeconds [Integer] - The time in seconds that your browser is to cache the preflight response for the specified resource.
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETcors.html
+
+        def get_bucket_cors(bucket_name)
+          unless bucket_name
+            raise ArgumentError.new('bucket_name is required')
+          end
+          request({
+            :expects    => 200,
+            :headers    => {},
+            :host       => "#{bucket_name}.#{@host}",
+            :idempotent => true,
+            :method     => 'GET',
+            :parser     => Fog::Parsers::Storage::InternetArchive::CorsConfiguration.new,
+            :query      => {'cors' => nil}
+          })
+        end
+      end
+
+      class Mock # :nodoc:all
+        require 'fog/internet_archive/requests/storage/cors_utils'
+
+        def get_bucket_cors(bucket_name)
+          response = Excon::Response.new
+          if cors = self.data[:cors][:bucket][bucket_name]
+            response.status = 200
+            if cors.is_a?(String)
+              response.body = Fog::Storage::InternetArchive.cors_to_hash(cors)
+            else
+              response.body = cors
+            end
+          else
+            response.status = 404
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/internet_archive/requests/storage/get_bucket_lifecycle.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Storage
+    class InternetArchive
+      class Real
+        require 'fog/internet_archive/parsers/storage/get_bucket_lifecycle'
+
+        # Get bucket lifecycle configuration
+        #
+        # @param bucket_name [String] name of bucket to get lifecycle configuration for
+        #
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * Rules - object expire rules [Array]:
+        #       * ID [String] - Unique identifier for the rule
+        #       * Prefix [String] - Prefix identifying one or more objects to which the rule applies
+        #       * Enabled [Boolean] - if rule is currently being applied
+        #       * Days [Integer] - lifetime, in days, of the objects that are subject to the rule
+        #
+        # @see http://docs.amazonwebservices.com/AmazonS3/latest/API/RESTBucketGETlifecycle.html
+
+        def get_bucket_lifecycle(bucket_name)
+          request({
+                    :expects  => 200,
+                    :headers  => {},
+                    :host     => "#{bucket_name}.#{@host}",
+                    :idempotent => true,
+                    :method   => 'GET',
+                    :parser   => Fog::Parsers::Storage::InternetArchive::GetBucketLifecycle.new,
+                    :query    => {'lifecycle' => nil}
+                  })
+        end
+      end
+    end
+  end
+end