sws 0.4

data/lib/sws/JSComponents/components/JSMenu/JSMenu.sws

@@ -0,0 +1,37 @@
+contento:
+  _class: SWS::Content
+
+menu_id_string:
+  _class: SWS::String
+  value: menu_id
+
+menu_link:
+  _class: SWS::Hyperlink
+  href: "'#'"
+  other_tag_string: menu_link_js_events
+
+menu_div:
+  _class: SWS::GenericContainer
+  tag_name: "'div'"
+  id: menu_div_id
+  other_tag_string: "'style=\"visibility: hidden; position:absolute; z-index:1; left:0; top:0\"'"
+
+menu_table:
+  _class: SWS::GenericContainer
+  tag_name: "'table'"
+  class: menu_class
+
+actions_repetition:
+  _class: SWS::Repetition
+  list: actions
+  item: action_cursor
+
+action_link:
+  _class: SWS::Hyperlink
+  action: action_for_cursor
+  other_tag_string: "'onmousedown=\"document.onmousedown=null;\"'"
+
+action_string:
+  _class: SWS::String
+  value: name_for_cursor
+

data/lib/sws/JSComponents/framework.yaml

@@ -0,0 +1,3 @@
+components:
+  JSComponents::JSMenu: components/JSMenu
+

data/lib/sws/adaptor.rb

@@ -0,0 +1,334 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+
+module SWS
+	
+	
+	# Adaptor is a part of application that listens for requests. Currently there
+	# are 3 available adaptors - Standalone, FastCGI and CGI (the last one is
+	# experimental). You can write your own adaptor - it should just inherit from
+	# Generic adaptor and implement run and each_request methods.
+	module Adaptor
+
+
+		# Base class for all adaptors
+		class Generic
+
+			# Header translation hash - defines how the env variables are named in request.headers
+			# TODO: add missing headers
+			HEADER_TRANSLATION = {
+				"HTTP_USER_AGENT" => "user-agent",
+				"HTTP_HOST" => "host",
+				"HTTP_COOKIE" => "cookie",
+				"CONTENT_LENGTH" => "content-length",
+				"CONTENT_TYPE" => "content-type",
+				"REMOTE_ADDR" => "remote-address"
+			}
+			
+			# Base path of the adaptor 
+			attr_reader :base_path
+
+			def initialize ()
+				raise "Adaptor::Generic cannot be instantiated - override and don't call super"
+			end
+
+
+			# Start the adaptor. Custom adaptors should override this method and
+			# shouldn't call super
+			def run ()
+				raise "Override and do not call super for Adaptor.run"
+			end
+
+
+			# Main adaptor method - invokes block for each received request. Custom
+			# adaptors should override this method and shouldn't call super
+			def each_request ()
+				raise "Override and do not call super for Adaptor.each_request"
+			end
+
+		end
+		
+		
+		# Adaptor listening on a TCPport
+		class Standalone < Generic
+
+			attr_accessor :port
+
+			# Creates new adaptor listening on a given port
+			def initialize ( port = 1234 )
+
+				@port = port
+				#Always "/" for this class, as the application listens on its own port
+				@base_path = "/"
+
+			end
+
+
+			# Start listening for request
+			def run ()
+				@server = TCPServer.new( @port )
+			end
+
+
+			# Main adaptor method - invokes block for each received request
+			def each_request ()
+
+				while ( socket = @server.accept() )
+
+					request = create_request( socket )
+					response = yield( request )
+					begin
+						socket.print( "#{response.http_version} #{response.status}\r\n" )
+						socket.print( response.to_s )						
+						socket.close()
+					rescue => exception
+						$log_sws_request.warn( "Exception #{exception.class} when writing response: #{exception.message}" )
+					end
+
+				end
+
+			end
+
+
+			private
+
+			# Gets the request data from socket and creates the Request object
+			def create_request ( socket )
+
+				lines = Array.new()
+				request_method,whole_path,http_version = socket.gets().split( /\s+/ )
+				$log_sws_request.debug( "New request: #{whole_path}" )
+				path,query_string = whole_path.split( /\?/,2 )
+				request = Request.new( request_method, path, query_string, http_version )
+				# the "sub" is needed to get rid of IPv6 prefix
+				# TODO: make it more elegant and handle IPv6 adresses
+				request.headers["remote-address"] = socket.peeraddr[3].sub( /^.*:/,"" )
+				begin
+					line = socket.gets()
+					# Read all header lines
+					lines << line unless ( line == "\r\n" )
+				end while ( line != "\r\n" )		
+				lines.each do |line|
+					key,value = line.strip().split( /:\s*/ )
+					key.downcase!()
+					request.headers[key] = value
+					$log_sws_request.debug( "Key: #{key}, value: #{value}\n" )
+					# read request content
+					if ( key == "content-length" )
+						# Headers has been read, so there is only the content itself left
+						request.content = socket.read( value.to_i )
+					end
+				end	
+				request.process_headers()
+				request.process_content() if ( request.has_content? )
+				return request
+
+			end
+
+		end
+
+		
+		# FastCGI adaptor. Note that at the moment it will only run properly if you
+		# start only one instace of the application. It SHOULD work ok if you run
+		# multiple instances and use session affinity patch for mod_fastcgi, but I
+		# didn't test that.
+		class FastCGI < Generic
+				
+			def initialize	
+
+				#The 'require' clause has been placed within initialize to avoid
+				#exception if the FastCGI adaptor is not used and fcgi.rb is missing
+				require 'fcgi'
+
+				#Base_path will be initialized on first request, because it is not known before
+			end
+
+
+			# Run for FastCGI adaptor is in fact performed in each_request, so this
+			# method is empty
+			def run
+			
+			end
+
+
+			# Main adaptor method - invokes block for each received request
+			def each_request ()
+				
+				FCGI.each_request do |fcgi_request|
+					#This is a FCGI request, not a SWS one - we need to transform it
+					sws_request = create_request( fcgi_request )
+
+					# Base path can only be deducted after first request
+					unless ( @base_path )
+						@base_path = fcgi_request.env["SCRIPT_NAME"] + "/"
+					end
+
+					response = yield( sws_request )
+					fcgi_request.out.print( "Status: #{response.status}\r\n" )
+					fcgi_request.out.print( response.to_s )
+					fcgi_request.finish
+				end
+
+			end
+
+
+			# Creates SWS::Request object using FastCGI request object
+			def create_request ( fcgi_request )
+
+				request_method = fcgi_request.env["REQUEST_METHOD"]
+				path = fcgi_request.env["PATH_INFO"] || "/"
+				# This may be invalid - but it isn't propably important
+				http_version = fcgi_request.env["SERVER_PROTOCOL"]
+				query_string = fcgi_request.env["QUERY_STRING"]
+				# We wan't the same behaviour as Standalone adaptor has
+				if query_string == "" then
+					query_string = nil
+				end
+				request = Request.new( request_method, path, query_string, http_version )
+				
+				HEADER_TRANSLATION.each do |original_header,request_header|
+					request.headers[request_header] = fcgi_request.env[original_header]
+				end
+
+				content_length = fcgi_request.env["CONTENT_LENGTH"]
+				if ( content_length )
+					request.content = fcgi_request.in.read( content_length.to_i )
+				end					
+				
+				fcgi_request.env.each do |key,value| 
+					unless HEADER_TRANSLATION.has_key?( key )
+						request.headers[key.downcase] = value
+					end
+				end
+				request.process_headers()
+				request.process_content() if ( request.has_content? )
+				return request
+				
+			end
+			
+		end
+
+
+		# CGI Adaptor. CGI scripts are not persitant, so I had to use some ugly
+		# hacks (including drb) to make it work transparently for the user (and
+		# developer). It has a serious bug - if the response is bigger than 8kB 
+		# it is  not returned to the client correctly. The use of this adaptor 
+		# is discouraged and it may be removed in future versions.
+		class CGI < Generic
+
+			
+			def initialize ( drb_port = 2345 )
+
+				# 'Require' included here, so that DRb is not loaded if this adaptor is
+				# not used
+				require 'drb' 
+				@drb_port = drb_port
+
+			end
+
+
+			# Setup DRb server. Remember the DRBObject is the adaptor itself.
+			def run ()
+
+				request = create_request()
+
+				# Base_path will be set on every request. This doesn't matter though,
+				# because on the remote adaptor it will be set only once
+				@base_path = ENV["SCRIPT_NAME"] + "/"
+				
+				begin
+					
+					adaptor = DRb::DRbObject.new_with_uri( "druby://localhost:#{@drb_port}" )
+					# Try to use the remote Adaptor object
+					adaptor.handle_request( request )
+
+				rescue DRb::DRbConnError
+
+					# Attempt to retrieve remote Adaptor object failed - need to start the DRb server
+	
+					# Probably not necessary
+					trap( "SIGCLD", "IGNORE" ) 
+
+					# Terminate parent and run child in daemon mode
+					if ( fork() ) then exit(0) end
+					DRb.start_service( "druby://localhost:#{@drb_port}", self )
+					Process.setsid()
+
+					@each_request_mutex = Mutex.new() 
+					@each_request_mutex.lock() 
+					@handle_request_mutex =	Mutex.new()
+
+					handle_request( request )
+
+				end
+
+			end
+			
+
+			# Main adaptor methods - invokes block for each received request
+			def each_request ()
+
+				loop do
+				
+					@each_request_mutex.lock()
+					response = yield( @current_request )
+					#	print( "Status: 200 OK\n" )
+					#	print( "Content-type: text/html;charset=iso-8859-2\n") 
+					#	print( "Pragma: no-cache\n" )
+					#	print( "Set-Cookie: session=6aa83079b309dd51d2dee0b1250719ca; path=/\n" )
+					#	print( "\n")
+					print( "Status: #{response.status}\r\n" )
+					$stderr.puts( "B1" )
+					$stderr.puts( "BEfore Response: #{response.to_s}"  )
+					print( response.to_s )
+					print( "\r\n" )
+					$stderr.puts( "After Response"  )
+					@handle_request_mutex.unlock()
+
+				end
+				
+			end
+
+
+			# Creates SWS::Request object from ENV variables
+			def create_request ()
+				
+				request_method = ENV["REQUEST_METHOD"]
+				path = ENV["PATH_INFO"] || "/"
+				$stderr.puts( "Path: #{path}" )
+				# This may be invalid - but it isn't propably important
+				http_version = ENV["SERVER_PROTOCOL"]
+				request = Request.new( request_method, path, http_version )
+
+				HEADER_TRANSLATION.each do |env_variable,header_name|
+					request.headers[header_name] = ENV[env_variable]
+				end
+
+				content_length = ENV["CONTENT_LENGTH"]
+				if ( content_length )
+					request.content = $stdin.read( content_length.to_i )
+				end					
+				
+				request.process_headers()
+				request.process_content() if ( request.has_content? )
+				return request
+
+			end
+				
+
+			protected
+			def handle_request( request )
+
+				@handle_request_mutex.lock()
+				@current_request = request
+				@each_request_mutex.unlock()
+
+			end
+
+
+		end
+
+	end
+
+end

data/lib/sws/application.rb

@@ -0,0 +1,604 @@
+#!/usr/bin/env ruby 
+
+module SWS
+
+	APP_CONFIG_FILE = "application.yaml"
+	FRAMEWORK_CONFIG_FILE = "framework.yaml"
+
+	CONFIG_COMPONENTS = "components"
+	CONFIG_RESOURCES = "resources"
+	CONFIG_FRAMEWORKS = "frameworks"
+	CONFIG_LOAD_PATHS = "load_paths"
+	
+	# Main class of each SWS application. Can be accessed as a singleton object.
+	# Contains global data (session independent) and perform fundamental
+	# request/response/exception handling. Defines request handlers.
+	
+	class Application
+		
+		
+		# Singleton instance of an application
+		@@instance = nil	
+
+		# Default encoding for components 
+		attr_accessor :default_encoding
+
+		# Adaptor object - determines the type of interface the application uses 
+		# (eg. Adaptor, FastCGIAdaptor etc) 
+		attr_reader :adaptor
+
+		# Handlers for different types of requests.
+		# There are following types of requests:
+		# - component request: URL /cp/11324134 - request for existing component registered
+		# in @pages hash - the number is component id, 'cp' - request handler key
+		# - page by name request: URL /pn/132443243/pageName - request for component
+		# by its name - 'pn' is request handler key, number is _previous_ component id
+		# (it is necessary so that one cannot access page directly by just writing
+		# eg. /pn/43532322/pageName)
+		# - direct action: URL /da/className/actionName - like direct action in WO.
+		# Again, 'da' is request handler key, actionName is self-descripting
+		# - resource request: URL /rs/frameworkName/resourceName - request for
+		# application resource, eg. image or CSS file.
+		# You can also provide custom request handlers - just add them to 
+		# @request_handlers hash.
+		# Key - request handler key (eg. 'pn', 'da'), value - method handling this 
+		# type of request.
+		attr_reader :request_handlers
+
+		# Request handler key for component requests 
+		attr_reader :component_request_handler_key
+		
+		# Request handler key for page by name requests
+		attr_reader :page_name_request_handler_key
+		
+		# Request handler key for direct action requests
+		attr_reader :direct_action_request_handler_key
+
+		# Request handler key for resource requests
+		attr_reader :resource_request_handler_key
+		
+		# Paths in which all files of components will be searched for
+		attr_reader :component_paths
+
+		# Paths in which resources will be searched for
+		attr_reader :resource_paths
+
+		# Name of the subclass of Component that will be used as default for serving
+		# requests (eg. for default DirectAction or "/"). Defaults to "Main"
+		attr_reader :default_component_class_name
+
+		# Name of the subclass of DirectAction that will be used to serve
+		# DirectAction requests with no class specified. Defaults to DirectAction
+		attr_reader :default_direct_action_class
+
+		# Name of the subclass of Session that will be used for storing sessions.
+		# Defaults to Session
+		attr_reader :session_class
+		
+		# Component class used to generate exception page
+		attr_reader :exception_component
+
+		# Creates new singleton Application object		
+		def initialize ()
+
+			if ( @@instance != nil )
+				raise "Cannot create Application instance if one exists!"
+			else
+				@@instance = self
+			end
+
+			@request_count = 0
+			@frameworks = Hash.new
+			
+			load_config_file()
+			
+			setup_request_handlers()
+			setup_component_cache()
+			setup_session_cleaner()			
+
+		end
+		
+
+		private
+
+		# Reads the configuration from YAML file
+		def load_config_file()
+			
+			@config = YAML::load( File.open( APP_CONFIG_FILE ) )
+			
+			# Adaptor to use
+			@adaptor = @config["adaptor_class"] ? 
+				SWS.get_class( @config["adaptor_class"] ).new : Adaptor::Standalone.new
+			# Class used for session objects
+			@session_class = @config["session_class"] ? 
+				SWS.get_class( @config["session_class"] ) : Session
+			# Class used for direct actions (if no class explicitly specified)
+			@default_direct_action_class = @config["default_direct_action_class"] ?
+				SWS.get_class( @config["default_direct_action_class"] ) : DirectAction
+			# Name of component returned for new sessions
+			@default_component_class_name = @config["default_component_class"] || "Main"
+			# Default component encoding
+			@default_encoding = @config["default_encoding"] || "iso-8859-1"
+			# Name of component used to create exception pages
+			@exception_component = @config["exception_component_class"] || "SWS::ExceptionPage"
+			
+			# Max number of sessions
+			@max_sessions = @config["max_sessions"] || 100
+			# Man number of top-level components per session
+			@max_components_per_session = @config["max_components_per_session"] || 5
+			# Sessions' inactivity time (in seconds) after which it will be swept out
+			@session_timeout = @config["session_timeout"] || 6*3600
+			# This time (in seconds) specifies how often session cleaning will be performed
+			@session_cleaner_interval = @config["session_cleaner_interval"] || 600
+			# Should the application refuse new sessions or kill Least Recently Used
+			# when limit reached?
+			@refuse_sessions = @config["refuse_sessions"] || false
+				
+			@config[CONFIG_FRAMEWORKS].each_pair { |name,location| load_framework( name, location ) }
+
+		end
+
+
+		# Loads a framework 
+		def load_framework( name, location )
+
+
+			config_file = find_framework_config_file( location )
+			unless ( config_file )
+				raise( "Cannot find framework #{name} in location #{location}" )
+			end
+
+			config = YAML::load( File.open( config_file ) )
+			path = File.dirname( config_file )
+			components = config[CONFIG_COMPONENTS] || Hash.new
+			resources = config[CONFIG_RESOURCES] || Hash.new
+			load_paths = config[CONFIG_LOAD_PATHS] || Array.new
+
+			@frameworks[name] = Framework.new( path,components,resources )
+
+			$LOAD_PATH.push( *load_paths )
+				
+		end
+		
+
+		# Searches for framework config file. Frameworks with location starting with
+		# "SYSTEM" are searched in standard locations ($LOAD_PATH/sws) - otherwise
+		# the location is relative to the application directory
+		# TODO: reconsider what should be added with respect to RubyGems
+		def find_framework_config_file( location )
+			
+			if( location =~ /^SYSTEM/ )
+				
+				loc = location.sub( /^SYSTEM/,"" )
+
+				$LOAD_PATH.each do |path|
+					config_file = File.join( path, loc, FRAMEWORK_CONFIG_FILE	)
+					if ( File.exists?( config_file ) )
+						return config_file
+					end
+				end
+
+			else
+				
+				config_file = File.join( location, FRAMEWORK_CONFIG_FILE )
+				if ( File.exists?( config_file ) )
+					return config_file
+				end
+				
+			end
+
+			return nil
+			
+		end
+
+		# Sets the request handlers up		
+		def setup_request_handlers ()
+			
+			#default request handlers' keys
+			@component_request_handler_key = "cp"
+			@page_name_request_handler_key = "pn"
+			@direct_action_request_handler_key = "da"
+			@resource_request_handler_key = "res"
+
+			#register default request handlers
+			@request_handlers = Hash.new()
+			@request_handlers [@component_request_handler_key] = :handle_component_request
+			@request_handlers [@page_name_request_handler_key] = :handle_page_name_request
+			@request_handlers [@direct_action_request_handler_key] = :handle_direct_action_request
+			@request_handlers [@resource_request_handler_key] = :handle_resource_request
+			#all other defaults to component requests
+			@request_handlers.default = :handle_component_request
+			
+		end
+
+
+		def setup_component_cache
+			ComponentCache.max_components_per_session = @max_components_per_session			
+		end
+
+		def setup_session_cleaner
+
+			@session_cleaner_mutex = Mutex.new	
+			@session_cleaner = SessionCleaner.new( @session_class.sessions, @session_cleaner_mutex, @session_timeout, @session_cleaner_interval )
+					
+		end
+
+		
+		public
+
+		# Returns the singleton instance of the application	
+		def Application.instance ()
+			return @@instance
+		end
+
+
+		# Starts the application (starts the adaptor and goes into #request_loop)
+		def run ()
+			
+			@adaptor.run()
+			request_loop()
+			
+		end
+		
+
+		# Main request loop of the application. Reads Request objects from the
+		# adaptor and passes them to #handle_request method
+		def request_loop ()
+			
+			@adaptor.each_request do |request|
+
+				@request_count += 1
+			
+				# The response has to be returned from the block - handle request returns one
+				response = nil
+				@session_cleaner_mutex.synchronize {
+					response = handle_request( request )
+				}				
+				response
+				
+			end
+			
+		end
+
+
+		# Exception handling method. If you want to customize error handling, just
+		# override this one.
+		def handle_exception ( request,exception )
+			
+			$log_sws_request.warn( "Exception in application loop: #{exception}" )
+			$log_sws_request.warn( "Backtrace: #{exception.backtrace.join("\n")}" )
+		
+			begin
+				
+				exception_page = Component.create( @exception_component, request )
+				exception_page.exception = exception
+				component,response = exception_page.process_request( request )
+				
+			rescue Exception => exception #just in case there is an error in SWS itself
+
+				$log_sws_component.warn( "Exception in exception component #{@exception_component}: #{exception}" )
+				$log_sws_component.warn( "Backtrace: #{exception.backtrace.join("\n")}" )
+				
+				response = Response.new( request,"500" )			
+				response.cookies << request.session.to_cookie
+				response.headers["Content-type"] = "text/html;charset=#{@default_encoding}"
+				response.headers["Pragma"] = "no-cache"
+				response.headers["Expires"] = "0"
+				response.headers["Cache-control"] = "private, no-cache, no-store, must-revalidate, max-age = 0"
+
+				response << "<HTML><BODY><H1>Exception raised!</H1>\n"
+				response << "<H3>#{exception.class}:#{exception}</H3>\n"
+				response << "Backtrace: <BR> #{exception.backtrace.join("<BR>\n")}"
+				response << "</BODY></HTML>\n"
+				
+			end
+
+			return response
+
+		end
+
+		
+		def handle_too_far_backtrack ( request )
+			
+				# TODO: not sure about the status
+				response = Response.new( request,"200 SWS" )
+				response.cookies << request.session.to_cookie
+				response.headers["Content-type"] = "text/html;charset=#{@default_encoding}"
+				response.headers["Pragma"] = "no-cache"
+				response.headers["Expires"] = "0"
+				response.headers["Cache-control"] = "private, no-cache, no-store, must-revalidate, max-age = 0"
+
+				# TODO: allow the user to enter the application again
+				response << "<HTML><BODY><H1>You backtracked too far</H1>\n"
+				response << "</BODY></HTML>\n"
+				return nil,response
+
+		end
+		
+		# Called when new session is to be refused. Default implementation return a
+		# simplistic info page. Note that this method probably shouldn't return a
+		# component, as a component may require session to work properly.
+		def handle_refuse_session ( request )
+
+			response = Response.new( request ,"503" ) 
+			response.headers["Content-type"] = "text/html;charset=#{@default_encoding}"
+			response.headers["Pragma"] = "no-cache"
+			response.headers["Expires"] = "0"
+			response.headers["Cache-control"] = "private, no-cache, no-store, must-revalidate, max-age = 0"
+
+			response << "<HTML><BODY><H1>Session refused!</H1>\n"
+			response << "<H3>Session refused due to application overload. Please try again later.</H3>"
+			response << "</BODY></HTML>\n"
+			
+			return response
+
+		end
+		
+
+		# Takes the request and calls one of request_handlers basing on request
+		# handler key contained in URL. Also performs session retrieval/creation.
+		def handle_request ( request )
+
+			# hack for requests for favicon if it doesn't exist
+			# TODO: it blocks ALL favicon.ico requests, but should block only if
+			# favicon.ico is not provided
+			# TODO: or we should omit this issue after implementation of
+			# handling more than one current component 
+			if ( request.query_string =~ /favicon.ico$/ || request.path =~ /favicon.ico$/ )
+				return Response.new( request, "404 Not Found" )
+			end
+
+			session = request.session 
+			if ( session == nil )
+				
+				if ( @session_class.sessions.size < @max_sessions )
+					
+					session = @session_class.new
+					request.session = session
+					
+				else	# Too many sessions
+					
+					if ( @refuse_sessions )
+						return handle_refuse_session( request )
+					else
+						# Delete Least Recently Used session
+						session_to_delete = @session_class.sessions.values.inject do |session1,session2|
+							session1.last_access_time < session2.last_access_time ? session1 : session2
+						end
+						
+						@session_class.delete_session( session_to_delete )
+						session = @session_class.new
+						request.session = session
+					end
+
+				end
+				
+			end
+
+			session.last_access_time = Time.now
+
+			#strip leading /'s
+			path = request.path.sub( /^\/+/,"" )
+
+			#path =~ ^/key/url_content$		
+			if ( md = /^([^\/]*)\/+(.*)$/.match( path ) )			
+				
+				request_handler_key = md[1]
+				#TODO: rename it: its just the url without request handler key
+				#I assume the query string is already stripped
+				url_content = md[2]
+				request_handler = method( @request_handlers[request_handler_key] )		
+			else
+				#call default request handler
+				request_handler = method( @request_handlers[path] )
+				url_content = path
+			end
+
+			begin
+
+				component,response = request_handler.call( request,url_content )
+				# The resource request handler does not return component
+
+				# That means that we only want to send response without any component.
+				# Variable component is used to return response. Look at
+				# SWS::Component#process_request for more. 
+				if( response == nil )
+					return component
+				end
+				
+				if ( component )
+					request.session.add_to_cache( component )
+				end
+				return response
+				
+			rescue Exception => exception
+				
+				return handle_exception( request,exception )
+				
+			end
+			
+
+		end
+
+		
+		# Handles component requests
+		def handle_component_request ( request,url_content )
+
+			# check if url_content =~ /^component_data(/action)
+			if ( md = /^([^\/]*)\/+(.*)$/.match( url_content ) )
+
+				component_data = md[1]
+				action_object_id = md[2].to_i
+
+			else	#no "/" after component_id
+
+				component_data = url_content
+
+			end
+
+			component_id, request_number = component_data.split( /\./ ).collect { |el| el.to_i }
+			
+			$log_sws_component.debug( "Request number: #{request_number}" )
+			$log_sws_component.debug( "Got component id: #{component_id}" )
+			component = request.session.get_from_cache( component_id )
+			$log_sws_component.debug( "Retrieved component id: #{component.object_id}" )
+			unless ( component && request_number )
+				if request.session.old?( component_id ) # Backtracked too far
+					return handle_too_far_backtrack( request )
+				else # new session or random URL	- redirect to default component
+					# We don't care about any parameters
+					request.erase_content()
+					component = Component.create( @default_component_class_name,request )
+					request_number = nil
+				end
+			else
+			
+				# TODO: make it possible to present a custom error page on backtrack (it
+				# would require holding ids of all old components in session)
+				if ( action_object_id )	
+					#action_object_id contains id of object, whose action should be performed
+					#right now it can only be a Hyperlink or a Form
+					action_object = component.action_components[ action_object_id ] 
+					if ( action_object )
+						# We don't call the action immediately - only mark it as enabled and
+						# it will be called during call_action phase of request-response loop
+						action_object.enable_action()
+					else
+						component = Component.create( @default_component_class_name,request )
+					end					
+				end
+			end
+			
+			$log_sws_component.debug( "Component id: #{component.object_id}, request_number #{request_number}" )
+			return component.process_request( request, request_number )
+			
+		end
+
+
+		# Handles page name requests
+		def handle_page_name_request ( request,url_content )
+
+			if ( md = /^(-?\d+)\/(.+)/.match( url_content ) )
+
+				previous_component = request.session.get_from_cache( md[1].to_i )
+				unless ( previous_component )
+					
+					request.erase_content()
+					component = Component.create( @default_component_class_name,request )
+
+					return component.process_request( request )
+					
+				else
+					
+					next_component_name = md[2]
+					component = Component.create( next_component_name, request, next_component_name)
+							
+					return component.process_request( request )
+					
+				end
+
+			else
+				raise( "Malformed url for pn type request" )
+			end
+
+		end
+
+		
+		# Handles direct action requests
+		def handle_direct_action_request ( request,url_content )
+			
+			class_name, method_name = url_content.split( /\/+/,2 )
+			if ( method_name )
+				klass = SWS.get_class( class_name + "Action" )
+			else
+				klass = @default_direct_action_class
+				method_name = class_name
+			end
+			unless ( klass && klass.ancestors.include?( DirectAction ) )
+				raise TypeError.new( "Direct action class name for url #{url_content} does not inherit from SWS::DirectAction" )
+			end
+			
+			direct_action = klass.new( request )
+						
+			new_component, response = direct_action.action_for_name( method_name )
+
+			return [new_component, response]
+			
+		end
+
+
+		# Handles resource requests
+		def handle_resource_request ( request,url_content )
+			
+			response = Response.new( request )
+
+			framework_name,resource_name = url_content.split( /\/+/,2 )
+			if ( framework_name == 'app' )
+				resource = @config[CONFIG_RESOURCES][resource_name]
+			else
+				framework = @frameworks[framework_name]
+				resource = framework.resources[resource_name]
+			end
+			
+			unless ( resource )
+				raise( "Cannot find resource #{resource_name} in framework #{framework}" )
+			end
+			
+			response.headers["Content-type"] = resource["mime-type"]
+			if ( framework )
+				path = File.join( framework.path, resource["filename"] )
+			else
+				path = resource["filename"]
+			end
+			unless( File.exists?( path ) )
+				raise( "File #{path} does not exist" )
+			end
+
+			file = File.open( path )
+			response << file.read
+			file.close()
+
+			return nil,response
+			
+		end
+
+
+		# Returns ComponentFiles struct for given component name. Usually called
+		# only once per component class, so it is a good place to require its ruby
+		# file.
+		def get_component( component_name )
+
+			# Find component path
+			path = @config[CONFIG_COMPONENTS][component_name]
+
+			unless ( path )
+				framework = @frameworks.values.find { |framework|	framework.components[component_name] }
+				if ( framework )
+					path = File.join( framework.path,framework.components[component_name] )
+				else
+					raise( "Component #{component_name} was not found in application or	frameworks" )
+				end
+			end		
+
+			# Retrieve component files. For components in nested namespaces only the
+			# last element of the name is used.
+			file = File.join( path, component_name.split( /::/ ).last )
+
+			if ( FileTest.file?( file+".rb" ) ) then ruby_file = file+".rb" end
+			if ( FileTest.file?( file+".sws" ) ) then sws_file = file+".sws" end
+			if ( FileTest.file?( file+".html" ) ) then html_file = file+".html" end
+			if ( FileTest.file?( file+".api" ) ) then api_file = file+".api" end
+
+			if ( ruby_file )
+				require( ruby_file )
+				klass = SWS.get_class( component_name )
+				return ComponentInfo.new( klass, sws_file, html_file, api_file )
+			end
+					
+			raise "Cannot find component files for component #{component_name}"
+			
+		end
+		
+	end
+
+end