nitro 0.1.2

data/lib/n/parts.rb

@@ -0,0 +1,154 @@
+# = Part
+#
+# A part encapsulates a service in the Framework. 
+#
+# code: 
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: parts.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "singleton"
+
+require "n/l10n"
+
+# gmosx, FIXME: safe is probably NOT needed!
+$parts = N::SafeHash.new
+$rewrites = N::SafeHash.new
+$roles = N::SafeArray.new
+
+module Kernel
+
+	# Special require for part definitions.
+	#
+	def require_part(path)
+		require("p/#{path}/part")
+		for lc in $lc_use
+			begin
+				require("p/#{path}/#{lc}")
+			rescue LoadError => e
+				# Drink it!
+				# $log.debug "No localization files for part '#{path}'" if $DBG
+			end
+		end
+	end
+	
+	# Register a part
+	#
+	def register_part(part_class)
+		part = part_class.instance()
+		$parts[part.name] = part
+		
+		# gmosx: DOESNT work yet, we have to manage
+		# the require order, perhaps DI/Copland can help
+		# here?
+		# auto require the parts this one depends
+		# on. 
+		#
+		#for dep_part in part.dependencies
+		#	require_part(dep_part)
+		#end
+			
+		part.start()		
+	end
+	
+end
+
+# ----------------------------------------------------------------------
+
+module N
+
+# = Part
+#
+# A module of functionality in the framework
+#
+# = Design:
+#
+# Q: Part should include Entity to allow optional runtime 
+# administration/customization ??
+#
+class Part
+	include Singleton 
+	
+	# the (internal) name of this part
+	attr_accessor :name
+	# the tile of this part (intended for humans)
+	attr_accessor :title
+	# a description of the part
+	attr_accessor :body
+	# the version of this part
+	attr_accessor :version
+	# the vendor
+	attr_accessor :vendor
+	# url of the vendor's homepage.
+	attr_accessor :vendor_url
+	# an array of part names this part depends on. The named
+	# parts are automatically required when requiring this part.
+	attr_accessor :dependencies
+	
+	prop_accessor String, :path
+
+	def initialize
+		sitemap()
+		rewrites()
+		roles()
+		prepared_statements()
+	end
+	
+	# Install this part to the application. Called
+	# by the application installation scripts. Typically
+	# inserts bootstrap data in the database
+	#
+	def install
+	end
+
+	# Uninstall this part. Typically cleans up the
+	# database.
+	#	
+	def unistall
+	end
+
+	#
+	#	
+	def start
+	end
+	
+	#
+	#
+	def stop
+	end
+
+	# Define the pages this part introduces.
+	#
+	def sitemap
+	end	
+
+	# Define the rewrite rules for this part.
+	#
+	def rewrites
+	end
+	
+	# Define the roles this part introduces.
+	#
+	def roles
+	end
+
+	# Define usefull prepared statements for this 
+	# part   
+	#
+	def prepared_statements
+	end
+
+	#
+	#
+	def to_s
+		@name
+	end	
+end
+
+end # module
+
+# Namespace for parts.
+#
+module P
+end # module

data/lib/n/properties.rb

@@ -0,0 +1,194 @@
+# = Properties support
+#
+# Ruby attributes are typeless and generally this is good. Some times
+# we need extra metadata though, for example in relational mapping, or
+# web form population.
+#
+# Only Fixnums, Strings, Floats, Times, Booleans are converted.
+#
+# The default = methods do not force the  types. A special 
+# __force_set method should be used instead.
+#
+# TODO:
+# Perhaps a sync is needed in evals (!!!!)
+#
+# code: gmosx, drak, ekarak
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: properties.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "n/utils/array"
+require "n/utils/hash"
+
+module N
+
+# Property Metadata
+#
+# === Design:
+# - add default value in the extra sql
+#
+class Property
+	# the symbol of the property
+	attr_accessor :symbol
+	# the string representation of the symbol
+	attr_accessor :name
+	# the class of the property
+	attr_accessor :klass 
+	# extra sql options for the property. if set,
+	# it must contain the sql_type for this class, the
+	# default is overriden.
+	attr_accessor :sql
+	
+	def initialize(symbol, klass, sql = nil)
+		@symbol, @klass = symbol, klass
+		@sql = sql
+		@name = @symbol.to_s()
+	end
+	
+	def ==(other)
+		return @symbol == other.symbol
+	end
+end
+
+end # module
+
+class Module
+
+	# Properties
+	# An array is used to enforce order.
+	attr_accessor :__props
+	
+	# Metadata
+	# A hash of module metadata.
+	attr_accessor :__meta
+	
+	# Define a property (== typed attribute)
+	# based on draks property redesign!
+	#
+	# ex:
+	# prop_accessor String, :title, :body
+	# prop_accessor String, "char(10) NOT NULL", :title, :body
+	# 
+	def prop_accessor(*params)
+		klass = params.shift
+	
+		# if the next param is a String, it is 
+		# extra sql metadata.
+		if params.first.is_a?(String) 
+			sql = params.shift
+		else
+			sql = nil
+		end
+		
+		# the rest of params are symbols
+
+		@__props = N::SafeArray.new() unless @__props
+		
+		params.each { |s|
+			add_prop(N::Property.new(s, klass, sql))			
+		}
+	end
+	# to be compatible with ruby parlance
+	alias_method :prop, :prop_accessor
+	
+	# Add the property
+	# Optimize this
+	#
+	def add_prop(prop)		
+		if idx = @__props.index(prop)
+			# override in case of duplicates. Keep the order of the props.
+			@__props[idx] = prop
+		else
+			@__props << prop
+		end
+		
+		# Precompile the property read/write methods
+
+		s, klass = prop.symbol, prop.klass 
+		
+		module_eval %{
+			def #{s}
+				return @#{s}
+			end
+			
+			def #{s}=(val)
+				@#{s} = val
+			end
+			
+			def __force_#{s}(val)
+					@#{s} = } + case klass.name
+												when Fixnum.name
+													"val.to_i()"
+												when String.name
+													"val.to_s()"
+												when Float.name
+													"val.to_f()"
+												when Time.name
+													"Time.parse(val.to_s())"
+												when TrueClass.name, FalseClass.name
+													"val.to_i() > 0"
+												else
+													"val"
+											end + %{ 
+			end
+		}
+	end
+	
+	# Attach metadata 
+	#
+	def meta(key, val)
+		@__meta = N::SafeHash.new unless @__meta
+		add_meta(key, val)
+	end
+	
+	# Add the metadata
+	# TODO: Optimize this
+	#
+	def add_meta(key, val)
+		@__meta[key] = [] unless @__meta[key]
+
+		# guard against duplicates, no need to keep order.
+		@__meta[key].delete_if { |v| val == v }
+		@__meta[key] << val			
+	end
+	
+	# This method is typically called before including other
+	# modules to preserve properties order. 
+	#
+	def inherit_meta(mod = superclass)
+		# concat props.
+		if mod.__props
+			@__props = N::SafeArray.new unless @__props
+			
+			mod.__props.each { |p|
+				add_prop(p)
+			} 
+		end
+		
+		# concat metadata
+		if mod.__meta
+			mod.__meta.each { |k, val|
+				val.each { |v|
+					meta(k, v)
+				} if val
+			}
+		end
+	end
+	
+	# Override the default include method to also include the metadata.
+	# WARNING: can cause infinite loop if overriden again!
+	#
+	alias_method :old_include, :include
+	
+	# A new version of include that includes the properties too.
+	#
+	def include(*modules)
+		old_include(*modules)
+		
+		for m in modules
+			inherit_meta(m)
+		end
+	end
+		
+end
+

data/lib/n/server.rb

@@ -0,0 +1,61 @@
+# = Server
+#
+# Generic server infrastructure
+#
+# code:: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: server.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "n/application"
+
+module N
+
+# = Server
+#
+# Base server class
+#
+class Server < N::Application
+	# the listening address/port for this server.
+	attr_reader :address, :port
+	
+	def initialize(name = "Server")
+		super
+	end
+	
+	# Start the server
+	#
+	def start
+		super
+	end
+	
+	# Stop the server
+	#
+	def stop
+		super
+	end
+	
+	# The main server loop
+	#
+	def run
+		begin
+			while :RUNNING == @status
+				if live = IO.select(@ios, nil, nil, 2.0)
+				
+				end
+			end
+		rescue
+		
+		end
+	end
+	
+	# Override this method in your custom server. This method is very 
+	# flexible, you can spawn threads, use keep alive connections, 
+	# handle+close, use handler pools, anything.
+	# 
+	def handle
+	end
+
+end
+
+end # module

data/lib/n/server/PLAYBACK.txt

@@ -0,0 +1,8 @@
+
+
+overload the servers accept method to store socket data in RECORD mode 
+and read sockets from a previously recorded stream in PLAYBACK mode.
+
+timing information must be stored along the socket data
+
+the centralized accept methot makes the scheme possible.

data/lib/n/server/RESEARCH.txt

@@ -0,0 +1,13 @@
+
+patterns: ObjectPool, ProducerConsumer
+
+produced consumer pattern: listener produces sockets, thread pool consumes
+sockets from a queue.
+
+--
+
+gmosx: daemons does not belong here ??
+gmosx: do not use a thread per connection, use a pool of conections that service
+		a fifo list of connections (sockets).
+
+gmosx: use a pipeline request handling architecture

data/lib/n/server/filter.rb

@@ -0,0 +1,77 @@
+# = Server filter
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 20024 Navel, all rights reserved.
+# $Id: filter.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "socket"
+require "thread"
+require "sync"
+
+module N
+
+# == Filter
+#
+# A server serves client requests by feeding the request/request pair
+# to a pipeline of processing filters. This is not a simple linear pipeline.
+# Instead it is what we call a 'folding' (hierarchical) pipeline: each
+# filter encapsulates the next. In effect, the pipeline is a generalized
+# filter!
+#
+# === Design:
+#
+# Filters are NOT singleton classes. This way we can assign one filter
+# class to multiple resources, and keep statistics and metrics for
+# each resource.
+# A filter may contain state (attributes) for example metrics.
+#
+class ServerFilter
+	# the next filter in the pipeline.
+	attr_reader :next_filter
+
+	# set the filters next.
+	#
+	# example:
+	# LogFilter.new(TimeFilter.new(PageFilter.new))
+
+	def initialize(next_filter = nil)
+		@next_filter = next_filter
+	end
+
+	# set the filters next (next_filter).
+	#
+	# example:
+	# LogFilter.new << TimeFilter.new << PageFilter.new
+
+	def << (next_filter = nil)
+		@next_filter = next_filter
+	end
+
+	# override this method to implement your filter.
+
+	def process(request)
+		# preprocessing comes here...
+
+		# walk the pipeline
+		return process_next(request)
+
+		# postprocessing comes here...
+
+		# return the result...
+	end
+	
+	# process the next filter in the pipeline
+	
+	def process_next(request)
+		if @next_filter
+			return @next_filter.process(request)
+		else
+			return nil
+		end
+	end
+	
+end
+
+end # module