stacker_bee 2.0.0.pre178 → 2.0.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjhmNmYwOWEwNDE5NmViNTkxMTZiZTIxNmQwNjA0NmFlMjUzOTk4OQ==
-  data.tar.gz: !binary |-
-    Y2IyNGIxYWI1ZTM1ODYwYTNkODM3MTlmMGYyZDZhNGNhYWQwYmU2OA==
+SHA1:
+  metadata.gz: c61314ae91d1a5401971f178fc31e00cd9b06687
+  data.tar.gz: 48d6f1e0eb6d767fdd42a3de0d1bfef4c6c30e22
 SHA512:
-  metadata.gz: !binary |-
-    Yzc3ZDZhNDIzNjcyNTdiYTFhNjcxMTE4NTRhZjRmNzk3ZmZiZDYzY2UyZTBm
-    MzVjMWY1YjRlNWJkNTQ1MWE3ZjEyNTcxMWM5YjdmMTNkODg2YTNhMzUzYTUx
-    ZDk5NWY4MjU3ZGRiN2ZkNDNhZGM3MzJlYjliOTk4YjAwMjE0MDM=
-  data.tar.gz: !binary |-
-    MWQ5YzMwNmI1ODA0ZjAyZmIzM2M0N2E1MzE3MGFmMjJkOGUxMmU0MDFiNThi
-    YjAxMDJlM2Q0OGU2NzNkZjE5MTViY2ZjOTgyNWZiM2ZiNWIwZWMyMDExZTlh
-    MTZmMDBkYjFmZWQ1ODZjZWVmMmYwYjQ1N2M5Y2JiMGI4NzM4Y2E=
+  metadata.gz: 4acc5d7d764361a10298e3a2cbb95d877f474f3cd4790f7f5bb0799f59c86937bee7762f42e71a048a77894a05ad747b7ea5613b50396eddeec76e0dba4e6fff
+  data.tar.gz: 2d1c306caec103c7b0464fb3d44dbd00571c00031f122acd2a80e83962220286b4a4d1c5498d6bfe8270558b295a41217f0524a6f93e9024bddb35fcb7f61263

data/.travis.yml

@@ -1,21 +1,9 @@
 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,11 +13,9 @@ You can install StackerBee with rubygems:
 
     $ gem install stacker_bee
 
-If you are using Bundler add the following to your Gemfile:
+If you are using Bundler simply add the following to your Gemfile:
 
-```ruby
-gem 'stacker_bee'
-```
+    gem 'stacker_bee'
 
 And execute:
 
@@ -26,42 +24,35 @@ And execute:
 
 ## Basic Usage
 
-```ruby
-cloud_stack = StackerBee::Client.new(
-  url:        'http://localhost:8080/client/api',
-  api_key:    'MY_API_KEY',
-  secret_key: 'MY_SECRET_KEY'
-)
+    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
 
-For example, you can use `list_virtual_machines` instead of `listVirtualMachines` and
+You can use `list_virtual_machines` instead of `listVirtualMachines` and
 `affinity_group_id` instead of `affinitygroupid` (if you want to).
 
 For example:
 
-```ruby
-vm = cloud_stack.list_virtual_machines(affinity_group_id: id).first
-puts vm[:iso_display_text]
-```
+    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, pass in a hash.
-
-```ruby
-cloud_stack.create_tags(tags: { type: 'community' }, resource_type: "Template", resource_ids: id )
-```
+For any endpoint requiring a map parameter, simply pass in a hash.
+    create_tags(tags: { type: 'community'}, resource_type: "Template", resource_ids: id )
 
 This will yield a request with the following query string:
 
@@ -72,9 +63,7 @@ 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.
 
-```ruby
-StackerBee::Client.api_path = '/path/to/your/listApis/response.json'
-```
+    StackerBee::Client.api_path = '/path/to/your/listApis/response.json'
 
 ### CloudStack REPL
 
@@ -97,76 +86,64 @@ Example:
 
 Configuring a client:
 
-```ruby
-cloud_stack = StackerBee::Client.new(
-  url:        'http://localhost:8080/client/api',
-  api_key:    'API_KEY',
-  secret_key: 'SECRET_KEY'
-)
-```
+    cloud_stack = StackerBee::Client.new(
+      url:        'http://localhost:8080/client/api'
+      api_key:    'API_KEY',
+      secret_key: 'SECRET_KEY',
+      logger:     Rails.logger
+    )
 
 All configuration parameters set on the `StackerBee::Client` class are used as defaults for `StackerBee::Client` instances.
 
-```ruby
-StackerBee::Client.url    = 'http://localhost:8080/client/api'
+    StackerBee::Client.url    = 'http://localhost:8080/client/api'
+    StackerBee::Client.logger = Rails.logger
 
-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.
 
-```ruby
-StackerBee::Client.url = 'http://localhost:8080/client/api'
-```
+    StackerBee::Client.url = 'http://localhost:8080/client/api'
 
 Or:
 
-```ruby
-my_client = StackerBee::Client.new(
-  url: 'http://localhost:8080/client/api'
-)
-```
+    my_client = StackerBee::Client.new(
+      url: 'http://localhost:8080/client/api'
+    )
 
 ### Keys
 
 Your CloudStack credentials, i.e. API key and secret key.
 
-```ruby
-StackerBee::Client.api_key    = 'MY_API_KEY'
-StackerBee::Client.secret_key = 'MY_SECRET_KEY'
-```
+    StackerBee::Client.api_key    = 'MY_API_KEY'
+    StackerBee::Client.secret_key = 'MY_SECRET_KEY'
 
 Or:
 
-```ruby
-my_client = StackerBee::Client.new(
-  api_key:    'MY_API_KEY',
-  secret_key: 'MY_SECRET_KEY'
-)
-```
+    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.
+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.
 
-```ruby
-StackerBee::Client.configuration = {
-  middlewares: ->(faraday) do
-    faraday.use Custom::LoggingMiddleware, Logger.new
-    faraday.use Custom::CachingMiddleware, Rails.cache
-  end
-}
-```
+    StackerBee::Client.default_config = {
+      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`.
 
@@ -178,35 +155,30 @@ 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:
 
-```ruby
-logger = GELF::Notifier.new("localhost", 12201)
+    logger = GELF::Notifier.new("localhost", 12201)
 
-StackerBee::Client.configuration = {
-  middlewares: ->(faraday) { faraday.use StackerBee::GraylogFaradayMiddleware, logger }
-}
-```
+    StackerBee::Client.default_config = {
+      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:
 
-```ruby
-StackerBee::Client.configuration = {
-  middlewares: ->(faraday) { faraday.response :logger }
-}
-```
+    StackerBee::Client.default_config = {
+      middlewares: ->(faraday) { faraday.response :logger }
+    }
 
 ### Bulk Configuration
 
 The `StackerBee::Client` class can be configured with multiple options at once.
 
-```ruby
-StackerBee::Client.configuration = {
-  url:        'http://localhost:8080/client/api',
-  api_key:    'API_KEY',
-  secret_key: 'MY_SECRET_KEY'
-}
-```
+    StackerBee::Client.default_config = {
+      url:        'http://localhost:8080/client/api',
+      logger:     Rails.logger,
+      api_key:    'API_KEY',
+      secret_key: 'MY_SECRET_KEY'
+    }
 
 ## Contributing
 
@@ -230,18 +202,6 @@ 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,7 +1,4 @@
 #! /usr/bin/env ruby
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-
 require 'optparse'
 require 'stacker_bee'
 require 'json'
@@ -57,7 +54,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
@@ -71,6 +68,8 @@ 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/stacker_bee/body_parser.rb

@@ -6,17 +6,7 @@ module StackerBee
     attr_reader :body
 
     def body=(raw_response)
-      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})
+      @body = parse(raw_response.body)
     end
 
     def parse(json)

data/lib/stacker_bee/client.rb

@@ -7,31 +7,11 @@ 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,
                    :url,
@@ -88,20 +68,11 @@ module StackerBee
       request = Request.new(endpoint_for(endpoint_name), api_key, params)
       request.allow_empty_string_params =
         configuration.allow_empty_string_params
-      path = path_for_endpoint(endpoint_name)
-      raw_response = connection.get(request, path)
+      raw_response = connection.get(request)
       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,6 +1,7 @@
 require "faraday"
 require "uri"
 require "stacker_bee/middleware/signed_query"
+require "stacker_bee/middleware/logger"
 require "stacker_bee/middleware/detokenizer"
 
 module StackerBee
@@ -12,17 +13,15 @@ module StackerBee
 
     def initialize(configuration)
       @configuration = configuration
-      uri = URI.parse(self.configuration.url)
+      uri      = URI.parse(self.configuration.url)
+      @path    = uri.path
       uri.path = ''
-      ssl_verify = !self.configuration.ssl_verify.nil? ?
-        self.configuration.ssl_verify : true
       fail ConnectionError, "no protocol specified" unless uri.scheme
-      initialize_faraday(url: uri.to_s,
-                         ssl: { verify: ssl_verify })
+      initialize_faraday(uri)
     end
 
-    def initialize_faraday(options)
-      @faraday = Faraday.new(options) do |faraday|
+    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
@@ -30,11 +29,10 @@ module StackerBee
       end
     end
 
-    def get(request, path)
-      @faraday.get(path, request.query_params)
-    rescue Faraday::Error::ConnectionFailed => error
-      raise ConnectionError,
-        "Failed to connect to #{configuration.url}, #{error}"
+    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/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)
-      self.params = params.dup
+      @params = params.dup
       flatten_params
     end
 
     def flatten_params
-      hashes = params.select { |_, val| val.respond_to?(:keys) }
-      flatten_map_values params, hashes
+      hashes = params.select { |key, val|  val.respond_to? :keys }
+      flatten_map_values(params, hashes)
     end
 
     def flatten_map_values(params, hashes)
-      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
+      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]
         end
-        params.delete hash_name
+        params.delete outer[0]
       end
     end
 
     def remove_empties(hash)
-      hash.reject { |_, v| v.nil? || v == "" }
+      hash.reject { |k, v| v.nil? || v == "" }
     end
   end
 end

data/lib/stacker_bee/graylog_faraday_middleware.rb

@@ -5,9 +5,8 @@ module StackerBee
     end
 
     def short_message(env)
-      message = env[:url].query.scan(/&command=([^&]*)/).join(' ')
-
-      "StackerBee #{message}".strip
+      message = env[:url].query.match(/&command=([^&]*)/)[1]
+      "StackerBee #{message}"
     end
   end
 end

data/lib/stacker_bee/middleware/logger.rb

@@ -0,0 +1,47 @@
+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 if logger.respond_to?(: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