steamcannon-thin 1.2.8

data/lib/thin/server.rb

@@ -0,0 +1,253 @@
+module Thin
+  # The uterly famous Thin HTTP server.
+  # It listen for incoming request through a given +backend+
+  # and forward all request to +app+.
+  #
+  # == TCP server
+  # Create a new TCP server on bound to <tt>host:port</tt> by specifiying +host+
+  # and +port+ as the first 2 arguments.
+  #
+  #   Thin::Server.start('0.0.0.0', 3000, app)
+  #
+  # == UNIX domain server
+  # Create a new UNIX domain socket bound to +socket+ file by specifiying a filename
+  # as the first argument. Eg.: /tmp/thin.sock. If the first argument contains a <tt>/</tt>
+  # it will be assumed to be a UNIX socket. 
+  #
+  #   Thin::Server.start('/tmp/thin.sock', app)
+  #
+  # == Using a custom backend
+  # You can implement your own way to connect the server to its client by creating your
+  # own Backend class and pass it as the :backend option.
+  #
+  #   Thin::Server.start('galaxy://faraway', 1345, app, :backend => Thin::Backends::MyFancyBackend)
+  #
+  # == Rack application (+app+)
+  # All requests will be processed through +app+ that must be a valid Rack adapter.
+  # A valid Rack adapter (application) must respond to <tt>call(env#Hash)</tt> and
+  # return an array of <tt>[status, headers, body]</tt>.
+  #
+  # == Building an app in place
+  # If a block is passed, a <tt>Rack::Builder</tt> instance
+  # will be passed to build the +app+. So you can do cool stuff like this:
+  # 
+  #   Thin::Server.start('0.0.0.0', 3000) do
+  #     use Rack::CommonLogger
+  #     use Rack::ShowExceptions
+  #     map "/lobster" do
+  #       use Rack::Lint
+  #       run Rack::Lobster.new
+  #     end
+  #   end
+  #
+  # == Controlling with signals
+  # * QUIT: Gracefull shutdown (see Server#stop)
+  # * INT and TERM: Force shutdown (see Server#stop!)
+  # Disable signals by passing <tt>:signals => false</tt>
+  # 
+  class Server
+    include Logging
+    include Daemonizable
+    extend  Forwardable
+    
+    # Default values
+    DEFAULT_TIMEOUT                        = 30 #sec
+    DEFAULT_HOST                           = '0.0.0.0'
+    DEFAULT_PORT                           = 3000
+    DEFAULT_MAXIMUM_CONNECTIONS            = 1024
+    DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS = 512
+        
+    # Application (Rack adapter) called with the request that produces the response.
+    attr_accessor :app
+
+    # A tag that will show in the process listing
+    attr_accessor :tag
+
+    # Backend handling the connections to the clients.
+    attr_accessor :backend
+    
+    # Maximum number of seconds for incoming data to arrive before the connection
+    # is dropped.
+    def_delegators :backend, :timeout, :timeout=
+    
+    # Maximum number of file or socket descriptors that the server may open.
+    def_delegators :backend, :maximum_connections, :maximum_connections=
+    
+    # Maximum number of connection that can be persistent at the same time.
+    # Most browser never close the connection so most of the time they are closed
+    # when the timeout occur. If we don't control the number of persistent connection,
+    # if would be very easy to overflow the server for a DoS attack.
+    def_delegators :backend, :maximum_persistent_connections, :maximum_persistent_connections=
+    
+    # Allow using threads in the backend.
+    def_delegators :backend, :threaded?, :threaded=
+    
+    # Allow using SSL in the backend.
+    def_delegators :backend, :ssl?, :ssl=, :ssl_options=
+    
+    # Address and port on which the server is listening for connections.
+    def_delegators :backend, :host, :port
+    
+    # UNIX domain socket on which the server is listening for connections.
+    def_delegator :backend, :socket
+    
+    # Disable the use of epoll under Linux
+    def_delegators :backend, :no_epoll, :no_epoll=
+    
+    def initialize(*args, &block)
+      host, port, options = DEFAULT_HOST, DEFAULT_PORT, {}
+      
+      # Guess each parameter by its type so they can be
+      # received in any order.
+      args.each do |arg|
+        case arg
+        when Fixnum, /^\d+$/ then port    = arg.to_i
+        when String          then host    = arg
+        when Hash            then options = arg
+        else
+          @app = arg if arg.respond_to?(:call)
+        end
+      end
+      
+      # Set tag if needed
+      self.tag = options[:tag]
+
+      # Try to intelligently select which backend to use.
+      @backend = select_backend(host, port, options)
+      
+      load_cgi_multipart_eof_fix
+      
+      @backend.server = self
+      
+      # Set defaults
+      @backend.maximum_connections            = DEFAULT_MAXIMUM_CONNECTIONS
+      @backend.maximum_persistent_connections = DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS
+      @backend.timeout                        = DEFAULT_TIMEOUT
+      
+      # Allow using Rack builder as a block
+      @app = Rack::Builder.new(&block).to_app if block
+      
+      # If in debug mode, wrap in logger adapter
+      @app = Rack::CommonLogger.new(@app) if Logging.debug?
+      
+      setup_signals unless options[:signals].class == FalseClass
+    end
+    
+    # Lil' shortcut to turn this:
+    # 
+    #   Server.new(...).start
+    # 
+    # into this:
+    # 
+    #   Server.start(...)
+    # 
+    def self.start(*args, &block)
+      new(*args, &block).start!
+    end
+        
+    # Start the server and listen for connections.
+    def start
+      raise ArgumentError, 'app required' unless @app
+      
+      log   ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::CODENAME})"
+      debug ">> Debugging ON"
+      trace ">> Tracing ON"
+      
+      log ">> Maximum connections set to #{@backend.maximum_connections}"
+      log ">> Listening on #{@backend}, CTRL+C to stop"
+      
+      @backend.start
+    end
+    alias :start! :start
+    
+    # == Gracefull shutdown
+    # Stops the server after processing all current connections.
+    # As soon as this method is called, the server stops accepting
+    # new requests and wait for all current connections to finish.
+    # Calling twice is the equivalent of calling <tt>stop!</tt>.
+    def stop
+      if running?
+        @backend.stop
+        unless @backend.empty?
+          log ">> Waiting for #{@backend.size} connection(s) to finish, " +
+                 "can take up to #{timeout} sec, CTRL+C to stop now"
+        end
+      else
+        stop!
+      end
+    end
+    
+    # == Force shutdown
+    # Stops the server closing all current connections right away.
+    # This doesn't wait for connection to finish their work and send data.
+    # All current requests will be dropped.
+    def stop!
+      log ">> Stopping ..."
+
+      @backend.stop!
+    end
+    
+    # == Configure the server
+    # The process might need to have superuser privilege to configure
+    # server with optimal options.
+    def config
+      @backend.config
+    end
+    
+    # Name of the server and type of backend used.
+    # This is also the name of the process in which Thin is running as a daemon.
+    def name
+      "thin server (#{@backend})" + (tag ? " [#{tag}]" : "")
+    end
+    alias :to_s :name
+    
+    # Return +true+ if the server is running and ready to receive requests.
+    # Note that the server might still be running and return +false+ when
+    # shuting down and waiting for active connections to complete.
+    def running?
+      @backend.running?
+    end
+    
+    protected
+      # Register signals:
+      # * INT calls +stop+ to shutdown gracefully.
+      # * TERM calls <tt>stop!</tt> to force shutdown.
+      def setup_signals
+        trap('INT')  { stop! }
+        trap('TERM') { stop! }
+        unless Thin.win?
+          trap('QUIT') { stop }
+          trap('HUP')  { restart }
+        end
+      end
+      
+      def select_backend(host, port, options)
+        case
+        when options.has_key?(:backend)
+          raise ArgumentError, ":backend must be a class" unless options[:backend].is_a?(Class)
+          options[:backend].new(host, port, options)
+        when options.has_key?(:swiftiply)
+          Backends::SwiftiplyClient.new(host, port, options)
+        when host.include?('/')
+          Backends::UnixServer.new(host)
+        else
+          Backends::TcpServer.new(host, port)
+        end
+      end
+      
+      # Taken from Mongrel cgi_multipart_eof_fix
+      # Ruby 1.8.5 has a security bug in cgi.rb, we need to patch it.
+      def load_cgi_multipart_eof_fix
+        version = RUBY_VERSION.split('.').map { |i| i.to_i }
+        
+        if version[0] <= 1 && version[1] <= 8 && version[2] <= 5 && RUBY_PLATFORM !~ /java/
+          begin
+            require 'cgi_multipart_eof_fix'
+          rescue LoadError
+            log "!! Ruby 1.8.5 is not secure please install cgi_multipart_eof_fix:"
+            log "   gem install cgi_multipart_eof_fix"
+          end
+        end
+      end
+  end
+end

data/lib/thin/stats.html.erb

@@ -0,0 +1,216 @@
+<%#
+# Taken from Rack::ShowException
+# adapted from Django <djangoproject.com>
+# Copyright (c) 2005, the Lawrence Journal-World
+# Used under the modified BSD license:
+# http://www.xfree86.org/3.3.6/COPYRIGHT2.html#5
+%>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html lang="en">
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <meta name="robots" content="NONE,NOARCHIVE" />
+  <title>Thin Stats</title>
+  <style type="text/css">
+    html * { padding:0; margin:0; }
+    body * { padding:10px 20px; }
+    body * * { padding:0; }
+    body { font:small sans-serif; }
+    body>div { border-bottom:1px solid #ddd; }
+    h1 { font-weight:normal; }
+    h2 { margin-bottom:.8em; }
+    h2 span { font-size:80%; color:#666; font-weight:normal; }
+    h3 { margin:1em 0 .5em 0; }
+    h4 { margin:0 0 .5em 0; font-weight: normal; }
+    table {
+        border:1px solid #ccc; border-collapse: collapse; background:white; }
+    tbody td, tbody th { vertical-align:top; padding:2px 3px; }
+    thead th {
+        padding:1px 6px 1px 3px; background:#fefefe; text-align:left;
+        font-weight:normal; font-size:11px; border:1px solid #ddd; }
+    tbody th { text-align:right; color:#666; padding-right:.5em; }
+    table.vars { margin:5px 0 2px 40px; }
+    table.vars td, table.req td { font-family:monospace; }
+    table td.code { width:100%;}
+    table td.code div { overflow:hidden; }
+    table.source th { color:#666; }
+    table.source td {
+        font-family:monospace; white-space:pre; border-bottom:1px solid #eee; }
+    ul.traceback { list-style-type:none; }
+    ul.traceback li.frame { margin-bottom:1em; }
+    div.context { margin: 10px 0; }
+    div.context ol {
+        padding-left:30px; margin:0 10px; list-style-position: inside; }
+    div.context ol li {
+        font-family:monospace; white-space:pre; color:#666; cursor:pointer; }
+    div.context ol.context-line li { color:black; background-color:#ccc; }
+    div.context ol.context-line li span { float: right; }
+    div.commands { margin-left: 40px; }
+    div.commands a { color:black; text-decoration:none; }
+    #summary { background: #ffc; }
+    #summary h2 { font-weight: normal; color: #666; }
+    #summary ul#quicklinks { list-style-type: none; margin-bottom: 2em; }
+    #summary ul#quicklinks li { float: left; padding: 0 1em; }
+    #summary ul#quicklinks>li+li { border-left: 1px #666 solid; }
+    #explanation { background:#eee; }
+    #template, #template-not-exist { background:#f6f6f6; }
+    #template-not-exist ul { margin: 0 0 0 20px; }
+    #traceback { background:#eee; }
+    #summary table { border:none; background:transparent; }
+    #requests { background:#f6f6f6; padding-left:120px; }
+    #requests h2, #requests h3 { position:relative; margin-left:-100px; }
+    #requests h3 { margin-bottom:-1em; }
+    .error { background: #ffc; }
+    .specific { color:#cc3300; font-weight:bold; }
+  </style>
+</head>
+<body>
+
+<div id="summary">
+  <h1>Server stats</h1>
+  <h2><%= Thin::SERVER %></h2>
+  <table>
+    <tr>
+      <th>Uptime</th>
+      <td><%= Time.now - @start_time %> sec</td>
+    </tr>
+    <tr>
+      <th>PID</th>
+      <td><%=h Process.pid %></td>
+    </tr>
+  </table>
+  
+  <% if @last_request %>
+    <h3>Jump to:</h3>
+    <ul id="quicklinks">
+      <li><a href="#get-info">GET</a></li>
+      <li><a href="#post-info">POST</a></li>
+      <li><a href="#cookie-info">Cookies</a></li>
+      <li><a href="#env-info">ENV</a></li>
+    </ul>
+  <% end %>
+</div>
+
+<div id="stats">
+  <h2>Requests</h2>
+  <h3>Stats</h3>
+  <table class="req">
+    <tr>
+      <td>Requests</td>
+      <td><%= @requests %></td>
+    </tr>
+    <tr>
+      <td>Finished</td>
+      <td><%= @requests_finished %></td>
+    </tr>
+    <tr>
+      <td>Errors</td>
+      <td><%= @requests - @requests_finished %></td>
+    </tr>
+    <tr>
+      <td>Last request</td>
+      <td><%= @last_request_time %> sec</td>
+    </tr>
+  </table>
+</div>
+
+<% if @last_request %>
+  <div id="requestinfo">
+    <h2>Last Request information</h2>
+
+    <h3 id="get-info">GET</h3>
+    <% unless @last_request.GET.empty? %>
+      <table class="req">
+        <thead>
+          <tr>
+            <th>Variable</th>
+            <th>Value</th>
+          </tr>
+        </thead>
+        <tbody>
+            <% @last_request.GET.sort_by { |k, v| k.to_s }.each { |key, val| %>
+            <tr>
+              <td><%=h key %></td>
+              <td class="code"><div><%=h val.inspect %></div></td>
+            </tr>
+            <% } %>
+        </tbody>
+      </table>
+    <% else %>
+      <p>No GET data.</p>
+    <% end %>
+
+    <h3 id="post-info">POST</h3>
+    <% unless @last_request.POST.empty? %>
+      <table class="req">
+        <thead>
+          <tr>
+            <th>Variable</th>
+            <th>Value</th>
+          </tr>
+        </thead>
+        <tbody>
+            <% @last_request.POST.sort_by { |k, v| k.to_s }.each { |key, val| %>
+            <tr>
+              <td><%=h key %></td>
+              <td class="code"><div><%=h val.inspect %></div></td>
+            </tr>
+            <% } %>
+        </tbody>
+      </table>
+    <% else %>
+      <p>No POST data.</p>
+    <% end %>
+
+
+    <h3 id="cookie-info">COOKIES</h3>
+    <% unless @last_request.cookies.empty? %>
+      <table class="req">
+        <thead>
+          <tr>
+            <th>Variable</th>
+            <th>Value</th>
+          </tr>
+        </thead>
+        <tbody>
+          <% @last_request.cookies.each { |key, val| %>
+            <tr>
+              <td><%=h key %></td>
+              <td class="code"><div><%=h val.inspect %></div></td>
+            </tr>
+          <% } %>
+        </tbody>
+      </table>
+    <% else %>
+      <p>No cookie data.</p>
+    <% end %>
+
+    <h3 id="env-info">Rack ENV</h3>
+      <table class="req">
+        <thead>
+          <tr>
+            <th>Variable</th>
+            <th>Value</th>
+          </tr>
+        </thead>
+        <tbody>
+            <% @last_request.env.sort_by { |k, v| k.to_s }.each { |key, val| %>
+            <tr>
+              <td><%=h key %></td>
+              <td class="code"><div><%=h val %></div></td>
+            </tr>
+            <% } %>
+        </tbody>
+      </table>
+
+  </div>
+<% end %>
+
+<div id="explanation">
+  <p>
+    You're seeing this page because you use <code>Thin::Stats</code>.
+  </p>
+</div>
+
+</body>
+</html>