sws 0.4

data/lib/sws/request.rb

@@ -0,0 +1,308 @@
+#!/usr/bin/env ruby
+
+module SWS
+	
+
+	# Struct containing data of a file passed as form-data
+	FileData = Struct.new( 
+		:content_disposition, 
+		:filename, 
+		:content_type, 
+		:charset, 
+		:content_transfer_encoding,
+		:contents
+	)
+	
+	# Class representing HTTP request	
+	class Request
+	
+		# Method of the request (POST,GET)
+		attr_reader :request_method
+		
+		# Path the request was made to
+		attr_reader	:path
+		
+		# Version of the HTTP protocol
+		attr_reader :http_version
+
+		# Query string (as in CGI). May be used freely, as SWS does not use it
+		# internally.
+		attr_reader :query_string
+		
+		# Hash: key - header name, value - header value
+		attr_reader :headers 
+
+		# Form parameters passed to the request (Hash)
+		attr_reader :params
+		
+		# Cookies passed to the request (Hash)
+		attr_reader :cookies
+
+		# User agent string
+		attr_reader :user_agent
+
+		# Name of the server host
+		attr_reader :host
+
+		# IP of the remote host
+		attr_reader :remote_address
+
+		# Content of the request
+		attr_accessor :content
+
+		# Session object connected with this request
+		attr_writer :session
+		
+
+		# Creates new Request object
+		def initialize ( request_method, path, query_string, http_version)
+			
+			@request_method = request_method
+			@path = path
+			@http_version = http_version
+			@query_string = query_string
+			@headers = Hash.new
+			@params = Hash.new
+			@cookies = Hash.new
+			@content = nil
+			@session = nil
+			
+		end
+	
+		
+		# Request true if content is not empty
+		def has_content? ()
+			return @content != nil
+		end
+	
+
+		# Returns string representation of the receiver
+		def to_s ()
+			
+			params = "" 
+			@params.each { |key,value| params << "Key: #{key}, value: #{value}\n" }
+			return "Method: #{request_method}, path: #{path}, params:\n #{params}"
+			
+		end
+		
+	
+		# Retrieves session from cookie (or only returns it if already retrieved)
+		def session () 			
+			#TODO: allow session to be stored in url
+	
+			if ( @session == nil ) 
+				session_id = @cookies["session"]
+				@session = Session.sessions[session_id]
+			end
+			return @session		 
+			
+		end
+		
+	
+		# Erases receiver's content - useful when new session is created on not refreshed HTML
+		def erase_content ()
+			#TODO: erase cookies and headers too?
+			@content = nil
+			@params = Hash.new()
+			
+		end
+		
+	
+		# Parses headers hash and generates a bunch of more useful parameters and
+		# cookies
+		def process_headers ()
+			
+			if ( @headers[ "cookie" ] )
+				@headers["cookie"].split( /;\s+/ ).each do |cookie_pair|
+					name, value = cookie_pair.split( /=/ )
+					@cookies[name] = value.url_decode
+				end
+			end
+			
+			@user_agent = @headers["user-agent"]
+			@host = @headers["host"]
+			@remote_address = @headers["remote-address"]
+			
+			#TODO: maybe add the rest of headers?
+			
+		end
+	
+		
+		# Parses request content and extracts form parameters
+		def process_content () 
+		
+			
+			$log_sws_request.debug( "Content: #{@content}" )
+			content_type = @headers["content-type"]
+			
+			if ( content_type =~ /application\/x-www-form-urlencoded/i )
+				
+				process_url_encoded_content()
+				
+			elsif ( content_type =~ /multipart\/form-data/i )
+			
+				process_multipart_form_data_content( content_type )
+
+			else 
+
+				raise( "Unsupported content type #{content_type}" )
+				
+			end
+			
+		end
+
+
+		protected
+
+		def process_url_encoded_content ()
+			
+			$log_sws_request.debug( "Content type: x-www-form-urlencoded" )
+			@content.split( '&' ).each do |param|
+				key,value = param.split( '=' )
+				unless ( value == nil )	#can be nil eg. in empty textfield
+					value.gsub!( /\+/," " ) 
+					value.url_decode!()
+				end			
+				$log_sws_request.debug( "Param: #{key}, value: #{value}" )
+				add_param( key,value )
+			end
+
+		end
+
+
+		def process_multipart_form_data_content ( content_type )
+
+			$log_sws_request.debug( "Content type: multipart/form-data" )
+			boundary = content_type.sub( /^.*boundary=/,"" )
+
+			$log_sws_request.debug( "Boundary: #{boundary}" )
+
+			# For some unknown reason (RFC, presumably :)  all browsers add '--'
+			# before the boundary and at the end of content
+			params = @content.split( /--#{boundary}-{0,2}\r\n/m )
+			params.delete_if { |param| param == "" }
+			#TODO: why the statement below was used? It breaks file uploads
+			#|| param =~ /^--/m }
+			params.each do |param|
+
+				$log_sws_request.debug( "Param: #{param}" )
+				headers,value = param.split( /\r\n\r\n/,2 )
+				
+				$log_sws_request.debug( "headers: #{headers}" )
+				if ( headers =~ /^content-disposition: form-data; name="([^"]+)"$/i )
+					
+					key = $1
+					$log_sws_request.debug( "Single value, #{key}: #{value}" )
+					#	should work properly with form-data content
+					# currently other types are unsupported
+					
+					# TODO: refactoring for proper coding/decoding 
+					#	value.gsub!( /\+/," " ) 
+					#	value.url_decode!()
+					
+					# Don't know why, but in some strings - like
+					# "nazwy_projekt�w_do_um�w\r\n" - using /\r\n/ in regexp doesn't strip
+					# these chars properly
+					value.sub!( /(\x0D\x0A)+$/, "" )
+  				add_param( key, value )
+
+				else
+					
+					$log_sws_request.debug( "File value" )
+					file_data = FileData.new
+					file_data.contents = value
+					headers.each_line do |header|
+						header.sub!( /\r\n$/,"" )
+						case header
+						when /^content-disposition/i
+							parse_multipart_form_data_content_disposition( file_data,header )
+						when /^content-type/i
+							parse_multipart_form_data_content_type( file_data,header )
+						when /^content-transfer-encoding/i
+							parse_multipart_form_data_content_transfer_encoding( file_data,header )
+						else
+							raise( "Unknown multipart/form-data header: --#{header}--" )
+						end
+					end
+
+				end
+
+			end
+
+		end
+
+
+		def process_multipart_mixed_content ( content_type )
+
+			raise( "Multipart/mixed content-type is not yet supported" )
+
+		end
+
+
+		def parse_multipart_form_data_content_disposition ( file_data, header )
+			
+			#TODO: avoid exception on malformed header
+			file_data.content_disposition, params = 
+				/^content-disposition: (.*?);\s*(.*)$/i.match( header ).captures
+			params.split( /;\s*/ ).each do |param|
+				key, value = /^(\w+)="?(.*?)"?$/.match( param ).captures
+				case key
+				when "name" then @params[value] = file_data
+				when "filename" then file_data.filename = value
+				else
+					raise( "Unknown content-disposition param in multipart/form-data: #{key}" )
+				end
+			end
+			
+		end
+
+
+		def parse_multipart_form_data_content_type ( file_data, header )
+
+			md = /^content-type: (.*?);\s*(.*)$/i.match( header )
+			if ( md )				
+				file_data.content_type,params = md.captures
+				params.split( /;\s*/ ).each do |param|
+					$log_sws_request.debug( "Param: #{param}" )
+					key,value = /^(\w+)="?(.*?)"?$/.match( param ).captures
+					case key
+					when "charset" then file_data.charset = value
+					else
+						raise( "Unknown param of content-type in multipart/form-data: #{key}" )
+					end
+				end
+			else
+				file_data.content_type = /^content-type: (.*)$/i.match( header ).captures[0]
+			end
+			
+		end
+
+
+		def parse_multipart_form_data_content_transfer_encoding ( file_data, header )
+			
+			file_data.content_transfer_encoding = 
+				/^,*:\s*(.*)$/.match( header ).captures[0]
+				
+		end
+
+
+		def add_param( key, value )
+
+			if ( @params[key] ) #that means this param has multiple values
+				if ( @params[key].instance_of?( Array ) ) 
+					#param already has multiple values assigned,
+					#so just add next value to the array
+					@params[key] << value
+				else #value in params has must be converted to an Array
+					values = [@params[key],value]
+					@params[key] = values
+				end
+			else
+				@params[key] = value
+			end
+
+		end
+
+	end
+
+end		

data/lib/sws/response.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+module SWS
+
+	
+	# Represents HTML reponse generated by SWS
+	class Response
+
+
+		# Hash of HTTP headers
+		attr_reader :headers
+
+		# Array of Cookie objects
+		attr_reader :cookies
+
+		# The version of HTTP protocol
+		attr_accessor :http_version
+
+		# Status of the response
+		attr_accessor :status
+	
+		# The Request the receiver is associated with
+		attr_reader :request
+
+		attr_reader :content
+		
+
+		# Creates new empty Response object
+		def initialize ( request,status = "200 SWS/OK" ) 
+			
+			@content = ""
+			@headers = Hash.new
+			@cookies = Array.new
+			@http_version = "HTTP/1.1"
+			@status = status
+			@request = request
+			
+		end
+
+		def Response.redirect( request, url )
+
+			response = Response.new( request, "302 Found" )
+			response.headers["Location"] = url
+			return response
+
+		end
+
+		# Appends a string to the receiver
+		def << ( string )
+			@content << string
+		end
+
+
+		# Returns string representation of the receiver
+		def to_s ()
+			
+			data = ""
+			@headers.each_pair { |key, value|	data << "#{key}: #{value}\r\n" }
+			@cookies.each { |cookie| data << "#{cookie}\r\n" }
+			# End headers
+			data << "\r\n"
+			data << @content
+			return data
+			
+		end
+
+	end
+
+end
+		

data/lib/sws/session.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/ruby
+
+require "digest/md5"
+
+module SWS
+
+	
+	# This is a class representing user sessions.  Sessions are based on id,
+	# which is passed in cookie
+	class Session
+		
+		# Hash for created sessions: key - id, value - Session object (can be subclasses of Session!)
+		@@sessions = Hash.new
+	
+		# Session id
+		attr_reader :sid
+	
+		# Time when the session was last active
+		attr_accessor :last_access_time
+
+		private	
+
+		# Creates new Session object and registers it
+		def initialize ()
+			
+			generate_sid()
+			#register session
+			@@sessions[@sid] = self
+
+		# Last top-level components created
+			@component_cache = ComponentCache.new()
+			
+		end
+	
+		
+		# Generates session id 
+		def generate_sid ()
+	
+			md5digest = Digest::MD5.new()
+			md5digest.update(Time.now.to_f.to_s + rand.to_s + $$.to_s)
+			@sid = (md5digest.hexdigest)
+			
+		end 
+	
+		
+		public
+
+		# Returns sessions Hash containing all registered sessions
+		def Session.sessions ()
+			return @@sessions
+		end
+
+		
+		# Deletes session from registered ones
+		def Session.delete_session ( session )
+			@@sessions.delete( session.sid )
+		end
+	
+		
+		# Returns session id represented as cookie in order to append it to
+		# response.
+		# TODO: deal with "path" (set it to base app path) 
+		def to_cookie ()
+			return Cookie.new( "session",@sid )
+		end
+	
+
+		# Returns string representation of the receiver
+		def to_s ()
+			return "#{self.class}, sid: #{@sid}"
+		end
+	
+		def add_to_cache ( component )
+			@component_cache.add_component( component )
+		end
+
+		def get_from_cache ( component_id )
+			return @component_cache.component( component_id )
+		end
+
+		def old? ( component_id )
+			return @component_cache.old?( component_id )
+		end
+
+	end
+	
+
+
+	class SessionCleaner < Thread
+		
+		# By default cleaning will be performed every 10 minutes and each session
+		# inactive for 6 hours will be deleted
+		def initialize ( sessions, mutex, session_timeout = 21600, cleanup_interval = 600 )
+
+			super do |sessions, mutex, session_timeout, cleanup_interval|
+				loop do
+					mutex.synchronize {			
+						sessions.delete_if() {
+							|key, value| ( Time.now - value.last_access_time ) > session_timeout
+						}
+					}
+
+					sleep cleanup_interval
+				end
+			end
+
+		end
+		
+	end
+
+
+
+	# TODO: not sure if it works entirely correctly, but for now it works good
+	# enough
+	class ComponentCache
+
+		def ComponentCache.max_components_per_session= ( max )
+			@@max_components_per_session = max
+		end
+
+
+		def initialize	
+			@components = Array.new
+			# Object_ids of components removed from cache. Useful when handling
+			# backtracking.
+			@old_component_ids = Array.new
+		end
+
+
+		# Adds a component to cache.
+		# Returns false if component was nil.
+		# Size of component cache can be customized in application.yaml
+		def add_component ( component )
+
+			unless @components.include?( component )
+				@components << component
+				if @components.length > @@max_components_per_session
+					# As checking for only one copy of a component is already done when
+					# inserting into @components, we don't need to do this here. We only
+					# store object_ids to limit memory footprint.
+					@old_component_ids << @components.shift.object_id
+				end
+			end
+
+		end
+
+
+		def component ( component_id )
+
+			if( component_id == @components.last.object_id )
+				return @components.last
+			else
+				component = @components.find { |c| c.object_id == component_id }
+		 	end		
+			
+			unless component
+				return nil
+			else
+				# Old behaviour (for optimalization)
+				# Remove all components that are after found component - they are in the
+				# "branch" the client shouldn't have access to. Of course they are added
+				# to @old_component_ids for the case user backtracks to them.
+				# 
+				# Accidentally, this works correctly even if component ==
+				# @components.last (that means there was no backtracking) - that is, it
+				# doesn't remove anything.
+				#
+				#@old_component_ids.concat( 
+				#	@components.slice!( @components.index( component ) + 1 .. -1 ).collect { |com| com.object_id }
+				#)
+				
+#				@components.push( @components.delete( component ) )
+#				puts @components.each { |c| print "-- ", c.object_id, "\n" }
+#				puts component_id
+				return component
+			end
+				
+		end
+
+
+		def old? ( component_id )
+			return @old_component_ids.include?( component_id )
+		end
+		
+		# This method returns last component in array - this is used
+		# when we need direct access to some common component atributes
+		# (i.e. request.headers)
+		# TODO: maybe it is unnecessary (i mean: there is better way to do this)
+		def last
+			return @components.last
+		end
+
+	end
+
+end