kontena-cli 1.3.0.pre1 → 1.3.0.pre2

data/lib/kontena/cli/stacks/yaml/reader.rb

@@ -25,7 +25,8 @@ module Kontena::Cli::Stacks
       attr_reader :file, :raw_content, :errors, :notifications, :defaults, :values, :registry
 
       def initialize(file, skip_validation: false, skip_variables: false, variables: nil, values: nil, defaults: nil)
-        require 'yaml'
+        require "safe_yaml"
+        SafeYAML::OPTIONS[:default_mode] = :safe
         require_relative 'service_extender'
         require_relative 'validator_v3'
         require_relative 'opto'
@@ -165,7 +166,7 @@ module Kontena::Cli::Stacks
         template = Liquid::Template.parse(content)
 
         # Wrap nil values in LiquidNull to not have Liquid consider them as undefined
-        vars = Hash[vars.map {|key, value| [key, value.nil? ? LiquidNull.new : value]}]
+        vars = vars.map {|key, value| [key, value.nil? ? LiquidNull.new : value]}.to_h
 
         template.render!(vars, strict_variables: true, strict_filters: true)
       end

data/lib/kontena/cli/stacks/yaml/service_extender.rb

@@ -1,4 +1,3 @@
-require 'yaml'
 require_relative '../../../util'
 
 module Kontena::Cli::Stacks

data/lib/kontena/cli/stacks/yaml/validations.rb

@@ -51,7 +51,7 @@ module Kontena::Cli::Stacks::YAML
         'env_file' => optional(-> (value) { value.is_a?(String) || value.is_a?(Array) }),
         'instances' => optional('integer'),
         'links' => optional(-> (value) { value.is_a?(Array) || value.nil? }),
-        'ports' => optional('array'),
+        'ports' => optional(-> (value) { value.is_a?(Array) && value.all? { |v| v.is_a?(String) && v.match(/\A(\d+\.\d+\.\d+\.\d+)?:?(\d+)\:(\d+)\/?(\w+)?\z/) } }),
         'pid' => optional('string'),
         'privileged' => optional('boolean'),
         'user' => optional('string'),

data/lib/kontena/cli/table_generator.rb

@@ -0,0 +1,125 @@
+require 'tty-table'
+
+module Kontena
+  module Cli
+    class TableGenerator
+
+      attr_reader :data
+      attr_reader :fields
+      attr_reader :header
+      attr_reader :row_format_proc, :header_format_proc, :render_options, :render_mode
+
+      DEFAULT_HEADER_FORMAT_PROC = lambda { |header| header.to_s.capitalize }
+
+      module Helper
+        def self.included(base)
+          if base.respond_to?(:option)
+            base.option ['-q', '--quiet'], :flag, "Output the identifying column only"
+          end
+        end
+
+        def table_generator
+          Kontena::Cli::TableGenerator
+        end
+
+        def generate_table(array, fields = nil, &block)
+          fields ||= self.fields if self.respond_to?(:fields)
+          table_generator.new(
+            array,
+            fields,
+            row_format_proc: block_given? ? block.to_proc : nil,
+            header_format_proc: lambda { |item| pastel.blue(item.to_s.capitalize) },
+            render_options: self.respond_to?(:render_options) ? self.render_options : nil
+          ).render
+        end
+
+        def print_table(array, fields = nil, &block)
+          puts generate_table(array, fields, &block)
+        end
+      end
+
+      # @param data [Array<Hash>,Array<Array>] an array of hashes or arrays
+      # @param fields [Array] an array of field names found in the data hashes.
+      # @param fields [Hash] a hash of field_title => field_name_in_the_data_hash, for example 'Users' => 'user_count'
+      # @param fields [NilClass] try to auto detect fields (all fields!) from the data hashes
+      # @return [TTY::Table]
+      def initialize(data, fields = nil, row_format_proc: nil, header_format_proc: nil, render_options: nil)
+        @data = data
+        @render_options = render_options || { }
+        @render_mode = @render_options.delete(:mode) || :basic
+        @row_format_proc = row_format_proc
+        @header_format_proc = header_format_proc || DEFAULT_HEADER_FORMAT_PROC
+        @fields = parse_fields(fields)
+        @header = generate_header(fields || @fields)
+      end
+
+      def create_table(header, rows)
+        TTY::Table.new(
+          header: header,
+          rows: rows
+        )
+      end
+
+      def table
+        create_table(header, rows)
+      end
+
+      def render
+        if data.empty?
+          fields.map(&method(:format_header_item)).join('  ')
+        else
+          table.render(render_mode, render_options)
+        end
+      end
+
+      def format_row(row)
+        return row if row_format_proc.nil?
+        row_clone = row.dup
+        row_format_proc.call(row_clone)
+        row_clone
+      end
+
+      def format_header_item(field_name)
+        header_format_proc.call(field_name)
+      end
+
+      def rows
+        fields.empty? ? data.map { |row| format_row(row).map(&:values) } : data.map { |row| format_row(row).values_at(*fields) }
+      end
+
+      # Collect all the unique keys from the hashes if the data
+      # is an array of hashes.
+      def detect_fields
+        if data.first.respond_to?(:keys)
+          data.flat_map(&:keys).uniq
+        else
+          []
+        end
+      end
+
+      def parse_fields(fields)
+        if fields.nil? || fields.empty?
+          detect_fields
+        elsif fields.kind_of?(Hash)
+          fields.values
+        else
+          fields
+        end
+      end
+
+      def generate_header(fields)
+        if fields.kind_of?(Hash)
+          header = fields.keys
+        else
+          header = Array(fields)
+        end
+
+        if header.size < 2
+          nil
+        else
+          header.map { |head| format_header_item(head) }
+        end
+      end
+    end
+  end
+end

data/lib/kontena/cli/vault/export_command.rb

@@ -11,12 +11,15 @@ module Kontena::Cli::Vault
 
     def execute
       require 'shellwords'
+      require 'json'
+      require "safe_yaml"
+      SafeYAML::OPTIONS[:default_mode] = :safe
       meth = json? ? :to_json : :to_yaml
-      puts Hash[
-        *Kontena.run!(['vault', 'ls', '--return']).sort.flat_map do |secret|
+      puts(
+        Kontena.run!(['vault', 'ls', '--return']).sort.map do |secret|
           [secret, Kontena.run!(['vault', 'read', '--return', secret])]
-        end
-      ].send(meth)
+        end.to_h.send(meth)
+      )
     end
   end
 end

data/lib/kontena/cli/vault/import_command.rb

@@ -15,6 +15,9 @@ module Kontena::Cli::Vault
     requires_current_master
 
     def parsed_input
+      require "json"
+      require "safe_yaml"
+      SafeYAML::OPTIONS[:default_mode] = :safe
       json? ? JSON.load(input) : YAML.safe_load(input)
     end
 

data/lib/kontena/cli/vault/list_command.rb

@@ -1,24 +1,37 @@
 module Kontena::Cli::Vault
   class ListCommand < Kontena::Command
+    include Kontena::Util
     include Kontena::Cli::Common
     include Kontena::Cli::GridOptions
+    include Kontena::Cli::TableGenerator::Helper
 
     option '--return', :flag, "Return the keys", hidden: true
+    option ['--[no-]long', '-l'], :flag, "Show full dates", default: !$stdout.tty?
 
-    def execute
-      require_api_url
-      require_current_grid
+    requires_current_master
+    requires_current_master_token
+    requires_current_grid
 
-      token = require_token
-      result = client(token).get("grids/#{current_grid}/secrets")
+    def secrets
+      client.get("grids/#{current_grid}/secrets")['secrets'].sort_by { |s| s['name'] }
+    end
 
-      return result['secrets'].map { |s| s['name'] } if return?
+    def fields
+      return['name'] if quiet?
+      %w(name created_at updated_at)
+    end
 
-      column_width_paddings = '%-54s %-25.25s %-25.25s'
-      puts column_width_paddings % ['NAME', 'CREATED AT', 'UPDATED AT']
-      result['secrets'].sort_by { |s| s['name'] }.each do |secret|
-        puts column_width_paddings % [secret['name'], secret['created_at'], secret['updated_at']]
+    def execute
+      return secrets.map { |s| s['name'] } if return?
+      print_table(secrets) do |row|
+        next if quiet? || long?
+        row['updated_at'] = updated?(row) ? pastel.blue('never') : time_ago(row['updated_at'])
+        row['created_at'] = time_ago(row['created_at'])
       end
     end
+
+    def updated?(row)
+      row['created_at'] == row['updated_at']
+    end
   end
 end

data/lib/kontena/cli/volumes/create_command.rb

@@ -4,13 +4,17 @@ module Kontena::Cli::Volumes
     include Kontena::Cli::Common
     include Kontena::Cli::GridOptions
 
-
     banner "Creates a volume"
     parameter 'NAME', 'Volume name'
 
-    option '--driver', 'DRIVER', 'Volume driver to be used'
+    SCOPES = %w(grid stack instance)
+
+    option '--driver', 'DRIVER', 'Volume driver to be used', required: true
     option '--driver-opt', 'DRIVER_OPT', 'Volume driver options', multivalued: true
-    option '--scope', 'SCOPE', 'Volume scope'
+    option '--scope', 'SCOPE', "Volume scope (#{SCOPES.join(',')})", required: true do |scope|
+      exit_with_error "Unknown scope '#{scope}, must be one of #{SCOPES.join(',')}" unless SCOPES.include?(scope)
+      scope
+    end
 
     requires_current_master
     requires_current_master_token
@@ -28,7 +32,7 @@ module Kontena::Cli::Volumes
     end
 
     def parse_driver_opts
-      Hash[driver_opt_list.map{|opt| opt.split '='}]
+      driver_opt_list.map{|opt| opt.split '='}.to_h
     end
 
     def create_volume(volume)

data/lib/kontena/cli/volumes/list_command.rb

@@ -1,21 +1,29 @@
 
 module Kontena::Cli::Volumes
   class ListCommand < Kontena::Command
+    include Kontena::Util
     include Kontena::Cli::Common
     include Kontena::Cli::GridOptions
+    include Kontena::Cli::TableGenerator::Helper
 
+    option ['--[no-]long', '-l'], :flag, "Show full dates", default: !$stdout.tty?
 
     requires_current_master
     requires_current_master_token
 
+    def volumes
+      client.get("volumes/#{current_grid}")['volumes']
+    end
+
+    def fields
+      quiet? ? ['id'] : %w(name scope driver created_at)
+    end
+
     def execute
-      require 'tty-table'
-      
-      volumes = client.get("volumes/#{current_grid}")['volumes']
-      table = TTY::Table.new ['NAME', 'SCOPE', 'DRIVER', 'CREATED AT'], volumes.map { |volume|
-        [volume['name'], volume['scope'], volume['driver'], volume['created_at']]
-      }
-      puts table.render(:basic)
+      print_table(volumes) do |row|
+        next if long? || quiet?
+        row['created_at'] = time_ago(row['created_at'])
+      end
     end
 
   end

data/lib/kontena/client.rb

@@ -1,15 +1,3 @@
-require 'json'
-require 'excon'
-require 'uri'
-require 'base64'
-require 'socket'
-require 'openssl'
-require 'uri'
-require 'time'
-require 'kontena/errors'
-require 'kontena/cli/version'
-require 'kontena/cli/config'
-
 module Kontena
   class Client
 
@@ -40,13 +28,23 @@ module Kontena
     # @param [Kontena::Cli::Config::Token,Hash] access_token
     # @param [Hash] options
     def initialize(api_url, token = nil, options = {})
+      require 'json'
+      require 'excon'
+      require 'uri'
+      require 'base64'
+      require 'socket'
+      require 'openssl'
+      require 'uri'
+      require 'time'
+      require 'kontena/errors'
+      require 'kontena/cli/version'
+      require 'kontena/cli/config'
+
       @api_url, @token, @options = api_url, token, options
       uri = URI.parse(@api_url)
       @host = uri.host
 
-      @logger = Logger.new(ENV["DEBUG"] ? $stderr : $stdout)
-      @logger.level = ENV["DEBUG"].nil? ? Logger::INFO : Logger::DEBUG
-      @logger.progname = 'CLIENT'
+      @logger = Kontena.logger
 
       @options[:default_headers] ||= {}
 
@@ -67,12 +65,12 @@ module Kontena
         excon_opts[:ssl_ca_file] = cert_file
         key = OpenSSL::X509::Certificate.new(File.read(cert_file))
         if key.issuer.to_s == "/C=FI/O=Test/OU=Test/CN=Test"
-          logger.debug "Key looks like a self-signed cert made by Kontena CLI, setting verify_peer_host to 'Test'"
+          debug { "Key looks like a self-signed cert made by Kontena CLI, setting verify_peer_host to 'Test'" }
           excon_opts[:ssl_verify_peer_host] = 'Test'
         end
       end
 
-      logger.debug "Excon opts: #{excon_opts.inspect}"
+      debug { "Excon opts: #{excon_opts.inspect}" }
 
       @http_client = Excon.new(api_url, excon_opts)
 
@@ -88,13 +86,20 @@ module Kontena
         else
           @token = token
         end
-        @default_headers.merge!('Authorization' => "Bearer #{@token['access_token']}")
       end
 
       @api_url = api_url
       @path_prefix = options[:prefix] || '/v1/'
     end
 
+    def debug(&block)
+      logger.debug("CLIENT", &block)
+    end
+
+    def error(&block)
+      logger.error("CLIENT", &block)
+    end
+
     # Generates a header hash for HTTP basic authentication.
     # Defaults to using client_id and client_secret as user/pass
     #
@@ -133,11 +138,12 @@ module Kontena
       return false unless token_verify_path
 
       final_path = token_verify_path.gsub(/\:access\_token/, token['access_token'])
-      logger.debug "Requesting user info from #{final_path}"
+      debug { "Requesting user info from #{final_path}" }
       request(path: final_path)
       true
     rescue => ex
-      logger.debug "Authentication verification exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
+      error { "Authentication verification exception" }
+      error { ex }
       false
     end
 
@@ -170,7 +176,8 @@ module Kontena
     def server_version
       request(auth: false, expects: 200)['version']
     rescue => ex
-      logger.debug "Server version exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
+      error { "Server version exception" }
+      error { ex }
       nil
     end
 
@@ -328,7 +335,7 @@ module Kontena
       parse_response(@last_response)
     rescue Excon::Errors::Unauthorized
       if token
-        logger.debug 'Server reports access token expired'
+        debug { 'Server reports access token expired' }
 
         if retried || !token || !token['refresh_token']
           raise Kontena::Errors::StandardError.new(401, 'The access token has expired and needs to be refreshed')
@@ -339,7 +346,7 @@ module Kontena
       end
       raise Kontena::Errors::StandardError.new(401, 'Unauthorized')
     rescue Excon::Errors::HTTPStatusError => error
-      logger.debug "Request #{error.request[:method].upcase} #{error.request[:path]}: #{error.response.status} #{error.response.reason_phrase}: #{error.response.body}"
+      debug { "Request #{error.request[:method].upcase} #{error.request[:path]}: #{error.response.status} #{error.response.reason_phrase}: #{error.response.body}" }
 
       handle_error_response(error.response)
     end
@@ -367,7 +374,8 @@ module Kontena
         {}
       end
     rescue => ex
-      logger.debug "Access token refresh exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
+      error { "Access token refresh exception" }
+      error { ex }
       false
     end
 
@@ -378,7 +386,7 @@ module Kontena
     # @param [Boolean] use_basic_auth? When true, use basic auth authentication header
     # @return [Boolean] success?
     def refresh_token
-      logger.debug "Performing token refresh"
+      debug { "Performing token refresh" }
       return false if token.nil?
       return false if token['refresh_token'].nil?
       uri = URI.parse(token_account['token_endpoint'])
@@ -386,7 +394,7 @@ module Kontena
       endpoint_data[:host] = uri.host if uri.host
       endpoint_data[:port] = uri.port if uri.port
 
-      logger.debug "Token refresh endpoint: #{endpoint_data.inspect}"
+      debug { "Token refresh endpoint: #{endpoint_data.inspect}" }
 
       return false unless endpoint_data[:path]
 
@@ -405,18 +413,19 @@ module Kontena
       )
 
       if response && response['access_token']
-        logger.debug "Got response to refresh request"
+        debug { "Got response to refresh request" }
         token['access_token']  = response['access_token']
         token['refresh_token'] = response['refresh_token']
         token['expires_at'] = in_to_at(response['expires_in'])
         token.config.write if token.respond_to?(:config)
         true
       else
-        logger.debug "Got null or bad response to refresh request: #{last_response.inspect}"
+        debug { "Got null or bad response to refresh request: #{last_response.inspect}" }
         false
       end
     rescue => ex
-      logger.debug "Access token refresh exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
+      error { "Access token refresh exception" }
+      error { ex }
       false
     end
 
@@ -507,7 +516,7 @@ module Kontena
     def parse_json(json)
       JSON.parse(json)
     rescue => ex
-      logger.debug "JSON parse exception: #{ex.class.name} : #{ex.message}"
+      debug { "JSON parse exception: #{ex.class.name} : #{ex.message}" }
       nil
     end
 
@@ -528,14 +537,16 @@ module Kontena
     def handle_error_response(response)
       data = parse_response(response)
 
+      request_path = " (#{response.path})"
+
       if data.is_a?(Hash) && data.has_key?('error') && data['error'].is_a?(Hash)
         raise Kontena::Errors::StandardErrorHash.new(response.status, response.reason_phrase, data['error'])
       elsif data.is_a?(Hash) && data.has_key?('error')
-        raise Kontena::Errors::StandardError.new(response.status, data['error'])
+        raise Kontena::Errors::StandardError.new(response.status, data['error'] + request_path)
       elsif data.is_a?(String) && !data.empty?
-        raise Kontena::Errors::StandardError.new(response.status, data)
+        raise Kontena::Errors::StandardError.new(response.status, data + request_path)
       else
-        raise Kontena::Errors::StandardError.new(response.status, response.reason_phrase)
+        raise Kontena::Errors::StandardError.new(response.status, response.reason_phrase + request_path)
       end
     end