Class: Rack::Server

### Home Classes Methods

### In Files

- lib/rack/server.rb

### Parent

Object

### Namespace

- CLASS Rack::Server::Options

### Methods

- ::middleware
- ::new
- ::start
- #app
- #default_options
- #middleware
- #options
- #server
- #start

### Files

- KNOWN-ISSUES
- README
- SPEC

### Class/Module Index

Quicksearch

- Rack
- Rack::Auth
- Rack::Auth::AbstractHandler
- Rack::Auth::AbstractRequest
- Rack::Auth::Basic
- Rack::Auth::Basic::Request
- Rack::Auth::Digest
- Rack::Auth::Digest::MD5
- Rack::Auth::Digest::Nonce
- Rack::Auth::Digest::Params
- Rack::Auth::Digest::Request
- Rack::Builder
- Rack::Cascade
- Rack::Chunked
- Rack::CommonLogger
- Rack::ConditionalGet
- Rack::Config
- Rack::ContentLength
- Rack::ContentType
- Rack::Deflater
- Rack::Deflater::DeflateStream
- Rack::Deflater::GzipStream
- Rack::Directory
- Rack::ETag
- Rack::File
- Rack::ForwardRequest
- Rack::Handler
- Rack::Handler::CGI
- Rack::Handler::EventedMongrel
- Rack::Handler::FastCGI
- Rack::Handler::LSWS
- Rack::Handler::Mongrel
- Rack::Handler::SCGI
- Rack::Handler::SwiftipliedMongrel
- Rack::Handler::Thin
- Rack::Handler::WEBrick
- Rack::Head
- Rack::Lint
- Rack::Lobster
- Rack::Lock
- Rack::Logger
- Rack::MethodOverride
- Rack::Mime
- Rack::MockRequest
- Rack::MockRequest::FatalWarner
- Rack::MockRequest::FatalWarning
- Rack::MockResponse
- Rack::NullLogger
- Rack::Recursive
- Rack::Reloader
- Rack::Reloader::Stat
- Rack::Request
- Rack::Response
- Rack::Response::Helpers
- Rack::RewindableInput
- Rack::RewindableInput::Tempfile
- Rack::Runtime
- Rack::Sendfile
- Rack::Server
- Rack::Server::Options
- Rack::Session
- Rack::Session::Abstract
- Rack::Session::Abstract::ID
- Rack::Session::Cookie
- Rack::Session::Memcache
- Rack::Session::Pool
- Rack::ShowExceptions
- Rack::ShowStatus
- Rack::Static
- Rack::URLMap
- Rack::Utils
- Rack::Utils::Context
- Rack::Utils::HeaderHash
- Rack::Utils::Multipart
- Rack::Utils::Multipart::UploadedFile
- FCGI
- FCGI::Stream

No matching classes.

# Rack::Server

### Attributes

options[W]

### Public Class Methods

middleware() click to toggle source

    # File lib/rack/server.rb, line 168
    def self.middleware
      @middleware ||= begin
        m = Hash.new {|h,k| h[k] = []}
        m["deployment"].concat  [lambda {|server| server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr] }]
        m["development"].concat m["deployment"] + [[Rack::ShowExceptions], [Rack::Lint]]
        m
      end
    end

new(options = nil) click to toggle source

Options may include:

- :app

      a rack application to run (overrides :config)

- :config

      a rackup configuration file path to load (.ru)

- :environment

      this selects the middleware that will be wrapped around
      your application. Default options available are:
        - development: CommonLogger, ShowExceptions, and Lint
        - deployment: CommonLogger
        - none: no extra middleware
      note: when the server is a cgi server, CommonLogger is not included.

- :server

      choose a specific Rack::Handler, e.g. cgi, fcgi, webrick

- :daemonize

      if true, the server will daemonize itself (fork, detach, etc)

- :pid

      path to write a pid file after daemonize

- :Host

      the host address to bind to (used by supporting Rack::Handler)

- :Port

      the port to bind to (used by supporting Rack::Handler)

- :AccessLog

      webrick acess log options (or supporting Rack::Handler)

- :debug

      turn on debug output ($DEBUG = true)

- :warn

      turn on warnings ($-w = true)

- :include

      add given paths to $LOAD_PATH

- :require

      require the given libraries

    # File lib/rack/server.rb, line 137
    def initialize(options = nil)
      @options = options
    end

start(options = nil) click to toggle source

Start a new rack server (like running rackup). This will parse ARGV and provide standard ARGV rackup options, defaulting to load ‘config.ru’.

Providing an options hash will prevent ARGV parsing and will not include any default options.

This method can be used to very easily launch a CGI application, for example:

    Rack::Server.start(
      :app => lambda do |e|
        [200, {'Content-Type' => 'text/html'}, ['hello world']]
      end,
      :server => 'cgi'
    )

Further options available here are documented on Rack::Server#initialize

    # File lib/rack/server.rb, line 99
    def self.start(options = nil)
      new(options).start
    end

### Public Instance Methods

app() click to toggle source

    # File lib/rack/server.rb, line 156
    def app
      @app ||= begin
        if !::File.exist? options[:config]
          abort "configuration #{options[:config]} not found"
        end

        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
        self.options.merge! options
        app
      end
    end

default_options() click to toggle source

    # File lib/rack/server.rb, line 145
    def default_options
      {
        :environment => "development",
        :pid         => nil,
        :Port        => 9292,
        :Host        => "0.0.0.0",
        :AccessLog   => [],
        :config      => "config.ru"
      }
    end

middleware() click to toggle source

    # File lib/rack/server.rb, line 177
    def middleware
      self.class.middleware
    end

options() click to toggle source

    # File lib/rack/server.rb, line 141
    def options
      @options ||= parse_options(ARGV)
    end

server() click to toggle source

    # File lib/rack/server.rb, line 216
    def server
      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
    end

start() click to toggle source

    # File lib/rack/server.rb, line 181
    def start
      if options[:debug]
        $DEBUG = true
        require 'pp'
        p options[:server]
        pp wrapped_app
        pp app
      end

      if options[:warn]
        $-w = true
      end

      if includes = options[:include]
        $LOAD_PATH.unshift(*includes)
      end

      if library = options[:require]
        require library
      end

      daemonize_app if options[:daemonize]
      write_pid if options[:pid]

      trap(:INT) do
        if server.respond_to?(:shutdown)
          server.shutdown
        else
          exit
        end
      end

      server.run wrapped_app, options
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.