ebb 0.2.1 → 0.3.0

data/bin/ebb_rails

@@ -1,4 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/../ruby_lib/ebb'
-
-Ebb::Runner::Rails.new.run(ARGV)

data/ruby_lib/ebb.rb

@@ -1,257 +0,0 @@
-# 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
-  VERSION = "0.2.1"
-  LIBDIR = File.dirname(__FILE__)
-  autoload :Runner, LIBDIR + '/ebb/runner'
-  autoload :FFI, LIBDIR + '/../src/ebb_ext'
-  
-  def self.start_server(app, options={})
-    if options.has_key?(:fileno)
-      fd = options[:fileno].to_i
-      FFI::server_listen_on_fd(fd)
-      log.puts "Ebb is listening on file descriptor #{fd}"
-    elsif options.has_key?(:unix_socket)
-      socketfile = options[:unix_socket]
-      FFI::server_listen_on_unix_socket(socketfile)
-      log.puts "Ebb is listening on unix socket #{socketfile}"
-    else
-      port = (options[:Port] || options[:port] || 4001).to_i
-      FFI::server_listen_on_port(port)
-      log.puts "Ebb is listening at http://0.0.0.0:#{port}/"
-    end
-    log.puts "Ebb PID #{Process.pid}"
-    
-    @running = true
-    trap('INT')  { stop_server }
-    
-    while @running
-      FFI::server_process_connections()
-      while client = FFI::server_waiting_clients.shift
-        if app.respond_to?(:deferred?) and app.deferred?(client.env)
-          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)
-    #p client.env
-    status, headers, body = app.call(client.env)
-    status = status.to_i
-    
-    # Write the status
-    client.write_status(status)
-    
-    # Add Content-Length to the headers.
-    if !headers.has_key?('Content-Length') and
-       headers.respond_to?(:[]=) and
-       status != 304
-    then
-      # for String just use "length" method
-      if body.kind_of?(String)
-        headers['Content-Length'] = body.length.to_s
-      else
-        # for non-Array object call "each" and transform to Array
-        unless body.kind_of?(Array)
-          parts = []
-          body.each {|p| parts << p}
-          body = parts
-        end
-        # body is Array so calculate Content-Length as sum of length each part
-        headers['Content-Length'] = body.inject(0) {|s, p| s + p.length }.to_s
-      end
-    end
-    
-    # Decide if we should keep the connection alive or not
-    unless headers.has_key?('Connection')
-      if headers.has_key?('Content-Length') and client.should_keep_alive?
-        headers['Connection'] = 'Keep-Alive'
-      else
-        headers['Connection'] = 'close'
-      end
-    end
-    
-    # Write the headers
-    headers.each { |field, value| client.write_header(field, value) }
-    
-    # Write the body
-    if body.kind_of?(String)
-      client.write_body(body)
-    else
-      body.each { |p| client.write_body(p) }
-    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
-  
-  class Client
-    attr_reader :fd, :body_head, :content_length
-    BASE_ENV = {
-      'SERVER_NAME' => '0.0.0.0',
-      'SCRIPT_NAME' => '',
-      'QUERY_STRING' => '',
-      'SERVER_SOFTWARE' => "Ebb-Ruby #{Ebb::VERSION}",
-      'SERVER_PROTOCOL' => 'HTTP/1.1',
-      'rack.version' => [0, 1],
-      'rack.errors' => STDERR,
-      'rack.url_scheme' => 'http',
-      'rack.multiprocess' => false,
-      'rack.run_once' => false
-    }
-    
-    def env
-      @env ||= begin
-        env = FFI::client_env(self).update(BASE_ENV)
-        env['rack.input'] = RequestBody.new(self)
-        env
-      end
-    end
-    
-    def write_status(status)
-      FFI::client_write_status(self, status, HTTP_STATUS_CODES[status])
-    end
-    
-    def write_body(data)
-      FFI::client_write_body(self, data)
-    end
-    
-    def write_header(field, value)
-      FFI::client_write_header(self, field, value)
-    end
-    
-    def release
-      FFI::client_release(self)
-    end
-    
-    def set_keep_alive
-      FFI::client_set_keep_alive(self)
-    end
-    
-    def should_keep_alive?
-      if env['HTTP_VERSION'] == 'HTTP/1.0'
-        return env['HTTP_CONNECTION'] =~ /Keep-Alive/i
-      else
-        return env['HTTP_CONNECTION'] !~ /close/i
-      end
-    end
-  end
-  
-  class RequestBody
-    def initialize(client)
-      @content_length = client.content_length
-      if client.body_head
-        @body_head = StringIO.new(client.body_head)
-        if @body_head.length < @content_length
-          @socket = IO.new(client.fd)
-        end
-      end
-      @total_read = 0
-    end
-    
-    def read(len = nil)
-      to_read =  len.nil? ? @content_length - @total_read : min(len, @content_length - @total_read)
-      return nil if to_read == 0 or @body_head.nil?
-      unless out = @body_head.read(to_read)
-        return nil if @socket.nil?
-        out = @socket.read(to_read)
-      end
-      @total_read += out.length
-      out
-    end
-    
-    def gets
-      raise NotImplemented
-    end
-    
-    def each(&block)
-      raise NotImplemented
-    end
-
-private
-
-    # cause i don't want to create an array
-    def min(a,b)
-      a > b ? b : a
-    end
-
-  end
-  
-  
-  HTTP_STATUS_CODES = {  
-    100  => 'Continue', 
-    101  => 'Switching Protocols', 
-    200  => 'OK', 
-    201  => 'Created', 
-    202  => 'Accepted', 
-    203  => 'Non-Authoritative Information', 
-    204  => 'No Content', 
-    205  => 'Reset Content', 
-    206  => 'Partial Content', 
-    300  => 'Multiple Choices', 
-    301  => 'Moved Permanently', 
-    302  => 'Moved Temporarily', 
-    303  => 'See Other', 
-    304  => 'Not Modified', 
-    305  => 'Use Proxy', 
-    400  => 'Bad Request', 
-    401  => 'Unauthorized', 
-    402  => 'Payment Required', 
-    403  => 'Forbidden', 
-    404  => 'Not Found', 
-    405  => 'Method Not Allowed', 
-    406  => 'Not Acceptable', 
-    407  => 'Proxy Authentication Required', 
-    408  => 'Request Time-out', 
-    409  => 'Conflict', 
-    410  => 'Gone', 
-    411  => 'Length Required', 
-    412  => 'Precondition Failed', 
-    413  => 'Request Entity Too Large', 
-    414  => 'Request-URI Too Large', 
-    415  => 'Unsupported Media Type', 
-    500  => 'Internal Server Error', 
-    501  => 'Not Implemented', 
-    502  => 'Bad Gateway', 
-    503  => 'Service Unavailable', 
-    504  => 'Gateway Time-out', 
-    505  => 'HTTP Version not supported'
-  }.freeze
-end
-
-
-module Rack
-  module Handler
-    module Ebb
-      def self.run(app, options={})
-        ::Ebb.start_server(app, options)
-      end
-    end
-  end
-end
-

data/ruby_lib/ebb/runner.rb

@@ -1,134 +0,0 @@
-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
-      }
-    end
-    
-    def parse_options(argv)
-      @parser.banner = "Usage: #{self.class} [options] start | stop"
-      @parser.separator ""
-      extra_options if respond_to?(:extra_options)
-      
-      @parser.separator ""
-      @parser.on("-p", "--port PORT", "(default: #{@options[:port]})") { |p| @options[:port] = p }
-      @parser.on("-s", "--socket SOCKET", "listen on unix domain socket") { |socket| options[:unix_socket] = socket }
-      @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::Client::BASE_ENV['SERVER_SOFTWARE']
-        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

@@ -1,31 +0,0 @@
-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
-        )
-
-        @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

data/ruby_lib/rack/adapter/rails.rb

@@ -1,159 +0,0 @@
-require 'cgi'
-require 'rubygems'
-require 'rack'
-
-# Adapter to run a Rails app with any supported Rack handler.
-# By default it will try to load the Rails application in the
-# current directory in the development environment.
-# Options:
-#  root: Root directory of the Rails app
-#  env: Rails environment to run in (development, production or test)
-# Based on http://fuzed.rubyforge.org/ Rails adapter
-module Rack
-  module Adapter 
-    class Rails
-      def initialize(options={})
-        @root   = options[:root]         || Dir.pwd
-        @env    = options[:environment]  || 'development'
-        @prefix = options[:prefix]
-        
-        load_application
-        
-        @file_server = Rack::File.new(::File.join(RAILS_ROOT, "public"))
-      end
-      
-      def load_application
-        ENV['RAILS_ENV'] = @env
-
-        require "#{@root}/config/environment"
-        require 'dispatcher'
-        
-        ActionController::AbstractRequest.relative_url_root = @prefix if @prefix 
-      end
-      
-      # TODO refactor this in File#can_serve?(path) ??
-      def file_exist?(path)
-        full_path = ::File.join(@file_server.root, Utils.unescape(path))
-        ::File.file?(full_path) && ::File.readable?(full_path)
-      end
-      
-      def serve_file(env)
-        @file_server.call(env)
-      end
-      
-      def serve_rails(env)
-        request         = Request.new(env)
-        response        = Response.new
-        
-        session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
-        cgi             = CGIWrapper.new(request, response)
-    
-        Dispatcher.dispatch(cgi, session_options, response)
-
-        response.finish
-      end
-      
-      def call(env)
-        path        = env['PATH_INFO'].chomp('/')
-        cached_path = (path.empty? ? 'index' : path) + ActionController::Base.page_cache_extension
-        
-        if file_exist?(path)              # Serve the file if it's there
-          serve_file(env)
-        elsif file_exist?(cached_path)    # Serve the page cache if it's there
-          env['PATH_INFO'] = cached_path
-          serve_file(env)
-        else                              # No static file, let Rails handle it
-          serve_rails(env)
-        end
-      end
-      
-      # Never spawn threads for a request
-      def deferred?(env)
-        false
-      end
-    
-      protected
-        
-        class CGIWrapper < ::CGI
-          def initialize(request, response, *args)
-            @request  = request
-            @response = response
-            @args     = *args
-            @input    = request.body
-
-            super *args
-          end
-        
-          def header(options = "text/html")
-            if options.is_a?(String)
-              @response['Content-Type']     = options unless @response['Content-Type']
-            else
-              @response['Content-Length']   = options.delete('Content-Length').to_s if options['Content-Length']
-            
-              @response['Content-Type']     = options.delete('type') || "text/html"
-              @response['Content-Type']    += "; charset=" + options.delete('charset') if options['charset']
-                        
-              @response['Content-Language'] = options.delete('language') if options['language']
-              @response['Expires']          = options.delete('expires') if options['expires']
-
-              @response.status              = options.delete('Status') if options['Status']
-              
-              # Convert 'cookie' header to 'Set-Cookie' headers.
-              # Because Set-Cookie header can appear more the once in the response body, 
-              # we store it in a line break seperated string that will be translated to
-              # multiple Set-Cookie header by the handler.
-              if cookie = options.delete('cookie')
-                cookies = []
-                
-                case cookie
-                  when Array then cookie.each { |c| cookies << c.to_s }
-                  when Hash  then cookie.each { |_, c| cookies << c.to_s }
-                  else            cookies << cookie.to_s
-                end
-        
-                @output_cookies.each { |c| cookies << c.to_s } if @output_cookies
-                
-                @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact.join("\n")
-              end
-              
-              options.each { |k,v| @response[k] = v }
-            end
-            
-            ""
-          end
-                        
-          def params
-            @params ||= @request.params
-          end
-        
-          def cookies
-            @request.cookies
-          end
-        
-          def query_string
-            @request.query_string
-          end
-          
-          # Used to wrap the normal args variable used inside CGI.
-          def args
-            @args
-          end
-    
-          # Used to wrap the normal env_table variable used inside CGI.
-          def env_table
-            @request.env
-          end
-    
-          # Used to wrap the normal stdinput variable used inside CGI.
-          def stdinput
-            @input
-          end
-        
-          def stdoutput
-            STDERR.puts "stdoutput should not be used."
-            @response.body
-          end
-      end
-    end
-  end
-end