aws-sdk-glacier 1.0.0.rc1

data/lib/aws-sdk-glacier/notification.rb

@@ -0,0 +1,179 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing for info on making contributions:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws
+  module Glacier
+    class Notification
+
+      extend Aws::Deprecations
+
+      # @overload def initialize(account_id, vault_name, options = {})
+      #   @param [String] account_id
+      #   @param [String] vault_name
+      #   @option options [Client] :client
+      # @overload def initialize(options = {})
+      #   @option options [required, String] :account_id
+      #   @option options [required, String] :vault_name
+      #   @option options [Client] :client
+      def initialize(*args)
+        options = Hash === args.last ? args.pop.dup : {}
+        @account_id = extract_account_id(args, options)
+        @vault_name = extract_vault_name(args, options)
+        @data = options.delete(:data)
+        @client = options.delete(:client) || Client.new(options)
+      end
+
+      # @!group Read-Only Attributes
+
+      # @return [String]
+      def account_id
+        @account_id
+      end
+
+      # @return [String]
+      def vault_name
+        @vault_name
+      end
+
+      # The Amazon Simple Notification Service (Amazon SNS) topic Amazon
+      # Resource Name (ARN).
+      # @return [String]
+      def sns_topic
+        data.sns_topic
+      end
+
+      # A list of one or more events for which Amazon Glacier will send a
+      # notification to the specified Amazon SNS topic.
+      # @return [Array<String>]
+      def events
+        data.events
+      end
+
+      # @!endgroup
+
+      # @return [Client]
+      def client
+        @client
+      end
+
+      # Loads, or reloads {#data} for the current {Notification}.
+      # Returns `self` making it possible to chain methods.
+      #
+      #     notification.reload.data
+      #
+      # @return [self]
+      def load
+        resp = @client.get_vault_notifications(
+          account_id: @account_id,
+          vault_name: @vault_name
+        )
+        @data = resp.vaultnotificationconfig
+        self
+      end
+      alias :reload :load
+
+      # @return [Types::VaultNotificationConfig]
+      #   Returns the data for this {Notification}. Calls
+      #   {Client#get_vault_notifications} if {#data_loaded?} is `false`.
+      def data
+        load unless @data
+        @data
+      end
+
+      # @return [Boolean]
+      #   Returns `true` if this resource is loaded.  Accessing attributes or
+      #   {#data} on an unloaded resource will trigger a call to {#load}.
+      def data_loaded?
+        !!@data
+      end
+
+      # @!group Actions
+
+      # @example Request syntax with placeholder values
+      #
+      #   notification.delete()
+      # @param [Hash] options ({})
+      # @return [EmptyStructure]
+      def delete(options = {})
+        options = options.merge(
+          account_id: @account_id,
+          vault_name: @vault_name
+        )
+        resp = @client.delete_vault_notifications(options)
+        resp.data
+      end
+
+      # @example Request syntax with placeholder values
+      #
+      #   notification.set({
+      #     vault_notification_config: {
+      #       sns_topic: "string",
+      #       events: ["string"],
+      #     },
+      #   })
+      # @param [Hash] options ({})
+      # @option options [Types::VaultNotificationConfig] :vault_notification_config
+      #   Provides options for specifying notification configuration.
+      # @return [EmptyStructure]
+      def set(options = {})
+        options = options.merge(
+          account_id: @account_id,
+          vault_name: @vault_name
+        )
+        resp = @client.set_vault_notifications(options)
+        resp.data
+      end
+
+      # @!group Associations
+
+      # @return [Vault]
+      def vault
+        Vault.new(
+          account_id: @account_id,
+          name: @vault_name,
+          client: @client
+        )
+      end
+
+      # @deprecated
+      # @api private
+      def identifiers
+        {
+          account_id: @account_id,
+          vault_name: @vault_name
+        }
+      end
+      deprecated(:identifiers)
+
+      private
+
+      def extract_account_id(args, options)
+        value = args[0] || options.delete(:account_id)
+        case value
+        when String then value
+        when nil then raise ArgumentError, "missing required option :account_id"
+        else
+          msg = "expected :account_id to be a String, got #{value.class}"
+          raise ArgumentError, msg
+        end
+      end
+
+      def extract_vault_name(args, options)
+        value = args[1] || options.delete(:vault_name)
+        case value
+        when String then value
+        when nil then raise ArgumentError, "missing required option :vault_name"
+        else
+          msg = "expected :vault_name to be a String, got #{value.class}"
+          raise ArgumentError, msg
+        end
+      end
+
+      class Collection < Aws::Resources::Collection; end
+    end
+  end
+end

data/lib/aws-sdk-glacier/plugins/account_id.rb

@@ -0,0 +1,22 @@
+module Aws
+  module Glacier
+    module Plugins
+      class AccountId < Seahorse::Client::Plugin
+
+        option(:account_id,
+          default: '-',
+          doc_type: String,
+          docstring: <<-DOCS)
+The default Glacier AWS account ID to use for all glacier
+operations. The default value of `-` uses the account
+your `:credentials` belong to.
+          DOCS
+
+        handle_request(step: :initialize) do |context|
+          context.params[:account_id] ||= context.config.account_id
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-glacier/plugins/api_version.rb

@@ -0,0 +1,22 @@
+module Aws
+  module Glacier
+    module Plugins
+      # @api private
+      class ApiVersion < Seahorse::Client::Plugin
+
+        class Handler < Seahorse::Client::Handler
+
+          def call(context)
+            version = context.config.api.version
+            context.http_request.headers['x-amz-glacier-version'] = version
+            @handler.call(context)
+          end
+
+        end
+
+        handler(Handler)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-glacier/plugins/checksums.rb

@@ -0,0 +1,91 @@
+require_relative '../tree_hash'
+require 'openssl'
+
+module Aws
+  module Glacier
+    module Plugins
+      # Computes the `:checksum` of the HTTP request body for operations
+      # that require the `X-Amz-Sha256-Tree-Hash` header.  This includes:
+      #
+      # * `:complete_multipart_upload`
+      # * `:upload_archive`
+      # * `:upload_multipart_part`
+      #
+      # The `:upload_archive` and `:upload_multipart_part` operations
+      # accept a `:checksum` request parameter.  If this param
+      # is present, then the checksum is assumed to be the proper
+      # tree hash of the file to be uploaded.  If this param is
+      # not present, then the required tree hash checksum will
+      # be generated.
+      #
+      # The `:complete_multipart_upload` operation does not accept
+      # a checksum and this plugin will always compute this of the
+      # HTTP request body on your behalf.
+      #
+      # @api private
+      class Checksums < Seahorse::Client::Plugin
+
+        CHECKSUM_OPERATIONS = [
+          :upload_archive,
+          :upload_multipart_part,
+        ]
+
+        class Handler < Seahorse::Client::Handler
+
+          HASH = 'X-Amz-Content-Sha256'
+
+          TREE_HASH = 'X-Amz-Sha256-Tree-Hash'
+
+          def call(context)
+            unless context.http_request.headers[TREE_HASH]
+              populate_checksum_headers(context)
+            end
+            @handler.call(context)
+          end
+
+          private
+
+          def populate_checksum_headers(context)
+            compute_checksums(context.http_request.body) do |hash, tree_hash|
+              context.http_request.headers[HASH] = hash
+              context.http_request.headers[TREE_HASH] = tree_hash.digest
+              context[:tree_hash] = tree_hash
+            end
+          end
+
+          # Computes two checksums of the body.  The tree hash is required
+          # by Glacier for operations where you upload a file.  The other
+          # checksum is required by signature version 4.  We compute both
+          # here so the sigv4 signer does not need to re-read the body.
+          def compute_checksums(body, &block)
+
+            tree_hash = TreeHash.new
+            digest = OpenSSL::Digest.new('sha256')
+
+            # if the body is empty/EOF, then we should compute the
+            # digests of the empty string
+            if body.size == 0
+              tree_hash.update('')
+              digest.update('')
+            end
+
+            # Rewind body before performing checksum computation.
+            body.rewind
+
+            while chunk = body.read(1024 * 1024) # read 1MB
+              tree_hash.update(chunk)
+              digest.update(chunk)
+            end
+            body.rewind
+
+            yield(digest.to_s, tree_hash)
+
+          end
+        end
+
+        handler(Handler, operations: CHECKSUM_OPERATIONS)
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-glacier/resource.rb

@@ -0,0 +1,82 @@
+# WARNING ABOUT GENERATED CODE
+#
+# This file is generated. See the contributing for info on making contributions:
+# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
+#
+# WARNING ABOUT GENERATED CODE
+
+module Aws
+  module Glacier
+    class Resource
+
+      # @param options ({})
+      # @option options [Client] :client
+      def initialize(options = {})
+        @client = options[:client] || Client.new(options)
+      end
+
+      # @return [Client]
+      def client
+        @client
+      end
+
+      # @!group Actions
+
+      # @example Request syntax with placeholder values
+      #
+      #   vault = glacier.create_vault({
+      #     vault_name: "string", # required
+      #   })
+      # @param [Hash] options ({})
+      # @option options [required, String] :vault_name
+      #   The name of the vault.
+      # @return [Vault]
+      def create_vault(options = {})
+        options = options.merge(account_id: "-")
+        resp = @client.create_vault(options)
+        Vault.new(
+          account_id: options[:account_id],
+          name: options[:vault_name],
+          client: @client
+        )
+      end
+
+      # @!group Associations
+
+      # @param [String] id
+      # @return [Account]
+      def account(id)
+        Account.new(
+          id: id,
+          client: @client
+        )
+      end
+
+      # @example Request syntax with placeholder values
+      #
+      #   vaults = glacier.vaults()
+      # @param [Hash] options ({})
+      # @return [Vault::Collection]
+      def vaults(options = {})
+        batches = Enumerator.new do |y|
+          options = options.merge(account_id: "-")
+          resp = @client.list_vaults(options)
+          resp.each_page do |page|
+            batch = []
+            page.data.vault_list.each do |v|
+              batch << Vault.new(
+                account_id: options[:account_id],
+                name: v.vault_name,
+                data: v,
+                client: @client
+              )
+            end
+            y.yield(batch)
+          end
+        end
+        Vault::Collection.new(batches)
+      end
+
+    end
+  end
+end

data/lib/aws-sdk-glacier/tree_hash.rb

@@ -0,0 +1,76 @@
+require 'openssl'
+
+module Aws
+  module Glacier
+    # Used for computing a tree hash SHA256 checksum of an object.
+    #
+    #    tree_hash = TreeHash.new
+    #    tree_hash.update(file.read(1024 * 1024)) until file.eof?
+    #    tree_hash.digest
+    #
+    # == Limitations and Notes
+    #
+    # There are two main limitations to be aware of when using TreeHash:
+    #
+    # * TreeHash is not thread safe. Use multiple TreeHash objects to concurrently
+    #   compute a tree hash of a large object.  Join their hashes at the end into
+    #   a single TreeHash and then call {#digest}
+    #
+    #      TreeHash.new(tree_hashes.map(&:hashes).flatten)
+    #
+    # * You must call {#update} with 1MB chunks of data.  Only the final
+    #   chunk may be smaller than 1MB.
+    #
+    # If you have a large object/file, and you would like to compute the
+    # chunks concurrently, you must break the original file/data into sections
+    # that are evenly divisible by 1MB.  Each section of data requires
+    # a seperate TreeHash object to compute hashes.  Once all sections of
+    # data are complete, you can rejoin their {#hashes} in sequential order
+    # into a single TreeHash, then call {#digest} on the final tree hash.
+    #
+    class TreeHash
+
+      def initialize(hashes = [])
+        @digest = OpenSSL::Digest.new('sha256')
+        @hashes = hashes
+      end
+
+      # @return [Array<String>] The built up list of hashes.  Each hash is
+      #   a sha255 digest of a 1MB chunk.
+      attr_accessor :hashes
+
+      # @param [String] chunk
+      # @return [String] Returns the computed SHA256 digest of the chunk.
+      def update(chunk)
+        @hashes << @digest.update(chunk).digest
+        @digest.reset
+        @hashes.last
+      end
+
+      def digest
+        hashes = @hashes
+        digest = OpenSSL::Digest.new('sha256')
+        until hashes.count == 1
+          hashes = hashes.each_slice(2).map do |h1,h2|
+            digest.reset
+            if h2
+              digest.update(h1)
+              digest.update(h2)
+              digest.digest
+            else
+              h1
+            end
+          end
+        end
+        hashes.first.bytes.map{|x| x.to_i.to_s(16).rjust(2, '0')}.join('')
+      end
+
+    end
+  end
+
+  # For backwards compatability, we are aliasing Aws::Glacier::TreeHash to
+  # Aws::TreeHash. It is no longer vendors in the aws-sdk-core gem, but
+  # users should still be able to use the old constant.
+  # @api private
+  TreeHash = Glacier::TreeHash
+end