marketo_api 0.0.7.pre.alpha

data/lib/marketo_api/concerns/caching.rb

@@ -0,0 +1,24 @@
+module MarketoApi
+  module Concerns
+    module Caching
+      # Public: Runs the block with caching disabled.
+      #
+      # block - A query/describe/etc.
+      #
+      # Returns the result of the block
+      def without_caching(&block)
+        options[:use_cache] = false
+        block.call
+      ensure
+        options.delete(:use_cache)
+      end
+
+      private
+
+      # Internal: Cache to use for the caching middleware
+      def cache
+        options[:cache]
+      end
+    end
+  end
+end

data/lib/marketo_api/concerns/connection.rb

@@ -0,0 +1,75 @@
+module MarketoApi
+  module Concerns
+    module Connection
+      # Public: The Faraday::Builder instance used for the middleware stack. This
+      # can be used to insert an custom middleware.
+      #
+      # Examples
+      #
+      #   # Add the instrumentation middleware for Rails.
+      #   client.middleware.use FaradayMiddleware::Instrumentation
+      #
+      # Returns the Faraday::Builder for the Faraday connection.
+      def middleware
+        connection.builder
+      end
+      alias_method :builder, :middleware
+
+      private
+
+      # Internal: Internal faraday connection where all requests go through
+      def connection
+        @connection ||= Faraday.new(options[:instance_url], connection_options) do |builder|
+          # Converts the request into JSON.
+          builder.request(:json)
+
+          # Handles reauthentication for 403 responses.
+          if authentication_middleware
+            builder.use(authentication_middleware, self, options)
+          end
+
+          # Sets the oauth token in the headers.
+          builder.use(MarketoApi::Middleware::Authorization, self, options)
+
+          # Ensures the instance url is set.
+          # builder.use(MarketoApi::Middleware::InstanceURL, self, options)
+
+          # Caches GET requests.
+          builder.use(MarketoApi::Middleware::Caching, cache, options) if cache
+
+          # Follows 30x redirects.
+          builder.use(FaradayMiddleware::FollowRedirects)
+
+          # Raises errors for 40x responses.
+          builder.use(MarketoApi::Middleware::RaiseError)
+
+          # Parses returned JSON response into a hash.
+          builder.response(:json, content_type: /\bjson$/)
+
+          # Inject custom headers into requests
+          # builder.use(MarketoApi::Middleware::CustomHeaders, self, options)
+
+          # Log request/responses
+          builder.use(MarketoApi::Middleware::Logger, MarketoApi.configuration.logger, options) if MarketoApi.log?
+
+          builder.adapter(adapter)
+        end
+      end
+
+      def adapter
+        options[:adapter]
+      end
+
+      # Internal: Faraday Connection options
+      def connection_options
+        {
+          request: {
+            timeout: options[:timeout],
+            open_timeout: options[:timeout]
+          },
+          ssl: options[:ssl]
+        }
+      end
+    end
+  end
+end

data/lib/marketo_api/concerns/verbs.rb

@@ -0,0 +1,60 @@
+module MarketoApi
+  module Concerns
+    module Verbs
+      # Internal: Define methods to handle a verb.
+      #
+      # verbs - A list of verbs to define methods for.
+      #
+      # Examples
+      #
+      #   define_verbs :get, :post
+      #
+      # Returns nil.
+      def define_verbs(*verbs)
+        verbs.each do |verb|
+          define_verb(verb)
+          define_api_verb(verb)
+        end
+      end
+
+      # Internal: Defines a method to handle HTTP requests with the passed in
+      # verb.
+      #
+      # verb - Symbol name of the verb (e.g. :get).
+      #
+      # Examples
+      #
+      #   define_verb :get
+      #   # => get '/rest/v1/leads'
+      #
+      # Returns nil.
+      def define_verb(verb)
+        define_method verb do |*args, &block|
+          begin
+            connection.send(verb, *args, &block)
+          rescue MarketoApi::UnauthorizedError
+            raise
+          end
+        end
+      end
+
+      # Internal: Defines a method to handle HTTP requests with the passed in
+      # verb to a marketo api endpoint.
+      #
+      # verb - Symbol name of the verb (e.g. :get).
+      #
+      # Examples
+      #
+      #   define_api_verb :get
+      #   # => api_get 'leads'
+      #
+      # Returns nil.
+      def define_api_verb(verb)
+        define_method :"api_#{verb}" do |*args, &block|
+          args[0] = api_path(args[0])
+          send(verb, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/marketo_api/config.rb

@@ -0,0 +1,131 @@
+# Totally took this from Restforce.
+require 'logger'
+
+module MarketoApi
+  class << self
+    attr_writer :log
+
+    # Returns the current Configuration
+    #
+    # Example
+    #
+    #    MarketoApi.configuration.api_version = "1.0"
+    #    MarketoApi.configuration.cache = "ActiveSupport::Cache.lookup_store :redis_store"
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields the Configuration
+    #
+    # Example
+    #
+    #    MarketoApi.configure do |config|
+    #      config.api_version = "1.0"
+    #      config.cache = "ActiveSupport::Cache.lookup_store :redis_store"
+    #    end
+    def configure
+      yield configuration
+    end
+
+    def log?
+      @log ||= false
+    end
+
+    def log(message)
+      return unless MarketoApi.log?
+      configuration.logger.send(configuration.log_level, message)
+    end
+  end
+
+  class Configuration
+    class Option
+      attr_reader :configuration, :name, :options
+
+      def self.define(*args)
+        new(*args).define
+      end
+
+      def initialize(configuration, name, options = {})
+        @configuration = configuration
+        @name = name
+        @options = options
+        @default = options.fetch(:default, nil)
+      end
+
+      def define
+        write_attribute
+        define_method if default_provided?
+        self
+      end
+
+      private
+
+      attr_reader :default
+      alias_method :default_provided?, :default
+
+      def write_attribute
+        configuration.send :attr_accessor, name
+      end
+
+      def define_method
+        our_default = default
+        our_name    = name
+        configuration.send :define_method, our_name do
+          instance_variable_get(:"@#{our_name}") ||
+            instance_variable_set(
+              :"@#{our_name}",
+              our_default.respond_to?(:call) ? our_default.call : our_default
+            )
+        end
+      end
+    end
+
+    class << self
+      attr_accessor :options
+
+      def option(*args)
+        option = Option.define(self, *args)
+        (self.options ||= []) << option.name
+      end
+    end
+
+    option :api_version, default: lambda { ENV['MARKETO_API_VERSION'] || '1' }
+
+    # The OAuth client id
+    option :client_id, default: lambda { ENV['MARKETO_CLIENT_ID'] }
+
+    # The OAuth client secret
+    option :client_secret, default: lambda { ENV['MARKETO_CLIENT_SECRET'] }
+
+    option :oauth_token
+
+    # The url to make all requests
+    option :instance_url
+
+    # Set this to an object that responds to read, write and fetch and all GET
+    # requests will be cached.
+    option :cache
+
+    # Faraday request read/open timeout.
+    option :timeout
+
+    # Faraday adapter to use. Defaults to Faraday.default_adapter.
+    option :adapter, default: lambda { Faraday.default_adapter }
+
+    # Set SSL options
+    option :ssl, default: {}
+
+    # A Hash that is converted to HTTP headers
+    option :request_headers
+
+    # Set a logger for when MarketoApi.log is set to true, defaulting to STDOUT
+    option :logger, default: ::Logger.new(STDOUT)
+
+    # Set a log level for logging when MarketoApi.log is set to true, defaulting to :debug
+    option :log_level, default: :debug
+
+    def options
+      self.class.options
+    end
+  end
+end

data/lib/marketo_api/middleware.rb

@@ -0,0 +1,27 @@
+module MarketoApi
+  # Base class that all middleware can extend. Provides some convenient helper
+  # functions.
+  class Middleware < Faraday::Middleware
+    autoload :RaiseError,     'marketo_api/middleware/raise_error'
+    autoload :Authentication, 'marketo_api/middleware/authentication'
+    autoload :Authorization,  'marketo_api/middleware/authorization'
+    autoload :Caching,        'marketo_api/middleware/caching'
+    autoload :Logger,         'marketo_api/middleware/logger'
+
+    def initialize(app, client, options)
+      @app = app
+      @client = client
+      @options = options
+    end
+
+    # Internal: Proxy to the client.
+    def client
+      @client
+    end
+
+    # Internal: Proxy to the client's faraday connection.
+    def connection
+      client.send(:connection)
+    end
+  end
+end

data/lib/marketo_api/middleware/authentication.rb

@@ -0,0 +1,64 @@
+module MarketoApi
+  # Faraday middleware that allows for on the fly authentication of requests.
+  # When a request fails (a status of 401 is returned), the middleware
+  # will attempt to either reauthenticate (request new access_token).
+  class Middleware::Authentication < MarketoApi::Middleware
+    autoload :Token, 'marketo_api/middleware/authentication/token'
+
+    # Rescue from 401's, authenticate then raise the error again so the client
+    # can reissue the request.
+    def call(env)
+      @app.call(env)
+    rescue MarketoApi::UnauthorizedError
+      authenticate!
+      raise
+    end
+
+    # Internal: Performs the authentication and returns the response body.
+    def authenticate!
+      encoded_params = URI.encode_www_form(params)
+      token_url = @options[:instance_url] + '/identity/oauth/token'
+      url = "#{token_url}?#{encoded_params}"
+      response = connection.get(url)
+
+      if response.status >= 500
+        raise MarketoApi::ServerError, error_message(response)
+      elsif response.status != 200
+        raise MarketoApi::AuthenticationError, error_message(response)
+      end
+
+      @options[:oauth_token] = response.body['access_token']
+      @options[:expires_in]  = response.body['expires_in']
+
+      response.body
+    end
+
+    # Internal: The params to post to the OAuth service.
+    def params
+      raise NotImplementedError
+    end
+
+    # Internal: Faraday connection to use when sending an authentication request.
+    def connection
+      @connection ||= Faraday.new(faraday_options) do |builder|
+        builder.use(Faraday::Request::UrlEncoded)
+        builder.response(:json)
+
+        builder.use(MarketoApi::Middleware::Logger, MarketoApi.configuration.logger, @options) if MarketoApi.log?
+
+        builder.adapter(@options[:adapter])
+      end
+    end
+
+    # Internal: The parsed error response.
+    def error_message(response)
+      "#{response.body['error']}: #{response.body['error_description']}"
+    end
+
+    private
+
+    def faraday_options
+      { url: @options[:instance_url], ssl: @options[:ssl] }
+    end
+  end
+end

data/lib/marketo_api/middleware/authentication/token.rb

@@ -0,0 +1,12 @@
+module MarketoApi
+  # Authentication middleware used to fetch the access_token
+  class Middleware::Authentication::Token < MarketoApi::Middleware::Authentication
+    def params
+      {
+        grant_type: 'client_credentials',
+        client_id: @options[:client_id],
+        client_secret: @options[:client_secret]
+      }
+    end
+  end
+end

data/lib/marketo_api/middleware/authorization.rb

@@ -0,0 +1,16 @@
+module MarketoApi
+  # Piece of middleware that simply injects the OAuth token into the request
+  # headers.
+  class Middleware::Authorization < MarketoApi::Middleware
+    AUTH_HEADER = 'Authorization'.freeze
+
+    def call(env)
+      env[:request_headers][AUTH_HEADER] = %(Bearer #{token})
+      @app.call(env)
+    end
+
+    def token
+      @options[:oauth_token]
+    end
+  end
+end

data/lib/marketo_api/middleware/caching.rb

@@ -0,0 +1,26 @@
+module MarketoApi
+  class Middleware::Caching < FaradayMiddleware::Caching
+    def call(env)
+      expire(cache_key(env)) unless use_cache?
+      super
+    end
+
+    def expire(key)
+      cache.delete(key) if cache
+    end
+
+    # We don't want to cache requests for different clients, so append the
+    # oauth token to the cache key.
+    def cache_key(env)
+      super(env) + hashed_auth_header(env)
+    end
+
+    def use_cache?
+      @options.fetch(:use_cache, true)
+    end
+
+    def hashed_auth_header(env)
+      Digest::SHA1.hexdigest(env[:request_headers][MarketoApi::Middleware::Authorization::AUTH_HEADER])
+    end
+  end
+end

data/lib/marketo_api/middleware/logger.rb

@@ -0,0 +1,40 @@
+require 'forwardable'
+
+module MarketoApi
+  class Middleware::Logger < Faraday::Response::Middleware
+    extend Forwardable
+
+    def initialize(app, logger, options)
+      super(app)
+      @options = options
+      @logger = logger || begin
+        require 'logger'
+        ::Logger.new(STDOUT)
+      end
+    end
+
+    def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+    def call(env)
+      debug('request') do
+        dump url: env[:url].to_s,
+          method: env[:method],
+          headers: env[:request_headers],
+          body: env[:body]
+      end
+      super
+    end
+
+    def on_complete(env)
+      debug('response') do
+        dump status: env[:status].to_s,
+          headers: env[:response_headers],
+          body: env[:body]
+      end
+    end
+
+    def dump(hash)
+      "\n" + hash.map { |k, v| "  #{k}: #{v.inspect}" }.join("\n")
+    end
+  end
+end