onering-client 0.0.46 → 0.0.50

data/lib/onering/api.rb

@@ -1,221 +1,276 @@
-require 'rest_client'
-require 'uri'
-require 'multi_json'
 require 'yaml'
-require 'addressable/uri'
+require 'hashlib'
 require 'deep_merge'
+require 'addressable/uri'
+require 'active_support/core_ext'
+require 'httparty'
 
 module Onering
-  module API
+  class API
+    module Actions
+      class Retry < ::Exception; end
+    end
+
     module Errors
+      class Exception < ::Exception; end
       class NotConnected < Exception; end
       class ClientError < Exception; end
       class ServerError < Exception; end
       class ConnectionTimeout < Exception; end
-      class ClientPemNotFound < Exception; end
-    end
-
-    class Base
-      include Onering::Util
-
-      DEFAULT_BASE="https://onering"
-      DEFAULT_PATH="/api"
-      DEFAULT_OPTIONS_FILE=[
-        "~/.onering/cli.yml",
-        "/etc/onering/cli.yml"
-      ]
-
-      DEFAULT_CLIENT_PEM=[
-        "~/.onering/client.pem",
-        "/etc/onering/client.pem"
-      ]
-
-      DEFAULT_VALIDATION_PEM=[
-        "/etc/onering/validation.pem"
-      ]
-
-      class<<self
-        def connect(options={})
-        # list all existing config files from least specific to most
-          @_configfiles = ([options[:config]] + 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 = {}
-          @_configfiles.each do |i|
-            c = YAML.load(File.read(File.expand_path(i))) rescue {}
-            @_config.deep_merge!(c)
-          end
+      class AuthenticationMissing < Exception; end
+    end
 
-          if options[:host].is_a?(URI)
-            @_uri = options[:host]
-          elsif options[:host].is_a?(String)
-            @_uri = Addressable::URI.parse("#{options[:host]}/#{DEFAULT_PATH}")
-          else
-            @_uri = Addressable::URI.parse("#{@_config['url'] || DEFAULT_BASE}/#{@_config['apiroot'] || DEFAULT_PATH}")
-          end
+    include Onering::Util
+    include ::HTTParty
 
-          unless @_uri.nil?
-            begin
-              @_pemfile = ([options[:pemfile], @_config['pemfile']]+DEFAULT_CLIENT_PEM).compact.select{|i|
-                (File.exists?((File.expand_path(i) rescue i)) rescue nil)
-              }.compact.first
+    attr_accessor :url
+    format        :json
 
-              raise Errors::ClientPemNotFound if @_pemfile.nil?
+    DEFAULT_CONFIG={}
+    DEFAULT_BASE="https://onering"
+    DEFAULT_PATH="/api"
+    DEFAULT_OPTIONS_FILE=["~/.onering/cli.yml", "/etc/onering/cli.yml"]
+    DEFAULT_CLIENT_PEM=["~/.onering/client.pem", "/etc/onering/client.pem"]
+    DEFAULT_CLIENT_KEY=["~/.onering/client.key", "/etc/onering/client.key"]
+    DEFAULT_VALIDATION_PEM="/etc/onering/validation.pem"
 
-              @_pem = File.read((File.expand_path(@_pemfile) rescue @_pemfile))
 
-              @rest = RestClient::Resource.new("#{@_uri.scheme}://#{@_uri.host}:#{@_uri.port || 443}", {
-                :timeout         => 120,
-                :open_timeout    => 30,
-                :ssl_client_cert => OpenSSL::X509::Certificate.new(@_pem),
-                :ssl_client_key  => OpenSSL::PKey::RSA.new(@_pem),
-                :verify_peer     => OpenSSL::SSL::VERIFY_PEER
-              })
+    def initialize(options={})
+      @_config = {}
+      @_plugins = {}
+      @_connection_options = options
 
-            rescue Errors::ClientPemNotFound
-            # client PEM not present, attempt autoregistration
-              STDERR.puts("Onering client.pem not found, attempting automatic registration...")
+    # load and merge all config file sources
+      _load_config(@_connection_options[:configfile], @_connection_options.get(:config, {}))
 
-              begin
-                @_validation = ([options[:validationfile], @_config['validationfile']]+DEFAULT_VALIDATION_PEM).compact.select{|i|
-                  (File.exists?((File.expand_path(i) rescue i)) rescue nil)
-                }.compact.first
+    # set API connectivity details
+      Onering::API.base_uri @_config.get(:url, DEFAULT_BASE)
 
-                if @_validation.nil?
-                  raise Errors::ClientError.new("Cannot automatically register client, cannot find validation.pem")
-                end
+      Onering::Reporter.setup()
+      connect(options) if options.get(:autoconnect, true)
+    end
 
-                @_validation = File.read(@_validation)
-
-                @rest = RestClient::Resource.new("#{@_uri.scheme}://#{@_uri.host}:#{@_uri.port || 443}", {
-                  :timeout         => 120,
-                  :open_timeout    => 30,
-                  :ssl_client_cert => OpenSSL::X509::Certificate.new(@_validation),
-                  :ssl_client_key  => OpenSSL::PKey::RSA.new(@_validation),
-                  :verify_peer     => OpenSSL::SSL::VERIFY_PEER
-                })
-
-
-                clients = [{
-                  :path       => "/etc/onering",
-                  :name       => (@_config['id'] || File.read("/etc/hardware.id")).strip.chomp,
-                  :keyname    => 'system',
-                  :autodelete => true
-                },{
-                  :path       => "~/.onering",
-                  :name       => ENV['USER'],
-                  :keyname    => 'cli',
-                  :autodelete => false
-                }]
-
-              # attempt to autoregister clients from least specific to most (machine account then user account)
-                clients.each do |client|
-                # determine if we can create this client
-                  client[:path] = (File.expand_path(client[:path]) rescue client[:path])
-                  next unless File.writable?(File.dirname(client[:path]))
-                  Dir.mkdir(client[:path]) unless File.directory?(client[:path])
-                  next unless File.writable?(client[:path])
-
-                  begin
-                    response = @rest["/api/users/#{client[:name]}/keys/#{client[:keyname]}"].get({
-                      :params => {
-                        :cert       => 'pem',
-                        :autodelete => client[:autodelete]
-                      }
-                    })
-
-                  rescue RestClient::Forbidden
-                    STDERR.puts("Cannot re-download key '#{client[:keyname]}' for client #{client[:name]}. Please remove the client key from Onering and try again.")
-                    next
-
-                  rescue RestClient::Exception => e
-                    raise Errors::ClientError.new("HTTP #{e.http_code}: #{e.message}")
-                  end
-
-
-                  File.open("#{client[:path]}/client.pem", "w") do |file|
-                    file.puts(response.to_str)
-                    STDERR.puts("Successfully registered client key #{client[:name]}:#{client[:keyname]}, key is at #{file.path}")
-                    break
-                  end
-                end
+    def connect(options={})
+    # setup authentication
+      _setup_auth()
 
-                if clients.select{|i| p = "#{i[:path]}/client.pem"; File.exists?((File.expand_path(p) rescue p)) }.empty?
-                  raise Errors::ClientError.new("Unable to register a Onering client.")
-                end
+      return self
+    end
 
-                retry
 
-              rescue Exception => e
-                STDERR.puts("Error occurred during autoregistration: #{e.class.name} - #{e.message}")
-              end
-            end
+    def request(method, endpoint, options={})
+      endpoint = [@_config.get(:path, DEFAULT_PATH).strip, endpoint.sub(/^\//,'')].join('/')
+
+      case method
+      when :post
+        rv = Onering::API.post(endpoint, options)
+      when :put
+        rv = Onering::API.put(endpoint, options)
+      when :delete
+        rv = Onering::API.delete(endpoint, options)
+      when :head
+        rv = Onering::API.head(endpoint, options)
+      else
+        rv = Onering::API.get(endpoint, options)
+      end
 
-          else
-            raise Errors::ClientError.new("Could not parse API URL.")
-          end
-        end
+      if rv.code >= 500
+        raise Errors::ServerError.new("HTTP #{rv.code} - #{Onering::Util.http_status(rv.code)} #{rv.parsed_response.get('error.message','') rescue ''}")
+      elsif rv.code >= 400
+        raise Errors::ClientError.new("HTTP #{rv.code} - #{Onering::Util.http_status(rv.code)} #{rv.parsed_response.get('error.message', '') rescue ''}")
+      else
+        rv
+      end
+    end
 
-        def request(endpoint, options={})
-          options = @_config.merge(options)
-          options[:method] = (options[:method].to_s.downcase.to_sym rescue nil)
-          request = nil
 
-          uri = Addressable::URI.parse("#{@_uri.to_s}/#{endpoint}")
-          uri.query_values = options[:fields] if options[:fields]
+    def get(endpoint, options={})
+      request(:get, endpoint, options)
+    end
 
-          raise Errors::NotConnected unless @rest
+    def post(endpoint, options={}, &block)
+      if block_given?
+        request(:post, endpoint, options.merge({
+          :body => yield
+        }))
+      else
+        request(:post, endpoint, options)
+      end
+    end
 
-          begin
-            case options[:method]
-            when :post
-              data = (options[:data].nil? ? nil : MultiJson.dump(options[:data]))
+    def put(endpoint, options={})
+      if block_given?
+        request(:put, endpoint, options.merge({
+          :body => yield
+        }))
+      else
+        request(:put, endpoint, options)
+      end
+    end
 
-              response = @rest[uri.request_uri].post(data, {
-                :content_type => 'application/json'
-              })
+    def delete(endpoint, options={})
+      request(:delete, endpoint, options)
+    end
 
-            when :delete
-              response = @rest[uri.request_uri].delete()
 
-            when :head
-              response = @rest[uri.request_uri].head()
-            else
-              response = @rest[uri.request_uri].get()
-            end
+  # I'm not a huge fan of what's happening here, but metaprogramming is hard...
+  #
+  # "Don't let the perfect be the enemy of the good."
+  #
+    def method_missing(method, *args, &block)
+      modname = method.to_s.split('_').map(&:capitalize).join
 
-          rescue RestClient::Unauthorized => e
-            raise Errors::ClientError.new("You are not authorized to perform this request")
+      if not (plugin = (Onering::API.const_get(modname) rescue nil)).nil?
+        @_plugins[method] ||= plugin.new.connect(@_connection_options)
+        return @_plugins[method]
+      else
+        super
+      end
+    end
 
-          rescue RestClient::Exception => e
-            raise Errors::ClientError.new("(HTTP #{e.http_code}) #{e.class.name}: #{e.message}")
-          end
+    def opt(name, default=nil)
+      @_config.get(name, default)
+    end
 
-          begin
-            rv = (response.empty? ? nil : MultiJson.load(response))
-          rescue Exception
-            rv = response
-          end
 
-          rv
-        end
+    def status()
+      Onering::API.get("/").parsed_response
+    end
 
-        def make_filter(filter)
-          filter = filter.collect{|k,v| "#{k}/#{v}" } if filter.is_a?(Hash)
-          filter = filter.collect{|i| i.sub(':','/') }.join("/") if filter.is_a?(Array)
-          filter
-        end
 
-        def echo(obj)
-          if obj.is_a?(Array)
-            obj.each do |i|
-              puts i
+
+  private
+# -----------------------------------------------------------------------------
+    def _load_config(configfile, 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.each do |i|
+        c = YAML.load(File.read(File.expand_path(i))) rescue {}
+        @_config.deep_merge!(c)
+      end
+
+    # settings specified in the library override everything
+      @_config.deep_merge!(config.compact) unless config.empty?
+    end
+
+
+# -----------------------------------------------------------------------------
+    def _setup_auth()
+      type = @_config.get('authentication.type', :auto)
+
+      case type.to_sym
+      when :token
+        _setup_auth_token()
+
+      else
+        _setup_auth_ssl()
+      end
+    end
+
+
+# -----------------------------------------------------------------------------
+    def _setup_auth_ssl()
+      begin
+      # get first keyfile found
+        key = (([@_config.get('authentication.keyfile')] + DEFAULT_CLIENT_PEM).compact.select{|i|
+          (File.exists?(File.expand_path(i)) rescue false)
+        }).first
+
+      # SSL client key not found, attempt autoregistration...
+        if key.nil?
+          if @_config.get('authentication.autoregister', true)
+            validation_key = @_config.get('authentication.validation_keyfile', DEFAULT_VALIDATION_PEM)
+            validation_key = (File.expand_path(validation_key) rescue validation_key)
+
+          # if validation key exists, autoregister
+            if File.size?(validation_key)
+            # set the authentication PEM to validation.pem
+              Onering::API.pem(File.read(validation_key))
+
+            # attempt to create client.pem from least-specific to most, first writable path wins
+              clients = [{
+                :path       => "/etc/onering",
+                :name       => fact('hardwareid'),
+                :keyname    => 'system',
+                :autodelete => true
+              },{
+                :path       => "~/.onering",
+                :name       => ENV['USER'],
+                :keyname    => 'cli',
+                :autodelete => false
+              }]
+
+            # for each client attempt...
+              clients.each do |client|
+              # expand and assemble path
+                client[:path] = (File.expand_path(client[:path]) rescue client[:path])
+                keyfile = File.join(client[:path], 'client.pem')
+
+              # skip this if we can't write to the parent directory
+                next unless File.writable?(client[:path])
+                Dir.mkdir(client[:path]) unless File.directory?(client[:path])
+                next if File.exists?(keyfile)
+
+              # attempt to create/download the keyfile
+                response = self.class.get("/api/users/#{client[:name].strip}/keys/#{client[:keyname]}")
+
+              # if successful, write the file
+                if response.code < 400 and response.body
+                  File.open(keyfile, 'w').puts(response.body)
+                  raise Actions::Retry.new
+                else
+              # all errors are fatal at this stage
+                  raise Errors::ClientError.new("Cannot autoregister client: HTTP #{response.code} - #{(response.parsed_response || {}).get('error.message', 'Unknown error')}")
+                end
+              end
+
+            # it is an error to not have created a client.pem by now
+              raise Errors::AuthenticationMissing.new("Cannot autoregister client: keyfile not created")
+
+            else
+            # cannot autoregister without a validation.pem
+              raise Errors::AuthenticationMissing.new("Cannot autoregister client: validation keyfile is missing")
             end
+          else
+            raise Errors::AuthenticationMissing.new("Cannot find SSL key and autoregistration is disabled")
           end
+        else
+          Onering::API.pem(File.read((File.expand_path(key) rescue key)))
         end
+
+      rescue Actions::Retry
+        retry
       end
     end
+
+
+# -----------------------------------------------------------------------------
+    def _setup_auth_token()
+    # get first keyfile found
+      key = @_config.get('authentication.key')
+      raise Errors::AuthenticationMissing.new("Cannot find an API token") if key.nil?
+
+    # set auth mechanism
+      Onering::API.headers({
+        'X-Auth-Mechanism' => 'token'
+      })
+
+    # set default parameters
+      Onering::API.default_params({
+        :token => key
+      })
+    end
   end
-end
+end

data/lib/onering/cli/automation.rb

@@ -0,0 +1,59 @@
+module Onering
+  module CLI
+    module Automation
+      def self.configure(global={})
+        @requests = Onering::CLI.connect(global).automation_requests
+        @jobs = Onering::CLI.connect(global).automation_jobs
+        @tasks = Onering::CLI.connect(global).automation_tasks
+      end
+
+      def self.run(args)
+        sc = args.shift   # subcommand
+        ssc = args.shift  # sub-subcommand
+
+        case (sc.downcase.to_sym rescue nil)
+# -----------------------------------------------------------------------------
+        when :requests
+          @opts = ::Trollop::options do
+            banner <<-EOS
+Options:
+EOS
+            stop_on %w{show status requeue flush}
+          end
+
+          case (ssc.downcase.to_sym rescue nil)
+          when :show
+            return @requests.show(args[0])
+
+          when :requeue
+            return @requests.requeue_all_failed() if args[0].nil?
+            return @requests.requeue(args[0])
+
+          when :status
+            fields = (args.empty? ? ["status"] : args)
+            rv = {}
+            out = @requests.summary(fields)
+
+            _rejigger_hash = Proc.new do |h|
+              [*h].collect{|i|
+                [i['id'], (i['children'].nil? ? i['count'] : Hash[_rejigger_hash.call(i['children'])])]
+              }
+            end
+
+            return Hash[_rejigger_hash.call(out)]
+
+          when :flush
+            return @requests.flush_queue()
+          end
+
+# -----------------------------------------------------------------------------
+        when :jobs
+
+
+# -----------------------------------------------------------------------------
+        when :tasks
+        end
+      end
+    end
+  end
+end

data/lib/onering/cli/call.rb

@@ -0,0 +1,36 @@
+module Onering
+  module CLI
+    module Call
+      def self.configure(global={})
+        @api = Onering::CLI.connect(global)
+
+        @opts = ::Trollop::options do
+          banner <<-EOS
+Call an arbitrary Onering API endpoint and return the output
+
+Usage:
+    onering call [options] [endpoint]
+
+Examples:
+    # Returns the API status page at path /api/
+    $ onering call /
+
+    # Returns details about the authenticated user
+    $ onering call users/current
+
+    # Delete the device called '0bf29c'
+    $ onering call devices/0bf29c -m delete
+
+Options:
+EOS
+          opt :method, "The HTTP method to use when performing the request (default: GET)", :default => 'get', :short => "-m", :type => :string
+        end
+      end
+
+      def self.run(args)
+        rv = @api.request(@opts[:method], args.first)
+        return (rv.parsed_response || rv.response.body)
+      end
+    end
+  end
+end

data/lib/onering/cli/devices.rb

@@ -0,0 +1,93 @@
+module Onering
+  module CLI
+    module Devices
+      def self.configure(global={})
+        @api = Onering::CLI.connect(global).devices
+
+        @opts = ::Trollop::options do
+          banner <<-EOS
+Options:
+EOS
+
+          opt :query, "The Onering urlquery to filter devices by", :short => '-f', :type => :string
+          opt :id,    "The node ID of the device to operate on", :short => '-i', :type => :string
+
+        # subcommands
+          stop_on %w{show get set list find save}
+        end
+      end
+
+      def self.run(args)
+        sc = args.shift
+
+        case (sc.downcase.to_sym rescue nil)
+# -----------------------------------------------------------------------------
+        when :show
+          return @api.devices.show(args[0])
+
+# -----------------------------------------------------------------------------
+        when :get
+          raise "Expected 1 parameter, got #{args.length}" unless args.length == 1
+
+          if @opts[:query_given]
+          # doing this until a bulk field query endpoint is built
+            return @api.list('id', {
+              :filter => @opts[:query]
+            }).collect{|i| @api.get_field(i, args[0])}
+
+          elsif @opts[:id_given]
+            return @api.get_field(@opts[:id], args[0])
+
+          end
+
+# -----------------------------------------------------------------------------
+        when :set
+          raise "Expected 2 parameters, got #{args.length}" unless args.length == 2
+
+          if @opts.get(:query)
+          # doing this until a bulk field set endpoint is built
+            return @api.list('id', {
+              :filter => @opts[:query]
+            }).collect{|i| @api.set_field(i, args[0])}
+
+          elsif @opts.get(:id)
+            return @api.set_field(@opts[:id], args[0], args[1])
+
+          end
+
+# -----------------------------------------------------------------------------
+        when :list
+          raise "Expected 1 parameter, got #{args.length}" unless args.length >= 1
+          return @api.list(args[0], {
+            :filter => [@opts[:query], args[1]].compact.join('/')
+          }.compact)
+
+# -----------------------------------------------------------------------------
+        when :find
+          raise "Expected 1 parameter, got #{args.length}" unless args.length == 1
+          return @api.find(args[0])
+
+# -----------------------------------------------------------------------------
+        when :save
+          rv = @api.save(args[0] || @opts[:id]) do
+          # read from pipe
+            if not STDIN.tty?
+              STDIN.read
+
+          # read from specified file
+            elsif (File.readable?(args[1]) rescue false)
+              File.read(args[1])
+
+            else
+              raise "Cannot save data, no input data specified"
+            end
+          end
+
+          rv.parsed_response
+        else
+          raise "Unknown subcommand #{sc.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/onering/cli/fact.rb

@@ -0,0 +1,23 @@
+module Onering
+  module CLI
+    module Fact
+      def self.configure(global={})
+        Onering::Reporter.setup()
+
+        @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)
+        return Onering::Util.fact(args[0])
+      end
+    end
+  end
+end