nitro 0.1.2

data/lib/n/app/session.rb

@@ -0,0 +1,224 @@
+# = Session
+#
+#--
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2002-2003 Navel, all rights reserved.
+# $Id: session.rb 84 2004-10-19 13:57:01Z gmosx $
+#++
+
+require "md5"
+
+require "n/utils/hash"
+require "n/app/user"
+
+module N; module App
+
+# = SessionManager
+#
+# This object manages Session Objects. Several utility methods
+# are also provided.
+#
+# === WARNING:
+#
+# This object is typically called in a distributed configuration.
+# Avoid writting methods that accept or return big objects!
+#
+# SOS: This object lives in the Cluster!
+#
+class SessionManager < N::SafeHash
+	# the collection of online users.
+	attr_reader :online
+
+	def initialize
+		super
+		@online = N::SafeHash.new
+	end
+
+	# Return the number of anonymous sessions.
+	#
+	def anonymous_count
+		return self.size - @online.size
+	end
+
+	# Login a named user.
+	# The caller may pass user.to_html instead of the user name.
+	# this method is distributed keep a lightweight
+	# signature. By using @online.keys i get access to the
+	# oids and in this way to the full objects.
+	#
+	def login(user_oid, user_name)
+		@online[user_oid] = user_name
+	end
+
+	# Logout a named user.
+	#
+	def logout(user_oid)
+		@online.delete(user_oid)
+	end
+
+	# Returns the session for the given user.
+	#
+	def session_for_user(user)
+		return values().find { |s| user.oid == s.user.oid }
+	end
+
+	# Returns the session for the given user.
+	#
+	def session_for_name(name)
+		return values().find { |s| name == s.user.name }
+	end
+
+	# garbage collect stale sessions
+	#
+	# === TODO:
+	#
+	# - add unit testing.
+	#
+	def self.garbage_collect!
+		# gmosx: the only way to get it to ruby with
+		# druby, aaarghhh!! Rethink this though! perhaps some
+		# fixes i made allow for recoding this.
+		for key in $sessions.keys()
+			begin
+				session = $sessions[key]
+ 				if session.stale?
+					$log.debug "Session finalized: logging out idle user '#{session.user}'" if $DBG
+					session.logout()
+					$sessions.delete(key)
+				end
+			rescue Exception, StandardError => e
+				$log.error "Session gc errror #$!"
+			end
+		end
+	end	
+end
+
+# = Session
+#
+# This object encapsulates a WebApplication session.
+#
+# === Design:
+#
+# The session should be persistable to survive server shutdowns.
+#
+# === Usage
+#
+# State is a neccessary evil but try to avoid using session
+# variables as much as possible. Session state is typically
+# distributed to many servers so avoid storing complete objects
+# in session variables, only store oids and integer/strings.
+#
+class Session < Hash
+	COOKIE_NAME = "nsid"
+
+	attr_reader :session_id
+
+	# keep the user to allow for session lookup based on user.
+	# also do NOT keep the full user as an object in the session hash
+	# to optimize druby usage!
+	#
+	attr_accessor :user
+	
+	# the last touch time
+	attr_accessor :touch_time
+	
+	#
+	#
+	def initialize(sid, request = nil)
+		super()
+		@session_id = sid
+		@touch_time = Time.now
+		@user = N::AnonymousUser.instance()
+	end
+	
+	# Login a user
+	#
+	# Returns false for banned users.
+	#
+	def login(request, user)
+		return false if user.banned? 
+		@user = user
+		@user.login(request)
+		$sessions.login(@user.oid, @user.name)
+		$log.info "User '#{user}' logged in!"
+		return true
+	end
+
+	# Logout a user
+	#
+	def logout()
+		self.clear()
+		@user.logout()
+		$sessions.logout(@user.oid)
+		$log.info "User '#{user}' logged out!"
+		@user = N::AnonymousUser.instance
+	end
+	
+	#
+	#
+	def touch
+		@touch_time = Time.now
+	end
+
+	#
+	#
+	def stale?
+		timeout = @user.anonymous? ? $srv_anon_session_timeout : $srv_session_timeout
+		return (Time.now - @touch_time > timeout)
+	end
+
+	# call this method to synchronize the session with other servers
+	# in the cluster.
+	#
+	def synchronize!
+		# gmosx: TODO, add a check if the session is allready
+		# synchronized.
+		$sessions[@session_id] = self
+	end
+	
+	# Refresh session entities.
+	#
+	# Call this when you manually change entities stored in the 
+	# session. A typical scenario is when you change an online user.
+	#
+	# === Warning: the current version only refreshes the "USER" entity.
+	#
+	def refresh!
+		@user = $db.get(@user.oid, @user.class) if @user
+	end
+
+	# Calculates a unique id.
+	#
+	# The session id must be unique, a monotonically increasing function
+	# like time is appropriate. Random may produce equal ids? add a prefix
+	# (SALT) to stop hackers from creating session_ids.
+	#
+	# TODO:
+	# make the prefix configurable
+	#
+	def self.calculate_id
+		time = Time.now
+		# FIXME: make this more random? 
+		id = Digest::MD5.md5("SALT#{time.to_i} #{time.tv_usec}").to_s
+		return id
+	end
+	
+	# Initialize sessions garbage collection.
+	#
+	# === Warning: this is not used yet!
+	#
+	def self.initialize_gc(session_manager, interval)
+		# gmosx, FIXME: store this in a variable.
+		Thread.new {
+			loop do
+				sleep(interval)
+				garbage_collect(session_manager.sessions)
+			end
+		}
+	end
+	
+end
+
+end; end # module

data/lib/n/app/user.rb

@@ -0,0 +1,47 @@
+# = User
+#
+# A user of the Web Application. This is a base object, typically
+# extended by the users part.
+#
+#--
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2002-2003 Navel, all rights reserved.
+# $Id: user.rb 86 2004-10-19 13:58:40Z gmosx $
+#++
+
+require "singleton"
+
+module N
+
+# = Anonymous User
+#
+# Implemented as singleton.
+#
+class AnonymousUser
+	include Singleton
+
+	attr_accessor :name
+	attr_accessor :locale
+	attr_accessor :shader
+	
+	def initialize
+		super
+		@name = "anonymous"
+		@locale = "en"
+		@shader = $default_shader
+	end
+	
+	def anonymous?
+		true
+	end
+	
+	def login
+	end
+	
+	def logout
+	end	
+end
+
+end # module

data/lib/n/app/webrick-servlet.rb

@@ -0,0 +1,213 @@
+# = Webrick Servlet.
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: webrick-servlet.rb 87 2004-10-19 17:27:45Z gmosx $
+
+require "drb"
+require "singleton"
+require "webrick"
+
+require "n/logger"
+require "n/utils/cache"
+require "n/app/request"
+require "n/app/request"
+require "n/app/handlers"
+require "n/app/session"
+
+# Override WEBrick to suit our needs.
+
+module WEBrick
+	class HTTPRequest
+		alias_method :old_parse_uri, :parse_uri
+		def parse_uri(str, scheme="http")
+			old_parse_uri(__rewrite(str.dup), scheme)
+		end
+		
+		# gmosx, FIXME: temp hack! 
+		#
+		def __rewrite(uri)
+			# FIXME: scan for first ONLY.
+			realm = uri.scan(/^\/(.*?)\//)
+			realm = realm[0][0] unless realm.empty?
+
+			if rules = $rewrites[realm]
+				for rule in rules
+					return uri if uri.gsub!(rule[0], rule[1])
+				end
+			end
+			
+			return uri
+		end		
+	end
+
+  class HTTPResponse
+		attr_writer :header
+		attr_writer :cookies
+	end
+end
+
+module N; module App
+
+# = WebrickServlet
+#
+class WebrickServlet < WEBrick::HTTPServlet::AbstractServlet
+	include WEBrick
+
+	def do_GET(wreq, wres)
+		request = create_request(wreq)
+		request.session = create_session(request)
+
+		extension = N::StringUtils.extension_from_path(request.path)
+		handler = $srv_extension_map[extension][1]
+
+		begin
+			fragment, script = handler.process(request)
+
+			if fragment
+				request.out["Content-Type"] = "text/html" unless request.out["Content-Type"]		
+				request.out_buffer = fragment.body
+			end
+			
+			unless request.expires?
+				request.expires!(Time.now())
+			end
+			
+		rescue Exception, StandardError => e
+			$log.error "error while handling the request #{request.uri}"
+			$log.error pp_exception(e)
+
+			if $error_page_url
+				# internal redirect to error page. 
+				# gmosx: reset handler for .rx pages.
+				handler = $srv_extension_map["sx"][1]
+				request.path = $error_page_url
+				retry
+			else
+				# no custom error page defined. Presen a simple yet 
+				# useful error screen.
+				request.out["Content-Type"] = "text/html"
+				body = %{
+					<h1>ERROR</h1>
+					<p>Click <a href="#{request.referer}">here</a> to return 
+					to the previous page.</p>
+				}
+				if request.error_log
+					body << %{
+						<h3>Request error log</h3>
+						<pre>#{request.error_log.join("\n")}</pre>
+					}
+				end
+				body << %{
+					<h3>Exception</h3>
+					<pre>#{pp_exception(e)}</pre>
+				}
+				request.out_buffer = body
+			end
+		end
+		
+		# gmosx: optimize me, do something more clever!!!
+		request.session.synchronize!
+
+		wres.status = request.status
+		wres.header = request.out
+		wres.cookies = request.out_cookies.values()
+		wres.body = request.out_buffer
+	end
+
+	def do_POST(wreq, wres)
+		do_GET(wreq, wres)
+	end
+	
+#-------------------------------------------------------------------------------
+
+	private
+
+	# Convert a webrick request to an engine request
+	# FIXME: this is UNOPTIMIZED code!
+	#
+	def create_request(wreq)
+		# FIXME: use a resource pool!
+		request = N::App::Request.new
+
+		request.uri = wreq.unparsed_uri
+		request.translated_uri = wreq.path_info
+		request.path = wreq.path
+#		request.path_info = wreq.path_info
+		request.query_string = wreq.query_string
+		request.method = wreq.request_method
+#		request.remote_addr = wreq["REMOTE_ADDR"]
+		# gmosx: we use an apache proxy for the moment.
+		request.remote_addr = wreq["X-FORWARDED-FOR"]
+
+		# gmosx: remove this ??		
+		request.in = {}
+			wreq.header.each { |k, v|
+			# gmosx: upcase to make compatible with n2 codebase.
+			request.in[k.upcase] = v[0]
+		}
+
+		request.parts = {} 
+		request.parameters = {}
+
+		wreq.query.each { |k, v|
+			if v.filename
+				request.parts[k] = N::App::RequestPart.new(v.filename,	v)
+			else
+				request.parameters[k] = v
+			end
+		}
+		
+		request.in_cookies = {}
+		wreq.cookies.each { |c|
+			request.in_cookies[c.name] = c
+		}
+			
+		# gmosx: is this STILL needed??
+		#
+		# INVESTIGATE, FIXME: this is a hack!
+		# apache prepends $srv_url and fucks up msie.
+		# FIXME: add unit test for this!
+
+		if ref = request.in["REFERER"]
+			split_re = Regexp.new($srv_url) unless split_re
+			xref = ref.split(split_re).last
+			if N::StringUtils.valid?(xref)
+				request.in["REFERER"] = xref
+			end
+		end
+
+		return request
+	end
+
+	# Create session
+	#
+	def create_session(request)
+		session = nil
+		session_id = nil
+
+		# gmosx: i have to fix the get_cookie method to return a
+		# full cookie object.
+
+		if session_id = request.get_cookie(N::App::Session::COOKIE_NAME)
+			session = $sessions[session_id]
+			$log.debug "Stale session cookie: #{session_id}" unless session
+			# FIXME: remove cookie if stale!
+		else
+			session_id = N::App::Session.calculate_id()
+			cookie = N::App::Cookie.new(N::App::Session::COOKIE_NAME, session_id)
+			request.out_cookies[N::App::Session::COOKIE_NAME] = cookie
+		end
+
+		# session not found and must be created
+		unless session
+			session = N::App::Session.new(session_id)
+		end
+		
+		return session
+	end
+end
+
+end; end # module