collins_client 0.2.7

data/lib/collins/profile.rb

@@ -0,0 +1,73 @@
+require 'collins/util'
+
+module Collins
+
+  class Profile
+
+    include Collins::Util
+
+    attr_accessor :options
+
+    def initialize options = {}
+      @options = symbolize_hash options, :downcase => true
+    end
+
+    def profile
+      @options[:profile]
+    end
+    def profile?
+      not profile.nil?
+    end
+
+    def label
+      @options[:label]
+    end
+    def label?
+      not label.nil?
+    end
+
+    def prefix
+      @options[:prefix]
+    end
+    def prefix?
+      not prefix.nil?
+    end
+
+    def suffix_allowed?
+      @options[:suffix_allowed]
+    end
+
+    def primary_role
+      @options[:primary_role]
+    end
+    def primary_role?
+      not primary_role.nil?
+    end
+
+    def pool
+      @options[:pool]
+    end
+    def pool?
+      not pool.nil?
+    end
+
+    def secondary_role
+      @options[:secondary_role]
+    end
+    def secondary_role?
+      not secondary_role.nil?
+    end
+
+    def requires_primary_role?
+      @options[:requires_primary_role]
+    end
+    def requires_pool?
+      @options[:requires_pool]
+    end
+    def requires_secondary_role?
+      @options[:requires_secondary_role]
+    end
+
+  end
+
+end

data/lib/collins/simple_callback.rb

@@ -0,0 +1,141 @@
+require 'collins/util'
+require 'collins/option'
+
+module Collins
+
+  # Represents a simple callback, e.g. something with a name, options and an exec block
+  # This is designed to be a building block for other callback implementations as opposed to a
+  # complete implementation. Note that we duck-type Proc. We can't extend it without running into
+  # some initialize issues. We do this so people can feel free to tread the class like a proc.
+  class SimpleCallback
+    include ::Collins::Util
+
+    EMPTY_NAME = :None
+
+    # @return [Symbol] Name of the callback
+    attr_reader :name
+
+    # @return [Hash] Options specified with the callback, after normalizing
+    attr_reader :options
+
+    # @return [Collins::SimpleCallback] {#empty?} will return true
+    def self.empty
+      Collins::SimpleCallback.new(:none => true) {}
+    end
+
+    # Instantiate a new SimpleCallback
+    #
+    # @param [Array,Hash] args Arguments for instantiation
+    # @yieldparam [Array<Object>] block Callback to execute, can also be specified via :block option
+    #
+    # @example
+    #  SimpleCallback.new(:my_callback, Proc.new {|arg1| puts(arg1)})
+    #  SimpleCallback.new(:my_callback, :block => Proc.new{|arg1| puts(arg1)})
+    #  SimpleCallback.new :my_callback, :opt1 => "val" do |arg1|
+    #    puts(arg1)
+    #  end
+    # 
+    # @raise [ArgumentError] when name not set, and not created via #{SimpleCallback.empty}
+    def initialize *args, &block
+      opts = {}
+      while arg = args.shift do
+        if arg.is_a?(Hash) then
+          opts.update(arg)
+        elsif arg.respond_to?(:call) then
+          opts.update(:block => arg)
+        else
+          key = [:name, :options].select{|k| !opts.key?(k)}.first
+          opts.update(key => arg) unless key.nil?
+        end
+      end
+      if block && block.respond_to?(:call) then
+        opts.update(:block => block)
+      end
+      opts = symbolize_hash(opts)
+      if opts.fetch(:none, false) then
+        @name = EMPTY_NAME
+        @block = ::Collins::None.new
+        @options = {}
+      else
+        @name = ::Collins::Option(opts.delete(:name)).get_or_else {
+          raise ArgumentError.new("SimpleCallback requires a name")
+        }.to_sym
+        @block = ::Collins::Option(opts.delete(:block))
+        @options = opts
+      end
+    end
+
+    # @see Hash
+    # @param [String,Symbol] key
+    # @return [Object] value associated with key
+    def [](key)
+      options[key.to_sym]
+    end
+
+    # @see Proc
+    # @return [Fixnum] number of arguments that would not be ignored
+    def arity
+      block.map {|b| b.arity}.get_or_else(0)
+    end
+    # @see Proc
+    # @return [Binding] binding associated with the proc
+    def binding
+      to_proc.binding
+    end
+    # @see Proc
+    # @return [Boolean] lambda or not
+    def lambda?
+      block.map {|b| b.lambda?}.get_or_else(false)
+    end
+    # @see Proc
+    # @return [Array<Array<Symbol>>] array of parameters accepted by proc
+    def parameters
+      block.map {|b| b.parameters}.get_or_else([])
+    end
+    # @see Proc
+    # @return [Proc] proc or noop proc
+    def to_proc
+      block.map{|b| b.to_proc}.get_or_else(Proc.new{})
+    end
+
+    # @return [Collins::Option] Self as option
+    def to_option
+      if self.defined? then
+        ::Collins::Some.new(self)
+      else
+        ::Collins::None.new
+      end
+    end
+
+    # @return [Boolean] True if block was given to constructor
+    def defined?
+      name != EMPTY_NAME || block.defined?
+    end
+    # @return [Boolean] False if block was given to constructor
+    def empty?
+      name == EMPTY_NAME && block.empty?
+    end
+
+    # Call the callback block with the specified arguments
+    #
+    # @see Proc
+    # @param [Array<Object>] args - Arguments for callback
+    # @return [Object] Value from callback
+    # @raise [NameError] if block wasn't specified but call was executed
+    def call *args
+      block.map do |b|
+        b.call(*args)
+      end.get
+    end
+
+    # @return [String] representation of callback
+    def to_s
+      "Collins::SimpleCallback(name = #{name}, options = #{options.inspect})"
+    end
+
+    protected
+    # The code block associated with the simple callback
+    attr_reader :block
+  end
+
+end

data/lib/collins/state.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+module Collins
+  class AssetState
+    include Collins::Util
+
+    attr_accessor :description, :id, :label, :name, :status
+
+    def self.from_json json
+      Collins::AssetState.new json
+    end
+
+    def initialize opts = {}
+      hash = symbolize_hash(opts).inject({}) do |result, (k,v)|
+        key = k.to_s.downcase.to_sym
+        result[key] = v
+        result
+      end
+      @description = hash[:description].to_s
+      @id = hash[:id].to_s.to_i
+      @label = hash[:label].to_s
+      @name = hash[:name].to_s
+      @status = get_status hash[:status]
+    end
+
+    def empty?
+      @id == 0
+    end
+
+    def to_s
+      if empty? then
+        "State(None)"
+      else
+        "State(id = #{id}, name = '#{name}', label = '#{label}', description = '#{description}')"
+      end
+    end
+
+    private
+    def get_status opt
+      opts = opt || {}
+      hash = symbolize_hash(opts).inject({}) do |result, (k,v)|
+        key = k.to_s.downcase.to_sym
+        result[key] = v
+        result
+      end
+      OpenStruct.new(hash)
+    end
+
+  end
+end

data/lib/collins/util.rb

@@ -0,0 +1,145 @@
+require 'collins/logging'
+
+module Collins
+
+  # General purpose util methods
+  #
+  # Methods in {Collins::Util} can be accessed by....
+  # 
+  #  * `Collins::Util.method_name`
+  #  * `ClassIncludingCollinsUtil.method_name`
+  #  * `instance_of_class_including_collins_util.method_name`
+  #
+  # Other than {Util#get\_asset\_or\_tag} most of these methods are not collins specific
+  module Util
+
+    include Collins::Util::Logging
+
+    def self.included base
+      base.extend(Collins::Util)
+    end
+
+    # Create a deep copy of a hash
+    #
+    # This is useful for copying a hash that will be mutated
+    # @note All keys and values must be serializable, Proc for instance will fail
+    # @param [Hash] hash the hash to copy
+    # @return [Hash]
+    def deep_copy_hash hash
+      require_that(hash.is_a?(Hash), "deep_copy_hash requires a hash be specified, got #{hash.class}")
+      Marshal.load Marshal.dump(hash)
+    end
+
+    # Require that a value not be empty
+    #
+    # If the value is a string, ensure that once stripped it's not empty. If the value responds to
+    # `:empty?`, ensure that it's not. Otherwise ensure the value isn't nil.
+    #
+    # @param [Object] value the value to check
+    # @param [String] message the exception message to use if the value is empty
+    # @param [Boolean,Object] return_value If true, returns value. If not false, returns the object
+    # @raise [ExpectationFailedError] if the value is empty
+    # @return [NilClass,Object] NilClass, or respecting return_value
+    def require_non_empty value, message, return_value = false
+      guard_value = if return_value == true then
+                      value
+                    elsif return_value != false then
+                      return_value
+                    else
+                      false
+                    end
+      if value.is_a?(String) then
+        require_that(!value.strip.empty?, message, guard_value)
+      elsif value.respond_to?(:empty?) then
+        require_that(!value.empty?, message, guard_value)
+      else
+        require_that(!value.nil?, message, guard_value)
+      end
+    end
+
+    # Require that a guard condition passes
+    #
+    # Simply checks that the guard is truthy, and throws an error otherwise
+    # @see #require_non_empty
+    def require_that guard, message, return_guard = false
+      if not guard then
+        raise ExpectationFailedError.new(message)
+      end
+      if return_guard == true then
+        guard
+      elsif return_guard != false then
+        return_guard
+      end
+    end
+
+    # Resolve an asset from a string tag or collins asset
+    # @note This is perhaps the only collins specific method in Util
+    # @param [Collins::Asset,String,Symbol] asset_or_tag
+    # @return [Collins::Asset] a collins asset
+    # @raise [ExpectationFailedError] if asset\_or\_tag isn't valid
+    def get_asset_or_tag asset_or_tag
+      asset =
+        case asset_or_tag
+          when Collins::Asset then asset_or_tag
+          when String then Collins::Asset.new(asset_or_tag)
+          when Symbol then Collins::Asset.new(asset_or_tag.to_s)
+        else
+          error_message = "Expected Collins::Asset, String or Symbol. Got #{asset_or_tag.class}"
+          raise ExpectationFailedError.new(error_message)
+        end
+      if asset.nil? || asset.tag.nil? then
+        raise ExpectationFailedError.new("Empty asset tag, but a tag is required")
+      end
+      asset
+    end
+
+    # Given a hash, rewrite keys to symbols
+    #
+    # @param [Hash] hash the hash to symbolize
+    # @param [Hash] options specify how to process the hash
+    # @option options [Boolean] :rewrite_regex if the value is a regex and this is true, convert it to a string
+    # @option options [Boolean] :downcase if true, downcase the keys as well
+    # @raise [ExpectationFailedError] if hash is not a hash
+    def symbolize_hash hash, options = {}
+      return {} if (hash.nil? or hash.empty?)
+      (raise ExpectationFailedError.new("symbolize_hash called without a hash")) unless hash.is_a?(Hash)
+      hash.inject({}) do |result, (k,v)|
+        key = options[:downcase] ? k.to_s.downcase.to_sym : k.to_s.to_sym
+        if v.is_a?(Hash) then
+          result[key] = symbolize_hash(v)
+        elsif v.is_a?(Regexp) && options[:rewrite_regex] then
+          result[key] = v.inspect[1..-2]
+        else
+          result[key] = v
+        end
+        result
+      end
+    end
+
+    # Given a hash, convert all keys to strings
+    # @see #symbolize_hash
+    def stringify_hash hash, options = {}
+      (raise ExpectationFailedError.new("stringify_hash called without a hash")) unless hash.is_a?(Hash)
+      hash.inject({}) do |result, (k,v)|
+        key = options[:downcase] ? k.to_s.downcase : k.to_s
+        if v.is_a?(Hash) then
+          result[key] = stringify_hash(v)
+        elsif v.is_a?(Regexp) && options[:rewrite_regex] then
+          result[key] = v.inspect[1..-2]
+        else
+          result[key] = v
+        end
+        result
+      end
+    end
+
+    # This provides access to these methods via a Collins::Util.method_name call
+    [:deep_copy_hash, :require_non_empty, :get_asset_or_tag, :require_that,
+     :symbolize_hash, :stringify_hash
+    ].each do |method|
+      module_function method
+      public method # without this, module_function makes the method private
+    end
+  end # Util module
+
+end # Collins module

data/lib/collins_client.rb

@@ -0,0 +1,7 @@
+$:.unshift File.join File.dirname(__FILE__)
+require 'collins/util'
+require 'collins/option'
+require 'collins/simple_callback'
+require 'collins/asset'
+require 'collins/client'
+require 'collins/errors'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: collins_client
+version: !ruby/object:Gem::Version
+  version: 0.2.7
+  prerelease: 
+platform: ruby
+authors:
+- Blake Matheny
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.3
+description: Provides ruby support for interacting with the Collins API
+email: bmatheny@tumblr.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- collins_client.gemspec
+- lib/collins/address.rb
+- lib/collins/api.rb
+- lib/collins/api/admin.rb
+- lib/collins/api/asset.rb
+- lib/collins/api/asset_state.rb
+- lib/collins/api/attributes.rb
+- lib/collins/api/ip_address.rb
+- lib/collins/api/logging.rb
+- lib/collins/api/management.rb
+- lib/collins/api/tag.rb
+- lib/collins/api/util.rb
+- lib/collins/api/util/errors.rb
+- lib/collins/api/util/parameters.rb
+- lib/collins/api/util/requests.rb
+- lib/collins/api/util/responses.rb
+- lib/collins/asset.rb
+- lib/collins/asset_client.rb
+- lib/collins/client.rb
+- lib/collins/errors.rb
+- lib/collins/ipmi.rb
+- lib/collins/logging.rb
+- lib/collins/monkeypatch.rb
+- lib/collins/option.rb
+- lib/collins/power.rb
+- lib/collins/profile.rb
+- lib/collins/simple_callback.rb
+- lib/collins/state.rb
+- lib/collins/util.rb
+- lib/collins_client.rb
+homepage: https://github.com/tumblr/collins/tree/master/support/ruby/collins-client
+licenses:
+- APL 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1509418886285766907
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Client library for Collins API
+test_files: []