RailsRemoteControl 1.0.0

data/History.txt

@@ -0,0 +1,7 @@
+= 1.0.0 / 2007-01-02
+
+* Birthday!
+* Monitor processes
+* Control process log level without restarts
+* Logs actions handled and count per process
+

data/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright 2006 Eric Hodel, The Robot Co-op.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the names of the authors nor the names of their contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+LICENSE.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/rails_remote_control
+lib/rails_remote_control.rb
+lib/rails_remote_control/http_server.rb
+lib/rails_remote_control/process.rb
+lib/rails_remote_control/remote.rb
+lib/rails_remote_control/remote/server.rb
+lib/rails_remote_control/server.rb
+lib/rails_remote_control/servlet.rb
+test/test_rails_remote_control.rb
+test/test_rails_remote_control_http_server.rb
+test/test_rails_remote_control_process.rb
+test/test_rails_remote_control_remote.rb
+test/test_rails_remote_control_remote_server.rb
+test/test_rails_remote_control_server.rb
+test/test_rails_remote_control_servlet.rb
+test/util.rb

data/README.txt

@@ -0,0 +1,38 @@
+RailsRemoteControl by Eric Hodel <drbrain@segment7.net>
+
+http://seattlerb.rubyforge.org/RailsRemoteControl
+
+== DESCRIPTION:
+
+Rails Remote Control allows you to attach to running Rails processes
+using DRb and change the log level without restarts.  Also, view
+actions handled per process.
+
+== FEATURES/PROBLEMS:
+
+* Monitor processes
+* Control process log level without restarts
+* Logs actions handled and count per process
+
+== SYNOPSYS:
+
+See RailsRemoteControl:
+
+  ri RailsRemoteControl
+
+== REQUIREMENTS:
+
+* A Rails project
+* DRb connectivity
+* RingyDingy (gem)
+
+== INSTALL:
+
+First install the gem:
+
+  $ sudo gem install RailsRemoteControl
+
+Then read and follow the RailsRemoteControl installation instructions:
+
+  $ ri RailsRemoteControl
+

data/Rakefile

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+$:.unshift 'lib'
+require 'rails_remote_control'
+
+hoe = Hoe.new('RailsRemoteControl', RailsRemoteControl::VERSION) do |p|
+  p.summary = 'Alter Rails log levels and monitor processes without restarts'
+  p.description = File.read('README.txt').scan(/== DESCRIPTION:(.*?)==/m).first.first.strip
+  p.author = 'Eric Hodel'
+  p.email = 'drbrain@segment7.net'
+  p.rubyforge_name = 'seattlerb'
+  p.url = 'http://seattlerb.rubyforge.org/RailsRemoteControl'
+  p.changes = File.read('History.txt').scan(/\A(=.*?)(=|\Z)/m).first.first
+
+  p.extra_deps << ['RingyDingy', '>= 1.2.0']
+  p.extra_deps << ['ZenTest', '>= 3.4.2']
+  p.extra_deps << ['actionpack', '>= 1.12.5']
+end
+
+# vim: syntax=Ruby

data/bin/rails_remote_control

@@ -0,0 +1,6 @@
+#!/usr/local/bin/ruby -w
+
+require 'rails_remote_control/http_server'
+
+RailsRemoteControl::HTTPServer.run
+

data/lib/rails_remote_control.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+
+##
+# RailsRemoteControl allows you to monitor individual Rails processes and
+# adjust the log level of a process for debugging purposes.  (For example, to
+# turn on partial rendering times for a single process.)
+#
+# = Installation
+#
+# First, start a RailsRemoteControl::Server when your Rails process starts up
+# by adding these two lines to config/environment.rb:
+#
+#   require 'rails_remote_control/server'
+#   RailsRemoteControl::Server.run 'my_rails_app'
+#
+# Next, add <tt>include RailsRemoteControl::Process</tt> in Application
+# controller:
+#
+#   require 'rails_remote_control/process'
+#   
+#   class ApplicationController < ActionController::Base
+#   
+#     include RailsRemoteControl::Process
+#   
+#     # ...
+#   
+#   end
+#
+# = Usage
+#
+# Then start up a RingServer where you want to monitor and control your remote
+# processes:
+#
+#   $ ring_server -d
+#
+# You can start the RingServer up before or after the Rails app.  The rails
+# processes will automatically connect soon after it starts.
+#
+# Then start up the RailsRemoteControl::HTTPServer so you can control your
+# processes:
+#
+#   $ rails_remote_control -d
+#
+# Then connect with your web browser to port 8000 on that machine.
+#
+# = It Doesn't Work
+#
+# * Do you have forward and reverse DNS set up for all your machines?
+#     $ host `hostname`
+#     ziz.jijo.segment7.net has address 10.101.28.1
+#     $ host 10.101.28.1
+#     1.28.101.10.in-addr.arpa domain name pointer ziz.jijo.segment7.net.
+#   Both forward and reverse addresses need to match here.
+# * Have you disabled IPv6 or set up RDNS for your IPv6 hosts?
+
+module RailsRemoteControl
+
+  ##
+  # The version of RailsRemoteControl you have installed.
+
+  VERSION = '1.0.0'
+
+end
+

data/lib/rails_remote_control/http_server.rb

@@ -0,0 +1,68 @@
+require 'rails_remote_control'
+require 'rails_remote_control/servlet'
+require 'webrick/httpserver'
+
+##
+# RailsRemoteControl HTTP server.
+#
+# This provides the console for monitoring and modifying your Rails processes.
+# By default it runs on port 8000.
+
+class RailsRemoteControl::HTTPServer < WEBrick::HTTPServer
+
+  @server = nil
+
+  ##
+  # Processes ARGV style +args+ into an options Hash.
+
+  def self.process_args(args)
+    options = {}
+    options[:Daemon] = false
+    options[:Port] = 8000
+
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: #{name} [options]"
+      opts.on("-p", "--port=PORT",
+              "RailsRemoteControl HTTP Server Port", Integer) do |port|
+        options[:Port] = port
+      end
+
+      opts.on("-d", "--daemon",
+              "Run as a daemon process") do |daemon|
+        options[:Daemon] = true
+      end
+    end
+
+    opts.parse! args
+
+    return options
+  end
+
+  ##
+  # Start and run a RailsRemoteControl HTTP server, depending upon +args+.
+
+  def self.run(args = ARGV)
+    options = process_args args
+
+    if options[:Daemon] then
+      WEBrick::Daemon.start
+    end
+
+    @server = new :Port => options[:Port]
+    @server.mount '/', RailsRemoteControl::Servlet
+
+    trap 'INT' do stop end
+    trap 'KILL' do stop end
+
+    @server.start
+  end
+
+  ##
+  # Stop the RailsRemoteControl HTTP server.
+
+  def self.stop
+    @server.stop
+  end
+
+end
+

data/lib/rails_remote_control/process.rb

@@ -0,0 +1,59 @@
+require 'rails_remote_control'
+
+##
+# RailsRemoteControl::Process records statistics of a running Rails process.
+#
+# Include it in your ApplicationController to record these statistics:
+#
+#   require 'rails_remote_control/process'
+#   
+#   class ApplicationController < ActionController::Base
+#   
+#     include RailsRemoteControl::Process
+#   
+#   end
+
+module RailsRemoteControl::Process
+
+  @requests_attempted = 0
+  @requests_handled = 0
+
+  @requests = Hash.new { |h,full_action_name| h[full_action_name] = 0 }
+
+  class << self
+
+    ##
+    # Hash mapping action names to times handled.
+
+    attr_reader :requests
+
+    ##
+    # Requests attempted
+
+    attr_accessor :requests_attempted
+
+    ##
+    # Requests successfully handled
+
+    attr_accessor :requests_handled
+
+  end
+
+  ##
+  # ActionController::Base#process wrapper that records statistics for actions
+  # handled by this Rails process.
+
+  def process(req, res)
+    RailsRemoteControl::Process.requests_attempted += 1
+
+    result = super
+
+    RailsRemoteControl::Process.requests_handled += 1
+    full_action_name = "#{self.class.name}##{action_name}"
+    RailsRemoteControl::Process.requests[full_action_name] += 1
+
+    return result
+  end
+
+end
+

data/lib/rails_remote_control/remote.rb

@@ -0,0 +1,38 @@
+require 'rails_remote_control'
+require 'ringy_dingy/ring_server'
+require 'rails_remote_control/server'
+
+##
+# RailsRemoteControl process locater.
+
+class RailsRemoteControl::Remote
+
+  ##
+  # Remote server struct
+
+  Server = Struct.new :host, :pid, :remote_server
+
+  ##
+  # Looks for services on the RingServer and returns an Array of discovered
+  # Rails processes.
+
+  def services
+    services = RingyDingy::RingServer.list_services
+    return [] if services.empty?
+
+    services = RingyDingy::RingServer.list_services.values.first.uniq
+
+    rrc_servers = services.select do |_, klass,|
+      klass == RailsRemoteControl::Server::RINGY_DINGY_SERVICE
+    end
+
+    rrc_servers.map do |_, _, server, name|
+      host, pid, = name.split '_', 3
+      Server.new host, pid.to_i, server
+    end
+  end
+
+end
+
+require 'rails_remote_control/remote/server'
+

data/lib/rails_remote_control/remote/server.rb

@@ -0,0 +1,16 @@
+require 'rails_remote_control/remote'
+
+##
+# RailsRemoteControl remote server convenience wrapper.
+
+class RailsRemoteControl::Remote::Server
+
+  ##
+  # Dispatch other messages to the remote server.
+
+  def method_missing(*args, &block)
+    remote_server.send(*args, &block)
+  end
+
+end
+

data/lib/rails_remote_control/server.rb

@@ -0,0 +1,117 @@
+require 'English'
+require 'logger'
+require 'rubygems'
+require 'ringy_dingy'
+require 'rails_remote_control'
+require 'rails_remote_control/process'
+
+##
+# RailsRemoteControl server process.  Run this from config/environment.rb to
+# allow RailsRemoteControl::Remote to find the Rails processes you are
+# running.
+#
+# = Example
+#
+# Add the following lines to config/environment.rb for your application:
+#
+#   require 'rails_remote_control/server'
+#   RailsRemoteControl::Server.run 'my_rails_app'
+
+class RailsRemoteControl::Server
+
+  ##
+  # Service name for RingyDingy
+
+  RINGY_DINGY_SERVICE = name.delete(':').intern
+
+  ##
+  # Run as +name+.
+
+  def self.run(name = nil)
+    new(name).run
+  end
+
+  ##
+  # Creates a new RailsRemoteControl server as +name+.
+  #
+  # Use +name+ to disambiguate multiple Rails applications.
+
+  def initialize(name)
+    @name = name
+    @ringy_dingy = RingyDingy.new self, RINGY_DINGY_SERVICE, name
+    @pid = $PID
+    @host = Socket.gethostname
+  end
+
+  ##
+  # Start running
+
+  def run
+    @ringy_dingy.run
+  end
+
+  ##
+  # Returns the current log level of the default logger for this Rails
+  # process.
+
+  def log_level
+    RAILS_DEFAULT_LOGGER.level
+  end
+
+  ##
+  # Sets the current log level of the default logger for this Rails process to
+  # +level+.
+
+  def log_level=(level)
+    RAILS_DEFAULT_LOGGER.level = level
+  end
+
+  ##
+  # A Hash mapping action names to number of requests handled.
+  #
+  # See RailsRemoteControl::Process#requests.
+
+  def requests
+    RailsRemoteControl::Process.requests
+  end
+
+  ##
+  # Number of requests attempted by this Rails process.
+
+  def requests_attempted
+    RailsRemoteControl::Process.requests_attempted
+  end
+
+  ##
+  # Number of requests handled by this Rails process.  (If this number is
+  # different from #requests_attempted something bad happened, check your
+  # logs.)
+
+  def requests_handled
+    RailsRemoteControl::Process.requests_handled
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other and other.name == self.name and
+      other.host == self.host and other.pid == self.pid
+  end
+
+  protected
+
+  ##
+  # Name of this Rails process.
+
+  attr_reader :name
+
+  ##
+  # Host this Rails process is running on.
+
+  attr_reader :host
+
+  ##
+  # Process id for this Rails process.
+
+  attr_reader :pid
+
+end
+

data/lib/rails_remote_control/servlet.rb

@@ -0,0 +1,207 @@
+$TESTING = false unless defined? $TESTING
+
+require 'webrick/httpservlet/abstract'
+require 'webrick/httpstatus'
+require 'rails_remote_control'
+require 'rails_remote_control/remote'
+require 'logger'
+
+##
+# RailsRemoteControl WEBrick servlet for process monitoring and control.
+
+class RailsRemoteControl::Servlet < WEBrick::HTTPServlet::AbstractServlet
+
+  logger_levels = Logger::Severity.constants.map do |c|
+    [Logger::Severity.const_get(c), c]
+  end
+
+  ##
+  # Map Logger's log levels to friendly names
+
+  LOGGER_LEVELS = logger_levels.sort_by { |l,n| l }
+
+  @services = nil
+  @services_thread = nil
+
+  ##
+  # Accessor for services cache
+
+  def self.services
+    @services
+  end
+
+  ##
+  # Fetching a list of services will block for five seconds, so do that in a
+  # separate thread and cache the results.  This method is called at require
+  # time.
+
+  def self.start_services_thread
+    @services_thread = Thread.start do
+      remote = RailsRemoteControl::Remote.new
+
+      loop do
+        @services = remote.services
+        sleep 10
+      end
+    end
+
+    sleep 0.1 while @services.nil?
+  end
+
+  start_services_thread unless $TESTING
+
+  def do_GET(req, res) # :nodoc:
+    case req.request_uri.request_uri
+    when '/' then
+      res.body = list
+    when %r%\A/server/([^/]+)/(\d+)\Z%
+      res.body = server $1, $2.to_i
+    else
+      super
+    end
+  end
+
+  def do_POST(req, res) # :nodoc:
+    case req.request_uri.request_uri
+    when %r%\A/server/([^/]+)/(\d+)/log_level\Z%
+      host, pid = $1, $2.to_i
+      req.body =~ /log_level=(\d+)/
+      level = Integer($1) rescue nil
+      res.body = set_log_level host, pid, level
+    else
+      super
+    end
+  end
+
+  ##
+  # Displays a list of rails processes available for remote control.
+
+  def list
+    out = "<title>No Processes</title>\n"
+    out << "<h1>No Processes</h1>\n"
+    out << "<p>Did you start ring_server?"
+    out << "<p>Did you start rails_remote_control?\n"
+    out << "<p>Did you set up your Rails application for monitoring?\n"
+    return out if services.nil?
+
+    out = []
+    out << "<title>Active Processes</title>"
+    out << "<h1>Active Processes</h1>"
+    out << nil
+    out << '<table>'
+    out << '<tr><th colspan=2>&nbsp;<th colspan=2>Requests<th>&nbsp;'
+    out << '<tr><th>Host<th>Process<th>Attempted<th>Handled<th>Log Level'
+
+    services.each do |server|
+      row = server_row server
+      out << row if row
+    end
+
+    out << '</table>' << nil
+
+    out.join "\n"
+  end
+
+  ##
+  # Displays information about process +pid+ on +host+.
+
+  def server(host, pid)
+    server = get_server host, pid
+
+    out = []
+    out << "<title>#{host} pid #{pid}</title>"
+    out << "<h1>#{host} pid #{pid}</h1>"
+    out << nil
+
+    out << '<a href="/">Active Processes</a>'
+    out << nil
+
+    out << '<table>'
+    out << "<tr><th>Log Level<td>#{server.log_level}"
+    out << "<tr><th>Requests Attempted<td>#{server.requests_attempted}"
+    out << "<tr><th>Requests Handled<td>#{server.requests_handled}"
+    out << '</table>' << nil
+
+    out << "<form method=\"post\" action=\"/server/#{host}/#{pid}/log_level\">"
+    out << '<div>'
+    out << '<label for="log_level">Change Log Level</label>'
+    out << '<select id="log_level" name="log_level">'
+
+    LOGGER_LEVELS.each do |level, name|
+      selected = server.log_level == level ? ' selected' : nil
+      out << "<option#{selected} value=\"#{level}\">#{name}</option>"
+    end
+
+    out << '</select>'
+    out << '<input type="submit" value="Change">'
+    out << '</div>' << '</form>' << nil
+
+    unless server.requests.empty? then
+      out << '<table>'
+      out << "<tr><th>Action<th>Requests Handled"
+      server.requests.sort_by { |a,c| -c }.each do |action, count|
+        out << "<tr><td>#{action}<td>#{count}"
+      end
+      out << '</table>' << nil
+    end
+
+    out.join "\n"
+  rescue DRb::DRbConnError
+    raise WEBrick::HTTPStatus::NotFound, "#{host}:#{pid} is no longer reachable"
+  rescue NoMethodError
+    raise WEBrick::HTTPStatus::NotFound, "#{host}:#{pid} has gone away"
+  end
+
+  def service(req, res) # :nodoc:
+    @req = req
+    @res = res
+    @res.content_type = 'text/html'
+    super
+  end
+
+  ##
+  # Services accessor
+
+  def services
+    self.class.services
+  end
+
+  ##
+  # Construct a table row with information on +server+.
+
+  def server_row(server)
+    tr = []
+    tr << "<td>#{server.host}"
+    tr << "<td><a href=\"/server/#{server.host}/#{server.pid}\">#{server.pid}</a>"
+    tr << "<td>#{server.requests_attempted}"
+    tr << "<td>#{server.requests_handled}"
+    tr << "<td>#{server.log_level}"
+
+    "<tr>#{tr.join}"
+
+  rescue DRb::DRbConnError
+    nil
+  end
+
+  ##
+  # Sets the log level for process +pid+ on +host+ to +level+.
+
+  def set_log_level(host, pid, level)
+    server = get_server host, pid
+    server.log_level = level
+    @res.set_redirect WEBrick::HTTPStatus::SeeOther, "/server/#{host}/#{pid}"
+  rescue DRb::DRbConnError
+    raise WEBrick::HTTPStatus::NotFound, "#{host}:#{pid} is no longer reachable"
+  rescue NoMethodError
+    raise WEBrick::HTTPStatus::NotFound, "#{host}:#{pid} has gone away"
+  end
+
+  ##
+  # Retrieves the server for process +pid+ on +host+.
+
+  def get_server(host, pid)
+    services.find { |s| s.host == host and s.pid == pid }
+  end
+
+end
+

data/test/test_rails_remote_control_http_server.rb

@@ -0,0 +1,16 @@
+$TESTING = true
+
+require 'test/unit'
+require 'rails_remote_control/http_server'
+
+class TestRailsRemoteControlHTTPServer < Test::Unit::TestCase
+  
+  def test_self_process_args
+    options = RailsRemoteControl::HTTPServer.process_args %w[-d -p 80]
+
+    expected = { :Daemon => true, :Port => 80 }
+    assert_equal expected, options
+  end
+
+end
+

data/test/test_rails_remote_control_process.rb

@@ -0,0 +1,93 @@
+require 'test/unit'
+
+module ActionController; end
+class ActionController::Base
+
+  attr_reader :action_name
+
+  def self.process(req, res)
+    new.process req, res
+  end
+
+  def process(req, res)
+    params = req.parameters
+    @action_name = params['action']
+  end
+
+  def controller_class_name
+    self.class.name.split('::').last
+  end
+
+end
+
+require 'rails_remote_control/process'
+
+class ApplicationController < ActionController::Base
+  include RailsRemoteControl::Process
+end
+
+class MyController < ApplicationController
+
+  def index
+  end
+
+  def show
+  end
+
+end
+
+module Nested; end
+class Nested::MyController < ApplicationController
+
+  def index
+  end
+
+  def show
+  end
+
+end
+
+module RailsRemoteControl
+  def Process.reset
+    @requests_handled = 0
+    @requests_attempted = 0
+    @requests.clear
+  end
+end
+
+class TestRailsRemoteControlProcess < Test::Unit::TestCase
+
+  RRCP = RailsRemoteControl::Process
+
+  FakeRequest = Struct.new :parameters
+
+  def setup
+    @request = FakeRequest.new
+    @request.parameters = { 'action' => 'index' }
+  end
+
+  def teardown
+    RRCP.reset
+  end
+
+  def test_process
+    MyController.new.process @request, nil
+
+    assert_equal 1, RRCP.requests_handled
+    assert_equal 1, RRCP.requests_attempted
+
+    expected = { 'MyController#index' => 1 }
+    assert_equal expected, RRCP.requests
+  end
+
+  def test_process_nested
+    Nested::MyController.new.process @request, nil
+
+    assert_equal 1, RRCP.requests_handled
+
+    expected = { 'Nested::MyController#index' => 1 }
+    assert_equal expected, RRCP.requests
+  end
+
+end
+

data/test/test_rails_remote_control_remote.rb

@@ -0,0 +1,42 @@
+$TESTING = true
+
+require 'test/unit'
+require 'rails_remote_control/remote'
+require 'test/util'
+
+class TestRailsRemoteControlRemote < Test::Unit::TestCase
+
+  RRCR = RailsRemoteControl::Remote
+
+  def setup
+    @remote = RRCR.new
+    RingyDingy::RingServer.default = RingyDingy::RingServer::DEFAULT
+  end
+
+  def teardown
+    RingyDingy::RingServer.default = RingyDingy::RingServer::DEFAULT
+  end
+
+  def test_services
+    RingyDingy::RingServer.default = RingyDingy::RingServer::DEFAULT
+
+    expected = [
+      RRCR::Server.new('cutie', 1000,
+                       RailsRemoteControl::Server.new('43places')),
+      RRCR::Server.new('cutie', 1001,
+                       RailsRemoteControl::Server.new('43places')),
+      RRCR::Server.new('hal', 61000,
+                       RailsRemoteControl::Server.new('43things')),
+    ]
+
+    assert_equal expected, @remote.services
+  end
+
+  def test_services_no_services
+    RingyDingy::RingServer.default = {}
+
+    assert_equal [], @remote.services
+  end
+
+end
+

data/test/test_rails_remote_control_remote_server.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'rails_remote_control/server'
+require 'rails_remote_control/remote/server'
+
+class TestRailsRemoteControlRemoteServer < Test::Unit::TestCase
+
+  def setup
+    @server = RailsRemoteControl::Server.new 'name'
+    @remote_server = RailsRemoteControl::Remote::Server.new 'localhost', $$, @server
+  end
+
+  def test_method_missing
+    assert_equal 0, @remote_server.requests_handled
+  end
+
+end
+

data/test/test_rails_remote_control_server.rb

@@ -0,0 +1,80 @@
+require 'test/unit'
+require 'rubygems'
+require 'test/zentest_assertions'
+require 'test/util'
+
+require 'rails_remote_control/server'
+
+class RailsRemoteControl::Server
+  attr_reader :ringy_dingy
+  public :host, :name, :pid
+end
+
+class TestRailsRemoteControlServer < Test::Unit::TestCase
+
+  RRCS = RailsRemoteControl::Server
+
+  def setup
+    @name = 'RailsRemoteControl::Server test'
+    @server = RRCS.new @name
+  end
+
+  def test_equal
+    server = RRCS.new @name
+
+    assert_equal server, @server
+  end
+
+  def test_host
+    assert_equal Socket.gethostname, @server.host
+  end
+
+  def test_initialize
+    deny_nil @server.ringy_dingy
+    assert_equal "#{Socket.gethostname.downcase}_#{$PID}_#{@name}",
+                 @server.ringy_dingy.identifier
+  end
+
+  def test_log_level
+    assert_equal Logger::DEBUG, @server.log_level
+  end
+
+  def test_log_level_equals
+    level = @server.log_level
+    @server.log_level = Logger::FATAL
+    assert_equal Logger::FATAL, @server.log_level
+    assert_equal Logger::FATAL, RAILS_DEFAULT_LOGGER.level
+  ensure
+    @server.log_level = level
+  end
+
+  def test_name
+    assert_equal @name, @server.name
+  end
+
+  def test_pid
+    assert_equal $$, @server.pid
+  end
+
+  def test_requests
+    assert_equal Hash.new, @server.requests
+  end
+
+  def test_requests_attempted
+    assert_equal 0, @server.requests_attempted
+  end
+
+  def test_requests_handled
+    assert_equal 0, @server.requests_handled
+  end
+
+  def test_run
+    assert_nil @server.ringy_dingy.thread
+    @server.run
+    deny_nil @server.ringy_dingy.thread
+  end
+
+  alias deny_nil assert_not_nil # HACK ZenTest 3.4.2
+
+end
+

data/test/test_rails_remote_control_servlet.rb

@@ -0,0 +1,230 @@
+$TESTING = true
+
+require 'test/unit'
+require 'stringio'
+require 'test/util'
+
+require 'rails_remote_control/servlet'
+
+require 'webrick/httprequest'
+require 'webrick/httpresponse'
+
+class FakeWEBrickServer
+  def [](arg); end
+end
+
+class RailsRemoteControl::Servlet
+  def self.services=(services)
+    @services = services
+  end
+end
+
+class TestRailsRemoteControlServlet < Test::Unit::TestCase
+
+  RRCRS = RailsRemoteControl::Remote::Server
+  RRCS = RailsRemoteControl::Servlet
+
+  def setup
+    @server = RailsRemoteControl::Server.new 'name'
+    @dead_server = RailsRemoteControl::Server.new 'name'
+    def @dead_server.requests_attempted() raise DRb::DRbConnError; end
+    RRCS.services = [
+      RRCRS.new('cutie', 1000, @server),
+      RRCRS.new('cutie', 1001, @server),
+      RRCRS.new('hal', 61000, @server),
+      RRCRS.new('hal', 61001, @dead_server),
+    ]
+
+    @http_server = FakeWEBrickServer.new
+    @servlet = RRCS.new @http_server
+    @config = { :Logger => nil, :HTTPVersion => '1.0' }
+  end
+
+  def teardown
+    RailsRemoteControl::Server.new(nil).requests.clear
+  end
+
+  def test_do_GET_list
+    req = WEBrick::HTTPRequest.new @config
+    req.parse StringIO.new("GET / HTTP/1.0\r\n\r\n")
+    res = WEBrick::HTTPResponse.new @config
+
+    def @servlet.list
+      return 'list'
+    end
+
+    @servlet.service req, res
+
+    assert_equal 'list', res.body
+  end
+
+  def test_do_GET_server
+    req = WEBrick::HTTPRequest.new @config
+    req.parse StringIO.new("GET /server/cutie/1000 HTTP/1.0\r\n\r\n")
+    res = WEBrick::HTTPResponse.new @config
+
+    def @servlet.server(host, pid)
+      return "server #{host} #{pid}"
+    end
+
+    @servlet.service req, res
+
+    assert_equal 'server cutie 1000', res.body
+  end
+
+  def test_do_GET_server_with_dot
+    req = WEBrick::HTTPRequest.new @config
+    req.parse StringIO.new("GET /server/kaa.local/1000 HTTP/1.0\r\n\r\n")
+    res = WEBrick::HTTPResponse.new @config
+
+    def @servlet.server(host, pid)
+      return "server %p %p" % [host, pid]
+    end
+
+    @servlet.service req, res
+
+    assert_equal 'server "kaa.local" 1000', res.body
+  end
+
+  def test_do_POST_server_log_level
+    req = WEBrick::HTTPRequest.new @config
+    req.parse StringIO.new("POST /server/cutie/1000/log_level HTTP/1.0\r\nContent-Length: 11\r\n\r\nlog_level=5")
+    res = WEBrick::HTTPResponse.new @config
+
+    def @servlet.set_log_level(host, pid, level)
+      return "server #{host} #{pid} #{level}"
+    end
+
+    @servlet.service req, res
+
+    assert_equal 'server cutie 1000 5', res.body
+  end
+
+  def test_list
+    expected = <<-EOF
+<title>Active Processes</title>
+<h1>Active Processes</h1>
+
+<table>
+<tr><th colspan=2>&nbsp;<th colspan=2>Requests<th>&nbsp;
+<tr><th>Host<th>Process<th>Attempted<th>Handled<th>Log Level
+<tr><td>cutie<td><a href="/server/cutie/1000">1000</a><td>0<td>0<td>0
+<tr><td>cutie<td><a href="/server/cutie/1001">1001</a><td>0<td>0<td>0
+<tr><td>hal<td><a href="/server/hal/61000">61000</a><td>0<td>0<td>0
+</table>
+    EOF
+
+    assert_equal expected, @servlet.list
+  end
+
+  def test_server
+    server = RailsRemoteControl::Server.new 'name'
+    server.requests['RouteController#index'] = 2
+    server.requests['RouteController#route_markers'] = 1
+    RRCS.services = [RRCRS.new('cutie', 1000, server)]
+
+    expected = <<-EOF
+<title>cutie pid 1000</title>
+<h1>cutie pid 1000</h1>
+
+<a href="/">Active Processes</a>
+
+<table>
+<tr><th>Log Level<td>0
+<tr><th>Requests Attempted<td>0
+<tr><th>Requests Handled<td>0
+</table>
+
+<form method="post" action="/server/cutie/1000/log_level">
+<div>
+<label for="log_level">Change Log Level</label>
+<select id="log_level" name="log_level">
+<option selected value="0">DEBUG</option>
+<option value="1">INFO</option>
+<option value="2">WARN</option>
+<option value="3">ERROR</option>
+<option value="4">FATAL</option>
+<option value="5">UNKNOWN</option>
+</select>
+<input type="submit" value="Change">
+</div>
+</form>
+
+<table>
+<tr><th>Action<th>Requests Handled
+<tr><td>RouteController#index<td>2
+<tr><td>RouteController#route_markers<td>1
+</table>
+    EOF
+
+    assert_equal expected, @servlet.server('cutie', 1000)
+  end
+
+  def test_server_dead
+    e = assert_raise WEBrick::HTTPStatus::NotFound do
+      @servlet.server 'hal', 61001
+    end
+
+    assert_equal 'hal:61001 is no longer reachable', e.message
+  end
+
+  def test_server_gone
+    util_test_gone :server
+  end
+
+  def test_server_no_requests
+    expected = <<-EOF
+<title>cutie pid 1001</title>
+<h1>cutie pid 1001</h1>
+
+<a href="/">Active Processes</a>
+
+<table>
+<tr><th>Log Level<td>0
+<tr><th>Requests Attempted<td>0
+<tr><th>Requests Handled<td>0
+</table>
+
+<form method="post" action="/server/cutie/1001/log_level">
+<div>
+<label for="log_level">Change Log Level</label>
+<select id="log_level" name="log_level">
+<option selected value="0">DEBUG</option>
+<option value="1">INFO</option>
+<option value="2">WARN</option>
+<option value="3">ERROR</option>
+<option value="4">FATAL</option>
+<option value="5">UNKNOWN</option>
+</select>
+<input type="submit" value="Change">
+</div>
+</form>
+    EOF
+
+    assert_equal expected, @servlet.server('cutie', 1001)
+  end
+
+  def test_set_log_level
+    @servlet.instance_variable_set :@res, WEBrick::HTTPResponse.new(@config)
+
+    assert_raise WEBrick::HTTPStatus::SeeOther do
+      @servlet.set_log_level 'cutie', 1000, 5
+    end
+
+    assert_equal 5, @server.log_level
+  end
+
+  def test_set_log_level_no_server
+    util_test_gone :set_log_level, 5
+  end
+
+  def util_test_gone(action, *args)
+    e = assert_raise WEBrick::HTTPStatus::NotFound do
+      @servlet.send(action, 'none', 0, *args)
+    end
+
+    assert_equal 'none:0 has gone away', e.message
+  end
+
+end
+

data/test/util.rb

@@ -0,0 +1,39 @@
+require 'logger'
+require 'rubygems'
+require 'test/zentest_assertions'
+require 'ringy_dingy/ring_server'
+require 'rails_remote_control/server'
+
+RAILS_DEFAULT_LOGGER = Logger.new '/dev/null'
+
+class RingyDingy::RingServer
+
+  @s1 = RailsRemoteControl::Server.new '43places'
+  @s2 = RailsRemoteControl::Server.new '43places'
+  @s3 = RailsRemoteControl::Server.new '43things'
+
+  DEFAULT = {
+    'druby://localhost:10000' => [
+      [:name, RailsRemoteControl::Server::RINGY_DINGY_SERVICE, @s1,
+        'cutie_1000_43places'],
+      [:name, RailsRemoteControl::Server::RINGY_DINGY_SERVICE, @s2,
+        'cutie_1001_43places'],
+      [:name, RailsRemoteControl::Server::RINGY_DINGY_SERVICE, @s3,
+        'hal_61000_43places'],
+    ]
+  }
+
+  def self.default=(default)
+    @default = default
+  end
+
+  class << self
+    remove_method :list_services
+  end
+
+  def self.list_services
+    @default
+  end
+
+end
+

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0.8
+specification_version: 1
+name: RailsRemoteControl
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2007-01-02 00:00:00 -08:00
+summary: Alter Rails log levels and monitor processes without restarts
+require_paths: 
+- lib
+email: drbrain@segment7.net
+homepage: http://seattlerb.rubyforge.org/RailsRemoteControl
+rubyforge_project: seattlerb
+description: Rails Remote Control allows you to attach to running Rails processes using DRb and change the log level without restarts.  Also, view actions handled per process.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Eric Hodel
+files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/rails_remote_control
+- lib/rails_remote_control.rb
+- lib/rails_remote_control/http_server.rb
+- lib/rails_remote_control/process.rb
+- lib/rails_remote_control/remote.rb
+- lib/rails_remote_control/remote/server.rb
+- lib/rails_remote_control/server.rb
+- lib/rails_remote_control/servlet.rb
+- test/test_rails_remote_control.rb
+- test/test_rails_remote_control_http_server.rb
+- test/test_rails_remote_control_process.rb
+- test/test_rails_remote_control_remote.rb
+- test/test_rails_remote_control_remote_server.rb
+- test/test_rails_remote_control_server.rb
+- test/test_rails_remote_control_servlet.rb
+- test/util.rb
+test_files: 
+- test/test_rails_remote_control.rb
+- test/test_rails_remote_control_http_server.rb
+- test/test_rails_remote_control_process.rb
+- test/test_rails_remote_control_remote.rb
+- test/test_rails_remote_control_remote_server.rb
+- test/test_rails_remote_control_server.rb
+- test/test_rails_remote_control_servlet.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- rails_remote_control
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: RingyDingy
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ZenTest
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.4.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.12.5
+    version: