collins_client 0.2.7

data/lib/collins/errors.rb

@@ -0,0 +1,56 @@
+module Collins
+
+  class CollinsError < StandardError; end
+  class ExpectationFailedError < CollinsError; end
+  class UnexpectedResponseError < CollinsError; end
+  class RequestError < CollinsError
+    attr_accessor :code, :uri
+    def initialize message, code
+      super(message)
+      @code = code.to_i
+    end
+    def description verbose = false
+      <<-D
+      #{message}
+      Response Code: #{code}
+      URI: #{uri}
+      D
+    end
+  end
+
+  class RichRequestError < RequestError
+    attr_accessor :class_of, :remote_description, :remote_message, :stacktrace
+    def initialize message, code, description, details = {}
+      super(message, code)
+      @code = code
+      @remote_description = description
+      @class_of = details["classOf"]
+      @remote_message = details["message"]
+      @stacktrace = details["stackTrace"]
+    end
+    def get_remote_stacktrace verbose
+      if verbose then
+        stacktrace
+      else
+        "Suppressed"
+      end
+    end
+    def description verbose = false
+      <<-D
+      #{message}
+      Response Code: #{code}
+      URI: #{uri}
+      Remote Description: #{remote_description}
+      Remote Exception Class: #{class_of}
+      Remote Message:
+      #{remote_message}
+
+      Remote Backtrace:
+      #{get_remote_stacktrace(verbose)}
+      D
+    end
+  end
+
+  class AuthenticationError < CollinsError; end
+
+end

data/lib/collins/ipmi.rb

@@ -0,0 +1,41 @@
+module Collins
+
+  class Ipmi
+
+    include Collins::Util
+
+    attr_accessor :address, :asset_id, :gateway, :id, :netmask, :password, :username
+
+    def self.from_json json
+      Collins::Ipmi.new json
+    end
+
+    def initialize opts = {}
+      hash = symbolize_hash(opts).inject({}) do |result, (k,v)|
+        key = k.to_s.downcase.sub(/^ipmi_/, "").to_sym
+        result[key] = v
+        result
+      end
+      @address = hash[:address].to_s
+      @asset_id = hash[:asset_id].to_s.to_i
+      @gateway = hash[:gateway].to_s
+      @id = hash[:id].to_s.to_i
+      @netmask = hash[:netmask].to_s
+      @password = hash[:password].to_s
+      @username = hash[:username].to_s
+    end
+
+    def empty?
+      @id == 0
+    end
+
+    def to_s
+      if empty? then
+        "Ipmi(None)"
+      else
+        "Ipmi(id = #{id}, asset_id = #{asset_id}, address = #{address}, gateway = #{gateway}, netmask = #{netmask}, username = #{username}, password = #{password})"
+      end
+    end
+
+  end
+end

data/lib/collins/logging.rb

@@ -0,0 +1,33 @@
+require 'collins/monkeypatch'
+require 'collins/option'
+
+module Collins; module Util
+
+  module Logging
+
+    DEFAULT_LOG_FORMAT = "%Y-%m-%d %H:%M:%S.%L"
+
+    def get_logger options = {}
+      return options[:logger] if options[:logger]
+      trace = Collins::Option(options[:trace]).get_or_else(false)
+      debug = Collins::Option(options[:debug]).get_or_else(false)
+      progname = Collins::Option(options[:progname] || options[:program]).get_or_else('unknown')
+      logfile = Collins::Option(options[:logfile]).get_or_else(STDOUT)
+      logger = Logger.new(logfile)
+      if trace then
+        logger.level = Logger::TRACE
+      elsif debug then
+        logger.level = Logger::DEBUG
+      else
+        logger.level = Logger::INFO
+      end
+      logger.progname = File.basename(progname)
+      logger.formatter = Proc.new do |severity, datetime, progname, message|
+        date_s = datetime.strftime(Collins::Util::Logging::DEFAULT_LOG_FORMAT)
+        "#{severity} [#{date_s}] #{progname}: #{message}\n"
+      end
+      logger
+    end
+  end
+
+end; end

data/lib/collins/monkeypatch.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+class Logger
+
+  module Severity
+    TRACE = -1
+  end
+
+  def trace?; @level <= TRACE; end
+
+  def trace(progname = nil, &block)
+    add(TRACE, nil, progname, &block)
+  end
+
+  private
+  def format_severity severity
+    if severity == TRACE then
+      'TRACE'
+    else
+      SEV_LABEL[severity] || 'ANY'
+    end
+  end
+
+end

data/lib/collins/option.rb

@@ -0,0 +1,220 @@
+module Collins
+
+  # Convenience method for creating an `Option`
+  def self.Option value
+    if value.nil? then
+      ::Collins::None()
+    else
+      ::Collins::Some(value)
+    end
+  end
+  # Convenience method for creating a `None`
+  def self.None
+    ::Collins::None.new
+  end
+  # Convenience method for creating a `Some`
+  def self.Some value
+    ::Collins::Some.new(value)
+  end
+
+  # Represents optional values. Instances of `Option` are either an instance of `Some` or `None`
+  # @note This is pretty much a straight rip off of the scala version
+  # @example
+  #   name = get_parameter("name")
+  #   upper = Option(name).map{|s| s.strip}.filter{|s|s.size > 0}.map{|s|s.upcase}
+  #   puts(upper.get_or_else(""))
+  class Option
+
+    # @return [Boolean] True if the value is undefined
+    def empty?
+      raise NotImplementedError.new("empty? not implemented")
+    end
+
+    # @return [Boolean] True if the value is defined
+    def defined?
+      !empty?
+    end
+
+    # @return [Object] Value, if defined
+    # @raise [NameError] if value is undefined
+    def get
+      raise NotImplementedError.new("get not implemented")
+    end
+
+    # The value associated with this option, or the default
+    #
+    # @example
+    #  # Raises an exception
+    #  Option(nil).get_or_else { raise Exception.new("Stuff") }
+    #  # Returns -1
+    #  Option("23").map {|i| i.to_i}.filter{|i| i > 25}.get_or_else -1
+    #
+    # @param [Object] default A default value to use if the option value is undefined
+    # @yield [] Provide a default with a block instead of a parameter
+    # @return [Object] If None, default, otherwise the value
+    def get_or_else *default
+      if empty? then
+        if block_given? then
+          yield
+        else
+          default.first
+        end
+      else
+        get
+      end
+    end
+
+    # Return this `Option` if non-empty, otherwise return the result of evaluating the default
+    # @example
+    #  Option(nil).or_else { "foo" } == Some("foo")
+    # @return [Option<Object>]
+    def or_else *default
+      if empty? then
+        res = if block_given? then
+                yield
+              else
+                default.first
+              end
+        if res.is_a?(Option) then
+          res
+        else
+          ::Collins::Option(res)
+        end
+      else
+        self
+      end
+    end
+
+    # Return true if non-empty and predicate is true for the value
+    # @return [Boolean] test passed
+    def exists? &predicate
+      !empty? && predicate.call(get)
+    end
+
+    # Apply the block specified to the value if non-empty
+    # @return [NilClass]
+    def foreach &f
+      if self.defined? then
+        f.call(get)
+      end
+      nil
+    end
+
+    # If the option value is defined, apply the specified block to that value
+    #
+    # @example
+    #  Option("15").map{|i| i.to_i}.get == 15
+    #
+    # @yieldparam [Object] block The current value
+    # @yieldreturn [Object] The new value
+    # @return [Option<Object>] Optional value
+    def map &block
+      if empty? then
+        None.new
+      else
+        Some.new(block.call(get))
+      end
+    end
+
+    # Same as map, but flatten the results
+    #
+    # This is useful when operating on an object that will return an `Option`.
+    #
+    # @example
+    #   Option(15).flat_map {|i| Option(i).filter{|i2| i2 > 0}} == Some(15)
+    #
+    # @see #map
+    # @return [Option<Object>] Optional value
+    def flat_map &block
+      if empty? then
+        None.new
+      else
+        res = block.call(get)
+        if res.is_a?(Some) then
+          res
+        else
+          Some.new(res)
+        end
+      end
+    end
+
+    # Convert to `None` if predicate fails
+    #
+    # Returns this option if it is non-empty *and* applying the predicate to this options returns
+    # true. Otherwise return `None`.
+    #
+    # @yieldparam [Object] predicate The current value
+    # @yieldreturn [Boolean] result of testing value
+    # @return [Option<Object>] `None` if predicate fails, or already `None`
+    def filter &predicate
+      if empty? || predicate.call(get) then
+        self
+      else
+        None.new
+      end
+    end
+
+    # Inverse of `filter` operation.
+    #
+    # Returns this option if it is non-empty *and* applying the predicate to this option returns
+    # false. Otherwise return `None`.
+    #
+    # @see #filter
+    # @return [Option<Object>]
+    def filter_not &predicate
+      if empty? || !predicate.call(get) then
+        self
+      else
+        None.new
+      end
+    end
+  end
+
+  # Represents a missing value
+  class None < Option
+    # Always true for `None`
+    # @see Option#empty?
+    def empty?
+      true
+    end
+    # Always raises a NameError
+    # @raise [NameError]
+    def get
+      raise NameError.new("None.get")
+    end
+    def eql? other
+      self.class.equal?(other.class)
+    end
+    alias == eql?
+  end
+
+  # Represents a present value
+  #
+  # A number of equality and comparison methods are implemented so that `Some` values are compared
+  # using the value of `x`.
+  class Some < Option
+    def initialize value
+      @x = value
+    end
+    def empty?
+      false
+    end
+    def get
+      x
+    end
+    def eql? other
+      self.class.equal?(other.class) && x.eql?(other.x)
+    end
+    alias == eql?
+    def hash
+      x.hash
+    end
+    def <=>(other)
+      self.class == other.class ?
+        (x <=> other.x) : nil
+    end
+    protected
+    attr_reader :x
+  end
+
+end

data/lib/collins/power.rb

@@ -0,0 +1,99 @@
+require 'collins/errors'
+
+module Collins
+
+  class InvalidPowerStatus < CollinsError; end
+
+  class PowerUnit
+    include Collins::Util
+
+    attr_accessor :key, :value, :type, :label, :position, :is_required, :unique
+
+    def initialize model = {}
+      hash = symbolize_hash(model).inject({}) do |result, (k,v)|
+        result[k.downcase] = v
+        result
+      end
+      @key = hash[:key].to_s
+      @value = hash[:value].to_s
+      @type = hash[:type].to_s
+      @label = hash[:label].to_s
+      @position = hash[:position].to_s.to_i
+      @is_required = hash[:is_required]
+      @unique = hash[:unique]
+    end
+
+    def is_required?
+      @is_required == true
+    end
+    def unique?
+      @unique == true
+    end
+  end
+
+  class Power
+
+    include Collins::Util
+
+    attr_accessor :unit_id, :units
+
+    class << self
+      def from_json json
+        return [] if (json.nil? or json.empty?)
+        if not json.is_a?(Array) then
+          json = [json]
+        end
+        json.map { |j| Collins::Power.new j }
+      end
+      def normalize_action action
+        case action.to_s.downcase.to_sym
+        when :off, :poweroff
+          "powerOff"
+        when :on, :poweron
+          "powerOn"
+        when :powersoft
+          "powerSoft"
+        when :soft, :rebootsoft
+          "rebootSoft"
+        when :hard, :reboothard
+          "rebootHard"
+        when :status, :powerstate
+          "powerState"
+        when :verify
+          "verify"
+        when :identify
+          "identify"
+        else
+          raise InvalidPowerStatus.new("#{action} is not a valid power status")
+        end
+      end
+    end
+
+    def initialize model = {}
+      hash = symbolize_hash(model).inject({}) do |result, (k,v)|
+        result[k.downcase] = v
+        result
+      end
+      @unit_id = hash[:unit_id].to_s.to_i
+      @units = (hash[:units] || []).map {|u| Collins::PowerUnit.new(u)}
+    end
+
+    def keys
+      units.map{|u| u.key }
+    end
+    def values
+      units.map{|u| u.value}
+    end
+    def types
+      units.map{|u| u.type}
+    end
+    def labels
+      units.map{|u| u.label}
+    end
+    def positions
+      units.map{|u| u.position}
+    end
+
+  end
+
+end