torquebox-console 0.1.4 → 0.2.0

data/Gemfile

@@ -1,9 +1,7 @@
 source :rubygems
 
-gem "pry", "~>0.9.10"
-gem "torquebox", "~>2.0"
-gem "sinatra", "~>1.3.3"
-gem "haml", "~>3.1.7"
-gem "stomp", "~>1.2.6"
-gem "thor", "~>0.14.6"
+gemspec
 
+group :development do
+  gem "jruby-openssl"
+end

data/README.md

@@ -16,3 +16,18 @@ First deploy to a TorqueBox server.
 Then you can connect with a web browser at
 `http://<servername>:<portnumber>/console`, or on the command line with
 `tbconsole connect`.
+
+To list and connect to other running applications, use the commands:
+
+    list_applications
+    list_runtimes
+    switch_application(app)
+    switch_runtime(app, runtime)
+
+The `switch_application` command is just a shortcut for
+`switch_runtime(app, 'web')` since the web runtime is the most
+commonly used.
+
+The console, especially runtime switching, is still pretty
+experimental so don't go doing anything crazy with it in a production
+environment.

data/TODO

@@ -1,5 +1,4 @@
 * Destroy queues on disconnect
-* Figure out how to attach to other runtimes
 * multi-line input 
 * Add auth if necessasry
 * Implement additional helper methods in Builtin, e.g. clear_cache
@@ -10,3 +9,4 @@
 * [done] Make web UI auto scroll
 * [done] Ensure the client unsubscribes
 * [done] escape angle brackets in the html
+* [done] Figure out how to attach to other runtimes

data/bin/tbconsole

@@ -25,51 +25,32 @@ class TorqueBoxConsoleCommand < Thor
 
   DEPLOYMENT_NAME = 'torquebox-console-knob.yml'
 
-  desc "deploy --dir=<deploy_dir> [--secure=username:password[,username:password]*]", 
-  <<-EOT
+  desc "deploy --dir=DIR", <<-EOT
 Writes the torquebox-console application to disk in the directory specified by 
---dir, and deploys the app to the TorqueBox instance specified by ENV['TORQUEBOX_HOME']
-(currently #{ENV['TORQUEBOX_HOME']}).
+--dir, and deploys the app to the TorqueBox instance detected on the local host,
+(currently #{TorqueBox::DeployUtils.torquebox_home}).
 
 If --dir is not provided, the torquebox-console app will be written to Dir.pwd/torquebox-console
 (currently #{Dir.pwd}/torquebox-console). 
-
 EOT
-  method_option :secure, :type => :hash, :default => nil
   method_option :dir, :type => :string, :default => "#{Dir.pwd}/torquebox-console"
   def deploy
     check
     deploy_dir = File.expand_path options[:dir]
     descriptor = TorqueBox::DeployUtils.basic_deployment_descriptor( :root => deploy_dir,
                                                                      :env => 'production' )
-    if options[:secure]
-      descriptor['environment']['REQUIRE_AUTHENTICATION'] = true
-      descriptor['auth'] = {'console' => {'domain'=>'torquebox-torquebox-console', 'credentials'=>{}}}
-      options[:secure].each do |user, pass|
-        descriptor['auth']['console']['credentials'][user] = pass
-      end
-      puts ">> Wrote user/password entries to TorqueBox::Console deployment descriptor"
-    else
-      puts ">> WARNING: deploying TorqueBox::Console with no security - use the --secure=username:password option to secure it"
-    end
-
-    unless File.exist?( deploy_dir )
-      puts ">> Creating torquebox-console app directory #{deploy_dir}."
-      Dir.mkdir( deploy_dir )
-    end
+    Dir.mkdir( deploy_dir ) unless File.exist?( deploy_dir )
     puts "Copying torquebox-console app to #{deploy_dir}"
     files = Dir.glob("#{root_dir}/*") - ["#{root_dir}/bin"]
-    FileUtils.cp_r( files, "#{deploy_dir}/", :verbose=>true )
+    FileUtils.cp_r( files, "#{deploy_dir}/" )
     name, dir = TorqueBox::DeployUtils.deploy_yaml( descriptor, :name => DEPLOYMENT_NAME )
-    puts ">> Deployed #{deploy_dir} as #{name} to #{dir}/#{name}"
+    puts ">> Deployed to #{dir}/#{name}"
   end
 
   desc "undeploy", "Undeploys TorqueBox::Console from the TorqueBox instance specified by $TORQUEBOX_HOME"
   def undeploy
     check
     name, dir = TorqueBox::DeployUtils.undeploy_yaml( :name => DEPLOYMENT_NAME )
-
-    puts ">> Undeployed #{name} from #{dir}" if name
   end
 
   desc "connect", "Runs the CLI console"
@@ -79,16 +60,13 @@ EOT
 
   protected
   def check
-    raise Exception.new("$TORQUEBOX_HOME must be set") unless ENV['TORQUEBOX_HOME']
+    if !TorqueBox::DeployUtils.torquebox_home
+      raise Exception.new("Can't find a local TorqueBox instance. Try setting TORQUEBOX_HOME.")
+    end
   end
 
   def root_dir
-    _root_dir_ = File.expand_path( File.join( File.dirname( __FILE__ ), '..' ) )
-    if _root_dir_ =~/\.rvm/
-      $stderr.puts "It looks like you're using RVM for your JRuby."
-      $stderr.puts "TorqueBox has some trouble with load paths with an '@'."
-    end
-    _root_dir_
+    File.expand_path( File.join( File.dirname( __FILE__ ), '..' ) )
   end
 end
 

data/console.rb

@@ -1,6 +1,28 @@
+require 'torquebox'
+require 'torquebox-stomp'
 require 'sinatra'
 require 'haml'
 
+class Sinatra::Application
+  include TorqueBox::Injectors
+end
+
+helpers do
+  def endpoint
+    unless @endpoint
+      @endpoint = fetch('stomp-endpoint')
+      # Workaround for https://issues.jboss.org/browse/TORQUE-957
+      if @endpoint =~ /default-host/
+        @endpoint.gsub!(/default-host/, "localhost")
+        @endpoint.gsub!(/\/console\/console/, "")
+      end
+      @endpoint
+    end
+    @endpoint
+  end
+end
+
 get '/' do
   haml :index, :format => :html5
 end
+

data/lib/torquebox/console/builtin.rb

@@ -12,32 +12,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'torquebox'
-
 module TorqueBox
   module Console
     module Builtin
       extend TorqueBox::Injectors
       class << self
-      def service_registry
-        @@service_registry ||= inject("service-registry")
+
+      # Simple placeholder methods - the stomplet is responsible
+      # for actually switching runtimes
+      def switch_application(app)
+        switch_runtime(app, 'web')
+      end
+      def switch_runtime(app, runtime)
+        [app, runtime]
       end
 
-      def list_runtimes
-        get_runtimes.each do |runtime| 
-          puts "Application: #{runtime[0]}"
-          puts "Pool: #{runtime[1]}"
-        end
+      def list_applications
+        list_runtimes.map { |runtimes| runtimes.first }.uniq
       end
 
-      def get_runtimes
-        service_registry.service_names.to_a.map { |x| parse_pool_name(x) }.reject(&:nil?)
+      def list_runtimes
+        service_registry = inject("service-registry")
+        service_registry.service_names.to_a.map { |x| parse_pool_name(x) }.
+          reject(&:nil?).map { |app, runtime, svc_name| [app, runtime] }.sort
       end
 
       def parse_pool_name(service_name)
         [$1, $3, service_name] if service_name.canonical_name =~
           /"(.*)(-knob\.yml|\.knob)"\.torquebox\.core\.runtime\.pool\.([^.]+)$/
       end
+
+      def create_block
+        Proc.new {}
+      end
       end
     end
   end

data/lib/torquebox/console/client.rb

@@ -22,12 +22,13 @@ module TorqueBox
       HOSTS   = [{:host => "localhost", :port => 8675}]
       PARAMS  = { :connect_headers => HEADERS, :hosts => HOSTS, :max_reconnect_attempts => -1 }
 
-      attr_accessor :client
+      attr_accessor :client, :closed
 
       def initialize
+        @closed = false
         @client = Stomp::Client.new( PARAMS )
       rescue Stomp::Error::MaxReconnectAttempts
-        puts "Can't connect to TorqueBox. Are you sure the server is running?"
+        puts "Cannot connect to TorqueBox. Are you sure the server is running?"
       end
 
       def self.connect
@@ -36,17 +37,36 @@ module TorqueBox
 
       def run
         if client
-          client.subscribe("/stomplet/console") do |msg| 
-            !msg.headers['prompt'] && puts(msg.body)
+          trap("INT") {
+            @closed = true
+            puts ""
+            puts "Disconnecting console, press enter to exit"
+          }
+          prompt = "TorqueBox> "
+          received_prompt = false
+          client.subscribe("/stomplet/console") do |msg|
+            if msg.headers['prompt']
+              prompt = msg.body
+              received_prompt = true
+            else
+              puts msg.body
+            end
           end
           # Since our messaging is async, sleep
           # before displaying the prompt
-          sleep 0.3
-          while(input = Readline.readline( "TorqueBox> ", true ))
-            client.publish("/stomplet/console", input)
-            sleep 0.3 # again with the async
+          while !received_prompt && !closed
+            sleep 0.05
+          end
+          while !closed && (input = Readline.readline( prompt, true ))
+            received_prompt = false
+            client.publish("/stomplet/console", input) unless closed
+            while !received_prompt && !closed
+              sleep 0.05 # again with the async
+            end
           end
           client.unsubscribe('/stomplet/console')
+          # Hide any errors printed after we've unsubscribed
+          $stderr.close
         end
       end
     end

data/lib/torquebox/console/server.rb

@@ -13,32 +13,26 @@
 # limitations under the License.
 
 require 'pry'
-require 'torquebox-stomp'
-require 'torquebox-cache'
-require 'torquebox-messaging'
 
 module TorqueBox
   module Console
     class Server
 
-      attr_accessor :input_queue, :output_queue, :console_id
+      attr_accessor :input_queue, :output_queue, :console_id, :application, :runtime
 
-      def initialize
-        @cache = TorqueBox::Infinispan::Cache.new(:name=>"torquebox-console")
-        @console_id = @cache.increment( "console" )
-
-        input_name = "/queues/torquebox-console/#{console_id}-input"
-        output_name = "/queues/torquebox-console/#{console_id}-output"
-
-        @input_queue = TorqueBox::Messaging::Queue.start( input_name, :durable => false )
-        @output_queue = TorqueBox::Messaging::Queue.start( output_name, :durable => false )
+      def initialize(console_id, input_queue, output_queue, application, runtime)
+        @console_id = console_id
+        @input_queue = input_queue
+        @output_queue = output_queue
+        @application = application
+        @runtime = runtime
       end
 
       def run( entry_point )
-        Thread.new do 
+        Thread.new do
           Pry.config.pager  = false
           #Pry.config.color  = false
-          Pry.config.prompt = proc { "TorqueBox> " }
+          Pry.config.prompt = proc { "TorqueBox (#{application}, #{runtime})> " }
           Pry.start entry_point, :input => self, :output => self
         end
       end
@@ -56,6 +50,11 @@ module TorqueBox
         output_queue.publish output.to_s
       end
 
+      def evaluate( code )
+        binding = TorqueBox::Console::Builtin.create_block.binding
+        eval( code, binding )
+      end
+
       # Pry (undocumented?) requires this
       def tty?
         false

data/lib/torquebox/console/version.rb

@@ -1,5 +1,5 @@
 module TorqueBox
   module Console
-    VERSION = "0.1.4"
+    VERSION = "0.2.0"
   end
 end

data/public/ansispan.js

@@ -13,7 +13,7 @@ var ansispan = function (str) {
     ).replace(
       new RegExp('\033\\[1;' + ansi + 'm', 'g'),
       '<span style="color: ' + ansispan.brightForegroundColors[ansi] + '">'
-    );
+    ).replace( new RegExp('\033\\[4m', 'g'), '<span style="text-decoration: underline">' );
   });
   //
   // `\033[1m` enables bold font, `\033[22m` disables it or \033[0m` resets
@@ -21,6 +21,7 @@ var ansispan = function (str) {
   str = str.replace(/\033\[1m/g, '<b>').replace(/\033\[22m/g, '</b>');
   str = str.replace(/\033\[1m/g, '<b>').replace(/\033\[0m/g, '</b>');
 
+
   //
   // `\033[3m` enables italics font, `\033[23m` disables it or \033[0m resets
   //

data/public/console.js

@@ -1,5 +1,14 @@
 $().ready( function() {
-  client = Stomp.client( "ws://localhost:8675" )
+  if (endpoint == null) {
+    // endpoint should be set in index.haml
+    // value provided by torquebox injection
+    // but if for whatever reason that doesn't
+    // work, we'll try this
+    endpoint = "ws://localhost:8675" 
+  } else { 
+    alert( "Using: " + endpoint )
+  }
+  client = Stomp.client( endpoint )
 
   var display_message = function( message ) {
       elem = $("#console .content")

data/stomplets/torque_box_console.rb

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'torquebox-cache'
+require 'torquebox-messaging'
 require 'torquebox-stomp'
 require 'torquebox-console'
 
@@ -20,40 +22,129 @@ class TorqueBoxConsole < TorqueBox::Stomp::JmsStomplet
   def configure( options )
     super
     @servers = {}
+    @server_runtimes = {}
+    @cache = TorqueBox::Infinispan::Cache.new(:name=>"torquebox-console")
   end
 
   def on_message( message, session )
-    server = @servers[session["console_id"]]
-    if server
-      send_to( server.input_queue, message.content_as_string )
+    console_id = session["console_id"]
+    input = message.content_as_string
+    servers = @servers[console_id]
+    if servers
+      server = servers.last
+      # Intercept the switch runtime commands
+      if input =~ /^\s*(switch_application|switch_runtime)\s*\(.+\)$/
+        app, runtime = server.evaluate( input )
+        switch_runtime( app, runtime, console_id )
+        output_queue = TorqueBox::Messaging::Queue.new( output_name( console_id ) )
+        send_to( output_queue, "Switched to #{runtime} runtime of #{app} application" )
+      else
+        input_queue = TorqueBox::Messaging::Queue.new( server.input_queue.name )
+        send_to( input_queue, input )
+      end
     else
-      logger.error("No console found for the server #{server}") 
+      logger.error("No server found for console #{console_id}")
     end
   end
 
   def on_subscribe( subscriber )
-    # Create a new server that sends/receives on the queue
-    server = TorqueBox::Console::Server.new
+    console_id = @cache.increment( "console" )
+    output_queue = TorqueBox::Messaging::Queue.start( output_name( console_id ), :durable => false )
 
-    # Keep a reference to it around for a while
-    console_id = server.console_id
-    @servers[console_id] = server
-
-    # Make sure we can find the server using session
+    # Make sure we can find the console using session
     subscriber.session["console_id"] = console_id
     logger.info "Running TorqueBox console #{console_id}."
 
-    # Subscribe our stomplet connection to the server's queue 
-    subscribe_to( subscriber, server.output_queue )
-    server.run( TorqueBox::Console::Builtin )
+    # Subscribe our stomplet connection to the server's queue
+    subscribe_to( subscriber, output_queue )
+
+    # start the console against the current app
+    switch_runtime( ENV['TORQUEBOX_APP_NAME'], 'web', console_id )
   end
- 
+
   def on_unsubscribe( subscriber )
     session = subscriber.session
     logger.info "Closing TorqueBox console #{session["console_id"]}"
     @servers.delete( session["console_id"] )
   end
 
+  def output_name(console_id)
+    "/queues/torquebox-console/#{console_id}-output"
+  end
+
+  def switch_runtime(app, runtime, console_id)
+    runtime ||= 'web'
+    @server_runtimes[console_id] ||= {}
+    @server_runtimes[console_id][app] ||= {}
+    existing_server = @server_runtimes[console_id][app][runtime]
+    if existing_server
+      # shuffle the desired runtime to the current one
+      @servers[console_id] << @servers[console_id].delete( existing_server )
+      input_queue = TorqueBox::Messaging::Queue.new( existing_server.input_queue.name )
+      send_to( input_queue, "" )
+    else
+      pool = lookup_runtime( app, runtime )
+      dependencies = Gem::Specification.find_by_name('pry').runtime_dependencies.map(&:name)
+      dependencies << 'pry'
+      load_paths = $:.select do |path|
+        dependencies.any? { |dep| path.include?(dep) }
+      end
+      load_paths << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+      load_paths.each do |path|
+        pool.evaluate(%Q{$: << '#{path}' unless $:.include?('#{path}')})
+      end
+      pool.evaluate("require 'torquebox/console/server'")
+      pool.evaluate("require 'torquebox/console/builtin'")
+
+      server_id = Time.now.to_f.to_s
+      input_name = "/queues/torquebox-console/#{console_id}-#{server_id}-input"
+      output_name = output_name( console_id )
+
+      server = pool.evaluate( """
+        input_queue = TorqueBox::Messaging::Queue.start( '#{input_name}', :durable => false )
+        output_queue = TorqueBox::Messaging::Queue.new( '#{output_name}' )
+        server = TorqueBox::Console::Server.new( #{console_id}, input_queue, output_queue, '#{app}', '#{runtime}' )
+        server.run( TorqueBox::Console::Builtin )
+        server
+      """ )
+      @server_runtimes[console_id][app][runtime] = server
+      @servers[console_id] ||= []
+      @servers[console_id] << server
+    end
+  end
+
+  def web_runtime(app)
+    lookup_runtime(app, 'web')
+  end
+
+  def lookup_runtime(app, name)
+    service_registry = inject('service-registry')
+    service_name = nil
+
+    if app
+      _, _, service_name = list_runtimes.detect { |v| v[0] == app && v[1] == name }
+    else
+      unit = inject('deployment-unit')
+      service_name = org.torquebox.core.as.CoreServices.runtimePoolName(unit, name)
+    end
+
+    return nil unless service_name
+    service_controller = service_registry.get_service(service_name)
+    return nil unless service_controller
+    pool = service_controller.service.value
+    pool
+  end
+
+  def list_runtimes
+    service_registry = inject("service-registry")
+    service_registry.service_names.to_a.map { |x| parse_pool_name(x) }.reject(&:nil?)
+  end
+
+  def parse_pool_name(service_name)
+    [$1, $3, service_name] if service_name.canonical_name =~
+      /"(.*)(-knob\.yml|\.knob)"\.torquebox\.core\.runtime\.pool\.([^.]+)$/
+  end
+
   def logger
     @logger ||= TorqueBox::Logger.new( self )
   end

data/views/index.haml

@@ -1,6 +1,8 @@
 !!!
 %html
   %head
+    %script{  :type  => "text/javascript" }
+      = "var endpoint = '#{endpoint}'"
     %script{  :type  => "text/javascript", 
               :src   => "https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js" }
     %script{  :type  => "text/javascript", 

metadata

@@ -2,7 +2,7 @@
 name: torquebox-console
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
   - Lance Ball
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-16 00:00:00 Z
+date: 2012-12-04 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: pry
@@ -61,7 +61,7 @@ dependencies:
     version_requirements: &id005 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
-        - - ~>
+        - - ">="
           - !ruby/object:Gem::Version 
             version: 0.14.6
     requirement: *id005
@@ -134,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: TorqueBox Console - A REPL commandline and information viewer for TorqueBox