scout_realtime 0.5.1

data/lib/vendor/rack-1.5.2/lib/rack/file.rb

@@ -0,0 +1,138 @@
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+
+module Rack
+  # Rack::File serves files below the +root+ directory given, according to the
+  # path info of the Rack request.
+  # e.g. when Rack::File.new("/etc") is used, you can access 'passwd' file
+  # as http://localhost:9292/passwd
+  #
+  # Handlers can detect if bodies are a Rack::File, and use mechanisms
+  # like sendfile on the +path+.
+
+  class File
+    SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
+    ALLOWED_VERBS = %w[GET HEAD]
+
+    attr_accessor :root
+    attr_accessor :path
+    attr_accessor :cache_control
+
+    alias :to_path :path
+
+    def initialize(root, headers={}, default_mime = 'text/plain')
+      @root = root
+      @headers = headers
+      @default_mime = default_mime
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    F = ::File
+
+    def _call(env)
+      unless ALLOWED_VERBS.include? env["REQUEST_METHOD"]
+        return fail(405, "Method Not Allowed")
+      end
+
+      path_info = Utils.unescape(env["PATH_INFO"])
+      parts = path_info.split SEPS
+
+      clean = []
+
+      parts.each do |part|
+        next if part.empty? || part == '.'
+        part == '..' ? clean.pop : clean << part
+      end
+
+      @path = F.join(@root, *clean)
+
+      available = begin
+        F.file?(@path) && F.readable?(@path)
+      rescue SystemCallError
+        false
+      end
+
+      if available
+        serving(env)
+      else
+        fail(404, "File not found: #{path_info}")
+      end
+    end
+
+    def serving(env)
+      last_modified = F.mtime(@path).httpdate
+      return [304, {}, []] if env['HTTP_IF_MODIFIED_SINCE'] == last_modified
+
+      headers = { "Last-Modified" => last_modified }
+      mime = Mime.mime_type(F.extname(@path), @default_mime)
+      headers["Content-Type"] = mime if mime
+
+      # Set custom headers
+      @headers.each { |field, content| headers[field] = content } if @headers
+
+      response = [ 200, headers, env["REQUEST_METHOD"] == "HEAD" ? [] : self ]
+
+      # NOTE:
+      #   We check via File::size? whether this file provides size info
+      #   via stat (e.g. /proc files often don't), otherwise we have to
+      #   figure it out by reading the whole file into memory.
+      size = F.size?(@path) || Utils.bytesize(F.read(@path))
+
+      ranges = Rack::Utils.byte_ranges(env, size)
+      if ranges.nil? || ranges.length > 1
+        # No ranges, or multiple ranges (which we don't support):
+        # TODO: Support multiple byte-ranges
+        response[0] = 200
+        @range = 0..size-1
+      elsif ranges.empty?
+        # Unsatisfiable. Return error, and file size:
+        response = fail(416, "Byte range unsatisfiable")
+        response[1]["Content-Range"] = "bytes */#{size}"
+        return response
+      else
+        # Partial content:
+        @range = ranges[0]
+        response[0] = 206
+        response[1]["Content-Range"] = "bytes #{@range.begin}-#{@range.end}/#{size}"
+        size = @range.end - @range.begin + 1
+      end
+
+      response[1]["Content-Length"] = size.to_s
+      response
+    end
+
+    def each
+      F.open(@path, "rb") do |file|
+        file.seek(@range.begin)
+        remaining_len = @range.end-@range.begin+1
+        while remaining_len > 0
+          part = file.read([8192, remaining_len].min)
+          break unless part
+          remaining_len -= part.length
+
+          yield part
+        end
+      end
+    end
+
+    private
+
+    def fail(status, body)
+      body += "\n"
+      [
+        status,
+        {
+          "Content-Type" => "text/plain",
+          "Content-Length" => body.size.to_s,
+          "X-Cascade" => "pass"
+        },
+        [body]
+      ]
+    end
+
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/cgi.rb

@@ -0,0 +1,61 @@
+require 'rack/content_length'
+require 'rack/rewindable_input'
+
+module Rack
+  module Handler
+    class CGI
+      def self.run(app, options=nil)
+        $stdin.binmode
+        serve app
+      end
+
+      def self.serve(app)
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        env.update({"rack.version" => Rack::VERSION,
+                     "rack.input" => Rack::RewindableInput.new($stdin),
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => true,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+
+      def self.send_headers(status, headers)
+        $stdout.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            $stdout.print "#{k}: #{v}\r\n"
+          }
+        }
+        $stdout.print "\r\n"
+        $stdout.flush
+      end
+
+      def self.send_body(body)
+        body.each { |part|
+          $stdout.print part
+          $stdout.flush
+        }
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/evented_mongrel.rb

@@ -0,0 +1,8 @@
+require 'swiftcore/evented_mongrel'
+
+module Rack
+  module Handler
+    class EventedMongrel < Handler::Mongrel
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/fastcgi.rb

@@ -0,0 +1,98 @@
+require 'fcgi'
+require 'socket'
+require 'rack/content_length'
+require 'rack/rewindable_input'
+
+if defined? FCGI::Stream
+  class FCGI::Stream
+    alias _rack_read_without_buffer read
+
+    def read(n, buffer=nil)
+      buf = _rack_read_without_buffer n
+      buffer.replace(buf.to_s)  if buffer
+      buf
+    end
+  end
+end
+
+module Rack
+  module Handler
+    class FastCGI
+      def self.run(app, options={})
+        if options[:File]
+          STDIN.reopen(UNIXServer.new(options[:File]))
+        elsif options[:Port]
+          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
+        end
+        FCGI.each { |request|
+          serve request, app
+        }
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
+        }
+      end
+
+      def self.serve(request, app)
+        env = request.env
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        rack_input = RewindableInput.new(request.in)
+
+        env.update({"rack.version" => Rack::VERSION,
+                     "rack.input" => rack_input,
+                     "rack.errors" => request.err,
+
+                     "rack.multithread" => false,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
+        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
+
+        begin
+          status, headers, body = app.call(env)
+          begin
+            send_headers request.out, status, headers
+            send_body request.out, body
+          ensure
+            body.close  if body.respond_to? :close
+          end
+        ensure
+          rack_input.close
+          request.finish
+        end
+      end
+
+      def self.send_headers(out, status, headers)
+        out.print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            out.print "#{k}: #{v}\r\n"
+          }
+        }
+        out.print "\r\n"
+        out.flush
+      end
+
+      def self.send_body(out, body)
+        body.each { |part|
+          out.print part
+          out.flush
+        }
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/lsws.rb

@@ -0,0 +1,61 @@
+require 'lsapi'
+require 'rack/content_length'
+require 'rack/rewindable_input'
+
+module Rack
+  module Handler
+    class LSWS
+      def self.run(app, options=nil)
+        while LSAPI.accept != nil
+          serve app
+        end
+      end
+      def self.serve(app)
+        env = ENV.to_hash
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
+
+        rack_input = RewindableInput.new($stdin.read.to_s)
+
+        env.update(
+          "rack.version" => Rack::VERSION,
+          "rack.input" => rack_input,
+          "rack.errors" => $stderr,
+          "rack.multithread" => false,
+          "rack.multiprocess" => true,
+          "rack.run_once" => false,
+          "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+        )
+
+        env["QUERY_STRING"] ||= ""
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["REQUEST_PATH"] ||= "/"
+        status, headers, body = app.call(env)
+        begin
+          send_headers status, headers
+          send_body body
+        ensure
+          body.close if body.respond_to? :close
+        end
+      ensure
+        rack_input.close
+      end
+      def self.send_headers(status, headers)
+        print "Status: #{status}\r\n"
+        headers.each { |k, vs|
+          vs.split("\n").each { |v|
+            print "#{k}: #{v}\r\n"
+          }
+        }
+        print "\r\n"
+        STDOUT.flush
+      end
+      def self.send_body(body)
+        body.each { |part|
+          print part
+          STDOUT.flush
+        }
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/mongrel.rb

@@ -0,0 +1,100 @@
+require 'mongrel'
+require 'stringio'
+require 'rack/content_length'
+require 'rack/chunked'
+
+module Rack
+  module Handler
+    class Mongrel < ::Mongrel::HttpHandler
+      def self.run(app, options={})
+        server = ::Mongrel::HttpServer.new(
+          options[:Host]           || '0.0.0.0',
+          options[:Port]           || 8080,
+          options[:num_processors] || 950,
+          options[:throttle]       || 0,
+          options[:timeout]        || 60)
+        # Acts like Rack::URLMap, utilizing Mongrel's own path finding methods.
+        # Use is similar to #run, replacing the app argument with a hash of
+        # { path=>app, ... } or an instance of Rack::URLMap.
+        if options[:map]
+          if app.is_a? Hash
+            app.each do |path, appl|
+              path = '/'+path unless path[0] == ?/
+              server.register(path, Rack::Handler::Mongrel.new(appl))
+            end
+          elsif app.is_a? URLMap
+            app.instance_variable_get(:@mapping).each do |(host, path, appl)|
+             next if !host.nil? && !options[:Host].nil? && options[:Host] != host
+             path = '/'+path unless path[0] == ?/
+             server.register(path, Rack::Handler::Mongrel.new(appl))
+            end
+          else
+            raise ArgumentError, "first argument should be a Hash or URLMap"
+          end
+        else
+          server.register('/', Rack::Handler::Mongrel.new(app))
+        end
+        yield server  if block_given?
+        server.run.join
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "Processors=N" => "Number of concurrent processors to accept (default: 950)",
+          "Timeout=N" => "Time before a request is dropped for inactivity (default: 60)",
+          "Throttle=N" => "Throttle time between socket.accept calls in hundredths of a second (default: 0)",
+        }
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def process(request, response)
+        env = Hash[request.params]
+        env.delete "HTTP_CONTENT_TYPE"
+        env.delete "HTTP_CONTENT_LENGTH"
+
+        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+
+        rack_input = request.body || StringIO.new('')
+        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+
+        env.update({"rack.version" => Rack::VERSION,
+                     "rack.input" => rack_input,
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => false, # ???
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+                   })
+        env["QUERY_STRING"] ||= ""
+
+        status, headers, body = @app.call(env)
+
+        begin
+          response.status = status.to_i
+          response.send_status(nil)
+
+          headers.each { |k, vs|
+            vs.split("\n").each { |v|
+              response.header[k] = v
+            }
+          }
+          response.send_header
+
+          body.each { |part|
+            response.write part
+            response.socket.flush
+          }
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/scgi.rb

@@ -0,0 +1,67 @@
+require 'scgi'
+require 'stringio'
+require 'rack/content_length'
+require 'rack/chunked'
+
+module Rack
+  module Handler
+    class SCGI < ::SCGI::Processor
+      attr_accessor :app
+
+      def self.run(app, options=nil)
+        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
+        new(options.merge(:app=>app,
+                          :host=>options[:Host],
+                          :port=>options[:Port],
+                          :socket=>options[:Socket])).listen
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+
+      def initialize(settings = {})
+        @app = settings[:app]
+        super(settings)
+      end
+
+      def process_request(request, input_body, socket)
+        env = Hash[request]
+        env.delete "HTTP_CONTENT_TYPE"
+        env.delete "HTTP_CONTENT_LENGTH"
+        env["REQUEST_PATH"], env["QUERY_STRING"] = env["REQUEST_URI"].split('?', 2)
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["PATH_INFO"] = env["REQUEST_PATH"]
+        env["QUERY_STRING"] ||= ""
+        env["SCRIPT_NAME"] = ""
+
+        rack_input = StringIO.new(input_body)
+        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+
+        env.update({"rack.version" => Rack::VERSION,
+                     "rack.input" => rack_input,
+                     "rack.errors" => $stderr,
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => true,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
+                   })
+        status, headers, body = app.call(env)
+        begin
+          socket.write("Status: #{status}\r\n")
+          headers.each do |k, vs|
+            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
+          end
+          socket.write("\r\n")
+          body.each {|s| socket.write(s)}
+        ensure
+          body.close if body.respond_to? :close
+        end
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/swiftiplied_mongrel.rb

@@ -0,0 +1,8 @@
+require 'swiftcore/swiftiplied_mongrel'
+
+module Rack
+  module Handler
+    class SwiftipliedMongrel < Handler::Mongrel
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/thin.rb

@@ -0,0 +1,27 @@
+require "thin"
+require "rack/content_length"
+require "rack/chunked"
+
+module Rack
+  module Handler
+    class Thin
+      def self.run(app, options={})
+        host = options.delete(:Host) || '0.0.0.0'
+        port = options.delete(:Port) || 8080
+        args = [host, port, app, options]
+        # Thin versions below 0.8.0 do not support additional options
+        args.pop if ::Thin::VERSION::MAJOR < 1 && ::Thin::VERSION::MINOR < 8
+        server = ::Thin::Server.new(*args)
+        yield server if block_given?
+        server.start
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/handler/webrick.rb

@@ -0,0 +1,81 @@
+require 'webrick'
+require 'stringio'
+require 'rack/content_length'
+
+module Rack
+  module Handler
+    class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
+      def self.run(app, options={})
+        options[:BindAddress] = options.delete(:Host) if options[:Host]
+        options[:Port] ||= 8080
+        @server = ::WEBrick::HTTPServer.new(options)
+        @server.mount "/", Rack::Handler::WEBrick, app
+        yield @server  if block_given?
+        @server.start
+      end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
+
+      def self.shutdown
+        @server.shutdown
+        @server = nil
+      end
+
+      def initialize(server, app)
+        super server
+        @app = app
+      end
+
+      def service(req, res)
+        env = req.meta_vars
+        env.delete_if { |k, v| v.nil? }
+
+        rack_input = StringIO.new(req.body.to_s)
+        rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+
+        env.update({"rack.version" => Rack::VERSION,
+                     "rack.input" => rack_input,
+                     "rack.errors" => $stderr,
+
+                     "rack.multithread" => true,
+                     "rack.multiprocess" => false,
+                     "rack.run_once" => false,
+
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
+                   })
+
+        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
+        env["QUERY_STRING"] ||= ""
+        unless env["PATH_INFO"] == ""
+          path, n = req.request_uri.path, env["SCRIPT_NAME"].length
+          env["PATH_INFO"] = path[n, path.length-n]
+        end
+        env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env["PATH_INFO"]].join
+
+        status, headers, body = @app.call(env)
+        begin
+          res.status = status.to_i
+          headers.each { |k, vs|
+            if k.downcase == "set-cookie"
+              res.cookies.concat vs.split("\n")
+            else
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[k] = vs.split("\n").join(", ")
+            end
+          }
+          body.each { |part|
+            res.body << part
+          }
+        ensure
+          body.close  if body.respond_to? :close
+        end
+      end
+    end
+  end
+end