ebb 0.0.4 → 0.1.0

data/ruby_lib/ebb.rb

@@ -1,50 +1,142 @@
-# A ruby binding to the ebb web server
-# Copyright (c) 2007 Ry Dahl <ry.d4hl@gmail.com>
-# This software is released under the "MIT License". See README file for details.
+# Ruby Binding to the Ebb Web Server
+# Copyright (c) 2008 Ry Dahl. This software is released under the MIT License.
+# See README file for details.
+require 'stringio'
 module Ebb
   LIBDIR = File.dirname(__FILE__)
-  VERSION = File.read(LIBDIR + "/../VERSION").gsub(/\s/,'')
-end
-
-require Ebb::LIBDIR + '/../src/ebb_ext'
-require Ebb::LIBDIR + '/daemonizable'
-
-module Ebb
+  require Ebb::LIBDIR + '/../src/ebb_ext'
+  autoload :Runner, LIBDIR + '/ebb/runner'
+  
+  def self.start_server(app, options={})
+    port = (options[:port] || 4001).to_i
+    if options.has_key?(:threaded_processing)
+      threaded_processing = options[:threaded_processing] ? true : false
+    else
+      threaded_processing = true
+    end
+    
+    Client::BASE_ENV['rack.multithread'] = threaded_processing
+    
+    FFI::server_listen_on_port(port)
+    @running = true
+    trap('INT')  { stop_server }
+    
+    log.puts "Ebb listening at http://0.0.0.0:#{port}/ (#{threaded_processing ? 'threaded' : 'sequential'} processing, PID #{Process.pid})"
+    
+    while @running
+      FFI::server_process_connections()
+      while client = FFI::waiting_clients.shift
+        if threaded_processing
+          Thread.new(client) { |c| process(app, c) }
+        else
+          process(app, client)
+        end
+      end
+    end
+    FFI::server_unlisten()
+  end
+  
+  def self.running?
+    FFI::server_open?
+  end
+  
+  def self.stop_server()
+    @running = false
+  end
+  
+  def self.process(app, client)
+    begin
+      status, headers, body = app.call(client.env)
+    rescue
+      raise if $DEBUG
+      status = 500
+      headers = {'Content-Type' => 'text/plain'}
+      body = "Internal Server Error\n"
+    end
+    
+    client.write_status(status)
+    
+    if headers.respond_to?(:[]=) and body.respond_to?(:length) and status != 304
+      headers['Connection'] = 'close'
+      headers['Content-Length'] = body.length.to_s
+    end
+    
+    headers.each { |field, value| client.write_header(field, value) }
+    client.write("\r\n")
+    
+    if body.kind_of?(String)
+      client.write(body)
+      client.body_written()
+      client.begin_transmission()
+    else
+      client.begin_transmission()
+      body.each { |p| client.write(p) }
+      client.body_written()
+    end
+  rescue => e
+    log.puts "Ebb Error! #{e.class}  #{e.message}"
+    log.puts e.backtrace.join("\n")
+  ensure
+    client.release
+  end
+  
+  @@log = STDOUT
+  def self.log=(output)
+    @@log = output
+  end
+  def self.log
+    @@log
+  end
+  
+  # This array is created and manipulated in the C extension.
+  def FFI.waiting_clients
+    @waiting_clients
+  end
+  
   class Client
     BASE_ENV = {
+      'SERVER_NAME' => '0.0.0.0',
       'SCRIPT_NAME' => '',
       'SERVER_SOFTWARE' => "Ebb #{Ebb::VERSION}",
       'SERVER_PROTOCOL' => 'HTTP/1.1',
       'rack.version' => [0, 1],
       'rack.errors' => STDERR,
       'rack.url_scheme' => 'http',
-      'rack.multithread'  => false,
       'rack.multiprocess' => false,
       'rack.run_once' => false
-    }.freeze
+    }
     
     def env
-      @env ||= begin
-        env = FFI::client_env(self).update(BASE_ENV)
-        env['rack.input'] = RequestBody.new(self)
-        env
-      end
+      env = FFI::client_env(self).update(BASE_ENV)
+      env['rack.input'] = RequestBody.new(self)
+      env
     end
     
-    def finished
-      FFI::client_finished(self)
+    def write_status(status)
+      s = status.to_i
+      FFI::client_write_status(self, s, HTTP_STATUS_CODES[s])
     end
     
     def write(data)
       FFI::client_write(self, data)
     end
     
-    def write_status(status)
-      FFI::client_write_status(self, status.to_i, HTTP_STATUS_CODES[status])
+    def write_header(field, value)
+      value.send(value.is_a?(String) ? :each_line : :each) do |v| 
+        FFI::client_write_header(self, field, v.chomp)
+      end
     end
     
-    def write_header(field, value)
-      FFI::client_write_header(self, field.to_s, value.to_s)
+    def body_written
+      FFI::client_set_body_written(self, true)
+    end
+    
+    def begin_transmission
+      FFI::client_begin_transmission(self)
+    end
+    
+    def release
+      FFI::client_release(self)
     end
   end
   
@@ -53,99 +145,36 @@ module Ebb
       @client = client
     end
     
-    def read(len)
-      FFI::client_read_input(@client, len)
+    def read(len = nil)
+      if @io
+        @io.read(len)
+      else
+        if len.nil?
+          s = ''
+          while(chunk = read(10*1024)) do
+            s << chunk
+          end
+          s
+        else
+          FFI::client_read_input(@client, len)
+        end
+      end
     end
     
     def gets
-      raise NotImplementedError
+      io.gets
     end
     
-    def each
-      raise NotImplementedError
-    end
-  end
-  
-  class Server
-    include Daemonizable
-    def self.run(app, options={})
-      # port must be an integer
-      server = self.new(app, options)
-      yield server if block_given?
-      server.start
-    end
-    
-    def initialize(app, options={})
-      @socket = options[:socket]
-      @port = (options[:port] || 4001).to_i
-      @timeout =  options[:timeout]
-      @app = app
-    end
-    
-    def start
-      trap('INT')  { @running = false }
-      
-      if @socket
-        raise NotImplemented
-        FFI::server_listen_on_socket(self, @socket) or raise "Problem listening on socket #{@socket}"
-      else
-        FFI::server_listen_on_port(self, @port) or raise "Problem listening on port #{@port}"
-      end
-      @waiting_clients = []
-      
-      puts "Ebb listening at http://0.0.0.0:#{@port}/"
-      
-      @running = true
-      while FFI::server_process_connections(self) and @running
-        unless @waiting_clients.empty?
-          if $DEBUG and  @waiting_clients.length > 1
-            puts "#{@waiting_clients.length} waiting clients"
-          end
-          client = @waiting_clients.shift
-          process_client(client)
-        end
-      end
-      puts "Ebb unlistening"
-      FFI::server_unlisten(self)
-    end
-    
-    def process_client(client)
-      #puts "Request: #{client.env.inspect}\n"
-      begin
-        status, headers, body = @app.call(client.env)
-      rescue
-        raise if $DEBUG
-        status = 500
-        headers = {'Content-Type' => 'text/plain'}
-        body = "Internal Server Error\n"
-      end
-      
-      client.write_status(status)
-      
-      if body.respond_to? :length and status != 304
-        headers['Connection'] = 'close'
-        headers['Content-Length'] = body.length
-      end
-      
-      headers.each { |k, v| client.write_header(k,v) }
-      
-      client.write "\r\n"
-      
-      # Not many apps use streaming yet so i'll hold off on that feature
-      # until the rest of ebb is more developed.
-      if body.kind_of?(String)
-        client.write body
-      else
-        body.each { |p| client.write p }
-      end
-      client.finished
+    def each(&block)
+      io.each(&block)
     end
     
-    def log(msg)
-      puts msg
+    def io
+      @io ||= StringIO.new(read)
     end
   end
   
+  
   HTTP_STATUS_CODES = {  
     100  => 'Continue', 
     101  => 'Switching Protocols', 
@@ -185,4 +214,4 @@ module Ebb
     504  => 'Gateway Time-out', 
     505  => 'HTTP Version not supported'
   }.freeze
-end
+end

data/ruby_lib/ebb/runner.rb

@@ -0,0 +1,135 @@
+require 'optparse'
+
+module Kernel
+  unless respond_to? :daemonize # Already part of Ruby 1.9, yeah!
+    # Turns the current script into a daemon process that detaches from the console.
+    # It can be shut down with a TERM signal. Taken from ActiveSupport.
+    def daemonize
+      exit if fork                   # Parent exits, child continues.
+      Process.setsid                 # Become session leader.
+      exit if fork                   # Zap session leader. See [1].
+      Dir.chdir "/"                  # Release old working directory.
+      File.umask 0000                # Ensure sensible umask. Adjust as needed.
+      STDIN.reopen "/dev/null"       # Free file descriptors and
+      STDOUT.reopen "/dev/null", "a" # point them somewhere sensible.
+      STDERR.reopen STDOUT           # STDOUT/ERR should better go to a logfile.
+      trap("TERM") { exit }
+    end
+  end
+end
+
+module Ebb
+  class Runner
+    # Classes are modules and I hate this 'Base' class pattern. I'm putting
+    # other classes inside this one.
+    autoload :Rails, LIBDIR + '/ebb/runner/rails'
+    
+    # Kill the process which PID is stored in +pid_file+.
+    def self.kill(pid_file, timeout=60)
+      raise ArgumentError, 'You must specify a pid_file to stop deamonized server' unless pid_file 
+      
+      if pid = File.read(pid_file)
+        pid = pid.to_i
+        
+        Process.kill('KILL', pid)
+        Ebb.log.puts "stopped!"
+      else
+        Ebb.log.puts "Can't stop process, no PID found in #{@pid_file}"
+      end
+    rescue Errno::ESRCH # No such process
+      Ebb.log.puts "process not found!"
+    ensure
+      File.delete(pid_file) rescue nil
+    end
+
+    def self.remove_pid_file(file)
+      File.delete(file) if file && File.exists?(file) && Process.pid == File.read(file)
+    end
+
+    def self.write_pid_file(file)
+      Ebb.log.puts ">> Writing PID to #{file}"
+      open(file,"w+") { |f| f.write(Process.pid) }
+      File.chmod(0644, file)
+    end
+    
+    attr_reader :options
+    
+    def initialize
+      @parser = OptionParser.new
+      @options = {
+        :port => 4001,
+        :timeout => 60,
+        :threaded_processing => true
+      }
+    end
+    
+    def parse_options(argv)
+      @parser.banner = "Usage: #{self.class} [options] start | stop"
+      @parser.separator ""
+      extra_options if respond_to?(:extra_options)
+      
+      @parser.separator ""
+      #  opts.on("-s", "--socket SOCKET", "listen on socket") { |socket| options[:socket] = socket }
+      @parser.on("-p", "--port PORT", "(default: #{@options[:port]})") { |p| @options[:port]=p }
+      @parser.on("-d", "--daemonize", "Daemonize") { @options[:daemonize] = true }
+      @parser.on("-l", "--log-file FILE", "File to redirect output") { |f| @options[:log_file]=f }
+      @parser.on("-P", "--pid-file FILE", "File to store PID") { |f| @options[:pid_file]=f }
+      # @parser.on("-t", "--timeout SECONDS", "(default: #{@options[:timeout]})") { |s| @options[:timeout]=s }
+      
+      @parser.separator ""
+      @parser.on_tail("-h", "--help", "Show this message") do
+        Ebb.log.puts @parser
+        exit
+      end
+      @parser.on_tail('-v', '--version', "Show version") do
+        Ebb.log.puts "Ebb #{Ebb::VERSION}"
+        exit
+      end
+      
+      @parser.parse!(argv)
+    end
+    
+    def run(argv)
+      parse_options(argv)
+      
+      case argv[0]
+      when 'start'
+        Ebb.log.print("Ebb is loading the application...")
+        Ebb.log.flush()
+        @app = app(@options)
+        Ebb.log.puts("done")
+        
+        if @options[:daemonize]
+          pwd = Dir.pwd # Current directory is changed during daemonization, so store it
+          Kernel.daemonize 
+          Dir.chdir pwd
+          trap('HUP', 'IGNORE') # Don't die upon logout
+        end
+        
+        if @options[:log_file]
+          [STDOUT, STDERR].each { |f| f.reopen @options[:log_file], 'a' } 
+        end
+        
+        if @options[:pid_file]
+          Runner.write_pid_file(@options[:pid_file])
+          at_exit do
+            Ebb.log.puts ">> Exiting!"
+            Runner.remove_pid_file(@options[:pid_file])
+          end
+        end
+        
+        Ebb::start_server(@app, @options)
+      when 'stop'
+        Ebb::Runner.kill @options[:pid_file], @options[:timeout]
+      when nil
+        Ebb.log.puts "Command required"
+        Ebb.log.puts @parser
+        exit 1
+      else
+        abort "Invalid command : #{argv[0]}"
+      end
+      
+    end
+  end
+end
+

data/ruby_lib/ebb/runner/rails.rb

@@ -0,0 +1,34 @@
+module Rack
+  module Adapter
+    autoload :Rails, Ebb::LIBDIR + '/rack/adapter/rails'
+  end
+end
+
+module Ebb
+  class Runner  
+    class Rails < Runner
+      def extra_options
+        # defaults for ebb_rails
+        @options.update(
+          :environment => 'development',
+          :port => 3000,
+          # rails has a mutex lock around each request - threaded processing
+          # will only slow things down
+          :threaded_processing => false
+        )
+
+        @parser.on("-e", "--env ENV", 
+                "Rails environment (default: development)") do |env| 
+          @options[:environment] = env
+        end
+        @parser.on("-c", "--chdir DIR", "RAILS_ROOT directory") do |c| 
+          @options[:root] = c
+        end
+      end
+
+      def app(options)
+        Rack::Adapter::Rails.new(options)
+      end
+    end
+  end
+end