class RJack::Jetty::ServerFactory

A factory for creating complete org.morbay.jetty.Server instances. Provides a general purpose facade for setup including the Server, a ThreadPool, a Connector, and various Handlers. It is non-exhaustive (not every Jetty facility is provided) but is designed to be easily extended.

Example

factory = Jetty::ServerFactory.new
factory.max_threads = 20
factory.port = 8080

# Set static resource context mapping URI to directory
factory.static_contexts[ '/html' ] = '/var/www/html'

# Implement custom handler and register it.
import 'org.eclipse.jetty.handler.AbstractHandler'
class RedirectHandler < AbstractHandler

  def initialize( redirects )
    super()
    @redirects = redirects
  end

  def handle( target, base_request, request, response )
    goto = @redirects[ target ]
    unless goto.nil?
      response.send_redirect( goto )
      base_request.handled = true
    end
  end
end

def factory.create_pre_handlers
  [ RedirectHandler.new( '/' => '/html/' ) ] + super
end

# Create a webapp context (war file or webapp expanded)
factory.webapp_contexts[ '/test' ] = Jetty::TestServlets::WEBAPP_TEST_WAR

# Create a context for a custom HelloServlet
import 'javax.servlet.http.HttpServlet'
class HelloServlet < HttpServlet
  def doGet( request, response )
    response.content_type = "text/plain"
    response.writer.write( 'Hello World!' )
  end
end

factory.set_context_servlets( '/hello', { '/*' => HelloServlet.new } )

# Create, start, and join (wait for shutdown)
server = factory.create
server.start
server.join

Attributes

max_idle_time_ms[RW]

max_threads[RW]

min_threads[RW]

port[RW]

request_log_file[RW]

Request log output to :stderr or file name (default: nil, no log)

servlet_contexts[RW]

static_contexts[RW]

static_welcome_files[RW]

stop_at_shutdown[RW]

webapp_contexts[RW]

Public Class Methods

new() click to toggle source

# File lib/rjack-jetty.rb, line 127
def initialize
  @port                 = 0        # Use any available port
  @max_threads          = 20
  @min_threads          = nil      # Compute from max_threads
  @max_idle_time_ms     = 10000
  @static_contexts      = {}
  @static_welcome_files = [ 'index.html' ]
  @webapp_contexts      = {}
  @request_log_file     = nil
  @servlet_contexts     = {}
  @stop_at_shutdown     = true
end

Public Instance Methods

create() click to toggle source

Returns a new org.morbay.jetty.Server that is ready to be started.

# File lib/rjack-jetty.rb, line 142
def create
  server = Server.new

  server.thread_pool = create_pool

  server.connectors = create_connectors.to_java( Connector )

  hcol = HandlerCollection.new
  hcol.handlers = create_handlers.compact.to_java( Handler )
  server.handler = hcol

  server.stop_at_shutdown = @stop_at_shutdown

  server
end

create_connectors() click to toggle source

Return array of org.eclipse.jetty.Connector instances.

This implementation returns a single SelectChannelConnector listening to the given port or an auto-selected avaiable port. Connections are retained for max_idle_time_ms.

# File lib/rjack-jetty.rb, line 175
def create_connectors
  connector = SelectChannelConnector.new
  connector.port = @port
  connector.max_idle_time = @max_idle_time_ms
  [ connector ]
end

create_context_handlers( context_handler_collection ) click to toggle source

Create context handlers on the provided ContextHandlerCollection

This implementation calls #create_static_contexts, #create_webapp_contexts, and create_servlet_context.

# File lib/rjack-jetty.rb, line 220
def create_context_handlers( context_handler_collection )
  create_static_contexts( context_handler_collection )
  create_webapp_contexts( context_handler_collection )
  create_servlet_contexts( context_handler_collection )
end

create_handlers() click to toggle source

Returns an Array of org.eclipse.jetty.Handler instances.

This implementation concatenates #create_pre_handlers and create_post_handlers.

# File lib/rjack-jetty.rb, line 186
def create_handlers
  ( create_pre_handlers + create_post_handlers )
end

create_pool() click to toggle source

Return a org.eclipse.thread.ThreadPool implementation.

This implementation creates a QueuedThreadPool with #min_threads (default #max_threads / 4), and #max_threads (default 20).

# File lib/rjack-jetty.rb, line 163
def create_pool
  pool = QueuedThreadPool.new
  pool.min_threads = [ @min_threads || ( @max_threads / 4 ), 4 ].max
  pool.max_threads = [ @max_threads, 5 ].max
  pool
end

create_post_handlers() click to toggle source

Returns an Array of “post” org.eclipse.jetty.Handler instances.

This implementation returns a DefaultHandler instance, and any handler returned by create_request_log_handler.

# File lib/rjack-jetty.rb, line 211
def create_post_handlers
  [ DefaultHandler.new, # Handle errors, etc.
    create_request_log_handler ]
end

create_pre_handlers() click to toggle source

Returns an Array of “pre” org.eclipse.jetty.Handler instances.

This implementation returns an array containing a single ContextHandlerCollection which itself contains the context handlers set by #create_context_handlers, or an empty array if no context handlers were set.

# File lib/rjack-jetty.rb, line 196
def create_pre_handlers
  ctx_handlers = ContextHandlerCollection.new
  create_context_handlers( ctx_handlers )
  h = ctx_handlers.handlers
  if( h.nil? || h.length == 0 )
    [ ]
  else
    [ ctx_handlers ]
  end
end

create_request_log( log_file ) click to toggle source

Create a NCSARequestLog to append to log_file

# File lib/rjack-jetty.rb, line 272
def create_request_log( log_file )
  log = if log_file == :stderr
          NCSARequestLog.new
        else
          NCSARequestLog.new( log_file )
        end
  log.log_time_zone = java.util.TimeZone::getDefault.getID
  log.append = true;
  log
end

create_request_log_handler() click to toggle source

Create RequestLogHandler from any set #request_log_file

# File lib/rjack-jetty.rb, line 263
def create_request_log_handler
  if @request_log_file
    log_handler = RequestLogHandler.new
    log_handler.request_log = create_request_log( @request_log_file )
    log_handler
  end
end

create_servlet_contexts( context_handler_collection ) click to toggle source

Create context handlers from servlet_contexts.

# File lib/rjack-jetty.rb, line 245
def create_servlet_contexts( context_handler_collection )
  @servlet_contexts.each do |ctx, s_o|
    servlets, options = s_o
    context = ServletContextHandler.new( context_handler_collection, ctx, options )
    servlets.each do |path, servlet|
      context.add_servlet( ServletHolder.new( servlet ), path )
    end
  end
end

create_static_contexts( context_handler_collection ) click to toggle source

Create context handlers for static resources from #static_contexts

# File lib/rjack-jetty.rb, line 227
def create_static_contexts( context_handler_collection )
  @static_contexts.each do |ctx, rpath|
    ch = ContextHandler.new( context_handler_collection, ctx )
    ch.resource_base = rpath
    ch.handler = ResourceHandler.new
    ch.handler.welcome_files =
      @static_welcome_files.to_java( java.lang.String )
  end
end

create_webapp_contexts( context_handler_collection ) click to toggle source

Create webapp context handlers from webapp_contexts.

# File lib/rjack-jetty.rb, line 256
def create_webapp_contexts( context_handler_collection )
  @webapp_contexts.each do |ctx, webapp_path|
    WebAppContext.new( context_handler_collection, webapp_path, ctx )
  end
end

set_context_servlets( context_path, servlets, options = ServletContextHandler::NO_SESSIONS ) click to toggle source

Set a context of servlets given context_path, a servlets hash (mapping path to Servlet), and options.

# File lib/rjack-jetty.rb, line 239
def set_context_servlets( context_path, servlets,
                          options = ServletContextHandler::NO_SESSIONS )
  @servlet_contexts[ context_path ] = [ servlets, options ]
end