fog-brightbox 0.3.0 → 0.4.0

data/lib/fog/brightbox/requests/storage/put_container.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Create a new container
+        #
+        # ==== Parameters
+        # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        #
+        def put_container(name, options = {})
+          headers = options[:headers] || {}
+          headers['X-Container-Read'] ||= options.delete(:read_permissions)
+          headers['X-Container-Write'] ||= options.delete(:write_permissions)
+
+          request(
+            :expects  => [201, 202],
+            :method   => 'PUT',
+            :path     => Fog::Storage::Brightbox.escape(name),
+            :headers  => headers
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/brightbox/requests/storage/put_dynamic_obj_manifest.rb

@@ -0,0 +1,43 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Create a new dynamic large object manifest
+        #
+        # Creates an object with a +X-Object-Manifest+ header that specifies the common prefix ("<container>/<prefix>")
+        # for all uploaded segments. Retrieving the manifest object streams all segments matching this prefix.
+        # Segments must sort in the order they should be concatenated. Note that any future objects stored in the container
+        # along with the segments that match the prefix will be included when retrieving the manifest object.
+        #
+        # All segments must be stored in the same container, but may be in a different container than the manifest object.
+        # The default +X-Object-Manifest+ header is set to "+container+/+object+", but may be overridden in +options+
+        # to specify the prefix and/or the container where segments were stored.
+        # If overridden, names should be CGI escaped (excluding spaces) if needed (see {Fog::Storage::Brightbox.escape}).
+        #
+        # @param container [String] Name for container where +object+ will be stored. Should be < 256 bytes and must not contain '/'
+        # @param object [String] Name for manifest object.
+        # @param options [Hash] Config headers for +object+.
+        # @option options [String] 'X-Object-Manifest' ("container/object") "<container>/<prefix>" for segment objects.
+        #
+        # @raise [Fog::Storage::Brightbox::NotFound] HTTP 404
+        # @raise [Excon::Errors::BadRequest] HTTP 400
+        # @raise [Excon::Errors::Unauthorized] HTTP 401
+        # @raise [Excon::Errors::HTTPStatusError]
+        #
+        # @see http://docs.brightbox.org/api/brightbox-object-storage/1.0/content/dynamic-large-object-creation.html
+        def put_dynamic_obj_manifest(container, object, options = {})
+          path = "#{Fog::Storage::Brightbox.escape(container)}/#{Fog::Storage::Brightbox.escape(object)}"
+          headers = {'X-Object-Manifest' => path}.merge(options)
+          request(
+            :expects  => 201,
+            :headers  => headers,
+            :method   => 'PUT',
+            :path     => path
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/brightbox/requests/storage/put_object.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Create a new object
+        #
+        # When passed a block, it will make a chunked request, calling
+        # the block for chunks until it returns an empty string.
+        # In this case the data parameter is ignored.
+        #
+        # ==== Parameters
+        # * container<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        # * object<~String> - Name for object
+        # * data<~String|File> - data to upload
+        # * options<~Hash> - config headers for object. Defaults to {}.
+        # * block<~Proc> - chunker
+        #
+        def put_object(container, object, data, options = {}, &block)
+          if block_given?
+            params = { :request_block => block }
+            headers = options
+          else
+            data = Fog::Storage.parse_data(data)
+            headers = data[:headers].merge!(options)
+            params = { :body => data[:body] }
+          end
+
+          params.merge!(
+            :expects    => 201,
+            :idempotent => !params[:request_block],
+            :headers    => headers,
+            :method     => 'PUT',
+            :path       => "#{Fog::Storage::Brightbox.escape(container)}/#{Fog::Storage::Brightbox.escape(object)}"
+          )
+
+          request(params)
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/requests/storage/put_object_manifest.rb

@@ -0,0 +1,16 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Create a new dynamic large object manifest
+        #
+        # This is an alias for {#put_dynamic_obj_manifest} for backward compatibility.
+        def put_object_manifest(container, object, options = {})
+          put_dynamic_obj_manifest(container, object, options)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/brightbox/requests/storage/put_static_obj_manifest.rb

@@ -0,0 +1,57 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Create a new static large object manifest.
+        #
+        # A static large object is similar to a dynamic large object. Whereas a GET for a dynamic large object manifest
+        # will stream segments based on the manifest's +X-Object-Manifest+ object name prefix, a static large object
+        # manifest streams segments which are defined by the user within the manifest. Information about each segment is
+        # provided in +segments+ as an Array of Hash objects, ordered in the sequence which the segments should be streamed.
+        #
+        # When the SLO manifest is received, each segment's +etag+ and +size_bytes+ will be verified.
+        # The +etag+ for each segment is returned in the response to {#put_object}, but may also be calculated.
+        # e.g. +Digest::MD5.hexdigest(segment_data)+
+        #
+        # The maximum number of segments for a static large object is 1000, and all segments (except the last) must be
+        # at least 1 MiB in size. Unlike a dynamic large object, segments are not required to be in the same container.
+        #
+        # @example
+        #   segments = [
+        #     { :path => 'segments_container/first_segment',
+        #       :etag => 'md5 for first_segment',
+        #       :size_bytes => 'byte size of first_segment' },
+        #     { :path => 'segments_container/second_segment',
+        #       :etag => 'md5 for second_segment',
+        #       :size_bytes => 'byte size of second_segment' }
+        #   ]
+        #   put_static_obj_manifest('my_container', 'my_large_object', segments)
+        #
+        # @param container [String] Name for container where +object+ will be stored.
+        #     Should be < 256 bytes and must not contain '/'
+        # @param object [String] Name for manifest object.
+        # @param segments [Array<Hash>] Segment data for the object.
+        # @param options [Hash] Config headers for +object+.
+        #
+        # @raise [Fog::Storage::Brightbox::NotFound] HTTP 404
+        # @raise [Excon::Errors::BadRequest] HTTP 400
+        # @raise [Excon::Errors::Unauthorized] HTTP 401
+        # @raise [Excon::Errors::HTTPStatusError]
+        #
+        # @see http://docs.brightbox.org/api/brightbox-object-storage/1.0/content/static-large-objects.html
+        def put_static_obj_manifest(container, object, segments, options = {})
+          request(
+            :expects  => 201,
+            :method   => 'PUT',
+            :headers  => options,
+            :body     => Fog::JSON.encode(segments),
+            :path     => "#{Fog::Storage::Brightbox.escape(container)}/#{Fog::Storage::Brightbox.escape(object)}",
+            :query    => { 'multipart-manifest' => 'put' }
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/brightbox/storage.rb

@@ -0,0 +1,166 @@
+require "fog/brightbox/core"
+require "fog/brightbox/storage/errors"
+require "fog/brightbox/storage/config"
+require "fog/brightbox/storage/authentication_request"
+require "fog/brightbox/storage/connection"
+
+module Fog
+  module Storage
+    class Brightbox < Fog::Service
+
+      requires   :brightbox_client_id,
+                 :brightbox_secret
+      recognizes :persistent, :brightbox_service_name,
+                 :brightbox_storage_url,
+                 :brightbox_service_type, :brightbox_tenant,
+                 :brightbox_region, :brightbox_temp_url_key
+
+      model_path "fog/brightbox/models/storage"
+      model       :directory
+      collection  :directories
+      model       :file
+      collection  :files
+
+      request_path "fog/brightbox/requests/storage"
+      request :copy_object
+      request :delete_container
+      request :delete_object
+      request :delete_multiple_objects
+      request :delete_static_large_object
+      request :get_container
+      request :get_containers
+      request :get_object
+      request :get_object_http_url
+      request :get_object_https_url
+      request :head_container
+      request :head_containers
+      request :head_object
+      request :post_set_meta_temp_url_key
+      request :put_container
+      request :put_dynamic_obj_manifest
+      request :put_object
+      request :put_object_manifest
+      request :put_static_obj_manifest
+
+      class Mock
+        def initialize(options={})
+        end
+      end
+
+      class Real
+        def initialize(config)
+          if config.respond_to?(:config_service?) && config.config_service?
+            @config = config
+          else
+            @config = Fog::Brightbox::Config.new(config)
+          end
+          @config = Fog::Brightbox::Storage::Config.new(@config)
+
+          @temp_url_key = @config.storage_temp_key
+        end
+
+        def needs_to_authenticate?
+          @config.must_authenticate?
+        end
+
+        def authentication_url
+          @auth_url ||= URI.parse(@config.storage_url.to_s)
+        end
+
+        def management_url
+          @config.storage_management_url
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def account
+          @config.account
+        end
+
+        def change_account(account)
+          @config.change_account(account)
+        end
+
+        def reset_account_name
+          @config.reset_account
+        end
+
+        def connection
+          @connection ||= Fog::Brightbox::Storage::Connection.new(@config)
+        end
+
+        def request(params, parse_json = true)
+          begin
+            authenticate if @config.must_authenticate?
+            connection.request(params, parse_json)
+          rescue Fog::Brightbox::Storage::AuthenticationRequired => error
+            if @config.managed_tokens?
+              @config.expire_tokens!
+              authenticate
+              retry
+            else # bad credentials
+              raise error
+            end
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Storage::Brightbox::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+        end
+
+        def authenticate
+          if !management_url || needs_to_authenticate?
+            response = Fog::Brightbox::Storage::AuthenticationRequest.new(@config).authenticate
+            if response.nil?
+              return false
+            else
+              update_config_from_auth_response(response)
+            end
+          else
+            false
+          end
+        end
+
+        # @param [URI] uri A URI object to extract the account from
+        # @return [String] The account
+        def extract_account_from_url(url)
+          url.path.split("/")[2]
+        end
+
+        private
+
+        def update_config_from_auth_response(response)
+          @config.update_tokens(response.access_token)
+
+          # Only update the management URL if not set
+          return true if management_url && account
+
+          unless management_url
+            new_management_url = response.management_url
+            if new_management_url && new_management_url != management_url.to_s
+              @config.storage_management_url = URI.parse(new_management_url)
+            end
+          end
+
+          unless account
+            # Extract the account ID sent by the server
+            change_account(extract_account_from_url(@config.storage_management_url))
+          end
+          true
+        end
+      end
+
+      # CGI.escape, but without special treatment on spaces
+      def self.escape(str,extra_exclude_chars = "")
+        str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+          "%" + $1.unpack("H2" * $1.bytesize).join("%").upcase
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/storage/authentication_request.rb

@@ -0,0 +1,52 @@
+module Fog
+  module Brightbox
+    module Storage
+      class AuthenticationRequest
+        attr_accessor :access_token, :management_url
+        attr_accessor :user, :tenant
+
+        def initialize(config)
+          @config = config
+        end
+
+        def authenticate
+          response = authentication_request
+
+          self.access_token = response.headers["X-Auth-Token"]
+          self.management_url = response.headers["X-Server-Management-Url"] || response.headers["X-Storage-Url"]
+          self
+        rescue Excon::Errors::Error
+          nil
+        end
+
+        private
+
+        def authentication_request
+          authentication_url = URI.parse(@config.storage_url.to_s)
+          connection = Fog::Core::Connection.new(authentication_url.to_s)
+          request_settings = {
+            :expects => [200, 204],
+            :headers => auth_headers,
+            :method => "GET",
+            :path => "v1"
+          }
+          connection.request(request_settings)
+        end
+
+        def auth_headers
+          if @config.user_credentials?
+            {
+              "X-Auth-User" => @config.username,
+              "X-Auth-Key" => @config.password
+            }
+          else
+            {
+              "X-Auth-User" => @config.client_id,
+              "X-Auth-Key" => @config.client_secret
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/storage/config.rb

@@ -0,0 +1,23 @@
+require "delegate"
+
+module Fog
+  module Brightbox
+    module Storage
+      class Config < SimpleDelegator
+        def initialize(config)
+          super
+          @config = config
+          raise ArgumentError unless required_args_available?
+        end
+
+        private
+
+        def required_args_available?
+          return false unless @config.client_id
+          return false unless @config.client_secret
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/storage/connection.rb

@@ -0,0 +1,83 @@
+require "fog/core/connection"
+require "fog/brightbox/storage/errors"
+
+module Fog
+  module Brightbox
+    module Storage
+      class Connection < Fog::Core::Connection
+        def initialize(config)
+          @config = config
+
+          unless management_url
+            raise ManagementUrlUnknown
+          else
+            @connection = super(management_url.to_s, persistent?, connection_options)
+          end
+        end
+
+        def request(params, parse_json = true)
+          begin
+            raise ArgumentError if params.nil?
+            request_params = params.merge({
+              :headers => request_headers(params),
+              :path => path_in_params(params)
+            })
+            response = @connection.request(request_params)
+          rescue Excon::Errors::Unauthorized => error
+            raise AuthenticationRequired.slurp(error)
+          rescue Excon::Errors::NotFound => error
+            raise Fog::Storage::Brightbox::NotFound.slurp(error)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise error
+          end
+
+          if !response.body.empty? && parse_json && response.get_header("Content-Type") =~ %r{application/json}
+            response.body = Fog::JSON.decode(response.body)
+          end
+          response
+        end
+
+        def management_url
+          @config.storage_management_url
+        end
+
+        def path_in_params(params)
+          if params.respond_to?(:key?) && params.key?(:path)
+            URI.join(@config.storage_management_url.to_s + "/", params[:path]).path
+          else
+            @config.storage_management_url.path
+          end
+        end
+
+        def request_headers(excon_params)
+          if excon_params.respond_to?(:key?) && excon_params.key?(:headers)
+            authenticated_headers.merge(excon_params[:headers])
+          else
+            authenticated_headers
+          end
+        end
+
+        def authenticated_headers
+          default_headers.merge({
+            "X-Auth-Token" => @config.latest_access_token
+          })
+        end
+
+        def default_headers
+          {
+            "Content-Type" => "application/json",
+            "Accept" => "application/json"
+          }
+        end
+
+        def persistent?
+          @config.connection_persistent?
+        end
+
+        def connection_options
+          @config.storage_connection_options
+        end
+      end
+    end
+  end
+end