vop 0.3.0

data/lib/vop/plugins/meta/commands/new_plugin.rb

@@ -0,0 +1,25 @@
+description "initializes a new plugin (folder)"
+
+param! 'name'
+param! 'path', :description => 'the path in which to create the new plugin.'
+
+require 'fileutils'
+
+run do |params|
+  raise "no such path: #{params['path']}" unless File.exists? params['path']
+
+  # a plugin is a directory
+  plugin_path = File.join(params['path'], params['name'])
+  Dir.mkdir(plugin_path)
+
+  # with subfolders for commands and helpers
+  %w|commands helpers|.each do |thing|
+    Dir.mkdir(File.join(plugin_path, thing))
+  end
+
+  # and a metadata file called '<name>.plugin'
+  plugin_file = params['name'] + '.plugin'
+  FileUtils.touch(File.join(plugin_path, plugin_file))
+
+  @op.reset
+end

data/lib/vop/plugins/meta/commands/show_search_path.rb

@@ -0,0 +1,3 @@
+run do
+  @op._search_path
+end

data/lib/vop/plugins/meta/commands/who_provides.rb

@@ -0,0 +1,5 @@
+param! 'name', :lookup => lambda { |params| @op.list_commands.map { |x| x[:name] } }
+
+run do |name|
+  @op.command(name).plugin.name
+end

data/lib/vop/plugins/meta/meta.plugin

@@ -0,0 +1 @@
+dependency :core

data/lib/vop/plugins/ssh/commands/scp.rb

@@ -0,0 +1,11 @@
+require 'net/scp'
+
+param! 'machine'
+param 'user'
+param! 'local_path'
+param! 'remote_path'
+
+run do |machine, local_path, remote_path, params|
+  user = params.has_key?('user') ? params['user'] : ENV['USER']
+  Net::SCP.upload!(params['machine'], user, local_path, remote_path)
+end

data/lib/vop/plugins/ssh/commands/ssh.rb

@@ -0,0 +1,19 @@
+require 'net/ssh'
+
+param! 'machine'
+param! 'command', :default_param => true
+param 'user' #, :default => ENV['USER']
+param 'key_file', :multi => true
+
+run do |params|
+  machine_name = params['machine']
+  user = params.has_key?('user') ? params['user'] : ENV['USER']
+
+  options = {}
+  if params.has_key? 'key_file'
+    options[:keys] = params['key_file']
+  end
+  Net::SSH.start(machine_name, user, options) do |ssh|
+    ssh.exec! params['command']
+  end
+end

data/lib/vop/plugins/ssh/ssh.plugin

@@ -0,0 +1 @@
+depends :core

data/lib/vop/shell.rb

@@ -0,0 +1,52 @@
+require 'vop'
+require 'vop/shell/vop_shell_backend'
+require 'vop/shell/base_shell'
+
+require 'docopt'
+require 'pp'
+
+module Vop
+
+  class Shell
+
+USAGE = <<DOCOPT
+virtualop
+
+Usage:
+  vop [options]
+
+Options:
+  -h --help       show this help screen
+  -v --verbose    enable debug output
+  -e --execute=<command>  to run a command directly
+
+DOCOPT
+
+    attr_reader :options
+    attr_reader :op
+
+    def initialize(vop = nil, options = {})
+      @op = vop || Vop.new
+      @options = options
+
+      backend = VopShellBackend.new(@op, :color_prompt => true)
+      @base_shell = BaseShell.new(backend)
+    end
+
+    def execute(string)
+      @base_shell.backend.process_input(string)
+    end
+
+    def run_cli
+      @base_shell.run
+    end
+
+    def self.setup()
+      options = Docopt::docopt(USAGE, {:help => true})
+
+      vop = Vop.new(options)
+      return Shell.new(vop, options)
+    end
+
+  end
+end

data/lib/vop/shell/backend.rb

@@ -0,0 +1,28 @@
+# responsible for what should happen when the user interacts with the shell
+# provides tab completion options and processes the user's input
+class Backend
+
+  # is called whenever the user submits a command (hitting enter)
+  def process_input(command_line)
+    raise "not implemented in abstract Backend!"
+  end
+
+  # is called whenever the user requests tab completion
+  # should return an array of completion proposals
+  def complete(word)
+    raise "not implemented in abstract Backend!"
+  end
+
+  def prompt
+    ">"
+  end
+
+  def process_ctrl_c
+
+  end
+
+  def show_banner
+
+  end
+
+end

data/lib/vop/shell/base_shell.rb

@@ -0,0 +1,112 @@
+require 'readline'
+
+# This class is an abstract implementation of a command shell
+# It handles command completion and history functions.
+# For the actual business logic, you need to pass it an implementation of ShellBackend
+class BaseShell
+  attr_reader :backend
+
+  def initialize(backend)
+    @logger = $logger
+    @backend = backend
+
+    at_exit { console.close }
+
+    trap("INT") {
+      Thread.kill(@thread)
+      @backend.process_ctrl_c
+    }
+  end
+
+  class SimpleConsole
+    def initialize(input = $stdin)
+      @input = input
+    end
+
+    def readline
+      begin
+        line = @input.readline
+        line.chomp! if line
+        line
+      rescue EOFError
+        nil
+      end
+    end
+
+    def close
+    end
+  end
+
+  class ReadlineConsole
+    HISTORY_FILE = ".vop_history"
+    MAX_HISTORY = 200
+
+    def history_path
+      File.join(ENV['HOME'] || ENV['USERPROFILE'], HISTORY_FILE)
+    end
+
+    def initialize(shell)
+      @shell = shell
+
+      if File.exist?(history_path)
+        hist = File.readlines(history_path).map{|line| line.chomp}
+        Readline::HISTORY.push(*hist)
+      end
+
+      #Readline.basic_word_break_characters = " \t\n\\`@><=;|&{([+*%"
+
+      # see http://stackoverflow.com/questions/13876024/how-to-write-a-ruby-command-line-app-that-supports-tab-completion#13876556
+      Readline.completer_word_break_characters = ""
+
+      Readline.completion_append_character = nil
+      Readline.completion_proc = @shell.backend.method(:complete).to_proc
+    end
+
+    def close
+      open(history_path, "wb") do |f|
+        history = Readline::HISTORY.to_a
+        if history.size > MAX_HISTORY
+          history = history[history.size - MAX_HISTORY, MAX_HISTORY]
+        end
+        history.each{|line| f.puts(line)}
+      end
+    end
+
+    def readline
+      line = Readline.readline(@shell.backend.prompt, true)
+      Readline::HISTORY.pop if /^\s*$/ =~ line
+      line
+    end
+  end
+
+  def console
+    @console ||= $stdin.tty? ? ReadlineConsole.new(self) : SimpleConsole.new
+  end
+
+  def run
+    backend.show_banner
+    loop do
+      @thread = Thread.new {
+        line = console.readline
+
+        if line
+          backend.process_input line
+        end
+      }
+      begin
+        @thread.join
+      rescue
+        error = $!
+        if error == "exit"
+          Kernel.exit
+        else
+          $stderr.puts "error: >>#{error}<<"
+          $stderr.puts error.backtrace.join("\n")
+        end
+      end
+
+    end
+    $stderr.puts "Exiting shell..."
+  end
+
+end

data/lib/vop/shell/formatter.rb

@@ -0,0 +1,46 @@
+require 'pp'
+require 'terminal-table'
+
+def format_output(command, data)
+  if data.is_a? Array
+    first_row = data.first
+    if first_row.is_a? Hash
+      # show all columns unless defined otherwise in the command
+      columns_to_display = first_row.keys
+      if command.show_options.include? :columns
+        columns_to_display = command.show_options[:columns]
+      end
+      column_headers = columns_to_display
+
+      rearranged = [] # array of hashes -> array of arrays
+      data.each do |row|
+        values = []
+        columns_to_display.each do |key|
+          values << row[key]
+        end
+        rearranged << values
+      end
+
+      begin
+        rearranged.sort_by! { |row| row.first }
+      rescue
+        puts "[WARN] ran into trouble sorting the result (by the first column); results may be not quite sorted."
+        begin
+          rearranged.sort_by! { |row| row.first || "zaphod" }
+        rescue
+          puts "[SHRUG] could not sort even when accounting for potential nil values, giving up."
+        end
+      end
+
+      puts Terminal::Table.new rows: rearranged, headings: column_headers
+    else
+      puts data.join("\n")
+    end
+  elsif data.is_a? Hash
+    data.each do |k,v|
+      puts "#{k} : #{v}"
+    end
+  else
+    puts data
+  end
+end

data/lib/vop/shell/vop_shell_backend.rb

@@ -0,0 +1,257 @@
+require 'vop/shell/backend'
+require 'vop/shell/formatter'
+
+class VopShellBackend < Backend
+
+  def initialize(op, options = {})
+    @op = op
+    @options = options
+    @local_context = {}
+
+    reset_to_command_mode
+  end
+
+  def context
+    @local_context
+  end
+
+  def reset_to_command_mode
+    # this shell has two modes that determine the available tab completion proposals
+    # command_mode
+    #    we're waiting for the user to pick a command that should be executed
+    # parameter mode
+    #    the command to execute has already been selected, but the user needs to specify additional parameters
+    # we'll start in the mode where no command has been selected yet
+    @command_selected = nil
+
+    # if the user selected a command already, we'll have to collect parameters for this command until
+    # we've got all mandatory parameters so that we can execute the command
+    @collected_values = Hash.new { |h,k| h[k] = [] }
+
+    @missing_params = []
+
+    @current_param = nil
+  end
+
+  def process_ctrl_c
+    puts "\n"
+    if @command_selected
+      reset_to_command_mode
+    else
+      Kernel.exit
+    end
+  end
+
+  def set_prompt(p)
+    @prompt = p
+  end
+
+  def prompt
+    @command_selected && @current_param ?
+      "#{@command_selected.short_name}.#{@current_param[:name]} ? " :
+      @prompt || '>> '
+  end
+
+  def show_banner
+    s = @options[:banner]
+    puts s if s
+  end
+
+  def complete(word)
+    $logger.debug "completing #{word}"
+
+    command_list = @op.commands.keys
+
+    list = []
+
+    parts = nil
+
+    if @command_selected
+      #$logger.debug("asking for lookup values for command '#{@command_selected.name}' and param '#{@current_param[:name]}'")
+      list = @command_selected.lookup(@current_param[:name], @collected_values)
+    else
+      begin
+        (parts, command, param_values) = parse_command_string(word)
+
+        if command
+          $logger.debug "command selected (#{command.name}), fetching param lookups"
+
+          # all lookup values for a default_param (if exists)
+          if command.default_param
+            list += command.lookup(command.default_param[:name], @collected_values)
+            $logger.debug "added lookups for default param, list now #{list.length} elements"
+          end
+
+          # names of all params that have not been specified yet or are :multi
+          command.params.each do |param|
+            if not param_values.keys.include? param[:name] || param[:multi]
+              list << param[:name]
+            end
+          end
+
+        else
+          $logger.debug "no command selected yet, returning command list"
+          list = command_list
+        end
+      rescue => e
+        $logger.debug "can't parse >>#{word}<< : #{e.message}"
+        $logger.debug e.backtrace
+      end
+    end
+
+    the_filter = parts ? parts.last : word
+    if the_filter
+      $logger.debug "filtering completion list against : #{the_filter}"
+      list.delete_if do |x|
+        x[0...the_filter.size] != the_filter
+      end
+    end
+
+    prefix = ''
+    if parts
+      prefix = parts.length > 1 ? parts[0..-2].join(" ").strip : ''
+    end
+    if $logger.debug?
+      more_text = list.length > 1 ? " (and #{list.length-1} more)" : ''
+      $logger.debug "completion from >#{word}< to #{prefix} + #{list.first}#{more_text}"
+    end
+    list.map do |x|
+      [prefix, x].join(' ').strip
+    end
+  end
+
+  def parse_command_string(command_line, presets = {})
+    parts = command_line.split.map { |x| x.chomp.strip }
+    (command_name, *params) = parts
+    command = @op.commands[command_name]
+
+    param_values = Hash.new { |h,k| h[k] = [] }
+    presets.each do |k,v|
+      param_values[k] = [v]
+    end
+    if params
+      params.each do |param|
+        if param =~ /(.+?)=(.+)/ then
+          # --> named param
+          key = $1
+          value = $2
+        else
+          # --> unnamed param
+          value = param
+          if command
+            default_param = command.default_param
+            if default_param != nil then
+              key = default_param[:name]
+              $logger.debug "collecting value '#{value}' for default param '#{default_param[:name]}'"
+            else
+              $logger.debug "ignoring param '#{value}' because there's no default param"
+            end
+          else
+            # can't process an unnamed param unless we've got a command
+          end
+        end
+
+        if key
+          param_values[key] << value
+        end
+      end
+    end
+    [parts, command, param_values]
+  end
+
+  def process_input(command_line)
+    $logger.debug "+++ process_input #{command_line} +++"
+    if @command_selected
+      # we're in parameter processing mode - so check which parameter
+      # we've got now and switch modes if necessary
+
+      # we might have been waiting for multiple param values - check if the user finished
+      # adding values by entering an empty string as value
+      if @current_param && (@current_param[:multi] and command_line == "") then
+        @missing_params.shift
+        execute_command_if_possible
+      else
+        # TODO check +command_line+ against lookups/general validity?
+        @collected_values[@current_param[:name]] << command_line
+        if @current_param[:multi] then
+          $logger.debug "param '#{@current_param[:name]}' expects multiple values...deferring mode switching"
+        else
+          @missing_params.shift
+          execute_command_if_possible
+        end
+      end
+    else
+      (unused, @command_selected, values) = parse_command_string(command_line, @local_context)
+
+      if @command_selected
+        values.each do |key, value_list|
+          begin
+            value_list.each do |value|
+              @current_param = @command_selected.param(key)
+              if @current_param
+                @collected_values[@current_param[:name]] << value
+              else
+                # TODO handle extra params?
+              end
+            end
+          rescue Exception => ex
+            # TODO broken (error: undefined method `accepts_extra_params' for Vop::Command machines.select_machine:Vop::Command)
+            if @command_selected && false && @command_selected.accepts_extra_params
+              puts "collecting value for extra param : #{key} => #{value}"
+              @collected_values["extra_params"] = {} unless @collected_values.has_key?("extra_params")
+              @collected_values["extra_params"][key] = Array.new if @collected_values["extra_params"][key] == nil
+              @collected_values["extra_params"][key] << value
+            else
+              #puts "ignoring parameter value '#{value_list}' for param '#{key}' : " + ex.to_s
+              raise ex
+            end
+          end
+        end
+
+
+        execute_command_if_possible
+      end
+    end
+  end
+
+  def execute_command_if_possible
+    mandatory = @command_selected.mandatory_params
+    @missing_params = mandatory.select { |p| ! @collected_values.include? p[:name] }
+
+    if @missing_params.size > 0
+      @current_param = @missing_params.first
+    else
+      execute_command
+    end
+  end
+
+  def execute_command
+    command = @command_selected
+    $logger.debug "vop_shell_backend executing command '#{command.short_name}'"
+
+    begin
+      extras = {
+        'shell' => self
+      }
+      (response, context) = @op.execute_command(command.short_name, @collected_values, extras)
+
+      if command.short_name == 'exit'
+        $logger.info "exiting on user request"
+        Kernel.exit(0)
+      end
+
+      if context
+        if context['prompt']
+          set_prompt context['prompt']
+        end
+
+        @local_context.merge! context
+      end
+
+      format_output(command, response)
+    ensure
+      reset_to_command_mode
+    end
+  end
+
+end