plezi 0.7.0

data/lib/plezi.rb

@@ -0,0 +1,125 @@
+### Ruby core extentions
+
+require 'singleton'
+require 'pathname'
+require 'logger'
+require 'socket'
+require 'openssl'
+require 'strscan'
+require 'base64'
+require 'digest/sha1'
+require 'securerandom'
+require 'time'
+require 'json'
+
+### version
+
+require "plezi/version"
+
+
+### Server requirements
+
+require "plezi/server/services/basic_service"
+require "plezi/server/services/ssl_service"
+require "plezi/server/services/no_service"
+
+require "plezi/server/protocols/http_protocol"
+require 'plezi/server/protocols/http_request'
+require 'plezi/server/protocols/http_response'
+
+require "plezi/server/helpers/http"
+require "plezi/server/helpers/mime_types"
+
+require "plezi/server/protocols/websocket"
+require 'plezi/server/protocols/ws_response'
+
+## Server-Framework Bridges
+require "plezi/handlers/http_echo"
+require "plezi/handlers/http_host"
+require "plezi/handlers/http_router"
+
+require "plezi/handlers/controller_magic"
+require "plezi/handlers/magic_helpers"
+require "plezi/handlers/route"
+
+require "plezi/handlers/stubs"
+
+### Framework requirements
+require "plezi/base/events"
+require "plezi/base/timers"
+require "plezi/base/services"
+require "plezi/base/connections"
+require "plezi/base/logging"
+require "plezi/base/io_reactor"
+require "plezi/base/cache"
+require "plezi/base/engine"
+
+### DSL requirements
+require "plezi/base/dsl"
+
+### optional Rack
+require "plezi/base/rack_app"
+
+## erb templating
+begin
+	require 'erb'
+rescue Exception => e
+	
+end
+
+
+
+##############################################################################
+# To make something new, we leap to the unknown.
+##############################################################################
+# Plezi is a stand alone web services app, which supports RESTful HTTP, HTTP Streaming and WebSockets.
+#
+# Plezi is a wonderful alternative to Socket.io which makes writing the server using Ruby a breeze. 
+#
+# Plezi routes accept Regexp's (regular exceptions) for route paths. for example:
+#
+#    require 'plezi'
+#    listen
+#    route(/[.]*/) {|request, response| response << "Your request, master: #{request.path}."}
+#
+# The catch-all route (/[.]*/) has a shortcut '*', so it's possible to write:
+#
+#    require 'plezi'
+#    listen
+#    route('*') {|request, response| response << "Your request, master: #{request.path}."}
+#
+#
+# Plezi accepts an optional class object that can be passed using the `route` command. Passing a class object is especially useful for RESTful and WebSocket applications.
+# read more at the Plezi::StubWSCtrl and Plezi::StubRESTCtrl documentation, which are stub classes used for testing routes.
+#
+#    require 'plezi'
+#    listen
+#    route "*", Plezi::StubRESTCtrl
+#
+# class routes that have a specific path (including root, but not a catch-all or Regexp path)
+# accept an implied `params[:id]` variable. the following path ('/'):
+#
+#    require 'plezi'
+#    listen
+#    route "/", Plezi::StubRESTCtrl
+#    # client requests: /1
+#    #  =>  Plezi::StubRESTCtrl.new.show() # where params[:id] == 1
+#
+# it is possible to use "magic" routes (i.e. `/resource/:type/(:id)/(:date){/[0-9]{8}}/:foo`) and it is also possible to set the appropriate paramaters within the `before` method of the Conltroller.
+#
+# Routes are handled in the order they are created. If overlapping routes exist, the first will execute first:
+#
+#    require 'plezi'
+#    listen
+#    route('*') do |request, response|
+#       response << "Your request, master: #{request.path}." unless request.path.match /cats/
+#    end
+#    route('*') {|request, response| response.body << "Ahhh... I love cats!"}
+#
+# all the examples above shuold be good to run from irb. updated examples can be found at the Readme file in the Github project: https://github.com/boazsegev/plezi
+#
+# thanks to Russ Olsen for his ideas for a DSL and his blog post at:
+# http://www.jroller.com/rolsen/entry/building_a_dsl_in_ruby1 
+##############################################################################
+module Plezi
+end

data/lib/plezi/base/cache.rb

@@ -0,0 +1,77 @@
+
+module Plezi
+
+	# File and Object Caching for Plezi
+	module_function
+	# contains the cached data, in the format: CACHE_STORE["filename"] = CacheObject
+	CACHE_STORE = {}
+	LOCK = Mutex.new
+	CACHABLE = %w{cache object slim haml css map js html scss sass coffee txt xml json yaml rb}
+
+	@cache_to_disk = true
+
+	# this class holds cached objects (data and modification times)
+	class CacheObject
+		# Cached attributes
+		attr_accessor :data, :mtime
+
+		# initialize a Cached object
+		def initialize d = nil, t = Time.now
+			@data, @mtime = d, t
+		end
+	end
+
+	# load the file from the cache (if exists) or the file system (if it doesn't)
+	def load_file filename
+		cached?(filename) ? get_cached(filename) : reload_file(filename)
+	end
+	# review a file's modification time
+	def file_mtime filename
+		return CACHE_STORE[filename].mtime if cached?(filename)
+		File.mtime(filename)
+	end
+
+	# force a file onto the cache (only if it is cachable - otherwise will load the file but will not cache it).
+	def reload_file filename
+		if CACHABLE.include? filename.match(/\.([^\.]+)$/)[1]
+			return cache_data filename, IO.read(filename), File.mtime(filename)
+		else
+			return IO.read(filename)
+		end
+	end
+	# places data into the cache, and attempts to save the data to a file name.
+	def save_file filename, data, save_to_disk = false
+		cache_data filename, data if CACHABLE.include? filename.match(/\.([^\.]+)$/)[1]
+		begin
+			IO.write filename, data if save_to_disk
+		rescue Exception => e
+			Plezi.warn("File couldn't be written (#{filename}) - file system error?")
+		end
+		data
+	end
+	# places data into the cache, under an identifier ( file name ).
+	def cache_data filename, data, mtime = Time.now
+		LOCK.synchronize { CACHE_STORE[filename] = CacheObject.new( data, mtime )  }
+		data
+	end
+	# Get data from the cache. will throw an exception if there is no data in the cache.
+	def get_cached filename
+		CACHE_STORE[filename].data # if CACHE_STORE[filename]
+	end
+
+	# returns true if the filename is cached.
+	def cached? filename
+		!CACHE_STORE[filename].nil?
+	end
+
+	# returns true if the file exists on disk or in the cache.
+	def file_exists? filename
+		(CACHE_STORE[filename] || File.exists?(filename)) ? true : false
+	end
+
+	# returns true if the file has been update since data was last cached.
+	def cache_needs_update? filename
+		return true if CACHE_STORE[filename].nil? || CACHE_STORE[filename].mtime < File.mtime(filename)
+		false
+	end
+end

data/lib/plezi/base/connections.rb

@@ -0,0 +1,33 @@
+
+module Plezi
+
+	module_function
+
+	# DANGER ZONE - Plezi Engine. the connections store
+	IO_CONNECTION_DIC = {}
+	# DANGER ZONE - Plezi Engine. the connections mutex
+	C_LOCKER = Mutex.new
+
+	# Plezi Engine, DO NOT CALL. disconnectes all active connections
+	def stop_connections
+		log 'Stopping connections'
+		C_LOCKER.synchronize {IO_CONNECTION_DIC.values.each {|c| c.timeout = -1; callback c, :on_disconnect unless c.disconnected?} ; IO_CONNECTION_DIC.clear}
+	end
+
+	# Plezi Engine, DO NOT CALL. adds a new connection to the connection stack
+	def add_connection io, params
+		connection = params[:service_type].new(io, params)
+		C_LOCKER.synchronize {IO_CONNECTION_DIC[connection.socket] = connection} if connection
+		callback(connection, :on_message)
+	end
+	# Plezi Engine, DO NOT CALL. removes a connection from the connection stack
+	def remove_connection connection
+		C_LOCKER.synchronize { IO_CONNECTION_DIC.delete connection.socket }
+	end
+
+	# clears closed connections from the stack
+	def clear_connections
+		C_LOCKER.synchronize { IO_CONNECTION_DIC.values.each {|c| callback c, :on_disconnect if c.disconnected? || c.timedout? } }
+	end
+
+end

data/lib/plezi/base/dsl.rb

@@ -0,0 +1,177 @@
+
+module Plezi
+
+	# this module contains the methods that are used as a DSL and sets up easy access to the Plezi framework.
+	#
+	# use the`listen`, `host` and `route` functions rather then accessing this object.
+	#
+	module DSL
+		module_function
+
+		@servers = {}
+		@active_router = nil
+
+		# adds a server (performs the action required by the listen method).
+		#
+		# accepts:
+		# port:: (optional) the port number for the service. if not defined, defaultes to the -p runtime argument (i.e. `./app.rb -p 8080`) or to 3000 if argument is missing. 
+		# params:: any parameter accepted by the Plezi.add_service method. defaults to: `:protocol=>Plezi::HTTPProtocol, :handler => HTTPRouter.new`
+		def listen(port, params = {})
+			# set port and arguments
+			if port.is_a?(Hash)
+				params = port
+				port = nil
+			end
+			if !port && defined? ARGV
+				if ARGV.find_index('-p')
+					port_index = ARGV.find_index('-p') + 1
+					port ||= ARGV[port_index].to_i
+					ARGV[port_index] = (port + 1).to_s
+				else
+					ARGV << '-p'
+					ARGV << '3000'
+					return listen nil, params
+				end
+			end
+			port ||= 3000
+
+			# create new service or choose existing
+			if @servers[port]
+				puts "WARNING: port aleady in use! returning existing service and attemptin to add host (maybe multiple hosts? use `host` instead)." unless params[:host]
+				@active_router = @servers[port][:handler]
+				@active_router.add_host params[:host], params
+				return @active_router
+			end
+			params[:protocol] ||= HTTPProtocol
+			@active_router = params[:handler] ||=  HTTPRouter.new # HTTPEcho #
+			@active_router.add_host params[:host], params
+			return false unless Plezi.add_service(port, params)
+			@servers[port] = params
+			@active_router
+		end
+
+		# adds a route to the last server created
+		def route(path, controller = nil, &block)
+			@active_router.add_route path, controller, &block
+		end
+
+
+		# adds a shared route to all existing services and hosts.
+		def shared_route(path, controller = nil, &block)
+			@servers.values.each {|p| p[:handler].add_shared_route path, controller, &block }
+		end
+
+		# adds a host to the last server created
+		#
+		# accepts the same parameter(s) as the `listen` command (see Plezi.add_service), except :protocol and :handler are ignored:
+		# alias:: a String or an Array of Strings which represent alternative host names (i.e. `alias: ["admin.google.com", "admin.gmail.com"]`).
+		def host(host_name, params)
+			@active_router.add_host host_name, params
+		end
+	end
+end
+
+Encoding.default_internal = 'utf-8'
+Encoding.default_external = 'utf-8'
+
+# Set a shortcut for the Plezi module.
+PL = Plezi
+
+# creates a server object and waits for routes to be set.
+# 
+# port:: the port to listen to. the first port defaults to 3000 and increments by 1 with every `listen` call. it's possible to set the first port number by running the app with the -p paramater.
+# params:: a Hash of serever paramaters, as listed in the Plezi#add_service documentation.
+#
+# The different keys in the params hash control the server's behaviour, as follows:
+#
+# host:: the host name. defaults to any host not explicitly defined (a catch-all).
+# alias:: a String or an Array of Strings which represent alternative host names (i.e. `alias: ["admin.google.com", "admin.gmail.com"]`).
+# root:: the public root folder. if this is defined, static files will be served from the location.
+# assets:: the assets root folder. defaults to nil (no assets support). if the path is defined, assets will be served from `/assets/...` (or the public_asset path defined) before any static files. assets will not be served if the file in the /public/assets folder if up to date (a rendering attempt will be made for systems that allow file writing).
+# assets_public:: the assets public uri location (uri format, NOT a file path). defaults to `/assets`. assets will be saved (or rendered) to the assets public folder and served as static files.
+# assets_callback:: a method that accepts one parameters: `request` and renders any custom assets. the method should return `false` unless it has created a response object (`response = Plezi::HTTPResponse.new(request)`) and sent a response to the client using `response.finish`.
+# save_assets:: saves the rendered assets to the filesystem, under the public folder. defaults to false.
+# templates:: the templates root folder. defaults to nil (no template support). templates can be rendered by a Controller class, using the `render` method.
+# ssl:: if true, an SSL service will be attempted. if no certificate is defined, an attempt will be made to create a self signed certificate.
+# ssl_key:: the public key for the SSL service.
+# ssl_cert:: the certificate for the SSL service.
+#
+def listen(port = nil, params = {})
+	Plezi::DSL.listen port, params
+end
+
+# adds a virtul host to the current service (the last `listen` call) or switches to an existing host within the active service.
+#
+# accepts:
+# host_name: a String with the full host name (i.e. "www.google.com" / "mail.google.com")
+# params:: any of the parameters accepted by the `listen` command, except `protocol`, `handler`, and `ssl` parameters.
+def host(host_name = false, params = {})
+	Plezi::DSL.host host_name, params
+end
+
+# adds a route to the last server object
+#
+# path:: the path for the route
+# controller:: The controller class which will accept the route.
+#
+# `path` paramaters has a few options:
+#
+# * `path` can be a Regexp object, forcing the all the logic into controller (typically using the before method).
+#
+# * simple String paths are assumed to be basic RESTful paths:
+#
+#     route "/users", Controller => route "/users/(:id)", Controller
+#
+# * routes can define their own parameters, for their own logic:
+#
+#     route "/path/:required_paramater/:required_paramater{with_format}/(:optional_paramater)/(:optional){with_format}"
+#
+# * routes can define optional or required routes with regular expressions in them:
+#
+#     route "(:locale){en|ru}/path"
+#
+# * routes which use the special '/' charecter within a parameter's format, must escape this charecter using the '\' charecter. **Notice the single quotes** in the following example:
+#
+#     route '(:math){[\d\+\-\*\^\%\.\/]}'
+#
+#   * or, with double quotes:
+#
+#     route "(:math){[\\d\\+\\-\\*\\^\\%\\.\\/]}"
+#
+# magic routes make for difficult debugging - the smarter the routes, the more difficult the debugging.
+# use with care and avoid complex routes when possible. RESTful routes are recommended when possible.
+# json serving apps are advised to use required paramaters, empty sections indicating missing required paramaters (i.e. /path///foo/bar///).
+#
+def route(path, controller = nil, &block)
+	Plezi::DSL.route(path, controller, &block)
+end
+
+# adds a route to the all the existing servers and hosts.
+#
+# accepts same options as route.
+def shared_route(path, controller = nil, &block)
+	Plezi::DSL.shared_route(path, controller, &block)
+end
+
+# finishes setup of the servers and starts them up. This will hange the proceess.
+#
+# this method is called automatically by the Plezi framework.
+#
+# it is recommended that you DO NOT CALL this method.
+# if any post shut-down actions need to be performed, use Plezi.on_shutdown instead.
+def start_services
+	return 0 if ( defined?(NO_PLEZI_AUTO_START) || defined?(BUILDING_PLEZI_TEMPLATE) || defined?(PLEZI_ON_RACK) )
+	Object.const_set "NO_PLEZI_AUTO_START", true
+	undef listen
+	undef host
+	undef route
+	undef shared_route
+	undef start_services
+	Plezi.start_services
+end
+
+# sets to start the services once dsl script is finished loading.
+at_exit { start_services } unless ( defined?(NO_PLEZI_AUTO_START) || defined?(BUILDING_PLEZI_TEMPLATE) || defined?(PLEZI_ON_RACK) )
+
+# sets a name for the process (on some systems).
+$0="Plezi (Ruby)"

data/lib/plezi/base/engine.rb

@@ -0,0 +1,85 @@
+
+module Plezi
+
+	module_function
+
+	# Plezi event cycle settings: gets how many worker threads Plezi will run.
+	def max_threads
+		@max_threads ||= 16
+	end
+	# Plezi event cycle settings: sets how many worker threads Plezi will run.
+	def max_threads= value
+		@max_threads = value
+	end
+
+	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+	#
+	# No timing methods will be called during this interval.
+	#
+	# get the current idle setting
+	def idle_sleep
+		@idle_sleep ||= 0.1
+	end
+	# Plezi event cycle settings: how long to wait for IO activity before forcing another cycle.
+	#
+	# No timing methods will be called during this interval.
+	#
+	# set the current idle setting
+	def idle_sleep= value
+		@idle_sleep = value
+	end
+
+	# Plezi Engine, DO NOT CALL. creates the thread pool and starts cycling through the events.
+	def start_services
+		# prepare threads
+		exit_flag = false
+		threads = []
+		run_every(5 , Plezi.method(:clear_connections)) #{info "Cleared inactive Connections"}
+		run_every 3600 , GC.method(:start)
+		# run_every( 1 , Proc.new() { Plezi.info "#{IO_CONNECTION_DIC.length} active connections ( #{ IO_CONNECTION_DIC.select{|k,v| v.protocol.is_a?(WSProtocol)} .length } websockets)." })
+		(max_threads).times {  Thread.new { thread_cycle until exit_flag }  }		
+
+		# Thread.new { check_connections until SERVICES.empty? }
+		#...
+		# set signal tarps
+		trap('INT'){ exit_flag = true; raise "close Plezi" }
+		trap('TERM'){ exit_flag = true; raise "close Plezi" }
+		puts 'Services running. Press ^C to stop'
+		# sleep until trap raises exception (cycling might cause the main thread to ignor signals and lose attention)
+		(sleep unless SERVICES.empty?) rescue true
+		# start shutdown.
+		exit_flag = true
+		# set new tarps
+		trap('INT'){ puts 'Forced exit.'; Kernel.exit }#rescue true}
+		trap('TERM'){ puts 'Forced exit.'; Kernel.exit }#rescue true }
+		puts 'Started shutdown process. Press ^C to force quit.'
+		# shut down listening sockets
+		stop_services
+		# disconnect active connections
+		stop_connections
+		# cycle down threads
+		info "Waiting for workers to cycle down"
+		threads.each {|t| t.join if t.alive?}
+
+		# rundown any active events
+		thread_cycle
+
+		# call shutdown callbacks
+		SHUTDOWN_CALLBACKS.each {|s| s[0].call(*s[1]) }
+		SHUTDOWN_CALLBACKS.clear
+
+		# return exit code?
+		0
+	end
+
+	# Plezi Engine, DO NOT CALL. runs one thread cycle
+	def self.thread_cycle flag = 0
+		io_reactor rescue false # stop_connections
+		true while fire_event
+		fire_timers
+
+		rescue Exception => e
+
+		error e
+	end
+end