onering-agent 0.4.3

data/lib/onering/cli/fact.rb

@@ -0,0 +1,22 @@
+module Onering
+  module CLI
+    class Fact < Plugin
+      def self.configure(global={})
+        @opts = ::Trollop::options do
+          banner <<-EOS
+Return the value of an internal fact.
+
+Usage:
+    onering [global] fact [name]
+
+EOS
+        end
+      end
+
+      def self.run(args)
+        args[0] = :hardwareid if args[0] and args[0] == 'id'
+        return Onering::Util.fact(args[0])
+      end
+    end
+  end
+end

data/lib/onering/cli/reporter.rb

@@ -0,0 +1,121 @@
+module Onering
+  module CLI
+    class Report < Plugin
+      DEFAULT_CACHE_MAXAGE=600
+
+      def self.configure(global={})
+        @global_opts = global
+        @api = Onering::CLI.connect(@global_opts.merge({
+          :autoconnect => false
+        }))
+
+        @opts = ::Trollop::options do
+          banner <<-EOS
+Generate a system report that can be saved or submitted to a Onering server
+
+Subcommands:
+    <none>
+      Generate and output the system inventory report.
+
+    get  <property> [fallback]
+      Get a specific <property> from the report, return [fallback] if not found.
+
+    save
+      Generate and save the system inventory report to Onering.
+
+Usage:
+    onering [global] report [options] [subcommands]
+
+Options:
+EOS
+          opt :id,             "Override the autodetected Hardware ID for this node", :short => '-I', :type => :string
+          opt :fields,         "Set the named FIELD to equal VALUE in the format FIELD=VALUE. Can be specified multiple times", :short => '-o', :type => :string, :multi => true
+          opt :save,           "Save the report output to the configured Onering server"
+          opt :timeout,        "The maximum amount of time to wait for a report to be generated", :type => :integer, :default => 60
+          opt :plugin_timeout, "The maximum amount of time to wait for a report plugin to return data", :type => :integer, :default => 10
+          opt :local,          "Do not attempt to contact a remote server for retrieving values not found locally", :type => :boolean, :default => false
+          opt :cachefile,      "Use the specified file as a local report cache", :type => :string, :short => '-F'
+          opt :nocache,        "Do not attempt to use a cache file for report generation", :type => :boolean, :default => false
+          opt :maxage,         "Maxmimum age (in seconds) of the cache before it is automatically regenerated", :type => :integer, :default => DEFAULT_CACHE_MAXAGE
+
+          stop_on %w{get save}
+        end
+
+      # initialize report generator with user options
+        @_reporter = Onering::Reporter.new({
+          :id             => @opts[:id],
+          :timeout        => @opts[:timeout],
+          :plugin_timeout => @opts[:plugin_timeout],
+          :nocache        => @opts[:nocache],
+          :cachefile      => @opts[:cachefile],
+          :maxage         => @opts[:maxage]
+        }.compact)
+      end
+
+      def self.run(args)
+      # saving, by default, should not use the cache (but should update it to keep it fresh)
+        if @opts[:save] === true or args[0] == 'save'
+          report = _report({
+            :cacheregen => true
+          })
+        else
+          report = _report()
+        end
+        
+      # pull overrides from CLI arguments
+        @opts[:fields].each do |field|
+          key, value = field.split('=', 2)
+          Onering::Logger.debug("Override value #{key} from command line argument", "Onering::CLI::Report")
+
+          value = nil if ['null', '', '-'].include?(value.to_s.strip.chomp)
+          report = report.set(key, value)
+        end
+
+      # save if specified
+        if @opts[:save] === true
+          _save(report)
+
+        else
+          sc = args.shift
+
+          case (sc.downcase.to_sym rescue nil)
+  # -----------------------------------------------------------------------------
+          when :save
+            _save(report)
+            return nil
+
+          when :get
+            Onering::Logger.fatal!("Expected at least 1 parameter, got #{args.length}", "Onering::CLI::Report") unless args.length >= 1
+            return @_reporter.get(args[0], args[1], {
+              :data  => report,
+              :api   => @global_opts,
+              :local => @opts[:local]
+            })
+          end
+        end
+
+        return report
+      end
+
+    private
+      def self._save(report)
+        @api.connect()
+        @api.assets.save(report['id']) do
+          MultiJson.dump(report)
+        end
+      end
+
+      def self._report(options={})
+        begin
+          Onering::Logger.debug("Gathering local data for report", "Onering::CLI::Report")
+          Onering::Logger.fatal("Reporter not configured. This is a bug", "Onering::CLI::Report") if @_reporter.nil?
+          report = @_reporter.report(options).stringify_keys()
+
+          return report
+        rescue Timeout::Error
+          Onering::Logger.fatal!("Report took too long to generate, exiting...", "Onering::CLI::Report")
+        end
+      end
+    end
+  end
+end

data/lib/onering/config.rb

@@ -0,0 +1,62 @@
+require 'set'
+require 'hashlib'
+
+module Onering
+  class Config
+    class<<self
+      DEFAULT_CONFIG={}
+      DEFAULT_OPTIONS_FILE=["~/.onering/cli.yml", "~/.onering/key.yml", "/etc/onering/cli.yml", "/etc/onering/key.yml"]
+
+      def load(configfile=nil, config={})
+        if configfile.nil?
+          configfile = []
+        else
+        # recursively grab all .yml files if directory is specified
+          configfile = (File.directory?(configfile) ? Dir.glob(File.join(configfile, "**", "*.yml")).sort : [configfile])
+        end
+
+      # list all existing config files from least specific to most
+        @_configfiles = (configfile + DEFAULT_OPTIONS_FILE).compact.select{|i|
+          (File.exists?(File.expand_path(i)) rescue false)
+        }.reverse
+
+      # merge all config files with more-specific values overriding less-specific ones
+        @_config ||= DEFAULT_CONFIG
+        @_configfiles_seen ||= Set.new()
+
+      # only load files we haven't seen before
+        (@_configfiles - @_configfiles_seen.to_a).each do |i|
+          c = YAML.load(File.read(File.expand_path(i))) rescue {}
+            
+          if c and not c.empty?
+            Onering::Logger.info("Loading config file at #{File.expand_path(i) rescue i}", "Onering::Config")
+            @_config.deep_merge!(c)
+          end
+
+          @_configfiles_seen << i
+        end
+
+
+      # settings specified in the library override everything
+        unless config.empty?
+          Onering::Logger.debug("Merging settings specified in library instantiation", "Onering::Config")
+          @_config.deep_merge!(config.compact)
+        end
+
+        return @_config
+      end
+
+      def get(key, default=nil)
+        @_config.get(key, default)
+      end
+
+      def set(key, value)
+        @_config.set(key, value)
+      end
+
+      def unset(key)
+        @_config.unset(key)
+      end
+    end
+  end
+end

data/lib/onering/logger.rb

@@ -0,0 +1,141 @@
+require 'logger'
+require 'rainbow'
+require 'onering/version'
+
+module Onering
+  class Logger
+    def self.setup(options={})
+      outputfn = options[:destination]
+      @_verbosity = 1
+
+      if options[:destination] == /STDOUT/i
+        options[:destination] = STDOUT
+
+      elsif options[:destination] == /STDERR/i or
+            options[:destination].nil?
+        options[:destination] = STDERR
+
+      elsif File.writable?(options[:destination])
+        options[:destination] = File.open(options[:destination], 'a')
+
+      else
+        options[:destination] = STDERR
+      end
+
+      @_logger = ::Logger.new(options[:destination])
+      @_logger.formatter = (options[:formatter] || proc{|severity, datetime, source, msg|
+        case severity.downcase.to_sym
+        when :fatal then sevtag = '!!'
+        when :error then sevtag = 'EE'
+        when :warn then sevtag = 'WW'
+        when :info then sevtag = 'II'
+        when :debug then sevtag = 'DD'
+        when :output then sevtag = ''
+        else sevtag = '??'
+        end
+
+        if options[:sevtag] == false
+          logline = [(source.nil? ? nil : "[#{source}]"), msg].compact.join(' ')
+        else
+          logline = ["#{sevtag} ", (source.nil? ? nil : "[#{source}]"), msg].compact.join(' ')
+        end
+
+        if options[:destination] === STDOUT or options[:destination] === STDERR
+          case severity.downcase.to_sym
+          when :fatal, :error
+            logline = logline.foreground(:red)
+          when :warn
+            logline = logline.foreground(:yellow)
+          when :info
+            logline = logline.foreground(:green)
+          when :debug, :debug2, :debug3
+            logline = logline.foreground(:blue)
+          end
+        end
+
+        options[:destination].puts(logline)
+      })
+
+      self.level = (options[:threshold] || :info)
+
+      self.debug("onering-client v#{Onering::Client::VERSION} started") if defined?(Onering::FULL_CLIENT)
+      self.debug("Logger is initialized. Output is #{outputfn || 'stderr'}, threshold: #{options[:threshold]} or worse", (options[:name] || "Onering::Logger"))
+    end
+
+
+    def self.logger()
+      return @_logger
+    end
+
+    def self.level=(severity)
+      @_logger.sev_threshold = _get_level(severity)
+      @_verbosity = (Integer(severity.to_s[-1]) rescue 1)
+
+      @_logger.sev_threshold
+    end
+
+
+    def self.log(severity, message, source=nil, verbosity=1)
+      if defined?(@_logger)
+        if @_verbosity >= verbosity
+          @_logger.add(_get_level(severity), message, source)
+          return true
+        end
+      end
+
+      return false
+    end
+
+    def self.fatal(message, source=nil, raise_error=false)
+      self.log(:fatal, message, source)
+      raise Onering::Client::FatalError.new(message) if raise_error === true
+    end
+
+    def self.fatal!(message, source=nil)
+      self.fatal(message, source, true)
+    end
+
+    def self.error(message, source=nil)
+      self.log(:error, message, source)
+    end
+
+    def self.warn(message, source=nil)
+      self.log(:warn, message, source)
+    end
+
+    def self.info(message, source=nil)
+      self.log(:info, message, source)
+    end
+
+    def self.debug(message, source=nil)
+      self.log(:debug, message, source)
+    end
+
+    def self.debug2(message, source=nil)
+      self.log(:debug, message, source, 2)
+    end
+
+    def self.debug3(message, source=nil)
+      self.log(:debug, message, source, 3)
+    end
+
+    def self.output(message, source=nil)
+      self.log(:output, message, source)
+    end
+
+    def self._get_level(severity)
+      case severity.to_sym
+      when :fatal
+        return ::Logger::FATAL
+      when :error
+        return ::Logger::ERROR
+      when :warn
+        return ::Logger::WARN
+      when :info
+        return ::Logger::INFO
+      else
+        return ::Logger::DEBUG
+      end
+    end
+  end
+end

data/lib/onering/plugins/assets.rb

@@ -0,0 +1,54 @@
+module Onering
+  class API
+    class Assets < API
+      def show(id)
+        get("/devices/#{id}").parsed_response
+      end
+
+      def get_field(id, field, fallback=nil)
+        rv = get("/devices/#{id}/get/#{field}")
+        rv = (rv.parsed_response rescue rv.response.body)
+        return fallback if rv.nil? or (rv.is_a?(String) and rv.strip.chomp.empty?)
+        return rv
+      end
+
+      def set_field(id, field, value)
+        rv = get("/devices/#{id}/set/#{field}/#{value}")
+        rv.parsed_response rescue rv.response.body
+      end
+
+      def list(field, options={
+        :unique => true,
+        :sort   => true,
+        :filter => nil
+      })
+        qs = {
+          :q => make_filter(options[:filter])
+        } if options[:filter]
+
+        rv = get("/devices/list/#{[*field].join('/')}", {
+          :query => qs
+        }).parsed_response
+
+        rv = rv.uniq if options[:unique]
+        rv = rv.sort if options[:sort]
+
+        return rv
+      end
+
+      def find(filter, options={})
+        get("/devices/find/#{make_filter(filter)}").parsed_response
+      end
+
+      def save(id, data=nil, &block)
+        if block_given?
+          post("/devices/#{id}", {}, &block)
+        else
+          post("/devices/#{id}", {
+            :body => data
+          })
+        end
+      end
+    end
+  end
+end

data/lib/onering/plugins/authentication.rb

@@ -0,0 +1,35 @@
+module Onering
+  class API
+    class Auth < API
+      def _check_type(type)
+        raise "Invalid authentication module object '#{type}'" unless %w{
+          users groups capabilities
+        }.include?(type.to_s)
+      end
+
+      def show(type, id='current')
+        _check_type(type)
+        get("#{type}/#{id}").parsed_response
+      end
+
+      def list(type, field='id', options={
+        :unique => true,
+        :sort   => true,
+        :filter => nil
+      })
+        _check_type(type)
+        rv = get("#{type}/list").parsed_response.collect{|i| i[field.to_s] }
+        rv = rv.uniq if options[:unique]
+        rv = rv.sort if options[:sort]
+        rv
+      end
+
+      def save(type, id, data)
+        _check_type(type)
+        post("#{type}/#{id}", {
+          :body   => data
+        }).parsed_response
+      end
+    end
+  end
+end

data/lib/onering/plugins/automation.rb

@@ -0,0 +1,70 @@
+module Onering
+  class API
+    class AutomationRequests < API
+      def summary(fields)
+        get("/automation/requests/summary/#{[*fields].join('/')}").parsed_response
+      end
+
+      def find_by_status(status)
+        get("/automation/requests/status/#{status}").parsed_response
+      end
+
+      def show(id)
+        get("/automation/requests/#{id}").parsed_response
+      end
+
+      def requeue(id)
+        get("/automation/requests/#{id}/requeue").parsed_response
+      end
+
+      def flush_queue()
+        get("/automation/requests/flush").parsed_response
+      end
+
+      def purge()
+        get("/automation/requests/purge").parsed_response
+      end
+
+      def requeue_all_failed()
+        get("/automation/requests/requeue").parsed_response
+      end
+    end
+
+
+# -----------------------------------------------------------------------------
+    class AutomationJobs < API
+      def list()
+        get("/automation/jobs/list").parsed_response
+      end
+
+      def show(name)
+        get("/automation/jobs/#{name}").parsed_response
+      end
+
+      def requests_waiting(name)
+        get("/automation/jobs/#{name}/waiting").parsed_response
+      end
+
+      def run(name, options={}, &block)
+        if block_given?
+          post("/automation/jobs/#{name}/run", {
+            :query => options
+          }, &block).parsed_response
+        else
+          get("/automation/jobs/#{name}/run", {
+            :query => options
+          }).parsed_response
+        end
+      end
+    end
+
+# -----------------------------------------------------------------------------
+    class AutomationTasks < API
+      def run(name, options={})
+        get("/automation/tasks/#{name}/run", {
+          :query => options
+        }).parsed_response
+      end
+    end
+  end
+end