fog-brightbox 0.0.1

data/lib/fog/brightbox/models/compute/server_groups.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/server_group'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class ServerGroups < Fog::Collection
+
+        model Fog::Compute::Brightbox::ServerGroup
+
+        def all
+          data = service.list_server_groups
+          load(data)
+        end
+
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_server_group(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/servers.rb

@@ -0,0 +1,61 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/server'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Brightbox::Server
+
+        def all
+          data = service.list_servers
+          load(data)
+        end
+
+        # Creates a server and maps an Cloud IP
+        #
+        # By default the public SSH key you have registered with
+        # Brightbox is already made available in an AWS compatible
+        # metdata service.
+        #
+        # @todo Support uploading of arbitary SSH keys
+        #
+        # @param [Hash] options
+        # @option options [String] name      Name for the server
+        # @option options [String] flavor_id Identifier for virtual hardware type to request
+        # @option options [String] image_id  Identifier for image to use when creating
+        # @option options [String] zone_id   Identifer for preferred zone to locate server in
+        # @option options [Array<String>] server_groups List of group identifiers for the server to join
+        #
+        # @return Fog::Compute::Brightbox::Server
+        #
+        def bootstrap(options = {})
+          server = create(options)
+
+          # Ensure server is now available
+          server.wait_for { ready? }
+
+          # To get a public IP address we need to map a cloud IP address
+          cip = service.cloud_ips.allocate
+          cip.map(server)
+          cip.wait_for { mapped? }
+
+          # Reload so the public IP is now available
+          server.reload
+        end
+
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_server(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/user.rb

@@ -0,0 +1,43 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class User < Fog::Model
+
+        identity :id
+        attribute :resource_type
+        attribute :url
+
+        attribute :name
+        attribute :email_address
+        attribute :ssh_key
+
+        # Boolean flags
+        attribute :email_verified
+        attribute :messaging_pref
+
+        # Links - to be replaced
+        attribute :account_id, :aliases => "default_account", :squash => "id"
+        attribute :accounts
+
+        def save
+          requires :identity
+
+          options = {
+            :email_address => email_address,
+            :ssh_key => ssh_key,
+            :name => name
+          }
+
+          data = service.update_user(identity, options)
+          merge_attributes(data)
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/user_collaboration.rb

@@ -0,0 +1,44 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Brightbox
+      class UserCollaboration < Fog::Model
+        identity  :id
+        attribute :status
+        attribute :email
+        attribute :role
+        attribute :role_label
+        attribute :account
+        attribute :user
+        attribute :inviter
+
+        def account_id
+          account['id'] || account[:id]
+        end
+
+        def accept
+          requires :identity
+          data = service.accept_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
+        def reject
+          requires :identity
+          data = service.reject_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
+        def destroy
+          requires :identity
+          data = service.destroy_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/user_collaborations.rb

@@ -0,0 +1,31 @@
+require "fog/core/collection"
+require "fog/brightbox/models/compute/user_collaboration"
+
+module Fog
+  module Compute
+    class Brightbox
+      class UserCollaborations < Fog::Collection
+        model Fog::Compute::Brightbox::UserCollaboration
+
+        def all
+          data = service.list_user_collaborations
+          load(data)
+        end
+
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_user_collaboration(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def destroy
+          requires :identity
+          service.destroy_user_collaboration(identity)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/users.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/user'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class Users < Fog::Collection
+
+        model Fog::Compute::Brightbox::User
+
+        def all
+          data = service.list_users
+          load(data)
+        end
+
+        def get(identifier = nil)
+          data = service.get_user(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/zone.rb

@@ -0,0 +1,22 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class Zone < Fog::Model
+
+        identity :id
+        attribute :url
+        attribute :resource_type
+
+        attribute :status
+        attribute :handle
+
+        attribute :description
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/zones.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/zone'
+
+module Fog
+  module Compute
+    class Brightbox
+
+      class Zones < Fog::Collection
+
+        model Fog::Compute::Brightbox::Zone
+
+        def all
+          data = service.list_zones
+          load(data)
+        end
+
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_zone(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/oauth2.rb

@@ -0,0 +1,166 @@
+# This module covers Brightbox's partial implementation of OAuth 2.0
+# and enables fog clients to implement several authentictication strategies
+#
+# @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
+
+  # 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
+
+    # Returns true if user details are available
+    # @return [Boolean]
+    def user_details?
+      !!(@username && @password)
+    end
+
+    # Is an access token available for these credentials?
+    def access_token?
+      !!@access_token
+    end
+
+    # 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
+
+  # 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
+    end
+
+    def authorization_body_data
+      raise "Not implemented"
+    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
+      }
+    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
+      }
+    end
+  end
+
+  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"])
+  end
+end