Class: Rack::Server

### Home Classes Methods

### In Files

- lib/rack/server.rb

### Parent

Object

### Namespace

- CLASS Rack::Server::Options

### Methods

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

### Files

- KNOWN-ISSUES

### 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::BodyProxy
- Rack::Builder
- Rack::Cascade
- Rack::Chunked
- Rack::Chunked::Body
- 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::Multipart
- Rack::Multipart::Generator
- Rack::Multipart::Parser
- Rack::Multipart::UploadedFile
- 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::Abstract::SessionHash
- Rack::Session::Cookie
- Rack::Session::Cookie::Base64
- Rack::Session::Cookie::Base64::Marshal
- Rack::Session::Cookie::Identity
- Rack::Session::Cookie::Reverse
- Rack::Session::Memcache
- Rack::Session::Pool
- Rack::ShowExceptions
- Rack::ShowStatus
- Rack::Static
- Rack::URLMap
- Rack::Utils
- Rack::Utils::Context
- Rack::Utils::HeaderHash
- Rack::Utils::KeySpaceConstrainedParams
- Rack::Utils::Multipart
- FCGI
- FCGI::Stream
- Object

No matching classes.

# Rack::Server

### Attributes

options[W]

### Public Class Methods

logging_middleware() click to toggle source

    # File lib/rack/server.rb, line 206
    def self.logging_middleware
      lambda { |server|
        server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr]
      }
    end

middleware() click to toggle source

    # File lib/rack/server.rb, line 212
    def self.middleware
      @middleware ||= begin
        m = Hash.new {|h,k| h[k] = []}
        m["deployment"].concat [
          [Rack::ContentLength],
          [Rack::Chunked],
          logging_middleware
        ]
        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 174
    def initialize(options = nil)
      @options = options
      @app = options[:app] if options && options[:app]
    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 136
    def self.start(options = nil)
      new(options).start
    end

### Public Instance Methods

app() click to toggle source

    # File lib/rack/server.rb, line 194
    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 183
    def default_options
      {
        :environment => ENV['RACK_ENV'] || "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 225
    def middleware
      self.class.middleware
    end

options() click to toggle source

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

server() click to toggle source

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

start(&blk) click to toggle source

    # File lib/rack/server.rb, line 229
    def start &blk
      if options[:warn]
        $-w = true
      end

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

      if library = options[:require]
        require library
      end

      if options[:debug]
        $DEBUG = true
        require 'pp'
        p options[:server]
        pp wrapped_app
        pp app
      end

      check_pid! if options[:pid]

      # Touch the wrapped app, so that the config.ru is loaded before
      # daemonization (i.e. before chdir, etc).
      wrapped_app

      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, &blk
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.