fog-brightbox 0.3.0 → 0.4.0

data/lib/fog/brightbox/models/storage/files.rb

@@ -0,0 +1,104 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/storage/file'
+
+module Fog
+  module Storage
+    class Brightbox
+
+      class Files < Fog::Collection
+
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::Brightbox::File
+
+        def all(options = {})
+          requires :directory
+          options = {
+            'limit'   => limit,
+            'marker'  => marker,
+            'path'    => path,
+            'prefix'  => prefix
+          }.merge!(options)
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
+          end
+        end
+
+        alias :each_file_this_page :each
+        def each
+          if !block_given?
+            self
+          else
+            subset = dup.all
+
+            subset.each_file_this_page {|f| yield f}
+            while subset.length == (subset.limit || 10000)
+              subset = subset.all(:marker => subset.last.key)
+              subset.each_file_this_page {|f| yield f}
+            end
+
+            self
+          end
+        end
+
+        def get(key, &block)
+          requires :directory
+          data = service.get_object(directory.key, key, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Brightbox::NotFound
+          nil
+        end
+
+        def get_url(key)
+          requires :directory
+          if self.directory.public_url
+            "#{self.directory.public_url}/#{Fog::Storage::Brightbox.escape(key, '/')}"
+          end
+        end
+
+        def get_http_url(key, expires, options = {})
+          requires :directory
+          service.get_object_http_url(directory.key, key, expires, options)
+        end
+
+        def get_https_url(key, expires, options = {})
+          requires :directory
+          service.get_object_https_url(directory.key, key, expires, options)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = service.head_object(directory.key, key)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Brightbox::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/oauth2.rb

@@ -3,164 +3,168 @@
 #
 # @see http://tools.ietf.org/html/draft-ietf-oauth-v2-10
 #
-module Fog::Brightbox::OAuth2
-
-  # This builds the simplest form of requesting an access token
-  # based on the arguments passed in
-  #
-  # @param [Fog::Core::Connection] connection
-  # @param [CredentialSet] credentials
-  #
-  # @return [Excon::Response]
-  def request_access_token(connection, credentials)
-    token_strategy = credentials.best_grant_strategy
-
-    header_content = "#{credentials.client_id}:#{credentials.client_secret}"
-    encoded_credentials = Base64.encode64(header_content).chomp
-
-    connection.request(
-      :path => "/token",
-      :expects  => 200,
-      :headers  => {
-        'Authorization' => "Basic #{encoded_credentials}",
-        'Content-Type' => 'application/json'
-      },
-      :method   => 'POST',
-      :body     => Fog::JSON.encode(token_strategy.authorization_body_data)
-    )
-  end
+module Fog
+  module Brightbox
+    module OAuth2
 
-  # Encapsulates credentials required to request access tokens from the
-  # Brightbox authorisation servers
-  #
-  # @todo Interface to update certain credentials (after password change)
-  #
-  class CredentialSet
-    attr_reader :client_id, :client_secret, :username, :password
-    attr_reader :access_token, :refresh_token, :expires_in
+    # This builds the simplest form of requesting an access token
+    # based on the arguments passed in
     #
-    # @param [String] client_id
-    # @param [String] client_secret
-    # @param [Hash] options
-    # @option options [String] :username
-    # @option options [String] :password
+    # @param [Fog::Core::Connection] connection
+    # @param [CredentialSet] credentials
     #
-    def initialize(client_id, client_secret, options = {})
-      @client_id     = client_id
-      @client_secret = client_secret
-      @username      = options[:username]
-      @password      = options[:password]
-      @access_token  = options[:access_token]
-      @refresh_token = options[:refresh_token]
-      @expires_in    = options[:expires_in]
+    # @return [Excon::Response]
+    def request_access_token(connection, credentials)
+      token_strategy = credentials.best_grant_strategy
+
+      header_content = "#{credentials.client_id}:#{credentials.client_secret}"
+      encoded_credentials = Base64.encode64(header_content).chomp
+
+      connection.request(
+        :path => "/token",
+        :expects  => 200,
+        :headers  => {
+          'Authorization' => "Basic #{encoded_credentials}",
+          'Content-Type' => 'application/json'
+        },
+        :method   => 'POST',
+        :body     => Fog::JSON.encode(token_strategy.authorization_body_data)
+      )
     end
 
-    # Returns true if user details are available
-    # @return [Boolean]
-    def user_details?
-      !!(@username && @password)
-    end
+    # Encapsulates credentials required to request access tokens from the
+    # Brightbox authorisation servers
+    #
+    # @todo Interface to update certain credentials (after password change)
+    #
+    class CredentialSet
+      attr_reader :client_id, :client_secret, :username, :password
+      attr_reader :access_token, :refresh_token, :expires_in
+      #
+      # @param [String] client_id
+      # @param [String] client_secret
+      # @param [Hash] options
+      # @option options [String] :username
+      # @option options [String] :password
+      #
+      def initialize(client_id, client_secret, options = {})
+        @client_id     = client_id
+        @client_secret = client_secret
+        @username      = options[:username]
+        @password      = options[:password]
+        @access_token  = options[:access_token]
+        @refresh_token = options[:refresh_token]
+        @expires_in    = options[:expires_in]
+      end
 
-    # Is an access token available for these credentials?
-    def access_token?
-      !!@access_token
-    end
+      # Returns true if user details are available
+      # @return [Boolean]
+      def user_details?
+        !!(@username && @password)
+      end
 
-    # Is a refresh token available for these credentials?
-    def refresh_token?
-      !!@refresh_token
-    end
+      # Is an access token available for these credentials?
+      def access_token?
+        !!@access_token
+      end
 
-    # Updates the credentials with newer tokens
-    def update_tokens(access_token, refresh_token = nil, expires_in = nil)
-      @access_token  = access_token
-      @refresh_token = refresh_token
-      @expires_in    = expires_in
+      # Is a refresh token available for these credentials?
+      def refresh_token?
+        !!@refresh_token
+      end
+
+      # Updates the credentials with newer tokens
+      def update_tokens(access_token, refresh_token = nil, expires_in = nil)
+        @access_token  = access_token
+        @refresh_token = refresh_token
+        @expires_in    = expires_in
+      end
+
+      # Based on available credentials returns the best strategy
+      #
+      # @todo Add a means to dictate which should or shouldn't be used
+      #
+      def best_grant_strategy
+        if refresh_token?
+          RefreshTokenStrategy.new(self)
+        elsif user_details?
+          UserCredentialsStrategy.new(self)
+        else
+          ClientCredentialsStrategy.new(self)
+        end
+      end
     end
 
-    # Based on available credentials returns the best strategy
+    # This strategy class is the basis for OAuth2 grant types
+    #
+    # @abstract Need to implement {#authorization_body_data} to return a
+    #   Hash matching the expected parameter form for the OAuth request
     #
-    # @todo Add a means to dictate which should or shouldn't be used
+    # @todo Strategies should be able to validate if credentials are suitable
+    #   so just client credentials cannot be used with user strategies
     #
-    def best_grant_strategy
-      if refresh_token?
-        RefreshTokenStrategy.new(self)
-      elsif user_details?
-        UserCredentialsStrategy.new(self)
-      else
-        ClientCredentialsStrategy.new(self)
+    class GrantTypeStrategy
+      def initialize(credentials)
+        @credentials = credentials
       end
-    end
-  end
 
-  # This strategy class is the basis for OAuth2 grant types
-  #
-  # @abstract Need to implement {#authorization_body_data} to return a
-  #   Hash matching the expected parameter form for the OAuth request
-  #
-  # @todo Strategies should be able to validate if credentials are suitable
-  #   so just client credentials cannot be used with user strategies
-  #
-  class GrantTypeStrategy
-    def initialize(credentials)
-      @credentials = credentials
+      def authorization_body_data
+        raise "Not implemented"
+      end
     end
 
-    def authorization_body_data
-      raise "Not implemented"
+    # This implements client based authentication/authorization
+    # based on the existing trust relationship using the `none`
+    # grant type.
+    #
+    class ClientCredentialsStrategy < GrantTypeStrategy
+      def authorization_body_data
+        {
+          "grant_type" => "none",
+          "client_id"  => @credentials.client_id
+        }
+      end
     end
-  end
 
-  # This implements client based authentication/authorization
-  # based on the existing trust relationship using the `none`
-  # grant type.
-  #
-  class ClientCredentialsStrategy < GrantTypeStrategy
-    def authorization_body_data
-      {
-        "grant_type" => "none",
-        "client_id"  => @credentials.client_id
-      }
+    # This passes user details through so the returned token
+    # carries the privileges of the user not account limited
+    # by the client
+    #
+    class UserCredentialsStrategy < GrantTypeStrategy
+      def authorization_body_data
+        {
+          "grant_type" => "password",
+          "client_id"  => @credentials.client_id,
+          "username"   => @credentials.username,
+          "password"   => @credentials.password
+        }
+      end
     end
-  end
 
-  # This passes user details through so the returned token
-  # carries the privileges of the user not account limited
-  # by the client
-  #
-  class UserCredentialsStrategy < GrantTypeStrategy
-    def authorization_body_data
-      {
-        "grant_type" => "password",
-        "client_id"  => @credentials.client_id,
-        "username"   => @credentials.username,
-        "password"   => @credentials.password
-      }
-    end
-  end
-
-  # This strategy attempts to use a refresh_token gained during an earlier
-  # request to reuse the credentials given originally
-  #
-  class RefreshTokenStrategy < GrantTypeStrategy
-    def authorization_body_data
-      {
-        "grant_type"    => "refresh_token",
-        "client_id"     => @credentials.client_id,
-        "refresh_token" => @credentials.refresh_token
-      }
+    # This strategy attempts to use a refresh_token gained during an earlier
+    # request to reuse the credentials given originally
+    #
+    class RefreshTokenStrategy < GrantTypeStrategy
+      def authorization_body_data
+        {
+          "grant_type"    => "refresh_token",
+          "client_id"     => @credentials.client_id,
+          "refresh_token" => @credentials.refresh_token
+        }
+      end
     end
-  end
 
-  private
+    private
 
-  # This updates the current credentials if passed a valid response
-  #
-  # @param [CredentialSet] credentials Credentials to update
-  # @param [Excon::Response] response Response object to parse value from
-  #
-  def update_credentials_from_response(credentials, response)
-    response_data = Fog::JSON.decode(response.body)
-    credentials.update_tokens(response_data["access_token"], response_data["refresh_token"], response_data["expires_in"])
+    # This updates the current credentials if passed a valid response
+    #
+    # @param [CredentialSet] credentials Credentials to update
+    # @param [Excon::Response] response Response object to parse value from
+    #
+    def update_credentials_from_response(credentials, response)
+      response_data = Fog::JSON.decode(response.body)
+      credentials.update_tokens(response_data["access_token"], response_data["refresh_token"], response_data["expires_in"])
+    end
   end
 end
+end

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

@@ -0,0 +1,27 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Copy object
+        #
+        # ==== Parameters
+        # * source_container_name<~String> - Name of source bucket
+        # * source_object_name<~String> - Name of source object
+        # * target_container_name<~String> - Name of bucket to create copy in
+        # * target_object_name<~String> - Name for new copy of object
+        # * options<~Hash> - Additional headers
+        def copy_object(source_container_name, source_object_name, target_container_name, target_object_name, options={})
+          headers = { 'X-Copy-From' => "/#{source_container_name}/#{source_object_name}" }.merge(options)
+          request({
+            :expects  => 201,
+            :headers  => headers,
+            :method   => 'PUT',
+            :path     => "#{Fog::Storage::Brightbox.escape(target_container_name)}/#{Fog::Storage::Brightbox.escape(target_object_name)}"
+          })
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  module Storage
+    class Brightbox
+      class Real
+
+        # Delete an existing container
+        #
+        # ==== Parameters
+        # * name<~String> - Name of container to delete
+        #
+        def delete_container(name)
+          request(
+            :expects  => 204,
+            :method   => 'DELETE',
+            :path     => Fog::Storage::Brightbox.escape(name)
+          )
+        end
+
+      end
+    end
+  end
+end