kontena-cli 1.0.6 → 1.1.0.pre1

data/lib/kontena/cli/vault_command.rb

@@ -1,8 +1,10 @@
-require_relative 'vault/write_command'
+require_relative 'vault/export_command'
+require_relative 'vault/import_command'
 require_relative 'vault/list_command'
 require_relative 'vault/read_command'
 require_relative 'vault/remove_command'
 require_relative 'vault/update_command'
+require_relative 'vault/write_command'
 
 class Kontena::Cli::VaultCommand < Kontena::Command
 
@@ -11,6 +13,8 @@ class Kontena::Cli::VaultCommand < Kontena::Command
   subcommand "read", "Read secret", Kontena::Cli::Vault::ReadCommand
   subcommand "update", "Update secret", Kontena::Cli::Vault::UpdateCommand
   subcommand ["remove", "rm"], "Remove secret", Kontena::Cli::Vault::RemoveCommand
+  subcommand "export", "Export secrets to STDOUT", Kontena::Cli::Vault::ExportCommand
+  subcommand "import", "Import secrets from a file or STDIN", Kontena::Cli::Vault::ImportCommand
 
   def execute
   end

data/lib/kontena/client.rb

@@ -23,6 +23,7 @@ module Kontena
     CONTENT_JSON       = 'application/json'.freeze
     JSON_REGEX         = /application\/(.+?\+)?json/.freeze
     CONTENT_TYPE       = 'Content-Type'.freeze
+    X_KONTENA_VERSION  = 'X-Kontena-Version'.freeze
     ACCEPT             = 'Accept'.freeze
     AUTHORIZATION      = 'Authorization'.freeze
 
@@ -46,7 +47,7 @@ module Kontena
       uri = URI.parse(@api_url)
       @host = uri.host
 
-      @logger = Logger.new(STDOUT)
+      @logger = Logger.new(ENV["DEBUG"] ? STDERR : STDOUT)
       @logger.level = ENV["DEBUG"].nil? ? Logger::INFO : Logger::DEBUG
       @logger.progname = 'CLIENT'
 
@@ -59,6 +60,10 @@ module Kontena
         write_timeout:   ENV["EXCON_WRITE_TIMEOUT"]   ? ENV["EXCON_WRITE_TIMEOUT"].to_i   : 5,
         ssl_verify_peer: ignore_ssl_errors? ? false : true
       }
+      if ENV["DEBUG"]
+        require_relative 'debug_instrumentor'
+        excon_opts[:instrumentor] = Kontena::DebugInstrumentor
+      end
 
       cert_file = File.join(Dir.home, "/.kontena/certs/#{uri.host}.pem")
       if File.exist?(cert_file) && File.readable?(cert_file)
@@ -135,7 +140,7 @@ module Kontena
       request(path: final_path)
       true
     rescue
-      ENV["DEBUG"] && puts("Authentication verification exception: #{$!} #{$!.message} #{$!.backtrace}")
+      logger.debug "Authentication verification exception: #{$!} #{$!.message} #{$!.backtrace}"
       false
     end
 
@@ -473,6 +478,8 @@ module Kontena
     # @param [Excon::Response]
     # @return [Hash,String]
     def parse_response(response)
+      check_version_and_warn(response.headers[X_KONTENA_VERSION])
+
       if response.headers[CONTENT_TYPE] =~ JSON_REGEX
         parse_json(response.body)
       else
@@ -480,6 +487,22 @@ module Kontena
       end
     end
 
+    def check_version_and_warn(server_version)
+      return nil if $VERSION_WARNING_ADDED
+      return nil unless server_version.to_s =~ /^\d+\.\d+\.\d+/
+
+      unless server_version[/^(\d+\.\d+)/, 1] == Kontena::Cli::VERSION[/^(\d+\.\d+)/, 1] # Just compare x.y
+        add_version_warning(server_version)
+        $VERSION_WARNING_ADDED = true
+      end
+    end
+
+    def add_version_warning(server_version)
+      at_exit do
+        warn Kontena.pastel.yellow("Warning: Server version is #{server_version}. You are using CLI version #{Kontena::Cli::VERSION}.")
+      end
+    end
+
     # Parse json
     #
     # @param [String] json

data/lib/kontena/command.rb

@@ -169,7 +169,7 @@ class Kontena::Command < Clamp::Command
   end
 
   def run(arguments)
-    ENV["DEBUG"] && puts("Running #{self} -- callback matcher = '#{self.class.callback_matcher.nil? ? "nil" : self.class.callback_matcher.map(&:to_s).join(' ')}'")
+    ENV["DEBUG"] && STDERR.puts("Running #{self} -- 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?

data/lib/kontena/debug_instrumentor.rb

@@ -0,0 +1,70 @@
+require 'uri'
+module Kontena
+  class DebugInstrumentor
+    def self.instrument(name, params = {}, &block)
+      result = []
+      params = params.dup
+
+      direction = name.split('.').last.capitalize
+
+      if direction == 'Request'
+        uri = URI.parse("#{params[:scheme]}://#{params[:host]}:#{params[:port]}")
+        uri.path = params[:path]
+        uri.query = URI.encode_www_form(params[:query]) if params[:query] && !params[:query].empty?
+        str = "#{params[:method].to_s.upcase} #{uri}"
+        str << " (ssl_verify: #{params[:ssl_verify_peer]}) " if params[:scheme] == 'https'
+        result << str
+      end
+
+      if params[:headers]
+        str = "Headers: {"
+        heads = []
+        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']
+        str << heads.join(', ')
+        str << "} "
+        result << str
+      end
+
+      if params[:status]
+        str = "Status: "
+        if params[:status] < 299
+          str << Kontena.pastel.green(params[:status])
+        else
+          str << Kontena.pastel.red(params[:status])
+        end
+        result << str
+      end
+
+      if params[:body] && !params[:body].empty?
+        str = "Body: "
+        if ENV["DEBUG"] == "api"
+          str << "\n"
+          str << params[:body]
+        else
+          body = params[:body].inspect.strip
+          str << body[0,80]
+          if body.length > 80
+            str << "...\""
+          end
+        end
+        result << str
+      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
+
+      if block_given?
+        yield
+      end
+    end
+  end
+end

data/lib/kontena/light_prompt.rb

@@ -0,0 +1,103 @@
+require 'tty-prompt'
+require 'pastel'
+
+module Kontena
+  class LightPrompt
+
+    attr_reader :prompt
+
+    extend Forwardable
+
+    class Menu
+      attr_reader :choices, :calls
+
+      def initialize
+        @choices = []
+        @calls = {}
+      end
+
+      def choice(text, label)
+        choices << [text, label]
+      end
+
+      def add_quit_choice
+        choice('(done)', :done)
+      end
+
+      def remove_choice(value)
+        choices.reject! { |c| c.last == value }
+      end
+
+      def remove_choices(values)
+        values.each { |v| remove_choice(v) }
+      end
+
+      def method_missing(meth, *args)
+        calls[meth] = args
+      end
+
+      def respond_to_missing?(meth, privates = false)
+        prompt.respond_to?(meth, privates)
+      end
+    end
+
+    def initialize(options={})
+      @prompt = TTY::Prompt.new(options)
+    end
+
+    def select(*args, &block)
+      choice_collector = Menu.new
+      yield choice_collector
+
+      prompt.enum_select(*args) do |menu|
+        choice_collector.calls.each do |meth, args|
+          if menu.respond_to?(meth)
+            menu.send(meth, *args)
+          end
+        end
+        choice_collector.choices.each do |choice|
+          menu.choice choice.first, choice.last
+        end
+      end
+    end
+
+    def multi_select(*args, &block)
+      choice_collector = Menu.new
+      yield choice_collector
+      choice_collector.add_quit_choice
+
+      selections = []
+
+      loop do
+        choice_collector.remove_choices(selections)
+
+        answer = prompt.enum_select(*args) do |menu|
+          choice_collector.calls.each do |meth, args|
+            if menu.respond_to?(meth)
+              menu.send(meth, *args)
+            end
+          end
+          choice_collector.choices.each do |choice|
+            menu.choice choice.first, choice.last
+          end
+        end
+
+        break if answer == :done
+        selections << answer
+      end
+
+      selections
+    end
+
+
+    def_delegators :prompt, :ask, :yes?, :error
+
+    def method_missing(meth, *args)
+      prompt.send(meth, *args)
+    end
+
+    def respond_to_missing?(meth, privates = false)
+      prompt.respond_to?(meth, privates)
+    end
+  end
+end

data/lib/kontena/plugin_manager.rb

@@ -2,27 +2,174 @@ require 'singleton'
 
 module Kontena
   class PluginManager
+
     include Singleton
 
     CLI_GEM = 'kontena-cli'.freeze
     MIN_CLI_VERSION = '0.15.99'.freeze
 
-    attr_reader :plugins
+    # Initialize plugin manager
+    def init
+      ENV["GEM_HOME"] = install_dir
+      Gem.paths = ENV
+      plugins
+      use_dummy_ui unless ENV["DEBUG"]
+      true
+    end
+
+    # Install a plugin
+    # @param plugin_name [String]
+    # @param pre [Boolean] install a prerelease version if available
+    # @param version [String] install a specific version
+    def install_plugin(plugin_name, pre: false, version: nil)
+      require 'rubygems/dependency_installer'
+      require 'rubygems/requirement'
+
+      cmd = Gem::DependencyInstaller.new(
+        document: false,
+        force: true,
+        prerelease: pre,
+        minimal_deps: true
+      )
+      plugin_version = version.nil? ? Gem::Requirement.default : Gem::Requirement.new(version)
+      without_safe { cmd.install(prefix(plugin_name), plugin_version) }
+      cleanup_plugin(plugin_name)
+      cmd.installed_gems
+    end
+
+    # Uninstall a plugin
+    # @param plugin_name [String]
+    def uninstall_plugin(plugin_name)
+      installed = installed(plugin_name)
+      raise "Plugin #{plugin_name} not installed" unless installed
+
+      require 'rubygems/uninstaller'
+      cmd = Gem::Uninstaller.new(
+        installed.name,
+        all: true,
+        executables: true,
+        force: true,
+        install_dir: installed.base_dir
+      )
+      cmd.uninstall
+    end
+
+    # Search rubygems for kontena plugins
+    # @param pattern [String] optional search pattern
+    def search_plugins(pattern = nil)
+      client = Excon.new('https://rubygems.org')
+      response = client.get(
+        path: "/api/v1/search.json?query=#{prefix(pattern)}",
+        headers: {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json'
+        }
+      )
+
+      JSON.parse(response.body) rescue nil
+    end
+
+    # Retrieve plugin versions from rubygems
+    # @param plugin_name [String]
+    def gem_versions(plugin_name)
+      client = Excon.new('https://rubygems.org')
+      response = client.get(
+        path: "/api/v1/versions/#{prefix(plugin_name)}.json",
+        headers: {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json'
+        }
+      )
+      versions = JSON.parse(response.body)
+      versions.map { |version| Gem::Version.new(version["number"]) }.sort.reverse
+    end
+
+    # Get the latest version number from rubygems
+    # @param plugin_name [String]
+    # @param pre [Boolean] include prerelease versions
+    def latest_version(plugin_name, pre: false)
+      return gem_versions(plugin_name).first if pre
+      gem_versions(plugin_name).find { |version| !version.prerelease? }
+    end
+
+    # Find a plugin by name from installed plugins
+    # @param plugin_name [String]
+    def installed(plugin_name)
+      search = prefix(plugin_name)
+      plugins.find {|plugin| plugin.name == search }
+    end
+
+    # Upgrade an installed plugin
+    # @param plugin_name [String]
+    # @param pre [Boolean] upgrade to a prerelease version if available. Will happen always when the installed version is a prerelease version.
+    def upgrade_plugin(plugin_name, pre: false)
+      installed = installed(plugin_name)
+      if installed.version.prerelease?
+        pre = true
+      end
+
+      if installed
+        latest = latest_version(plugin_name, pre: pre)
+        if latest > installed.version
+          install_plugin(plugin_name, version: latest.to_s)
+        end
+      else
+        raise "Plugin #{plugin_name} not installed"
+      end
+    end
+
+    # Runs gem cleanup, removes remains from previous versions
+    # @param plugin_name [String]
+    def cleanup_plugin(plugin_name)
+      require 'rubygems/commands/cleanup_command'
+      cmd = Gem::Commands::CleanupCommand.new
+      options = ['--norc']
+      options += ['-q', '--no-verbose'] unless ENV["DEBUG"]
+      cmd.handle_options options
+      without_safe { cmd.execute }
+    rescue Gem::SystemExitException => e
+      return true if e.exit_code == 0
+      raise
+    end
 
-    def initialize
-      @plugins = []
+    # Gem installation directory
+    # @return [String]
+    def install_dir
+      return @install_dir if @install_dir
+      install_dir = File.join(Dir.home, '.kontena', 'gems', RUBY_VERSION)
+      unless File.directory?(install_dir)
+        require 'fileutils'
+        FileUtils.mkdir_p(install_dir, mode: 0700)
+      end
+      @install_dir = install_dir
     end
 
+
     # @return [Array<Gem::Specification>]
+    def plugins
+      @plugins ||= load_plugins
+    end
+
+    private
+
+    # Execute block without SafeYAML. Gem does security internally.
+    def without_safe(&block)
+      SafeYAML::OPTIONS[:default_mode] = :unsafe if Object.const_defined?(:SafeYAML)
+      yield
+    ensure
+      SafeYAML::OPTIONS[:default_mode] = :safe if Object.const_defined?(:SafeYAML)
+    end
+
     def load_plugins
+      plugins = []
       Gem::Specification.to_a.each do |spec|
         spec.require_paths.to_a.each do |require_path|
           plugin = File.join(spec.gem_dir, require_path, 'kontena_cli_plugin.rb')
-          if File.exist?(plugin) && !@plugins.find{ |p| p.name == spec.name }
+          if File.exist?(plugin) && !plugins.find{ |p| p.name == spec.name }
             begin
               if spec_has_valid_dependency?(spec)
                 load(plugin)
-                @plugins << spec
+                plugins << spec
               else
                 plugin_name = spec.name.sub('kontena-plugin-', '')
                 STDERR.puts " [#{Kontena.pastel.red('error')}] Plugin #{Kontena.pastel.cyan(plugin_name)} (#{spec.version}) is not compatible with the current cli version."
@@ -39,11 +186,25 @@ module Kontena
           end
         end
       end
-      @plugins
+      plugins
     rescue => exc
       STDERR.puts exc.message
     end
 
+    def prefix(plugin_name)
+      return plugin_name if plugin_name.to_s.start_with?('kontena-plugin-')
+      "kontena-plugin-#{plugin_name}"
+    end
+
+    def dummy_ui
+      Gem::StreamUI.new(StringIO.new, StringIO.new, StringIO.new, false)
+    end
+
+    def use_dummy_ui
+      require 'rubygems/user_interaction'
+      Gem::DefaultUserInteraction.ui = dummy_ui
+    end
+
     # @param [Gem::Specification] spec
     # @return [Boolean]
     def spec_has_valid_dependency?(spec)