stacker_bee 1.0.0

data/lib/stacker_bee.rb

@@ -0,0 +1,16 @@
+require_stacker_bee = if defined?(require_relative)
+                        lambda do |path|
+                          require_relative path
+                        end
+                      else # for 1.8.7
+                        lambda do |path|
+                          require "stacker_bee/#{path}"
+                        end
+                      end
+
+%w(
+  version
+  client
+).each do |file_name|
+  require_stacker_bee["stacker_bee/#{file_name}"]
+end

data/lib/stacker_bee/api.rb

@@ -0,0 +1,44 @@
+require "multi_json"
+require "stacker_bee/utilities"
+
+module StackerBee
+  class API
+    include Utilities
+
+    attr_accessor :api_path
+
+    def initialize(attrs = {})
+      attrs.each_pair do |key, value|
+        setter = "#{key}="
+        send(setter, value)
+      end
+    end
+
+    def [](key)
+      endpoints[uncase(key)]
+    end
+
+    def key?(key)
+      endpoints.key? uncase(key)
+    end
+
+    protected
+
+    def endpoints
+      @endpoints ||= read_endpoints
+    end
+
+    def read_endpoints
+      return unless api_path
+      json     = File.read(api_path)
+      response = MultiJson.load(json)
+      apis_by_endpoint(response)
+    end
+
+    def apis_by_endpoint(response)
+      response["listapisresponse"]["api"].each_with_object({}) do |api, memo|
+        memo[uncase(api["name"])] = api
+      end
+    end
+  end
+end

data/lib/stacker_bee/body_parser.rb

@@ -0,0 +1,23 @@
+require "multi_json"
+require "stacker_bee/rash"
+
+module StackerBee
+  module BodyParser
+    attr_reader :body
+
+    def body=(raw_response)
+      @body = parse(raw_response.body)
+    end
+
+    def parse(json)
+      parsed = MultiJson.load(json)
+      fail "Cannot determine response key in #{parsed.keys}" if parsed.size > 1
+      case value = parsed.values.first
+      when Hash  then Rash.new(value)
+      when Array then value.map { |item| Rash.new(item) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/stacker_bee/client.rb

@@ -0,0 +1,105 @@
+require "forwardable"
+require "stacker_bee/configuration"
+require "stacker_bee/api"
+require "stacker_bee/connection"
+require "stacker_bee/request"
+require "stacker_bee/response"
+
+module StackerBee
+  class Client
+    DEFAULT_API_PATH = File.join(
+      File.dirname(__FILE__), '../../config/4.2.json'
+    )
+
+    extend Forwardable
+    def_delegators :configuration,
+                   :logger,
+                   :logger=,
+                   :url,
+                   :url=,
+                   :api_key,
+                   :api_key=,
+                   :secret_key,
+                   :secret_key=
+
+    class << self
+
+      def reset!
+        @api, @api_path, @default_config = nil
+      end
+
+      def default_config
+        @default_config ||= {
+          allow_empty_string_params: false
+        }
+      end
+
+      def configuration=(config_hash)
+        default_config.merge!(config_hash)
+      end
+
+      def api_path
+        @api_path ||= DEFAULT_API_PATH
+      end
+
+      def api_path=(new_api_path)
+        return @api_path if @api_path == new_api_path
+        @api = nil
+        @api_path = new_api_path
+      end
+
+      def api
+        @api ||= API.new(api_path: api_path)
+      end
+    end
+
+    def initialize(config = {})
+      self.configuration = config
+    end
+
+    def configuration=(config)
+      @configuration = configuration_with_defaults(config)
+    end
+
+    def configuration
+      @configuration ||= configuration_with_defaults
+    end
+
+    def request(endpoint_name, params = {})
+      request      = Request.new(endpoint_for(endpoint_name), api_key, params)
+      request.allow_empty_string_params =
+        configuration.allow_empty_string_params
+      raw_response = connection.get(request)
+      Response.new(raw_response)
+    end
+
+    def endpoint_for(name)
+      api = self.class.api[name]
+      api && api["name"]
+    end
+
+    def method_missing(name, *args, &block)
+      endpoint = endpoint_for(name)
+      if endpoint
+        request(endpoint, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(name, include_private = false)
+      self.class.api.key?(name) || super
+    end
+
+    protected
+
+    def connection
+      @connection ||= Connection.new(configuration)
+    end
+
+    def configuration_with_defaults(config = {})
+      config_hash = self.class.default_config.merge(config)
+      Configuration.new(config_hash)
+    end
+  end
+end

data/lib/stacker_bee/configuration.rb

@@ -0,0 +1,6 @@
+require "ostruct"
+
+module StackerBee
+  class Configuration < OpenStruct
+  end
+end

data/lib/stacker_bee/connection.rb

@@ -0,0 +1,31 @@
+require "faraday"
+require "uri"
+require "stacker_bee/middleware/signed_query"
+require "stacker_bee/middleware/logger"
+
+module StackerBee
+  class ConnectionError < Exception
+  end
+
+  class Connection
+    attr_accessor :configuration
+    def initialize(configuration)
+      @configuration = configuration
+      uri      = URI.parse(self.configuration.url)
+      @path    = uri.path
+      uri.path = ''
+      fail ConnectionError, "no protocol specified" unless uri.scheme
+      @faraday = Faraday.new(url: uri.to_s) do |faraday|
+        faraday.use      Middleware::SignedQuery, self.configuration.secret_key
+        faraday.use      Middleware::Logger, self.configuration.logger
+        faraday.adapter  Faraday.default_adapter  # Net::HTTP
+      end
+    end
+
+    def get(request)
+      @faraday.get(@path, request.query_params)
+    rescue Faraday::Error::ConnectionFailed
+      raise ConnectionError, "Failed to connect to #{configuration.url}"
+    end
+  end
+end

data/lib/stacker_bee/middleware/logger.rb

@@ -0,0 +1,48 @@
+require 'forwardable'
+require 'logger'
+require 'pp'
+
+module StackerBee
+  module Middleware
+    class Logger < Faraday::Response::Middleware
+      extend Forwardable
+      PROGNAME = "StackerBee"
+
+      attr_accessor :logger
+
+      def initialize(app, _logger = nil)
+        super(app)
+        self.logger = _logger
+        logger.progname ||= PROGNAME
+      end
+
+      def logger
+        @logger ||= ::Logger.new($stdout)
+      end
+
+      def_delegators :logger, :debug, :info, :warn, :error, :fatal
+
+      def call(env)
+        log_request(env)
+        super
+      end
+
+      def on_complete(env)
+        log_response(env)
+      end
+
+      def log_request(env)
+        info  "#{env[:method]} #{env[:url]}"
+        debug env[:request_headers].pretty_inspect
+      end
+
+      def log_response(env)
+        status_message = "Status: #{env[:status]}"
+        env[:status] < 400 ? info(status_message) : error(status_message)
+        debug env[:response_headers].pretty_inspect
+        debug env[:body]
+      end
+
+    end
+  end
+end

data/lib/stacker_bee/middleware/signed_query.rb

@@ -0,0 +1,29 @@
+require "faraday"
+require "base64"
+
+module StackerBee
+  module Middleware
+    class SignedQuery < Faraday::Middleware
+      def initialize(app, key)
+        @key = key
+        fail "Key cannot be nil" unless @key
+        super(app)
+      end
+
+      def call(env)
+        sign_uri(env[:url])
+        @app.call(env)
+      end
+
+      def sign_uri(uri)
+        downcased  = uri.query.downcase
+        nonplussed = downcased.gsub('+', '%20')
+        signed     = OpenSSL::HMAC.digest 'sha1', @key, nonplussed
+        encoded    = Base64.encode64(signed).chomp
+        escaped    = CGI.escape(encoded)
+
+        uri.query << "&signature=#{escaped}"
+      end
+    end
+  end
+end

data/lib/stacker_bee/rash.rb

@@ -0,0 +1,95 @@
+require 'forwardable'
+require "stacker_bee/utilities"
+
+module StackerBee
+  class Rash
+    extend Forwardable
+    include Utilities
+
+    def_delegators :@hash, *[
+      :default, :default_proc, :each_value, :empty?, :has_value?, :hash,
+      :length, :size, :value?, :values, :assoc, :each, :each_key, :each_pair,
+      :flatten, :invert, :keys, :key, :merge, :rassoc, :to_a, :to_h, :to_hash
+    ]
+
+    def initialize(hash = {})
+      @hash = {}
+      hash.each_pair do |key, value|
+        @hash[convert_key(key)] = convert_value(value)
+      end
+      @hash.freeze
+    end
+
+    def ==(other)
+      case other
+      when Rash
+        super || @hash == other.to_hash
+      when Hash
+        self == Rash.new(other)
+      else
+        super
+      end
+    end
+
+    def select(*args, &block)
+      Rash.new @hash.select(*args, &block)
+    end
+
+    def reject(*args, &block)
+      Rash.new @hash.reject(*args, &block)
+    end
+
+    def values_at(*keys)
+      @hash.values_at(*keys.map { |key| convert_key(key) })
+    end
+
+    def fetch(key, *args, &block)
+      @hash.fetch(convert_key(key), *args, &block)
+    end
+
+    def [](key)
+      @hash[convert_key(key)]
+    end
+
+    def key?(key)
+      @hash.key?(convert_key(key))
+    end
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?,  :key?
+
+    def to_hash
+      self.class.deep_dup(@hash)
+    end
+
+    def inspect
+      "#<#{self.class} #{@hash}>"
+    end
+    alias_method :to_s, :inspect
+
+    protected
+
+    def self.deep_dup(hash)
+      hash.dup.tap do |duplicate|
+        duplicate.each_pair do |key, value|
+          duplicate[key] = deep_dup(value) if value.is_a?(Hash)
+        end
+      end
+    end
+
+    def convert_key(key)
+      key.kind_of?(Numeric) ? key : uncase(key)
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        Rash.new(value)
+      when Array
+        value.map { |item| convert_value(item) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/stacker_bee/request.rb

@@ -0,0 +1,41 @@
+require "stacker_bee/utilities"
+
+module StackerBee
+  class Request
+    include Utilities
+
+    RESPONSE_TYPE = "json"
+
+    attr_accessor :params
+    attr_writer   :allow_empty_string_params
+
+    def initialize(endpoint, api_key, params = {})
+      params[:api_key]  = api_key
+      params[:command]  = endpoint
+      params[:response] = RESPONSE_TYPE
+      self.params = params
+    end
+
+    def query_params
+      params
+        .reject { |key, val| val.nil? }
+        .reject { |key, val| !allow_empty_string_params && val == '' }
+        .sort
+        .map { |(key, val)| [cloud_stack_key(key), cloud_stack_value(val)] }
+    end
+
+    def allow_empty_string_params
+      @allow_empty_string_params ||= false
+    end
+
+    private
+
+    def cloud_stack_key(key)
+      camel_case(key, true)
+    end
+
+    def cloud_stack_value(value)
+      value.respond_to?(:join) ? value.join(',') : value
+    end
+  end
+end