cloudmonkey 1.0.0

data/lib/cm.rb

@@ -0,0 +1,180 @@
+require 'json'
+require 'ostruct'
+require 'open3'
+
+module CloudMonkey
+  class CMClient
+    def initialize(params)
+      @host = params[:host] || 'localhost'
+      @port = params[:port] || 8080
+      @apikey = params[:apikey]
+      @secretkey = params[:secretkey]
+      @config = params[:config] || File.join("#{Dir.home}", ".cloudmonkey-cmrb")
+      @debug = params[:debug] || false
+      configure
+    end
+
+    # Set a cloudmonkey configuration option.
+    def set(key, value)
+      run_cmd("set #{key} #{value}", nil)
+    end
+
+    # Configure the cloudmonkey client for use with the library.
+    def configure
+      set('host', "#{@host}")
+      set('port', "#{@port}")
+      set('apikey', "#{@apikey}")
+      set('secretkey', "#{@secretkey}")
+      set('display', 'json')
+      set('asyncblock', 'false')
+      set('color', 'false')
+    end
+
+    # Execute a command with cloudmonkey. The command can be
+    # multi-word, e.g. "list users". Params, if provided, must be a
+    # hash (e.g. :account => "admin"), or a string value (.e.g "help"
+    # as the command and "list users" as the parameter).
+    def execute(cmd, params = nil)
+      cmd.downcase!
+      run_cmd(cmd, params)
+    end
+
+    # Catch missing methods to transform them into cloudmonkey
+    # commands. This allows magic translation of ruby into cloudmonkey
+    # commands. Because cloudmonkey api commands have a specific
+    # format of 1 or more words followed by key=value parameters, we
+    # turn the method_name into "method name" and pass in the first
+    # argument only, which is assumed to be a hash or SINGLE string
+    # value.
+    def method_missing(name, *args)
+      cmd = name.to_s.split('_').join(' ').strip
+      execute cmd, args[0]
+    end    
+
+    private
+    # Run a cloudmonkey command.
+    def run_cmd(input, params = nil)
+      input += ' '
+     
+      # We recognize hash parameters and straight-up string
+      # parameters, but nothing else
+      unless params.nil?
+        if params.is_a?(Hash)
+          params.each { |key, value| input += "#{key.downcase}=#{value} " }
+          input.chop!
+        elsif params.is_a?(String)
+          input += params
+        else
+          raise 'We do not know how to handle these parameters'
+        end
+      end
+      
+      cmd = "cloudmonkey -c #{@config} #{input}"
+      output = nil
+
+      puts "running #{cmd}" if @debug
+      Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+        output = stdout.read
+      end
+
+      # usually the output is json, but not if it is an error or just
+      # general messages.
+      begin
+        json = JSON.parse(output, :symbolize_names => true)
+        # is it an async job? these responses usually have the id of
+        # whatever you are making and the jobid (2 keys)
+        if json.has_key?(:jobid) and json.length <= 2
+          handle_async_job(json[:jobid])
+        else 
+          # it is a query result.
+          return json
+        end
+      rescue JSON::ParserError
+        handle_non_json_output(output)
+      end
+    end
+
+    # Handle an async job that was submitted. This is for anything
+    # that is not a query method. The function has already been
+    # submitted, but we do need a result.
+    def handle_async_job(jobid)
+      result = run_cmd('query asyncjobresult', :jobid => jobid)
+      # see cs documentation for job status codes - 0 means pending
+      while result[:jobstatus] == 0
+        sleep(3)
+        result = run_cmd('query asyncjobresult', :jobid => jobid)
+      end
+      
+      # if there is a job result, we are interested only in
+      # that. otherwise just return the whole response because we
+      # don't really know what's in it.
+      result.has_key?(:jobresult) ? result[:jobresult] : result
+    end
+
+    # Handle non-json output. This happens when Cloudmonkey returns an
+    # error or if it's just a generic message. Errors are raised as a
+    # runtime exception, while generic message sare put into a hash
+    # with a :message property.
+    def handle_non_json_output(message)     
+      # handle various error messages, otherwise simply return a hash
+      # with the message
+      if message.start_with?('[Errno') or message.start_with?('Unauthorized:')
+        raise message
+      else
+        # if the message is non-0 length after stripping, then it is a
+        # valid message. otherwise it is nothing (nil).
+        { :message => message } if message.strip.length > 0
+      end
+    end
+  end # end cmclient
+
+  # For functions that require execution of many commands, or for
+  # unwrapping lists that Cloudmonkey returns.
+  class CMHelper
+    # cm is a CMClient
+    def initialize(cm)
+      @cm = cm
+    end
+    
+    # Return a single network by name.
+    def list_physical_network(name)
+      networks = @cm.list_physicalnetworks(:name => name)
+      unless networks.nil?
+        return networks[:physicalnetwork][0] if networks[:count] > 0
+      end
+    end
+
+    # Return a single zone by name.
+    def list_zone(name)
+      zones = @cm.list_zones(:name => name)
+      unless zones.nil?
+        return zones[:zone][0] if zones[:count] > 0
+      end
+    end
+
+    # Enable a custom virtual router-derived network service
+    # provider. The provider will provide everything a VirtualRouter
+    # provides, but using itself instead of the regular VirtualRouter.
+    def enable_custom_vrouter_provider(provider, iface_id, zone_id)
+      nsp = @cm.add_networkserviceprovider(:name => provider, :physicalnetworkid => iface_id)
+      nsp = nsp[:networkserviceprovider]
+       
+      element = @cm.create_virtualrouterelement(:nspid => nsp[:id])[:virtualrouterelement]
+      @cm.configure_virtualrouterelement(:enabled => true, :id => element[:id])
+      new_nsp = @cm.update_networkserviceprovider(:state => 'Enabled', :id => nsp[:id])
+      return new_nsp[:networkserviceprovider]
+    end
+
+    # Delete a network service provider by name and physical network ID.
+    def delete_network_service_provider(name, iface_id)
+      nsps = @cm.list_networkserviceproviders(:name => name, :phsyicalnetworkid => iface_id)
+      if nsps[:count] > 0
+        nsp = nsps[:networkserviceprovider][0]
+        @cm.delete_networkserviceprovider(:id => nsp[:id])
+      else
+        return false
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: cloudmonkey
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- GreenQloud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-27 00:00:00.000000000 Z
+dependencies: []
+description: A simple interface to the CloudMonkey console command, allowing it to
+  be used in Ruby scripts.
+email:
+- developers@greenqloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cm.rb
+homepage: http://www.greenqloud.com
+licenses:
+- Apache
+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.23
+signing_key: 
+specification_version: 3
+summary: CloudMonkey-Ruby
+test_files: []