class SmartSessionStore

# The class to be used for creating, retrieving and updating sessions.
# Defaults to SmartSessionStore::Session, which is derived from +ActiveRecord::Base+.
#
# In order to achieve acceptable performance you should implement
# your own session class, similar to the one provided for Myqsl.
#
# Only functions +find_session+, +create_session+,
# +update_session+ and +destroy+ are required. See file +mysql_session.rb+.

cattr_accessor :session_class
@@session_class = SqlSession

# Create a new SmartSessionStore instance.
#
# +session+ is the session for which this instance is being created.
#
# +option+ is currently ignored as no options are recognized.

def initialize(session, option=nil)
if @session = @@session_class.find_session(session.session_id)
# Is this really necessary? Because CGI:Session will call restore method anyway.
self.data = unmarshalize(@session.data)
else
@session = @@session_class.create_session(session.session_id, marshalize({}))
self.data = {}
end
end

# Update the database and disassociate the session object
def close
if @session
save_session
@session = nil
end
end

# Delete the current session, disassociate and destroy session object
def delete
if @session
@session.destroy
@session = nil
end
end

# Restore session data from the session object.
# The data hash returned by this restore method is stored in the CGI::Session and is used
# by the application when session properties are set and get within
# an ActionController::Base instance whenever the brackets operator is used.
# e.g. session[:username] = "Peter".
# This means that this session store must not create a new Hash
# except here, because otherwise the CGI:Session and this session store
# use different objects.
def restore
if @session
self.data = unmarshalize(@session.data)
end
end

# Save session data in the session object
def update
if @session
save_session
end
end

private

def data= data
@data = data
if @session && @session.data
@original_marshalized_data = @session.data
else
@original_marshalized_data = marshalize( {})
end
@data
end

def unmarshalize(data)
Marshal.load(Base64.decode64(data))
end

def marshalize(data)
Base64.encode64(Marshal.dump(data))
end

# Bugfix by Flexoptix was added in this method:
# If save is called more than once in a single request (it is already called automatically
# at the end of request processing by the rails framework and it can be called manually through
# "session.update()", the session may not be stored into the database, because smart_session thinks
# nothing has changed.
def save_session
# fo_logger = Log4r::Logger.new(self.class.name.to_s)
# fo_logger.level = Log4r::DEBUG
# fo_logger.add('fo_logger_output')

if @original_marshalized_data
# Bugfix by Flexoptix BEGIN
# we have to get the information every time not only if @original_data is empty.
# this is because @original_marshalized_data is update at the end of this method.
# So if save_session is called more than once than this is necessary.
# ORIGINAL @original_data ||= unmarshalize @original_marshalized_data
@original_data = unmarshalize @original_marshalized_data
# Bugfix by Flexoptix END
else
@original_data = {}
end
@data ||= {}

# fo_logger.info("#{ENV['SERVER_IDENTIFICATION']} - session date before merge: #{@data.object_id} #{@data.to_a().join(', ')}")
# fo_logger.info("#{ENV['SERVER_IDENTIFICATION']} - comparing with original: #{@original_data.object_id} #{@original_data.to_a().join(', ')}")

# find out which keys have been deleted
deleted_keys = @original_data.keys - @data.keys
changed_keys = []

# find out which keys have been change
@data.each {|k,v| changed_keys << k if Marshal.dump( @original_data[k]) != Marshal.dump( v)}

if changed_keys.empty? && deleted_keys.empty?
# fo_logger.info("#{ENV['SERVER_IDENTIFICATION']} - no session update")
return
end

SqlSession.transaction do
fresh_session = @@session_class.find_session(@session.session_id, true)
# Important for testing:
# This code block is only execute when the session record in database has changed meanwhile
# by another concurrent request. So the manual save problem (which has been fixed)
# only popped up when the there were more than one instance of mongrel.
if fresh_session && fresh_session.data != @original_marshalized_data && fresh_data = unmarshalize(fresh_session.data)
# fo_logger.info("#{ENV['SERVER_IDENTIFICATION']} - current data: #{fresh_data.to_a().join(', ')}")
deleted_keys.each {|k| fresh_data.delete k}
changed_keys.each {|k| fresh_data[k] = @data[k]}

# Bugfix by Flexoptix BEGIN
# ORIGINAL @data = fresh_data
# we must use the existing hash which was returned to the CGI::Session when
# the restore method was called.
# If we just would use the = operator the @data field
# would point to a new Hash in memory and CGI::Session would not
# know anything about it.
@data.clear()
@data.merge!(fresh_data)
# Bugfix by Flexoptix END

@session = fresh_session
end
# Bugfix by Flexoptix BEGIN
# ORIGINAL: @session.update_session(@original_marshalized_data)
@original_marshalized_data = marshalize(@data)
@session.update_session(marshalize(@data)) # @original_marshalized_data
# Bugfix by Flexoptix END

# fo_logger.info("#{ENV['SERVER_IDENTIFICATION']} - session data after merge: #{@data.object_id} #{@data.to_a().join(', ')}")
end

end
end

__END__

# This software is released under the MIT license
# Copyright (c) 2007 Frederick Cheung
# Copyright (c) 2005,2006 Stefan Kaes

# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:

# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

deleted_keys = @original_data.keys - @data.keys
changed_keys = []
@data.each {|k,v| changed_keys << k if Marshal.dump( @original_data[k]) != Marshal.dump( v)}

return if changed_keys.empty? && deleted_keys.empty?