nitro 0.8.0 → 0.9.3

data/lib/glue/string.rb

@@ -4,7 +4,7 @@
 # * Elias Karakoulakis  <ekarak@ktismata.com>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: string.rb 165 2004-11-18 12:04:04Z gmosx $
+# $Id: string.rb 202 2005-01-17 10:44:13Z gmosx $
 
 require "uri"
 

data/lib/glue/time.rb

@@ -2,7 +2,7 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: time.rb 167 2004-11-23 14:03:10Z gmosx $
+# $Id: time.rb 202 2005-01-17 10:44:13Z gmosx $
 
 require "time.rb"
 

data/lib/glue/validation.rb

@@ -216,7 +216,7 @@ module Validation
 
 			for name in params
 				confirm_name = "#{name}#{c[:postfix]}"
-				attr_accessor :"#{confirm_name}"
+				eval "attr_accessor :#{confirm_name}"
 
 				code = %{
 					if obj.#{confirm_name}.nil? or (obj.#{confirm_name} != obj.#{name})

data/lib/nitro.rb

@@ -5,13 +5,25 @@
 # robust infrastructure for scalable web applications that can be 
 # distributed over a server cluster. However, Nitro can also power 
 # simple web applications for deployment on intranets or even personal 
-# computers. Nitro integrates the powerful Og Object-Relational mapping 
-# library.
+# computers. 
 #
-# code: 
-# * George Moschovitis  <gm@navel.gr>
+# Nitro integrates the powerful Og Object-Relational mapping 
+# library.
 #
-# (c) 2004 Navel, all rights reserved.
-# $Id: nitro.rb 167 2004-11-23 14:03:10Z gmosx $
+#--
+# George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: nitro.rb 215 2005-01-24 10:44:05Z gmosx $
+#++
 
 require 'glue'
+require 'glue/logger'
+
+require 'nitro/context'
+require 'nitro/dispatcher'
+require 'nitro/render'
+
+# Define Nitro namespace.
+
+module Nitro
+end

data/lib/nitro/adaptors/cgi.rb

@@ -0,0 +1,291 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2005 Navel, all rights reserved.
+# $Id$
+
+require 'cgi'
+
+module N
+
+=begin
+# Extend the Request module.
+
+module Request
+	include CGI::QueryExtension
+	
+	def stdinput
+		@in	
+	end
+end
+=end
+
+# CGI utility methods.
+
+class CgiUtils
+	
+	# HTTP protocol EOL constants
+
+	CR = "\x0d"
+	LF = "\x0a"
+	CRLF = "\x0d\x0a"
+	EOL = CRLF
+
+	# Constants for readable code
+
+	STATUS_OK = 200
+	STATUS_PARTIAL_CONTENT = 206
+	STATUS_MOVED = 301
+	STATUS_REDIRECT = 302
+	STATUS_SEE_OTHER = 303				# gmosx: VERIFY THIS
+	STATUS_SEE_OTHER_307 = 307		# gmosx: VERIFY THIS
+	STATUS_NOT_MODIFIED = 304
+	STATUS_BAD_REQUEST = 400
+	STATUS_AUTH_REQUIRED = 401       
+	STATUS_FORBIDDEN = 403           
+	STATUS_NOT_FOUND = 404           
+	STATUS_METHOD_NOT_ALLOWED = 405  
+	STATUS_NOT_ACCEPTABLE = 406      
+	STATUS_LENGTH_REQUIRED = 411     
+	STATUS_PRECONDITION_FAILED = 412 
+	STATUS_SERVER_ERROR = 500        
+	STATUS_NOT_IMPLEMENTED = 501    
+	STATUS_BAD_GATEWAY = 502         
+	STATUS_VARIANT_ALSO_VARIES = 506 
+
+	# Hash to allow id to description maping.
+
+	STATUS_STRINGS = {
+		200 => "OK",
+		206 => "Partial Content",
+		300 => "Multiple Choices",
+		301 => "Moved Permanently",
+		302 => "Found",
+		303 => "See other", # gmosx: VERIFY THIS
+		304 => "Not Modified",
+		307 => "See other 07", # gmosx: VERIFY THIS
+		400 => "Bad Request",
+		401 => "Authorization Required",
+		403 => "Forbidden",
+		404 => "Not Found",
+		405 => "Method Not Allowed",
+		406 => "Not Acceptable",
+		411 => "Length Required",
+		412 => "Precondition Failed",
+		500 => "Internal Server Error",
+		501 => "Method Not Implemented",
+		502 => "Bad Gateway",
+		506 => "Variant Also Negotiates"
+	}
+
+	# Returns a hash with the pairs from the query 
+	# string. The implicit hash construction that is done 
+	# in parse_request_params is not done here.
+	#
+	# Parameters in the form xxx[] are converted
+	# to arrays.
+
+	def self.parse_query_string(query_string)
+		# gmosx, THINK: better return nil here?
+
+		return {} if (query_string.nil? or query_string.empty?)
+
+		params = {}
+
+		query_string.split(/[&;]/).each do |p| 
+			key, val = p.split('=')
+			
+			key = CGI.unescape(key) unless key.nil?
+			val = CGI.unescape(val) unless val.nil?
+
+			if key =~ /(.*)\[\]$/
+				if params.has_key?($1)
+					params[$1] << val
+				else
+					params[$1] = [val]
+				end
+			else
+				params[key] = val.nil? ? nil : val
+			end
+		end
+		
+		return params
+	end
+
+	# Parse the HTTP_COOKIE header and returns the
+	# cookies as a key->value hash. For efficiency no 
+	# cookie objects are created.
+	#
+	# [+context+]
+	#		The context 
+
+	def self.parse_cookies(context) 
+		env = context.env
+
+		# FIXME: dont precreate?
+		context.cookies = {}
+
+		if env.has_key?('HTTP_COOKIE') or env.has_key?('COOKIE')    
+			(env['HTTP_COOKIE'] or env['COOKIE']).split(/; /).each do |c|
+				key, val = c.split(/=/, 2)
+				
+				key = CGI.unescape(key)
+				val = val.split(/&/).collect{|v| CGI::unescape(v)}.join("\0")
+
+				if context.cookies.include?(key)
+					context.cookies[key] += "\0" + val
+				else
+					context.cookies[key] = val
+				end
+			end
+		end
+	end
+
+	# Build the response headers for the context. 
+																																											
+	def self.response_headers(context)
+		reason = STATUS_STRINGS[context.status] 
+		buf = "HTTP/1.1 #{context.status} #{reason} #{EOL}"
+		
+		context.response_headers.each do |key, value|
+			tmp = key.gsub(/\bwww|^te$|\b\w/) { |s| s.upcase }
+			buf << "#{tmp}: #{value}" << EOL
+		end
+	
+		context.response_cookies.each do |cookie|
+			buf << "Set-Cookie: " << cookie.to_s << EOL
+		end if context.response_cookies
+			
+		buf << EOL
+	end
+	
+	# Initialize the request params.
+	# Handles multipart forms (in particular, forms that involve 
+	# file uploads). Reads query parameters in the @params field, 
+	# and cookies into @cookies.
+	
+	def self.parse_params(context)
+		method = context.method
+		if (:post == method) and
+				%r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(context.headers['CONTENT_TYPE'])
+			boundary = $1.dup
+			context.params = read_multipart(boundary, Integer(context.headers['CONTENT_LENGTH']))
+		else 
+			case method
+			when :get, :head
+				context.params = CgiUtils.parse_query_string(context.query_string)	
+			when :post
+				context.in.binmode if defined?(context.in.binmode)
+										
+				context.params = CgiUtils.parse_query_string(
+						context.in.read(
+						Integer(context.headers['CONTENT_LENGTH'])) || '')	
+			end
+		end
+	end
+
+	# Parse a multipart request.
+	
+	def self.read_multipart(boundary, content_length)
+		params = Hash.new([])
+		boundary = "--" + boundary
+		buf = ""
+		bufsize = 10 * 1024
+
+		# start multipart/form-data
+		stdinput.binmode if defined? stdinput.binmode
+		boundary_size = boundary.size + EOL.size
+		content_length -= boundary_size
+		status = stdinput.read(boundary_size)
+		if nil == status
+			raise EOFError, "no content body"
+		elsif boundary + EOL != status
+			raise EOFError, "bad content body"
+		end
+
+		loop do
+			head = nil
+			if 10240 < content_length
+				require "tempfile"
+				body = Tempfile.new("CGI")
+			else
+				begin
+					require "stringio"
+					body = StringIO.new
+				rescue LoadError
+					require "tempfile"
+					body = Tempfile.new("CGI")
+				end
+			end
+			body.binmode if defined? body.binmode
+
+			until head and /#{boundary}(?:#{EOL}|--)/n.match(buf)
+
+				if (not head) and /#{EOL}#{EOL}/n.match(buf)
+					buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
+						head = $1.dup
+						""
+					end
+					next
+				end
+
+				if head and ( (EOL + boundary + EOL).size < buf.size )
+					body.print buf[0 ... (buf.size - (EOL + boundary + EOL).size)]
+					buf[0 ... (buf.size - (EOL + boundary + EOL).size)] = ""
+				end
+
+				c = if bufsize < content_length
+							stdinput.read(bufsize)
+						else
+							stdinput.read(content_length)
+						end
+				if c.nil?
+					raise EOFError, "bad content body"
+				end
+				buf.concat(c)
+				content_length -= c.size
+			end
+
+			buf = buf.sub(/\A((?:.|\n)*?)(?:[\r\n]{1,2})?#{boundary}([\r\n]{1,2}|--)/n) do
+				body.print $1
+				if "--" == $2
+					content_length = -1
+				end
+				""
+			end
+
+			body.rewind
+
+			/Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
+filename = ($1 or "")
+if /Mac/ni.match(env_table['HTTP_USER_AGENT']) and
+		/Mozilla/ni.match(env_table['HTTP_USER_AGENT']) and
+		(not /MSIE/ni.match(env_table['HTTP_USER_AGENT']))
+	filename = CGI::unescape(filename)
+end
+			
+			/Content-Type: (.*)/ni.match(head)
+			content_type = ($1 or "")
+
+			(class << body; self; end).class_eval do
+				alias local_path path
+				define_method(:original_filename) {filename.dup.taint}
+				define_method(:content_type) {content_type.dup.taint}
+			end
+
+			/Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
+			name = $1.dup
+
+			if params.has_key?(name)
+				params[name].push(body)
+			else
+				params[name] = [body]
+			end
+			break if buf.size == 0
+			break if content_length === -1
+		end
+
+		params
+	end
+
+end
+
+end

data/lib/nitro/adaptors/fastcgi.rb

@@ -0,0 +1,42 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2005 Navel, all rights reserved.
+# $Id$
+
+require 'cgi'
+require 'fcgi'
+
+require 'nitro/context'
+require 'nitro/dispatcher'
+require 'nitro/adaptors/cgi'
+
+module N
+
+# FastCGI Adaptor. FastCGI is a language independent, 
+# scalable, open extension to CGI that provides high 
+# performance without the limitations of server 
+# specific APIs.
+
+class FastCGI
+
+	def self.start(conf)
+		FCGI.each do |cgi|
+			context = Context.new(conf)
+
+			context.in = cgi.in
+			context.headers = cgi.env
+
+			CgiUtils.parse_params(context)
+			CgiUtils.parse_cookies(context)
+			
+			context.render(context.path)
+
+			cgi.out.print(CgiUtils.response_headers(context))
+			cgi.out.print(context.out)
+
+			cgi.finish
+		end
+	end
+
+end
+
+end

data/lib/nitro/adaptors/runner.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id$
+
+require 'optparse'
+
+module N
+
+# The Runner is a helper class that encapsulates a web 
+# application and is responsible for launching the 
+# application using different adaptors. Default arguments
+# parsing is also provided.
+#
+# You can implement your own, custom version of the Runner
+# to run your custom web applications.
+#
+#--
+# TODO: find a better name
+#++
+
+class Runner
+
+	# Parse the arguments and run the web application
+	# using the declared environment and adaptor
+	
+	def self.run(argv)
+
+		# :start, :stop, :restart.
+
+		action = :start
+
+		# :webrick, :lhttp, :apache 
+
+		server = :webrick
+
+		# daemonize? (in webrick only)
+
+		daemon = false
+
+		# log to file ?
+
+		log_to_file = false
+
+		# Parse the arguments.
+
+		parser = OptionParser.new do |opts|
+
+			opts.banner = 'Usage: ctl [options]'
+			opts.separator ''
+			opts.separator 'Specific options:'
+
+			opts.on("-s", "--start", "Start application.") do 
+				action = :start	
+			end
+
+			opts.on("-S", "--stop", "Stop application.") do
+				action = :stop
+			end
+
+			opts.on("-r", "--restart", "Restart application.") do
+				action = :restart
+			end
+
+			opts.on("-d", "--daemon", "Run application as a daemon.") do
+				daemon = true
+				log_to_file = true
+			end
+			
+			opts.on("-D", "--debug", "Run application in debug mode.") do
+				$DBG = true
+			end
+
+			opts.on("-w", "--webrick", "Use a webrick server [default].") do
+				server = :webrick
+			end
+
+			opts.on("-l", "--lhttpd", "Use a webrick server [default].") do
+				server = :lhttpd
+				log_to_file = true
+			end
+
+			opts.on_tail("-v", "--version", "Show version.") do 
+				require 'nitro/version'
+				puts "Nitro #{Nitro::Version}"
+				exit
+			end
+
+			opts.on_tail("-?", "--help", "Show this message.") do
+				puts opts
+				exit
+			end
+			
+		end
+
+		parser.parse!(ARGV)
+
+		require 'conf/app.conf.rb'
+
+		if log_to_file
+			Logger.set(Logger.new('log/app.log'))
+		end
+		
+		case server
+
+		when :webrick
+			require 'nitro/adaptors/webrick'
+			N::Webrick.start($conf)
+			
+		when :lhttpd
+			require 'nitro/adaptors/fastcgi'
+			`lighttpd -f conf/lhttpd.conf`
+		end
+	end
+
+end
+
+# Run the app!
+
+Runner.run(ARGV)
+
+end