grifter 0.0.4

data/lib/grifter/blankslate.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+#
+#  Robert Schultheis (Knewton)
+#  This is a slightly modified BlankSlate, as taken from https://github.com/masover/blankslate
+#  Included is some stuff allowing us to send methods back to a parent
+#  Which makes our api script DSL very easy to use
+#
+#  Original file comments:
+#
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+######################################################################
+# BlankSlate provides an abstract base class with no predefined
+# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+# BlankSlate is useful as a base class when writing classes that
+# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+#
+class BlankSlate
+  class << self
+
+    # Hide the method named +name+ in the BlankSlate class.  Don't
+    # hide +instance_eval+ or any method beginning with "__".
+    def hide(name)
+      methods = instance_methods.map(&:to_sym)
+      if methods.include?(name.to_sym) and
+        name !~ /^(__|instance_eval)/
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+
+    def find_hidden_method(name)
+      @hidden_methods ||= {}
+      @hidden_methods[name] || superclass.find_hidden_method(name)
+    end
+
+    # Redefine a previously hidden method so that it may be called on a blank
+    # slate object.
+    def reveal(name)
+      hidden_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless hidden_method
+      define_method(name, hidden_method)
+    end
+  end
+
+  (instance_methods - [:object_id]).each { |m| hide(m) }
+
+  def initialize(parent)
+    @parent = parent
+  end
+
+  def method_missing(method_id, *arguments, &block)
+    @parent.send(method_id, *arguments, &block)
+  end
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+#
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Kernel
+      BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+#
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Object
+      BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+#
+class Module
+  alias blankslate_original_append_features append_features
+  def append_features(mod)
+    result = blankslate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      BlankSlate.hide(name)
+    end
+    result
+  end
+end

data/lib/grifter/configuration.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+
+require_relative 'log'
+
+class Grifter
+  module Configuration
+    def recursive_symbolize hash
+      hash.inject({}) do |h, (k,v)|
+        h[k.intern] = case v
+                      when Hash
+                        recursive_symbolize v
+                      else
+                        v
+                      end
+        h
+      end
+    end
+
+    def load_config_file options={}
+      options = {
+        config_file: ENV['GRIFTER_CONFIG_FILE'] ? ENV['GRIFTER_CONFIG_FILE'] : 'grifter.yml',
+        environment: ENV['GRIFTER_ENVIRONMENT'],
+      }.merge(options)
+      Log.debug "Loading config file '#{options[:config_file]}'"
+      unless File.exist?(options[:config_file])
+        raise "No such config file: '#{options[:config_file]}'"
+      end
+      hash = YAML.load_file(options[:config_file])
+      symbolized = recursive_symbolize(hash)
+      normalize_config(symbolized, options)
+    end
+
+    #this method ensure the config hash has everything we need to instantiate the service objects
+    def normalize_config config, options={}
+      unless ((config.is_a? Hash) &&
+              (config.has_key? :services) &&
+              (config[:services].is_a? Hash) &&
+              (config[:services].length > 0))
+        raise GrifterConfigurationError.new ":services block not found in configuration"
+      end
+
+      #fill out services block entirely for each service
+      config[:services].each_pair do |service_name, service_config|
+        service_config[:name] = service_name.to_s
+       #setup port config
+       unless service_config[:port]
+         if service_config[:ssl]
+           service_config[:port] = 443
+         else
+          service_config[:port] = 80
+         end
+       end
+
+       #ssl config
+       unless service_config[:ssl]
+         service_config[:ssl] = false
+       end
+
+       #ignore_ssl_certificate
+       unless service_config[:ignore_ssl_cert]
+         service_config[:ignore_ssl_cert] = false
+       end
+
+       unless service_config[:base_uri]
+         service_config[:base_uri] = ''
+       end
+
+      end
+
+      #merge any environment overrides into the service block
+      if options[:environment]
+        options[:environment] = options[:environment].to_sym
+        unless config[:environments] && config[:environments][options[:environment]]
+          raise GrifterConfigurationError.new "No such environment specified in config: '#{options[:environment]}'"
+        end
+
+        config[:environments][options[:environment]].each_pair do |service_name, service_overrides|
+          config[:services][service_name].merge! service_overrides
+        end
+      end
+
+
+      return config
+    end
+  end
+end
+
+class GrifterConfigurationError < Exception
+end

data/lib/grifter/helpers.rb

@@ -0,0 +1,24 @@
+require_relative '../grifter'
+
+class Grifter
+  module Helpers
+
+    def grifter_instance
+      @@grifter_instance ||= ::Grifter.new
+    end
+    module_function :grifter_instance
+
+    def self.included(mod)
+      def grifter
+        grifter_instance
+      end
+
+      grifter_instance.singleton_methods.each do |meth|
+        define_method meth do |*args, &block|
+          grifter_instance.send(meth, *args, &block)
+        end
+      end
+    end
+
+  end
+end

data/lib/grifter/http_service.rb

@@ -0,0 +1,142 @@
+require 'net/http'
+
+require_relative 'json_helpers'
+require_relative 'log'
+
+class Grifter
+  class HTTPService
+
+    include Grifter::JsonHelpers
+
+    def initialize config
+
+      @config = config
+      @name = config[:name]
+      @base_uri = config[:base_uri]
+
+      Log.debug "Configuring service '#{@name}' with:\n\t#{@config.inspect}"
+
+      @http = Net::HTTP.new(@config[:hostname], @config[:port])
+      @http.use_ssl = @config[:ssl]
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @config[:ignore_ssl_cert]
+
+      @headers = {
+        'accept' => 'application/json',
+        'content-type' => 'application/json',
+      }
+      if @config[:default_headers]
+        Log.debug "Default headers configured: " + @config[:default_headers].inspect
+        @config[:default_headers].each_pair do |k, v|
+          @headers[k.to_s] = v.to_s
+        end
+      end
+    end
+
+    #allow stubbing http if we are testing
+    attr_reader :http if defined?(RSpec)
+
+    attr_reader :headers, :name, :config
+
+    #this is useful for testing apis, and other times
+    #you want to interrogate the http details of a response
+    attr_reader :last_request, :last_response
+
+    RequestLogSeperator = '-'*40
+    def do_request req
+      Log.debug RequestLogSeperator
+      Log.debug "#{req.class} #{req.path}"
+      Log.debug "HEADERS: #{req.to_hash}"
+      Log.debug "BODY:\n#{req.body}" if req.request_body_permitted?
+      response = @http.request(req)
+      Log.debug "RESPONSE CODE: #{response.code}"
+      Log.debug "RESPONSE HEADERS: #{response.to_hash}"
+      Log.debug "RESPONSE BODY:\n#{jsonify response.body}\n"
+
+      @last_request = req
+      @last_response = response
+
+      raise RequestException.new(req, response) unless response.kind_of? Net::HTTPSuccess
+
+      objectify response.body
+    end
+
+    #add base uri to request
+    def make_path path_suffix, base_uri=nil
+      base_uri_to_use = base_uri ? base_uri : @base_uri
+      if base_uri_to_use
+        base_uri_to_use + path_suffix
+      else
+        path_suffix
+      end
+    end
+
+    def make_headers options
+      if options[:additional_headers]
+        @headers.merge options[:additional_headers]
+      elsif options[:headers]
+        options[:headers]
+      else
+        @headers
+      end
+    end
+
+    def req_args path, options
+      [make_path(path, options[:base_uri]), make_headers(options)]
+    end
+
+    def get path, options={}
+      req = Net::HTTP::Get.new(*req_args(path, options))
+      do_request req
+    end
+
+    def head path, options={}
+      req = Net::HTTP::Head.new(*req_args(path, options))
+      do_request req
+    end
+
+    def delete path, options={}
+      req = Net::HTTP::Delete.new(*req_args(path, options))
+      do_request req
+    end
+
+    def post path, obj, options={}
+      req = Net::HTTP::Post.new(*req_args(path, options))
+      req.body = jsonify(obj)
+      do_request req
+    end
+
+    def put path, obj, options={}
+      req = Net::HTTP::Put.new(*req_args(path, options))
+      req.body = jsonify(obj)
+      do_request req
+    end
+
+    def post_form path, params, options={}
+      request_obj = Net::HTTP::Post.new(*req_args(path, options))
+      request_obj.set_form_data params
+      request_obj.basic_auth(options[:username], options[:password]) if options[:username]
+      do_request request_obj
+    end
+  end
+
+  class RequestException < Exception
+    def initialize(request, response)
+      @request, @response = request, response
+    end
+
+    #this makes good info show up in rspec reports
+    def to_s
+      "#{self.class}\nResponseCode: #{@response.code}\nResponseBody:\n#{@response.body}"
+    end
+
+    #shortcut methods
+    def code
+      @response.code
+    end
+
+    def body
+      @response.body
+    end
+  end
+end
+

data/lib/grifter/json_helpers.rb

@@ -0,0 +1,38 @@
+require 'json'
+
+class Grifter
+  module JsonHelpers
+
+    #always returns a string, intended for request bodies
+    #every attempt is made to ensure string is valid json
+    #but if that is not possible, then its returned as is
+    def jsonify obj
+      case obj
+      when String
+        JSON.pretty_generate(JSON.parse(obj))
+      when Hash, Array
+        JSON.pretty_generate(obj)
+      else
+        obj.to_s
+      end
+    rescue Exception
+      obj.to_s
+    end
+    #module_function :jsonify
+
+    #attempts to parse json strings into native ruby objects
+    def objectify json_string
+      case json_string
+      when Hash, Array
+        return json_string
+      else
+        JSON.parse(json_string.to_s)
+      end
+    rescue Exception => e
+      Log.debug "Unable to parse non-json object: #{e.to_s}"
+      json_string
+    end
+    #module_function :objectify
+
+  end
+end

data/lib/grifter/log.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+class Grifter
+  class Log
+    GrifterFormatter = proc do |severity, datetime, progname, msg|
+      "#{severity[0]}: [#{datetime.strftime('%m/%d/%y %H:%M:%S')}][#{progname}] - #{msg}\n"
+    end
+
+    @@loggers = []
+    def self.add_logger handle
+      new_logger = Logger.new handle
+      new_logger.progname = 'grifter'
+      new_logger.formatter = GrifterFormatter
+      @@loggers << new_logger
+    end
+
+    self.add_logger(STDOUT)
+
+    def self.level= log_level
+      @@loggers.each { |logger| logger.level = log_level}
+    end
+
+    def self.log level, msg
+      @@loggers.each {|logger| logger.send(level, msg)}
+    end
+
+    [:fatal, :error, :warn, :info,:debug].each do |log_method|
+      define_singleton_method log_method do |msg|
+        log(log_method, msg)
+      end
+    end
+  end
+end
+
+