kontena-plugin-shell 0.1.0

data/lib/kontena/plugin/shell/command.rb

@@ -0,0 +1,85 @@
+module Kontena::Plugin
+  module Shell
+    class Command
+
+      attr_reader :context, :args, :session
+
+      def self.command(name = nil)
+        return @command if instance_variable_defined?(:@command)
+        disabled_commands = ENV['KOSH_DISABLED_COMMANDS'].to_s.split(/,/)
+        Array(name).each { |name| Shell.commands[name] = self unless disabled_commands.include?(name) }
+        @command = name
+      end
+
+      def self.subcommands(subcommands = nil)
+        return @subcommands if instance_variable_defined?(:@subcommands)
+        @subcommands = {}
+        Array(subcommands).each do |sc|
+          Array(sc.command).each do |name|
+            @subcommands[name] = sc
+          end
+        end
+      end
+
+      def self.has_subcommands?
+        !subcommands.nil? && !subcommands.empty?
+      end
+
+      def has_subcommands?
+        self.class.has_subcommands?
+      end
+
+      def self.description(text = nil)
+        @description ||= text
+      end
+
+      def self.help(text = nil)
+        @help ||= text
+      end
+
+      def self.completions(*completions)
+        @completions ||= completions
+      end
+
+      def initialize(context = nil, args = nil, session = nil)
+        @args = Array(args)
+        @context = context
+        @session = session
+      end
+
+      def run
+        if has_subcommands?
+          if args[1]
+            subcommand = self.class.subcommands[args[1]]
+            if subcommand
+              subcommand.new(context, args[1..-1], session).run
+            else
+              puts Kontena.pastel.red("Unknown subcommand")
+            end
+          else
+            context << args[0]
+          end
+        else
+          execute
+        end
+      rescue Kontena::Plugin::Shell::ExitCommand::CleanExit
+        puts Kontena.pastel.green("Bye!")
+        exit 0
+      rescue => ex
+        puts Kontena.pastel.red("ERROR: " + ex.message)
+        puts Kontena.pastel.green(ex.backtrace.join("\n  ")) if ENV["DEBUG"]
+      end
+    end
+
+    # SubCommand is just like a command, except it doesn't register the
+    # class to Shell.commands.
+    class SubCommand < Command
+      def self.command(name = nil)
+        @command ||= name
+      end
+    end
+
+  end
+end
+
+Dir[File.expand_path('../commands/**/*.rb', __FILE__)].each { |file| require file }

data/lib/kontena/plugin/shell/commands/batch.rb

@@ -0,0 +1,29 @@
+require 'kontena/plugin/shell/command'
+require 'kontena/plugin/shell/commands/batch_do'
+
+module Kontena::Plugin
+  module Shell
+    class BatchCommand < Command
+
+      command 'batch'
+      description 'Run/create command batches'
+      help -> (context, tokens) {
+        if tokens && tokens[2] && subcommands[tokens[2]]
+          subcommands[tokens[2]].help
+        else
+          <<-EOB.gsub(/^\s+/, '')
+            To run a series of commands in a batch, use:
+
+            > batch do
+            > command
+            > command 2
+            > end
+          EOB
+        end
+      }
+
+      subcommands [Kontena::Plugin::Shell::BatchDoCommand]
+      completions *subcommands.keys
+    end
+  end
+end

data/lib/kontena/plugin/shell/commands/batch_do.rb

@@ -0,0 +1,30 @@
+require 'kontena/plugin/shell/command'
+
+module Kontena::Plugin
+  module Shell
+    class BatchDoCommand < SubCommand
+
+      command 'do'
+      description 'Run a batch of commands'
+      help "Example:\n> batch do\n> master users ls\n> master ls\n> end"
+      completions nil
+
+      def execute
+        if args.size > 1
+          lines = args[1..-1].join(' ').split(/(?<!\\);/).map(&:strip)
+        else
+          lines = []
+          while buf = Readline.readline("#{Kontena.pastel.green('..')}#{Kontena.pastel.red('>')} ", true)
+            buf.strip!
+            break if buf == 'end'
+            lines << buf unless buf.empty?
+          end
+          (lines.size + 1).times { Readline::HISTORY.pop }
+          Readline::HISTORY.push "batch do #{lines.join('; ')}"
+        end
+
+        lines.each { |line| session.run_command(line) }
+      end
+    end
+  end
+end

data/lib/kontena/plugin/shell/commands/context_top.rb

@@ -0,0 +1,22 @@
+require 'kontena/plugin/shell/command'
+
+module Kontena::Plugin
+  module Shell
+    class ContextTopCommand < Command
+      command '/'
+      description 'Clear context'
+      help "Go to top in context.\n\nYou can also directly call other commands without switching context first by using for example #{Kontena.pastel.yellow('/ master ls')}"
+
+      def execute
+        if args[1] && session
+          old_context = context.to_a.clone
+          context.top
+          session.run_command(args[1..-1].join(' '))
+          context.concat(old_context)
+        else
+          context.top
+        end
+      end
+    end
+  end
+end

data/lib/kontena/plugin/shell/commands/context_up.rb

@@ -0,0 +1,15 @@
+require 'kontena/plugin/shell/command'
+
+module Kontena::Plugin
+  module Shell
+    class ContextUpCommand < Command
+      command '..'
+      description 'Go up in context'
+      help 'Go up in context'
+
+      def execute
+        context.up
+      end
+    end
+  end
+end

data/lib/kontena/plugin/shell/commands/debug.rb

@@ -0,0 +1,29 @@
+require 'kontena/plugin/shell/command'
+
+module Kontena::Plugin
+  module Shell
+    class DebugCommand < Command
+      command 'debug'
+      description 'Toggle debug output'
+      help 'Use debug on/off to toggle debug output.'
+
+      completions 'on', 'off', 'api'
+
+      def execute
+        case args[1]
+        when 'true', 'on', '1'
+          ENV['DEBUG'] = 'true'
+        when 'api'
+          ENV['DEBUG'] = 'api'
+        when 'off', 'false', '0'
+          ENV.delete('DEBUG')
+        when NilClass
+          # do nothing
+        else
+          puts Kontena.pastel.red("Unknown argument '#{args[1]}'")
+        end
+        puts "Debug #{Kontena.pastel.send(*ENV['DEBUG'] ? [:green, 'on'] : [:red, 'off'])}"
+      end
+    end
+  end
+end

data/lib/kontena/plugin/shell/commands/exit.rb

@@ -0,0 +1,20 @@
+require 'kontena/plugin/shell/command'
+
+module Kontena::Plugin
+  module Shell
+    class ExitCommand < Command
+      command 'exit'
+      description 'Quit shell'
+      help 'Enter "exit" to quit.'
+
+      completions nil
+
+      CleanExit = Class.new(StandardError)
+
+      def execute
+        raise CleanExit
+      end
+    end
+  end
+end
+

data/lib/kontena/plugin/shell/commands/help.rb

@@ -0,0 +1,43 @@
+require 'kontena/plugin/shell/command'
+
+module Kontena::Plugin
+  module Shell
+    class HelpCommand < Command
+      command 'help'
+      description 'Show help'
+      help 'Use "help <command>" to see help for a specific command'
+      #completions -> (context, tokens, word) { Kontena::Completer.complete(context.to_a + tokens) }
+
+      def cmd
+        full_line = context + args[1..-1]
+        cmd = Shell.command(full_line.first) || Shell.command('kontena')
+      end
+
+      def execute
+        if cmd.help.respond_to?(:call)
+          help_text = cmd.help.call(context, args[1..-1])
+        else
+          help_text = cmd.help
+        end
+        puts help_text
+
+        if cmd.has_subcommands?
+          puts
+          puts Kontena.pastel.green("Subcommands:")
+          cmd.subcommands.each do |name, sc|
+            puts sprintf('    %-29s %s', name, sc.description)
+          end
+          puts
+        end
+
+        if args.empty? || (args.size == 1 && args.first == 'help')
+          puts Kontena.pastel.green('KOSH commands:')
+          Shell.commands.each do |name, cmd|
+            next if cmd == Kontena::Plugin::Shell::KontenaCommand
+            puts sprintf('    %-29s %s', name, cmd.description)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kontena/plugin/shell/commands/kontena.rb

@@ -0,0 +1,57 @@
+require 'kontena/main_command' unless Kontena.const_defined?(:MainCommand)
+require 'kontena/plugin/shell/command'
+require 'kontena/plugin/shell/completer'
+require 'kontena/plugin/shell/context'
+
+module Kontena::Plugin
+  module Shell
+    class KontenaCommand < Command
+
+      command ['kontena'] + Kontena::MainCommand.recognised_subcommands.flat_map(&:names)
+      description 'Run Kontena-cli command'
+      help -> (context, tokens) { new(context, tokens).subcommand_class.help('').gsub(/^(\s+)\[OPTIONS\] SUB/, "\\1 SUB") }
+      completions -> (context, tokens, word) { Kontena::Plugin::Shell::Completer.complete(context.to_a + tokens) }
+
+      def cmd
+        cmd = Kontena::MainCommand.new('')
+        cmdline = context.to_a + args
+        cmdline.shift if cmdline.first == 'kontena'
+        cmd.parse(cmdline)
+        cmd
+      end
+
+      def execute
+        cmd.run([])
+      rescue Clamp::HelpWanted => ex
+        unless args.include?('--help') || args.include?('-h')
+          context.concat(args)
+        end
+      rescue SystemExit => ex
+        puts Kontena.pastel.red('[Command exited with error]') unless ex.status.zero?
+      rescue => ex
+        puts Kontena.pastel.red("ERROR: #{ex.message}")
+      end
+
+      def subcommand_class
+        (context + args).reject { |t| t.start_with?('-') }.inject(Kontena::MainCommand) do |base, token|
+          if base.has_subcommands?
+            sc = base.recognised_subcommands.find { |sc| sc.names.include?(token) }
+            sc ? sc.subcommand_class : base
+          else
+            base
+          end
+        end
+      end
+    end
+  end
+end
+
+if ENV["KOSH_DISABLED_COMMANDS"]
+  ENV["KOSH_DISABLED_COMMANDS"].split(',').each do |command|
+    tokens = command.split(' ')
+    subcommand = tokens.pop
+    kontena = Kontena::Plugin::Shell::KontenaCommand.new(Kontena::Plugin::Shell::Context.new(tokens))
+    found_subcommand = kontena.subcommand_class
+    found_subcommand.recognised_subcommands.delete_if { |sc| sc.names.include?(subcommand) }
+  end
+end

data/lib/kontena/plugin/shell/completer.rb

@@ -0,0 +1,216 @@
+# this is mostly just a wrapped version of the completer in cli
+require 'kontena/cli/common' unless Kontena.const_defined?(:Cli) && Kontena::Cli.const_defined?(:Common)
+require 'yaml'
+
+module Kontena::Plugin::Shell
+  module Completer
+    class Helper
+      include Kontena::Cli::Common
+
+      def grids
+        client.get("grids")['grids'].map{|grid| grid['id']}
+      rescue
+        []
+      end
+
+      def nodes
+        client.get("grids/#{current_grid}/nodes")['nodes'].map{|node| node['name']}
+      rescue
+        []
+      end
+
+      def stacks
+        stacks = client.get("grids/#{current_grid}/stacks")['stacks']
+        results = []
+        results.push stacks.map{|s| s['name']}
+        results.delete('null')
+        results
+      rescue
+        []
+      end
+
+      def services
+        services = client.get("grids/#{current_grid}/services")['services']
+        results = []
+        results.push services.map{ |s|
+          stack = s['stack']['id'].split('/').last
+          if stack != 'null'
+            "#{stack}/#{s['name']}"
+          else
+            s['name']
+          end
+        }
+        results
+      rescue
+        []
+      end
+
+      def containers
+        results = []
+        client.get("grids/#{current_grid}/services")['services'].each do |service|
+          containers = client.get("services/#{service['id']}/containers")['containers']
+          results.push(containers.map{|c| c['name'] })
+          results.push(containers.map{|c| c['id'] })
+        end
+        results
+      rescue
+        []
+      end
+
+      def yml_services
+        if File.exist?('kontena.yml')
+          yaml = YAML.safe_load(File.read('kontena.yml'))
+          services = yaml['services']
+          services.keys
+        end
+      rescue
+        []
+      end
+
+      def yml_files
+        Dir["./*.yml"].map{|file| file.sub('./', '')}
+      rescue
+        []
+      end
+
+      def master_names
+        config_file = File.expand_path('~/.kontena_client.json')
+        if(File.exist?(config_file))
+          config = JSON.parse(File.read(config_file))
+          return config['servers'].map{|s| s['name']}
+        end
+      rescue
+        []
+      end
+    end
+
+    def self.complete(words)
+      while words.first == 'kontena' || words.first == 'complete'
+        words.shift
+      end
+      helper = Helper.new
+      completion = []
+
+      case words[0]
+      when NilClass, ''
+        completion.concat %w(cloud logout grid app service stack vault certificate node master vpn registry container etcd external-registry whoami plugin version)
+      when 'plugin'
+        sub_commands = %w(list ls search install uninstall)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+        else
+          completion.push sub_commands
+        end
+      when 'etcd'
+        sub_commands = %w(get set mkdir mk list ls rm)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+        else
+          completion.push sub_commands
+        end
+      when 'registry'
+        sub_commands = %w(create remove rm)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+        else
+          completion.push sub_commands
+        end
+      when 'grid'
+        sub_commands = %w(add-user audit-log create current list user remove show use)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+          completion.push helper.grids
+        else
+          completion.push sub_commands
+        end
+      when 'node'
+        sub_commands = %w(list show remove)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+          completion.push helper.nodes
+        else
+          completion.push sub_commands
+        end
+      when 'master'
+        sub_commands = %w(list use users current remove rm config cfg login logout token join audit-log init-cloud)
+        if words[1] && words[1] == 'use'
+          completion.push helper.master_names
+        elsif words[1] && words[1] == 'users'
+          users_sub_commands = %(invite list role)
+          completion.push users_sub_commands
+        elsif words[1] && ['config', 'cfg'].include?(words[1])
+          config_sub_commands = %(set get dump load import export unset)
+          completion.push config_sub_commands
+        elsif words[1] && words[1] == 'token'
+          token_sub_commands = %(list ls rm remove show current create)
+          completion.push token_sub_commands
+        elsif words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+        else
+          completion.push sub_commands
+        end
+      when 'cloud'
+        sub_commands = %w(login logout master)
+        if words[1] && words[1] == 'master'
+          cloud_master_sub_commands = %(list ls remove rm add show update)
+          completion.push cloud_master_sub_commands
+        elsif words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+        else
+          completion.push sub_commands
+        end
+      when 'service'
+        sub_commands = %w(containers create delete deploy list logs restart
+                        scale show start stats stop update monitor env
+                        secret link unlink)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+          completion.push helper.services
+        else
+          completion.push sub_commands
+        end
+      when 'container'
+        sub_commands = %w(exec inspect logs)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+          completion.push helper.containers
+        else
+          completion.push sub_commands
+        end
+      when 'vpn'
+        completion.push %w(config create delete)
+      when 'external-registry'
+        completion.push %w(add list delete)
+      when 'app'
+        sub_commands = %w(init build config deploy start stop remove rm ps list
+                          logs monitor show)
+        if words[1]
+          completion.push(sub_commands) unless sub_commands.include?(words[1])
+          completion.push helper.yml_services
+        else
+          completion.push sub_commands
+        end
+      when 'stack'
+        sub_commands = %w(build install upgrade deploy start stop remove rm ls list
+                          logs monitor show registry)
+        if words[1]
+          if words[1] == 'registry'
+            registry_sub_commands = %(push pull search show rm)
+            completion.push registry_sub_commands
+          elsif %w(install).include?(words[1])
+              completion.push helper.yml_files
+          elsif words[1] == 'upgrade' && words[3]
+            completion.push helper.yml_files
+          else
+            completion.push(sub_commands) unless sub_commands.include?(words[1])
+            completion.push helper.stacks
+          end
+        else
+          completion.push sub_commands
+        end
+      else
+      end
+      completion.flatten.flat_map { |item| item.split(/\s+/) }
+    end
+  end
+end