rsence-pre 2.3.0.9 → 2.3.0.10

data/VERSION

@@ -1 +1 @@
-2.3.0.9.pre
+2.3.0.10.pre

data/js/controls/textarea/themes/default/textarea.css

@@ -12,7 +12,7 @@
 }
 
 .default .disabled .textarea_input {
-  #{(BROWSER_TYPE.safari||BROWSER_TYPE.chrome)?'color:#ccc;':'color:#999'}
+  color: #333;
 }
 .default .textarea_input:focus {
   outline-color: transparent;

data/js/core/elem/elem.coffee

@@ -4,6 +4,7 @@ BROWSER_TYPE contains browser types.
 Used for quick checks mostly in layout code
 ###
 BROWSER_TYPE =
+  version: 0.0
   mac: false
   win: false
   ie:  false

data/js/datetime/calendar/themes/default/calendar.css

@@ -85,7 +85,7 @@
 .calendar_weeks_week_col_no {
   color: #666;
 }
-.calendar_weeks_week_col_no:hover {
+.enabled > .calendar_control > .calendar_weeks > .calendar_weeks_week_row > .calendar_weeks_week_col_no:hover {
   color: #000;
 }
 .calendar_weeks_week_col_yes,
@@ -98,7 +98,7 @@
 .calendar_weeks_week_col_sel {
   background-color: #fff;
 }
-.calendar_weeks_week_col_yes:hover {
+.enabled > .calendar_control > .calendar_weeks > .calendar_weeks_week_row > .calendar_weeks_week_col_yes:hover {
   border: 2px solid black; margin: -1px; z-index: 100; border-radius: 3px;
 }
 .calendar_bg {
@@ -110,8 +110,9 @@
   position: absolute;
   font-size: 0; line-height: 0; /* ie bug work-arounds */
 }
-.disabled > .calendar_bg {
-  opacity: 0.9;
+.disabled > .calendar_bg *,
+.disabled > .calendar_control * {
+  opacity: 0.8;
 }
 .calendar_bg .calendar_nw,
 .calendar_bg .calendar_n,

data/lib/rsence/pluginmanager.rb

@@ -423,7 +423,7 @@ module RSence
             break
           end
         else
-          warn "Invalid module_const.class: #{module_const.class.inspect}"
+          warn "Invalid module_const.class: #{module_const.class.inspect} in bundle path: #{path.inspect}"
         end
       end
     end

data/lib/rsence/session/mongo_sessionstorage.rb

@@ -0,0 +1,240 @@
+
+require 'mongo'
+
+# MongoSessionStorage is the SessionStorage backend for MongoDB
+# Authentication string format is strictly like this for now:
+#   mongodb://username:password@host:port/database
+class MongoSessionStorage
+  
+  # Poor-man's connection string parser:
+  def parse_db_uri( db_pool_size=48, db_pool_timeout=2 )
+    db_str = @db_uri.split('mongodb://')[1]
+    ( db_auth_str, db_conn_str ) = db_str.split('@')
+    ( db_username, db_password ) = db_auth_str.split(':')
+    ( db_host, db_port_name_str ) = db_conn_str.split(':')
+    ( db_port, db_name ) = db_port_name_str.split('/')
+    return {
+      :pool_size => db_pool_size,
+      :pool_timeout => db_pool_timeout,
+      :host => db_host,
+      :port => db_port,
+      :username => db_username,
+      :password => db_password,
+      :db => db_name
+    }
+  end
+
+  # Opens database connection
+  def db_open
+    # mongodb://rsence:2N74krTMURIpSr6Y91Hy@localhost:37035/rsence_sessions
+    conn = parse_db_uri
+    @conn = Mongo::Connection.new( conn[:host], conn[:port], {
+      :pool_size => conn[:pool_size],
+      :pool_timeout => conn[:timeout],
+      :auths => [{
+        'username' => conn[:username],
+        'password' => conn[:password],
+        'db_name'  => conn[:db]
+      }]
+    } )
+    @conn.apply_saved_authentication
+    @db = @conn.db( conn[:db] )
+    @db_auth = @db.authenticate( conn[:username], conn[:password], true )
+  end
+
+  # Checks, whether the string can be converted to BSON::ObjectId
+  def legal_bson_str?( _id )
+    ( _id.class == String and BSON::ObjectId.legal?( _id ) )
+  end
+
+  # Converts string-id's to BSON id's
+  def bson_id( _id )
+    if legal_bson_str?( _id )
+      return BSON::ObjectId.from_string( _id )
+    elsif _id.class == BSON::ObjectId
+      return _id
+    else
+      return nil
+    end
+  end
+  
+  # Closes database connection
+  def db_close
+    @conn.close
+    @db = nil
+    @db_auth = false
+  end
+
+  # Tests database authentication
+  def db_test
+    begin
+      db_open
+    rescue => e
+      warn "MongoDB connection exception: #{e.inspect}"
+      return false
+    end
+    return true if @db_auth
+    db_close
+    warn "MongoDB authentication failed"
+    return false
+  end
+
+  # Just binds the collections to their own instance members
+  def db_init
+    @ses_coll = @db['rsence_ses']
+    @up_coll  = @db['rsence_uploads']
+  end
+
+  # Finds every document is the rsence_ses
+  # collection and calls #restore_session
+  def load_session_data
+    @ses_coll.find.each do |ses_row|
+      ses_id   = ses_row['_id'].to_s
+      ses_data_bin = ses_row['ses_data']
+      if ses_data_bin.nil?
+        remove_session_data( ses_id )
+      else
+        begin
+          ses_data = Marshal.load( ses_data_bin.to_s )
+        rescue => e
+          warn "Unable to restore session #{ses_id}"
+          remove_session_data( ses_id )
+        end
+        restore_session( ses_id, ses_data )
+      end
+    end
+  end
+
+  # Inserts new session and returns its id
+  def insert_session_data( ses_data )
+    if legal_bson_str?( ses_data[:user_id] )
+      user_id = bson_id( ses_data[:user_id] )
+    else
+      user_id = ses_data[:user_id]
+    end
+    ses_id = @ses_coll.insert({
+      'cookie_key'  => ses_data[:cookie_key],
+      'ses_key'     => ses_data[:ses_key],
+      'ses_timeout' => ses_data[:ses_timeout],
+      'user_id'     => user_id
+    })
+    return ses_id.to_s
+  end
+
+  # Stores the session data, requires inserted session
+  def store_session_data( ses_data )
+    ses_id = bson_id( ses_data[:ses_id] )
+    if legal_bson_str?( ses_data[:user_id] )
+      user_id = bson_id( ses_data[:user_id] )
+    else
+      user_id = ses_data[:user_id]
+    end
+    ses_data_bin = BSON::Binary.new( Marshal.dump( ses_data ) )
+    @ses_coll.update({'_id' => ses_id}, {'$set' => {
+      'cookie_key'  => ses_data[:cookie_key],
+      'ses_key'     => ses_data[:ses_key],
+      'user_id'     => user_id,
+      'ses_data'    => ses_data_bin,
+      'ses_timeout' => ses_data[:timeout],
+      'ses_stored'  => Time.now.to_i
+    }})
+  end
+
+  # Removes session data of a session
+  def remove_session_data( ses_id )
+    ses_id = bson_id( ses_id )
+    @ses_coll.remove({'_id' => ses_id})
+    @up_coll.remove({'ses_id' => ses_id})
+  end
+
+  # Removes all session data
+  def remove_all_session_data
+    @ses_coll.remove
+    @up_coll.remove
+  end
+
+  # Creates upload, returns its id as string
+  def new_upload_data( data )
+    ses_id = bson_id( data[:ses_id] )
+    if legal_bson_str?( data[:ticket_id] )
+      ticket_id = bson_id( data[:ticket_id] )
+    else
+      ticket_id = data[:ticket_id]
+    end
+    return @up_coll.insert({
+      'ses_id'      => ses_id,
+      'ticket_id'   => ticket_id,
+      'upload_date' => data[:upload_date],
+      'upload_done' => data[:upload_done],
+      'file_name'   => data[:file_name],
+      'file_size'   => data[:file_size],
+      'file_mime'   => data[:file_mime],
+      'file_data'   => BSON::Binary.new( data[:file_data] )
+    }).to_s
+  end
+
+  # Sets upload data
+  def set_upload_data( upload_id, file_data )
+    upload_id = bson_id( upload_id )
+    @up_coll.update({'_id' => upload_id}, { '$set' => {
+      'file_data'   => BSON::Binary.new( file_data ),
+      'upload_done' => true
+    }})
+  end
+
+  # Gets upload data
+  def get_upload_data( upload_id )
+    upload_id = bson_id( upload_id )
+    up_data = @up_coll.find_one({ '_id' => upload_id }, {
+      :fields => [ 'upload_date', 'upload_done', 'file_name',
+                   'file_size', 'file_mime', 'file_data' ]
+    })
+    return {
+      :upload_date => up_data['upload_date'],
+      :upload_done => up_data['upload_done'],
+      :file_name => up_data['file_name'],
+      :file_size => up_data['file_size'],
+      :file_mime => up_data['file_mime'],
+      :file_data => up_data['file_data'].to_s
+    }
+  end
+
+  # Gets upload metadata only
+  def get_upload_meta( upload_id )
+    upload_id = bson_id( upload_id )
+    up_data = @up_coll.find_one({ '_id' => upload_id }, {
+      :fields => [ 'upload_date', 'upload_done', 'file_name',
+                   'file_size', 'file_mime' ]
+    })
+    return {
+      :upload_date => up_data['upload_date'],
+      :upload_done => up_data['upload_done'],
+      :file_name => up_data['file_name'],
+      :file_size => up_data['file_size'],
+      :file_mime => up_data['file_mime'],
+      :file_data => nil
+    }
+  end
+
+  # Deletes upload by id
+  def del_upload( upload_id )
+    upload_id = bson_id( upload_id )
+    @up_coll.remove( { '_id' => upload_id } )
+  end
+
+  # Deletes upload by ticket_id and ses_id
+  def del_uploads( ticket_id, ses_id )
+    if legal_bson_str?( ses_id )
+      ses_id = bson_id( ses_id )
+    else
+      ses_id = false
+    end
+    if legal_bson_str?( ticket_id )
+      ticket_id = bson_id( ticket_id )
+    else
+      ticket_id = ticket_id
+    end
+    @up_coll.remove( { 'ses_id' => ses_id } ) if ses_id
+    @up_coll.remove( { 'ticket_id' => ticket_id } ) if ticket_id
+  end
+end

data/lib/rsence/session/sequel_sessionstorage.rb

@@ -0,0 +1,241 @@
+
+require 'sequel'
+
+# SequelSessionStorage is the SessionStorage backend for
+# Sequel (SQL) database storage
+class SequelSessionStorage
+
+  # Opens database connection
+  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
+
+  # Tests database connection
+  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
+
+  # Closes database connection
+  def db_close
+    @db.disconnect
+  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
+  
+    return true
+  end
+
+  def load_session_data
+    @db[:rsence_session].all do |ses_row|
+      ses_id = ses_row[:id]
+      ses_data_dump = ses_row[:ses_data]
+      if ses_data_dump.nil?
+        remove_session_data( ses_id )
+      else
+        begin
+          ses_data = Marshal.load( ses_data_dump )
+          restore_session( ses_id, ses_data )
+        rescue => e
+          warn "Unable to load session: #{ses_id}, because: #{e.message}"
+          remove_session_data( ses_id )
+        end
+      end
+    end
+  end
+
+  def insert_session_data( ses_data )
+    db_open
+    new_id = @db[:rsence_session].insert( ses_data )
+    db_close
+    return new_id
+  end
+
+  def store_session_data( ses_data )
+    ses_data_dump = Marshal.dump( ses_data )
+    ses_id = ses_data[:ses_id]
+    db_open
+    @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
+    )
+    db_close
+  end
+
+  def remove_session_data( ses_id )
+    db_open
+    # Deletes the session's row from the database
+    @db[:rsence_uploads].filter(:ses_id => ses_id).delete
+    @db[:rsence_session].filter(:id => ses_id).delete
+    db_close
+  end
+
+  def remove_all_session_data
+    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
+
+  def new_upload_data( data )
+    db_open
+    new_id = @db[:rsence_uploads].insert( data )
+    db_close
+    return new_id
+  end
+
+  def set_upload_data( upload_id, file_data )
+    db_open
+    @db[:rsence_uploads].filter(:id => upload_id).update( {
+      :file_data => file_data.to_sequel_blob,
+      :upload_done => true
+    } )
+    db_close
+  end
+
+  def get_upload_data( row_id )
+    db_open
+    row_datas = @db[:rsence_uploads].select(
+      :upload_date, :upload_done, :file_name,
+      :file_size, :file_mime, :file_data
+    ).filter(
+      :id => row_id
+    )
+    db_close
+    return row_datas.first
+  end
+
+  def get_upload_meta( row_id )
+    db_open
+    row_datas = @db[:rsence_uploads].select(
+      :upload_date, :upload_done, :file_name,
+      :file_size, :file_mime
+    ).filter(
+      :id => row_id
+    )
+    db_close
+    return row_datas.first
+  end
+
+  def del_upload( row_id )
+    db_open
+    @db[:rsence_uploads].filter( :id => row_id ).delete
+    db_close
+  end
+
+  def del_uploads( ticket_id, ses_id )
+    db_open
+    @db[:rsence_uploads].filter( :ticket_id => ticket_id ).delete
+    @db[:rsence_uploads].filter( :ses_id => ses_id ).delete
+    db_close
+  end
+
+end

data/lib/rsence/sessionstorage.rb

@@ -10,19 +10,21 @@
 
 module RSence
 
-  require 'rubygems'
-  require 'sequel'
-  
   ## HValue class for session restoration
   require 'rsence/value'
-  
+
+  if RSence.config[:database][:ses_db].start_with? 'mongodb://'
+    require 'rsence/session/mongo_sessionstorage'
+    SessionBackend = MongoSessionStorage
+  else
+    require 'rsence/session/sequel_sessionstorage'
+    SessionBackend = SequelSessionStorage
+  end
+
   # 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
+  # the superclass for SessionManager that handles the persistent
+  # storage.
+  class SessionStorage < SessionBackend
     attr_accessor :db
     def initialize
       ## Session data storage (by ses_id)
@@ -57,181 +59,26 @@ module RSence
         puts "Warning: Session database is not available. Can't use persistent sessions."
         @id_counter = 0
       end
-    
       @accept_requests = true
-    
     end
-  
+    attr_reader :db_avail
     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] )
+
+    ## 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 )
+      if @db_avail
+        return insert_session_data( {
+          :cookie_key  => cookie_key,
+          :ses_key     => ses_key,
+          :ses_timeout => timeout_secs,
+          :user_id     => user_id
+        } )
       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
-    
-      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
-          begin
-            ses_data = Marshal.load( 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
-            if @plugins
-              @plugins.delegate( :load_ses_id, ses_id )
-              @plugins.delegate( :load_ses, ses_data )
-            end
-          rescue => e
-            warn "Unable to load session: #{ses_id}, because: #{e.message}"
-            @db[:rsence_session].filter(:id => ses_id).delete
-            @db[:rsence_uploads].filter(:ses_id => ses_id).delete
-          end
-        end
+        @id_counter += 1
+        return @id_counter
       end
-      db_close
     end
-  
+
     ## Stores all sessions to db from ram
     def store_sessions
       unless @db_avail
@@ -239,59 +86,52 @@ module RSence
         return
       end
       puts "Storing sessions..." if RSence.args[:verbose]
-      db_open
       ses_ids = @sessions.keys
       ses_ids.each do |ses_id|
-        ses_data = @sessions[ses_id]
+        ses_data = @sessions[ses_id].clone
         if @plugins
           @plugins.delegate( :dump_ses, ses_data )
           @plugins.delegate( :dump_ses_id, ses_id )
         end
         begin
-          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
-          )
+          store_session_data( ses_data )
         rescue => e
           warn "Unable to dump session: #{ses_id}, because: #{e.message}"
         end
       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]
+
+    ## Restores a single session, called from the database backend
+    def restore_session( ses_id, ses_data )
+      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
+      if @plugins
+        @plugins.delegate( :load_ses_id, ses_id )
+        @plugins.delegate( :load_ses, ses_data )
+      end
     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 )
+
+    ## Deletes all rows from rsence_session as well as rsence_uploads
+    def reset_sessions
       unless @db_avail
-        @id_counter += 1
-        return @id_counter
+        puts "Warning: Can't reset sessions: No database!" if RSence.args[:verbose]
+        return
       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
+      remove_all_session_data
+    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]
+      load_session_data
     end
-  
+
     ## Expires a session by its identifier
     def expire_session( ses_id )
     
@@ -330,15 +170,11 @@ module RSence
       end
     
       if @db_avail
-        db_open
-        # Deletes the session's row from the database
-        @db[:rsence_uploads].filter(:ses_id => ses_id).delete
-        @db[:rsence_session].filter(:id => ses_id).delete
-        db_close
+        remove_session_data( ses_id )
       end
     
     end
-  
+
     ## Expires all sessions that meet the timeout criteria
     def expire_sessions
     
@@ -352,5 +188,13 @@ module RSence
       
       end
     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
   end
 end

data/lib/rsence/transporter.rb

@@ -54,6 +54,7 @@ module RSence
       RSence.value_manager = @valuemanager
       @sessions = SessionManager.new( self )
       @plugins.sessions = @sessions
+      @plugins.ticket.set_db_state( @sessions.db_avail )
       RSence.session_manager = @sessions
       if RSence.config[:session_conf][:reset_sessions]
         puts "Resetting all sessions..."

data/lib/rsence.rb

@@ -98,6 +98,7 @@ module RSence
     end
     
     def self.transporter
+      return nil unless class_variable_defined?(:'@@transporter')
       @@transporter
     end
     def self.transporter=(transporter)
@@ -110,6 +111,7 @@ module RSence
     end
     
     def self.plugin_manager
+      return nil unless class_variable_defined?(:'@@plugin_manager')
       @@plugin_manager
     end
     def self.plugin_manager=(plugin_manager)
@@ -122,6 +124,7 @@ module RSence
     end
     
     def self.value_manager
+      return nil unless class_variable_defined?(:'@@value_manager')
       @@value_manager
     end
     def self.value_manager=(value_manager)
@@ -134,6 +137,7 @@ module RSence
     end
     
     def self.session_manager
+      return nil unless class_variable_defined?(:'@@session_manager')
       @@session_manager
     end
     def self.session_manager=(session_manager)

data/plugins/ticket/lib/common.rb

@@ -78,30 +78,13 @@ module Common
       :by_id   => {},
       :ses_ids => {}
     }
+
+    @db = false
     
-    begin
-      db_uri = ::RSence.config[:database][:ses_db]
-      if db_uri.start_with?('sqlite://')
-        @db = Sequel.sqlite( db_uri.split('sqlite://')[1] )
-      else
-        @db = Sequel.connect( db_uri )
-      end
-    rescue => e
-      if RSence.args[:debug]
-        err_msg = [
-          "ERROR: TicketServices 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
-      @upload_id = 0
-      @db = false
-    end
+  end
+
+  def set_db_state( state )
+    @db = state
   end
 
   attr_accessor :raw_uris # :nodoc:
@@ -113,9 +96,8 @@ module Common
     return time.gmtime.strftime('%a, %d %b %Y %H:%M:%S %Z')
   end
   
-  # Disconnects connection to the database.
+  # Cleans up structures (not used at the moment)
   def shutdown # :nodoc:
-    @db.disconnect if @db
   end
   
   # Serves files and images by returning an URI. Content is given as second 

data/plugins/ticket/lib/upload.rb

@@ -138,7 +138,7 @@ create table rsence_uploads (
           :file_data   => ''
         }
         if @db
-          upload_id = @db[:rsence_uploads].insert( insert_hash )
+          upload_id = RSence.session_manager.new_upload_data( insert_hash )
         else
           @upload_id += 1
           upload_id = @upload_id
@@ -151,29 +151,18 @@ create table rsence_uploads (
         @upload_slots[:uploaded][ticket_id].push( upload_id )
         
         update_hash = {
-          :file_data   => file_data[:tempfile].read.to_sequel_blob,
+          :file_data   => file_data[:tempfile].read,
           :upload_done => true
         }
         if @db
-          @db[:rsence_uploads].filter(:id => upload_id).update( update_hash )
+          RSence.session_manager.set_upload_data( upload_id, update_hash[:file_data] )
         else
           @upload_slots[:rsence_uploads][upload_id].merge!( update_hash )
         end
       end
     end
     
-    response_body = %{
-      <html>
-        <head>
-          <script type="text/javascript">
-            with(parent){
-              HVM.values[#{value_id.to_json}].set(#{done_value.to_json});
-            }
-          </script>
-        </head>
-        <body></body>
-      </html>
-    }
+    response_body = %{<html><head><script>parent.HVM.values[#{value_id.to_json}].set(#{done_value.to_json});</script></head></html>}
     
     response.status = 200
     response['Content-Type'] = 'text/html; charset=UTF-8'
@@ -187,40 +176,28 @@ create table rsence_uploads (
       @upload_slots[:uploaded][ticket_id].each do |row_id|
         if with_data
           if @db
-            row_datas = @db[:rsence_uploads].select(
-              :upload_date, :upload_done, :file_name,
-              :file_size, :file_mime, :file_data
-            ).filter(
-              :id => row_id
-            )
+            row_data = RSence.session_manager.get_upload_data( row_id )
           else
-            row_datas = @upload_slots[:rsence_uploads][row_id]
+            row_data = @upload_slots[:rsence_uploads][row_id].first
           end
-          if row_datas.count == 1
-            row_data = row_datas.first
+          unless row_data.nil?
             row_hash = {
               :date => Time.at(row_data[:upload_date]),
               :done => row_data[:upload_done],
               :size => row_data[:file_size],
               :mime => row_data[:file_mime],
               :name => row_data[:file_name],
-              :data => row_data[:file_data]
+              :data => row_data[:file_data].to_s
             }
             uploads.push(row_hash)
           end
         else
           if @db
-            row_datas = @db[:rsence_uploads].select(
-              :upload_date, :upload_done, :file_name,
-              :file_size, :file_mime
-            ).filter(
-              :id => row_id
-            )
+            row_data = RSence.session_manager.get_upload_meta( row_id )
           else
-            row_datas = @upload_slots[:rsence_uploads][row_id]
+            row_data = @upload_slots[:rsence_uploads][row_id].first
           end
-          if row_datas.count == 1
-            row_data = row_datas.first
+          unless row_data.nil?
             row_hash = {
               :date => Time.at(row_data[:upload_date]),
               :done => row_data[:upload_done],
@@ -240,7 +217,7 @@ create table rsence_uploads (
   def del_upload( ticket_id, row_id )
     @upload_slots[:uploaded][ticket_id].delete(row_id)
     if @db
-      @db[:rsence_uploads].filter( :id => row_id ).delete
+      RSence.session_manager.del_upload( row_id )
     else
       @upload_slots[:rsence_uploads].delete(row_id)
     end
@@ -257,7 +234,7 @@ create table rsence_uploads (
       @upload_slots[:uploaded][ticket_id].each do |row_id|
         @upload_slots[:uploaded][ticket_id].delete( row_id )
         if @db
-          @db[:rsence_uploads].filter( :id => row_id ).delete
+          RSence.session_manager.del_upload( row_id )
         else
           @upload_slots[:rsence_uploads].delete(row_id)
         end
@@ -268,8 +245,7 @@ create table rsence_uploads (
       @upload_slots[:by_id].delete( ticket_id )
     end
     if @db
-      @db[:rsence_uploads].filter( :ticket_id => ticket_id ).delete
-      @db[:rsence_uploads].filter( :ses_id => ses_id ).delete
+      RSence.session_manager.del_uploads( ticket_id, ses_id )
     end
   end
   

data/plugins/ticket/ticket.rb

@@ -130,6 +130,17 @@ class TicketPlugin < Plugin
     super
     @ticketserve = TicketServe.new
   end
+
+  def open
+    super
+    unless RSence.session_manager.nil?
+      set_db_state( RSence.session_manager.db_avail )
+    end
+  end
+
+  def set_db_state( state )
+    @ticketserve.set_db_state( state )
+  end
   
   # @private Shuts down TicketServe
   def shutdown

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsence-pre
 version: !ruby/object:Gem::Version
-  version: 2.3.0.9
+  version: 2.3.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-02 00:00:00.000000000 Z
+date: 2012-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsence-deps
@@ -103,6 +103,8 @@ files:
 - lib/rsence/plugins/plugin_sqlite_db.rb
 - lib/rsence/plugins/servlet.rb
 - lib/rsence/plugins.rb
+- lib/rsence/session/mongo_sessionstorage.rb
+- lib/rsence/session/sequel_sessionstorage.rb
 - lib/rsence/sessionmanager.rb
 - lib/rsence/sessionstorage.rb
 - lib/rsence/sigcomm.rb