fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/lib/fog/bluebox/models/compute/flavors.rb

@@ -10,12 +10,12 @@ module Fog
         model Fog::Compute::Bluebox::Flavor
 
         def all
-          data = connection.get_products.body
+          data = service.get_products.body
           load(data)
         end
 
         def get(product_id)
-          response = connection.get_product(product_id)
+          response = service.get_product(product_id)
           new(response.body)
         rescue Fog::Compute::Bluebox::NotFound
           nil

data/lib/fog/bluebox/models/compute/image.rb

@@ -7,26 +7,26 @@ module Fog
       class Image < Fog::Model
 
         identity :id
-        
+
         attribute :block_id
         attribute :description
         attribute :public
         attribute :created_at, :aliases => 'created'
-        
+
         def save
           requires :block_id
-          
-          data = connection.create_template(block_id, attributes)
+
+          data = service.create_template(block_id, attributes)
           true
         end
-        
+
         def destroy
           requires :id
-          
-          data = connection.destroy_template(id)
+
+          data = service.destroy_template(id)
           true
         end
-        
+
       end
 
     end

data/lib/fog/bluebox/models/compute/images.rb

@@ -10,12 +10,12 @@ module Fog
         model Fog::Compute::Bluebox::Image
 
         def all
-          data = connection.get_templates.body
+          data = service.get_templates.body
           load(data)
         end
 
         def get(template_id)
-          response = connection.get_template(template_id)
+          response = service.get_template(template_id)
           new(response.body)
         rescue Fog::Compute::Bluebox::NotFound
           nil

data/lib/fog/bluebox/models/compute/locations.rb

@@ -10,12 +10,12 @@ module Fog
         model Fog::Compute::Bluebox::Location
 
         def all
-          data = connection.get_locations.body
+          data = service.get_locations.body
           load(data)
         end
 
         def get(location_id)
-          response = connection.get_location(location_id)
+          response = service.get_location(location_id)
           new(response.body)
         rescue Fog::Compute::Bluebox::NotFound
           nil

data/lib/fog/bluebox/models/compute/server.rb

@@ -33,23 +33,23 @@ module Fog
 
         def destroy
           requires :id
-          connection.destroy_block(id)
+          service.destroy_block(id)
           true
         end
 
         def flavor
           requires :flavor_id
-          connection.flavors.get(flavor_id)
+          service.flavors.get(flavor_id)
         end
 
         def image
           requires :image_id
-          connection.images.get(image_id)
+          service.images.get(image_id)
         end
-        
+
         def location
           requires :location_id
-          connection.locations.get(location_id)
+          service.locations.get(location_id)
         end
 
         def private_ip_address
@@ -66,16 +66,16 @@ module Fog
 
         def reboot(type = 'SOFT')
           requires :id
-          connection.reboot_block(id, type)
+          service.reboot_block(id, type)
           true
         end
 
         def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :flavor_id, :image_id, :location_id
           options = {}
 
-          if identity.nil?  # new record
+          unless persisted?  # new record
             raise(ArgumentError, "password or public_key is required for this operation") if !password && !public_key
             options['ssh_public_key'] = public_key if public_key
             options['password'] = password if @password
@@ -88,10 +88,10 @@ module Fog
           elsif @lb_applications
             options['lb_applications'] = lb_applications
           end
-          
+
           options['username'] = username
           options['hostname'] = hostname if @hostname
-          data = connection.create_block(flavor_id, image_id, location_id, options)
+          data = service.create_block(flavor_id, image_id, location_id, options)
           merge_attributes(data.body)
           true
         end

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

@@ -10,7 +10,7 @@ module Fog
         model Fog::Compute::Bluebox::Server
 
         def all
-          data = connection.get_blocks.body
+          data = service.get_blocks.body
           load(data)
         end
 
@@ -22,7 +22,7 @@ module Fog
         end
 
         def get(server_id)
-          if server_id && server = connection.get_block(server_id).body
+          if server_id && server = service.get_block(server_id).body
             new(server)
           end
         rescue Fog::Compute::Bluebox::NotFound

data/lib/fog/bluebox/models/dns/record.rb

@@ -23,7 +23,7 @@ module Fog
 
         def destroy
           requires :identity
-          connection.delete_record(@zone.identity, identity)
+          service.delete_record(@zone.identity, identity)
           true
         end
 
@@ -34,9 +34,9 @@ module Fog
         def save
           requires :zone, :type, :name, :value
           data = unless identity
-            connection.create_record(zone.identity, type, name, value)
+            service.create_record(zone.identity, type, name, value)
           else
-            connection.update_record(zone.identity, identity, {:type => type, :name => name, :content => value})
+            service.update_record(zone.identity, identity, {:type => type, :name => name, :content => value})
           end
           merge_attributes(data.body)
           true

data/lib/fog/bluebox/models/dns/records.rb

@@ -13,12 +13,12 @@ module Fog
 
         def all
           requires :zone
-          data = connection.get_records(zone.identity).body['records']
+          data = service.get_records(zone.identity).body['records']
           load(data)
         end
 
         def get(record_id)
-          data = connection.get_record(zone.identity, record_id).body
+          data = service.get_record(zone.identity, record_id).body
           new(data)
         rescue Fog::Service::NotFound
           nil

data/lib/fog/bluebox/models/dns/zone.rb

@@ -31,7 +31,7 @@ module Fog
           @records ||= begin
             Fog::DNS::Bluebox::Records.new(
               :zone       => self,
-              :connection => connection
+              :service => service
             )
           end
         end
@@ -46,7 +46,7 @@ module Fog
 
         def destroy
           requires :identity
-          connection.delete_zone(identity)
+          service.delete_zone(identity)
           true
         end
 
@@ -54,7 +54,7 @@ module Fog
           requires :domain, :ttl
           options = attributes.dup
           options[:name] = options.delete(:domain)
-          data = identity.nil? ? connection.create_zone(options) : connection.update_zone(identity, options)
+          data = identity.nil? ? service.create_zone(options) : service.update_zone(identity, options)
           merge_attributes(data.body)
           true
         end

data/lib/fog/bluebox/models/dns/zones.rb

@@ -10,12 +10,12 @@ module Fog
         model Fog::DNS::Bluebox::Zone
 
         def all
-          data = connection.get_zones.body['zones']
+          data = service.get_zones.body['zones']
           load(data)
         end
 
         def get(zone_id)
-          data = connection.get_zone(zone_id).body
+          data = service.get_zone(zone_id).body
           new(data)
         rescue Fog::Service::NotFound
           nil

data/lib/fog/bluebox/requests/compute/create_block.rb

@@ -12,7 +12,7 @@ module Fog
         # * options<~Hash>:
         #     * password<~String>   - Password for block
         #   or
-        #     * public_key<~String> - SSH public key
+        #     * ssh_public_key<~String> - SSH public key
         #     * username<~String>   - Defaults to deploy
         #
         # ==== Returns
@@ -20,7 +20,7 @@ module Fog
         #   * body<~Hash>:
         def create_block(product_id, template_id, location_id, options = {})
 
-          unless options.has_key?('password') || options.has_key?('public_key')
+          unless options.has_key?('password') || options.has_key?('ssh_public_key')
             raise ArgumentError, 'Either password or public_key must be supplied'
           end
 
@@ -30,14 +30,12 @@ module Fog
             'location' => location_id
           }
 
-          body = URI.encode options.map {|k,v| "#{k}=#{v}"}.join('&')
-
           request(
             :expects  => 200,
             :method   => 'POST',
             :path     => '/api/blocks.json',
             :query    => query,
-            :body     => URI.encode(body)
+            :body     => options.map {|k,v| "#{CGI.escape(k)}=#{CGI.escape(v)}"}.join('&')
           )
         end
 

data/lib/fog/brightbox/compute.rb

@@ -1,5 +1,6 @@
 require 'fog/brightbox'
 require 'fog/compute'
+require 'fog/brightbox/oauth2'
 
 module Fog
   module Compute
@@ -16,6 +17,12 @@ module Fog
       # User credentials (still requires client details)
       recognizes :brightbox_username, :brightbox_password, :brightbox_account
 
+      # Cached tokens
+      recognizes :brightbox_access_token, :brightbox_refresh_token
+
+      # Automatic token management
+      recognizes :brightbox_token_management
+
       # Excon connection settings
       recognizes :persistent
 
@@ -106,6 +113,7 @@ module Fog
       request :remove_nodes_load_balancer
       request :remove_servers_server_group
       request :reset_ftp_password_account
+      request :reset_ftp_password_scoped_account
       request :reset_secret_api_client
       request :reset_secret_application
       request :shutdown_server
@@ -126,6 +134,137 @@ module Fog
       request :update_user
 
       module Shared
+        include Fog::Brightbox::OAuth2
+
+        # Creates a new instance of the Brightbox Compute service
+        #
+        # @note If you create service using just a refresh token when it
+        #   expires the service will no longer be able to authenticate.
+        #
+        # @param [Hash] options
+        # @option options [String] :brightbox_api_url   Override the default (or configured) API endpoint
+        # @option options [String] :brightbox_auth_url  Override the default (or configured) API authentication endpoint
+        # @option options [String] :brightbox_client_id Client identifier to authenticate with (overrides configured)
+        # @option options [String] :brightbox_secret    Client secret to authenticate with (overrides configured)
+        # @option options [String] :brightbox_username  Email or user identifier for user based authentication
+        # @option options [String] :brightbox_password  Password for user based authentication
+        # @option options [String] :brightbox_account   Account identifier to scope this connection to
+        # @option options [String] :connection_options  Settings to pass to underlying {Fog::Connection}
+        # @option options [Boolean] :persistent         Sets a persistent HTTP {Fog::Connection}
+        # @option options [String] :brightbox_access_token  Sets the OAuth access token to use rather than requesting a new token
+        # @option options [String] :brightbox_refresh_token Sets the refresh token to use when requesting a newer access token
+        # @option options [String] :brightbox_token_management Overide the existing behaviour to request access tokens if expired (default is `true`)
+        #
+        def initialize(options)
+          # Currently authentication and api endpoints are the same but may change
+          @auth_url            = options[:brightbox_auth_url]  || Fog.credentials[:brightbox_auth_url] || API_URL
+          @auth_connection     = Fog::Connection.new(@auth_url)
+
+          @api_url             = options[:brightbox_api_url]   || Fog.credentials[:brightbox_api_url]  || API_URL
+          @connection_options  = options[:connection_options]  || {}
+          @persistent          = options[:persistent]          || false
+          @connection          = Fog::Connection.new(@api_url, @persistent, @connection_options)
+
+          # Authentication options
+          client_id            = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
+          client_secret        = options[:brightbox_secret]    || Fog.credentials[:brightbox_secret]
+
+          username             = options[:brightbox_username]  || Fog.credentials[:brightbox_username]
+          password             = options[:brightbox_password]  || Fog.credentials[:brightbox_password]
+          @configured_account  = options[:brightbox_account]   || Fog.credentials[:brightbox_account]
+          # Request account can be changed at anytime and changes behaviour of future requests
+          @scoped_account      = @configured_account
+
+          credential_options   = {:username => username, :password => password}
+          @credentials         = CredentialSet.new(client_id, client_secret, credential_options)
+
+          # If existing tokens have been cached, allow continued use of them in the service
+          @credentials.update_tokens(options[:brightbox_access_token], options[:brightbox_refresh_token])
+
+          @token_management    = options.fetch(:brightbox_token_management, true)
+        end
+
+        # Sets the scoped account for future requests
+        # @param [String] scoped_account Identifier of the account to scope request to
+        def scoped_account=(scoped_account)
+          @scoped_account = scoped_account
+        end
+
+        # This returns the account identifier that the request should be scoped by
+        # based on the options passed to the request and current configuration
+        #
+        # @param [String] options_account Any identifier passed into the request
+        #
+        # @return [String, nil] The account identifier to scope the request to or nil
+        def scoped_account(options_account = nil)
+          [options_account, @scoped_account].compact.first
+        end
+
+        # Resets the scoped account back to intially configured one
+        def scoped_account_reset
+          @scoped_account = @configured_account
+        end
+
+        # Returns the scoped account being used for requests
+        #
+        # * For API clients this is the owning account
+        # * For User applications this is the account specified by either +account_id+
+        #   option on the service or the +brightbox_account+ setting in your configuration
+        #
+        # @return [Fog::Compute::Brightbox::Account]
+        #
+        def account
+          account_data = get_scoped_account.merge(:service => self)
+          Fog::Compute::Brightbox::Account.new(account_data)
+        end
+
+        # Returns true if authentication is being performed as a user
+        # @return [Boolean]
+        def authenticating_as_user?
+          @credentials.user_details?
+        end
+
+        # Returns true if an access token is set
+        # @return [Boolean]
+        def access_token_available?
+          !! @credentials.access_token
+        end
+
+        # Returns the current access token or nil
+        # @return [String,nil]
+        def access_token
+          @credentials.access_token
+        end
+
+        # Returns the current refresh token or nil
+        # @return [String,nil]
+        def refresh_token
+          @credentials.refresh_token
+        end
+
+        # Requests a new access token
+        #
+        # @return [String] New access token
+        def get_access_token
+          begin
+            get_access_token!
+          rescue Excon::Errors::Unauthorized, Excon::Errors::BadRequest
+            @credentials.update_tokens(nil, nil)
+          end
+          @credentials.access_token
+        end
+
+        # Requests a new access token and raises if there is a problem
+        #
+        # @return [String] New access token
+        # @raise [Excon::Errors::BadRequest] The credentials are expired or incorrect
+        #
+        def get_access_token!
+          response = request_access_token(@auth_connection, @credentials)
+          update_credentials_from_response(@credentials, response)
+          @credentials.access_token
+        end
+
         # Returns an identifier for the default image for use
         #
         # Currently tries to find the latest version Ubuntu LTS (i686) widening
@@ -139,120 +278,183 @@ module Fog
           return @default_image_id unless @default_image_id.nil?
           @default_image_id = Fog.credentials[:brightbox_default_image] || select_default_image
         end
+
+      private
+
+        # This makes a request of the API based on the configured setting for
+        # token management.
+        #
+        # @param [Hash] options Excon compatible options
+        # @see https://github.com/geemus/excon/blob/master/lib/excon/connection.rb
+        #
+        # @return [Hash] Data of response body
+        #
+        def make_request(options)
+          if @token_management
+            managed_token_request(options)
+          else
+            authenticated_request(options)
+          end
+        end
+
+        # This request checks for access tokens and will ask for a new one if
+        # it receives Unauthorized from the API before repeating the request
+        #
+        # @param [Hash] options Excon compatible options
+        #
+        # @return [Excon::Response]
+        def managed_token_request(options)
+          begin
+            get_access_token unless access_token_available?
+            response = authenticated_request(options)
+          rescue Excon::Errors::Unauthorized
+            get_access_token
+            response = authenticated_request(options)
+          end
+        end
+
+        # This request makes an authenticated request of the API using currently
+        # setup credentials.
+        #
+        # @param [Hash] options Excon compatible options
+        #
+        # @see https://github.com/geemus/excon/blob/master/lib/excon/connection.rb
+        #
+        # @return [Excon::Response]
+        def authenticated_request(options)
+          headers = options[:headers] || {}
+          headers.merge!("Authorization" => "OAuth #{@credentials.access_token}", "Content-Type" => "application/json")
+          options[:headers] = headers
+          # TODO This is just a wrapper around a call to Excon::Connection#request
+          #   so can be extracted from Compute by passing in the connection,
+          #   credentials and options
+          @connection.request(options)
+        end
       end
 
+      # The Mock Service allows you to run a fake instance of the Service
+      # which makes no real connections.
+      #
+      # @todo Implement
+      #
       class Mock
         include Shared
 
-        def initialize(options)
-          @brightbox_client_id = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
-          @brightbox_secret = options[:brightbox_secret] || Fog.credentials[:brightbox_secret]
+        def request(method, path, expected_responses, parameters = {})
+          _request
         end
 
-        def request(options)
-          raise "Not implemented"
+        def request_access_token(connection, credentials)
+          _request
         end
 
       private
+
+        def _request
+          raise Fog::Errors::MockNotImplemented
+        end
+
         def select_default_image
           "img-mockd"
         end
       end
 
+      # The Real Service actually makes real connections to the Brightbox
+      # service.
+      #
       class Real
         include Shared
 
-        def initialize(options)
-          # Currently authentication and api endpoints are the same but may change
-          @auth_url             = options[:brightbox_auth_url] || Fog.credentials[:brightbox_auth_url] || API_URL
-          @api_url              = options[:brightbox_api_url] || Fog.credentials[:brightbox_api_url] || API_URL
-          @connection_options   = options[:connection_options] || {}
-          @brightbox_client_id  = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
-          @brightbox_secret     = options[:brightbox_secret] || Fog.credentials[:brightbox_secret]
-          @brightbox_username   = options[:brightbox_username] || Fog.credentials[:brightbox_username]
-          @brightbox_password   = options[:brightbox_password] || Fog.credentials[:brightbox_password]
-          @brightbox_account    = options[:brightbox_account] || Fog.credentials[:brightbox_account]
-          @persistent           = options[:persistent] || false
-          @connection = Fog::Connection.new(@api_url, @persistent, @connection_options)
-        end
-
-        def request(method, url, expected_responses, options = {})
-          request_options = {
-            :method   => method.to_s.upcase,
-            :path     => url,
-            :expects  => expected_responses
-          }
-          options[:account_id] = @brightbox_account if options[:account_id].nil? && @brightbox_account
-          request_options[:body] = Fog::JSON.encode(options) unless options.empty?
-          make_request(request_options)
+        # Makes an API request to the given path using passed options or those
+        # set with the service setup
+        #
+        # @todo Standard Fog behaviour is to return the Excon::Response but
+        #   this was unintentionally changed to be the Hash version of the
+        #   data in the body. This loses access to some details and should
+        #   be corrected in a backwards compatible manner
+        #
+        # @overload request(params)
+        #   @param [Hash] params Excon compatible options
+        #   @option params [String] :body text to be sent over a socket
+        #   @option params [Hash<Symbol, String>] :headers The default headers to supply in a request
+        #   @option params [String] :host The destination host's reachable DNS name or IP, in the form of a String
+        #   @option params [String] :path appears after 'scheme://host:port/'
+        #   @option params [Fixnum] :port The port on which to connect, to the destination host
+        #   @option params [Hash]   :query appended to the 'scheme://host:port/path/' in the form of '?key=value'
+        #   @option params [String] :scheme The protocol; 'https' causes OpenSSL to be used
+        #   @return [Excon::Response]
+        #   @see https://github.com/geemus/excon/blob/master/lib/excon/connection.rb
+        #
+        # @overload request(method, path, expected_responses, params = {})
+        #   @param [String] method HTTP method to use for the request
+        #   @param [String] path   The absolute path for the request
+        #   @param [Array<Fixnum>] expected_responses HTTP response codes that have been successful
+        #   @param [Hash] params Keys and values for JSON
+        #   @option params [String] :account_id The scoping account if required
+        #   @deprecated #request with multiple arguments is deprecated
+        #     since it is inconsistent with original fog version.
+        #   @return [Hash]
+        def request(*args)
+          if args.size == 1
+            authenticated_request(*args)
+          else
+            Fog::Logger.deprecation("#request with multiple parameters is deprecated, use #wrapped_request instead [light_black](#{caller.first})[/]")
+            wrapped_request(*args)
+          end
         end
 
-        # Returns the scoped account being used for requests
+        # Makes a request but with seperated arguments and parses the response to a hash
         #
-        # API Clients:: This is the owning account
-        # User Apps::   This is the account specified by either +account_id+
-        #               option on a connection or the +brightbox_account+
-        #               setting in your configuration
+        # @note #wrapped_request is the non-standard form of request introduced by mistake
         #
-        # === Returns:
+        # @param [String] method HTTP method to use for the request
+        # @param [String] path   The absolute path for the request
+        # @param [Array<Fixnum>] expected_responses HTTP response codes that have been successful
+        # @param [Hash]  parameters Keys and values for JSON
+        # @option parameters [String] :account_id The scoping account if required
         #
-        # <tt>Fog::Compute::Brightbox::Account</tt>
-        #
-        def account
-          Fog::Compute::Brightbox::Account.new(get_scoped_account)
+        # @return [Hash]
+        def wrapped_request(method, path, expected_responses, parameters = {})
+          _wrapped_request(method, path, expected_responses, parameters)
         end
 
       private
-        def get_oauth_token(options = {})
-          auth_url = options[:brightbox_auth_url] || @auth_url
-
-          connection = Fog::Connection.new(auth_url)
-          authentication_body_hash = if @brightbox_username && @brightbox_password
-            {
-              'client_id' => @brightbox_client_id,
-              'grant_type' => 'password',
-              'username' => @brightbox_username,
-              'password' => @brightbox_password
-            }
-          else
-            {'client_id' => @brightbox_client_id, 'grant_type' => 'none'}
-          end
-          @authentication_body = Fog::JSON.encode(authentication_body_hash)
-
-          response = connection.request({
-            :path => "/token",
-            :expects  => 200,
-            :headers  => {
-              'Authorization' => "Basic " + Base64.encode64("#{@brightbox_client_id}:#{@brightbox_secret}").chomp,
-              'Content-Type' => 'application/json'
-            },
-            :method   => 'POST',
-            :body     => @authentication_body
-          })
-          @oauth_token = Fog::JSON.decode(response.body)["access_token"]
-          return @oauth_token
-        end
 
-        def make_request(params)
-          begin
-            get_oauth_token if @oauth_token.nil?
-            response = authenticated_request(params)
-          rescue Excon::Errors::Unauthorized
-            get_oauth_token
-            response = authenticated_request(params)
+        # Wrapped request is the non-standard form of request introduced by mistake
+        #
+        # @param [String] method HTTP method to use for the request
+        # @param [String] path   The absolute path for the request
+        # @param [Array<Fixnum>] expected_responses HTTP response codes that have been successful
+        # @param [Hash]  parameters Keys and values for JSON
+        # @option parameters [String] :account_id The scoping account if required
+        #
+        # @return [Hash]
+        def _wrapped_request(method, path, expected_responses, parameters = {})
+          request_options = {
+            :method   => method.to_s.upcase,
+            :path     => path,
+            :expects  => expected_responses
+          }
+
+          # Select the account to scope for this request
+          account = scoped_account(parameters.fetch(:account_id, nil))
+          if account
+            request_options[:query] = { :account_id => account }
           end
+
+          request_options[:body] = Fog::JSON.encode(parameters) unless parameters.empty?
+
+          response = make_request(request_options)
+
+          # FIXME We should revert to returning the Excon::Request after a suitable
+          # configuration option is in place to switch back to this incorrect behaviour
           unless response.body.empty?
-            response = Fog::JSON.decode(response.body)
+            Fog::JSON.decode(response.body)
+          else
+            response
           end
         end
 
-        def authenticated_request(options)
-          headers = options[:headers] || {}
-          headers.merge!("Authorization" => "OAuth #{@oauth_token}", "Content-Type" => "application/json")
-          options[:headers] = headers
-          @connection.request(options)
-        end
-
         # Queries the API and tries to select the most suitable official Image
         # to use if the user chooses not to select their own.
         def select_default_image