nitro 0.1.2

data/lib/n/app/webrick.rb

@@ -0,0 +1,70 @@
+# = Webrick AppServer
+#
+# Used temporarily unitl we build our own app server.
+#
+# code:: gmosx, elathan
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: webrick.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "drb"
+require "cgi"
+require "webrick"
+
+require "n/logger"
+require "n/application"
+require "n/app/server"
+require "n/app/webrick-servlet"
+
+module N; module App
+
+# = 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.
+#
+class Webrick < N::Server
+	include N::App::ServerMixin
+	include WEBrick
+
+	attr_accessor :webrick
+	
+	def initialize(name = "WebrickServer")
+		super
+		initialize_app()
+	end
+
+	def start
+		accesslog = WEBrick::BasicLog::new("/dev/null") 
+		referer = WEBrick::BasicLog::new("/dev/null")	
+		
+		@webrick = HTTPServer.new(
+			:BindAddress => $appsrv_address, 
+			:Port => $appsrv_port, 
+			:DirectoryIndex => ["index.sx"],
+			# 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::App::WebrickServlet)
+		
+		trap("INT") {
+		 @webrick.shutdown() 
+		}
+		
+		@webrick.start()
+	end
+	
+	def stop
+		@webrick.stop
+	end
+	
+end
+
+end; end # module

data/lib/n/application.rb

@@ -0,0 +1,187 @@
+# = Application
+#
+# code: gmosx, ekarak, drak, elathan
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: application.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require 'optparse'
+require 'ostruct'
+   
+require "n/logger"
+require "n/std"
+
+module N
+
+# == Application
+#
+# the default Application object of the Framework.
+#
+class Application
+	# credentials of the application
+	attr_accessor :name, :title, :description, :version
+
+	# the status of the application
+	# use symbols to denote status.
+	# valid status symbols:
+	# * :run = The server is running
+	# * :stop = The server is stopped
+	attr_accessor :status
+
+	# startup time of the application
+	attr_accessor :create_time
+
+	attr_reader :daemonized
+
+	# the pid of the application
+	attr_reader :pid, :pidfile
+	
+	#
+	#
+	def initialize(name = "Unknown")
+		@name = name
+		@pidfile = "/tmp/#{@name}.pid"
+		@create_time = Time.now()
+		@status = :stop
+	end
+
+	# FIXME: deleting of arguments is wrong, recode
+	# this using GETOPT.
+	#
+	def parse_arguments(args = ARGV)
+      
+		opts = OptionParser.new { |opts|
+			opts.banner = "Usage: application.rb [action]"
+
+			opts.separator ""
+			opts.separator "Specific options:"
+ 
+   		opts.on("-s", "--start",
+   				"Start Navel's Application Server.") { 
+				start()
+   		}
+
+			opts.on("-S", "--stop",
+   				"Stop Navel's Application Server.") { 
+				stop()
+   		}
+
+			opts.on("-r", "--restart",
+   				"Restart Navel's Application Server.") { 
+				restart()
+   		}
+
+			opts.on("-d", "--daemon",
+   				"Run Navel's Application Server as a daemon.") { 
+				daemonize()
+				start()
+   		}
+
+			opts.on_tail("-?", "--help", "Show this message.") {
+   			puts opts
+     		exit
+			}
+    }   
+		begin
+			opts.parse!(args)
+		rescue => ex
+			puts ex
+			puts "Please, either specify a valid option or invoke the usage using -? or --help."
+		end
+	end
+	alias_method :exec, :parse_arguments
+
+	#
+	#
+	def start()
+		raise "Application allready started!" unless :stop == @status
+
+		begin		
+			run()
+		rescue => ex
+			puts ex
+		end
+		
+		# to allow for chaining
+		return self
+	end
+
+	# Override to properly restart the application
+	#
+	def restart()
+		stop()
+		start()
+
+		# to allow for chaining
+		return self
+	end
+
+	# Stop the application. Typically kills ths application daemon.
+	#
+	def stop
+		if dpid = daemon_pid()
+			begin
+				File.delete(@pidfile)
+				Process.kill("SIGKILL", dpid)
+				$log.info "Successfully killed #{@name} instance, pid=#{dpid}"
+			rescue => ex
+				$log.error "Cannot kill #{@name} instance, pid=#{dpid}"
+				$log.error ex
+			end
+		else
+			$log.error "Cannot locate pid of running instance!"
+		end
+
+		# to allow for chaining
+		return self
+	end
+
+	# Begin the application loop.
+	# Override this method in your application.
+	#
+	def run
+		# to allow for chaining
+		return self
+	end
+
+	# Run the application as a daemon
+	# FIXME: handle logging for daemons.
+	# ???: How does this work !?!?
+	#
+	def daemonize
+		unless @daemonized
+			trap "SIGCLD", "IGNORE"
+
+			pid = fork()
+			
+			if pid # parent process
+				@pid = pid
+				File.open(@pidfile, 'w') {|f| f << "#{pid}\n" }
+				exit!
+			else # child
+				$log.info "Daemon for '#{@name}', process id: #{Process.pid}"
+			end
+
+			# change process group and lose control tty
+			Process.setpgrp()
+		end
+
+		@daemonized = true
+
+		return self
+	end
+
+	# Returns the pid of the running daemon 
+	#
+	def daemon_pid()
+		begin
+			return File.open(@pidfile).read.chomp.to_i
+		rescue
+			$log.info "Could not read pid from #{@pidfile}"
+			return nil
+		end
+	end
+end
+
+end # module
+

data/lib/n/config.rb

@@ -0,0 +1,31 @@
+# = Config
+#
+# Configuration
+#
+# code: 
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: config.rb 89 2004-10-20 12:55:58Z gmosx $
+
+$srv_name = "Nitro"
+$srv_version = "0.1.2"
+
+$srv_monitor_scripts = true
+$srv_default_file = "index.sx"
+$srv_autologin_expires = 60*60*24*30
+
+# session timeout (in seconds)
+$srv_session_timeout = 35*60
+
+# session timeout for anonymous user (in seconds)
+$srv_anon_session_timeout = 30*60
+
+# enable distributed state?
+$drb_state = false
+
+# use the default error page.
+$error_page_url = nil
+
+# default encoding for the app.
+$conf_encoding = "iso-8859-1"

data/lib/n/db.rb

@@ -0,0 +1,217 @@
+# = Database
+#
+# An efficient, yet simple Object-Relational Mapper. 
+#
+# === Design
+#
+# Keep this class backend agnostic. Put backend specific code in
+# the Connection / Managed class.
+#
+# Try to make the methods work with oids. We do keep 
+# a unified id space. Include the N::Sequenced Marker to 
+# denote custom id space.
+# Do NOT implement descendants use a root id (rid).
+#
+# For class ids we use the name instead of a hash. Class ids are
+# typically not used in querys, they are stored for completeness.
+# If we store a hash we cannot reclaim the class thus invalidating
+# the point. Instead of .name(), to_s() is used so the methods
+# are more flexible (they accept class names too!!)
+# 
+# === WARNING:
+#
+# When creating a new db exec the following:
+# CREATE SEQUENCE oids_seq;
+#
+# or
+#
+# DbTools.create_oids_seq
+#
+#
+# === Todo
+#
+# - support caching
+# - support prepared statements
+# - foreign keys (delete cascade)
+# - keep attribudes as marshaled!!
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: db.rb 79 2004-10-18 16:38:19Z gmosx $
+
+module N; 
+
+require "n/properties"
+require "n/utils/array"
+require "n/utils/time"
+require "n/utils/pool"
+
+require "n/db/utils"
+require "n/db/managed"
+require "n/db/connection"
+require "n/db/mixins"
+
+# Configuration
+
+# if true, enables the read only mode
+$db_read_only_mode = false
+
+# = Database
+#
+# === Design:
+#
+# - This is NOT a singleton, an application may access multiple
+#   databases.
+#
+class Db
+	# hash of configuration options.
+	attr_accessor :config
+
+	# Pool of connections to the backend.
+	attr_accessor :pool
+	
+	# Entities cache.
+	attr_accessor :cache
+
+	# Managed classes fields. A hash of hashes.
+	attr_accessor :fields
+	
+	# Initialize the database interface.
+	#
+	def initialize(config)
+		@config = config
+		
+		if backend = config[:backend]
+			require "n/db/#{backend}"
+		else
+			require "n/db/psql"
+		end
+
+		$log.info "Connecting to database '#{config[:database]}'."
+		
+		@pool = N::Pool.new
+		@fields = N::SafeHash.new
+		
+		for i in (0...config[:connection_count])
+			@pool << DbConnection.new(config)
+		end
+	end
+	
+	# Shutdown the database interface.
+	#
+	def shutdown
+		for con in @pool
+			con.close()
+		end
+	end
+	alias_method :close, :shutdown
+
+	# Get a connection from the pool to access the database.
+	#
+	def get_connection
+		return @pool.pop()
+	end
+	
+	# Restore an unused connection to the pool.
+	#
+	def put_connection(connection)
+		return @pool.push(connection)
+	end	
+	
+	# Utility method, automatically restores a connection to the pool.
+	#
+	def connect(deserialize = nil, &block)
+		result = nil
+		
+		begin
+			db = @pool.pop()
+			db.deserialize = deserialize unless deserialize.nil?
+			
+			result = yield(db)
+			
+			db.deserialize = true
+		ensure
+			@pool.push(db)
+		end
+
+		return result
+	end
+	alias_method :open, :connect
+
+	# Utility method, gets connection and encloses in transaction.
+	#
+	def transaction(deserialize = nil, &block) 
+		result = nil
+		
+		begin
+			db = @pool.pop()
+			db.deserialize = deserialize if deserialize
+			
+			db.start()
+			result = yield(db)
+			db.commit()
+			
+			db.deserialize = true
+		ensure
+			@pool.push(db)
+		end
+
+		return result
+	end
+
+	# Utility method, creates an entity from a row
+	#
+	def entity_from_row(row, klass)
+		entity = klass.new()
+		entity.__db_read_row__(row)
+		return entity
+	end
+
+	private
+	
+	# Automatically wrap connection methods.
+	#
+	def self.wrap_method(method, args)
+		args = args.split(/,/)
+		class_eval %{
+			def #{method}(#{args.join(", ")})
+				begin
+					db = @pool.pop()
+					res = db.#{method}(#{args.collect {|a| a.split(/=/)[0]}.join(", ")})
+				ensure
+					@pool.push(db)
+				end
+				return res
+			end
+		}
+	end
+
+	wrap_method :put, "entity"
+	alias_method :<<, :put
+	wrap_method :insert, "obj"
+	wrap_method :update, "obj"
+	wrap_method :update_properties, "update_sql, ent_or_oid, klass = nil"
+	wrap_method :pupdate, "update_sql, ent_or_oid, klass = nil"	
+	wrap_method :get, "oid, klass"	
+	wrap_method :get_by_oid, "oid, klass"
+	wrap_method :get_by_name, "name, klass"
+	wrap_method :get_all, "klass, extrasql = nil"
+	wrap_method :select, "sql, klass, join_fields = nil"
+	wrap_method :select_one, "sql, klass, join_fields = nil"
+	wrap_method :child, "entity, klass, extrasql = nil"
+	wrap_method :children, "entity, klass, extrasql = nil"
+	wrap_method :count_children, "entity, klass, extrasql = nil"
+	wrap_method :delete, "entity, klass = nil, cascade = true"
+	wrap_method :query, "sql"
+	wrap_method :query_one, "sql"
+	wrap_method :count, "sql"
+	wrap_method :match, "sql"
+	wrap_method :exec, "sql"
+	wrap_method :exec_and_clear, "sql"
+	wrap_method :exec_clear, "sql"
+end
+
+end # module
+