hammer_cli 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c28ad069fcd115c4b6f01ad2b5d0b2cdf8b3cbd
-  data.tar.gz: 2f9a543685a78f837bd1d1b657702c745c2ae0ba
+  metadata.gz: ef7854e6b8f65d3432b1f748a1bd300d4ab2274e
+  data.tar.gz: 09a8c5faa16658f072ebde9a0ca6493e0044dc8b
 SHA512:
-  metadata.gz: e641575e3077ce1a854ba6f6e7bfc96d9b03c634a56ee09dcb8d5d486db188aa2bd5f4e7856dcc4f30c08b9ab6630d73397e3a9726db833064d11fc8afdfeecb
-  data.tar.gz: 287e3b3f607305f302ff58d6c74c6cc871b46d627fd32e0392a2443a2f516561934344419ab9333f3083804a15996c4d9f4695b0eeb32357b8fb022416fdb2e3
+  metadata.gz: 398fa3c73cab657f5fa0afb2b9a255427fc7bcbca0a2d7488d74ddc1daca9b93bf237173ce644358529b26caffe0577abff3a9f03567343b565d23026009bbeb
+  data.tar.gz: 302c34a77aa5cffbf6bee3d2975e393c9ba5afdd08f9e820ae30e354010f5495ee2316acfb1fd9534489e2f5af1b5854fb7501c747aa30fb5acc8621e0645bb2

data/bin/hammer

@@ -31,6 +31,16 @@ class PreParser < Clamp::Command
   option ["--output"], "ADAPTER", "Set output format"
   option ["--csv-separator"], "SEPARATOR", "Character to separate the values"
   option ["--autocomplete"], "LINE", "Get list of possible endings"
+  option ["--verify-ssl"], "VERIFY_SSL", "Configure SSL verification of remote system" do |value|
+    bool_normalizer = HammerCLI::Options::Normalizers::Bool.new
+    bool_normalizer.format(value)
+  end
+  option ["--ssl-ca-file"], "CA_FILE", "Configure the file containing the CA certificates"
+  option ["--ssl-ca-path"], "CA_PATH", "Configure the directory containing the CA certificates"
+  option ["--ssl-client-cert"], "CERT_FILE", "Configure the client's public certificate"
+  option ["--ssl-client-key"], "KEY_FILE", "Configure the client's private key"
+  option ["--ssl-with-basic-auth"], :flag, "Use standard authentication in addition to client certificate authentication"
+  option ["--fetch-ca-cert"], "SERVER", "Fetch CA certificate from server and exit"
 end
 
 preparser = PreParser.new File.basename($0), {}
@@ -76,7 +86,13 @@ HammerCLI::Settings.load({
     :host => preparser.server,
     :interactive => preparser.interactive,
     :verbose => preparser.verbose? || preparser.debug?,
-    :reload_cache => preparser.reload_cache?
+    :reload_cache => preparser.reload_cache?,
+    :verify_ssl => preparser.verify_ssl,
+    :ssl_ca_file => preparser.ssl_ca_file,
+    :ssl_ca_path => preparser.ssl_ca_path,
+    :ssl_client_cert => preparser.ssl_client_cert,
+    :ssl_client_key => preparser.ssl_client_key,
+    :ssl_with_basic_auth => preparser.ssl_with_basic_auth?
   }})
 
 if HammerCLI::Settings.get(:ui, :mark_translated)
@@ -107,6 +123,11 @@ end
 # load hammer core
 require 'hammer_cli'
 
+if preparser.fetch_ca_cert
+  require 'hammer_cli/ca_cert_fetcher'
+  exit HammerCLI::CACertFetcher.fetch_ca_cert(preparser.fetch_ca_cert)
+end
+
 # load modules set in config
 begin
   HammerCLI::Modules.load_all

data/config/cli_config.template.yml

@@ -31,3 +31,23 @@
 # Log record pattern (logging gem syntax)
 #:log_pattern: '[%5l %d %c] %m'
 
+
+# SSL auth options
+#:ssl:
+  # Path to a ca file
+  #:ssl_ca_file: '/path/to/ca_certificate.pem'
+
+  # Path to a direcotry with ca file
+  #:ssl_ca_path: '/path/to/ca/'
+
+  # Turn SSL verification on/off
+  #:verify_ssl: true
+
+  # Path to a client certificate
+  #:ssl_client_cert: '/path/to/cert.crt'
+
+  # Path to a client key
+  #:ssl_client_key: '/path/to/cert.key'
+
+  # Enable standard authentication in addition to client certificate authentication
+  #:ssl_with_basic_auth: true

data/doc/release_notes.md

@@ -1,6 +1,13 @@
 Release notes
 =============
 
+### 0.10.0 (2017-03-28)
+* Defaults match on option switch name (#233) ([#17920](http://projects.theforeman.org/issues/17920))
+* Add support for client certificate authentication ([#12401](http://projects.theforeman.org/issues/12401))
+* Only include .mo files below locale/ ([#18439](http://projects.theforeman.org/issues/18439))
+* Hide label fields when the value is empty or nil ([#18446](http://projects.theforeman.org/issues/18446))
+* Replacement for table_print gem ([#17740](http://projects.theforeman.org/issues/17740))
+
 ### 0.9.0 (2016-12-15)
 * Double quotes in list type params ([#17180](http://projects.theforeman.org/issues/17180))
 * API connection moved to context ([PR #227](https://github.com/theforeman/hammer-cli/pull/227)) ([#8016](http://projects.theforeman.org/issues/8016))

data/lib/hammer_cli/abstract.rb

@@ -1,6 +1,9 @@
 require 'hammer_cli/exception_handler'
 require 'hammer_cli/logger_watch'
 require 'hammer_cli/options/option_definition'
+require 'hammer_cli/options/option_collector'
+require 'hammer_cli/options/sources/command_line'
+require 'hammer_cli/options/sources/saved_defaults'
 require 'hammer_cli/clamp'
 require 'hammer_cli/subcommand'
 require 'hammer_cli/options/matcher'
@@ -224,28 +227,22 @@ module HammerCLI
     end
 
     def all_options
-      @all_options ||= self.class.recognised_options.inject({}) do |hash, opt|
-        hash[opt.attribute_name] = send(opt.read_method)
-        hash[opt.attribute_name] = add_custom_defaults(opt.attribute_name) if hash[opt.attribute_name].nil?
-        hash
-      end
-      @all_options
+      option_collector.all_options
     end
 
     def options
-      all_options.reject {|key, value| value.nil? }
+      option_collector.options
     end
 
-    private
-
-    def add_custom_defaults(attr)
-      if context[:defaults]
-        value = context[:defaults].get_defaults(attr)
-        logger.info("Custom default value #{value} was used for attribute #{attr}") if value
-        value
-      end
+    def option_collector
+      @option_collector ||= HammerCLI::Options::OptionCollector.new(self.class.recognised_options, [
+        HammerCLI::Options::Sources::CommandLine.new(self),
+        HammerCLI::Options::Sources::SavedDefaults.new(context[:defaults], logger)
+      ])
     end
 
+    private
+
     def self.inherited_output_definition
       od = nil
       if superclass.respond_to? :output_definition

data/lib/hammer_cli/apipie/api_connection.rb

@@ -1,11 +1,13 @@
 require 'apipie_bindings'
+require 'hammer_cli/ssloptions'
+
 module HammerCLI::Apipie
   class ApiConnection < HammerCLI::AbstractConnector
     attr_reader :api
 
     def initialize(params, options = {})
       @logger = options[:logger]
-      @api = ApipieBindings::API.new(params)
+      @api = ApipieBindings::API.new(params, HammerCLI::SSLOptions.get_options)
       if options[:reload_cache]
         @api.clean_cache
         @logger.debug 'Apipie cache was cleared' unless @logger.nil?

data/lib/hammer_cli/ca_cert_fetcher.rb

@@ -0,0 +1,67 @@
+module HammerCLI
+  class CACertFetcher
+    def self.fetch_ca_cert(host)
+      CACertFetcher.new.fetch_ca_cert(host)
+    end
+
+    def fetch_ca_cert(host)
+      begin
+        uri = URI.parse(host)
+
+        hostname = uri.host
+        port = uri.port || 443
+
+        if hostname.nil?
+          $stderr.puts _("Couldn't parse URI '%s'.") % host
+          $stderr.puts scheme_error(uri)
+          return HammerCLI::EX_SOFTWARE
+        end
+
+        puts get_ca_cert(hostname, port)
+        return HammerCLI::EX_OK
+      rescue StandardError => e
+        msg = [_('Fetching the CA certificate failed:')]
+
+        if e.is_a?(OpenSSL::SSL::SSLError) && e.message.include?('unknown protocol')
+          msg << _('The service at the given URI does not accept SSL connections')
+          msg << scheme_error(uri) if uri.scheme == 'http'
+        else
+          msg << e.message
+        end
+        $stderr.puts msg.join("\n")
+        return HammerCLI::EX_SOFTWARE
+      end
+    end
+
+    protected
+
+    def scheme_error(uri)
+      _("Perhaps you meant to connect to '%s'?") % uri_to_https(uri)
+    end
+
+    def uri_to_https(uri)
+      https_uri = uri.to_s
+      if uri.scheme == 'http'
+        # Scheme is http, replace with https.
+        https_uri = https_uri.sub(/^http/, 'https')
+      elsif uri.scheme.nil? || !https_uri.match(/:\/\//)
+        # Scheme either wasn't recognized or host was parsed into scheme.
+        # That can happen when user enters '<host>:<port>' without scheme.
+        https_uri = "https://#{https_uri}"
+      end
+      https_uri
+    end
+
+    def get_ca_cert(hostname, port)
+      noverify_ssl_connection = OpenSSL::SSL::SSLSocket.new(TCPSocket.new(hostname, port), noverify_ssl_context)
+      noverify_ssl_connection.connect
+      noverify_ssl_connection.peer_cert_chain.last
+    end
+
+    def noverify_ssl_context
+      noverify_ssl_context = OpenSSL::SSL::SSLContext.new
+      noverify_ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      noverify_ssl_context
+    end
+  end
+end

data/lib/hammer_cli/defaults.rb

@@ -32,9 +32,9 @@ module HammerCLI
       create_default_file if defaults_settings.empty?
       update_defaults_file do |defaults|
         default_options.each do |key, value|
-          key = key.to_sym
+          key = switch_to_name(key).to_sym
           defaults.delete_if { |k,| defaults_match?(k, key) }
-          defaults[key] = (value ? {:value => value,} : {:provider => provider})
+          defaults[key] = (value ? {:value => value} : {:provider => provider})
         end
       end
     end
@@ -44,16 +44,16 @@ module HammerCLI
     end
 
     def get_defaults(opt)
-      option = opt
-      option = opt.gsub("option_",'') if opt.include? "option_"
       unless defaults_settings.nil?
-        option_key = defaults_settings[option.to_sym].nil? ? option.gsub('_','-').to_sym : option.to_sym
-        return nil if defaults_settings[option_key].nil?
+        option_key = normalize_option(opt)
+        settings_key = defaults_settings[option_key.to_sym].nil? ? option_key.gsub('_','-').to_sym : option_key.to_sym
 
-        if defaults_settings[option_key][:provider]
-          providers[defaults_settings[option_key][:provider]].get_defaults(option.to_sym)
+        return nil if defaults_settings[settings_key].nil?
+
+        if defaults_settings[settings_key][:provider]
+          providers[defaults_settings[settings_key][:provider]].get_defaults(option_key.to_sym)
         else
-          defaults_settings[option_key][:value]
+          defaults_settings[settings_key][:value]
         end
       end
     end
@@ -89,7 +89,15 @@ module HammerCLI
     private
 
     def defaults_match?(default_a, default_b)
-      default_a.to_s.gsub('-','_') == default_b.to_s.gsub('-','_')
+      normalize_option(default_a) == normalize_option(default_b)
+    end
+
+    def normalize_option(opt)
+      switch_to_name(opt).gsub(/^option_/,'').gsub('-','_')
+    end
+
+    def switch_to_name(opt)
+      opt.to_s.gsub(/^-[-]?/,'')
     end
   end
 

data/lib/hammer_cli/exception_handler.rb

@@ -16,6 +16,8 @@ module HammerCLI
         [Clamp::UsageError, :handle_usage_exception],
         [RestClient::ResourceNotFound, :handle_not_found],
         [RestClient::Unauthorized, :handle_unauthorized],
+        [RestClient::SSLCertificateNotVerified, :handle_ssl_cert_not_verified],
+        [OpenSSL::SSL::SSLError, :handle_ssl_error],
         [ApipieBindings::DocLoadingError, :handle_apipie_docloading_error],
         [ApipieBindings::MissingArgumentsError, :handle_apipie_missing_arguments_error],
         [HammerCLI::ModuleDisabledButRequired, :handle_generic_config_error]
@@ -88,12 +90,49 @@ module HammerCLI
       HammerCLI::EX_UNAUTHORIZED
     end
 
+    def rake_command
+      "rake apipie:cache"
+    end
+
+    def handle_ssl_error(e)
+      print_error(_("SSL error") + ": #{e.message}")
+      log_full_error(e)
+      HammerCLI::EX_CONFIG
+    end
+
+    def handle_ssl_cert_not_verified(e)
+      print_error(ssl_cert_message)
+      log_full_error(e)
+      HammerCLI::EX_CONFIG
+    end
+
+    def ssl_cert_instructions
+    end
+
+    def ssl_cert_message
+      message = _("SSL certificate verification failed")
+      message += "\n#{ssl_cert_instructions}" if ssl_cert_instructions
+      message
+    end
+
     def handle_apipie_docloading_error(e)
-      rake_command = "rake apipie:cache"
-      print_error _("Could not load the API description from the server") + "\n  - " +
-                  _("is the server down?") + "\n  - " +
-                  _("was '%s' run on the server when using apipie cache? (typical production settings)") % rake_command
-      log_full_error e
+      api_cache_instructions = "\n  - " +
+                               _("is the server down?") + "\n  - " +
+                               _("was '%s' run on the server when using apipie cache? (typical production settings)") % rake_command
+
+      message = _("Could not load the API description from the server") + ": "
+      if e.respond_to?(:original_error)
+        if e.original_error.is_a?(RestClient::SSLCertificateNotVerified)
+          message += ssl_cert_message + "\n\n"
+        else
+          message += "\n#{e.original_error.message}"
+          message += api_cache_instructions
+        end
+      else
+        message += api_cache_instructions
+      end
+      print_error(message)
+      log_full_error(e)
       HammerCLI::EX_CONFIG
     end
 

data/lib/hammer_cli/main.rb

@@ -16,6 +16,14 @@ module HammerCLI
       :context_target => :password
     option ["-s", "--server"], "SERVER", _("remote system address"),
       :context_target => :uri
+    option ["--verify-ssl"], "VERIFY_SSL", _("Configure SSL verification of remote system"),
+      :format => HammerCLI::Options::Normalizers::Bool.new
+    option ["--ssl-ca-file"], "CA_FILE", _("Configure the file containing the CA certificates")
+    option ["--ssl-ca-path"], "CA_PATH", _("Configure the directory containing the CA certificates")
+    option ["--ssl-client-cert"], "CERT_FILE", _("Configure the client's public certificate")
+    option ["--ssl-client-key"], "KEY_FILE", _("Configure the client's private key")
+    option ["--ssl-with-basic-auth"], :flag, _("Use standard authentication in addition to client certificate authentication")
+    option ["--fetch-ca-cert"], "SERVER", _("Fetch CA certificate from server and exit")
 
     option "--version", :flag, _("show version") do
       puts "hammer (%s)" % HammerCLI.version

data/lib/hammer_cli/options/option_collector.rb

@@ -0,0 +1,22 @@
+module HammerCLI
+  module Options
+    class OptionCollector
+      attr_accessor :option_sources
+
+      def initialize(recognised_options, option_sources)
+        @recognised_options = recognised_options
+        @option_sources = option_sources
+      end
+
+      def all_options
+        @all_options ||= @option_sources.inject({}) do |all_options, source|
+          source.get_options(@recognised_options, all_options)
+        end
+      end
+
+      def options
+        @options ||= all_options.reject {|key, value| value.nil? }
+      end
+    end
+  end
+end

data/lib/hammer_cli/options/sources/command_line.rb

@@ -0,0 +1,18 @@
+module HammerCLI
+  module Options
+    module Sources
+      class CommandLine
+        def initialize(command)
+          @command = command
+        end
+
+        def get_options(defined_options, result)
+          defined_options.each do |opt|
+            result[opt.attribute_name] ||= @command.send(opt.read_method)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/hammer_cli/options/sources/saved_defaults.rb

@@ -0,0 +1,31 @@
+module HammerCLI
+  module Options
+    module Sources
+      class SavedDefaults
+        def initialize(defaults, logger)
+          @defaults = defaults
+          @logger = logger
+        end
+
+        def get_options(defined_options, result)
+          defined_options.each do |opt|
+            result[opt.attribute_name] = add_custom_defaults(opt) if result[opt.attribute_name].nil?
+          end if @defaults
+          result
+        end
+
+        protected
+        def add_custom_defaults(opt)
+          opt.switches.each do |switch|
+            value = @defaults.get_defaults(switch)
+            if value
+              @logger.info("Custom default value #{value} was used for attribute #{switch}")
+              return value
+            end
+          end
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,5 @@
-require 'table_print'
 require File.join(File.dirname(__FILE__), 'wrapper_formatter')
-require 'hammer_cli/table_print/formatter'
-require 'hammer_cli/table_print/column'
+require 'hammer_cli/output/utils'
 
 module HammerCLI::Output::Adapter
 
@@ -10,6 +8,10 @@ module HammerCLI::Output::Adapter
     MAX_COLUMN_WIDTH = 80
     MIN_COLUMN_WIDTH = 5
 
+    HLINE = '-'
+    LINE_SEPARATOR = '-|-'
+    COLUMN_SEPARATOR = ' | '
+
     def tags
       [:screen, :flat]
     end
@@ -21,44 +23,32 @@ module HammerCLI::Output::Adapter
     def print_collection(all_fields, collection)
       fields = field_filter.filter(all_fields)
 
-      rows = collection.collect do |d|
-        row = {}
-        fields.each do |f|
-          row[label_for(f)] = WrapperFormatter.new(
-            @formatters.formatter_for_type(f.class), f.parameters).format(data_for_field(f, d) || "")
-        end
-        row
-      end
-
-      if rows.empty?
-        keys = fields.map { |f| [label_for(f), ''] }
-        rows = [Hash[keys]]
-        @header_only = true
-      end
+      formatted_collection = format_values(fields, collection)
+      # calculate hash of column widths (label -> width)
+      widths = calculate_widths(fields, formatted_collection)
 
-      options = fields.collect do |f|
-        { label_for(f) => {
-            :width => max_width_for(f)
-          }
-        }
+      header_bits = []
+      hline_bits = []
+      fields.map do |f|
+        header_bits << normalize_column(widths[f.label], f.label.upcase)
+        hline_bits << HLINE * widths[f.label]
       end
 
-      sort_order = fields.map { |f| f.label.upcase }
+      line = hline_bits.join(LINE_SEPARATOR)
 
-      printer = TablePrint::Printer.new(rows, options)
-      TablePrint::Config.max_width = MAX_COLUMN_WIDTH
-      TablePrint::Config.multibyte = true
+      puts line
+      puts header_bits.join(COLUMN_SEPARATOR)
+      puts line
 
-      output = sort_columns(printer.table_print, sort_order)
-      dashes = /\n([-|]+)\n/.match(output)
-
-      if @header_only
-        output = output.lines.first
+      formatted_collection.collect do |row|
+        row_bits = fields.map do |f|
+          normalize_column(widths[f.label], row[f.label] || "")
+        end
+        puts row_bits.join(COLUMN_SEPARATOR)
       end
 
-      puts dashes[1] if dashes
-      puts output
-      puts dashes[1] if dashes
+      # print closing line only when the table isn't empty
+      puts line unless formatted_collection.empty?
 
       if collection.meta.pagination_set? && collection.count < collection.meta.subtotal
         pages = (collection.meta.subtotal.to_f/collection.meta.per_page).ceil
@@ -68,73 +58,62 @@ module HammerCLI::Output::Adapter
 
     protected
 
-    def field_filter
-      filtered = [Fields::ContainerField]
-      filtered << Fields::Id unless @context[:show_ids]
-      HammerCLI::Output::FieldFilter.new(filtered)
-    end
-
-    private
-
-    def label_for(field)
-      width = width_for(field)
-      if width
-        "%-#{width}s" % field.label.to_s
+    def normalize_column(width, value)
+      value = value.to_s
+      padding = width - HammerCLI::Output::Utils.real_length(value)
+      if padding >= 0
+        value += (" " * padding)
       else
-        field.label.to_s
+        value, real_length = HammerCLI::Output::Utils.real_truncate(value, width-3)
+        value += '...'
+        value += ' ' if real_length < (width - 3)
       end
+      value
     end
 
-    def max_width_for(field)
-      width = width_for(field)
-      width ||= field.parameters[:max_width]
-      width = MIN_COLUMN_WIDTH if width && width < MIN_COLUMN_WIDTH
-      width
+    def format_values(fields, collection)
+      collection.collect do |d|
+        fields.inject({}) do |row, f|
+          formatter = WrapperFormatter.new(@formatters.formatter_for_type(f.class), f.parameters)
+          row.update(f.label => formatter.format(data_for_field(f, d) || "").to_s)
+        end
+      end
     end
 
-    def width_for(field)
-      width = field.parameters[:width]
-      width = MIN_COLUMN_WIDTH if width && width < MIN_COLUMN_WIDTH
-      width
+    def calculate_widths(fields, collection)
+      Hash[fields.map { |f| [f.label, calculate_column_width(f, collection)] }]
     end
 
+    def calculate_column_width(field, collection)
+      if field.parameters[:width]
+        return [field.parameters[:width], MIN_COLUMN_WIDTH].max
+      end
 
-    def sort_columns(output, sort_order)
-      return output if sort_order.length == 1 # don't sort one column
-      delimiter = ' | '
-      lines = output.split("\n")
-      out = []
-
-      headers = lines.first.split(delimiter).map(&:strip)
-
-      # create mapping table for column indexes
-      sort_map = []
-      sort_order.each { |c| sort_map << headers.index(c) }
-
-      lines.each do |line|
-        columns = line.split(delimiter)
-        if columns.length == 1 # dashes
-          columns = columns.first.split('-|-')
-          if columns.length == 1
-            out << columns.first
-          else # new style dashes
-            new_row = []
-            sort_map.each { |i| new_row << columns[i] }
-            out << new_row.join('-|-')
-          end
-        else
-          # reorder row
-          new_row = []
-          sort_map.each { |i| new_row << columns[i] }
-          out << new_row.join(delimiter)
-        end
+      width = HammerCLI::Output::Utils.real_length(field.label.to_s)
+      max_width = max_width_for(field)
+      collection.each do |item|
+        width = [HammerCLI::Output::Utils.real_length(item[field.label]), width].max
+        return max_width if width >= max_width
       end
+      width
+    end
 
-      out.join("\n")
+    def field_filter
+      filtered = [Fields::ContainerField]
+      filtered << Fields::Id unless @context[:show_ids]
+      HammerCLI::Output::FieldFilter.new(filtered)
     end
 
+    private
+
+    def max_width_for(field)
+      if field.parameters[:max_width]
+        [field.parameters[:max_width], MAX_COLUMN_WIDTH].min
+      else
+        MAX_COLUMN_WIDTH
+      end
+    end
   end
 
   HammerCLI::Output::Output.register_adapter(:table, Table)
-
 end

data/lib/hammer_cli/output/fields.rb

@@ -85,7 +85,7 @@ module Fields
     def display?(value)
       return true if not hide_blank?
 
-      fields.any? do |f|
+      !(value.nil? || value.empty?) && fields.any? do |f|
         f.display?(HammerCLI::Output::Adapter::Abstract.data_for_field(f, value))
       end
     end