jaws 0.5.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Graham Batty
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,35 @@
+= JAWS
+
+Just Another Web Server. Obviously there are already a few in the Ruby eco-system, so I'll just list the design goals:
+
+* Have a concurrency model that's predictable and easy to understand
+  It doesn't use EventMachine and uses a small and manageable thread pool to serve requests.
+  Specifically, it can handle a concurrency of N with N threads, but doesn't accept any connections
+  above that concurrency. This is so that it doesn't drop connections if it gets overloaded, nor
+  does it advertise a concurrency level (like 950) that in a practical web app is just impossible.
+* Have a pluggable listen/accept system
+  Things like Swiftiply and CloudBridge, which have unusual means of accepting incoming connections, 
+  currently monkey patch mongrel to enable their behaviour. This server allows you to override the
+  standard accept behaviour so these systems can work without fragile object surgery.
+* Be built for rack right from the start
+  This server talks rack and only rack. It doesn't expect to be used as a standalone server.
+* Be capable of being run in pure ruby, but provide better performance if possible
+  As things move forward, having a pure ruby implementation is important for enabling people
+  to work on and improve ruby software. This server uses the http_parser gem for http parsing,
+  which provides a first class implementation in ruby and (will eventually) support using a
+  C extension that conforms to the same interface, as set out by the specs in that gem,
+  so that it can achieve the same or better parsing performance as mongrel.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Graham Batty. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "jaws"
+    gem.summary = %Q{Just Another Web Server}
+    gem.description = %Q{A Ruby web server designed to have a predictable and simple concurrency model, and to be capable of running in a pure-ruby environment.}
+    gem.email = "graham@stormbrew.ca"
+    gem.homepage = "http://github.com/stormbrew/jaws"
+    gem.authors = ["Graham Batty"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency "http_parser", ">= 0.1.2"
+    gem.add_dependency "rack", ">= 1.1.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "jaws #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/lib/jaws/server.rb

@@ -0,0 +1,324 @@
+require 'rack/utils'
+require 'http/parser'
+require 'mutex_m'
+require 'socket'
+
+module Jaws
+  def self.decapse_name(name)
+    name.gsub(%r{^([A-Z])}) { $1.downcase }.gsub(%r{([a-z])([A-Z])}) { $1 + "_" + $2.downcase }
+  end
+  def self.encapse_name(name)
+    name.gsub(%r{(^|_)([a-z])}) { $2.upcase }
+  end
+  
+  class Server
+    DefaultOptions = {
+      :Host => '0.0.0.0',
+      :Port => 8080,
+      :MaxClients => 20, 
+      :SystemCores => nil,
+      :ReadTimeout => 2,
+    }
+    
+    # The default values for most of the rack environment variables
+    DefaultRackEnv = {
+      "rack.version" => [1,1],
+      "rack.url_scheme" => "http",
+      "rack.input" => StringIO.new,
+      "rack.errors" => $stderr,
+      "rack.multithread" => true,
+      "rack.multiprocess" => false,
+      "rack.run_once" => false,
+      "SCRIPT_NAME" => "",
+      "PATH_INFO" => "",
+      "QUERY_STRING" => "",
+      "SERVER_SOFTWARE" => "Rack+Jaws",
+    }
+    
+    StatusStrings = Rack::Utils::HTTP_STATUS_CODES
+    CodesWithoutBody = Rack::Utils::STATUS_WITH_NO_ENTITY_BODY
+    
+    # The host to listen on when run(app) is called. Also set with options[:Host]
+    attr_accessor :host
+    # The port to listen on when run(app) is called. Also set with options[:Port]
+    attr_accessor :port
+    # The maximum number of requests this server should handle concurrently. Also set with options[:MaxClients]
+    # Note that you should set this legitimately to the number of clients you can actually handle and not
+    # some arbitrary high number like with Mongrel. This server will simply not accept more connections
+    # than it can handle, which allows you to run other server instances on other machines to take up the slack.
+    # A really really good rule of thumb for a database driven site is to have it be less than the number
+    # of database connections your (hopefuly properly tuned) database server can handle. If you run
+    # more than one web server machine, the TOTAL max_clients from all those servers should be less than what
+    # the database can handle.
+    attr_accessor :max_clients
+    # The number of cores the system has. This may eventually be used to determine if the process should fork
+    # if it's running on a ruby implementation that doesn't support multiprocessing. If set to nil,
+    # it'll auto-detect, and failing that just assume it shouldn't fork at all. If you want it to never
+    # fork, you should set it to 1 (1 core means 1 process).
+    # Also set with options[:SystemCores]
+    attr_accessor :system_cores
+    # The amount of time, in seconds, the server will wait without input before disconnecting the client.
+    # Also set with options[:Timeout]
+    attr_accessor :read_timeout
+    
+    # Initializes a new Jaws server object. Pass it a hash of options (:Host, :Port, :MaxClients, and :SystemCores valid)
+    def initialize(options = DefaultOptions)
+      @options = DefaultOptions.merge(options)
+      self.class::DefaultOptions.each do |k,v|
+        send(:"#{Jaws.decapse_name(k.to_s)}=", @options[k])
+      end
+      self.extend Mutex_m
+    end
+    
+    # You can re-implement this in a derived class in order to use a different
+    # mechanism to listen for connections. It should return
+    # an object that responds to accept() by returning an open connection to a
+    # client. It also has to respond to synchronize and yield to the block
+    # given to that method and be thread safe in that block. It must also
+    # respond to close() by immediately terminating any waiting accept() calls
+    # and responding to closed? with true thereafter. Close may be called
+    # from outside the object's synchronize block.
+    def create_listener(options)
+      l = TCPServer.new(@host, @port)
+      # let 10 requests back up for each request we can handle concurrently.
+      # note that this value is often truncated by the OS to numbers like 128
+      # or even 5. You may be able to raise this maximum using sysctl (on BSD/OSX)
+      # or /proc/sys/net/core/somaxconn on linux 2.6.
+      l.listen(@max_clients * 10)
+      l.extend Mutex_m # lock around use of the listener object.
+      return l
+    end
+    protected :create_listener
+    
+    # Builds an env object from the information provided. Derived handlers
+    # can override this to provide additional information.
+    def build_env(client, req)
+      rack_env = DefaultRackEnv.dup
+      req.fill_rack_env(rack_env)
+      rack_env["SERVER_PORT"] ||= @port.to_s
+      
+      if (rack_env["rack.input"].respond_to? :set_encoding)
+        rack_env["rack.input"].set_encoding "ASCII-8BIT"
+      end
+      
+      rack_env["REMOTE_PORT"], rack_env["REMOTE_ADDR"] = Socket::unpack_sockaddr_in(client.getpeername)
+      rack_env["REMOTE_PORT"] &&= rack_env["REMOTE_PORT"].to_s
+      rack_env["SERVER_PROTOCOL"] = "HTTP/" << req.version.join('.')
+      
+      return rack_env      
+    end
+    protected :build_env
+    
+    # Reads from a connection, yielding chunks of data as it goes,
+    # until the connection closes. Once the connection closes, it returns.
+    def chunked_read(io, timeout)
+      begin
+        loop do
+          list = IO.select([io], [], [], @read_timeout)
+          if (list.nil? || list.empty?)
+            # IO.select tells us we timed out by giving us nil,
+            # disconnect the non-talkative client.
+            return
+          end
+          data = io.recv(4096)
+          if (data == "")
+            # If recv returns an empty string, that means the other
+            # end closed the connection (either in response to our
+            # end closing the write pipe or because they just felt
+            # like it) so we close the connection from our end too.
+            return
+          end
+          yield data
+        end
+      ensure
+        io.close if (!io.closed?)
+      end
+    end
+    private :read_timeout
+    
+    def process_request(client, req, app)
+      rack_env = build_env(client, req)
+      
+      # call the app
+      begin
+        status, headers, body = app.call(rack_env)
+
+        # headers
+        match = %r{^([0-9]{3,3})( +([[:graph:] ]+))?}.match(status.to_s)
+        code = match[1].to_i
+        response = "HTTP/1.1 #{match[1]} #{match[3] || StatusStrings[code] || "Unknown"}\r\n"
+
+        if (!headers["Transfer-Encoding"] || headers["Transfer-Encoding"] == "identity")
+          body_len = headers["Content-Length"] && headers["Content-Length"].to_i
+          if (!body_len)
+            headers["Transfer-Encoding"] = "chunked"
+          end
+        else
+          headers.delete("Content-Length")
+        end
+
+        headers.each do |key, vals|
+          vals.each_line do |val|
+            response << "#{key}: #{val}\r\n"
+          end
+        end
+        response << "\r\n"
+      
+        client.write(response)
+
+        # only output a body if the request wants one and the status code
+        # should have one.
+        if (req.method != "HEAD" && !CodesWithoutBody.include?(code))
+          if (body_len)        
+            # If the app set a content length, we output that length
+            written = 0
+            body.each do |chunk|
+              remain = body_len - written
+              if (chunk.size > remain)
+                chunk[remain, chunk.size] = ""
+              end
+              client.write(chunk)
+              written += chunk.size
+              if (written >= body_len)
+                break
+              end
+            end
+            if (written < body_len)
+              $stderr.puts("Request gave Content-Length(#{body_len}) but gave less data(#{written}). Aborting connection.")
+              return
+            end
+          else
+            # If the app didn't set a length, we do it chunked.
+            body.each do |chunk|
+              client.write(chunk.size.to_s(16) + "\r\n")
+              client.write(chunk)
+              client.write("\r\n")
+            end
+            client.write("0\r\n")
+            client.write("\r\n")
+          end
+        end
+      
+        # if the conditions are right, close the connection
+        if ((req.headers["CONNECTION"] && req.headers["CONNECTION"] =~ /close/) ||
+            (headers["Connection"] && headers["Connection"] =~ /close/) ||
+            (req.version == [1,0]))
+          client.close_write
+        end
+      rescue Errno::EPIPE
+        raise # pass the buck up.
+      rescue Object => e
+        err_str = "<h2>500 Internal Server Error</h2>"
+        err_str << "<p>#{e}: #{e.backtrace.first}</p>"
+        client.write("HTTP/1.1 500 Internal Server Error\r\n")
+        client.write("Connection: close\r\n")
+        client.write("Content-Length: #{err_str.length}\r\n")
+        client.write("Content-Type: text/html\r\n")
+        client.write("\r\n")
+        client.write(err_str)
+        client.close_write
+        return
+      ensure
+        body.close if (body.respond_to? :close)
+      end
+    end
+    private :process_request
+    
+    # Accepts a connection from a client and handles requests on it until
+    # the connection closes. 
+    def process_client(app)
+      loop do
+        begin
+          client = @listener.synchronize do
+            begin
+              @listener && @listener.accept()
+            rescue => e
+              return # this means we've been turned off, so exit the loop.
+            end
+          end
+          if (!client)
+            return # nil return means we're quitting, exit loop.
+          end
+          
+          req = Http::Parser.new()
+          buf = ""
+          chunked_read(client, @timeout) do |data|
+            begin
+              buf << data
+              req.parse!(buf)
+              if (req.done?)
+                process_request(client, req, app)
+                req = Http::Parser.new()
+                if (@listener.closed?)
+                  return # ignore any more requests from this client if we're shutting down.
+                end
+              end
+            rescue Http::ParserError => e
+              err_str = "<h2>#{e.code} #{e.message}</h2>"
+              client.write("HTTP/1.1 #{e.code} #{e.message}\r\n")
+              client.write("Connection: close\r\n")
+              client.write("Content-Length: #{err_str.length}\r\n")
+              client.write("Content-Type: text/html\r\n")
+              client.write("\r\n")
+              client.write(err_str)
+              client.close_write            
+            end
+          end
+       rescue Errno::EPIPE
+          # do nothing, just let the connection close.
+        rescue Object => e
+          $stderr.puts("Unhandled error #{e}:")
+          e.backtrace.each do |line|
+            $stderr.puts(line)
+          end
+        ensure
+          client.close if (client && !client.closed?)
+        end
+      end
+    end
+    private :process_client
+    
+    # Runs the application through the configured handler.
+    # Can only be run once at a time. If you try to run it more than
+    # once, the second run will block until the first finishes.
+    def run(app)
+      synchronize do
+        begin
+          @listener = create_listener(@options)
+          if (@max_clients > 1)
+            @master = Thread.current
+            @workers = (0...@max_clients).collect do
+              Thread.new do
+                process_client(app)
+              end
+            end
+            @workers.each do |worker|
+              worker.join
+            end
+          else
+            @master = Thread.current
+            @workers = [Thread.current]
+            process_client(app)
+          end      
+        ensure
+          @listener.close if (@listener && !@listener.closed?)
+          @listener = @master = @workers = nil
+        end
+      end
+    end
+    
+    def stop()
+      # close the connection, the handler threads will exit
+      # the next time they try to load.
+      # TODO: Make it force them to exit after a timeout.
+      @listener.close if !@listener.closed?
+    end
+    
+    def running?
+      !@workers.nil?
+    end
+    def stopped?
+      @workers.nil?
+    end
+  end
+end

data/lib/rack/handler/jaws.rb

@@ -0,0 +1,13 @@
+require 'jaws/server'
+
+module Rack
+  module Handler
+    # This class is here for rackup-style automatic server detection.
+    # See Jaws::Server for more details.
+    class Jaws
+      def self.run(app, options = Jaws::Server::DefaultOptions)
+        ::Jaws::Server.new(options).run(app)
+      end
+    end
+  end
+end

data/spec/jaws_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'jaws/server'
+require 'rack/lint'
+
+describe Jaws::Server  do
+  include TestRequest::Helpers
+  
+  before :all do
+    @server = Jaws::Server.new(:Host => @host='0.0.0.0',:Port => @port=9204)
+    @thread = Thread.new do
+      @server.run(Rack::Lint.new(TestRequest.new))
+    end
+    Thread.pass until @server.running?
+  end
+  
+  after :all do
+    @server.stop
+    Thread.pass until @server.stopped?
+  end
+  
+  it "should respond to a simple get request" do
+    GET "/"
+    status.should == 200
+  end
+  
+  it "should have CGI headers on GET" do
+    GET("/")
+    response["REQUEST_METHOD"].should == "GET"
+    response["SCRIPT_NAME"].should == ''
+    response["PATH_INFO"].should == "/"
+    response["QUERY_STRING"].should == ""
+    response["test.postdata"].should == ""
+
+    GET("/test/foo?quux=1")
+    response["REQUEST_METHOD"].should == "GET"
+    response["SCRIPT_NAME"].should == ''
+    response["REQUEST_URI"].should == "/test/foo?quux=1"
+    response["PATH_INFO"].should == "/test/foo"
+    response["QUERY_STRING"].should == "quux=1"
+  end
+
+  it "should have CGI headers on POST" do
+    POST("/", {"rack-form-data" => "23"}, {'X-test-header' => '42'})
+    status.should == 200
+    response["REQUEST_METHOD"].should == "POST"
+    response["REQUEST_URI"].should == "/"
+    response["QUERY_STRING"].should == ""
+    response["HTTP_X_TEST_HEADER"].should == "42"
+    response["test.postdata"].should == "rack-form-data=23"
+  end
+
+  it "should support HTTP auth" do
+    GET("/test", {:user => "ruth", :passwd => "secret"})
+    response["HTTP_AUTHORIZATION"].should == "Basic cnV0aDpzZWNyZXQ="
+  end
+
+  it "should set status" do
+    GET("/test?secret")
+    status.should == 403
+    response["rack.url_scheme"].should == "http"
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,69 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'spec'
+require 'spec/autorun'
+require 'yaml'
+require 'net/http'
+
+Spec::Runner.configure do |config|
+  
+end
+
+# Borrowed from Rack's own specs.
+class TestRequest
+  def call(env)
+    status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
+    env["test.postdata"] = env["rack.input"].read
+    body = env.to_yaml
+    size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+    [status, {"Content-Type" => "text/yaml", "Content-Length" => size.to_s}, [body]]
+  end
+
+  module Helpers
+    attr_reader :status, :response
+
+    ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+    ENV["RUBYOPT"] = "-I#{ROOT}/lib -rubygems"
+
+    def root
+      ROOT
+    end
+
+    def rackup
+      "#{ROOT}/bin/rackup"
+    end
+
+    def GET(path, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        get = Net::HTTP::Get.new(path, header)
+        get.basic_auth user, passwd  if user && passwd
+        http.request(get) { |response|
+          @status = response.code.to_i
+          begin
+            @response = YAML.load(response.body)
+          rescue ArgumentError
+            @response = nil
+          end
+        }
+      }
+    end
+
+    def POST(path, formdata={}, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        post = Net::HTTP::Post.new(path, header)
+        post.form_data = formdata
+        post.basic_auth user, passwd  if user && passwd
+        http.request(post) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: jaws
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- Graham Batty
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-16 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: http_parser
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id003
+description: A Ruby web server designed to have a predictable and simple concurrency model, and to be capable of running in a pure-ruby environment.
+email: graham@stormbrew.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/jaws/server.rb
+- lib/rack/handler/jaws.rb
+- spec/jaws_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/stormbrew/jaws
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Just Another Web Server
+test_files: 
+- spec/jaws_spec.rb
+- spec/spec_helper.rb