stacker_bee 2.0.0 → 2.1.0.pre180

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: c61314ae91d1a5401971f178fc31e00cd9b06687
-  data.tar.gz: 48d6f1e0eb6d767fdd42a3de0d1bfef4c6c30e22
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjM2MmUzMTI4NjMzMTkxMjUxOTAzYzk0NzBlN2ZmNGJlNDQ3NjFjYw==
+  data.tar.gz: !binary |-
+    Yjg3ZGM0M2E3MTU2Yzg1M2Q4YmY3NDZhZjMzNjRiYzIyOWY2ZjhmOQ==
 SHA512:
-  metadata.gz: 4acc5d7d764361a10298e3a2cbb95d877f474f3cd4790f7f5bb0799f59c86937bee7762f42e71a048a77894a05ad747b7ea5613b50396eddeec76e0dba4e6fff
-  data.tar.gz: 2d1c306caec103c7b0464fb3d44dbd00571c00031f122acd2a80e83962220286b4a4d1c5498d6bfe8270558b295a41217f0524a6f93e9024bddb35fcb7f61263
+  metadata.gz: !binary |-
+    N2I1ODhiMTY2NWVhYmUxNzE4OWViNTVmZDY4MjgzM2QyOGI0MTkyZDdiNzY1
+    OTk1YjJiMGIzMDUyYmZlZDQ5NGY4OTQzYzNhMjExZjg5MDk4MDc3ZmZiNzg0
+    ZTEzZDAxNzdiOTcxMDM0OWM2ZmI1NGRkN2JmNzUxZWZhOGFmYjE=
+  data.tar.gz: !binary |-
+    ZGIzOWIyYWM0MjZhYTBjOTNiZjVhOWUxZGJiNDg2NDA0MTE3NTM5NDUyN2Jl
+    ZGU1NzFjMzRhOTUzOTRmNTg4NjQ5NmE0MDBjYWU0NDZlYmExYjk0NDdlZTQ3
+    MmM0OGZmNTY1MmJlMWRjNzEwOGNjNjc5OGU4OTM4ODViZTUyYzA=

data/.travis.yml

@@ -1,9 +1,21 @@
 language: ruby
 rvm:
+  - 2.1.0
   - 2.0.0
   - 1.9.3
   - 1.9.2
   - jruby-19mode
-  - rbx-19mode
   - ruby-head
   - jruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+deploy:
+  provider: rubygems
+  api_key:
+    secure: d5hC4iuoXOsrQKJRd9GSyZP2UlO2v9HsayhgNk2RlQQJFbqki6TcIlxN6j39/QER3pM3MUZyvCewtvxjrijt4f82xJGHRXaVNZvPSyD91PkGUtOuibLojc+GmwrzzRpu0d3TSEuzeKBSVag7AuJFO3oQnhEyblyZPyqWh1Ii1nM=
+  gem: stacker_bee
+  on:
+    repo: promptworks/stacker_bee
+    ruby: 2.1.0

data/README.md

@@ -13,9 +13,11 @@ You can install StackerBee with rubygems:
 
     $ gem install stacker_bee
 
-If you are using Bundler simply add the following to your Gemfile:
+If you are using Bundler add the following to your Gemfile:
 
-    gem 'stacker_bee'
+```ruby
+gem 'stacker_bee'
+```
 
 And execute:
 
@@ -24,35 +26,42 @@ And execute:
 
 ## Basic Usage
 
-    cloud_stack = StackerBee::Client.new(
-      url:        'http://localhost:8080/client/api',
-      api_key:    'MY_API_KEY',
-      secret_key: 'MY_SECRET_KEY'
-    )
+```ruby
+cloud_stack = StackerBee::Client.new(
+  url:        'http://localhost:8080/client/api',
+  api_key:    'MY_API_KEY',
+  secret_key: 'MY_SECRET_KEY'
+)
 
-    cloud_stack.list_virtual_machines state: 'Running'
-    # => [ { id: '48b91ab4...', displayName: '...', ... },
-    #      { id: '59c02bc5...', displayName: '...', ... },
-    #      ... ]
+cloud_stack.list_virtual_machines state: 'Running'
+# => [ { id: '48b91ab4...', displayName: '...', ... },
+#      { id: '59c02bc5...', displayName: '...', ... },
+#      ... ]
 
-    cloud_stack.create_volume name: 'MyVolume'
+cloud_stack.create_volume name: 'MyVolume'
+```
 
 ## Features
 
 ### Idomatic Ruby formatting for names
 
-You can use `list_virtual_machines` instead of `listVirtualMachines` and
+For example, you can use `list_virtual_machines` instead of `listVirtualMachines` and
 `affinity_group_id` instead of `affinitygroupid` (if you want to).
 
 For example:
 
-    vm = cloud_stack.list_virtual_machines(affinity_group_id: id).first
-    puts vm[:iso_display_text]
+```ruby
+vm = cloud_stack.list_virtual_machines(affinity_group_id: id).first
+puts vm[:iso_display_text]
+```
 
 ### Handling 'map' parameters
 
-For any endpoint requiring a map parameter, simply pass in a hash.
-    create_tags(tags: { type: 'community'}, resource_type: "Template", resource_ids: id )
+For any endpoint requiring a map parameter, pass in a hash.
+
+```ruby
+cloud_stack.create_tags(tags: { type: 'community' }, resource_type: "Template", resource_ids: id )
+```
 
 This will yield a request with the following query string:
 
@@ -63,7 +72,9 @@ This will yield a request with the following query string:
 By default, StackerBee uses the CloudStack 4.2 API, but it doesn't have to.
 Use a different API version by setting the `api_path` configuration option to the path of a JSON file containing the response from your CloudStack instance's `listApis` command.
 
-    StackerBee::Client.api_path = '/path/to/your/listApis/response.json'
+```ruby
+StackerBee::Client.api_path = '/path/to/your/listApis/response.json'
+```
 
 ### CloudStack REPL
 
@@ -86,64 +97,106 @@ Example:
 
 Configuring a client:
 
-    cloud_stack = StackerBee::Client.new(
-      url:        'http://localhost:8080/client/api'
-      api_key:    'API_KEY',
-      secret_key: 'SECRET_KEY',
-      logger:     Rails.logger
-    )
+```ruby
+cloud_stack = StackerBee::Client.new(
+  url:        'http://localhost:8080/client/api',
+  api_key:    'API_KEY',
+  secret_key: 'SECRET_KEY'
+)
+```
 
 All configuration parameters set on the `StackerBee::Client` class are used as defaults for `StackerBee::Client` instances.
 
-    StackerBee::Client.url    = 'http://localhost:8080/client/api'
-    StackerBee::Client.logger = Rails.logger
+```ruby
+StackerBee::Client.url    = 'http://localhost:8080/client/api'
 
-    user_client = StackerBee::Client.new(
-      api_key:    'USER_API_KEY',
-      secret_key: 'USER_SECRET_KEY'
-    )
+user_client = StackerBee::Client.new(
+  api_key:    'USER_API_KEY',
+  secret_key: 'USER_SECRET_KEY'
+)
 
-    root_client = StackerBee::Client.new(
-      api_key:    'ROOT_API_KEY',
-      secret_key: 'ROOT_SECRET_KEY'
-    )
+root_client = StackerBee::Client.new(
+  api_key:    'ROOT_API_KEY',
+  secret_key: 'ROOT_SECRET_KEY'
+)
+```
 
 ### URL
 
 The URL of your CloudStack instance's URL.
 
-    StackerBee::Client.url = 'http://localhost:8080/client/api'
+```ruby
+StackerBee::Client.url = 'http://localhost:8080/client/api'
+```
 
 Or:
 
-    my_client = StackerBee::Client.new(
-      url: 'http://localhost:8080/client/api'
-    )
+```ruby
+my_client = StackerBee::Client.new(
+  url: 'http://localhost:8080/client/api'
+)
+```
 
 ### Keys
 
 Your CloudStack credentials, i.e. API key and secret key.
 
-    StackerBee::Client.api_key    = 'MY_API_KEY'
-    StackerBee::Client.secret_key = 'MY_SECRET_KEY'
+```ruby
+StackerBee::Client.api_key    = 'MY_API_KEY'
+StackerBee::Client.secret_key = 'MY_SECRET_KEY'
+```
 
 Or:
 
-    my_client = StackerBee::Client.new(
-      api_key:    'MY_API_KEY',
-      secret_key: 'MY_SECRET_KEY'
-    )
+```ruby
+my_client = StackerBee::Client.new(
+  api_key:    'MY_API_KEY',
+  secret_key: 'MY_SECRET_KEY'
+)
+```
+
+### Middleware
+
+StackerBee can be configured with middleware. It uses it's own middleware stack to implement some of its functionality.
+
+To add a middleware, use the `middlewares` configuration option. For example:
+
+```ruby
+class StdoutLoggingMiddleware < StackerBee::Middleware::Base
+  def call(env)
+    app.call(env)
+    p "CloudStack call: #{env.inspect}"
+  end
+end
+
+class PrependedMiddleware < StackerBee::Middleware::Base
+  def call(env) app.call(env) end
+end
+
+StackerBee::Client.configuration = {
+  middlewares: ->(builder) do
+    # Using `before` places the middleware before the default middlewares
+    builder.before PrependedMiddleware
+
+    # Using `use` places the middleware after the default middlewares,
+    # but before the request is sent to Faraday
+    builder.use StdoutLoggingMiddleware
+  end
+}
+```
 
 ### Faraday Middleware
 
-StackerBee is built on [Faraday](https://github.com/lostisland/faraday) and makes it easy for you to add Faraday middleware. Here's an example of adding your own middleware.
+StackerBee is built on [Faraday](https://github.com/lostisland/faraday) and allows you to add Faraday middleware. Here's an example of adding your own middleware.
 
-    StackerBee::Client.default_config = {
-      middlewares: ->(faraday) do
-        faraday.use Custom::LoggingMiddleware, Logger.new
-        faraday.use Custom::CachingMiddleware, Rails.cache
-      end
-    }
+```ruby
+StackerBee::Client.configuration = {
+  faraday_middlewares: ->(faraday) do
+    faraday.use Custom::LoggingMiddleware, Logger.new
+    faraday.use Custom::CachingMiddleware, Rails.cache
+  end
+}
+```
 
 StackerBee itself puts some middlewares on Faraday. Any middlewares you add will be placed after these. If you want your middleware to come as the very first, you can use Faraday's builder like `faraday.builder.insert 0, MyMiddleware`.
 
@@ -155,30 +208,35 @@ Logging is best handled with Faraday middleware.
 
 If you're using the Graylog2 GELF format, you're in luck because StackerBee currently ships with a Faraday middleware for that. Here's an example of logging to Graylog2:
 
-    logger = GELF::Notifier.new("localhost", 12201)
+```ruby
+logger = GELF::Notifier.new("localhost", 12201)
 
-    StackerBee::Client.default_config = {
-      middlewares: ->(faraday) { faraday.use faraday.use StackerBee::GraylogFaradayMiddleware, logger }
-    }
+StackerBee::Client.configuration = {
+  faraday_middlewares: ->(faraday) { faraday.use faraday.use StackerBee::GraylogFaradayMiddleware, logger }
+}
+```
 
 #### Basic logging
 
 To log to a file or STDOUT, Faraday has a built-in logger. You can use it like so:
 
-    StackerBee::Client.default_config = {
-      middlewares: ->(faraday) { faraday.response :logger }
-    }
+```ruby
+StackerBee::Client.configuration = {
+  faraday_middlewares: ->(faraday) { faraday.response :logger }
+}
+```
 
 ### Bulk Configuration
 
 The `StackerBee::Client` class can be configured with multiple options at once.
 
-    StackerBee::Client.default_config = {
-      url:        'http://localhost:8080/client/api',
-      logger:     Rails.logger,
-      api_key:    'API_KEY',
-      secret_key: 'MY_SECRET_KEY'
-    }
+```ruby
+StackerBee::Client.configuration = {
+  url:        'http://localhost:8080/client/api',
+  api_key:    'API_KEY',
+  secret_key: 'MY_SECRET_KEY'
+}
+```
 
 ## Contributing
 
@@ -202,6 +260,18 @@ This project uses [Rubocop](https://github.com/bbatsov/rubocop) to enforce code
 
     $ bundle exec rubocop
 
+### Releasing
+
+To create a release, first bump the version in `lib/stacker_bee/version.rb`, and commit. Then, build the gem and release it to Rubygems with `rake release`:
+
+    $ rake release
+    stacker_bee 1.2.3 built to pkg/stacker_bee-1.2.3.gem.
+    Tagged v1.2.3.
+    Pushed git commits and tags.
+    Pushed stacker_bee 1.2.3 to rubygems.org.
+
+We use Bundler's gem tasks to manage releases. See the output of `rake -T` and [Bundler's Rubygems documentation](http://bundler.io/rubygems.html) for more information.
+
 ## Thanks to
 
 - [Chip Childers](http://github.com/chipchilders) for a [reference implementation of a CloudStack client in Ruby](http://chipchilders.github.io/cloudstack_ruby_client/)

data/bin/stacker_bee

@@ -1,4 +1,7 @@
 #! /usr/bin/env ruby
+
+$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
 require 'optparse'
 require 'stacker_bee'
 require 'json'
@@ -54,7 +57,7 @@ begin
     options.merge! YAML.load(hash)
   end
   unless (%w(api_key secret_key url) - options.keys).empty?
-    puts "Please specify a config file or all of the following: " +
+    puts "Please specify a config file or all of the following: " \
          "--api_key, --secret_key and --url"
     exit
   end
@@ -68,8 +71,6 @@ if verbose
   puts "StackerBee version #{StackerBee::VERSION}"
   puts "URL: #{options["url"]}"
   puts "API key: #{options["api_key"]}"
-else
-  options['logger'] = Logger.new('/dev/null')
 end
 
 client = StackerBee::Client.new(options)

data/config.default.yml

@@ -1,3 +1,3 @@
-url: 'http://127.0.0.1:1234/client/api'
+url: 'http://127.0.0.1:1234/client/api/'
 api_key: 'MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY-KEY-MY'
 secret_key: 'TOP-SECRET-TOP-SECRET-TOP-SECRET-TOP-SECRET-TOP-SECRET-TOP-SECRET-TOP-SECRET-TOP-SECRE'

data/lib/stacker_bee/api.rb

@@ -9,8 +9,7 @@ module StackerBee
 
     def initialize(attrs = {})
       attrs.each_pair do |key, value|
-        setter = "#{key}="
-        send(setter, value)
+        send "#{key}=", value
       end
     end
 
@@ -19,7 +18,7 @@ module StackerBee
     end
 
     def key?(key)
-      endpoints.key? uncase(key)
+      endpoints.key?(uncase(key))
     end
 
     protected

data/lib/stacker_bee/client.rb

@@ -2,9 +2,23 @@ require "forwardable"
 require "stacker_bee/configuration"
 require "stacker_bee/api"
 require "stacker_bee/connection"
-require "stacker_bee/request"
-require "stacker_bee/dictionary_flattener"
-require "stacker_bee/response"
+require "stacker_bee/middleware/environment"
+require "stacker_bee/middleware/base"
+require "stacker_bee/middleware/adapter"
+require "stacker_bee/middleware/endpoint_normalizer"
+require "stacker_bee/middleware/remove_empty_strings"
+require "stacker_bee/middleware/cloud_stack_api"
+require "stacker_bee/middleware/dictionary_flattener"
+require "stacker_bee/middleware/remove_nils"
+require "stacker_bee/middleware/format_keys"
+require "stacker_bee/middleware/format_values"
+require "stacker_bee/middleware/json_body"
+require "stacker_bee/middleware/de_namespace"
+require "stacker_bee/middleware/rashify_response"
+require "stacker_bee/middleware/clean_response"
+require "stacker_bee/middleware/raise_on_http_error"
+require "stacker_bee/middleware/http_status"
+require "stacker_bee/middleware/console_access"
 
 module StackerBee
   class Client
@@ -21,6 +35,58 @@ module StackerBee
                    :secret_key,
                    :secret_key=
 
+    def middlewares
+      # request
+      builder.use Middleware::ConsoleAccess
+
+      builder.use Middleware::EndpointNormalizer, api: self.class.api
+      builder.use Middleware::RemoveEmptyStrings
+      builder.use Middleware::CloudStackAPI, api_key: configuration.api_key
+
+      configuration.middlewares.call builder
+
+      builder.use Middleware::DictionaryFlattener
+      builder.use Middleware::RemoveNils
+      builder.use Middleware::FormatKeys
+      builder.use Middleware::FormatValues
+
+      # response
+      builder.use Middleware::RaiseOnHTTPError
+      builder.use Middleware::HTTPStatus
+      builder.use Middleware::CleanResponse
+      builder.use Middleware::RashifyResponse
+      builder.use Middleware::DeNamespace
+      builder.use Middleware::JSONBody
+
+      builder.use Middleware::Adapter, connection: connection
+
+      builder.build
+    end
+
+    def builder
+      @builder ||= Builder.new
+    end
+
+    class Builder
+      attr_accessor :middlewares
+
+      def middlewares
+        @middlewares ||= []
+      end
+
+      def use(*middleware_definition)
+        middlewares << middleware_definition
+      end
+
+      def before(*middleware_definition)
+        middlewares.unshift middleware_definition
+      end
+
+      def build
+        middlewares.map { |klass, *args| klass.new(*args) }
+      end
+    end
+
     class << self
       def reset!
         @api, @api_path, @default_config = nil
@@ -28,8 +94,8 @@ module StackerBee
 
       def default_config
         @default_config ||= {
-          allow_empty_string_params: false,
-          middlewares: ->(*) {}
+          faraday_middlewares: proc {},
+          middlewares:         proc {}
         }
       end
 
@@ -65,29 +131,45 @@ module StackerBee
     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)
+      env = Middleware::Environment.new(
+        endpoint_name: endpoint_name,
+        api_key:       api_key,
+        params:        params
+      )
+
+      middleware_app.call(env)
+
+      env.response.body
     end
 
-    def endpoint_for(name)
-      api = self.class.api[name]
-      api && api["name"]
+    def middleware_app
+      @app ||= begin
+                 middleware_stack = middlewares
+
+                 last_middleware = nil
+                 middleware_stack.reverse.each do |middleware|
+                   middleware.app = last_middleware
+                   last_middleware = middleware
+                 end
+
+                 middleware_stack.first
+               end
     end
 
-    def method_missing(name, *args, &block)
-      endpoint = endpoint_for(name)
-      if endpoint
-        request(endpoint, *args, &block)
+    def method_missing(method_name, *args, &block)
+      if respond_to_via_delegation?(method_name)
+        request(method_name, *args, &block)
       else
         super
       end
     end
 
-    def respond_to?(name, include_private = false)
-      self.class.api.key?(name) || super
+    def respond_to?(method_name, include_private = false)
+      super || respond_to_via_delegation?(method_name)
+    end
+
+    def respond_to_via_delegation?(method_name)
+      !!middleware_app.endpoint_name_for(method_name)
     end
 
     protected

data/lib/stacker_bee/connection.rb

@@ -1,8 +1,7 @@
 require "faraday"
 require "uri"
-require "stacker_bee/middleware/signed_query"
-require "stacker_bee/middleware/logger"
-require "stacker_bee/middleware/detokenizer"
+require "stacker_bee/http_middleware/signed_query"
+require "stacker_bee/http_middleware/detokenizer"
 
 module StackerBee
   class ConnectionError < StandardError
@@ -13,26 +12,42 @@ module StackerBee
 
     def initialize(configuration)
       @configuration = configuration
-      uri      = URI.parse(self.configuration.url)
-      @path    = uri.path
+
+      uri = URI.parse(self.configuration.url)
       uri.path = ''
       fail ConnectionError, "no protocol specified" unless uri.scheme
-      initialize_faraday(uri)
+
+      ssl_verify = !configuration.ssl_verify.nil? ?
+        configuration.ssl_verify : true
+
+      initialize_faraday(url: uri.to_s,
+                         ssl: { verify: ssl_verify })
+    end
+
+    def initialize_faraday(options)
+      @faraday = Faraday.new(options) do |faraday|
+        faraday.use HTTPMiddleware::Detokenizer
+        faraday.use HTTPMiddleware::SignedQuery, configuration.secret_key
+
+        configuration.faraday_middlewares.call faraday
+
+        unless has_adapter?(faraday.builder.handlers)
+          faraday.adapter  Faraday.default_adapter  # Net::HTTP
+        end
+      end
     end
 
-    def initialize_faraday(uri)
-      @faraday = Faraday.new(url: uri.to_s) do |faraday|
-        faraday.use      Middleware::Detokenizer
-        faraday.use      Middleware::SignedQuery, configuration.secret_key
-        configuration.middlewares.call faraday
-        faraday.adapter  Faraday.default_adapter  # Net::HTTP
+    def has_adapter?(handlers)
+      handlers.detect do |handler|
+        handler.klass.ancestors.include?(Faraday::Adapter)
       end
     end
 
-    def get(request)
-      @faraday.get(@path, request.query_params)
-    rescue Faraday::Error::ConnectionFailed
-      raise ConnectionError, "Failed to connect to #{configuration.url}"
+    def get(params, path)
+      @faraday.get(path, params)
+    rescue Faraday::Error::ConnectionFailed => error
+      raise ConnectionError,
+        "Failed to connect to #{configuration.url}, #{error}"
     end
   end
 end

data/lib/stacker_bee/{middleware → http_middleware}/detokenizer.rb

@@ -2,7 +2,7 @@ require "faraday"
 require "base64"
 
 module StackerBee
-  module Middleware
+  module HTTPMiddleware
     class Detokenizer < Faraday::Middleware
       def call(env)
         detokenize(env[:url])
@@ -10,7 +10,8 @@ module StackerBee
       end
 
       def detokenize(uri)
-        uri.query = StackerBee::DictionaryFlattener.detokenize uri.query
+        uri.query =
+          StackerBee::Middleware::DictionaryFlattener.detokenize uri.query
       end
     end
   end

data/lib/stacker_bee/http_middleware/graylog.rb

@@ -0,0 +1,14 @@
+module StackerBee
+  module HTTPMiddleware
+    class Graylog < FaradayMiddleware::Graylog
+      def facility
+        'stacker-bee'
+      end
+
+      def short_message(env)
+        message = env[:url].query.scan(/&command=([^&]*)/).join(' ')
+        "StackerBee #{message}".strip
+      end
+    end
+  end
+end

data/lib/stacker_bee/{middleware → http_middleware}/signed_query.rb

@@ -2,7 +2,7 @@ require "faraday"
 require "base64"
 
 module StackerBee
-  module Middleware
+  module HTTPMiddleware
     class SignedQuery < Faraday::Middleware
       def initialize(app, key)
         @key = key

data/lib/stacker_bee/middleware/adapter.rb

@@ -0,0 +1,16 @@
+module StackerBee
+  module Middleware
+    class Adapter < Base
+      def call(env)
+        params = env.request.params.to_a.sort
+        env.raw_response = connection.get(params, env.request.path)
+        env.response.content_type =
+          env.raw_response.env[:response_headers]["content-type"]
+        env.response.body = env.raw_response.body
+      end
+
+      def endpoint_name_for(*)
+      end
+    end
+  end
+end