rhcp_shell 0.0.9 → 0.2.11

data/bin/rhcp_shell

@@ -12,6 +12,8 @@ require 'base_shell'
 require 'rhcp_shell_backend'
 require 'version'
 
+require 'uri'
+
 module RHCP
   class Shell
 
@@ -51,8 +53,14 @@ EOF
       [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
       [ '--username', '-u', GetoptLong::REQUIRED_ARGUMENT ],
       [ '--password', '-p', GetoptLong::REQUIRED_ARGUMENT ],
-      [ '--hostname', GetoptLong::REQUIRED_ARGUMENT ]
+      [ '--hostname', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--port', '-P', GetoptLong::REQUIRED_ARGUMENT ]
     )
+    
+    options = {
+      "hostname" => "localhost",
+      "port" => 42000      
+    }
 
     options = Hash.new
     opts.each do |opt, arg|
@@ -62,7 +70,7 @@ EOF
           Kernel.exit(1)
         else
           opt =~ /--(.+)/
-          $logger.debug "setting #{arg} for #{$1}" unless $1 == "password"
+          $logger.debug "setting #{arg} for #{$1}" unless $1 == "password"          
           options[$1] = arg
       end
     end
@@ -70,10 +78,8 @@ EOF
     host = options["hostname"]
     if host == nil then
       host = "http://localhost:42000"
-    else
-      if host !~ /http:/ then
+    elsif host !~ /http:/ then
         host = "http://#{host}:42000/rhcp"
-      end
     end
     $logger.debug "now connecting to #{host}"
 
@@ -81,6 +87,19 @@ EOF
 
     begin
       url = URI.parse(host)
+      
+    if (false)       
+      http_options = {
+        :host => options["hostname"],
+        :port => 80,
+        :path => "/rhcp"
+      }
+      if options.has_key?('username')
+        http_options[:userinfo] = "#{options['username']}:#{options['password']}"
+      end
+      url = URI::HTTP.build(http_options)
+    end
+    
       @http_broker = RHCP::Client::HttpBroker.new(url)
 
       backend = RHCPShellBackend.new(@http_broker)
@@ -105,6 +124,7 @@ end
   
 # TODO introduce something like the RAILS_ENVs
 $logger = Logger.new("rhcp_shell.log")
+$logger.level = Logger::DEBUG
 RHCP::ModuleHelper.instance().logger = $logger
 
 shell = RHCP::Shell.new

data/bin/rhcp_shell.log

@@ -0,0 +1,11 @@
+# Logfile created on Sat Jun 25 20:16:10 +0000 2011 by logger.rb/22285
+D, [2011-06-25T20:16:10.643948 #1686] DEBUG -- : now connecting to http://localhost:42000
+D, [2011-06-25T20:16:10.644097 #1686] DEBUG -- : connecting to http://localhost:42000
+D, [2011-06-25T20:16:31.881621 #1688] DEBUG -- : setting http://localhost for hostname
+D, [2011-06-25T20:16:31.881756 #1688] DEBUG -- : now connecting to http://localhost
+D, [2011-06-25T20:16:31.881865 #1688] DEBUG -- : connecting to http://localhost
+E, [2011-06-25T20:16:31.883273 #1688] ERROR -- : cannot connect to 'http://localhost' : got http status code 404
+D, [2011-06-25T20:16:45.728319 #1690] DEBUG -- : setting http://localhost/rhcp for hostname
+D, [2011-06-25T20:16:45.728460 #1690] DEBUG -- : now connecting to http://localhost/rhcp
+D, [2011-06-25T20:16:45.728582 #1690] DEBUG -- : connecting to http://localhost/rhcp
+E, [2011-06-25T20:16:45.730109 #1690] ERROR -- : cannot connect to 'http://localhost/rhcp' : got http status code 404

data/lib/base_shell.rb

@@ -89,10 +89,22 @@ class BaseShell
           else
             @logger.debug "got an empty line"      
           end
-          
+
           backend.process_input line
       }
-      @thread.join
+      begin
+        @thread.join
+      rescue
+        error = $!
+        if error == "exit"
+          puts "exiting"
+          Kernel.exit
+        else
+          puts "got an error in @thread.join: #{error}"
+        end
+        
+      end
+      
     end
     $stderr.puts "Exiting shell..."      
   end

data/lib/display_types/table.rb

@@ -0,0 +1,106 @@
+def format_table_output(command, response)
+
+    # TODO make sure that the response really holds the correct data types and that we've got at least one column
+    # TODO check that all columns in overview_columns are valid
+    # TODO check that all columns in column_titles are valid and match overview_columns
+    output = ""         
+    
+    # let's find out which columns we want to display
+    $logger.debug "overview columns : #{command.result_hints[:overview_columns]}"
+    # TODO this will probably fail if no overview_columns are specified
+    columns_to_display = command.result_hints.has_key?(:overview_columns) ?
+      command.result_hints[:overview_columns].clone() :
+      # by default, we'll display all columns, sorted alphabetically
+      columns_to_display = response.data[0].keys.sort
+    
+    # and which titles they should have (default : column names)
+    $logger.debug "column titles : #{command.result_hints[:column_titles].length}"
+    column_title_list = command.result_hints[:column_titles].length > 0 ?
+      command.result_hints[:column_titles].clone() :
+      column_title_list = columns_to_display
+    $logger.debug "column title list : #{column_title_list}"
+    
+    # TODO the sorting column should be configurable
+    first_column = columns_to_display[0]
+    $logger.debug "sorting by #{first_column}"
+    response.data = response.data.sort { |a,b| a[first_column] <=> b[first_column] }          
+    
+    # add the index column
+    columns_to_display.unshift "__idx"
+    column_title_list.unshift "\#"
+    count = 1
+    response.data.each do |row|
+      row["__idx"] = count
+      count = count+1
+    end
+    
+    column_titles = {}
+    0.upto(column_title_list.length - 1) do |i|
+      column_titles[columns_to_display[i]] = column_title_list[i]
+    end
+    $logger.debug "column titles : #{column_titles}"
+    
+    # initialize the max_width for all columns
+    @max_width = {}
+    column_titles.each do |key, value|
+      @max_width[key] = 0
+    end
+    # find the maximum column width for each column
+    response.data.each do |row|
+      row.each do |k,v|
+        if ! @max_width.has_key?(k) || v.to_s.length >  @max_width[k]
+          @max_width[k] = v.to_s.length
+        end
+      end
+    end
+    
+    # check the column_title for max width
+    columns_to_display.each do |col_name|
+      if column_titles[col_name].length > @max_width[col_name]
+        @max_width[col_name] = column_titles[col_name].length
+      end
+    end
+    #@max_width["row_count"] = response.data.length.to_s.length
+    $logger.debug "max width : #{@max_width}"
+    
+    # and build headers
+    @total_width = 2 + columns_to_display.length-1 # separators at front and end of table and between the values
+    columns_to_display.each do |col|
+      @total_width += @max_width[col] + 2 # each column has a space in front and behind the value
+    end
+    output += print_line
+    
+    columns_to_display.each do |col|
+      output += print_cell(col, column_titles[col])
+    end
+    output += "|\n"
+
+    output += print_line
+    
+    # print the table values
+    response.data.each do |row|            
+      columns_to_display.each do |col|
+        output += print_cell(col, row[col])
+      end
+      output += "|\n"
+    end
+    output += print_line
+  
+end
+
+def print_cell(col_name, the_value)
+    result = "| "
+    result += the_value.to_s
+    1.upto(@max_width[col_name] - the_value.to_s.length) { |i| 
+      result += " " 
+    }
+    result += " "
+    result
+  end
+  
+  def print_line
+    result = ""
+    @total_width.times { |i| result += "-" }
+    result += "\n"
+    result
+  end

data/lib/local_commands/context.rb

@@ -0,0 +1,24 @@
+def add_context_commands(broker, context_aware_broker)
+  
+  command = RHCP::Command.new("show_context", "displays the context currently stored in the local ContextAwareBroker",
+    lambda { |req,res| 
+      result = []
+      @command_broker.context.cookies.each do |k,v|
+        result << {
+          "key" => k,
+          "value" => v
+        }
+      end
+      result
+    }
+  )
+  
+  command.result_hints[:display_type] = "table"
+  command.result_hints[:overview_columns] = [ "key", "value" ]
+  command.result_hints[:column_titles] = [ "key", "value" ]
+  command.mark_as_read_only
+  command.result_hints[:cache] = false
+  
+  broker.register_command command
+  
+end

data/lib/local_commands/detail.rb

@@ -0,0 +1,33 @@
+def add_detail_command(broker)
+
+  command = RHCP::Command.new("detail", "shows details about a single record of the last response\n" + (" " * 43)  + "(makes sense if you executed a command that returned a table)",
+    lambda { |req,res| 
+      if @last_response == nil
+        puts "did not find any old response data...is it possible that you did not execute a command yet that returned a table?"
+        return
+      end
+      row_count = @last_response.data.length
+      begin
+        row_index = req.get_param_value("row_index").to_i
+        raise "invalid index" if (row_index < 1 || row_index > row_count)
+      rescue
+        puts "invalid row index - please specify a number between 1 and #{row_count}"  
+        return
+      end
+      puts "displaying details about row \# #{row_index}"          
+      @last_response.data[row_index - 1].each do |k,v|
+        puts "  #{k}\t#{v}"
+      end
+
+    }
+    ).add_param(RHCP::CommandParam.new("row_index", "the index of the row you want to see details about",
+      {
+        :is_default_param => true,
+        :mandatory => true            
+      }
+    )
+  )
+  command.result_hints[:display_type] = "hidden"
+  broker.register_command command
+  
+end  

data/lib/local_commands/exit.rb

@@ -0,0 +1,9 @@
+def add_exit_command(broker)
+  broker.register_command RHCP::Command.new("exit", "closes the shell", 
+    lambda { |req,res| 
+      puts "Have a nice day"
+      #self.process_ctrl_c
+      Kernel.exit(0)
+    }
+  )
+end

data/lib/local_commands/help.rb

@@ -0,0 +1,74 @@
+def param_example(param, suffix = "")
+  result = ""
+  result += "<" if param.is_default_param
+
+  if param.is_default_param then
+    result += "#{param.name}#{suffix}"
+  else
+    result += "#{param.name}"
+    result += "=<value#{suffix}>"
+  end
+
+  result += ">" if param.is_default_param
+  result
+end
+
+def add_help_commands(broker)
+  command = RHCP::Command.new("help", "displays help about this shell",
+    lambda { 
+      |req,res|
+        
+      if (req.has_param_value("command"))
+        command_name = req.get_param_value("command")
+        puts "Syntax:"
+        command_line = "  #{command_name}"
+        command = @command_broker.get_command(command_name)
+
+        command.params.sort { |a,b| a.name <=> b.name }.each do |param|
+          command_line += " "
+          command_line += "[" unless param.mandatory
+
+          command_line += param_example(param)  
+
+          if param.allows_multiple_values then
+            command_line += " "
+            command_line += param_example(param, "2")
+            command_line += " ..."
+          end
+
+          command_line += "]" unless param.mandatory
+        end
+        puts command_line
+        puts "Description:"
+        puts "  #{command.description}"
+        if command.params.size > 0 then
+          puts "Parameters:"
+          command.params.sort { |a,b| a.name <=> b.name }.each do |param|
+            puts sprintf("  %-20s %s\n", param.name, param.description)
+          end
+       end
+       puts ""
+      else
+        puts "The following commands are available:"
+        @command_broker.get_command_list.values.sort { |a,b| a.name <=> b.name }.each do |command|
+          # TODO calculate the maximum command name length dynamically
+          # TODO and allow for multiple lines of description (check if it's an array?)
+          puts sprintf("  %-40s %s\n", command.name, command.description)
+        end
+        puts ""
+        puts "Type help <command name> for detailed information about a command."
+      end          
+    }
+    ).add_param(RHCP::CommandParam.new("command", "the name of the command to display help for", 
+        { 
+          :mandatory => false,
+          :is_default_param => true,
+          :lookup_method => lambda {
+            @command_broker.get_command_list.values.map { |c| c.name }
+          }
+        }
+    )
+  )
+  command.result_hints[:display_type] = "hidden"
+  broker.register_command command
+end      

data/lib/local_commands/set_prompt.rb

@@ -0,0 +1,17 @@
+def add_set_prompt_command(broker, shell_backend)
+
+  command = RHCP::Command.new("set_prompt", "changes the current prompt",
+    lambda { |req,res| 
+      res.set_context("prompt" => req.get_param_value("new_prompt"))      
+    }
+    ).add_param(RHCP::CommandParam.new("new_prompt", "the new prompt that should be used from now on",
+      {
+        :is_default_param => true,
+        :mandatory => true            
+      }
+    )
+  )
+  command.result_hints[:display_type] = "hidden"
+  broker.register_command command
+  
+end  

data/lib/rhcp_shell_backend.rb

@@ -1,7 +1,16 @@
 require 'shell_backend.rb'
 
+require 'local_commands/help'
+require 'local_commands/detail'
+require 'local_commands/exit'
+require 'local_commands/context'
+require 'local_commands/set_prompt'
+
+require 'display_types/table'
+
 require 'rubygems'
 require 'rhcp'
+require 'rhcp/memcached_broker'
 
 # This shell presents RHCP commands to the user and handles all the parameter
 # lookup, validation and command completion stuff
@@ -18,132 +27,44 @@ class RHCPShellBackend < ShellBackend
   # TODO refactor this monstrosity
 
   attr_reader :last_response
-  attr_reader :prompt
   attr_accessor :banner
+
+  attr_reader :command_broker
+  attr_accessor :lookup_broker    
   
-  def initialize(command_broker)
+  def initialize(command_broker, options = {})
     super()
-    
+
     local_broker = setup_local_broker
-    @command_broker = RHCP::DispatchingBroker.new()
-    @command_broker.add_broker(command_broker)
-    @command_broker.add_broker(local_broker)
+    dispatcher = RHCP::DispatchingBroker.new()
+    dispatcher.add_broker(command_broker)
+    dispatcher.add_broker(local_broker)
+
+    @command_broker = RHCP::Client::ContextAwareBroker.new(dispatcher)
+    @lookup_broker = @command_broker    
+
+    @lookup_cache = {}
+    
+    @current_prompt = nil
+    
+    @prompt_color_enabled = options.has_key?(:color_prompt) ?
+      options[:color_prompt] : false
     
     reset_to_command_mode
-  end   
+  end
+  
+  def wrap_lookup_broker
+    @lookup_broker = RHCP::MemcachedBroker.new(@lookup_broker)
+  end
   
   def setup_local_broker    
     broker = RHCP::Broker.new()
     begin
-      broker.register_command RHCP::Command.new("exit", "closes the shell", 
-        lambda { |req,res| 
-          puts "Have a nice day"
-          Kernel.exit(0)
-        }
-      )
-      
-      def param_example(param, suffix = "")
-        result = ""
-        result += "<" if param.is_default_param
-
-        if param.is_default_param then
-          result += "#{param.name}#{suffix}"
-        else
-          result += "#{param.name}"
-          result += "=<value#{suffix}>"
-        end
-
-        result += ">" if param.is_default_param
-        result
-      end
-            
-      command = RHCP::Command.new("help", "displays help about this shell",
-        lambda { 
-          |req,res|
-            
-          if (req.has_param_value("command"))
-            command_name = req.get_param_value("command")
-            puts "Syntax:"
-            command_line = "  #{command_name}"
-            command = @command_broker.get_command(command_name)
-
-            command.params.values.sort { |a,b| a.name <=> b.name }.each do |param|
-              command_line += " "
-              command_line += "[" unless param.mandatory
-
-              command_line += param_example(param)  
-
-              if param.allows_multiple_values then
-                command_line += ", "
-                command_line += param_example(param, "2")
-                command_line += ", ..."
-              end
-
-              command_line += "]" unless param.mandatory
-            end
-            puts command_line
-            puts "Description:"
-            puts "  #{command.description}"
-            if command.params.size > 0 then
-              puts "Parameters:"
-              command.params.values.sort { |a,b| a.name <=> b.name }.each do |param|
-                puts sprintf("  %-20s %s\n", param.name, param.description)
-              end
-           end
-           puts ""
-          else
-            puts "The following commands are available:"
-            @command_broker.get_command_list.values.sort { |a,b| a.name <=> b.name }.each do |command|
-              # TODO calculate the maximum command name length dynamically
-              puts sprintf("  %-40s %s\n", command.name, command.description)
-            end
-            puts ""
-            puts "Type help <command name> for detailed information about a command."
-          end          
-        }
-        ).add_param(RHCP::CommandParam.new("command", "the name of the command to display help for", 
-            { 
-              :mandatory => false,
-              :is_default_param => true,
-              :lookup_method => lambda {
-                @command_broker.get_command_list.values.map { |c| c.name }
-              }
-            }
-        )
-      )
-      command.result_hints[:display_type] = "hidden"
-      broker.register_command command
-      
-      command = RHCP::Command.new("detail", "shows details about a single record of the last response\n" + (" " * 43)  + "(makes sense if you executed a command that returned a table)",
-        lambda { |req,res| 
-          if @last_response == nil
-            puts "did not find any old response data...is it possible that you did not execute a command yet that returned a table?"
-            return
-          end
-          row_count = @last_response.data.length
-          begin
-            row_index = req.get_param_value("row_index").to_i
-            raise "invalid index" if (row_index < 1 || row_index > row_count)
-          rescue
-            puts "invalid row index - please specify a number between 1 and #{row_count}"  
-            return
-          end
-          puts "displaying details about row \# #{row_index}"          
-          @last_response.data[row_index - 1].each do |k,v|
-            puts "  #{k}\t#{v}"
-          end
-
-        }
-        ).add_param(RHCP::CommandParam.new("row_index", "the index of the row you want to see details about",
-          {
-            :is_default_param => true,
-            :mandatory => true            
-          }
-        )
-      )
-      command.result_hints[:display_type] = "hidden"
-      broker.register_command command
-      
+      add_exit_command(broker)
+      add_help_commands(broker)
+      add_detail_command(broker)
+      add_context_commands(broker, @command_broker)
+      add_set_prompt_command(broker, self)
     rescue RHCP::RhcpException => ex
       # TODO do we really want to catch this here?
       raise ex unless /duplicate command name/ =~ ex.to_s
@@ -152,8 +73,6 @@ class RHCPShellBackend < ShellBackend
   end
   
   def reset_to_command_mode
-    set_prompt nil
-    
     # 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
@@ -164,7 +83,8 @@ class RHCPShellBackend < ShellBackend
     
     # 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_params = Hash.new
+    @collected_values = {}
+
     
     # the mandatory params that are still missing (valid in parameter mode only) 
     @missing_params = Array.new    
@@ -175,13 +95,13 @@ class RHCPShellBackend < ShellBackend
   
   def execute_command_if_possible
     # check if we got all mandatory params now
-    mandatory_params = @command_selected.params.select { |name,param| param.mandatory }.map { |k,v| v }
-    @missing_params = mandatory_params.select { |p| ! @collected_params.include? p.name }
+    mandatory_params = @command_broker.get_mandatory_params(@command_selected.name)
+    #mandatory_params = @command_selected.get_mandatory_params()
+    @missing_params = mandatory_params.select { |p| ! @collected_values.include? p.name }
     
     if (@missing_params.size > 0) then
       $logger.debug "got #{@missing_params.size} missing params : #{@missing_params.map{|param| param.name}}"    
       @current_param = @missing_params[0]
-      set_prompt "#{@command_selected.name}.#{@current_param.name}"
     else 
       execute_command
     end
@@ -199,7 +119,7 @@ class RHCPShellBackend < ShellBackend
       # convert "*" into regexp notation ".*"
       regex_str = new_value.gsub(/\*/, '.*')
 
-      # handle ranges (x..y)
+      # handle ranges (42..45)
       result = /(.+?)(\d+)(\.{2})(\d+)(.*)/.match(regex_str)
       ranged_regex = nil
       if result then
@@ -214,7 +134,7 @@ class RHCPShellBackend < ShellBackend
           end
         end
       else
-        ranged_regex = Regexp.new(regex_str)  
+        ranged_regex = Regexp.new('^' + regex_str + '$')
       end
 
       $logger.debug "wildcard regexp : #{ranged_regex}"
@@ -222,7 +142,9 @@ class RHCPShellBackend < ShellBackend
       re = ranged_regex
 
       # get lookup values, filter and return them
-      lookup_values = @current_param.get_lookup_values()
+      request = RHCP::Request.new(@command_selected, @collected_values)
+      lookup_values = @command_broker.get_lookup_values(request, @current_param.name )
+      #lookup_values = @current_param.get_lookup_values()
       lookup_values.select { |lookup_value| re.match(lookup_value) }
     else
       [ new_value ]
@@ -234,137 +156,43 @@ class RHCPShellBackend < ShellBackend
   # returns the values that have been added (might be more than 'new_value' when wildcards are used)
   def add_parameter_value(new_value)
     # pre-process the value if necessary
-    processed_param_values = pre_process_param_value(new_value)
+    # TODO reactivate wildcard checking (too expensive right now and we aren't using it)
+    #processed_param_values = pre_process_param_value(new_value)
+    processed_param_values = [ new_value ]
+
     # TODO this check is already part of check_param_is_valid (which is called later in this method and when the request is created) - we do not want to check this three times...?
     if processed_param_values.size == 0
       raise RHCP::RhcpException.new("invalid value '#{new_value}' for parameter '#{@current_param.name}'")
     end
-    #processed_param_values = [ new_value ]
+    
     processed_param_values.each do |value|
-      # TODO we need to pass a value array here, and we should include the already selected param values
-      @current_param.check_param_is_valid([ value ])
+      request = RHCP::Request.new(@command_selected, @collected_values)
+      @command_broker.check_param_is_valid(request, @current_param.name, [ value ])
       $logger.debug "accepted value #{value} for param #{@current_param.name}"
 
-      @collected_params[@current_param.name] = Array.new if @collected_params[@current_param.name] == nil
-      @collected_params[@current_param.name] << value      
+      @collected_values[@current_param.name] = Array.new if @collected_values[@current_param.name] == nil
+      @collected_values[@current_param.name] << value
     end
     processed_param_values
   end
   
-  def print_cell(col_name, the_value)
-    result = "| "
-    result += the_value.to_s
-    1.upto(@max_width[col_name] - the_value.to_s.length) { |i| 
-      result += " " 
-    }
-    result += " "
-    result
-  end
-  
-  def print_line
-    result = ""
-    @total_width.times { |i| result += "-" }
-    result += "\n"
-    result
-  end
-  
   def execute_command
     begin
-      command = @command_broker.get_command(@command_selected.name)      
-      request = RHCP::Request.new(command, @collected_params)
-      response = command.execute_request(request)      
-      @last_response = response  # we might want to access this response in further commands
+      $logger.debug("(ShellBackend) gonna execute command '#{@command_selected.name}' on broker '#{@command_broker}'")
+      command = @command_broker.get_command(@command_selected.name)
+      request = RHCP::Request.new(command, @collected_values)
+      response = @command_broker.execute(request)
+
+      # we might want to access this response in further commands
+      @last_response = response
+
       if (response.status == RHCP::Response::Status::OK)
+        
         $logger.debug "raw result : #{response.data}"
-         $logger.debug "result hints: #{command.result_hints}"
+        $logger.debug "result hints: #{command.result_hints}"
         $logger.debug "display_type : #{command.result_hints[:display_type]}"
         if command.result_hints[:display_type] == "table"
-          # TODO make sure that the response really holds the correct data types and that we've got at least one column
-          # TODO check that all columns in overview_columns are valid
-          # TODO check that all columns in column_titles are valid and match overview_columns
-          output = ""         
-          
-          # let's find out which columns we want to display
-          $logger.debug "overview columns : #{command.result_hints[:overview_columns]}"
-          # TODO this will probably fail if no overview_columns are specified
-          columns_to_display = command.result_hints.has_key?(:overview_columns) ?
-            command.result_hints[:overview_columns].clone() :
-            # by default, we'll display all columns, sorted alphabetically
-            columns_to_display = response.data[0].keys.sort
-          
-          # and which titles they should have (default : column names)
-          $logger.debug "column titles : #{command.result_hints[:column_titles].length}"
-          column_title_list = command.result_hints[:column_titles].length > 0 ?
-            command.result_hints[:column_titles].clone() :
-            column_title_list = columns_to_display
-          $logger.debug "column title list : #{column_title_list}"
-          
-          # TODO the sorting column should be configurable
-          first_column = columns_to_display[0]
-          $logger.debug "sorting by #{first_column}"
-          response.data = response.data.sort { |a,b| a[first_column] <=> b[first_column] }          
-          
-          # add the index column
-          columns_to_display.unshift "__idx"
-          column_title_list.unshift "\#"
-          count = 1
-          response.data.each do |row|
-            row["__idx"] = count
-            count = count+1
-          end
-          
-          column_titles = {}
-          0.upto(column_title_list.length - 1) do |i|
-            column_titles[columns_to_display[i]] = column_title_list[i]
-          end
-          $logger.debug "column titles : #{column_titles}"
-          
-          # initialize the max_width for all columns
-          @max_width = {}
-          column_titles.each do |key, value|
-            @max_width[key] = 0
-          end
-          # find the maximum column width for each column
-          response.data.each do |row|
-            row.each do |k,v|
-              if ! @max_width.has_key?(k) || v.to_s.length >  @max_width[k]
-                @max_width[k] = v.to_s.length
-              end
-            end
-          end
-          
-          # check the column_title for max width
-          columns_to_display.each do |col_name|
-            if column_titles[col_name].length > @max_width[col_name]
-              @max_width[col_name] = column_titles[col_name].length
-            end
-          end
-          #@max_width["row_count"] = response.data.length.to_s.length
-          $logger.debug "max width : #{@max_width}"
-          
-          # and build headers
-          @total_width = 2 + columns_to_display.length-1 # separators at front and end of table and between the values
-          columns_to_display.each do |col|
-            @total_width += @max_width[col] + 2 # each column has a space in front and behind the value
-          end
-          output += print_line
-          
-          columns_to_display.each do |col|
-            output += print_cell(col, column_titles[col])
-          end
-          output += "|\n"
-
-          output += print_line
-          
-          # print the table values
-          response.data.each do |row|            
-            columns_to_display.each do |col|
-              output += print_cell(col, row[col])
-            end
-            output += "|\n"
-          end
-          output += print_line
-          
+          output = format_table_output(command, response)
           puts output
         elsif command.result_hints[:display_type] == "list"
           output = ""
@@ -375,16 +203,35 @@ class RHCPShellBackend < ShellBackend
         elsif command.result_hints[:display_type] == "hidden"
           $logger.debug "suppressing output due to display_type 'hidden'"
         else
-          puts "executed '#{@command_selected.name}' successfully : #{response.data}"
+          puts "executed '#{@command_selected.name}' successfully : #{@prompt_color_enabled ? green(response.data) : response.data}"
+        end
+        
+        # if the command has been executed successfully, we might have to update the prompt
+        if @command_broker.context.cookies.has_key?('prompt')
+          set_prompt @command_broker.context.cookies['prompt']
         end
+        
       else
-        puts "could not execute '#{@command_selected.name}' : #{response.error_text}"
+        if @command_selected.name == 'exit'
+          $logger.debug "exiting on user request"
+          Kernel.exit(0)
+        end
+        
+        puts "could not execute '#{@command_selected.name}' : #{@prompt_color_enabled ? red(response.error_text) : response.error_text}"
         $logger.error "#{response.error_text} : #{response.error_detail}"
+        
+        set_prompt nil
       end
       reset_to_command_mode
     rescue
-      puts "got an error : #{$!}"
-      raise
+      error = $!
+      if (error == "exit")
+        puts "exiting"
+        Kernel.exit
+      else
+        puts "got an error : >>#{$!}<<"
+        raise
+      end
     end
   end  
   
@@ -393,107 +240,103 @@ class RHCPShellBackend < ShellBackend
   def process_input(command_line)
     $logger.debug "processing input '#{command_line}'"
     
-    if (@command_selected) then
-      # 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 selecting an empty string as value
-      if (@current_param.allows_multiple_values and command_line == "") then
-        $logger.debug "finished multiple parameter input mode for param #{@current_param.name}"
-        @missing_params.shift        
-        execute_command_if_possible
-      else       
-        accepted_params = add_parameter_value(command_line)
-        if accepted_params
-          # stop asking for more values if
-          # a) the parameter does not allow more than one value
-          # b) the user entered a wildcard parameter that has been expanded to multiple values
-          if (! @current_param.allows_multiple_values or accepted_params.length > 1) then
-            $logger.debug "finished parameter input mode for param #{@current_param.name}"
-            @missing_params.shift        
-            execute_command_if_possible
-          else
-            $logger.debug "param '#{@current_param.name}' expects multiple values...deferring mode switching"
+    # we might have to setup the context aware broker for this thread
+    Thread.current['broker'] = @command_broker
+    
+    begin
+      if (@command_selected) then
+        # 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 selecting an empty string as value
+        if (@current_param.allows_multiple_values and command_line == "") then
+          $logger.debug "finished multiple parameter input mode for param #{@current_param.name}"
+          @missing_params.shift        
+          execute_command_if_possible
+        else       
+          accepted_params = add_parameter_value(command_line)
+          if accepted_params
+            # stop asking for more values if
+            # a) the parameter does not allow more than one value
+            # b) the user entered a wildcard parameter that has been expanded to multiple values
+            if (! @current_param.allows_multiple_values or accepted_params.length > 1) then
+              $logger.debug "finished parameter input mode for param #{@current_param.name}"
+              @missing_params.shift        
+              execute_command_if_possible
+            else
+              $logger.debug "param '#{@current_param.name}' expects multiple values...deferring mode switching"
+            end
           end
         end
-      end
-    else
-      # we're waiting for the user to enter a command
-      # we might have a command with params
-      command, *params = command_line.split
-      $logger.debug "got command '#{command}' (params: #{params})"
-
-      # remember what the user specified so far
-      begin
-        @command_selected = @command_broker.get_command(command)
-        #if (@command_selected != nil) then
-        $logger.debug "command_selected: #{@command_selected}"
-          
-        # apply the preset param values to this new command
-        # TODO reactivate parameter presets        
-#        @command_broker.get_global_parameter_presets().each do |name, values|
-#          # check if the selected command needs this param
-#          @current_param = @command_broker.get_param(command, name)
-#          if @current_param and not @current_param.ignore_global_presets then
-#            $logger.debug "presetting global parameter '#{name}' to '#{values}'"
-#            values.each do |value|
-#              add_parameter_value(value)
-#            end
-#          end
-#        end
-        
-        # process the params specified on the command line          
-        if (params != nil) then            
-          params.each do |param|
-            if param =~ /(.+?)=(.+)/ then
-              # --> named param
-              key = $1
-              value = $2
-            else
-              # TODO if there's only one param, we can always use this as default param (maybe do this in the command?)
-              # --> unnamed param
-              value = param
-              default_param = @command_selected.default_param
-              if default_param != nil then
-                key = default_param.name
-                $logger.debug "collecting value '#{value}' for default param '#{default_param.name}'"
+      else
+        # we're waiting for the user to enter a command
+        # we might have a command with params
+        command, *params = command_line.split
+        $logger.debug "got command '#{command}' (params: #{params})"
+  
+        # remember what the user specified so far
+        begin
+          @command_selected = @command_broker.get_command(command)
+          #if (@command_selected != nil) then
+          $logger.debug "command_selected: #{@command_selected}"
+            
+          # process the params specified on the command line          
+          if (params != nil) then            
+            params.each do |param|
+              if param =~ /(.+?)=(.+)/ then
+                # --> named param
+                key = $1
+                value = $2
               else
-                $logger.info "ignoring param '#{value}' because there's no default param"
+                # TODO if there's only one param, we can always use this as default param (maybe do this in the command?)
+                # --> unnamed param
+                value = param
+                default_param = @command_selected.default_param
+                if default_param != nil then
+                  key = default_param.name
+                  $logger.debug "collecting value '#{value}' for default param '#{default_param.name}'"
+                else
+                  $logger.info "ignoring param '#{value}' because there's no default param"
+                end
               end
-            end
-
-            if key then
-              begin
-                @current_param = @command_selected.get_param(key)
-                add_parameter_value(value)
-              rescue RHCP::RhcpException => ex
-                puts ex.to_s
+  
+              if key then
+                begin
+                  @current_param = @command_selected.get_param(key)
+                  add_parameter_value(value)
+                rescue RHCP::RhcpException => ex
+                  puts "ignoring parameter value '#{value}' for param '#{key}' : " + ex.to_s
+                end
               end
             end
           end
+                      
+          $logger.debug "selected command #{@command_selected.name}" 
+          execute_command_if_possible
+        rescue RHCP::RhcpException => ex
+          puts "#{ex}"
+          reset_to_command_mode
         end
-                    
-        $logger.debug "selected command #{@command_selected.name}" 
-        execute_command_if_possible
-      rescue RHCP::RhcpException => ex
-        puts "#{ex}"
       end
+    rescue RHCP::RhcpException => ex
+      $logger.error ex
+      puts "exception raised: #{ex.to_s}"
+      reset_to_command_mode
     end
- rescue => err
-   $logger.error err
-    puts "exception raised: #{err.to_s}"
   end
   
   def complete(word = "")
-    $logger.debug "collection completion values for '#{word}'"
+    $logger.debug "collecting completion values for '#{word}'"
+    
+    Thread.current['broker'] = @command_broker
 
     if (@command_selected) then
-      # TODO include partial_value here?
-      props = @command_selected.params[@current_param.name].get_lookup_values()
-      #props = @command_broker.get_lookup_values(@command_selected.name, @current_param.name)
+      $logger.debug("asking for lookup values for command '#{@command_selected.name}' and param '#{@current_param.name}'")
+      request = RHCP::Request.new(@command_selected, @collected_values, @command_broker.context)
+      props = @lookup_broker.get_lookup_values(request, @current_param.name)
     else
-      props = @command_broker.get_command_list.values.map{|command| command.name}.sort
+      props = @lookup_broker.get_command_list(@command_broker.context).values.map{|command| command.name}.sort
     end
     
     proposal_list = props.map { |p| "'#{p}'" }.join(" ")
@@ -503,12 +346,23 @@ class RHCPShellBackend < ShellBackend
     props.select{|name|name[0...(prefix.size)] == prefix}
   end
   
-def show_banner
+  def show_banner
     puts @banner
   end
   
+  require 'util/colorize'
+  
+  def prompt
+    if @current_param != nil
+      "#{@command_selected.name}.#{@current_param.name} $ "
+    else    
+      @current_prompt || "$ "
+      #"#{@current_prompt and @current_prompt != '' ? @current_prompt + " " : ""}$ "
+    end
+  end
+  
   def set_prompt(string)
-    @prompt = "#{string ? string + " " : ""}$ "
+    @current_prompt = string    
   end
   
   def process_ctrl_c

data/lib/util/colorize.rb

@@ -0,0 +1,15 @@
+def colorize(text, color_code)
+  "\e[#{color_code}m#{text}\e[0m"
+end
+
+def red(text)
+  colorize(text, 31)
+end
+
+def green(text)
+  colorize(text, 32)
+end
+
+# Actual example
+#puts 'Importing categories [ ' + green('DONE') + ' ]'
+#puts 'Importing tags       [' + red('FAILED') + ']'

data/lib/version.rb

@@ -4,8 +4,8 @@ module RhcpShell #:nodoc:
     include Singleton
 
     MAJOR = 0
-    MINOR = 0
-    TINY  = 9
+    MINOR = 2
+    TINY  = 11
 
     def Version.to_s
       [ MAJOR, MINOR, TINY ].join(".")

data/test/rhcp_shell_backend_test.rb

@@ -50,7 +50,7 @@ class RhcpShellBackendTest < Test::Unit::TestCase
   
   def setup
     # set up a local broker that we'll use for testing
-    # TODO do something about this - it shouldn't be necessary to instantiate this beforehand
+    # TODO do something about this - it shouldn't be necessary to instantiate the logger beforehand
     $logger = Logger.new($stdout)
     @log = Array.new()
     @backend = BackendMock.new($broker, self.method(:add_to_log))
@@ -127,6 +127,8 @@ class RhcpShellBackendTest < Test::Unit::TestCase
     commands << "help"
     commands << "exit"
     commands << "detail"
+    commands << "show_context"
+    commands << "set_prompt"
     assert_equal commands.sort, @backend.complete.sort
     assert_no_error
   end
@@ -138,7 +140,7 @@ class RhcpShellBackendTest < Test::Unit::TestCase
   
   def test_invalid_param_value
     @backend.process_input "reverse input=bla"
-    assert_received [ "invalid value 'bla' for parameter 'input'" ]
+    assert_received [ "ignoring parameter value 'bla' for param 'input' : invalid value 'bla' for parameter 'input'" ]
   end
   
   def test_multi_params
@@ -164,24 +166,25 @@ class RhcpShellBackendTest < Test::Unit::TestCase
     @backend.process_input "perpetuum_mobile"
     assert_received [ "could not execute 'perpetuum_mobile' : don't know how to do this" ]
   end
-  
-  def test_wildcard_support
-    @backend.process_input "cook ingredient=m*"
-    assert_received [ "executed 'cook' successfully : mascarpone marzipan" ]
-  end
-  
+
   def test_preprocess_without_lookup_values
     @backend.process_input "test thoroughly=yes"
     assert_no_error
   end
-  
-  def test_wildcard_ranges
-    @backend.process_input "echo input=string01..05"
-    assert_received [ "executed 'echo' successfully : string01 string02 string03 string04 string05" ]
-    
-    @backend.process_input "echo input=string17..20"
-    assert_received [ "executed 'echo' successfully : string17 string18 string19 string20" ]
-  end    
+
+# TODO reactivate wildcards
+#  def test_wildcard_support
+#    @backend.process_input "cook ingredient=m*"
+#    assert_received [ "executed 'cook' successfully : mascarpone marzipan" ]
+#  end
+#
+#  def test_wildcard_ranges
+#    @backend.process_input "echo input=string01..05"
+#    assert_received [ "executed 'echo' successfully : string01 string02 string03 string04 string05" ]
+#
+#    @backend.process_input "echo input=string17..20"
+#    assert_received [ "executed 'echo' successfully : string17 string18 string19 string20" ]
+#  end
   
   def test_help
     @backend.process_input "help"
@@ -196,7 +199,7 @@ class RhcpShellBackendTest < Test::Unit::TestCase
     @backend.process_input "help cook"
     puts "LOG >>#{@log}<<"
     assert_log_contains "Syntax:"
-    assert_log_contains "cook ingredient=<value>, ingredient=<value2>, ..."
+    assert_log_contains "cook ingredient=<value> ingredient=<value2> ..."
   end
   
   def test_help_with_default_param
@@ -267,5 +270,39 @@ class RhcpShellBackendTest < Test::Unit::TestCase
 #  ./virtualop_rhcp.rb:131:in `setup_local_shell'
 #  ./virtualop_rhcp.rb:168
 #  exception raised: comparison of Fixnum with nil failed
+
+  # say_hello should be workable with normal parameters
+  def test_context_handling_normal_parameter
+    @backend.command_broker.context.cookies.clear
+    @backend.process_input "say_hello the_host=zaphod"
+    assert_received [ "executed 'say_hello' successfully : hello from zaphod" ]
+  end
+
+  def test_command_completion_with_context
+    # we should not see let_explode_host, but both say_hello and switch_host
+    assert @backend.complete.select { |command| command == "say_hello" }.size() > 0
+    assert @backend.complete.select { |command| command == "switch_host" }.size() > 0
+    assert @backend.complete.select { |command| command == "let_explode_host" }.size() == 0
+
+    # test if this changes with context
+    @backend.process_input "switch_host new_host=serenity"
+    assert @backend.complete.select { |command| command == "let_explode_host" }.size() > 0
+  end
+
+  def test_context_handling
+    # context values should be usable by commands
+    @backend.process_input "switch_host new_host=serenity"
+    #@backend.context['host'] = 'serenity'
+    @backend.process_input "say_hello"
+    assert_received [ "executed 'say_hello' successfully : hello from serenity" ]
+  end
+
+  def test_command_setting_context
+    @backend.process_input "switch_host new_host=moon"
+    @backend.process_input "say_hello"
+    assert_received [ "executed 'switch_host' successfully : hostmoon",
+                      "executed 'say_hello' successfully : hello from moon" ]
+  end
+
   
 end

data/test/setup_test_registry.rb

@@ -112,4 +112,40 @@ broker.register_command command2
 
 p broker.get_command("build_a_table")
 
+
+switch_host = RHCP::Command.new("switch_host", "modifies the context",
+  lambda { |request, response|
+    response.set_context({'host' => request.get_param_value('new_host')})
+  }
+)
+switch_host.add_param(RHCP::CommandParam.new("new_host", "the new host name",
+    {
+      :mandatory => true,
+      :is_default_param => true,
+    }
+))
+broker.register_command switch_host
+
+host_command = RHCP::Command.new("say_hello", "uses context",
+  lambda { |request, response|
+    "hello from " + request.get_param_value('the_host')
+  }
+)
+host_command.add_param(RHCP::CommandParam.new("the_host", "the host name (should be taken from context)",
+    {
+      :mandatory => true,
+      :is_default_param => true,
+      :autofill_context_key => 'host'
+    }
+))
+broker.register_command host_command
+
+context_command = RHCP::Command.new("let_explode_host", "available only in host context",
+  lambda { |request, response|
+    "kaboom."
+  }
+)
+context_command.enabled_through_context_keys = ['host']
+broker.register_command context_command
+
 $broker = broker

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rhcp_shell
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  hash: 1
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 11
+  version: 0.2.11
 platform: ruby
 authors: 
 - Philipp Traeder
@@ -9,19 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-15 00:00:00 +02:00
+date: 2011-07-26 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rhcp
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 0
+        - 1
+        - 9
         version: 0.1.9
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: philipp at hitchhackers.net
 executables: 
@@ -31,39 +43,55 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- bin/rhcp_shell.log
 - bin/rhcp_shell
+- lib/util/colorize.rb
 - lib/shell_backend.rb
+- lib/version.rb
+- lib/rhcp_shell_backend.rb
 - lib/base_shell.rb
+- lib/display_types/table.rb
 - lib/test.log
-- lib/rhcp_shell_backend.rb
-- lib/version.rb
-- test/rhcp_shell_backend_test.rb
+- lib/local_commands/context.rb
+- lib/local_commands/set_prompt.rb
+- lib/local_commands/help.rb
+- lib/local_commands/exit.rb
+- lib/local_commands/detail.rb
 - test/setup_test_registry.rb
+- test/rhcp_shell_backend_test.rb
 has_rdoc: true
 homepage: http://rubyforge.org/projects/rhcp
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: rhcp
-rubygems_version: 1.3.1
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: RHCP is a protocol designed for building up a command-metadata-based communication infrastructure making it easier for application developers to export commands in applications to generic clients - this is the generic shell for it.
 test_files: []