kontena-cli 1.4.0.pre6 → 1.4.0.pre7

data/lib/kontena/plugin_manager/cleaner.rb

@@ -0,0 +1,33 @@
+require 'kontena/plugin_manager/common'
+require 'rubygems/commands/cleanup_command'
+
+module Kontena
+  module PluginManager
+    class Cleaner
+      include Common
+
+      attr_reader :plugin_name
+
+      def initialize(plugin_name)
+        @plugin_name = plugin_name
+      end
+
+      def command
+        @command ||= Gem::Commands::CleanupCommand.new
+      end
+
+      # Runs gem cleanup, removes remains from previous versions
+      # @param plugin_name [String]
+      def cleanup
+        options = []
+        options += ['-q', '--no-verbose'] unless ENV["DEBUG"]
+        command.handle_options options
+        command.execute
+        true
+      rescue Gem::SystemExitException => e
+        raise unless e.exit_code.zero?
+        true
+      end
+    end
+  end
+end

data/lib/kontena/plugin_manager/common.rb

@@ -0,0 +1,86 @@
+require 'kontena/plugin_manager'
+
+module Kontena
+  module PluginManager
+    module Common
+      Gem.autoload :DefaultUserInteraction, 'rubygems/user_interaction'
+      Gem.autoload :StreamUI, 'rubygems/user_interaction'
+
+      # @return [Boolean] is the CLI in plugin debugging mode?
+      def plugin_debug?
+        @plugin_debug ||= ENV['DEBUG'] == 'plugin'
+      end
+      module_function :plugin_debug?
+
+      # @return [Gem::StreamUI] a rubygems user interaction module with minimal output
+      def dummy_ui
+        Gem::StreamUI.new(StringIO.new, StringIO.new, StringIO.new, false)
+      end
+      module_function :dummy_ui
+
+      # Tell rubygems to use the dummy ui as default user interaction
+      def use_dummy_ui
+        Gem::DefaultUserInteraction.ui = dummy_ui
+      end
+      module_function :use_dummy_ui
+
+      # Prefix a plugin name into a gem name (hello to kontena-plugin-hello)
+      def prefix(plugin_name)
+        return plugin_name if plugin_name.to_s.start_with?('kontena-plugin-')
+        "kontena-plugin-#{plugin_name}"
+      end
+      module_function :prefix
+
+      # 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
+      module_function :installed
+
+      def installed?(plugin_name)
+        !installed(plugin_name).nil?
+      end
+      module_function :installed?
+
+      # 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
+      module_function :install_dir
+
+      # @return [Kontena::PluginManager::RubygemsClient]
+      def rubygems_client
+        @rubygems_client ||= Kontena::PluginManager::RubygemsClient.new
+      end
+      module_function :rubygems_client
+
+      # Search rubygems for kontena plugins
+      # @param pattern [String] optional search pattern
+      def search_plugins(pattern = nil)
+        rubygems_client.search(prefix(pattern))
+      end
+      module_function :search_plugins
+
+      # Retrieve plugin versions from rubygems
+      # @param plugin_name [String]
+      def gem_versions(plugin_name)
+        rubygems_client.versions(prefix(plugin_name))
+      end
+      module_function :gem_versions
+
+      def plugins
+        Kontena::PluginManager.plugins
+      end
+      module_function :plugins
+    end
+  end
+end

data/lib/kontena/plugin_manager/installer.rb

@@ -0,0 +1,54 @@
+require 'kontena/plugin_manager/common'
+require 'rubygems/dependency_installer'
+require 'rubygems/requirement'
+
+module Kontena
+  module PluginManager
+    class Installer
+      include Common
+
+      attr_reader :plugin_name, :pre, :version
+
+      # Create a new instance of plugin installer
+      # @param plugin_name [String]
+      # @param pre [Boolean] install a prerelease version if available
+      # @param version [String] install a specific version
+      def initialize(plugin_name, pre: false, version: nil)
+        @plugin_name = plugin_name
+        @pre = pre
+        @version = version
+      end
+
+      def command
+        @command ||= Gem::DependencyInstaller.new(
+          document: false,
+          force: true,
+          prerelease: pre,
+          minimal_deps: true
+        )
+      end
+
+      # Install a plugin
+      def install
+        plugin_version = version.nil? ? Gem::Requirement.default : Gem::Requirement.new(version)
+        command.install(prefix(plugin_name), plugin_version)
+        command.installed_gems
+      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
+        return install if version
+        installed = installed(plugin_name)
+        pre = installed.version.prerelease?
+
+        raise "Plugin #{plugin_name} not installed" unless installed
+        latest = rubygems_client.latest_version(prefix(plugin_name), pre: pre)
+        if latest > installed.version
+          Installer.new(plugin_name, version: latest.to_s).install
+        end
+      end
+    end
+  end
+end

data/lib/kontena/plugin_manager/loader.rb

@@ -0,0 +1,93 @@
+require 'kontena_cli'
+require 'kontena/plugin_manager/common'
+
+module Kontena
+  module PluginManager
+    class Loader
+      include Common
+
+      CLI_GEM = 'kontena-cli'.freeze
+      MIN_CLI_VERSION = '0.15.99'.freeze
+
+      def loaded_plugins
+        @loaded_plugins ||= []
+      end
+
+      def load_plugins
+        Gem::Specification.to_a.each do |spec|
+          plugin_path = plugin_require_path(spec)
+          next unless plugin_path
+          next if loaded_plugins.find { |p| p.name == spec.name }
+          load_plugin(plugin_path, spec)
+        end
+        loaded_plugins
+      end
+
+      private
+
+      def load_plugin(path, spec)
+        unless spec_has_valid_dependency?(spec)
+          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."
+          $stderr.puts "         To update the plugin, run 'kontena plugin install #{plugin_name}'"
+          return false
+        end
+
+        start_tracking
+        activate(spec)
+
+        Kontena.logger.debug { "Loading plugin #{spec.name} from #{path}" }
+        require(path)
+        Kontena.logger.debug { "Loaded plugin #{spec.name}" } if plugin_debug?
+
+        report_tracking
+        true
+      rescue ScriptError, LoadError, StandardError => ex
+        warn " [#{Kontena.pastel.red('error')}] Failed to load plugin: #{spec.name} from #{spec.gem_dir}\n\tRerun the command with environment DEBUG=true set to get the full exception."
+        Kontena.logger.error(ex)
+        spec.description = spec.description + Kontena.pastel.red(" (broken)")
+        false
+      ensure
+        loaded_plugins << spec
+      end
+
+      def activate(spec)
+        Kontena.logger.debug { "Activating plugin #{spec.name}" } if plugin_debug?
+        spec.activate
+        spec.activate_dependencies
+      end
+
+      # @param [Gem::Specification] spec
+      # @return [Boolean]
+      def spec_has_valid_dependency?(spec)
+        kontena_cli = spec.runtime_dependencies.find{ |d| d.name == CLI_GEM }
+        !kontena_cli.match?(CLI_GEM, MIN_CLI_VERSION)
+      rescue
+        false
+      end
+
+      def plugin_require_path(spec)
+        paths = spec.require_paths.to_a.map do |require_path|
+          File.join(spec.gem_dir, require_path, 'kontena_cli_plugin.rb')
+        end
+        paths.find { |path| File.exist?(path) }
+      end
+
+      def start_tracking
+        return unless plugin_debug?
+        @loaded_features_before = $LOADED_FEATURES.dup
+        @load_path_before = $LOAD_PATH.dup
+      end
+
+      def report_tracking
+        return unless plugin_debug?
+        added_features = ($LOADED_FEATURES - @loaded_features_before).map {|feat| "- #{feat}"}
+        added_paths = ($LOAD_PATH - @load_path_before).map {|feat| "- #{feat}"}
+        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
+    end
+  end
+end

data/lib/kontena/plugin_manager/rubygems_client.rb

@@ -1,40 +1,59 @@
-require 'excon'
+require 'kontena_cli'
 require 'json'
+require 'uri'
+require 'net/https'
 
 module Kontena
-  class PluginManager
+  module PluginManager
     class RubygemsClient
 
-      RUBYGEMS_URL = 'https://rubygems.org'
-      HEADERS = {
-        'Content-Type' => 'application/json',
-        'Accept' => 'application/json'
-      }
+      JSON_MIME  ='application/json'.freeze
+      ACCEPT = 'Accept'.freeze
+      HTTPOK = "200".freeze
 
-      attr_reader :client
+      def search(pattern = nil)
+        get('/api/v1/search.json', query: pattern)
+      end
 
-      def initialize
-        @client = Excon.new(RUBYGEMS_URL)
+      def versions(gem_name)
+        response = get("/api/v1/versions/#{gem_name}.json")
+        response.map { |version| Gem::Version.new(version["number"]) }.sort.reverse
       end
 
-      def search(pattern = nil)
-        response = client.get(
-          path: "/api/v1/search.json?query=#{pattern}",
-          headers: HEADERS
-        )
+      # Get the latest version number from rubygems
+      # @param plugin_name [String]
+      # @param pre [Boolean] include prerelease versions
+      def latest_version(gem_name, pre: false)
+        return versions(gem_name).first if pre
+        versions(gem_name).find { |version| !version.prerelease? }
+      end
 
-        JSON.parse(response.body)
+      def client
+        return @client if @client
+        @client = Net::HTTP.new('rubygems.org', 443)
+        @client.use_ssl = true
+        @client
       end
 
-      def versions(gem_name)
-        response = client.get(
-          path: "/api/v1/versions/#{gem_name}.json",
-          headers: HEADERS
-        )
-        versions = JSON.parse(response.body)
-        versions.map { |version| Gem::Version.new(version["number"]) }.sort.reverse
+      def request_path(path, query = nil)
+        uri = URI(path)
+        uri.query = URI.encode_www_form(query) if query
+        uri.to_s
+      end
+
+      def get_request(path)
+        request = Net::HTTP::Get.new(path)
+        request[ACCEPT] = JSON_MIME
+        request
       end
 
+      def get(path, query = nil)
+        Kontena.logger.debug { "Requesting GET #{path}" }
+        response = client.request(get_request(request_path(path, query)))
+        Kontena.logger.debug { "Response #{response.code}" }
+        raise "Server responded with #{response.code} (#{response.class.name})" unless response.code == HTTPOK
+        JSON.parse(response.body)
+      end
     end
   end
 end

data/lib/kontena/plugin_manager/uninstaller.rb

@@ -0,0 +1,34 @@
+require 'rubygems/uninstaller'
+
+module Kontena
+  module PluginManager
+    class Uninstaller
+      include PluginManager::Common
+
+      attr_reader :plugin_name
+
+      def initialize(plugin_name)
+        @plugin_name = plugin_name
+      end
+
+      def command(spec)
+        @command ||= Gem::Uninstaller.new(
+          spec.name,
+          all: true,
+          executables: true,
+          force: true,
+          install_dir: spec.base_dir
+        )
+      end
+
+      # Uninstall a plugin
+      # @param plugin_name [String]
+      def uninstall
+        installed = installed(plugin_name)
+        raise "Plugin #{plugin_name} not installed" unless installed
+
+        command(installed).uninstall
+      end
+    end
+  end
+end

data/lib/kontena/util.rb

@@ -28,6 +28,30 @@ module Kontena
     end
     module_function :symbolize_keys!
 
+    def stringify_keys(obj)
+      case obj
+      when Hash
+        obj.map { |k,v| [k.to_s, stringify_keys(v)] }.to_h
+      when Array
+        obj.map { |v| stringify_keys(v) }
+      else
+        obj
+      end
+    end
+    module_function :stringify_keys
+
+    def stringify_keys!(obj)
+      case obj
+      when Hash
+        obj.keys.each { |k| obj[k.to_s] = stringify_keys!(obj.delete(k)) }
+      when Array
+        obj.map! { |v| stringify_keys!(v) }
+      else
+      end
+      obj
+    end
+    module_function :stringify_keys!
+
     # @param [String] cmd
     def which(cmd)
       exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']

data/lib/kontena_cli.rb

@@ -21,6 +21,7 @@ module Kontena
   autoload :PluginManager, 'kontena/plugin_manager'
   autoload :MainCommand, 'kontena/main_command'
   autoload :Errors, 'kontena/errors'
+  autoload :Util, 'kontena/util'
 
   # 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.

data/omnibus/config/projects/kontena.rb

@@ -5,7 +5,9 @@
 #
 
 name "kontena"
+package_name "kontena-cli"
 friendly_name "Kontena CLI"
+description "Command-line tool for the Kontena Platform"
 maintainer "Kontena, Inc."
 homepage "https://kontena.io"
 
@@ -20,7 +22,7 @@ build_iteration 1
 dependency "preparation"
 
 # kontena dependencies/components
-dependency "kontena"
+dependency "kontena-cli"
 
 # Version manifest file
 dependency "version-manifest"
@@ -32,3 +34,7 @@ package :pkg do
   identifier "io.kontena.cli.pkg.kontena"
   signing_identity "Developer ID Installer: Kontena Oy (JJ22T2W355)"
 end
+
+package :deb do
+  vendor "Kontena, Inc <info@kontena.io>"
+end