rsence-pre 2.1.0.1.pre

data/lib/http/broker.rb

@@ -0,0 +1,150 @@
+##   RSence
+ #   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
+ ##
+
+require 'rubygems'
+require 'rack'
+
+## Minimally WEBrick -compatible response object
+require 'http/response'
+
+## Minimally WEBrick -compatible request object
+require 'http/request'
+
+
+module RSence
+
+
+# Broker sets up Rack and routes requests to the proper request processing instance.
+class Broker
+  
+  # This method is called from Rack.
+  # @param [Hash] env is the Rack environment.
+  # @return [Array(Number, Hash, String)] Rack-style response status, header, body
+  def call( env )
+    sleep @@ping_sim if @@ping_sim
+    unless @@transporter.online?
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- Server busy."
+      headers = {
+        'Retry-After' => '2',
+        'Content-Type' => 'text/plain',
+        'Refresh' => "2; #{env['REQUEST_URI']}",
+        'Content-Length' => '4'
+      }
+      return [ 503, headers, 'BUSY' ]
+    end
+    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
+  
+  # Returns a dynamically created "REST Dispatcher" kind of class that has
+  # request and response as instance variables and the rest of the Broker
+  # class as the superclass. It calls the method according to the http method. Called from {#call}
+  # Broker currently implements only the {#get} and {#post} methods.
+  # @return [Broker] An instance of Broker with a {Request} instance as +@request+ and a {Response} instance as +@response+
+  def dispatcher_class
+    @dispatcher ||= Class.new(self.class) do
+      attr_accessor :content_type
+      def initialize(request,response)
+        @request  = request
+        @response = response
+      end
+    end
+  end
+  
+  # Creates the Rack instance and set up itself accordingly.
+  #
+  # @param [Transporter] transporter The single {Transporter} instance initialized by {HTTPDaemon}
+  # @param [Hash{Symbol => String}] conf Rack initialization settings
+  # @option conf [String] :bind_address ('127.0.0.1') The TCP/IP address or mask to bind to.
+  # @option conf [#to_i] :port ('8001') The TCP port to bind to.
+  # @option conf [String] :rack_require ('mongrel') The Rack handler to use.
+  def self.start( transporter, conf = {:bind_address => '127.0.0.1', :port => '8001', :rack_require => 'mongrel'} )
+    
+    host = conf[:bind_address]
+    port = conf[:port]
+    
+    @@transporter = transporter
+    latency = ::RSence.config[:http_server][:latency]
+    if latency == 0
+      @@ping_sim = false
+    else
+      @@ping_sim = latency/1000.0
+    end
+    Thread.new do
+      Thread.pass
+      puts "Testing if #{host}:#{port} responds.." if ::RSence.args[:debug]
+      until RSence.argv.test_port( port, host )
+        puts "..#{host}:#{port} doesn't respond yet.." if ::RSence.args[:debug]
+        sleep 0.2
+      end
+      puts "..#{host}:#{port} responds!" if ::RSence.args[:debug]
+      puts "RSence is online on the address http://#{host}:#{port}#{::RSence.config[:base_url]}"
+      @@transporter.online = true
+    end
+    
+    require 'rack'
+    
+    # Loads the selected web-server (default is 'mongrel')
+    rack_require = conf[:rack_require]
+    puts conf.inspect if RSence.args[:debug]
+    
+    require rack_require
+    
+    # Selects the handler for Rack
+    handler = {
+      'webrick'  => lambda { Rack::Handler::WEBrick  },
+      'ebb'      => lambda { Rack::Handler::Ebb      },
+      'thin'     => lambda { Rack::Handler::Thin     },
+      'mongrel'  => lambda { Rack::Handler::Mongrel  },
+      'unicorn'  => lambda { Rack::Handler::Unicorn  },
+      'rainbows' => lambda { Rack::Handler::Rainbows }
+    }[rack_require].call
+    
+    handler.run( Rack::Lint.new(self.new), :Host => host, :Port => port )
+    
+  end
+  
+  # Generic 404 error handler. Just sets up response status, headers, body as a small "Page Not Found" html page
+  def not_found
+    puts "/404: #{@request.fullpath.inspect}" if RSence.args[:verbose]
+    @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
+  
+  # Routes POST requests to {Transporter#servlet}
+  def post
+    
+    puts "post: #{@request.fullpath}" if RSence.args[:verbose]
+    
+    not_found unless @@transporter.servlet( :post, @request, @response )
+    
+  end
+  
+  # Routes GET requests to {Transporter#servlet}
+  def get
+    
+    puts "get: #{@request.fullpath}" if RSence.args[:verbose]
+    
+    not_found unless @@transporter.servlet( :get, @request, @response )
+    
+  end
+  
+  ### -- Add more http methods here when we have some apps to test with CalDAV implementation maybe? ++
+  
+end
+
+end

data/lib/http/rackup.rb

@@ -0,0 +1,91 @@
+##   RSence
+ #   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
+ ##
+
+
+warn "Current RSence rackup Broker implementation does not work."
+warn "Please try again in a future revision."
+exit
+
+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

data/lib/http/request.rb

@@ -0,0 +1,66 @@
+##   RSence
+ #   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
+ ##
+
+
+
+require 'rubygems'
+require 'rack'
+
+module RSence
+  
+  # Simple Request class, slightly more involved
+  # than the Rack::Request it's extending.
+  class Request < Rack::Request
+    attr_reader :header, :path, :query
+    def initialize(env)
+      @header = {}
+      super
+      env2header()
+      @path = path_info()
+      @query = params()
+    end
+    def unparsed_uri
+      return @header['request-uri']
+    end
+    def env2header
+      [ ['SERVER_NAME',           'server-name'],
+        ['HTTP_USER_AGENT',       'user-agent'],
+        ['HTTP_ACCEPT_ENCODING',  'accept-encoding'],
+        ['PATH_INFO',             'path-info'],
+        ['HTTP_HOST',             'host'],
+        ['HTTP_ACCEPT_LANGUAGE',  'accept-language'],
+        ['SERVER_PROTOCOL',       'server-protocol'],
+        ['REQUEST_PATH',          'request-path'],
+        ['HTTP_KEEP_ALIVE',       'keep-alive'],
+        ['SERVER_SOFTWARE',       'server-software'],
+        ['REMOTE_ADDR',           'remote-addr'],
+        ['HTTP_REFERER',          'referer'],
+        ['HTTP_VERSION',          'version'],
+        ['HTTP_ACCEPT_CHARSET',   'accept-charset'],
+        ['REQUEST_URI',           'request-uri'],
+        ['SERVER_PORT',           'server-port'],
+        ['QUERY_STRING',          'query-string'],
+        ['HTTP_ACCEPT',           'accept'],
+        ['REQUEST_METHOD',        'request-method'],
+        ['HTTP_CONNECTION',       'connection'],
+        ['HTTP_SOAPACTION',       'soapaction'],
+        ['HTTP_FORWARDED_HOST',   'forwarded-host']
+      ].each do |env_key,header_key|
+        if @env.has_key?(env_key)
+          @header[header_key] = @env[env_key]
+        end
+        if env_key.start_with?( 'HTTP_' )
+          x_env_key = "HTTP_X#{env_key[4..-1]}"
+          if @env.has_key?( x_env_key )
+            @header["x-#{header_key}"] = @env[ x_env_key ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/http/response.rb

@@ -0,0 +1,65 @@
+##   RSence
+ #   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
+  
+  # Classic WEBrick -compatible Response object for Rack.
+  # Implements only the methods used by the framework.
+  class Response
+    
+    # Adds the + method "operator" to an extended Array.
+    # Used for pushing http body data.
+    class ResponseBody < Array
+      def +(body_data)
+        self.push(body_data)
+      end
+    end
+
+    def initialize
+      @body = ResponseBody.new(1)
+      @body[0] = ''
+      @status = 200
+      @header = {
+        'Content-Type' => 'text/plain',
+        'Server' => 'RSence'
+      }
+    end
+    def body=(body_data)
+      @body = ResponseBody.new(1)
+      @body[0] = body_data
+    end
+    def body
+      @body.join
+    end
+    def content_type=(new_content_type)
+      @header['Content-Type'] = new_content_type
+    end
+    def content_type
+      @header['Content-Type']
+    end
+    def camelize( header_key )
+      header_key.capitalize.gsub(/\-([a-z])/) { '-'+$1.upcase }
+    end
+    def []=(header_key,header_val)
+      @header[camelize( header_key )] = header_val.to_s
+    end
+    def status=(new_val)
+      @status = new_val.to_i
+    end
+    def status
+      @status
+    end
+    def header
+      @header
+    end
+  end
+
+end
+

data/lib/plugins/dependencies.rb

@@ -0,0 +1,285 @@
+##   RSence
+ #   Copyright 2010 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
+  
+  # = Description:
+  # Generic dependency calculator. Used by PluginManager.
+  # = Usage:
+  # This is an almost real world example:
+  #   ## Initialize with pre-satisfied dependencies
+  #   deps = RSence::Dependencies.new( [:foo1,:foo2] )
+  #   
+  #   ## :client_pkg doesn't depend on anything
+  #   deps.set_deps( :client_pkg, nil )
+  #   
+  #   ## :system is the category of :client_pkg
+  #   deps.set_deps( :system, :client_pkg )
+  #   
+  #   ## :index_html depends on :client_pkg
+  #   deps.set_deps( :index_html, :client_pkg )
+  #   
+  #   ## :system is the category of :index_html
+  #   deps.set_deps( :system, :index_html )
+  #   
+  #   ## :main depends on :index_html
+  #   deps.set_deps( :main, :index_html )
+  #   
+  #   ## :system is the category of :main
+  #   deps.set_deps( :system, :main )
+  #   
+  #   ## :impossible has several dependencies, of which :foo3 can't be satisfied
+  #   deps.set_deps( :impossible, [:foo1, :foo2, :foo3] )
+  #   
+  #   ## :ticket has no dependencies
+  #   deps.set_deps( :ticket, nil )
+  #   
+  #   ## :system is the category of :ticket
+  #   deps.set_deps( :system, :ticket )
+  #   
+  #   ## :welcome depends on the :system category
+  #   deps.set_deps( :welcome, :system )
+  #   
+  #   ## :first doesn't depend on anything
+  #   deps.set_deps( :first, nil )
+  #   
+  #   ## Prepending is handled like this:
+  #   deps.set_deps( :client_pkg, :first )
+  #   deps.set_deps( :ticket, :first )
+  #   
+  #   ## Calculates the list of dependencies and returns them in an Array
+  #   p deps.list
+  #   
+  #   ## Output of the example above:
+  #   # impossible dependencies:
+  #   #   :impossible => [:foo3]
+  #   # [:foo1, :foo2, :first, :ticket, :client_pkg, :index_html, :main, :system, :welcome]
+  class Dependencies
+    
+    # Don't use Dependencies for external projects yet. It's subject to change
+    # without deprecation warnings.
+    # +resolved+ and +categories+ are optional.
+    def initialize( resolved = [], categories = {}, quiet=true )
+      @quiet = quiet
+      @pre_resolved = resolved.clone
+      @depends_on = {
+        # :name => [ :dep1, :dep2, :dep3, ... ]
+      }
+      @dependencies_of = {
+        #:dep1 => [ :name1, :name2, ... ]
+      }
+      @categories = []
+      categories.each_key do |cat_name, cat_items|
+        add_category( cat_name )
+        set_deps( cat_name, nil )
+      end
+      @unresolved = []
+      recalculate!
+    end
+    
+    # Returns true, if +name+ is a pre-resolved dependency.
+    def pre_resolved?( name )
+      @pre_resolved.include?( name )
+    end
+    
+    # Returns true, if +name+ is not a pre-resolved dependency and not a category.
+    def loadable?( name )
+      return (not pre_resolved?(name) and not category?(name))
+    end
+    
+    # Returns list of items that are dependencies of +name+ in
+    # no particular order.
+    def deps_of( name )
+      outp = []
+      if @dependencies_of.has_key?(name)
+        @dependencies_of[name].each do |dep|
+          outp.push( dep )
+          outp += deps_of( dep )
+        end
+      end
+      outp.uniq!
+      outp.delete( name )
+      return outp
+    end
+    alias dependencies_of deps_of
+    
+    # Returns list of items that +name+ depends on in no particular order.
+    def deps_on( name )
+      outp = []
+      if @depends_on.has_key?(name)
+        @depends_on[name].each do |dep|
+          outp.push( dep )
+          outp += deps_on( dep )
+        end
+      end
+      outp.uniq!
+      outp.delete( name )
+      return outp
+    end
+    alias depends_on deps_on
+    
+    # List of categories
+    attr_reader :categories
+    
+    # Adds the category +name+.
+    def add_category( name )
+      @categories.push( name ) unless @categories.include?( name )
+    end
+    
+    # Deletes the category +name+, but doesn't dissolve its dependencies.
+    # Essentially turns +name+ into a regular item.
+    def del_category( name )
+      @categories.delete( name ) if @categories.include?( name )
+    end
+    
+    # Returns true, if +name+ is a category.
+    def category?( name )
+      @categories.include?( name )
+    end
+    
+    # Set list of dependency names as +deps+ that +name+ depends on
+    def set_deps( name, deps )
+      if deps.class == Symbol
+        deps = [deps]
+      elsif deps.class == String
+        deps = [deps.to_sym]
+      elsif deps.class == NilClass
+        deps = []
+      elsif deps.class != Array
+        raise "Dependencies.set_deps error: the deps is an unsupported type: #{deps.class}"
+      end
+      if not @depends_on.has_key?(name)
+        @depends_on[name] = deps
+      else
+        deps.each do |dep|
+          @depends_on[name].push( dep ) unless @depends_on[name].include?( dep )
+        end
+      end
+      deps.each do |dep|
+        if not @dependencies_of.has_key?( dep )
+          @dependencies_of[dep] = [name]
+        elsif not @dependencies_of[dep].include?( name )
+          @dependencies_of[dep].push( name )
+        end
+      end
+      recalculate!
+    end
+    alias set_dependencies set_deps
+    alias set_dependency set_deps
+    
+    # Returns copy of the @depends_on Array
+    def clone_depends_on
+      Marshal.load( Marshal.dump( @depends_on ) )
+    end
+    
+    # Returns clone of the @dependencies_of Array
+    def clone_dependencies_of
+      Marshal.load( Marshal.dump( @dependencies_of ) )
+    end
+    
+    # Remove +name+ from dependency system, throws error if it's depended on another item.
+    def del_item( name )
+      d_of = deps_of( name )
+      if not d_of.empty?
+        d_of.each do |dep|
+          if category?( dep )
+            @depends_on[ dep ].delete( name )
+          else
+            throw "Dependencies.del_item error: the following items depend on #{name.inspect} -> #{deps_of(name).inspect}"
+          end
+        end
+      end
+      unless category?( name )
+        deps_on( name ).each do |dep|
+          @dependencies_of[dep].delete(name) if @dependencies_of.has_key?(dep)
+        end
+        @depends_on.delete( name )
+        @dependencies_of.delete( name )
+      end
+      recalculate!
+    end
+    
+    # Returns the order of deletion possible without breaking the dependency chain
+    def del_order( name )
+      d_order = []
+      d_of = deps_of( name )
+      list.reverse.each do |dep|
+        if d_of.include?( dep )
+          d_order.push( dep )
+        end
+      end
+      d_order.push( name )
+      return d_order
+    end
+    
+    # Deletes +name+ and all dependencies of +name+
+    def del_deps( name )
+      del_order( name ).each do |del_name|
+        del_item( del_name )
+      end
+    end
+    
+    # Returns true, if +name+ is unresolved. The list of unresolved items is
+    # updated every time self#recalculate is called.
+    def unresolved?( name )
+      @unresolved.include?( name )
+    end
+    
+    # Returns true, if +name+ is resolved (a valid dependency). Inverse of self#unresolved?
+    def resolved?( name )
+      (not unresolved?( name ))
+    end
+    
+    # Recalculates the list and unresolved items.
+    def recalculate!
+      unresolved = []
+      resolved = @pre_resolved.clone
+      same_len = false
+      depends_on = clone_depends_on
+      target_len = depends_on.keys.length + resolved.length
+      until resolved.length == target_len
+        len = resolved.length
+        depends_on.each do | name, deps |
+          if deps.empty? and not resolved.include?(name)
+            resolved.push( name )
+          elsif deps.empty?
+            next
+          else
+            deps.each do |dep|
+              deps.delete(dep) if resolved.include?(dep)
+            end
+          end
+        end
+        if len == resolved.length
+          if same_len
+            warn "impossible dependencies:" unless @quiet
+            (depends_on.keys - resolved).each do |unsatisfied|
+              warn "  #{unsatisfied.inspect} => #{depends_on[unsatisfied].inspect}" unless @quiet
+              unresolved.push( unsatisfied )
+            end
+            break
+          else
+            same_len = true
+          end
+        else
+          same_len = false
+        end
+      end
+      @unresolved = unresolved
+      @resolved = resolved
+    end
+    
+    # Returns dependencies sorted in load order
+    def list
+      @resolved.clone
+    end
+    alias load_order list
+  end
+end
+