pbox 1.17.2

data/lib/rhc/commands/port_forward.rb

@@ -0,0 +1,197 @@
+require 'uri'
+
+module RHC::Commands
+  class ForwardingSpec
+    include RHC::Helpers
+    include Enumerable
+    # class to represent how SSH port forwarding should be performed
+    attr_accessor :port_from
+    attr_reader :remote_host, :port_to, :host_from, :service
+    attr_writer :bound
+
+    def initialize(service, remote_host, port_to, port_from = nil)
+      @service     = service
+      @remote_host = remote_host
+      @port_to     = port_to
+      @host_from   = '127.0.0.1'
+      @port_from   = port_from || port_to # match ports if possible
+      @bound       = false
+    end
+
+    def to_cmd_arg
+      # string to be used in a direct SSH command
+      "-L #{port_from}:#{remote_host}:#{port_to}"
+    end
+
+    def to_fwd_args
+      # array of arguments to be passed to Net::SSH::Service::Forward#local
+      [port_from.to_i, remote_host, port_to.to_i]
+    end
+
+    def bound?
+      @bound
+    end
+
+    # :nocov: These are for sorting. No need to test for coverage.
+    def <=>(other)
+      if bound? && !other.bound?
+        -1
+      elsif !bound? && other.bound?
+        1
+      else
+        order_by_attrs(other, :service, :remote_host, :port_from)
+      end
+    end
+
+    def order_by_attrs(other, *attrs)
+      # compare self and "other" by examining their "attrs" in order
+      # attrs should be an array of symbols to which self and "other"
+      # respond when sent.
+      while attribute = attrs.shift do
+        if self.send(attribute) != other.send(attribute)
+          return self.send(attribute) <=> other.send(attribute)
+        end
+      end
+      0
+    end
+    # :nocov:
+
+    private :order_by_attrs
+  end
+
+  class PortForward < Base
+
+    UP_TO_256 = /25[0-5]|2[0-4][0-9]|[01]?(?:[0-9][0-9]?)/
+    UP_TO_65535 = /6553[0-5]|655[0-2][0-9]|65[0-4][0-9][0-9]|6[0-4][0-9][0-9][0-9]|[0-5]?(?:[0-9][0-9]{0,3})/
+    # 'host' part is a bit lax; we rely on 'pbox-list-ports' to hand us a reasonable output
+    # about the host information, be it numeric or FQDN in IPv4 or IPv6.
+    HOST_AND_PORT = /(.+):(#{UP_TO_65535})\b/
+
+    summary "Forward remote ports to the workstation"
+    syntax "<application>"
+    takes_application :argument => true
+    option ["-g", "--gear ID"], "Gear ID you are port forwarding to (optional)"
+    def run(app)
+      rest_app = find_app
+      ssh_uri = URI.parse(options.gear ? rest_app.gear_ssh_url(options.gear) : rest_app.ssh_url)
+
+      say "Using #{ssh_uri}..." if options.debug
+
+      forwarding_specs = []
+
+      begin
+        say "Checking available ports ... "
+
+        Net::SSH.start(ssh_uri.host, ssh_uri.user) do |ssh|
+          # If a specific gear is targeted, do not include remote (e.g. database) ports
+          list_ports_cmd = "pbox-list-ports#{options.gear ? ' --exclude-remote' : ''}"
+          ssh.exec! list_ports_cmd do |channel, stream, data|
+            if stream == :stderr
+              data.each_line do |line|
+                line.chomp!
+                # FIXME: This is really brittle; there must be a better way
+                # for the server to tell us that permission (what permission?)
+                # is denied.
+                raise RHC::PermissionDeniedException.new "Permission denied." if line =~ /permission denied/i
+                # ...and also which services are available for the application
+                # for us to forward ports for.
+                if line =~ /\A\s*(\S+) -> #{HOST_AND_PORT}\z/
+                  debug fs = ForwardingSpec.new($1, $2, $3.to_i)
+                  forwarding_specs << fs
+                else
+                  debug line
+                end
+
+              end
+            end
+          end
+
+          if forwarding_specs.length == 0
+            # check if the gears have been stopped
+            if rest_app.gear_groups.all?{ |gg| gg.gears.all?{ |g| g["state"] == "stopped" } }
+              warn "none"
+              error "The application is stopped. Please restart the application and try again."
+              return 1
+            else
+              warn "none"
+              raise RHC::NoPortsToForwardException.new "There are no available ports to forward for this application. Your application may be stopped or idled."
+            end
+          end
+
+          success "done"
+
+          begin
+            Net::SSH.start(ssh_uri.host, ssh_uri.user) do |ssh|
+              say "Forwarding ports ..."
+              forwarding_specs.each do |fs|
+                given_up = nil
+                while !fs.bound? && !given_up
+                  begin
+                    args = fs.to_fwd_args
+                    debug args.inspect
+                    ssh.forward.local(*args)
+                    fs.bound = true
+                  rescue Errno::EADDRINUSE, Errno::EACCES => e
+                    warn "#{e} while forwarding port #{fs.port_from}. Trying local port #{fs.port_from+1}"
+                    fs.port_from += 1
+                  rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+                    given_up = true
+                  end
+                end
+              end
+
+              bound_ports = forwarding_specs.select(&:bound?)
+              if bound_ports.length > 0
+                paragraph{ say "To connect to a service running on ProtonBox, use the Local address" }
+                paragraph do
+                  say table(
+                        bound_ports.map do |fs|
+                          [fs.service, "#{fs.host_from}:#{fs.port_from}", " => ", "#{fs.remote_host}:#{fs.port_to.to_s}"]
+                        end,
+                        :header => ["Service", "Local", "    ", "ProtonBox"]
+                      )
+                end
+              end
+
+              # for failed port forwarding attempts
+              failed_port_forwards = forwarding_specs.select { |fs| !fs.bound? }
+              if failed_port_forwards.length > 0
+                ssh_cmd_arg = failed_port_forwards.map { |fs| fs.to_cmd_arg }.join(" ")
+                ssh_cmd = "ssh -N #{ssh_cmd_arg} #{ssh_uri.user}@#{ssh_uri.host}"
+                warn "Error forwarding some port(s). You can try to forward manually by running:\n#{ssh_cmd}"
+              else
+                say "Press CTRL-C to terminate port forwarding"
+              end
+
+              unless forwarding_specs.any?(&:bound?)
+                warn "No ports have been bound"
+                return
+              end
+              ssh.loop { true }
+            end
+          rescue Interrupt
+            say " Ending port forward"
+            return 0
+          end
+
+        end
+
+      rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+        ssh_cmd = ["ssh","-N"]
+        unbound_fs = forwarding_specs.select { |fs| !fs.bound? }
+        ssh_cmd += unbound_fs.map { |fs| fs.to_cmd_arg }
+        ssh_cmd += ["#{ssh_uri.user}@#{ssh_uri.host}"]
+        raise RHC::PortForwardFailedException.new("#{e.message + "\n" if options.debug}Error trying to forward ports. You can try to forward manually by running:\n" + ssh_cmd.join(" "))
+      end
+
+      0
+    rescue RHC::Rest::ConnectionException => e
+      error "Connection to #{protonbox_server} failed: #{e.message}"
+      1
+    end
+  end
+end
+
+# mock for windows
+if defined?(UNIXServer) != 'constant' or UNIXServer.class != Class then class UNIXServer; end; end
+

data/lib/rhc/commands/server.rb

@@ -0,0 +1,40 @@
+module RHC::Commands
+  class Server < Base
+    suppress_wizard
+
+    summary "Display information about the status of the ProtonBox service"
+    description <<-DESC
+      Retrieves any open issues or notices about the operation of the
+      ProtonBox service and displays them in the order they were opened.
+
+      When connected to an ProtonBox Enterprise server, will only display
+      the version of the API that it is connecting to.
+      DESC
+    def run
+      say "Connected to #{protonbox_server}"
+
+      if protonbox_online_server?
+        #status = decode_json(get("#{protonbox_url}/app/status/status.json").body)
+        status = rest_client.request(:method => :get, :url => "#{protonbox_url}/app/status/status.json", :lazy_auth => true){ |res| decode_json(res.content) }
+        open = status['open']
+
+        (success 'All systems running fine' and return 0) if open.blank?
+
+        open.each do |i|
+          i = i['issue']
+          say color("%-3s %s" % ["##{i['id']}", i['title']], :bold)
+          items = i['updates'].map{ |u| [u['description'], date(u['created_at'])] }
+          items.unshift ['Opened', date(i['created_at'])]
+          table(items, :align => [nil,:right], :join => '  ').each{ |s| say "    #{s}" }
+        end
+        say "\n"
+        warn pluralize(open.length, "open issue")
+
+        open.length #exit with the count of open items
+      else
+        success "Using API version #{rest_client.api_version_negotiated}"
+        0
+      end
+    end
+  end
+end

data/lib/rhc/commands/setup.rb

@@ -0,0 +1,60 @@
+require 'rhc/commands/base'
+require 'rhc/wizard'
+require 'rhc/config'
+
+module RHC::Commands
+  class Setup < Base
+    suppress_wizard
+
+    summary "Connects to ProtonBox and sets up your keys and domain"
+    description <<-DESC
+      Connects to an ProtonBox server to get you started. Will help you
+      configure your SSH keys, set up a domain, and check for any potential
+      problems with Git or SSH.
+
+      Any options you pass to the setup command will be stored in a
+      .protonbox/protonbox.conf file in your home directory. If you run
+      setup at a later time, any previous configuration will be reused.
+
+      Pass the --clean option to ignore your saved configuration and only
+      use options you pass on the command line. Pass --config FILE to use
+      default values from another config (the values will still be written
+      to .protonbox/protonbox.conf).
+
+      If the server supports authorization tokens, you may pass the
+      --create-token option to instruct the wizard to generate a key for you.
+
+      If you would like to enable tab-completion in Bash shells, pass
+      --autocomplete for more information.
+      DESC
+    option ["--server NAME"], "Hostname of the ProtonBox server", :default => :server_context, :required => true
+    option ['--clean'], "Ignore any saved configuration options"
+    option ['--[no-]create-token'], "Create an authorization token for this server"
+    option ['--autocomplete'], "Instructions for enabling tab-completion"
+    def run
+      if options.autocomplete
+        src = File.join(File.join(Gem.loaded_specs['pbox'].full_gem_path, "autocomplete"), "pbox_bash")
+        dest = File.join(RHC::Config.home_conf_dir, "bash_autocomplete")
+
+        FileUtils.mkdir_p(RHC::Config.home_conf_dir)
+        FileUtils.cp(src, dest)
+
+        say <<-LINE.strip_heredoc
+          To enable tab-completion for PBOX under Bash shells, add the following command to
+          your .bashrc or .bash_profile file:
+
+            . #{dest}
+
+          Save your shell and then restart. Type "pbox" and then hit the TAB key twice to
+          trigger completion of your command.
+
+          Tab-completion is not available in the Windows terminal.
+          LINE
+        return 0
+      end
+
+      raise OptionParser::InvalidOption, "Setup can not be run with the --noprompt option" if options.noprompt
+      RHC::RerunWizard.new(config, options).run ?  0 : 1
+    end
+  end
+end

data/lib/rhc/commands/snapshot.rb

@@ -0,0 +1,137 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Snapshot < Base
+    summary "Save the current state of your application locally"
+    syntax "<action>"
+    description <<-DESC
+      Snapshots allow you to export the current state of your ProtonBox application
+      into an archive on your local system, and then to restore it later.
+
+      The snapshot archive contains the Git repository, dumps of any attached databases,
+      and any other information that the cartridges decide to export.
+
+      WARNING: Both 'save' and 'restore' will stop the application and then restart
+      after the operation completes.
+      DESC
+    alias_action :"app snapshot", :root_command => true
+    default_action :help
+
+    summary "Save a snapshot of your app to disk"
+    syntax "<application> [--filepath FILE] [--ssh path_to_ssh_executable]"
+    takes_application :argument => true
+    option ["-f", "--filepath FILE"], "Local path to save tarball (default: ./$APPNAME.tar.gz)"
+    option ["--deployment"], "Snapshot as a deployable file which can be deployed with 'pbox deploy'"
+    option ["--ssh PATH"], "Full path to your SSH executable with additional options"
+    alias_action :"app snapshot save", :root_command => true, :deprecated => true
+    def save(app)
+      ssh = check_ssh_executable! options.ssh
+      rest_app = find_app
+
+      raise RHC::DeploymentsNotSupportedException.new if options.deployment && !rest_app.supports?("DEPLOY")
+
+      ssh_uri = URI.parse(rest_app.ssh_url)
+      filename = options.filepath ? options.filepath : "#{rest_app.name}.tar.gz"
+
+      snapshot_cmd = options.deployment ? 'gear archive-deployment' : 'snapshot'
+      ssh_cmd = "#{ssh} #{ssh_uri.user}@#{ssh_uri.host} '#{snapshot_cmd}' > #{filename}"
+      debug ssh_cmd
+
+      say "Pulling down a snapshot to #{filename}..."
+
+      begin
+        if !RHC::Helpers.windows?
+          status, output = exec(ssh_cmd)
+          if status != 0
+            debug output
+            raise RHC::SnapshotSaveException.new "Error in trying to save snapshot. You can try to save manually by running:\n#{ssh_cmd}"
+          end
+        else
+          Net::SSH.start(ssh_uri.host, ssh_uri.user) do |ssh|
+            File.open(filename, 'wb') do |file|
+              ssh.exec! "snapshot" do |channel, stream, data|
+                if stream == :stdout
+                  file.write(data)
+                else
+                  debug data
+                end
+              end
+            end
+          end
+        end
+      rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+        debug e.backtrace
+        raise RHC::SnapshotSaveException.new "Error in trying to save snapshot. You can try to save manually by running:\n#{ssh_cmd}"
+      end
+      results { say "Success" }
+      0
+    end
+
+    summary "Restores a previously saved snapshot"
+    syntax "<application> [--filepath FILE] [--ssh path_to_ssh_executable]"
+    takes_application :argument => true
+    option ["-f", "--filepath FILE"], "Local path to restore tarball"
+    option ["--ssh PATH"], "Full path to your SSH executable with additional options"
+    alias_action :"app snapshot restore", :root_command => true, :deprecated => true
+    def restore(app)
+      ssh = check_ssh_executable! options.ssh
+      rest_app = find_app
+      filename = options.filepath ? options.filepath : "#{rest_app.name}.tar.gz"
+
+      if File.exists? filename
+
+        include_git = RHC::Helpers.windows? ? true : RHC::TarGz.contains(filename, './*/git')
+        ssh_uri = URI.parse(rest_app.ssh_url)
+
+        ssh_cmd = "cat '#{filename}' | #{ssh} #{ssh_uri.user}@#{ssh_uri.host} 'restore#{include_git ? ' INCLUDE_GIT' : ''}'"
+
+        say "Restoring from snapshot #{filename}..."
+        debug ssh_cmd
+
+        begin
+          if !RHC::Helpers.windows?
+            status, output = exec(ssh_cmd)
+            if status != 0
+              debug output
+              raise RHC::SnapshotRestoreException.new "Error in trying to restore snapshot. You can try to restore manually by running:\n#{ssh_cmd}"
+            end
+          else
+            ssh = Net::SSH.start(ssh_uri.host, ssh_uri.user)
+            ssh.open_channel do |channel|
+              channel.exec("restore#{include_git ? ' INCLUDE_GIT' : ''}") do |ch, success|
+                channel.on_data do |ch, data|
+                  say data
+                end
+                channel.on_extended_data do |ch, type, data|
+                  say data
+                end
+                channel.on_close do |ch|
+                  say "Terminating..."
+                end
+                File.open(filename, 'rb') do |file|
+                  file.chunk(1024) do |chunk|
+                    channel.send_data chunk
+                  end
+                end
+                channel.eof!
+              end
+            end
+            ssh.loop
+          end
+        rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+          debug e.backtrace
+          raise RHC::SnapshotRestoreException.new "Error in trying to restore snapshot. You can try to restore manually by running:\n#{ssh_cmd}"
+        end
+
+      else
+        raise RHC::SnapshotRestoreException.new "Archive not found: #{filename}"
+      end
+      results { say "Success" }
+      0
+    end
+
+    protected
+      include RHC::SSHHelpers
+
+  end
+end

data/lib/rhc/commands/ssh.rb

@@ -0,0 +1,51 @@
+require 'rhc/commands/base'
+require 'resolv'
+require 'rhc/git_helpers'
+require 'rhc/cartridge_helpers'
+
+module RHC::Commands
+  class Ssh < Base
+    suppress_wizard
+
+    summary "SSH into the specified application"
+    description <<-DESC
+      Connect to your application using SSH.  This will connect to your primary gear
+      (the one with your Git repository and web cartridge) by default.  To SSH to
+      other gears run 'pbox show-app --gears' to get a list of their SSH hosts.
+
+      You may run a specific SSH command by passing one or more arguments, or use a
+      different SSH executable or pass options to SSH with the '--ssh' option.
+      DESC
+    syntax "[--ssh path_to_ssh_executable] [--gears] [<app> --] <command>"
+    takes_application :argument => true
+    argument :command, "Command to run in the application's SSH session", ['--command COMMAND'], :type => :list, :optional => true
+    option ["--ssh PATH"], "Path to your SSH executable or additional options"
+    option ["--gears"], "Execute this command on all gears in the app.  Requires a command."
+    option ["--limit INTEGER"], "Limit the number of simultaneous SSH connections opened with --gears (default: 5).", :type => Integer, :default => 5
+    option ["--raw"], "Output only the data returned by each host, no hostname prefix."
+    alias_action 'app ssh', :root_command => true
+    def run(_, command)
+      raise ArgumentError, "--gears requires a command" if options.gears && command.blank?
+      raise ArgumentError, "--limit must be an integer greater than zero" if options.limit && options.limit < 1
+
+      ssh = check_ssh_executable! options.ssh
+
+      if options.gears
+        run_on_gears(command.join(' '), find_app(:with_gear_groups => true))
+        0
+      else
+        rest_app = find_app
+        $stderr.puts "Connecting to #{rest_app.ssh_string.to_s} ..." unless command.present?
+
+        debug "Using user specified SSH: #{options.ssh}" if options.ssh
+
+        command_line = [ ssh.split, rest_app.ssh_string.to_s, command].flatten.compact
+        debug "Invoking Kernel.exec with #{command_line.inspect}"
+        Kernel.send(:exec, *command_line)
+      end
+    end
+
+    protected
+      include RHC::SSHHelpers
+  end
+end

data/lib/rhc/commands/sshkey.rb

@@ -0,0 +1,97 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Sshkey < Base
+    include RHC::SSHHelpers
+
+    summary 'Add and remove keys for Git and SSH'
+    syntax '<action>'
+    description <<-DESC
+      ProtonBox uses public keys to securely access your application source
+      code and to control access to your application gears via SSH.  Your
+      account may have one or more public SSH keys associated with it, and
+      any computer with the private SSH key will be able to download code
+      from Git or SSH to the application.
+
+      Depending on your operating system, you may have to ensure that both
+      Git and the local SSH installation have access to your keys.  Running
+      the 'setup' command is any easy way to get your first key created and
+      uploaded.
+      DESC
+    default_action :list
+
+    summary 'Display all the SSH keys for your account'
+    syntax ''
+    def list
+      keys = rest_client.sshkeys.each{ |key| paragraph{ display_key(key) } }
+
+      success "You have #{keys.length} SSH keys associated with your account."
+
+      0
+    end
+
+    summary 'Show the SSH key with the given name'
+    syntax '<name>'
+    argument :name, 'SSH key to display', []
+    def show(name)
+      key = rest_client.find_key(name)
+      display_key(key)
+
+      0
+    end
+
+    summary 'Add SSH key to your account'
+    syntax '<name> <path to SSH key file>'
+    argument :name, 'Name for this key', []
+    argument :key, 'SSH public key filepath', [], :optional => true
+    option ['--confirm'], 'Bypass key validation'
+    option ['--type TYPE'], 'Provide the key type directly if no key file is given'
+    option ['--content CONTENT'], 'Provide the key content directly if no key file is given'
+    def add(name, key_path=nil)
+
+      if key_path
+        type, content, comment = ssh_key_triple_for(key_path)
+      elsif options[:type].present? and options[:content].present?
+        type = options[:type]
+        content = options[:content]
+      else
+       raise ArgumentError, "You must either provide a key file, or the key type and content"
+      end
+
+      if type == 'krb5-principal'
+        # TODO: validate krb5?
+      else
+        # validate the user input before sending it to the server
+        begin
+          Net::SSH::KeyFactory.load_data_public_key "#{type} #{content}"
+        rescue NotImplementedError, OpenSSL::PKey::PKeyError, Net::SSH::Exception => e
+          debug e.inspect
+          if options.confirm
+            warn 'The key you are uploading is not recognized.  You may not be able to authenticate to your application through Git or SSH.'
+          else
+            raise ::RHC::KeyDataInvalidException.new("File '#{key_path}' does not appear to be a recognizable key file (#{e}). You may specify the '--confirm' flag to add the key anyway.") if key_path
+            raise ::RHC::KeyDataInvalidException.new("The provided type and content does not appear to be a recognizable key (#{e}). You may specify the '--confirm' flag to add the key anyway.")
+          end
+        end
+      end
+
+      rest_client.add_key(name, content, type)
+      results { say key_path ? "SSH key #{key_path} has been added as '#{name}'" : "SSH key '#{name}' has been added" }
+
+      0
+    end
+
+    summary 'Remove SSH key from your account'
+    syntax '<name>'
+    alias_action :delete, :deprecated => true
+    argument :name, 'Name of SSH key to remove'
+    def remove(name)
+      say "Removing the key '#{name} ... "
+      rest_client.delete_key(name)
+
+      success "removed"
+
+      0
+    end
+  end
+end

data/lib/rhc/commands/tail.rb

@@ -0,0 +1,47 @@
+require 'rhc/commands/base'
+require 'rhc/config'
+require 'rhc/ssh_helpers'
+
+module RHC::Commands
+  class Tail < Base
+    include RHC::SSHHelpers
+
+    summary "Tail the logs of an application"
+    syntax "<application>"
+    takes_application :argument => true
+    option ["-o", "--opts options"], "Options to pass to the server-side (linux based) tail command (applicable to tail command only) (-f is implicit.  See the linux tail man page full list of options.) (Ex: --opts '-n 100')"
+    option ["-f", "--files files"], "File glob relative to app (default <application_name>/logs/*) (optional)"
+    option ["-g", "--gear ID"], "Tail only a specific gear"
+    #option ["-c", "--cartridge name"], "Tail only a specific cartridge"
+    alias_action :"app tail", :root_command => true, :deprecated => true
+    def run(app_name)
+      rest_app = find_app(:include => :cartridges)
+      ssh_url = options.gear ? rest_app.gear_ssh_url(options.gear) : rest_app.ssh_url
+
+      tail('*', URI(ssh_url), options)
+
+      0
+    end
+
+    private
+      #Application log file tailing
+      def tail(cartridge_name, ssh_url, options)
+        debug "Tail in progress for cartridge #{cartridge_name}"
+
+        host = ssh_url.host
+        uuid = ssh_url.user
+
+        file_glob = options.files ? options.files : "#{cartridge_name}/log*/*"
+        remote_cmd = "tail#{options.opts ? ' --opts ' + Base64::encode64(options.opts).chomp : ''} #{file_glob}"
+        ssh_cmd = "ssh -t #{uuid}@#{host} '#{remote_cmd}'"
+        begin
+          #Use ssh -t to tail the logs
+          debug ssh_cmd
+          ssh_ruby(host, uuid, remote_cmd, false, true)
+        rescue
+          warn "You can tail this application directly with:\n#{ssh_cmd}"
+          raise
+        end
+      end
+  end
+end

data/lib/rhc/commands/threaddump.rb

@@ -0,0 +1,14 @@
+require 'rhc/commands/base'
+module RHC::Commands
+  class Threaddump < Base
+    summary "Trigger a thread dump for JBoss and Ruby apps"
+    syntax "<application>"
+    takes_application :argument => true
+    def run(app)
+      rest_app = find_app
+      rest_app.threaddump.messages.each { |m| say m }
+
+      0
+    end
+  end
+end