Class: Rack::Server

Inherits:
Object
  • Object
show all
Defined in:
rack/rack/server.rb

Defined Under Namespace

Classes: Options

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Server) initialize(options = nil)

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



178
179
180
181
 
# File 'rack/rack/server.rb', line 178

def initialize(options = nil)
  @options = options
  @app = options[:app] if options && options[:app]
end

Instance Attribute Details

- (void) options 



183
184
185
 
# File 'rack/rack/server.rb', line 183

def options
  @options ||= parse_options(ARGV)
end

Class Method Details

+ (void) logging_middleware 



202
203
204
205
206
 
# File 'rack/rack/server.rb', line 202

def self.logging_middleware
  lambda { |server|
    server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr]
  }
end

+ (void) middleware 



208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'rack/rack/server.rb', line 208

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

+ (void) start(options = nil)

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, => 'text/html', ['hello world']] end, :server => 'cgi' )

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



140
141
142
 
# File 'rack/rack/server.rb', line 140

def self.start(options = nil)
  new(options).start
end

Instance Method Details

- (void) app 



198
199
200
 
# File 'rack/rack/server.rb', line 198

def app
  @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
end

- (void) default_options 



187
188
189
190
191
192
193
194
195
196
 
# File 'rack/rack/server.rb', line 187

def default_options
  {
    :environment => ENV['RACK_ENV'] || "development",
    :pid         => nil,
    :Port        => 9292,
    :Host        => "0.0.0.0",
    :AccessLog   => [],
    :config      => "config.ru"
  }
end

- (void) middleware 



221
222
223
 
# File 'rack/rack/server.rb', line 221

def middleware
  self.class.middleware
end

- (void) server 



267
268
269
 
# File 'rack/rack/server.rb', line 267

def server
  @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
end

- (void) start(&blk) 



225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
 
# File 'rack/rack/server.rb', line 225

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