rsence 2.0.0.0.pre

data/lib/session/sessionstorage.rb

@@ -0,0 +1,314 @@
+##   Riassence Framework
+ #   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
+ ##
+
+require 'rubygems'
+require 'sequel'
+
+## HValue class for session restoration
+require 'values/hvalue'
+
+
+module RSence
+
+=begin
+SessionStorage doesn't do anything by itself, it's simply
+the superclass for SessionManager that does all the boring
+housekeeping duties.
+
+Splitted of as a separate file to reduce the complexity
+of SessionManager.
+
+=end
+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]
+    
+    db_init
+    
+    @accept_requests = true
+    
+  end
+  
+  attr_reader :accept_requests
+  
+  def db_test
+    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)
+  end
+  
+  def db_close
+    @db.disconnect
+  end
+  
+  def db_open
+    @db = Sequel.connect(@db_uri)
+  end
+  
+  # def db_open
+  #   ## Tests if database has sufficient privileges
+  #   begin
+  #     @db = Sequel.connect(@db_uri)
+  #     db_test
+  #     db_close
+  #     @db = Sequel.connect(@db_uri)
+  #   rescue => e
+  #     $stderr.write( "SessionStorage: error #{e.inspect}\nReverting to default database.\n" )
+  #     @db_uri = "sqlite://#{File.join(SERVER_PATH,'var','db','rsence_ses.db')}"
+  #     @db = Sequel.connect(@db_uri)
+  #     db_test
+  #     db_close
+  #     @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 $DEBUG_MODE
+      @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 $DEBUG_MODE
+      @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 $DEBUG_MODE
+      @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
+    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
+    puts "Restoring sessions..." if $DEBUG_MODE
+    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
+    puts "Storing sessions..." if $DEBUG_MODE
+    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 $DEBUG_MODE
+    store_sessions
+    puts "Session shutdown complete." if $DEBUG_MODE
+  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 )
+    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
+    
+    db_open
+    # Deletes the session's row from the database
+    @db[:rsence_session].filter(:id => ses_id).delete
+    db_close
+    
+  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,254 @@
+#--
+##   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
+
+=begin
+  Transporter is the counterpart to the client's HTransporter xhr engine.
+=end
+
+class Transporter
+  
+  # ValueManager syncronizes value objects
+  require 'values/valuemanager'
+  
+  # SessionManager creates, validates, stores and expires sessions
+  require 'session/sessionmanager'
+
+  # PluginManager handles all the plugins
+  require 'plugins/pluginmanager'
+  
+  attr_accessor :valuemanager, :sessions, :plugins
+  
+  def initialize
+    @config = ::RSence.config[:transporter_conf]
+    
+    @valuemanager = ValueManager.new
+    @sessions = SessionManager.new( self )
+    @plugins = PluginManager.new( ::RSence.config[:plugin_paths], self, $DEBUG_MODE )
+    
+    # Used by:
+    #   plugins/main/main.rb
+    $SESSION = @sessions
+    
+  end
+  
+  def servlet( request_type, request, response )
+    broker_urls = ::RSence.config[:broker_urls]
+    uri = request.fullpath
+    # if $DEBUG_MODE and uri == $config[:index_html][:respond_address] and request_type == :get
+    #   unless ARGV.include?('-no-rescan') or ARGV.include?('--no-rescan')
+    #     puts "Reloading plugins."
+    #     if ARGV.include?('-say')
+    #       Thread.new do
+    #         Thread.pass
+    #         system('say "Reloading plugins."')
+    #       end
+    #     end
+    #     @plugins.rescan
+    #     puts "Plugins reloaded."
+    #     if ARGV.include?('-say')
+    #       Thread.new do
+    #         Thread.pass
+    #         system('say "Plugins reloaded."')
+    #       end
+    #     end
+    #   end
+    # end
+    
+    if 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
+      else
+        session = {}
+        return @plugins.match_servlet( request_type, request, response, session )
+      ## /SOAP handles SOAP Requests
+      # elsif uri == broker_urls[:soap]
+      #   soap( request, response )
+      #   return true
+      end
+    else
+      session = {}
+      return @plugins.match_servlet( request_type, request, response, session )
+    end
+  end
+  
+  ## handles incoming SOAP requests
+  # def soap(request, response)
+  #   PluginManager.soap( request, response )
+  # 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 $DEBUG_MODE
+    puts err_descr
+    if $DEBUG_MODE
+      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 $DEBUG_MODE
+      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]
+        msg.reply("COMM.Transporter.url=#{::RSence.config[:broker_urls][:x].to_json};")
+      end
+      
+      # Appends a 'new session.' message for new sessions in $DEBUG_MODE:
+      puts "new session." if msg.new_session and $DEBUG_MODE
+      puts "restored session." if msg.restored_session and $DEBUG_MODE
+      puts "clone source." if msg.cloned_targets and $DEBUG_MODE
+      puts "clone target." if msg.cloned_source and $DEBUG_MODE
+      
+      ## 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