rsence 2.0.0.0.pre

data/lib/daemon/daemon.rb

@@ -0,0 +1,293 @@
+#--
+##   Riassence Framework
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+ #++
+
+# Use the default configuration:
+require 'conf/default'
+
+# Use rubygems to load rack
+require 'rubygems'
+require 'rack'
+
+# Loads the selected web-server (default is 'thin')
+require RSence.config[:http_server][:rack_require]
+
+# Methods that return rack the selected handler
+def rack_webrick_handler;  Rack::Handler::WEBrick;  end
+def rack_ebb_handler;      Rack::Handler::Ebb;      end
+def rack_thin_handler;     Rack::Handler::Thin;     end
+def rack_mongrel_handler;  Rack::Handler::Mongrel;  end
+def rack_unicorn_handler;  Rack::Handler::Unicorn;  end
+def rack_rainbows_handler; Rack::Handler::Rainbows; end
+
+# Selects the handler for Rack
+RSence.config[:http_server][:rack_handler] = self.method({
+  'fuzed'    => :rack_fuzed_handler,
+  'webrick'  => :rack_webrick_handler,
+  'ebb'      => :rack_ebb_handler,
+  'thin'     => :rack_thin_handler,
+  'mongrel'  => :rack_mongrel_handler,
+  'unicorn'  => :rack_unicorn_handler,
+  'rainbows' => :rack_rainbows_handler
+}[RSence.config[:http_server][:rack_require]]).call
+
+# Debug mode switch. The debug mode is intended for developers, not production.
+$DEBUG_MODE  = RSence.config[:debug_mode]
+
+# Transporter is the top-level handler for calls coming from the javascript COMM.Transporter.
+require 'transporter/transporter'
+
+## Broker routes requests to the correct handler
+require 'http/broker'
+
+
+module RSence
+
+# adapted from:
+# http://snippets.dzone.com/posts/show/2265
+
+require 'fileutils'
+
+module Daemon
+  
+  class Base
+    def self.pid_fn
+      RSence.config[:daemon][:pid_fn]
+    end
+    def self.log_fn
+      RSence.config[:daemon][:log_fn]
+    end
+    def self.daemonize
+      Controller.daemonize(self)
+    end
+  end
+  
+  module PidFile
+    def self.store(daemon, pid)
+      dir_path_pid = File.split( daemon.pid_fn )[0]
+      FileUtils.mkdir_p( dir_path_pid ) unless File.exists? dir_path_pid
+      File.open(daemon.pid_fn, 'w') {|f| f << pid}
+    end
+    def self.recall(daemon)
+      IO.read(daemon.pid_fn).to_i rescue nil
+    end
+  end
+  
+  module Controller
+    
+    def self.print_status(daemon)
+      is_running = self.status(daemon)
+      puts "Riassence Framework is #{'not ' unless is_running}running"
+    end
+    
+    ## Status is not entirely reliable
+    def self.status(daemon)
+      if File.file?(daemon.pid_fn)
+        begin
+          pid = File.read(daemon.pid_fn).to_i
+          pid && Process.kill('USR2',pid)
+          return true
+        rescue Errno::ESRCH => e
+          return false
+        end
+      end
+      return false
+    end
+    
+    def self.open_log( outpath, errpath )
+      dir_path_out = File.split( outpath )[0]
+      FileUtils.mkdir_p( dir_path_out ) unless File.exists? dir_path_out
+      dir_path_err = File.split( outpath )[0]
+      FileUtils.mkdir_p( dir_path_err ) unless File.exists? dir_path_err
+      if File.exist?( outpath )
+        STDOUT.reopen( outpath, "a" )
+      else
+        STDOUT.reopen( outpath, "w" )
+      end
+      if File.exist?( errpath )
+        STDERR.reopen( errpath, "a" )
+      else
+        STDERR.reopen( errpath, "w" )
+      end
+      STDOUT.sync = true
+      STDERR.sync = true
+    end
+    
+    def self.log_io(daemon)
+      outpath = "#{daemon.log_fn}.stdout"
+      errpath = "#{daemon.log_fn}.stderr"
+      if $DEBUG_MODE
+        Thread.new do
+          puts "Waiting 2 seconds before switching output to log file #{outpath} and .../#{File.split(errpath)[1]}"
+          sleep 2
+          puts "Switching to stdin and stdout to log mode. Follow the log file to see further server output."
+          self.open_log( outpath, errpath )
+        end
+      else
+        self.open_log( outpath, errpath )
+      end
+    end
+    
+    def self.daemonize(daemon)
+      cmd = ARGV[0]
+      if ['i386-mingw32','x86-mingw32'].include? RUBY_PLATFORM
+        if cmd == 'start'
+          warn "Running on Microsoft Windows: unable to background. Using the run command instead of start"
+          cmd = 'run'
+        elsif cmd != 'run'
+          puts "Invalid command: #{cmd.inspect}. Windows supports only run and help."
+          exit
+        end
+      elsif not cmd or not %w[status start stop restart save run].include?( cmd )
+        puts "Invalid command. Please specify one of the following: run, start, stop, restart, status, save or help."
+        exit
+      end
+      case cmd
+      when 'run'
+        puts "Starting as a foreground process."
+        puts "Enter CTRL-C to stop."
+        self.start_fg(daemon)
+      when 'status'
+        self.print_status(daemon)
+      when 'start'
+        self.start(daemon)
+      when 'stop'
+        self.stop(daemon)
+      when 'restart'
+        self.stop(daemon,true)
+        self.start(daemon)
+      when 'save'
+        self.save(daemon)
+      end
+    end
+    def self.start_fg(daemon)
+      ['INT', 'TERM', 'KILL'].each do |signal|
+        Signal.trap(signal) do
+          puts "Got signal #{signal.inspect}"
+          daemon.stop
+          exit
+        end
+      end
+      daemon.start
+      exit
+    end
+    def self.start(daemon)
+      is_running = self.status(daemon)
+      if is_running
+        puts "Riassence Framework is already running. Try restart."
+        exit
+      elsif not is_running and File.file?(daemon.pid_fn)
+        puts "Stale pid file, removing.."
+        FileUtils.rm(daemon.pid_fn)
+      end
+      fork do
+        Process.setsid
+        exit if fork
+        PidFile.store(daemon, Process.pid)
+        Signal.trap('USR1') do 
+          if @transporter != nil
+            @transporter.plugins.shutdown if @transporter.plugins
+            @transporter.sessions.shutdown if @transporter.session
+          end
+        end
+        Signal.trap('USR2') do 
+          puts "Alive."
+        end
+        ['INT', 'TERM', 'KILL'].each do |signal|
+          Signal.trap(signal) do
+            puts "Got signal #{signal.inspect}"
+            daemon.stop
+            exit
+          end
+        end
+        Signal.trap('HUP') {
+          daemon.restart
+        }
+        STDIN.reopen( "/dev/null" )
+        daemon.start
+      end
+      
+      timeout = Time.now + 10
+      sleep 0.1 until self.status(daemon) or timeout < Time.now
+      
+      if timeout < Time.now
+        puts "Riassence Framework did not start, please check the logfile."
+      else
+        puts "Riassence Framework is running now."
+      end
+      
+      sleep 2.5 if $DEBUG_MODE
+      
+      #Process.kill("USR2", File.read(daemon.pid_fn).to_i)
+    end
+    def self.save(daemon,is_restart=false)
+      if !File.file?(daemon.pid_fn)
+        puts "Pid file not found. Is Riassence Framework started?"
+        return if is_restart
+        exit
+      end
+      pid = File.read(daemon.pid_fn).to_i
+      begin
+        pid && Process.kill("USR1", pid)
+        puts "Session data saved."
+      rescue
+        puts "Error, no such pid (#{pid}) running"
+      end
+    end
+    def self.stop(daemon,is_restart=false)
+      self.save(daemon,is_restart)
+      if !File.file?(daemon.pid_fn)
+        puts "Pid file not found. Is Riassence Framework started?"
+        return if is_restart
+        exit
+      end
+      pid = PidFile.recall(daemon)
+      begin
+        pid && Process.kill("TERM", pid)
+        puts "Riassence Framework is stopped now."
+      rescue
+        puts "Error, no such pid (#{pid}) running"
+      end
+      FileUtils.rm(daemon.pid_fn)
+    end
+  end
+end
+
+class HTTPDaemon < Daemon::Base
+  def self.start
+    @transporter = Transporter.new
+    
+    unless ARGV.include?('--log-fg')
+      Daemon::Controller.log_io(self)
+    end
+    
+    # This is the main http handler instance:
+    @broker = Broker.start(
+      @transporter,
+      RSence.config[:http_server][:rack_handler],
+      RSence.config[:http_server][:bind_address],
+      RSence.config[:http_server][:port]
+    )
+    
+    yield @broker if block_given?
+    
+  end
+  def self.restart
+    self.stop
+    @broker = nil
+    self.start
+  end
+  def self.stop
+    @transporter.plugins.shutdown
+    @transporter.sessions.shutdown
+  end
+end
+
+end
+

data/lib/http/broker.rb

@@ -0,0 +1,102 @@
+#--
+##   Riassence Framework
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+ #++
+
+
+
+module RSence
+
+require 'rubygems'
+require 'rack'
+
+## Minimally WEBrick -compatible response object
+require 'http/response'
+
+## Minimally WEBrick -compatible request object
+require 'http/request'
+
+=begin
+
+ Broker routes requests to the proper request processing instance
+
+=end
+
+class Broker
+  
+  def call(env)
+    request  = Request.new(env)
+    response = Response.new
+    request_method = request.request_method.downcase
+    dispatcher = dispatcher_class.new( request, response )
+    dispatcher.send(request_method)
+    content_type = dispatcher.content_type
+    response.header['Content-Length'] = response.body.length.to_s unless response.header.has_key?('Content-Length')
+    return [response.status, response.header, response.body]
+  end
+  
+  def dispatcher_class
+    @dispatcher ||= Class.new(self.class) do
+      attr_accessor :content_type
+      def initialize(request,response)
+        @request  = request
+        @response = response
+      end
+    end
+  end
+  
+  def self.start( transporter, handler, host, port)
+    @@transporter = transporter
+    conf = ::RSence.config[:http_server][:latency]
+    if conf == 0
+      @@ping_sim = false
+    else
+      @@ping_sim = conf/1000.0
+    end
+    handler.run( Rack::Lint.new(self.new), :Host => host, :Port => port )
+  end
+  
+  def self.included(receiver)
+    receiver.extend( SingletonMethods )
+  end
+  
+  def not_found
+    puts "/404: #{@request.fullpath.inspect}" if $DEBUG_MODE
+    @response.status = 404
+    err404 = '<html><head><title>404 - Page Not Found</title></head><body>404 - Page Not Found</body></html>'
+    @response['content-type'] = 'text/html; charset=UTF-8'
+    @response['content-length'] = err404.length.to_s
+    @response.body = err404
+  end
+  
+  ## Post requests are always xhr requests
+  def post
+    
+    puts "post: #{@request.fullpath}" if $DEBUG_MODE
+    
+    sleep @@ping_sim if @@ping_sim
+    
+    not_found unless @@transporter.servlet( :post, @request, @response )
+    
+  end
+  
+  ## Get requests are different, depending on the uri requested
+  def get
+    
+    puts "get: #{@request.fullpath}" if $DEBUG_MODE
+    
+    sleep @@ping_sim if @@ping_sim
+    
+    not_found unless @@transporter.servlet( :get, @request, @response )
+    
+  end
+  
+  
+end
+
+end

data/lib/http/rackup.rb

@@ -0,0 +1,88 @@
+#--
+##   Riassence Framework
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+ #++
+
+if ARGV.include?('--root-path')
+  SERVER_PATH = ARGV[ARGV.index('--root-path')+1]
+else
+  path = ::File.dirname(__FILE__)
+  exp_path = ::File.expand_path( path )
+  lib_path = ::File.split( exp_path )[0]
+  SERVER_PATH = ::File.split( lib_path )[0]
+end
+
+$LOAD_PATH << SERVER_PATH
+$LOAD_PATH << ::File.join( SERVER_PATH, 'lib' )
+
+# Use the default configuration:
+require 'conf/default'
+
+# Debug mode switch. The debug mode is intended for developers, not production.
+$DEBUG_MODE  = RSence.config[:debug_mode]
+
+ENV['RACK_ENV'] = 'production' unless $DEBUG_MODE
+
+## Minimally WEBrick -compatible response object
+require 'http/response'
+
+## Minimally WEBrick -compatible request object
+require 'http/request'
+
+# Transporter is the top-level handler for calls coming from the javascript COMM.Transporter.
+require 'transporter/transporter'
+
+module RSence
+module Broker
+  
+  @@transporter = Transporter.new
+  
+  def self.start
+    conf = ::RSence.config[:http_server][:latency]
+    if conf == 0
+      @@ping_sim = false
+    else
+      @@ping_sim = conf/1000.0
+    end
+  end
+  
+  def self.stop
+    @@transporter.plugins.shutdown
+    @@transporter.sessions.shutdown
+  end
+  
+  def self.call(env)
+    request  = Request.new(env)
+    response = Response.new
+    request_method = request.request_method.downcase
+    if request_method == 'get'
+      puts "get: #{request.fullpath}" if $DEBUG_MODE
+      sleep @@ping_sim if @@ping_sim
+      not_found( request, response ) unless @@transporter.servlet( :get, request, response )
+    elsif request_method == 'post'
+      puts "post: #{request.fullpath}" if $DEBUG_MODE
+      sleep @@ping_sim if @@ping_sim
+      not_found( request, response ) unless @@transporter.servlet( :post, request, response )
+    else
+      puts "unsupported method: #{request_method.inspect}"
+    end
+    response.header['Content-Length'] = response.body.length.to_s unless response.header.has_key?('Content-Length')
+    return [response.status, response.header, response.body]
+  end
+  
+  def not_found( request, response )
+    puts "/404: #{request.fullpath.inspect}" if $DEBUG_MODE
+    response.status = 404
+    err404 = '<html><head><title>404 - Page Not Found</title></head><body>404 - Page Not Found</body></html>'
+    response['content-type'] = 'text/html; charset=UTF-8'
+    response['content-length'] = err404.length.to_s
+    response.body = err404
+  end
+  
+end
+end