ebb 0.0.1

data/libev/ev_win32.c

@@ -0,0 +1,117 @@
+/*
+ * libev win32 compatibility cruft
+ *
+ * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _WIN32
+
+#include <sys/timeb.h>
+
+/* note: the comment below could not be substantiated, but what would I care */
+/* MSDN says this is required to handle SIGFPE */
+volatile double SIGFPE_REQ = 0.0f; 
+
+/* oh, the humanity! */
+static int
+ev_pipe (int filedes [2])
+{
+  struct sockaddr_in addr = { 0 };
+  int addr_size = sizeof (addr);
+  SOCKET listener;
+  SOCKET sock [2] = { -1, -1 };
+
+  if ((listener = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
+    return -1;
+
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  addr.sin_port = 0;
+
+  if (bind (listener, (struct sockaddr *)&addr, addr_size))
+    goto fail;
+
+  if (getsockname(listener, (struct sockaddr *)&addr, &addr_size))
+    goto fail;
+
+  if (listen (listener, 1))
+    goto fail;
+
+  if ((sock [0] = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
+    goto fail;
+
+  if (connect (sock[0], (struct sockaddr *)&addr, addr_size))
+    goto fail;
+
+  if ((sock[1] = accept (listener, 0, 0)) < 0)
+    goto fail;
+
+  closesocket (listener);
+
+#if EV_SELECT_IS_WINSOCKET
+  filedes [0] = _open_osfhandle (sock [0], 0);
+  filedes [1] = _open_osfhandle (sock [1], 0);
+#else
+  /* when select isn't winsocket, we also expect socket, connect, accept etc.
+   * to work on fds */
+  filedes [0] = sock [0];
+  filedes [1] = sock [1];
+#endif
+
+  return 0;
+
+fail:
+  closesocket (listener);
+
+  if (sock [0] != INVALID_SOCKET) closesocket (sock [0]);
+  if (sock [1] != INVALID_SOCKET) closesocket (sock [1]);
+
+  return -1;
+}
+
+#undef pipe
+#define pipe(filedes) ev_pipe (filedes)
+
+static int
+ev_gettimeofday (struct timeval *tv, struct timezone *tz)
+{
+  struct _timeb tb;
+
+  _ftime (&tb);
+
+  tv->tv_sec  = (long)tb.time;
+  tv->tv_usec = ((long)tb.millitm) * 1000;
+
+  return 0;
+}
+
+#undef gettimeofday
+#define gettimeofday(tv,tz) ev_gettimeofday (tv, tz)
+
+#endif
+

data/libev/ev_wrap.h

@@ -0,0 +1,132 @@
+/* DO NOT EDIT, automatically generated by update_ev_wrap */
+#ifndef EV_WRAP_H
+#define EV_WRAP_H
+#define now_floor ((loop)->now_floor)
+#define mn_now ((loop)->mn_now)
+#define rtmn_diff ((loop)->rtmn_diff)
+#define io_blocktime ((loop)->io_blocktime)
+#define timeout_blocktime ((loop)->timeout_blocktime)
+#define backend ((loop)->backend)
+#define activecnt ((loop)->activecnt)
+#define loop_count ((loop)->loop_count)
+#define backend_fd ((loop)->backend_fd)
+#define backend_fudge ((loop)->backend_fudge)
+#define backend_modify ((loop)->backend_modify)
+#define backend_poll ((loop)->backend_poll)
+#define curpid ((loop)->curpid)
+#define postfork ((loop)->postfork)
+#define vec_ri ((loop)->vec_ri)
+#define vec_ro ((loop)->vec_ro)
+#define vec_wi ((loop)->vec_wi)
+#define vec_wo ((loop)->vec_wo)
+#define vec_max ((loop)->vec_max)
+#define polls ((loop)->polls)
+#define pollmax ((loop)->pollmax)
+#define pollcnt ((loop)->pollcnt)
+#define pollidxs ((loop)->pollidxs)
+#define pollidxmax ((loop)->pollidxmax)
+#define epoll_events ((loop)->epoll_events)
+#define epoll_eventmax ((loop)->epoll_eventmax)
+#define kqueue_changes ((loop)->kqueue_changes)
+#define kqueue_changemax ((loop)->kqueue_changemax)
+#define kqueue_changecnt ((loop)->kqueue_changecnt)
+#define kqueue_events ((loop)->kqueue_events)
+#define kqueue_eventmax ((loop)->kqueue_eventmax)
+#define port_events ((loop)->port_events)
+#define port_eventmax ((loop)->port_eventmax)
+#define anfds ((loop)->anfds)
+#define anfdmax ((loop)->anfdmax)
+#define pendings ((loop)->pendings)
+#define pendingmax ((loop)->pendingmax)
+#define pendingcnt ((loop)->pendingcnt)
+#define fdchanges ((loop)->fdchanges)
+#define fdchangemax ((loop)->fdchangemax)
+#define fdchangecnt ((loop)->fdchangecnt)
+#define timers ((loop)->timers)
+#define timermax ((loop)->timermax)
+#define timercnt ((loop)->timercnt)
+#define periodics ((loop)->periodics)
+#define periodicmax ((loop)->periodicmax)
+#define periodiccnt ((loop)->periodiccnt)
+#define idles ((loop)->idles)
+#define idlemax ((loop)->idlemax)
+#define idlecnt ((loop)->idlecnt)
+#define idleall ((loop)->idleall)
+#define prepares ((loop)->prepares)
+#define preparemax ((loop)->preparemax)
+#define preparecnt ((loop)->preparecnt)
+#define checks ((loop)->checks)
+#define checkmax ((loop)->checkmax)
+#define checkcnt ((loop)->checkcnt)
+#define forks ((loop)->forks)
+#define forkmax ((loop)->forkmax)
+#define forkcnt ((loop)->forkcnt)
+#define fs_fd ((loop)->fs_fd)
+#define fs_w ((loop)->fs_w)
+#define fs_hash ((loop)->fs_hash)
+#else
+#undef EV_WRAP_H
+#undef now_floor
+#undef mn_now
+#undef rtmn_diff
+#undef io_blocktime
+#undef timeout_blocktime
+#undef backend
+#undef activecnt
+#undef loop_count
+#undef backend_fd
+#undef backend_fudge
+#undef backend_modify
+#undef backend_poll
+#undef curpid
+#undef postfork
+#undef vec_ri
+#undef vec_ro
+#undef vec_wi
+#undef vec_wo
+#undef vec_max
+#undef polls
+#undef pollmax
+#undef pollcnt
+#undef pollidxs
+#undef pollidxmax
+#undef epoll_events
+#undef epoll_eventmax
+#undef kqueue_changes
+#undef kqueue_changemax
+#undef kqueue_changecnt
+#undef kqueue_events
+#undef kqueue_eventmax
+#undef port_events
+#undef port_eventmax
+#undef anfds
+#undef anfdmax
+#undef pendings
+#undef pendingmax
+#undef pendingcnt
+#undef fdchanges
+#undef fdchangemax
+#undef fdchangecnt
+#undef timers
+#undef timermax
+#undef timercnt
+#undef periodics
+#undef periodicmax
+#undef periodiccnt
+#undef idles
+#undef idlemax
+#undef idlecnt
+#undef idleall
+#undef prepares
+#undef preparemax
+#undef preparecnt
+#undef checks
+#undef checkmax
+#undef checkcnt
+#undef forks
+#undef forkmax
+#undef forkcnt
+#undef fs_fd
+#undef fs_w
+#undef fs_hash
+#endif

data/ruby_lib/daemonizable.rb

@@ -0,0 +1,134 @@
+# Copyright (c) 2007 Marc-André Cournoyer
+require 'etc'
+
+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 Process
+  # Returns +true+ the process identied by +pid+ is running.
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::ESRCH
+    false
+  end
+  module_function :running?
+end
+
+# Module included in classes that can be turned into a daemon.
+# Handle stuff like:
+# * storing the PID in a file
+# * redirecting output to the log file
+# * changing processs privileges
+# * killing the process gracefully
+module Daemonizable
+  attr_accessor :pid_file, :log_file
+  
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  def daemonizable_init(options)
+    pid_file = options[:pid_file]
+    log_file = options[:log_file]
+    if options[:daemonize]
+      change_privilege options[:user], options[:group] if options[:user] && options[:group]
+      daemonize
+    end
+  end
+  
+  def pid
+    File.exist?(pid_file) ? open(pid_file).read : nil
+  end
+  
+  # Turns the current script into a daemon process that detaches from the console.
+  def daemonize
+    raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
+    
+    pwd = Dir.pwd # Current directory is changed during daemonization, so store it
+    super         # Calls Kernel#daemonize
+    Dir.chdir pwd
+    
+    trap('HUP', 'IGNORE') # Don't die upon logout
+
+    # Redirect output to the logfile
+    [STDOUT, STDERR].each { |f| f.reopen @log_file, 'a' } if @log_file
+    
+    write_pid_file
+    at_exit do
+      log ">> Exiting!"
+      remove_pid_file
+    end
+  end
+  
+  # Change privileges of the process
+  # to the specified user and group.
+  def change_privilege(user, group=user)
+    log ">> Changing process privilege to #{user}:#{group}"
+    
+    uid, gid = Process.euid, Process.egid
+    target_uid = Etc.getpwnam(user).uid
+    target_gid = Etc.getgrnam(group).gid
+
+    if uid != target_uid || gid != target_gid
+      # Change process ownership
+      Process.initgroups(user, target_gid)
+      Process::GID.change_privilege(target_gid)
+      Process::UID.change_privilege(target_uid)
+    end
+  rescue Errno::EPERM => e
+    log "Couldn't change user and group to #{user}:#{group}: #{e}"
+  end
+  
+  module ClassMethods
+    # Kill the process which PID is stored in +pid_file+.
+    def kill(pid_file, timeout=60)
+      if pid = open(pid_file).read
+        pid = pid.to_i
+        print "Sending INT signal to process #{pid} ... "
+        begin
+          Process.kill('INT', pid)
+          Timeout.timeout(timeout) do
+            sleep 0.1 while Process.running?(pid)
+          end
+        rescue Timeout::Error
+          print "timeout, Sending KILL signal ... "
+          Process.kill('KILL', pid)
+        end
+        puts "stopped!"
+      else
+        puts "Can't stop process, no PID found in #{@pid_file}"
+      end
+    rescue Errno::ESRCH # No such process
+      puts "process not found!"
+    ensure
+      File.delete(pid_file) rescue nil
+    end
+  end
+  
+  private
+    def remove_pid_file
+      File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
+    end
+
+    def write_pid_file
+      log ">> Writing PID to #{@pid_file}"
+      FileUtils.mkdir_p File.dirname(@pid_file)
+      open(@pid_file,"w") { |f| f.write(Process.pid) }
+      File.chmod(0644, @pid_file)
+    end
+end

data/ruby_lib/ebb.rb

@@ -0,0 +1,179 @@
+# 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.
+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
+  class Client
+    BASE_ENV = {
+      'SCRIPT_NAME' => '',
+      'SERVER_SOFTWARE' => "Ebb #{Ebb::VERSION}",
+      'SERVER_PROTOCOL' => 'HTTP/1.1',
+      'GATEWAY_INTERFACE' => 'CGI/1.2',
+      '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
+    end
+    
+    def finished
+      FFI::client_finished(self)
+    end
+    
+    def write(data)
+      FFI::client_write(self, data)
+    end
+  end
+  
+  class RequestBody
+    def initialize(client)
+      @client = client
+    end
+    
+    def read(len)
+      FFI::client_read_input(@client, len)
+    end
+    
+    def gets
+      raise NotImplementedError
+    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
+      
+      daemonizable_init(options)
+      FFI::server_initialize(self)
+    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 "HTTP/1.1 %d %s\r\n" % [status, HTTP_STATUS_CODES[status]]
+      
+      if body.respond_to? :length and status != 304
+        client.write "Connection: close\r\n"
+        headers['Content-Length'] = body.length
+      end
+      
+      headers.each { |k, v| client.write "#{k}: #{v}\r\n" }
+      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
+    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