stacker_bee 1.0.1 → 2.0.0.pre.pre164

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 113d9dc3b7034e99f4fa25d03b558de6f6a71c67
-  data.tar.gz: 3ec61352a7c75f6cdf92fbe7bd628fd2d3890d15
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZmNkOGY0ZGRkY2Y0MjYzZGZmYzJjMWI0MTZjMzU5MTIwNWYyZDY5MA==
+  data.tar.gz: !binary |-
+    OTBhNzY3NmQ1ODU1MzliZGVmYWE4NWNhNGViMGMyNTdmNWI3NmY1OA==
 SHA512:
-  metadata.gz: 3583805c59178743eba73e67477b1d7a47e47dbd57e76248e2ab90ba398ebf2c452601c7c7b431039b22d612414d4c7fa874fec74ecea333ca0feceae53e21f0
-  data.tar.gz: e5bd192f9e42c7d9a6facca1fed0ab07339a089e329e41aaf6257516ede551e50f51e79963ede771ba183f8a8951a4b0bfc0919391c9ba5af9a5530905869739
+  metadata.gz: !binary |-
+    NmRlNzQ2MGU1ZjBlODlmYzJmZTFjY2Y5MjcyNWY5ZDI2MmFhNWQzODM4YjZm
+    NTZkZTZjZTQxNzI4NzFkOTFiMDVmYTdmZWQ3MDc3YjVjZGZkMDZhZmZjMjQ5
+    NzYxMmZmOWEzYWIyODZlOTZlOGZjYmE1ZDYwY2ViMjA1YzkzNzk=
+  data.tar.gz: !binary |-
+    ODNlNzY5MmJmZWE1MDhlNzkxZjYxNGZkNWU4Y2ExZGU5NmUzMjZmOWFiZTY1
+    NzM5ODBhYjgyZGY2MGI4NTkxM2UxYTZhNDE2NzAxYmQ5MDJkMWVkZGIxNzNh
+    NmIwZGI4MWE2MTQ1NTY1YTg1YWFkNGZmMjgxY2EzYjQxNWFmNTg=

data/.travis.yml

@@ -1,9 +1,22 @@
 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:
+    all_branches: true
+    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,55 +26,55 @@ 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.
+For any endpoint requiring a map parameter, pass in a hash.
 
-    create_tags(tags: { type: 'community'}, resource_type: "Template", resource_ids: id )
+```ruby
+cloud_stack.create_tags(tags: { type: 'community' }, resource_type: "Template", resource_ids: id )
+```
 
 This will yield a request with the following query string:
 
     ...&tags[0].key=type&tags[0].name=type&tags[0].value=community
 
-### Configurable Logger
-
-    StackerBee::Client.logger = Rails.logger
-
-Or
-
-    StackerBee::Client.logger = Logger.new
-
 ### Configurable API Version
 
 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
 
@@ -95,80 +97,116 @@ 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'
+)
+```
+
+### Faraday 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.
+
+```ruby
+StackerBee::Client.configuration = {
+  middlewares: ->(faraday) do
+    faraday.use Custom::LoggingMiddleware, Logger.new
+    faraday.use Custom::CachingMiddleware, Rails.cache
+  end
+}
+```
 
-### Logger
+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`.
 
-StackerBee can be configured with a custom `Logger`.
+### Logging
 
-    StackerBee::Client.logger = Logger.new
+Logging is best handled with Faraday middleware.
 
-Or
+#### GELF/Graylog2
 
-    my_client = StackerBee::Client.new(
-      logger: Logger.new
-    )
+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:
 
-For Rails apps, it's sometimes convenient to use Rail's logger:
+```ruby
+logger = GELF::Notifier.new("localhost", 12201)
 
-    StackerBee::Client.logger = Rails.logger
+StackerBee::Client.configuration = {
+  middlewares: ->(faraday) { 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:
+
+```ruby
+StackerBee::Client.configuration = {
+  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
 
@@ -192,6 +230,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/lib/faraday_middleware/response/graylog.rb

@@ -0,0 +1,35 @@
+require 'faraday_middleware'
+require 'faraday_middleware/response_middleware'
+
+module FaradayMiddleware
+  class Graylog < ResponseMiddleware
+    INFO  = 1
+    ERROR = 3
+
+    attr_accessor :facility
+
+    def initialize(app, logger, options = {})
+      @logger       = logger
+      self.facility = options[:facility] || "faraday-middleware-graylog"
+
+      super app, options
+    end
+
+    def process_response(env)
+      @logger.notify(
+        facility:      facility,
+        short_message: short_message(env),
+        level:         level(env),
+        _data:         env.dup.tap { |e| e.delete(:response) }
+      )
+    end
+
+    def short_message(env)
+      facility + " Request"
+    end
+
+    def level(env)
+      env[:status] < 400 ? INFO : ERROR
+    end
+  end
+end

data/lib/stacker_bee/body_parser.rb

@@ -6,7 +6,17 @@ module StackerBee
     attr_reader :body
 
     def body=(raw_response)
-      @body = parse(raw_response.body)
+      response_body = raw_response.body
+
+      unless html?(raw_response)
+        response_body = parse(response_body)
+      end
+
+      @body = response_body
+    end
+
+    def html?(raw_response)
+      raw_response.headers['content-type'].to_s.match(%r{/html})
     end
 
     def parse(json)

data/lib/stacker_bee/client.rb

@@ -7,15 +7,33 @@ require "stacker_bee/dictionary_flattener"
 require "stacker_bee/response"
 
 module StackerBee
+  module ConsoleAccess
+    ENDPOINT = "consoleAccess"
+    PATH = "/client/console"
+
+    def console_access(options)
+      options.merge!(cmd: 'access')
+      request("consoleAccess", options)
+    end
+
+    def path_for_endpoint(endpoint_name)
+      PATH if endpoint_name == ENDPOINT
+    end
+
+    def endpoint_for(name)
+      name if name == ENDPOINT
+    end
+  end
+
   class Client
     DEFAULT_API_PATH = File.join(
       File.dirname(__FILE__), '../../config/4.2.json'
     )
 
+    include ConsoleAccess
+
     extend Forwardable
     def_delegators :configuration,
-                   :logger,
-                   :logger=,
                    :url,
                    :url=,
                    :api_key,
@@ -30,7 +48,8 @@ module StackerBee
 
       def default_config
         @default_config ||= {
-          allow_empty_string_params: false
+          allow_empty_string_params: false,
+          middlewares: ->(*) {}
         }
       end
 
@@ -69,11 +88,20 @@ module StackerBee
       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)
+      path = path_for_endpoint(endpoint_name)
+      raw_response = connection.get(request, path)
       Response.new(raw_response)
     end
 
+    def path_for_endpoint(endpoint_name)
+      super || URI.parse(configuration.url).path
+    end
+
     def endpoint_for(name)
+      if result = super
+        return result
+      end
+
       api = self.class.api[name]
       api && api["name"]
     end

data/lib/stacker_bee/connection.rb

@@ -1,11 +1,10 @@
 require "faraday"
 require "uri"
 require "stacker_bee/middleware/signed_query"
-require "stacker_bee/middleware/logger"
 require "stacker_bee/middleware/detokenizer"
 
 module StackerBee
-  class ConnectionError < Exception
+  class ConnectionError < StandardError
   end
 
   class Connection
@@ -13,8 +12,7 @@ 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)
@@ -24,15 +22,16 @@ module StackerBee
       @faraday = Faraday.new(url: uri.to_s) do |faraday|
         faraday.use      Middleware::Detokenizer
         faraday.use      Middleware::SignedQuery, configuration.secret_key
-        faraday.use      Middleware::Logger, configuration.logger
+        configuration.middlewares.call faraday
         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}"
+    def get(request, path)
+      @faraday.get(path, request.query_params)
+    rescue Faraday::Error::ConnectionFailed => error
+      raise ConnectionError,
+        "Failed to connect to #{configuration.url}, #{error}"
     end
   end
 end

data/lib/stacker_bee/dictionary_flattener.rb

@@ -6,36 +6,36 @@ module StackerBee
     attr_accessor :params
 
     def self.tokenize(key)
-      key.gsub(/\[/, LB).gsub(/\]/, RB)
+      key.gsub("[", LB).gsub("]", RB)
     end
 
     def self.detokenize(key)
-      key.gsub(/#{LB}/, "[").gsub(/#{RB}/, "]")
+      key.gsub(LB, "[").gsub(RB, "]")
     end
 
     def initialize(params)
-      @params = params.dup
+      self.params = params.dup
       flatten_params
     end
 
     def flatten_params
-      hashes = params.select { |key, val|  val.respond_to? :keys }
-      flatten_map_values(params, hashes)
+      hashes = params.select { |_, val| val.respond_to?(:keys) }
+      flatten_map_values params, hashes
     end
 
     def flatten_map_values(params, hashes)
-      hashes.each do |outer|
-        remove_empties(outer[1]).each_with_index do |array, index|
-          key = self.class.tokenize("#{outer[0]}[#{index}]")
-          params["#{key}.key"] = params["#{key}.name"] = array[0]
-          params["#{key}.value"] = array[1]
+      hashes.each do |hash_name, hash|
+        remove_empties(hash).each_with_index do |(key, value), index|
+          hash_url_key = self.class.tokenize("#{hash_name}[#{index}]")
+          params["#{hash_url_key}.key"] = params["#{hash_url_key}.name"] = key
+          params["#{hash_url_key}.value"] = value
         end
-        params.delete outer[0]
+        params.delete hash_name
       end
     end
 
     def remove_empties(hash)
-      hash.reject{ |k, v| v.nil? || v == "" }
+      hash.reject { |_, v| v.nil? || v == "" }
     end
   end
 end

data/lib/stacker_bee/graylog_faraday_middleware.rb

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

data/lib/stacker_bee/request_error.rb

@@ -1,7 +1,7 @@
 require "stacker_bee/body_parser"
 
 module StackerBee
-  class RequestError < Exception
+  class RequestError < StandardError
     include BodyParser
 
     def initialize(raw_body)

data/lib/stacker_bee/version.rb

@@ -1,3 +1,3 @@
 module StackerBee
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/stacker_bee.rb

@@ -1,2 +1,5 @@
 require_relative "stacker_bee/version"
 require_relative "stacker_bee/client"
+
+require_relative "faraday_middleware/response/graylog"
+require_relative "stacker_bee/graylog_faraday_middleware"

data/spec/cassettes/A_request_sent_to_CloudStack_for_console_access/returns_html_for_console_access.yml

@@ -0,0 +1,34 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: "<CLOUD_STACK_HOST>/client/console?apiKey=<CLOUD_STACK_API_KEY>&cmd=access&command=consoleAccess&response=json&signature=DsI/kxaNO7AgzDCgE1j/3rtq3xU&vm=36f9c08b-f17a-4d0e-ac9b-d45ce2d34fcd"
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.8.9
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Server:
+      - Apache-Coyote/1.1
+      Content-Type:
+      - text/html
+      Content-Length:
+      - '616'
+      Date:
+      - Tue, 11 Feb 2014 19:33:34 GMT
+    body:
+      encoding: UTF-8
+      string: "<html><title>console2</title><frameset><frame src=\"https://207-19-99-5.realhostip.com/ajax?token=FAKE_TOKEN\"></frame></frameset></html>"
+    http_version: 
+  recorded_at: Tue, 11 Feb 2014 19:34:25 GMT
+recorded_with: VCR 2.8.0

data/spec/integration/configure_middleware_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Client initialization configures the middleware" do
+
+  context "pass a new middleware to the client" do
+    subject { StackerBee::Client.new(configuration) }
+
+    let(:configuration) do
+      {
+        url:         "http://garbagestring",
+        api_key:     "HI!",
+        secret_key:  "SECRETT",
+        middlewares: ->(faraday) { faraday.use middleware_class }
+      }
+    end
+
+    let(:middleware_class) do
+      Class.new(Faraday::Middleware) do
+        def call(env)
+          fail "MiddlewareUsed"
+        end
+      end
+    end
+
+    it "uses the middle ware" do
+      expect { subject.list_virtual_machines }
+        .to raise_exception "MiddlewareUsed"
+    end
+  end
+end