kontena-cli 1.3.0.pre1 → 1.3.0.pre2

data/lib/kontena/command.rb

@@ -1,14 +1,15 @@
 require 'clamp'
 require 'kontena/cli/subcommand_loader'
-require 'kontena/cli/common'
 require 'kontena/util'
 require 'kontena/cli/bytes_helper'
 require 'kontena/cli/grid_options'
+require 'excon/errors'
 
 class Kontena::Command < Clamp::Command
 
   option ['-D', '--debug'], :flag, "Enable debug", environment_variable: 'DEBUG' do
     ENV['DEBUG'] ||= 'true'
+    Kontena.reset_logger
   end
 
   attr_accessor :arguments
@@ -182,7 +183,7 @@ class Kontena::Command < Clamp::Command
   end
 
   def run(arguments)
-    ENV["DEBUG"] && $stderr.puts("Running #{self} -- callback matcher = '#{self.class.callback_matcher.nil? ? "nil" : self.class.callback_matcher.map(&:to_s).join(' ')}'")
+    Kontena.logger.debug { "Running #{self.class.name} with #{arguments.inspect} -- callback matcher = '#{self.class.callback_matcher.nil? ? "nil" : self.class.callback_matcher.map(&:to_s).join(' ')}'" }
     @arguments = arguments
 
     run_callbacks :before_parse unless help_requested?
@@ -218,7 +219,8 @@ class Kontena::Command < Clamp::Command
     end
   rescue Kontena::Errors::StandardError => ex
     raise ex if ENV['DEBUG']
-    abort(" [#{Kontena.pastel.red('error')}] #{ex.class.name} : #{ex.message}")
+    Kontena.logger.error(ex)
+    abort(" [#{Kontena.pastel.red('error')}] #{ex.status} : #{ex.message}")
   rescue Errno::EPIPE
     # If user is piping the command outputs to some other command that might exit before CLI has outputted everything
     abort
@@ -226,7 +228,8 @@ class Kontena::Command < Clamp::Command
     raise
   rescue => ex
     raise ex if ENV['DEBUG']
-    abort(" [#{Kontena.pastel.red('error')}] #{ex.class.name} : #{ex.message}\n         Rerun the command with environment DEBUG=true set to get the full exception")
+    Kontena.logger.error(ex)
+    abort(" [#{Kontena.pastel.red('error')}] #{ex.class.name} : #{ex.message}\n         See #{Kontena.log_target} or run the command again with environment DEBUG=true set to see the full exception")
   end
 end
 

data/lib/kontena/debug_instrumentor.rb

@@ -22,6 +22,7 @@ module Kontena
         heads << "Accept: #{params[:headers]['Accept']}" if params[:headers]['Accept']
         heads << "Content-Type: #{params[:headers]['Content-Type']}" if params[:headers]['Content-Type']
         heads << "Authorization: #{params[:headers]['Authorization'].split(' ', 2).first}" if params[:headers]['Authorization']
+        heads << "X-Kontena-Version: #{params[:headers]['X-Kontena-Version']}" if params[:headers]['X-Kontena-Version']
         str << heads.join(', ')
         str << "} "
         result << str
@@ -50,17 +51,17 @@ module Kontena
           end
         end
         result << str
+      elsif params[:error]
+        result << params[:error]
       end
 
-      if $stderr.tty?
-        if direction == 'Request'
-          $stderr.puts(Kontena.pastel.blue("[API Client #{direction}]: #{result.join(" | ")}"))
-        else
-          $stderr.puts(Kontena.pastel.magenta("[API Client #{direction}]: #{result.join(" | ")}"))
-        end
-      else
-        $stderr.puts("[API Client #{direction}]: #{result.join(" | ")}")
-      end
+      color = case direction
+              when 'Request' then :blue
+              when 'Response' then :magenta
+              else :red
+              end
+
+      Kontena.logger.debug("CLIENT") { Kontena.pastel.send(color, "[#{direction}]: #{result.join(" | ")}") }
 
       if block_given?
         yield

data/lib/kontena/main_command.rb

@@ -1,9 +1,6 @@
 require 'kontena/command'
 
 class Kontena::MainCommand < Kontena::Command
-  include Kontena::Util
-  include Kontena::Cli::Common
-
   option ['-v', '--version'], :flag, "Output Kontena CLI version #{Kontena::Cli::VERSION}" do
     build_tags = [ 'ruby' + RUBY_VERSION ]
     build_tags << RUBY_PLATFORM
@@ -44,6 +41,7 @@ class Kontena::MainCommand < Kontena::Command
 
   def subcommand_missing(name)
     if known_plugin_subcommand?(name)
+      extend Kontena::Cli::Common
       exit_with_error "The '#{name}' plugin has not been installed. Use: kontena plugin install #{name}"
     else
       super(name)

data/lib/kontena/plugin_manager.rb

@@ -159,6 +159,10 @@ module Kontena
       SafeYAML::OPTIONS[:default_mode] = :safe if Object.const_defined?(:SafeYAML)
     end
 
+    def plugin_debug?
+      @plugin_debug ||= ENV['DEBUG'] == 'plugin'
+    end
+
     def load_plugins
       plugins = []
       Gem::Specification.to_a.each do |spec|
@@ -167,21 +171,25 @@ module Kontena
           if File.exist?(plugin) && !plugins.find{ |p| p.name == spec.name }
             begin
               if spec_has_valid_dependency?(spec)
+
                 loaded_features_before = $LOADED_FEATURES.dup
                 load_path_before = $LOAD_PATH.dup
 
-                ENV["DEBUG"] && $stderr.puts("Activating plugin #{spec.name}")
+                Kontena.logger.debug { "Activating plugin #{spec.name}" } if plugin_debug?
                 spec.activate
                 spec.activate_dependencies
 
-                ENV["DEBUG"] && $stderr.puts("Loading plugin #{spec.name}")
+                Kontena.logger.debug { "Loading plugin #{spec.name}" }
                 require(plugin)
+                Kontena.logger.debug { "Loaded plugin #{spec.name}" } if plugin_debug?
 
-                if ENV['DEBUG'] == 'plugin'
+                if plugin_debug?
                   added_features = ($LOADED_FEATURES - loaded_features_before).map {|feat| "- #{feat}"}
                   added_paths = ($LOAD_PATH - load_path_before).map {|feat| "- #{feat}"}
-                  $stderr.puts "Plugin manager loaded features for #{spec.name}: \n#{added_features.join("\n")}" unless added_features.empty?
-                  $stderr.puts "Plugin manager load paths added for #{spec.name}: \n#{added_paths.join("\n")}" unless added_paths.empty?
+                  Kontena.logger.debug { "Plugin manager loaded features for #{spec.name}:" } unless added_features.empty?
+                  added_features.each { |feat| Kontena.logger.debug { feat } }
+                  Kontena.logger.debug { "Plugin manager load paths added for #{spec.name}:" } unless added_paths.empty?
+                  added_paths.each { |path| Kontena.logger.debug { path } }
                 end
 
                 plugins << spec
@@ -192,7 +200,7 @@ module Kontena
               end
             rescue ScriptError, StandardError => ex
               warn " [#{Kontena.pastel.red('error')}] Failed to load plugin: #{spec.name}\n\tRerun the command with environment DEBUG=true set to get the full exception."
-              ENV['DEBUG'] && $stderr.puts("#{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}")
+              Kontena.logger.error(ex)
             end
           end
         end
@@ -200,7 +208,7 @@ module Kontena
       plugins
     rescue => ex
       $stderr.puts Kontena.pastel.red(ex.message)
-      ENV['DEBUG'] && $stderr.puts("#{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}")
+      Kontena.logger.error(ex)
     end
 
     def prefix(plugin_name)

data/lib/kontena/stacks_cache.rb

@@ -1,10 +1,6 @@
-require_relative 'stacks_client'
-require_relative 'cli/common'
-require_relative 'cli/stacks/common'
-require 'yaml'
-require 'uri'
-
 module Kontena
+  autoload :StacksClient, 'kontena/stacks_client'
+
   class StacksCache
     class CachedStack
 
@@ -12,6 +8,8 @@ module Kontena
       attr_accessor :version
 
       def initialize(stack, version = nil)
+        require "safe_yaml"
+        SafeYAML::OPTIONS[:default_mode] = :safe
         unless version
           stack, version = stack.split(':', 2)
         end
@@ -59,6 +57,8 @@ module Kontena
     end
 
     class RegistryClientFactory
+      require 'kontena/cli/common'
+      require 'kontena/cli/stacks/common'
       include Kontena::Cli::Common
       include Kontena::Cli::Stacks::Common
     end
@@ -69,7 +69,7 @@ module Kontena
       end
 
       def dputs(msg)
-        ENV["DEBUG"] && $stderr.puts(msg)
+        Kontena.logger.debug { msg }
       end
 
       def cache(stack, version = nil)

data/lib/kontena/stacks_client.rb

@@ -7,6 +7,19 @@ module Kontena
     ACCEPT_YAML = { 'Accept' => 'application/yaml' }
     CT_YAML     = { 'Content-Type' => 'application/yaml' }
 
+    def raise_unless_token
+      unless token && token['access_token']
+        raise Kontena::Errors::StandardError.new(401, "Stack registry write operations require authentication")
+      end
+    end
+
+    def raise_unless_read_token
+      return false unless options[:read_requires_token]
+      unless token && token['access_token']
+        raise Kontena::Errors::StandardError.new(401, "Stack registry requires authentication")
+      end
+    end
+
     def full_uri(stack_name, version = nil)
       URI.join(api_url, path_to(stack_name, version)).to_s
     end
@@ -16,29 +29,35 @@ module Kontena
     end
 
     def push(stack_name, version, data)
-      post('/stack/', data, {}, CT_YAML)
+      raise_unless_token
+      post('/stack/', data, {}, CT_YAML, true)
     end
 
     def show(stack_name, stack_version = nil)
-      get("#{path_to(stack_name, stack_version)}", {}, ACCEPT_JSON)
+      raise_unless_read_token
+      get("#{path_to(stack_name, stack_version)}", nil, ACCEPT_JSON, options[:read_requires_token])
     end
 
     def versions(stack_name)
-      get("#{path_to(stack_name, nil)}/versions", {}, ACCEPT_JSON)['versions']
+      raise_unless_read_token
+      get("#{path_to(stack_name, nil)}/versions", nil, ACCEPT_JSON, options[:read_requires_token])['versions']
     end
 
     def pull(stack_name, version = nil)
-      get(path_to(stack_name, version), {}, ACCEPT_YAML)
+      raise_unless_read_token
+      get(path_to(stack_name, version), nil, ACCEPT_YAML, options[:read_requires_token])
     rescue StandardError => ex
       ex.message << " : #{path_to(stack_name, version)}"
       raise ex, ex.message
     end
 
     def search(query)
-      get('/search', { q: query }, {}, ACCEPT_JSON)['stacks']
+      raise_unless_read_token
+      get('/search', { q: query }, ACCEPT_JSON, options[:read_requires_token])['stacks']
     end
 
     def destroy(stack_name, version = nil)
+      raise_unless_token
       delete(path_to(stack_name, version), {})
     end
   end

data/lib/kontena/util.rb

@@ -1,9 +1,33 @@
 module Kontena
   module Util
     def self.included(base)
-        base.extend(ClassMethods)
+      base.extend(ClassMethods)
     end
 
+    def symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.map { |k,v| [k.to_sym, symbolize_keys(v)] }.to_h
+      when Array
+        obj.map { |v| symbolize_keys(v) }
+      else
+        obj
+      end
+    end
+    module_function :symbolize_keys
+
+    def symbolize_keys!(obj)
+      case obj
+      when Hash
+        obj.keys.each { |k| obj[k.to_sym] = symbolize_keys!(obj.delete(k)) }
+      when Array
+        obj.map! { |v| symbolize_keys!(v) }
+      else
+      end
+      obj
+    end
+    module_function :symbolize_keys!
+
     # @param [String] cmd
     def which(cmd)
       exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
@@ -30,26 +54,30 @@ module Kontena
 
     def time_ago(time)
       now = Time.now.to_i
-      time = DateTime.parse(time).to_time.to_i
+      time = time.kind_of?(Integer) ? time : DateTime.parse(time).to_time.to_i
       diff = now - time
-      if diff > 60 * 60 * 24
-        "#{diff / 60 / 60 / 24} days"
-      elsif diff > 60 * 60
-        "#{diff / 60 / 60} hours"
-      elsif diff > 60
-        "#{diff / 60} minutes"
+      seconds_to_human(diff) + ' ago'
+    end
+
+    def time_until(seconds)
+      'in ' + seconds_to_human(seconds)
+    end
+
+    def seconds_to_human(seconds)
+      if seconds > 60 * 60 * 24
+        result = "#{seconds / 60 / 60 / 24} days"
+      elsif seconds > 60 * 60
+        result = "#{seconds / 60 / 60} hours"
+      elsif seconds > 60
+        result = "#{seconds / 60} minutes"
       else
-        "#{diff} seconds"
+        result = "#{seconds} seconds"
       end
+      result.start_with?('1 ') ? result[0..-2] : result
     end
 
     def longest_string_in_array(array)
-      longest = 0
-      array.each do |item|
-        longest = item.length if item.length > longest
-      end
-
-      longest
+      array.max_by(&:length).length
     end
 
     module_function(:which)

data/lib/kontena_cli.rb

@@ -1,4 +1,26 @@
+require 'logger'
+
+$KONTENA_START_TIME = Time.now.to_f
+at_exit do
+  Kontena.logger.debug { "Execution took #{(Time.now.to_f - $KONTENA_START_TIME).round(3)} seconds" }
+  Kontena.logger.debug { "#{$!.class.name}" + ($!.respond_to?(:status) ? " status #{$!.status}" : "") } if $!
+end
+
 module Kontena
+  module Cli
+    autoload :Config, 'kontena/cli/config'
+    autoload :Spinner, 'kontena/cli/spinner'
+    autoload :Common, 'kontena/cli/common'
+    autoload :TableGenerator, 'kontena/cli/table_generator'
+  end
+
+  autoload :Command, 'kontena/command'
+  autoload :Client, 'kontena/client'
+  autoload :StacksCache, 'kontena/stacks_cache'
+  autoload :PluginManager, 'kontena/plugin_manager'
+  autoload :MainCommand, 'kontena/main_command'
+  autoload :Errors, 'kontena/errors'
+
   # Run a kontena command like it was launched from the command line. Re-raises any exceptions,
   # except a SystemExit with status 0, which is considered a success.
   #
@@ -12,16 +34,17 @@ module Kontena
     else
       command = cmdline
     end
-    ENV["DEBUG"] && puts("Running Kontena.run(#{command.inspect}")
+    logger.debug { "Running Kontena.run(#{command.inspect}" }
     result = Kontena::MainCommand.new(File.basename(__FILE__)).run(command)
-    ENV["DEBUG"] && puts("Command completed, result: #{result.inspect} status: 0")
+    logger.debug { "Command completed, result: #{result.inspect} status: 0" }
     result
   rescue SystemExit => ex
-    ENV["DEBUG"] && $stderr.puts("Command caused SystemExit, result: #{result.inspect} status: #{ex.status}")
+    logger.debug { "Command caused SystemExit, status: #{ex.status}" }
     return true if ex.status.zero?
     raise ex
   rescue => ex
-    ENV["DEBUG"] && $stderr.puts("Command raised #{ex.class.name} with message: #{ex.message}\n#{ex.backtrace.join("\n  ")}")
+    logger.error { "Command #{cmdline.inspect} exception" }
+    logger.error { ex }
     raise ex
   end
 
@@ -37,6 +60,29 @@ module Kontena
     false
   end
 
+  def self.log_target
+    return @log_target if @log_target
+
+    @log_target = ENV['LOG_TARGET']
+
+    if ENV["DEBUG"]
+      @log_target ||= $stderr
+    elsif @log_target.nil?
+      @log_target = File.join(home, 'kontena.log')
+    end
+  end
+
+  def self.reset_logger
+    @log_target, @logger = nil
+  end
+
+  def self.home
+    return @home if @home
+    @home = File.join(Dir.home, '.kontena')
+    Dir.mkdir(@home, 0700) unless File.directory?(@home)
+    @home
+  end
+
   # @return [String] x.y
   def self.minor_version
     Kontena::Cli::VERSION.split('.')[0..1].join('.')
@@ -59,7 +105,9 @@ module Kontena
   end
 
   def self.pastel
-    @pastel ||= Pastel.new(enabled: !simple_terminal?)
+    return @pastel if @pastel
+    require 'pastel'
+    @pastel = Pastel.new(enabled: !simple_terminal?)
   end
 
   def self.prompt
@@ -96,6 +144,23 @@ module Kontena
       File.join(Kontena.root, 'lib/kontena/cli', *joinables)
     end
   end
+
+  def self.logger
+    return @logger if @logger
+    if log_target.respond_to?(:tty?) && log_target.tty?
+      logger = Logger.new(log_target)
+      require 'kontena/cli/log_formatters/compact'
+      logger.formatter = Kontena::Cli::LogFormatter::Compact.new
+    else
+      logger = Logger.new(log_target, 1, 1_048_576)
+      require 'kontena/cli/log_formatters/strip_color'
+      logger.formatter = Kontena::Cli::LogFormatter::StripColor.new
+    end
+    logger.level = ENV["DEBUG"] ? Logger::DEBUG : Logger::INFO
+    logger.progname = 'CLI'
+    @logger = logger
+  end
+
 end
 
 # Monkeypatching string to mimick 'colorize' gem
@@ -115,13 +180,5 @@ end
 
 require 'ruby_dig'
 require 'shellwords'
-require "safe_yaml"
-SafeYAML::OPTIONS[:default_mode] = :safe
 require 'kontena/cli/version'
-require 'kontena/cli/common'
-require 'kontena/command'
-require 'kontena/client'
-require 'kontena/stacks_cache'
-require 'kontena/plugin_manager'
-require 'kontena/main_command'
-require 'kontena/cli/spinner'
+Kontena.logger.debug { "Kontena CLI #{Kontena::Cli::VERSION} (ruby-#{RUBY_VERSION}+#{RUBY_PLATFORM})" }