krates 1.6.0

data/lib/kontena/machine/random_name.rb

@@ -0,0 +1,42 @@
+module Kontena
+  module Machine
+    module RandomName
+
+      def generate_name
+        rnd1 = Random.rand(64)
+        rnd2 = Random.rand(64)
+        "#{adjectives[rnd1%adjectives.length]}-#{nouns[rnd2%adjectives.length]}"
+      end
+
+      private
+
+      def adjectives
+        [
+            "autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
+            "summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
+            "patient", "twilight", "dawn", "crimson", "wispy", "weathered", "blue",
+            "billowing", "broken", "cold", "damp", "falling", "frosty", "green",
+            "long", "late", "bold", "little", "morning", "muddy",
+            "red", "rough", "still", "small", "sparkling", "shy",
+            "wandering", "withered", "wild", "black", "young", "holy", "solitary",
+            "fragrant", "aged", "snowy", "proud", "floral", "restless",
+            "polished", "purple", "lively", "nameless"
+        ]
+      end
+
+      def nouns
+        [
+            "waterfall", "river", "breeze", "moon", "rain", "wind", "sea", "morning",
+            "snow", "lake", "sunset", "pine", "shadow", "leaf", "dawn", "glitter",
+            "forest", "hill", "cloud", "meadow", "sun", "glade", "bird", "brook",
+            "butterfly", "bush", "dew", "dust", "field", "fire", "flower", "firefly",
+            "feather", "grass", "haze", "mountain", "night", "pond", "darkness",
+            "snowflake", "silence", "sound", "sky", "shape", "surf", "thunder",
+            "violet", "water", "wildflower", "wave", "water", "resonance", "sun",
+            "wood", "dream", "cherry", "tree", "fog", "frost", "voice", "paper",
+            "frog", "smoke", "star"
+        ]
+      end
+    end
+  end
+end

data/lib/kontena/main_command.rb

@@ -0,0 +1,66 @@
+require 'kontena/command'
+
+class Kontena::MainCommand < Kontena::Command
+  option ['-v', '--version'], :flag, "Output Kontena CLI version #{Kontena::Cli::VERSION}" do
+    build_tags = [ 'ruby' + RUBY_VERSION ]
+    build_tags << RUBY_PLATFORM
+    build_tags += ENV["KONTENA_EXTRA_BUILDTAGS"].to_s.split(',')
+    puts ['kontena-cli', Kontena::Cli::VERSION, "[#{build_tags.join('+')}]"].join(' ')
+    exit 0
+  end
+
+  banner Kontena.pastel.green("Getting started:"), false
+  banner ' - Create a Kontena Master (see "kontena plugin search" for a list of', false
+  banner '   provisioning plugins)', false
+  banner ' - Or log into an existing master, use: "kontena master login <master url>"', false
+  banner ' - Read more about Kontena at https://www.kontena.io/docs/', false
+
+  subcommand "master", "Kontena Master specific commands", load_subcommand('master_command')
+  subcommand "cloud", "Kontena Cloud specific commands", load_subcommand('cloud_command')
+  subcommand "node", "Node specific commands", load_subcommand('node_command')
+  subcommand "grid", "Grid specific commands", load_subcommand('grid_command')
+  subcommand "stack", "Stack specific commands", load_subcommand('stack_command')
+  subcommand "service", "Service specific commands", load_subcommand('service_command')
+  subcommand "container", "Container specific commands", load_subcommand('container_command')
+  subcommand "vault", "Vault specific commands", load_subcommand('vault_command')
+  subcommand "vpn", "VPN specific commands", load_subcommand('vpn_command')
+  subcommand "etcd", "Etcd specific commands", load_subcommand('etcd_command')
+  subcommand "certificate", "LE Certificate specific commands", load_subcommand('certificate_command')
+  subcommand "registry", "Registry specific commands", load_subcommand('registry_command')
+  subcommand "external-registry", "External registry specific commands", load_subcommand('external_registry_command')
+  subcommand "volume", "Volume specific commands", load_subcommand('volume_command')
+  subcommand "plugin", "Plugin specific commands", load_subcommand('plugin_command')
+  subcommand "whoami", "Shows current logged in user", load_subcommand('whoami_command')
+  subcommand "version", "Show CLI and current master version", load_subcommand('version_command')
+
+  def execute
+  end
+
+  # @param [String] command
+  # @param [String] description
+  # @param [Class] klass
+  def self.register(command, description, command_class)
+    subcommand(command, description, command_class)
+  end
+
+  def subcommand_missing(name)
+    extend Kontena::Cli::Common
+    if known_plugin_subcommand?(name)
+      exit_with_error "The '#{name}' plugin has not been installed. Use: kontena plugin install #{name}"
+    elsif name == 'login'
+      exit_with_error "Use 'kontena master login' to log into a Kontena Master\n"+
+             "         or 'kontena cloud login' for logging into your Kontena Cloud account"
+    elsif name == 'logout'
+      exit_with_error "Use 'kontena master logout' to log out from a Kontena Master\n"+
+             "         or 'kontena cloud logout' for logging out from your Kontena Cloud account"
+    elsif name == 'app'
+      exit_with_error "The deprecated app subcommand has been moved into a plugin. You can install\n" +
+             "         it by using 'kontena plugin install app-command'"
+    end
+    super
+  end
+
+  def known_plugin_subcommand?(name)
+    ['vagrant', 'packet', 'digitalocean', 'azure', 'upcloud', 'aws', 'shell'].include?(name)
+  end
+end

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 Kontena.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,89 @@
+require 'kontena/plugin_manager'
+
+module Kontena
+  module PluginManager
+    module Common
+      Gem.autoload :DefaultUserInteraction, 'rubygems/user_interaction'
+      Gem.autoload :StreamUI, 'rubygems/user_interaction'
+
+      KONTENA_PLUGIN = 'kontena-plugin-%s'
+
+      # @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 KONTENA_PLUGIN % nil if plugin_name.nil? || plugin_name.empty?
+        return plugin_name if plugin_name.start_with?('kontena-plugin-') || plugin_name.include?('.')
+        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, '.krates', '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,78 @@
+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
+      attr_accessor :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 pre?
+        !!@pre
+      end
+
+      def command
+        @command ||= Gem::DependencyInstaller.new(
+          document: false,
+          force: true,
+          prerelease: pre,
+          minimal_deps: true
+        )
+      end
+
+      # Install a plugin
+      def install
+        return install_uri if plugin_name.include?('://')
+        plugin_version = version.nil? ? Gem::Requirement.default : Gem::Requirement.new(version)
+        command.install(prefix(plugin_name), plugin_version)
+        command.installed_gems
+      end
+
+      def install_uri
+        require 'tempfile'
+        require 'open-uri'
+        file = Tempfile.new(['kontena_plugin', '.gem'])
+        open(plugin_name) do |input|
+          file.write input.read
+          file.close
+        end
+        self.class.new(file.path).install
+      ensure
+        file.unlink
+      end
+
+      def available_upgrade
+        installed = installed(plugin_name)
+        return false unless installed
+
+        pre = installed.version.prerelease?
+        latest = rubygems_client.latest_version(prefix(plugin_name), pre: pre? || pre)
+        if latest > installed.version
+          latest.to_s
+        end
+      end
+
+      # Upgrade an installed plugin
+      def upgrade
+        return install if version
+        upgrade_to = available_upgrade
+        if upgrade_to
+          Installer.new(plugin_name, version: upgrade_to).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 = 'krates'.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(spec)
+        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(spec)
+        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

@@ -0,0 +1,59 @@
+require 'kontena_cli'
+require 'json'
+require 'uri'
+require 'net/https'
+
+module Kontena
+  module PluginManager
+    class RubygemsClient
+
+      JSON_MIME  ='application/json'.freeze
+      ACCEPT = 'Accept'.freeze
+      HTTPOK = "200".freeze
+
+      def search(pattern = nil)
+        get('/api/v1/search.json', query: pattern)
+      end
+
+      def versions(gem_name)
+        response = get("/api/v1/versions/#{gem_name}.json")
+        response.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(gem_name, pre: false)
+        return versions(gem_name).first if pre
+        versions(gem_name).find { |version| !version.prerelease? }
+      end
+
+      def client
+        return @client if @client
+        @client = Net::HTTP.new('rubygems.org', 443)
+        @client.use_ssl = true
+        @client
+      end
+
+      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/plugin_manager.rb

@@ -0,0 +1,26 @@
+module Kontena
+  module PluginManager
+    autoload :RubygemsClient, 'kontena/plugin_manager/rubygems_client'
+    autoload :Loader, 'kontena/plugin_manager/loader'
+    autoload :Installer, 'kontena/plugin_manager/installer'
+    autoload :Uninstaller, 'kontena/plugin_manager/uninstaller'
+    autoload :Cleaner, 'kontena/plugin_manager/cleaner'
+    autoload :Common, 'kontena/plugin_manager/common'
+
+    # Initialize plugin manager
+    def init
+      ENV["GEM_HOME"] = Common.install_dir
+      Gem.paths = ENV
+      Common.use_dummy_ui unless Kontena.debug?
+      plugins
+      true
+    end
+    module_function :init
+
+    # @return [Array<Gem::Specification>]
+    def plugins
+      @plugins ||= Loader.new.load_plugins
+    end
+    module_function :plugins
+  end
+end

data/lib/kontena/presets/github_auth_provider.yml

@@ -0,0 +1,11 @@
+---
+oauth2.authorize_endpoint: https://github.com/login/oauth/authorize
+oauth2.code_requires_basic_auth: false
+oauth2.token_endpoint: https://github.com/login/oauth/access_token
+oauth2.token_method: post
+oauth2.token_post_content_type: application/json
+oauth2.userinfo_scope: user:email
+oauth2.userinfo_endpoint: https://api.github.com/user
+oauth2.userinfo_username_jsonpath: "$..login"
+oauth2.userinfo_email_jsonpath: "$..email"
+oauth2.userinfo_user_id_jsonpath: "$..id"

data/lib/kontena/presets/kontena_auth_provider.yml

@@ -0,0 +1,11 @@
+---
+oauth2.authorize_endpoint: https://cloud.kontena.io/login/oauth/authorize
+oauth2.code_requires_basic_auth: false
+oauth2.token_endpoint: https://cloud-api.kontena.io/oauth2/token
+oauth2.token_method: post
+oauth2.token_post_content_type: application/x-www-form-urlencoded
+oauth2.userinfo_endpoint: https://cloud-api.kontena.io/user
+oauth2.userinfo_username_jsonpath: "$..username"
+oauth2.userinfo_email_jsonpath: "$..email"
+oauth2.userinfo_user_id_jsonpath: "$..id"
+oauth2.userinfo_scope: user

data/lib/kontena/scripts/completer

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# resolve bin path, ignoring symlinks
+require 'pathname'
+bin_file = Pathname.new(__FILE__).realpath
+$:.unshift File.expand_path('../../..', bin_file)
+
+require 'kontena/scripts/completer'