hammer_cli 0.0.4

data/lib/hammer_cli/exception_handler.rb

@@ -0,0 +1,69 @@
+require 'rest_client'
+require 'logging'
+
+module HammerCLI
+  class ExceptionHandler
+
+    def initialize options={}
+      @output = options[:output] or raise "Missing option output"
+      @logger = Logging.logger['Exception']
+    end
+
+    def mappings
+      [
+        [Exception, :handle_general_exception], # catch all
+        [RestClient::ResourceNotFound, :handle_not_found],
+        [RestClient::Unauthorized, :handle_unauthorized],
+      ]
+    end
+
+    def handle_exception e, options={}
+      @options = options
+      handler = mappings.reverse.find { |m| e.class.respond_to?(:"<=") ? e.class <= m[0] : false }
+      return send(handler[1], e) if handler
+      raise e
+    end
+
+    protected
+
+    def print_error error
+      error = error.join("\n") if error.kind_of? Array
+      @logger.error error
+
+      if @options[:heading]
+        @output.print_error @options[:heading], error
+      else
+        @output.print_error error
+      end
+    end
+
+    def log_full_error e
+      backtrace = e.backtrace || []
+      @logger.error "\n\n#{e.class} (#{e.message}):\n    " + 
+        backtrace.join("\n    ")
+        "\n\n"
+    end 
+
+    def handle_general_exception e
+      print_error "Error: " + e.message
+      log_full_error e
+      HammerCLI::EX_SOFTWARE
+    end
+
+    def handle_not_found e
+      print_error e.message
+      log_full_error e
+      HammerCLI::EX_NOT_FOUND
+    end
+
+    def handle_unauthorized e
+      print_error "Invalid username or password"
+      log_full_error e
+      HammerCLI::EX_UNAUTHORIZED
+    end
+
+  end
+end
+
+
+

data/lib/hammer_cli/exit_codes.rb

@@ -0,0 +1,23 @@
+module HammerCLI
+  # taken from sysexits.h
+  EX_OK           = 0       # successful termination
+  EX_USAGE        = 64      # command line usage error
+  EX_DATAERR      = 65      # data format error
+  EX_NOINPUT      = 66      # cannot open input
+  EX_NOUSER       = 67      # addressee unknown 
+  EX_NOHOST       = 68      # host name unknown
+  EX_UNAVAILABLE  = 69      # service unavailable
+  EX_SOFTWARE     = 70      # internal software error
+  EX_OSERR        = 71      # system error (e.g., can't fork)
+  EX_OSFILE       = 72      # critical OS file missing
+  EX_CANTCREAT    = 73      # can't create (user) output file
+  EX_IOERR        = 74      # input/output error
+  EX_TEMPFAIL     = 75      # temp failure; user is invited to retry
+  EX_PROTOCOL     = 76      # remote error in protocol
+  EX_NOPERM       = 77      # permission denied
+  EX_CONFIG       = 78      # configuration error
+
+  # non POSIX codes
+  EX_NOT_FOUND    = 128     # resource was not found
+  EX_UNAUTHORIZED = 129     # authorization failed
+end

data/lib/hammer_cli/logger.rb

@@ -0,0 +1,50 @@
+require 'fileutils'
+require 'logging'
+
+module HammerCLI
+  module Logger
+
+    Logging.color_scheme('bright',
+                         :levels => {
+                             :info  => :green,
+                             :warn  => :yellow,
+                             :error => :red,
+                             :fatal => [:white, :on_red]},
+                         :date   => :blue,
+                         :logger => :cyan,
+                         :line   => :yellow,
+                         :file   => :yellow,
+                         :method => :yellow)
+
+    pattern         = "[%5l %d %c] %m\n"
+    COLOR_LAYOUT    = Logging::Layouts::Pattern.new(:pattern => pattern, :color_scheme => 'bright')
+    NOCOLOR_LAYOUT  = Logging::Layouts::Pattern.new(:pattern => pattern, :color_scheme => nil)
+    DEFAULT_LOG_DIR = '/var/log/foreman'
+
+    log_dir = File.expand_path(HammerCLI::Settings[:log_dir] || DEFAULT_LOG_DIR)
+    begin
+      FileUtils.mkdir_p(log_dir, :mode => 0750)
+    rescue Errno::EACCES => e
+      puts "No permissions to create log dir #{log_dir}"
+    end
+
+    logger   = Logging.logger.root
+    filename = "#{log_dir}/hammer.log"
+    begin
+      logger.appenders = ::Logging.appenders.rolling_file('configure',
+                                                          :filename => filename,
+                                                          :layout   => NOCOLOR_LAYOUT,
+                                                          :truncate => false,
+                                                          :keep     => 5,
+                                                          :size     => HammerCLI::Settings[:log_size] || 1024*1024) # 1MB
+      # set owner and group (it's ignored if attribute is nil)
+      FileUtils.chown HammerCLI::Settings[:log_owner], HammerCLI::Settings[:log_group], filename
+    rescue ArgumentError => e
+      puts "File #{filename} not writeable, won't log anything to file!"
+    end
+
+    logger.level = HammerCLI::Settings[:log_level]
+
+  end 
+
+end

data/lib/hammer_cli/logger_watch.rb

@@ -0,0 +1,14 @@
+require 'awesome_print'
+
+module HammerCLI
+  module Logger
+    module Watch
+      def watch(label, obj, options={})
+        if debug?
+          options = { :plain => HammerCLI::Settings[:watch_plain], :indent => -2 }.merge(options)
+          debug label + "\n" + obj.ai(options)
+        end
+      end
+    end
+  end
+end

data/lib/hammer_cli/main.rb

@@ -0,0 +1,53 @@
+require 'highline/import'
+
+module HammerCLI
+
+  class MainCommand < AbstractCommand
+
+    option ["-v", "--verbose"], :flag, "be verbose"
+    option ["-c", "--config"], "CFG_FILE", "path to custom config file"
+
+    option ["-u", "--username"], "USERNAME", "username to access the remote system"
+    option ["-p", "--password"], "PASSWORD", "password to access the remote system"
+
+    option "--version", :flag, "show version" do
+      puts "hammer-%s" % HammerCLI.version
+      exit(HammerCLI::EX_OK)
+    end
+
+    option ["-P", "--ask-pass"], :flag, "Ask for password" do 
+      context[:password] = get_password()
+      ''
+    end
+
+    option "--autocomplete", "LINE", "Get list of possible endings" do |line|
+      line = line.split
+      line.shift
+      endings = self.class.autocomplete(line).map { |l| l[0] }
+      puts endings.join(' ')
+      exit(HammerCLI::EX_OK)
+    end
+
+    def password=(password)
+      context[:password] = password.nil? ? ENV['FOREMAN_PASSWORD'] : password
+    end
+
+    def username=(username)
+      context[:username] = username.nil? ? ENV['FOREMAN_USERNAME'] : username
+    end
+
+    private
+
+    def get_password(prompt="Enter Password ")
+      ask(prompt) {|q| q.echo = false}
+    end
+
+
+
+  end
+
+end
+
+# extend MainCommand
+require 'hammer_cli/shell'
+

data/lib/hammer_cli/messages.rb

@@ -0,0 +1,55 @@
+
+module HammerCLI
+  module Messages
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def success_message_for action
+      self.class.success_message_for action
+    end
+
+    def success_message
+      self.class.success_message
+    end
+
+    def failure_message_for action
+      self.class.failure_message_for action
+    end
+
+    def failure_message
+      self.class.failure_message
+    end
+
+    def handle_exception e
+      exception_handler.handle_exception e, :heading => failure_message
+    end
+
+    module ClassMethods
+      def success_message_for action, msg=nil
+        @success_message ||= {}
+        @success_message[action] = msg unless msg.nil?
+        @success_message[action]
+      end
+
+      def success_message msg=nil
+        success_message_for :default, msg
+      end
+
+      def failure_message_for action, msg=nil
+        @failure_message ||= {}
+        @failure_message[action] = msg unless msg.nil?
+        @failure_message[action]
+      end
+
+      def failure_message msg=nil
+        failure_message_for :default, msg
+      end
+    end
+
+  end
+end
+
+
+

data/lib/hammer_cli/option_formatters.rb

@@ -0,0 +1,13 @@
+module HammerCLI
+  module OptionFormatters
+
+    def self.list(val)
+      val.is_a?(String) ? val.split(",") : []
+    end
+
+    def self.file(path)
+      File.read(File.expand_path(path))
+    end
+
+  end
+end

data/lib/hammer_cli/output/adapter/abstract.rb

@@ -0,0 +1,27 @@
+
+module HammerCLI::Output::Adapter
+
+  class Abstract
+
+    def print_message msg
+      puts msg
+    end
+
+    def print_error msg, details=nil
+      details = details.split("\n") if details.kind_of? String
+
+      if details
+        indent = "  "
+        $stderr.puts msg+":"
+        $stderr.puts indent + details.join("\n"+indent)
+      else
+        $stderr.puts msg
+      end
+    end
+
+    def print_records fields, data, heading=nil
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/hammer_cli/output/adapter/base.rb

@@ -0,0 +1,143 @@
+module HammerCLI::Output::Adapter
+  class Base < Abstract
+
+    HEADING_LINE_WIDTH = 80
+    GROUP_INDENT = " "*2
+    LABEL_DIVIDER = ": "
+
+    def print_records fields, data, heading=nil
+      self.fields = fields
+
+      puts "-"*HEADING_LINE_WIDTH
+      puts "  " + heading.to_s
+      puts "-"*HEADING_LINE_WIDTH
+
+      data.each do |d|
+        fields.collect do |f|
+          render_field(f, d)
+        end
+        puts
+      end
+    end
+
+    protected
+
+    def render_Field(field, data, indent="")
+      puts indent.to_s+" "+format_value(field, data).to_s
+    end
+
+    def render_Label(field, data, indent="")
+      render_label(field, indent)
+      puts
+      indent = indent.to_s + GROUP_INDENT
+
+      field.output_definition.fields.collect do |f|
+        render_field(f, data, indent)
+      end
+    end
+
+    def render_LabeledField(field, data, indent="")
+      render_label(field, indent)
+      puts format_value(field, data).to_s
+    end
+
+    def render_KeyValue(field, data, indent="")
+      render_label(field, indent)
+      params = field.get_value(data) || []
+      print "%{name} => %{value}" % params
+    end
+
+    def render_Collection(field, data, indent="")
+      render_label(field, indent)
+      puts
+      indent = indent.to_s + " "*(label_width_for_list(self.fields)+LABEL_DIVIDER.size)
+
+      field.get_value(data).each do |d|
+        field.output_definition.fields.collect do |f|
+          render_field(f, d, indent)
+        end
+        puts
+      end
+    end
+
+    def render_Joint(field, data, indent="")
+      render_label(field, indent)
+      data = field.get_value(data)
+      puts field.attributes.collect{|attr| data[attr] }.join(" ")
+    end
+
+    def format_Date(string_date)
+      t = DateTime.parse(string_date.to_s)
+      t.strftime("%Y/%m/%d %H:%M:%S")
+    rescue ArgumentError
+      ""
+    end
+
+    def format_List(list)
+      list.join(", ") if list
+    end
+
+    def format_OSName(os)
+      "%{name} %{major}.%{minor}" % os
+    end
+
+    def format_Server(server)
+      "%{name} (%{url})" % server
+    end
+
+
+    def render_field(field, data, indent="")
+      renderer = find_renderer(field)
+      renderer.call(field, data, indent)
+    end
+
+    def render_label(field, indent="")
+      if field.label
+        w = label_width_for_list(self.fields) - indent.size + 1
+        print indent.to_s+" %#{-w}s" % (field.label.to_s+LABEL_DIVIDER)
+      else
+        print indent.to_s+" "
+      end
+    end
+
+    def format_value(field, data)
+      format_method = "format_"+field_type(field.class)
+
+      value = field.get_value(data)
+      value = send(format_method, value) if respond_to?(format_method, true)
+      value
+    end
+
+    def find_renderer(field)
+      field.class.ancestors.each do |cls|
+        render_method = "render_"+field_type(cls)
+        return method(render_method) if respond_to?(render_method, true)
+      end
+      raise "No renderer found for field %s" % field.class
+    end
+
+    def field_type(field_class)
+      field_class.name.split("::")[-1]
+    end
+
+    def label_width_for(field)
+      if field.respond_to?(:output_definition)
+        label_width_for_list(field.output_definition.fields)+GROUP_INDENT.size
+      elsif field.respond_to?(:label)
+        field.label.size+LABEL_DIVIDER.size rescue 0
+      else
+        0
+      end
+    end
+
+    def label_width_for_list(fields)
+      fields.inject(0) do |result, f|
+        width = label_width_for(f)
+        (width > result) ? width : result
+      end
+    end
+
+    attr_accessor :fields
+
+  end
+end

data/lib/hammer_cli/output/adapter/silent.rb

@@ -0,0 +1,17 @@
+
+module HammerCLI::Output::Adapter
+
+  class Silent
+
+    def print_message msg
+    end
+
+    def print_error msg, details=[]
+    end
+
+    def print_records fields, data, heading=nil
+    end
+
+  end
+
+end

data/lib/hammer_cli/output/adapter/table.rb

@@ -0,0 +1,53 @@
+require 'table_print'
+
+module HammerCLI::Output::Adapter
+
+  class Table < Base
+
+    def print_records fields, data, heading=nil
+
+      rows = data.collect do |d|
+        row = {}
+        fields.each do |f|
+          row[f.label.to_sym] = f.get_value(d)
+        end
+        row
+      end
+
+      options = fields.collect do |f|
+        { f.label.to_sym => { 
+            :formatters => [ Formatter.new(self, "format_"+field_type(f.class)) ] } }
+      end
+
+      printer = TablePrint::Printer.new(rows, options)
+      output = printer.table_print
+      dashes = /\n(-+)\n/.match output
+      puts dashes[1]
+      puts output
+      puts dashes[1]
+    end
+
+    def print_heading heading, size
+      size = heading.size if heading.size > size
+      puts '-' * size
+      puts ' ' * ((size-heading.size)/2) + heading
+      puts '-' * size
+    end
+
+  end
+
+  class Formatter
+    def initialize adapter, method
+      @adapter = adapter
+      @method = method
+    end
+
+    def format value
+      if @adapter.respond_to?(@method, true)
+        value = @adapter.send(@method, value) 
+      end
+      value
+    end
+  end
+
+end

data/lib/hammer_cli/output/adapter.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), 'adapter/abstract')
+require File.join(File.dirname(__FILE__), 'adapter/base')
+require File.join(File.dirname(__FILE__), 'adapter/table')
+require File.join(File.dirname(__FILE__), 'adapter/silent')
+
+

data/lib/hammer_cli/output/definition.rb

@@ -0,0 +1,17 @@
+module HammerCLI::Output
+
+  class Definition
+
+    attr_accessor :fields
+
+    def initialize
+      @fields = []
+    end
+
+    def append(fields)
+      @fields += fields
+    end
+
+  end
+
+end

data/lib/hammer_cli/output/dsl.rb

@@ -0,0 +1,56 @@
+module HammerCLI::Output
+
+  class Dsl
+
+    def initialize options={}
+      @current_path = options[:path] || []
+    end
+
+    def fields
+      @fields ||= []
+      @fields
+    end
+
+    def build &block
+      self.instance_eval &block
+    end
+
+    protected
+
+    def field key, label, type=nil, options={}, &block
+      options[:path] = current_path.clone << key
+      options[:label] = label
+      type ||= HammerCLI::Output::DataField
+      custom_field type, options, &block
+    end
+
+    def custom_field type, options={}, &block
+      self.fields << type.new(options, &block)
+    end
+
+    def label label, &block
+      options = {}
+      options[:path] = current_path.clone
+      options[:label] = label
+      custom_field HammerCLI::Output::Fields::Label, options, &block
+    end
+
+    def from key
+      self.current_path.push key
+      yield if block_given?
+      self.current_path.pop
+    end
+
+    def collection key, label, options={}, &block
+      field key, label,  HammerCLI::Output::Fields::Collection, options, &block
+    end
+
+
+    def current_path
+      @current_path ||= []
+      @current_path
+    end
+
+  end
+
+end