voxel-hapi 1.1.6

data/bin/rhapi

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require "rubygems"
+require 'optparse'
+require 'yaml'
+gem "hapi", ">= 1.1.0"
+require "hapi"
+require "pp"
+
+option_data = [
+  {
+    :short        => '-U',    :long   => '--username USERNAME',
+    :type         => String,  :key    => :username,
+    :description  => 'hAPI Username',
+    :required     => true
+  },
+
+  {
+    :short        => '-P',    :long   => '--password PASSWORD',
+    :type         => String,  :key    => :password,
+    :description  => 'hAPI Password',
+    :required     => true
+  },
+
+  {
+    :short        => '-H',    :long   => '--hostname HOSTNAME',
+    :type         => String,  :key    => :hostname,
+    :description  => 'hAPI Server Hostname',
+    :default      => 'api.voxel.net'
+  },
+
+  {
+    :short        => '-V',    :long   => '--version VERSION',
+    :type         => String,  :key    => :version,
+    :description  => 'hAPI Version',
+    :default      => '1.0'
+  },
+
+  {
+    :short        => nil,    :long   => '--[no-]useauthkey',
+    :type         => nil, :key    => :useauthkey,
+    :description  => 'Are username and password actually key and secret?',
+    :default      => false
+  },
+
+  {
+    :short        => '-m',    :long   => '--method METHOD',
+    :type         => String,  :key    => :method,
+    :description  => 'hAPI Method Name',
+    :required     => true
+  },
+
+ {
+    :short        => '-y',    :long   => '--yaml-param PARAMFILE',
+    :type         => String,  :key    => :yaml_param,
+    :description  => 'hAPI Method Paramaters in YAML Format (FILENAME)'
+  },
+
+  {
+    :short        => '-r',    :long   => '--repeat INTERVAL',
+    :type         => String,  :key    => :repeat,
+    :description  => 'Should the method be repeated (loop time in seconds)'
+  },
+
+  {
+    :short        => '-o',    :long   => '--output-format FORMAT',
+    :type         => String,  :key    => :output_format,
+    :description  => 'Output format (Defaults to Ruby Array/Hash)',
+    :default      => :xml
+  },
+]
+
+begin
+  parsed_options = {}
+
+  option_parser = OptionParser.new do |op|
+    op.set_summary_indent('  ')
+    op.banner = "Usage: #{$0} [OPTIONS] [METHOD PARAM]"
+    op.separator " "
+   
+    option_data.each do |opt|
+      if opt[:short].nil?
+        op.on( opt[:long], opt[:type], opt[:description]) do |s|
+          parsed_options[opt[:key]] = s
+        end
+      else
+        op.on( opt[:short], opt[:long], opt[:type], opt[:description]) do |s|
+          parsed_options[opt[:key]] = s
+        end
+      end
+
+      parsed_options[opt[:key]] = opt[:default] if opt.has_key?(:default)
+    end
+
+    op.on_tail('-x', '--[no-]debug', "Enable Debugging Output") { |s| parsed_options[:debug] = s }
+    op.on_tail('-h', '--help', "Displays help message") { puts op; exit 0; }
+  end
+ 
+  if ENV.has_key?('HAPI_CONFIG') and File.readable?(ENV['HAPI_CONFIG'])
+    File.open(ENV['HAPI_CONFIG']) { |fh| parsed_options.merge! YAML::load( fh ) }
+  end
+
+  option_parser.parse!(ARGV)
+
+  option_data.each do |od|
+    if od.has_key?(:required) and not parsed_options.has_key?(od[:key])
+      raise StandardError, "#{od[:long].split(' ')[0]} is a required parameter"
+    end
+  end
+
+  if parsed_options[:useauthkey] #and not parsed_options.has_key?(:username)
+    api = HAPI.new( parsed_options.merge( { :authkey => { :key => parsed_options[:username], :secret => parsed_options[:password] } } ) )
+  else
+    hapi_options = {}
+
+    [ :username, :password, :version, :debug, :hostname ].each do |k|
+      hapi_options[k] = parsed_options[k]
+    end
+
+    api = HAPI.new hapi_options
+ end
+
+  mparam = Hash.new
+
+  if parsed_options.has_key?(:yaml_param) and File.readable?(parsed_options[:yaml_param])
+    File.open(parsed_options[:yaml_param]) { |fh| mparam.reverse_merge! YAML::load( fh ) }
+  end
+
+  #pp ARGV
+  if ARGV.length > 0
+  #if parsed_options.has_key?(:method_param)
+    ARGV.each do |kval|
+      key, value = kval.split('=')
+      mparam[key.to_sym] = value
+    end
+  end
+
+  api_method_name = api.translate_api_to_method( parsed_options[:method] )
+
+  if parsed_options.has_key?(:repeat)
+    while true
+      puts api.send(api_method_name, mparam, { :format => :xml } )
+      $stdout.flush
+      sleep parsed_options[:repeat].to_i
+    end
+  else
+    puts api.send(api_method_name, mparam, { :format => :xml } )
+  end
+rescue OptionParser::ParseError => e
+  STDERR.puts e
+  exit 1
+# rescue HAPI::Backend => ex
+#   STDERR.puts "[ERROR] (#{ex.class.to_s}) #{ex.message}"
+#  exit 1
+rescue StandardError => ex
+  STDERR.puts "[ERROR] (#{ex.class.to_s}) #{ex.message}"
+  STDERR.puts ex.backtrace
+  exit 1
+rescue RuntimeError => ex
+  STDERR.puts ex.message
+  exit 1
+rescue SystemExit
+  exit 0
+rescue Exception => ex
+  STDERR.puts "Unhandled Exception: #{ex.class.to_s}"
+  STDERR.printf ex.message + "\n\n"
+  STDERR.puts "Backtrace:"
+  STDERR.puts ex.backtrace
+  exit 1
+end
+

data/examples/hapirc.example

@@ -0,0 +1,7 @@
+---
+:username: 1234
+:password: passw0rd
+:hostname: api.voxel.net
+:version: 1.0
+:debug: false
+:useauthkey: false

data/lib/hapi.rb

@@ -0,0 +1,216 @@
+# The library provides the class HAPI, a ruby interface to Voxel's hAPI
+# http://api.voxel.net/docs
+#
+# Author::    James W. Brinkerhoff  (mailto:jwb@voxel.net)
+# Copyright:: Copyright (c) 2009 Voxel dot Net, Inc.
+# License::   Unknown
+
+require 'xmlsimple'
+require 'net/https'
+require 'uri'
+require 'yaml'
+require 'time'
+require 'digest/md5'
+
+class String
+  def underscore
+      self.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      self.first.downcase + camelize(self)[1..-1]
+    end
+  end
+end
+
+class Hash
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+  
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
+  end
+end
+
+class HAPI
+  #Library Version
+  LIB_VERSION = '1.1.6'
+  #UserAgent for Logging
+  USER_AGENT  = "Voxel hAPI ruby Client; #{LIB_VERSION}"
+
+  #API Username
+  attr_accessor :username
+  #API Password
+  attr_accessor :password
+  #API Host, Defaults to api.voxel.net
+  attr_accessor :hostname
+  #API Endpoint Version, Defaults to '1.0'
+  attr_accessor :version
+  #Debug Mode, When true outputs debugging info via STDERR
+  attr_accessor :debug
+  #Are username and password a key/secret pair
+  attr_accessor :useauthkey
+  #Default formatting for return values, :xml or :ruby
+  attr_accessor :default_format
+
+  def initialize(options = {})
+    options.reverse_merge! :filename => nil
+
+    unless options[:filename].nil?
+      raise "#{options[:filename]} is not readable!" unless File.readable?(options[:filename])
+
+      yaml_options = YAML.load(File.read(options[:filename]))
+      options.merge!( yaml_options )
+    end
+
+    options.reverse_merge! :hostname => 'api.voxel.net', :debug => false,
+    :version => '1.0', :useauthkey => false, :default_format => :xml
+
+    validate_required_options options, :username, :password
+
+    [ :username, :password, :hostname, :version, :debug, :useauthkey, :default_format ].each do |k|
+      send( "#{k.to_s}=", options[k] )
+    end
+
+    begin
+      unless @useauthkey
+        keypair = voxel_hapi_authkeys_read( {}, { :format => :ruby, :http_auth => true } )['authkey']
+
+        @username = keypair['key']
+        @password = keypair['secret']
+      end
+    rescue Exception => ex
+      raise ex
+    end
+  end
+
+  def self.new_from_config(filename, additional_options = {})
+    STDERR.puts "WARNING: new_from_config is no longer in use"
+
+    new(additional_options)
+  end
+
+  def helper_devices_status()
+    voxcloud = voxel_voxcloud_status['devices']
+    voxservers = voxel_voxservers_status['devices']
+
+    statuses = voxcloud['device'] unless voxcloud.empty?
+    statuses += voxservers['device'] unless voxservers.empty?
+
+    devices = {}
+
+    statuses.each { |s| devices[s['id']] = s['status'] }
+
+    devices
+  end
+
+  def translate_api_to_method( api_method_name )
+    ruby_method_name = []
+
+    api_method_name.split(".").each do |mp|
+      if mp.include?("_")
+        ruby_method_name << mp.camelize 
+      else
+        ruby_method_name << mp
+      end
+    end
+
+    ruby_method_name.join("_")
+  end
+
+  def translate_method_to_api( method_name )
+    method_name.split("_").map { |mp| mp.underscore }.join(".")
+  end
+
+  private
+  
+  def request_method( method_name, method_arguments = {}, options = {} )
+    options.reverse_merge! :format => @default_format, :http_auth => false
+
+    STDERR.puts "Calling method #{method_name}" if debug
+
+    begin
+      signed_request = sign_request( method_name, method_arguments )
+      response = make_http_request( signed_request, options[:http_auth] )
+      STDERR.puts response if @debug
+      return process_response( response, options[:format] )
+    rescue Exception => ex
+      raise ex
+    end
+  end
+
+  def method_missing( method_id, *args )
+    STDERR.puts "Calling method #{method_id.id2name}" if @debug
+
+    request_method( translate_method_to_api(method_id.id2name), *args )
+  end
+
+  def validate_required_options( all, *required )
+    required.each do |opt|
+      raise ":#{opt} must be specified" unless all.has_key?(opt)
+      raise ":#{opt} must be non-NULL"  if all[opt].nil?
+    end
+  end
+
+  def make_http_request( options = {}, auth = false )
+    url = URI.parse( "https://#{@hostname}/version/#{@version}" )
+
+    request = Net::HTTP::Post.new(url.path)
+      
+    request.basic_auth( @username, @password ) if auth
+    request.set_form_data(options)
+    request.add_field('User-Agent', USER_AGENT)
+
+    http = Net::HTTP.new(url.host, url.port)
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    http.use_ssl = true
+    response = http.request(request)
+
+    case response
+    when Net::HTTPSuccess, Net::HTTPRedirection
+      response.body
+    when Net::HTTPUnauthorized
+      STDERR.puts response.class.to_s if @debug
+      raise "Invalid Username or Password"
+    else
+      STDERR.puts response.class.to_s if @debug
+      raise "Invalid response code from API endpoint"
+    end
+  end
+
+  def sign_request( method_name, method_arguments = {} )
+    request             = method_arguments.clone
+    request[:method]    = method_name
+    request[:timestamp] = Time.now.xmlschema
+    request[:key]       = @username
+    request[:api_sig]   = Digest::MD5.hexdigest( @password + create_param_string(request) )
+
+    request
+  end
+
+  def create_param_string( params = {} )
+    params.keys.map { |k| k.to_s }.sort.map { |k| "#{k}#{params[k.to_sym]}" }.join("") 
+  end
+
+  def process_xml_document( xml_data, options = {} )
+    options.reverse_merge! 'ForceArray' => false
+    XmlSimple.xml_in(xml_data, options)
+  end
+
+  def process_response( document, format )
+    case format
+    when :ruby
+      return process_xml_document( document )
+    when :xml
+      return document
+    end
+  end
+end
+

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: voxel-hapi
+version: !ruby/object:Gem::Version
+  version: 1.1.6
+  prerelease: 
+platform: ruby
+authors:
+- James W. Brinkerhoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: &9669620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.12
+  type: :runtime
+  prerelease: false
+  version_requirements: *9669620
+- !ruby/object:Gem::Dependency
+  name: libxml-ruby
+  requirement: &9669160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *9669160
+description: 
+email: jwb@voxel.net
+executables:
+- rhapi
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hapi.rb
+- bin/rhapi
+- examples/hapirc.example
+homepage: http://voxel.net/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A Ruby Class Interface to Voxel's hAPI
+test_files: []