nitro 0.3.0 → 0.4.1

data/lib/n/sync/handler.rb

@@ -1,229 +0,0 @@
-# code:
-# * George Moschovitis  <gm@navel.gr>
-# * Anastasios Koutoumanos  <ak@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: handler.rb 101 2004-10-22 12:35:39Z gmosx $
-
-require "timeout"
-require "n/server"
-
-module N; module Sync
-
-class HandlerExitException < Exception; end
-
-# = Handler 
-#
-# Sync Server Handler
-#
-# === Design:
-#
-# Override this to create your handler. A handler can 
-# act as a multiplexer to implement multiple services per server.
-#
-class Handler
-	SEPARATOR = "\000"
-	
-	# socket timeout in seconds
-	@@socket_timeout = 30
-	
-	# handler timeout in seconds
-	@@handler_timeout = 60 * 60
-
-	attr :server, :socket
-
-	attr :thread, :touch_time
-	
-	# status
-	attr_accessor :status
-	
-	STATUS_IDLE = 0
-	STATUS_RUNNING = 10
-	STATUS_STOPPED = 20
-
-	def initialize(server, socket)
-		@server, @socket = server, socket
-	end
-
-	# Called when the handler starts.
-	#
-	def start
-		touch!
-		@thread = Thread.new(&method("run").to_proc)
-	end
-
-	# Called when the handler stops.
-	#
-	def stop
-		unless STATUS_STOPPED == @status
-			@status = STATUS_STOPPED
-			$log.debug "Stoping handler" if $DBG
-	
-			begin
-				@socket.close()
-			rescue Exception, StandardError => e
-				# gmosx: this is needed to be FAULT TOLERANT
-				# DRINK IT!
-				$log.error "Cannot close exception when stoping handler."
-			end
-			
-			# gmosx: why not? more FAULT TOLERANT.
-			@server.handlers.delete_if {|h| STATUS_STOPPED == h.status}
-
-		end
-	end
-
-	# called by the garbage collector.
-	#
-	def gc!
-		@thread.raise HandlerExitException.new()
-	end
-	
-	# Perform the handler's action.
-	#
-	def run
-		@status = STATUS_RUNNING
-		
-		while (STATUS_RUNNING == @status) and (not @socket.closed?)
-			begin
-				unless cmd = read()
-					$log.error "Client closed connection"
-					@status = STATUS_IDLE
-				else
-					touch!
-					handle(cmd.chop())
-				end
-			rescue HandlerExitException => ex
-				@status = STATUS_IDLE
-				$log.debug "Handler exit" if $DBG
-			rescue Exception, StandardError => ex
-				@status = STATUS_IDLE
-				$log.debug ex if $DBG
-			end
-		end
-
-		begin		
-			stop()
-		rescue Exception, StandardError => e
-			# gmosx: this rescue block needed to get debug info!
-			# 
-			$log.error pp_exception(e)
-		end
-	end
-	
-	def touch!
-		@touch_time = Time.now()
-	end
-	
-	def live?
-		return Time.now < @touch_time + @@handler_timeout
-	end
-	
-	# Read xml from the socket
-	#
-	def read
-		return unless @status == STATUS_RUNNING
-		
-		cmd = nil
-		
-		# gmosx: no timeout here!
-		cmd = @socket.gets(SEPARATOR)
-		$log.debug "in: #{cmd}" if $DBG
-		
-		return cmd
-	end	
-		
-	# Write xml to the socket
-	#
-	def write(cmd)
-		return unless @status == STATUS_RUNNING
-		
-		$log.debug "out: #{cmd}" if $DBG
-		
-		begin
-			timeout(@@socket_timeout) { @socket << "#{cmd}#{SEPARATOR}" }
-		rescue Exception, StandardError => e
-			# gmosx: the socket is invalid close the handler.
-			$log.error pp_exception(e)
-			stop()
-		end
-	end	
-
-	# parse the xml commnad to create a ruby method call.
-	#
-	def parse(cmd)
-		return unless @status == STATUS_RUNNING
-		
-		cmd = REXML::Document.new(cmd).root()
-
-		method = cmd.name().gsub(/-/, "_")
-		unless cmd.attributes.empty?
-			args = "(#{cmd.attributes.collect { |k, v| ":#{k.gsub(/-/, "_")} => '#{v}'" }.join(", ")})"
-		else
-			args = nil
-		end
-
-		return "cmd_#{method}#{args}"
-	end
-		
-	# Generic handler.
-	#
-	def handle(cmd)
-		if cmd = parse(cmd)
-			$log.debug "exec: #{cmd}" if $DBG
-			begin
-				eval(cmd)
-			rescue => ex
-				$log.error ex
-			end
-		end
-	end
-
- 	# Send to another handler
-	#	
-	def send(cmd, handler)
-		handler.write(cmd)
-	end
-
-	# Broadcast to all handlers (clients)
-	#
-	def broadcast(cmd)
-		@server.broadcast(cmd)
-	end	
-	
-	# Broadcast to all other handlers (clients)
-	#
-	def broadcast_to_others(cmd)
-		for handler in @server.handlers
-			unless self == handler 
-				handler.write(cmd)
-			end
-		end
-	end	
-
-	# ------------------------------------------------------------------
-
-	def info(txt)
-		write(%|<info text="#{txt}" />|)
-	end
-
-	def error(txt)
-		write(%|<error text="#{txt}" />|)
-	end
-	
-	# ------------------------------------------------------------------
-	# Commands
-
-	# A sample command
-	#
-	def cmd_ping(args)
-		cmd = %{<pong time="#{Time.now}"}
-		cmd += %{ challenge="#{args[:challenge]}"} if args
-		cmd += " />"
-		
-		write(cmd)
-	end
-	
-end
-
-end; end #modules

data/lib/n/sync/server.rb

@@ -1,176 +0,0 @@
-# code: 
-# * George Moschovitis  <gm@navel.gr>
-# * Anastasios Koutoumanos  <ak@navel.gr>
-#
-# (c) 2004 Navel, all rights reserved.
-# $Id: server.rb 101 2004-10-22 12:35:39Z gmosx $
-
-require "thread"
-require "socket"
-require "rexml/document"
-
-require "n/std"
-require "n/application"
-require "n/utils/array"
-require "n/sync/handler"
-
-module N; module Sync
-
-# = Server
-#
-# A Synchronous server tha communicates with clients using
-# application specific xml protocols. Typically communicates with
-# Flash clients utilising the XmlSocket functionality to enable 'push' 
-# flash applications.
-#
-# The Macromedia XML Socket protocol is used, \000 is used as a eof 
-# marker. NO: the XML protocol is not really appropriate, better use
-# a space optimized delimited ASCII protocol.
-#
-# === Design:
-# 
-# Should support clustered operation: A cluster of servers is spawned.
-# The client connects to one of the servers at random. The client sticks 
-# to the server. Each server considers the others as clients and 
-# rebroadcasts all the events.
-#
-# We keep one service per server for simplicity, if we need multiple
-# services we can implement a multiplexer service (handler).
-#
-# === TODO:
-#
-# - Investigate if this server can be done with select.
-#
-class Server < N::Application
-	MONITOR_INTERVAL = 2 * 60
-	
-	# a single tcp server accepts all tcp requests
-	attr :tcp_server
-
-	# the listening address/port for this server.
-	attr_reader :address, :port
-		
-	# the handler class, used to instantiate handlers
-	attr :handler_class
-	
-	# maximum number of clients to connect.
-	attr_accessor :max_handlers
-
-	# the handler list, all handler attached to the server.
-	attr_accessor :handlers	
-	
-	# status
-	attr_accessor :status
-	
-	STATUS_IDLE = 0
-	STATUS_RUNNING = 10
-	STATUS_STOPPED = 20
-	
-	def initialize(address = "localhost", port = 2121, handler_class = N::Sync::Handler, max_handlers = nil)
-		@address, @port = address, port
-		@max_handlers = max_handlers
-		@name, @title = "nsync", "Navel Sync"
-		@status = STATUS_IDLE
-		
-		@handlers = N::SafeArray.new()
-		@handler_class = handler_class
-		
-		super()		
-	end
-
-	# Start the server.
-	#
-	def start()
-		# a single tcp server accepts all tcp requests
-		@tcp_server = TCPServer.new(address, port)
-
-		start_monitor()
-		run()
-	end
-
-	# Stop the server.
-	#
-	def stop()
-		@status = STATUS_STOPED
-	end
-	
-	# Run the main loop of the server.
-	#
-	def run() 
-		@status = STATUS_RUNNING
-		$log.info "Server is running."
-		
-		begin
-			while (STATUS_RUNNING == @status)
-				socket = @tcp_server.accept()
-				$log.debug "Socket accepted" if $DBG
-				handler = @handler_class.new(self, socket)
-				handlers << handler
-				handler.start()
-			end
-		rescue Exception, StandardError => e
-			$log.error pp_exception(e)
-			# tml, FIXME:
-			# this is dangerous! make more FAULT TOLERANT!
-		end
-		
-		@status = STATUS_IDLE
-	end
-	
-	def shutdown()
-		end_monitor()
-		for handler in handlers
-			handler.stop()
-		end
-		Thread.exit()
-	end
-
-	# ------------------------------------------------------------------
-	
-	def start_monitor
-		@monitor = Thread.new {
-			begin
-				while true
-					sleep(MONITOR_INTERVAL)
-					$log.debug "monitor beat -- #{@handlers.size()} handlers" if $DBG
-					
-					for handler in @handlers
-						unless handler.live?
-							$log.info "Idle handler detected!"
-							handler.gc!()
-						end
-					end
-				end
-			rescue Exception, StandardError => e
-				$log.error pp_exception(e)
-			end
-		}
-	end
-	
-	def end_monitor
-		Thread.kill(@monitor)
-	end
-	
-	# ------------------------------------------------------------------
-
-	def send(cmd, handler)
-		handler.write(cmd)
-	end
-	
-	def broadcast(cmd)
-		for handler in @handlers
-			handler.write(cmd)
-		end
-	end	
-	
-end
-
-if $0 == __FILE__
-	require "n/logger"
-	
-	$log = Logger.new(STDERR)
-	Server.new().exec()
-end
-
-end; end #modules
-

data/lib/p/README

@@ -1 +0,0 @@
-Add Web Application Framework parts in this directory