rsence-pre 2.1.0.1.pre

data/lib/session/sessionstorage.rb

@@ -0,0 +1,340 @@
+##   RSence
+ #   Copyright 2006 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 'sequel'
+  
+  ## HValue class for session restoration
+  require 'values/hvalue'
+  
+  # SessionStorage doesn't do anything by itself, it's simply
+  # the superclass for SessionManager that does all the boring
+  # housekeeping duties.
+  # 
+  # Spliced of as a separate file to reduce the complexity
+  # of SessionManager.
+  class SessionStorage
+    attr_accessor :db
+    def initialize
+      ## Session data storage (by ses_id)
+      @sessions     = {}
+    
+      ## Session id by key
+      @session_keys = {}
+    
+      ## Session id by cookie key
+      @session_cookie_keys = {}
+    
+      @clone_origins = {
+        # id => [ id, id, id ... ]
+      }
+      @clone_sources = {
+        # id => id
+      }
+      @clone_targets = {
+        # id => [ id, id, id ... ]
+      }
+    
+      ## Disposable keys (new ses_key each request)
+      @config = RSence.config[:session_conf]
+    
+      @db_uri = RSence.config[:database][:ses_db]
+    
+      if db_test
+        @db_avail = true
+        db_init
+      else
+        @db_avail = false
+        puts "Warning: Session database is not available. Can't use persistent sessions."
+        @id_counter = 0
+      end
+    
+      @accept_requests = true
+    
+    end
+  
+    attr_reader :accept_requests
+  
+    def db_test
+      begin
+        db_open
+        if @db.table_exists?(:rsence_test)
+          @db.drop_table(:rsence_test)
+        end
+        @db.create_table(:rsence_test) { primary_key :id; String :test }
+        test_id = @db[:rsence_test].insert( :test => 'TestFoo' )
+        @db[:rsence_test].filter( :id => test_id ).update( :test => 'TestFoo2' )
+        @db[:rsence_test].filter( :id => test_id ).delete
+        @db[:rsence_test].delete
+        @db.drop_table(:rsence_test)
+        db_close
+        return true
+      rescue => e
+        if RSence.args[:debug]
+          err_msg = [
+            "ERROR: SessionStorage couldn't open database",
+            "#{e.class.to_s}, #{e.message}",
+            "Backtrace:",
+            "\t"+e.backtrace.join("\n\t")
+          ].join("\n")+"\n"
+          $stderr.write( err_msg )
+        elsif RSence.args[:verbose]
+          puts "Failed to open database '#{@db_uri}'."
+          puts "Run RSence in debug mode for full error output."
+        end
+        return false
+      end
+    end
+  
+    def db_close
+      @db.disconnect
+    end
+  
+    def db_open
+      # work-around for windows (drive letters causing confusion)
+      if @db_uri.start_with?('sqlite://')
+        @db = Sequel.sqlite( @db_uri.split('sqlite://')[1] )
+      else
+        @db = Sequel.connect(@db_uri)
+      end
+    end
+  
+    ## Creates the 'rsence_session' table, if necessary
+    ## This table is used to store sessions
+    def create_session_table
+      db_open
+      unless @db.table_exists?(:rsence_session)
+        puts "Creating session table..." if RSence.args[:verbose]
+        @db.create_table :rsence_session do
+          primary_key( :id )
+          column( :cookie_key,  String  )
+          column( :ses_key,     String  )
+          column( :ses_timeout, Integer )
+          column( :user_id,     Integer )
+          column( :ses_active,  TrueClass )
+          column( :ses_stored,  Integer )
+          column( :ses_data,    File    )
+        end
+      end
+      db_close
+    end
+  
+    ## Creates the 'rsence_version' table, if necessary
+    ## This table is used to check for the need of future database upgrades
+    def create_version_table
+      db_open
+      unless @db.table_exists?(:rsence_version)
+        puts "Creating version info table..." if RSence.args[:verbose]
+        @db.create_table :rsence_version do
+          Integer :version
+        end
+        @db[:rsence_version].insert(:version => 586)
+      end
+      db_close
+    end
+  
+    ## Creates the 'rsence_uploads' table, if necessary
+    ## This table is used for storing temporary uploads before processing
+    def create_uploads_table
+      db_open
+      unless @db.table_exists?(:rsence_uploads)
+        puts "Creating uploads table..." if RSence.args[:verbose]
+        @db.create_table :rsence_uploads do
+          primary_key( :id )
+          foreign_key( :ses_id, :rsence_session )
+          column( :upload_date, Integer )
+          column( :upload_done, Integer )
+          column( :ticket_id,   String  )
+          column( :file_size,   Integer )
+          column( :file_name,   String  )
+          column( :file_mime,   String  )
+          column( :file_data,   File    )
+        end
+      end
+      db_close
+    end
+  
+    # returns the version in the rsence_version table
+    def table_version
+      db_open
+      rsence_version = @db[:rsence_version].select(:version).all[0][:version]
+      db_close
+      return rsence_version
+    end
+  
+    ## Checks database connectivity and loads stored sessions from the database
+    def db_init
+    
+      create_session_table
+      create_version_table
+      create_uploads_table
+    
+      ## Used for future upgrades:
+      # version = table_version
+    
+      if @config[:reset_sessions]
+        puts "Resetting all sessions..."
+        reset_sessions()
+      else
+        restore_sessions()
+      end
+    
+      return true
+    end
+  
+    ## Deletes all rows from rsence_session as well as rsence_uploads
+    def reset_sessions
+      unless @db_avail
+        puts "Warning: Can't reset sessions: No database!" if RSence.args[:verbose]
+        return
+      end
+      db_open
+      @db[:rsence_session].delete if @db.table_exists?(:rsence_session)
+      @db[:rsence_uploads].delete if @db.table_exists?(:rsence_uploads)
+      db_close
+    end
+  
+    ## Restores all saved sessions from db to ram
+    def restore_sessions
+      unless @db_avail
+        puts "Warning: Can't restore sessions: No database!" if RSence.args[:verbose]
+        return
+      end
+      puts "Restoring sessions..." if RSence.args[:verbose]
+      db_open
+      @db[:rsence_session].all do |ses_row|
+        ses_id = ses_row[:id]
+        ses_data_dump = ses_row[:ses_data]
+      
+        if ses_data_dump == nil
+          @db[:rsence_session].filter(:id => ses_id).delete
+          @db[:rsence_uploads].filter(:ses_id => ses_id).delete
+        else
+          ses_data = Marshal.restore( ses_data_dump )
+          ses_key = ses_data[:ses_key]
+          @sessions[ses_id] = ses_data
+          @session_keys[ ses_key ] = ses_id
+          @session_cookie_keys[ ses_data[:cookie_key] ] = ses_id
+        end
+      end
+      db_close
+    end
+  
+    ## Stores all sessions to db from ram
+    def store_sessions
+      unless @db_avail
+        puts "Warning: Can't store sessions: No database!" if RSence.args[:verbose]
+        return
+      end
+      puts "Storing sessions..." if RSence.args[:verbose]
+      db_open
+      @sessions.each_key do |ses_id|
+        ses_data = @sessions[ ses_id ]
+        ses_data_dump = Marshal.dump( ses_data )
+        @db[:rsence_session].filter(
+          :id => ses_id
+        ).update(
+          :cookie_key  => ses_data[:cookie_key],
+          :ses_key     => ses_data[:ses_key],
+          :user_id     => ses_data[:user_id],
+          :ses_data    => ses_data_dump.to_sequel_blob,
+          :ses_timeout => ses_data[:timeout],
+          :ses_stored  => Time.now.to_i
+        )
+      end
+      db_close
+    end
+  
+    ## Shut-down signal, triggers store_sessions for now
+    def shutdown
+      @accept_requests = false
+      puts "Session shutdown in progress..." if RSence.args[:verbose]
+      store_sessions
+      puts "Session shutdown complete." if RSence.args[:verbose]
+    end
+  
+  
+    ## Returns a new, unique session identifier by storing the params to the database
+    def new_ses_id( cookie_key, ses_key, timeout_secs, user_id=0 )
+      unless @db_avail
+        @id_counter += 1
+        return @id_counter
+      end
+      db_open
+      new_id = @db[:rsence_session].insert(
+        :cookie_key  => cookie_key,
+        :ses_key     => ses_key,
+        :ses_timeout => timeout_secs,
+        :user_id     => user_id
+      )
+      db_close
+      return new_id
+    end
+  
+    ## Expires a session by its identifier
+    def expire_session( ses_id )
+    
+      return unless @sessions.has_key? ses_id
+    
+      ses_data = @sessions[ ses_id ]
+    
+      # Makes the session invalid for xhr's by deleting its key
+      @session_keys.delete( ses_data[:ses_key] )
+    
+      # Makes the session invalid for all requests by deleting its cookie key
+      @session_cookie_keys.delete( ses_data[:cookie_key] )
+    
+      # Deletes the session data itself
+      @sessions.delete( ses_id )
+    
+      # Removes all ticket-based storage bound to the session
+      @plugins[:ticketservices].expire_ses( ses_id ) if @plugins
+    
+      # target -> source cleanup
+      if @clone_sources.has_key?( ses_id )
+        source_id = @clone_sources[ ses_id ]
+        @clone_sources.delete( ses_id ) if @clone_sources.has_key?( ses_id )
+        @clone_targets[ source_id ].delete( ses_id ) if @clone_targets.has_key?( source_id )
+      end
+    
+      # source -> targets cleanup
+      if @clone_targets.has_key?( ses_id )
+        @clone_targets[ ses_id ].each do |target_id|
+          @clone_sources.delete( target_id ) if @clone_sources.has_key?( target_id )
+        end
+        @clone_targets.delete( ses_id ) if @clone_targets.has_key?( ses_id )
+      end
+    
+      if @db_avail
+        db_open
+        # Deletes the session's row from the database
+        @db[:rsence_session].filter(:id => ses_id).delete
+        db_close
+      end
+    
+    end
+  
+    ## Expires all sessions that meet the timeout criteria
+    def expire_sessions
+    
+      # Loop through all sessions in memory:
+      @sessions.each_key do |ses_id|
+      
+        timed_out = @sessions[ ses_id ][:timeout] < Time.now.to_i
+      
+        ## Deletes the session, if the session is too old
+        expire_session( ses_id ) if timed_out
+      
+      end
+    end
+  end
+end

data/lib/transporter/transporter.rb

@@ -0,0 +1,263 @@
+##   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
+ ##
+
+
+# ValueManager synchronizes value objects
+require 'values/valuemanager'
+
+# SessionManager creates, validates, stores and expires sessions
+require 'session/sessionmanager'
+
+# PluginManager handles all the plugins
+require 'plugins/pluginmanager'
+
+
+module RSence
+  
+  # Transporter handles incoming requests targeted at RSence and distributes calls and data accordingly. It's called via {Broker}.
+  # @see Broker
+  class Transporter
+    
+    # The single instance of the {ValueManager}
+    # @return [ValueManager]
+    attr_accessor :valuemanager
+    
+    # The single instance of the {SessionManager}
+    # @return [SessionManager]
+    attr_accessor :sessions
+    
+    # The main instance of the {PluginManager}
+    # @return [PluginManager]
+    attr_accessor :plugins
+    
+    def initialize
+      @config = RSence.config[:transporter_conf]
+      @accept_req = false
+      @valuemanager = ValueManager.new
+      @sessions = SessionManager.new( self )
+      core_pkgs = {
+        :core => [:transporter, :session_storage, :session_manager, :value_manager]
+      }
+      @plugins = PluginManager.new(
+        RSence.config[:plugin_paths],
+        self,
+        RSence.args[:autoupdate],
+        false,
+        core_pkgs[:core],
+        core_pkgs
+      )
+      if RSence.launch_pid != Process.pid
+        Process.kill( 'TERM', RSence.launch_pid )
+      end
+    end
+  
+    def online?
+      @accept_req
+    end
+  
+    def online=(state)
+      return if @accept_req == state
+      if RSence.args[:verbose]
+        if state
+          puts "RSence is online now."
+        else
+          puts "RSence is offline now."
+        end
+      end
+      @accept_req = state
+    end
+  
+    def shutdown
+      online=false
+      @plugins.shutdown
+      @sessions.shutdown
+    end
+  
+    def servlet( request_type, request, response )
+      broker_urls = RSence.config[:broker_urls]
+      uri = request.fullpath
+    
+      if @plugins.match_servlet( request_type, request, response, {} )
+        return true
+      elsif request_type == :post
+        ## /x handles xhr without cookies
+        if uri == broker_urls[:x] and @sessions.accept_requests
+          xhr( request, response, { :cookies => true, :servlet => false } )
+          return true
+        ## /hello handles the first xhr (with cookies, for session key)
+        elsif uri == broker_urls[:hello] and @sessions.accept_requests
+          xhr( request, response, { :cookies => true, :servlet => false } )
+          return true
+        end
+      end
+      return false
+    end
+  
+    # wrapper for the session manager stop client functionality
+    def xhr_error_handler(msg,err_name,err_extra_descr='')
+      @sessions.stop_client_with_message( msg,
+        @config[:messages][err_name][:title],
+        @config[:messages][err_name][:descr]+err_extra_descr,
+        @config[:messages][err_name][:uri]
+      )
+    end
+  
+    # wrapper for tracebacks in xhr
+    def xhr_traceback_handler(e,err_descr='Transporter::UnspecifiedError')
+      puts "=="*40 if RSence.args[:debug]
+      puts err_descr
+      if RSence.args[:debug]
+        puts "--"*40
+        puts e.message
+        puts "  #{e.backtrace.join("\n  ")}"
+        puts "=="*40
+      end
+    end
+  
+    ## handles incoming XMLHttpRequests from the browser
+    def xhr(request, response, options = { :cookies => false, :servlet => false } )
+    
+      session_conf = RSence.config[:session_conf]
+    
+      options[:cookies] = false unless options.has_key?(:cookies)
+    
+      if session_conf[:session_cookies] and session_conf[:trust_cookies]
+        options[:cookies] = true
+      end
+    
+      # Creates the msg object, also checks or creates a new session; verifies session keys and such
+      msg = @sessions.init_msg( request, response, options )
+    
+      response_success = true
+    
+      # If the client encounters an error, display error message
+      if request.query.has_key?('err_msg')
+        response_success = false
+        client_error_msg = request.query['err_msg'].inspect
+        puts "\nCLIENT ERROR:\n#{client_error_msg}\n" if RSence.args[:debug]
+        xhr_error_handler(msg,:client_error,client_error_msg)
+      end
+    
+      # If the session is valid, continue:
+      if msg.ses_valid and response_success
+        
+        # If cookies are true, it means the url base needs to
+        # be changed from /hello to /x to prevent further cookie juggling.
+        if options[:cookies] and not options[:servlet]
+          conf_sync_url = RSence.config[:broker_urls][:x]
+        else
+          conf_sync_url = RSence.config[:broker_urls][:hello]
+        end
+        if msg.request.path != conf_sync_url
+          msg.reply("COMM.Transporter.url=#{conf_sync_url.to_json};")
+        end
+        
+        # Appends a 'new session.' message for new sessions in RSence.args[:verbose]:
+        if RSence.args[:verbose]
+          puts "new session." if msg.new_session
+          puts "restored session." if msg.restored_session
+          puts "clone source." if msg.cloned_targets
+          puts "clone target." if msg.cloned_source
+        end
+        
+        ## Pass the client XML to the value manager
+        if request.query.has_key?( 'values' )
+          syncdata_str = request.query[ 'values' ]
+          begin
+            @valuemanager.xhr( msg, syncdata_str )
+          rescue => e
+            response_success = false
+            xhr_error_handler( msg, :valuemanager_xhr_error, e.message )
+            xhr_traceback_handler( e, "Transporter::ValueManagerXHRError: @valuemanager.xhr failed." )
+          end
+        end
+      
+        ## Calls the restore_ses of plugins, when a session is restored (page reload with previously active session)
+        if msg.restored_session
+          msg.session[:deps] = []
+        
+          if msg.cloned_source
+            begin
+              @plugins.delegate( :cloned_target, msg, msg.cloned_source )
+            rescue => e
+              response_success = false
+              xhr_error_handler( msg, :plugin_delegate_cloned_target_error, e.message )
+              xhr_traceback_handler( e, "Transporter::PluginDelegateClonedTargetError: @plugins.delegate 'cloned_target' failed." )
+            end
+          end
+        
+          begin
+            @plugins.delegate( :restore_ses, msg )
+          rescue => e
+            response_success = false
+            xhr_error_handler( msg, :plugin_delegate_restore_ses_error, e.message )
+            xhr_traceback_handler( e, "Transporter::PluginDelegateRestoreSesError: @plugins.delegate 'restore_ses' failed." )
+          end
+        
+        elsif msg.new_session
+          begin
+            @plugins.delegate( :init_ses, msg )
+          rescue => e
+            response_success = false
+            xhr_error_handler( msg, :plugin_delegate_init_ses_error, e.message )
+            xhr_traceback_handler( e, "Transporter::PluginDelegateInitSesError: @plugins.delegate 'init_ses' failed." )
+          end
+        elsif msg.cloned_targets
+          begin
+            @plugins.delegate( :cloned_source, msg, msg.cloned_targets )
+          rescue => e
+            response_success = false
+            xhr_error_handler( msg, :plugin_delegate_cloned_source_error, e.message )
+            xhr_traceback_handler( e, "Transporter::PluginDelegateClonedSourceError: @plugins.delegate 'cloned_source' failed." )
+          end
+        end
+        
+        ## Calls validators for changed values
+        begin
+          @valuemanager.validate( msg )
+        rescue => e
+          response_success = false
+          xhr_error_handler( msg, :valuemanager_validate_error, e.message )
+          xhr_traceback_handler( e, "Transporter::ValueManagerValidateError: @valuemanager.validate failed." )
+        end
+        
+        ### Allows every plugin to respond to the idle call
+        begin
+          @plugins.delegate( :idle, msg )
+        rescue => e
+          response_success = false
+          xhr_error_handler( msg, :plugin_idle_error, e.message )
+          xhr_traceback_handler( e, "Transporter::PluginIdleError: @plugins.idle failed." )
+        end
+        
+        ### Processes outgoing values to client
+        begin
+          @valuemanager.sync_client( msg )
+        rescue => e
+          response_success = false
+          xhr_error_handler( msg, :valuemanager_sync_client_error, e.message )
+          xhr_traceback_handler( e, "Transporter::ValueManagerSyncClientError: @valuemanager.sync_client failed." )
+        end
+        
+      else
+      
+        # session is not valid, the error was set in SessionManager
+        response_success = false
+      
+      end
+    
+      msg.response_success = response_success
+    
+      unless options[:servlet]
+        msg.response_done()
+      end
+    
+      return msg
+    end
+  end
+end

data/lib/util/gzstring.rb

@@ -0,0 +1,9 @@
+
+require 'zlib'
+
+
+# @private Implements the +write+ method for strings, used with zlib to
+#   use GZStrings as the target for compression.
+class GZString < String
+  alias write <<
+end

data/lib/util/ruby19_fixes.rb

@@ -0,0 +1,18 @@
+
+# NOTE: Ruby 1.9 isn't fully supported yet.
+# There are some encoding handlers and some of the dependencies are not fully working yet.
+# One should wait for Ruby 2.0 for production use anyway.
+
+# Ruby 1.9 encoding defaults.
+# This is clearly not enough but a good start for fixing the encoding madness.
+Encoding.default_external = Encoding::BINARY
+Encoding.default_internal = Encoding::BINARY
+
+# Ruby 1.9 doesn't have String#each anymore.
+# This is a backwards-compatible work-around.
+class String
+  def each 
+    self.split($/).each { |e| yield e } 
+  end 
+end
+