nitro 0.3.0 → 0.4.1

data/lib/n/server/webrick.rb

@@ -1,283 +0,0 @@
-# code:
-# * George Moschovitis  <gm@navel.gr>
-# * Elias Athanasopoulos  <elathan@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: webrick.rb 118 2004-11-01 10:13:42Z gmosx $
-
-require "drb"
-require "cgi"
-require "singleton"
-require "webrick"
-
-require "n/logger"
-require "n/application"
-require "n/utils/cache"
-require "n/server/request"
-require "n/server/request"
-require "n/server/handlers"
-require "n/server/session"
-require "n/server/appserver"
-
-# 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
-
-	# Expose some response variables.
-	#
-  class HTTPResponse
-		attr_writer :header
-		attr_writer :cookies
-	end
-end
-
-module N
-
-# = Webrick AppServer
-#
-# The Application Server. Handles dynamic requests in a web application.
-# Dont keepalive (or use a VERY SMALL keepalive). Typically this server
-# is used along with a standard http server that handles other resources.
-#
-# Used temporarily unitl we build our own app server.
-#
-class Webrick < N::AppServer
-	include WEBrick
-
-	# the integrated webrock server.
-	attr_accessor :webrick
-	
-	def initialize(name = "WebrickServer")
-		super
-	end
-
-	# Start the application server.
-	#
-	def start
-		accesslog = WEBrick::BasicLog::new("/dev/null") 
-		referer = WEBrick::BasicLog::new("/dev/null")	
-		
-		@webrick = HTTPServer.new(
-			:BindAddress => $appsrv_address, 
-			:Port => $appsrv_port, 
-			:DocumentRoot => $root_dir,
-			# gmosx, FIXME: this shit still logs!!
-			:Logger => Log.new(nil, WEBrick::Log::WARN),
-			# elathan: amateur...
-			:AccessLog => [
-          [accesslog, AccessLog::COMMON_LOG_FORMAT],
-          [referer, AccessLog::REFERER_LOG_FORMAT]
-        ]
-		)
-		
-		@webrick.mount("/", N::WebrickServlet)
-		
-		trap("INT") {
-		 @webrick.shutdown() 
-		}
-		
-		@webrick.start()
-	end
-	
-	# Stop the application server.
-	#
-	def stop
-		@webrick.stop
-	end
-	
-end
-
-# = WebrickServlet
-#
-# A webrick servlet that implements the Nitro Engine.
-# 
-# TODO: Lots of stuff should be factored out!
-#
-class WebrickServlet < WEBrick::HTTPServlet::AbstractServlet
-	include WEBrick
-
-	# Handle a HTTP GET request.
-	# 
-	def do_GET(wreq, wres)
-		request = create_request(wreq)
-		request.session = create_session(request)
-
-		extension = N::StringUtils.extension_from_path(request.path)
-		if handler = $srv_extension_map[extension]
-			handler = handler[1]
-		else
-			$log.error "Cannot handle '#{request.path}'"
-			return nil
-		end
-
-		begin
-			$og.get_connection if $og
-			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
-		ensure
-			$og.put_connection if $og
-		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
-
-	alias :do_POST :do_GET
-
-#-------------------------------------------------------------------------------
-
-	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::Request.new
-
-		request.uri = wreq.unparsed_uri
-		request.translated_uri = wreq.path_info
-		request.path = wreq.path
-		# enforce filename if missing, FIXME: improve this.
-		request.path << $index_filename if request.path[-1] == ?/ 
-#		request.path_info = wreq.path_info
-		request.query_string = wreq.query_string
-		request.method = wreq.request_method
-		# gmosx: X-FORWARDED-FOR is used in a proxy configuration.
-		request.remote_addr = wreq["X-FORWARDED-FOR"] || wreq["REMOTE_ADDR"]
-
-		# 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::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::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::Session.calculate_id()
-			cookie = N::Cookie.new(N::Session::COOKIE_NAME, session_id)
-			request.out_cookies[N::Session::COOKIE_NAME] = cookie
-		end
-
-		# session not found and must be created
-		unless session
-			session = N::Session.new(session_id)
-		end
-		
-		return session
-	end
-end
-
-end # module

data/lib/n/shaders.rb

@@ -1,166 +0,0 @@
-# code:
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: shaders.rb 109 2004-10-27 09:12:45Z gmosx $
-
-module N;
-
-# = Shader
-#
-# The equivalent of a 3d engine shader. Converts the page representation 
-# to the html output. Actually converts it to a dynamic page ready for
-# evaluation.
-#
-# === Design:
-#
-# We follow the xp methodology: the shader as simple as possible.
-# In the future we may add mulitple xsls (xsl pipeline) but
-# we done need them now, so we wont code them!
-#
-# - when compiling get the default shader and keep it in the
-#   script structure.
-#
-#   noo better push them in a request stack!
-#
-# - when rendering:
-#	if there is an override shader use it! (example: inject shader)
-#	if there is a parent shader use it!
-#	if there is a script shader use it!
-#	if there is a user shader use it!
-#	if there is an app shader use it!
-#	no shading!
-#
-# === Think:
-#
-# - are inject override shaders possible ? (no they are
-#   dynamic)
-#
-# === TODO:
-#
-# - add monitoring support for xsl's.
-#
-# One shader can utilize several xsls to render different pages.
-# the shader selection may be time consuming but is performed once
-# when transforming the script, so its essentially for free (and
-# anyway the xsl transoformation is orders of magnitude slower)
-#
-# There is no need to keep post xsl. I can reuse the same xsl 
-# by calling transform again. 
-#
-class Shader
-	attr_accessor :name
-	attr_accessor :xsl_filename
-	# the xslt transoformer.
-	attr_accessor :xslt
-	attr_accessor :mtime
-	
-	def initialize(name, xsl_filename)
-		# leave this require here. only inlcude the xslt 
-		# library if the project needs it.
-		require "xml/xslt"
-
-		@name = name
-		@xsl_filename = xsl_filename
-		@xslt = XML::XSLT.new
-		parse_xsl!
-	end
-	
-	# transform the given document
-	#
-	def xsl_transform(document)
-		@xslt.xml = document
-		return @xslt.serve()
-	end
-	alias_method :transform, :xsl_transform
-	
-	def xsl
-		parse_xsl! if $reload_xsl
-		return @xsl
-	end
-	
-	def to_s
-		@name
-	end
-	
-private 
-	
-	# Parse the xsl.
-	#
-	def parse_xsl!
-		$log.debug "Parsing xsl '#{@xsl_filename}'" if $DBG
-		@mtime = File.stat(@xsl_filename).mtime
-		@xslt.xsl = File.read(@xsl_filename)
-	end
-
-end
-
-# = NilShader
-#
-# A shader that does absolutely nothing. Typically
-# used when you want to avoid XSLT in simple 
-# applications.
-#
-class NilShader < Shader
-	def initialize
-		# gmosx: to get better display.
-		@name = nil
-		@mtime = Time.at(0)
-	end
-
-	# No transform, just convert to a String.	
-	def transform(document)
-		return document.to_s
-	end
-end
-
-# = ShaderManager
-#
-# Manages the shaders for the webapp.
-#
-# TODO: integrate with sitemap.
-#
-# === Design:
-#
-# - the shader selection may be time consuming but is performed once
-#   when transforming the script, so its essentially for free (and
-# 	anyway the xsl transoformation is orders of magnitude slower)
-#
-class ShaderManager
-	# corresponding arrays
-	attr_accessor :regex, :shaders 
-	attr_accessor :default_shader
-
-	def initialize
-		@regex = []
-		@shaders = []
-	end
-
-	def set_default(shader)
-		@default_shader = shader
-	end
-
-	def add(regex, shader)
-		@regex << regex
-		@shaders << shader
-	end
-
-	def shader_for_path(path)
-		@regex.each_with_index { |rx, idx|
-			if path =~ rx
-				return @shaders[idx]
-			end
-		}
-		return @default_shader
-	end
-
-	def delete(regex)
-		if idx = @regex.index(regex)
-			@regex.delete_at(idx)
-			@shaders.delete_at(idx)
-		end
-	end
-
-end
-
-end # module;

data/lib/n/sync/clc.rb

@@ -1,110 +0,0 @@
-#!/usr/local/bin/ruby -w
-
-# = A Command Line Client (clc) for the Sync Server
-#
-# code: 
-#	* Anastasios Koutoumanos  <ak@navel.gr>
-# * George Moschovitis  <gm@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: clc.rb 101 2004-10-22 12:35:39Z gmosx $
-
-require "logger"
-require "socket"
-require "thread"
-require "timeout"
-require "getoptlong"
-
-@opts = GetoptLong.new(
-  [ "--server", "-s", GetoptLong::REQUIRED_ARGUMENT ],
-  [ "--port", "-p",  GetoptLong::REQUIRED_ARGUMENT ],
-  [ "--file", "-f", "-l", GetoptLong::REQUIRED_ARGUMENT ]
-)
-
-def prompt
-	printf(Time.now.strftime("%H:%M:%S> "))
-end
-
-def connect(srv, port)
-	begin
-		@socket = TCPSocket.new(srv, port)
-	rescue
-		$log.error "Cannot connect to server, is it online?"
-		exit(0)
-	end
-	$log.info "Connected to #{@socket.addr[3]}:#{@socket.addr[1]}"
-end
-
-def send(str)
-	$log.info "write: #{str}"
-	@socket.send("#{str}\000", 0)
-end
-
-def read()
-	begin
-		loop do
-			timeout(0.7) do
-				while @socket.readline("\000")
-					$log.info "read: #{$_}"
-				end
-			end
-		end
-	rescue TimeoutError
-		#drink it
-	end
-end
-
-def write(cmd)
-	if cmd = cmd.strip() and not cmd.empty?
-		send(cmd)
-	 else
-		 $log.error "Syntax error"
-	 end
-end
-
-if __FILE__ == $0
-
-	$log = Logger.new(STDERR)
-
-	@opts.each { |opt, arg|
-		case opt
-			when "--file"
-				@file = File.new(arg)
-			when "--server"
-				@server = arg
-			when "--port"
-				port = port.to_i
-		end
-	}
-
-	@server ||= "localhost"
-	@port ||= 2121
-	
-	connect(@server, @port)
-	
-	reader = Thread.new {
-		loop do
-			read()
-		end
-	}
-
-	writer = Thread.new {
-		# replay input file
-		if @file
-			@file.each_line { |cmd|
-				write(cmd)				
-			}
-		end
-
-		# normal rep loop
-		loop do
-			prompt()
-			cmd = gets()
-			write(cmd)
-		end
-	}
-
-	reader.join()
-	writer.join()
-	
-end