plezi 0.9.2 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42fdb6ed987158652982b125bfe4164b5c2015dc
-  data.tar.gz: e0ce2fd542ce59a313570197c718fe0f420a94ff
+  metadata.gz: 0a5c7776c37ebc623189d2a99863f6571fbef572
+  data.tar.gz: 82f7af02e2db159f56d3bd8ee4ce4a2cc4553aca
 SHA512:
-  metadata.gz: d04fcf22270263b548c011c0d05be50a5f04962e67e3f81a86ab2ede142312241fc0f7756c3a026d4aa8184a9da5a33c92e0c217187f355978e16ff74b8988a3
-  data.tar.gz: 6e7cf7932aec26f04663ae84a62eef18f6dcf69a471db99a1befdd67ac30b8453810949e139dfaa3d1d00f5f275f81213bd81aadf70b0426afd694115913b8c3
+  metadata.gz: efa0d7353a2e2e4e07a9c52867397731afe670e9fb51a69ba2e7b3b6f07d2ea54985a1037f50b620b06f47768f53285afb7e10023566da60eaa114f8034b64a4
+  data.tar.gz: 52fd0e21072250e92837cc85cc236c2054c664c3a86e9517c96b796baca9bb26fb7ff9a243172b28a2f477b1cc6c5b6ae51faa6f3c62311bc2f67c45852febb7

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ***
 
+Change log v.0.10.1
+
+**fix**: fixed an issue where the new Controller's inner router might route to RESTful methods that weren't defined (:show, :save, etc').
+
+**fix**: fixed an issue with the new Controller's inner router might not reset it's cache when methods are added to the controller after the service has begun.
+
+***
+
+Change log v.0.10.0
+
+**Major Revesion**:
+
+- The Plezi IO Reactor was extracted to an external gem called [GReactor](https://github.com/boazsegev/GReactor) and optimized.
+- The Plezi HTTP and Websocket Server was extracted to an external gem called [GRHttp](https://github.com/boazsegev/GRHttp) and optimized.
+- The Websocket API, implementation and engine were all revised. CAREFUL: **Old Websocket API deprecated**.
+
+**WebSocket API revisions**:
+
+- The `#on_connect` callback had been renamed to `#on_open`, for clarity and to conform with the Javascript API.
+- The `#on_disconnect` callback had been renamed to `#on_close`, for clarity and to conform with the Javascript API.
+- The `#collect` method had been deprecated due to scaling limitations it had imposed.
+- The `#broadcast` and `Controller.broadcast` methods had been altered and would no longer accept an optional block of code.
+- The Redis support had been altered and the redis connection object (if exists) is now available using `Plezi.redis_connection` instead of the older Controller method.
+
+**Settings API revisions**:
+
+- The settings API had been moved to the namespace `Plezi::Settings`.
+
+***
+
 Change log v.0.9.2
 
 **Some API deprecation notice**

data/README.md

@@ -1,20 +1,18 @@
 # Plezi, The Rack Free Ruby framework for realtime web-apps
 [![Gem Version](https://badge.fury.io/rb/plezi.svg)](http://badge.fury.io/rb/plezi)
-[![Inline docs](http://inch-ci.org/github/boazsegev/plezi.svg?branch=master)](http://inch-ci.org/github/boazsegev/plezi)
+[![Inline docs](http://inch-ci.org/github/boazsegev/plezi.svg?branch=master)](http://www.rubydoc.info/gems/plezi/)
 
 > People who are serious about their frameworks, should write their own servers...
 
-Find more info on [Plezi's framework, web server and websocket documentation](http://www.rubydoc.info/gems/plezi/)
+Find more info on [Plezi's framework documentation](http://www.rubydoc.info/gems/plezi/)
 
-## About the Plezi framework \ server
+## About the Plezi framework
 
 Plezi is an easy to use Ruby Websocket Framework, with full RESTful routing support and HTTP streaming support. It's name comes from the word "fun" in Haitian, since Plezi is really fun to work with and it keeps our code clean and streamlined.
 
 Plezi works as an asynchronous multi-threaded Ruby alternative to a Rack/Rails/Sintra/Faye/EM-Websockets combo. It's also great as an alternative to socket.io, allowing for both websockets and long pulling.
 
-Plezi contains an object-oriented server, divided into parts that can be changed/updated and removed easily and dynamically. This allows - much like Node.js - native WebSocket support (and, if you would like to write your own Protocol or Handler, native SMPT or any other custom protocol you might wish to implement).
-
-You can follow our [tutorial to write your first Plezi Chatroom](http://boazsegev.github.io/plezi/websockets.html) - but it's better to start with this readme and explore the WebSockets example given here.
+Plezi runs over the [GRHttp server](https://github.com/boazsegev/GRHttp), which is a pure Ruby HTTP and Websocket Generic Server build using [GReactor](https://github.com/boazsegev/GReactor) - a multi-threaded pure ruby alternative to EventMachine with basic process forking support (enjoy it, if your code is scaling ready).
 
 ## Installation
 
@@ -23,6 +21,7 @@ Add this line to your application's Gemfile:
 ```ruby
 gem 'plezi'
 ```
+
 Or install it yourself as:
 
     $ gem install plezi
@@ -33,7 +32,9 @@ to create a new barebones app using the Plezi framework, run from terminal:
 
     $ plezi new appname
 
-That's it, now you have a ready to use basic web server (with some demo code). If you're on MacOS or linux you can simply double click the `appname` script file in the `appname` folder. Or, from the terminal, you can type:
+That's it, now you have a ready to use basic web server (with some demo code, such as a websocket chatroom).
+
+If you're on MacOS or linux you can simply double click the `appname` script file in the `appname` folder. Or, from the terminal, you can type:
 
     $ cd appname
     $ ./appname # ( or: plezi s )
@@ -44,11 +45,11 @@ the default first port for the app is 3000. you can set the first port to listen
 
     $ ./appname -p 80
 
-you now have a smart framework app that will happily eat any gem you feed it. it responds extra well to Haml, Sass and Coffee-Script, which you can enable in it's Gemfile.
+you now have a smart framework app that will happily assimilate any gem you feed it. it responds extra well to Haml, Sass and Coffee-Script, which you can enable in it's Gemfile.
 
 ## Barebones Web Service
 
-this example is basic, useless, but required for every doc out there...
+This example is basic, useless, but required for every doc out there...
 
 "Hello World!" in 3 lines - try it in irb (exit irb to start server):
 
@@ -56,11 +57,11 @@ this example is basic, useless, but required for every doc out there...
 		listen
 		route(/.?/) { |req, res| res << "Hello World!" }
 
-After you exited irb, the Plezi server started up. go to http://localhost:3000/ and see it run :)
+After you exit irb, the Plezi server will start up. Go to http://localhost:3000/ and see it run :)
 
 ## Plezi Controller classes
 
-One of the best things about the Plezi is it's ability to take in any class as a controller class and route to the classes methods with special support for RESTful methods (`index`, `show`, `new`, `save`, `update`, `delete`, `before` and `after`) and for WebSockets (`pre_connect`, `on_connect`, `on_message(data)`, `on_disconnect`, `broadcast`, `collect`):
+One of the best things about the Plezi is it's ability to take in any class as a controller class and route to the classes methods with special support for RESTful methods (`index`, `show`, `new`, `save`, `update`, `delete`, `before` and `after`) and for WebSockets (`pre_connect`, `on_open`, `on_message(data)`, `on_close`, `broadcast`, `unicast`, `on_broadcast(data)`):
 
         require 'plezi'
 
@@ -77,11 +78,11 @@ Except for WebSockets, returning a String will automatically add the string to t
 
 Controllers can even be nested (order matters) or have advanced uses that are definitly worth exploring.
 
-**please read the demo code for Plezi::StubRESTCtrl and Plezi::StubWSCtrl to learn more.**
+\* please read the demo code for Plezi::StubRESTCtrl and Plezi::StubWSCtrl to learn more. Also, read more about the [GRHttp server](GRHttp websocket and HTTP server) at the core of Plezi to get more information about the amazing [HTTPRequest](http://www.rubydoc.info/gems/grhttp/0.0.6/GRHttp/HTTPRequest) and [HTTPResponse](http://www.rubydoc.info/gems/grhttp/GRHttp/HTTPResponse) objects.
 
 ## Native Websocket and Redis support
 
-Plezi Controllers have access to native websocket support through the `pre_connect`, `on_connect`, `on_message(data)`, `on_disconnect`, `broadcast` and `collect` methods.
+Plezi Controllers have access to native websocket support through the `pre_connect`, `on_open`, `on_message(data)`, `on_close`, `broadcast` and `unicast` methods.
 
 Here is some demo code for a simple Websocket broadcasting server, where messages sent to the server will be broadcasted back to all the **other** active connections (the connection sending the message will not recieve the broadcast).
 
@@ -128,15 +129,18 @@ method names starting with an underscore ('_') will NOT be made public by the ro
 
 Plezi comes with native HTTP streaming support, alowing you to use Plezi Events and Timers to send an Asynchronous response.
 
-Let's make the classic 'Hello World' use HTTP Streaming and Asynchronous Plezi Events:
+Let's make the classic 'Hello World' use HTTP Streaming:
 
 ```ruby
         require 'plezi'
 
         class Controller
             def index
-                response.start_http_streaming
-                PL.callback(response, :send, "Hello World") { response.finish }
+                response.stream_async do
+                    sleep 0.5
+                    response << "Hello ";
+                    response.stream_async{ sleep 0.5; response << "World" }
+                end
                 true
             end
         end
@@ -145,7 +149,9 @@ Let's make the classic 'Hello World' use HTTP Streaming and Asynchronous Plezi E
         route '*' , Controller
 ```
 
-Notice the easy use of Asynchronous Events using the PL#callback method. The optional block passed to this method (`response.finish`) will be executed only after the asynchronous call for the response#send method with the "Hello World" argument has completed.
+Notice you can nest calls to the `response.stream_async` method, allowing you to breakdown big blocking tasks into smaller chunks. `response.stream_async` will return immediately, scheduling the task for background processing.
+
+You can also handle other tasks asynchronously using the [GReactor API](http://www.rubydoc.info/gems/greactor)'s.
 
 More on asynchronous events and timers later.
 
@@ -153,7 +159,7 @@ More on asynchronous events and timers later.
 
 Plezi supports magic routes, in similar formats found in other systems, such as: `route "/:required/(:optional_with_format){[\\d]*}/(:optional)", Plezi::StubRESTCtrl`.
 
-Plezi assummes all simple string routes to be RESTful routes with the parameter `:id` ( `"/user" == "/user/(:id)"` ).
+Plezi assummes all simple routes to be RESTful routes with the parameter `:id` ( `"/user" == "/user/(:id)"` ).
 
     require 'plezi'
     listen
@@ -172,7 +178,7 @@ now visit:
 
 ## Plezi Virtual Hosts
 
-Plezi can be used to create virtual hosts for the same service:
+Plezi can be used to create virtual hosts for the same service, allowing you to handle different domains and subdomains with one app:
 
     require 'plezi'
     listen
@@ -203,7 +209,7 @@ Now visit:
 
 ## Plezi Logging
 
-The Plezi module (also `PL`) has methods to help with logging as well as the support you already noticed for dynamic routes, dynamic services and more.
+The Plezi module (also `PL`) delegates to the GReactor methods, helping with logging as well as the support you already noticed for dynamic routes, dynamic services and more.
 
 Logging:
 
@@ -211,6 +217,7 @@ Logging:
 
     # simple logging of strings
     PL.info 'log info'
+    GReactor.info 'This is the same, but more direct.'
     PL.warn 'log warning'
     PL.error 'log error'
     PL.fatal "log a fatal error (shuoldn't be needed)."
@@ -223,9 +230,11 @@ Logging:
         PL.error e
     end
 
+Please notice it is faster to use the GReactor API directly when using API that is delegated to GReactor.
+
 ## Plezi Events and Timers
 
-The Plezi module (also `PL`) also has methods to help with asynchronous tasking, callbacks, timers and customized shutdown cleanup.
+The Plezi module (also `PL`) also delegates to the [GReactor's API](http://www.rubydoc.info/gems/greactor/GReactor) to help with asynchronous tasking, callbacks, timers and customized shutdown cleanup.
 
 Asynchronous callbacks (works only while services are active and running):
 
@@ -236,14 +245,17 @@ Asynchronous callbacks (works only while services are active and running):
     end
 
     # shutdown callbacks
-    PL.on_shutdown(Kernel, :my_shutdown_proc, Time.now) { puts "this will run after shutdown." }
-    PL.on_shutdown() { puts "this will run too." }
+    GReactor.on_shutdown(Kernel, :my_shutdown_proc, Time.now) { puts "this will run after shutdown." }
+    GReactor.on_shutdown() { puts "this will run too." }
 
     # a timer
-    PL.run_after 2, -> {puts "this will wait 2 seconds to run... too late. for this example"}
+    GReactor.run_after 2, -> {puts "this will wait 2 seconds to run... too late. for this example"}
 
     # an asynchronous method call with an optional callback block
-    PL.callback(Kernel, :puts, "Plezi will start eating our code once we exit terminal.") {puts 'first output finished'}
+    GReactor.callback(Kernel, :puts, "Plezi will start eating our code once we exit terminal.") {puts 'first output finished'}
+
+    GReactor.run_async {puts "notice that the background tasks will only start once the Plezi's engine is running."}
+    GReactor.run_async {puts "exit Plezi to observe the shutdown callbacks."}
 
 ## Re-write Routes
 
@@ -313,12 +325,6 @@ As you can see in the example above, Plezi supports Proc routes as well as Class
 
 Please notice that there are some differences between the two. Proc routes less friedly, but plenty powerful and are great for custom 404 error handling.
 
-## Plezi Settings
-
-Plezi is ment to be very flexible. please take a look at the Plezi Module for settings you might want to play with (max_threads, idle_sleep, create_logger) or any monkey patching you might enjoy.
-
-Feel free to fork or contribute. right now I am one person, but together we can make something exciting that will help us enjoy Ruby in this brave new world and (hopefully) set an example that will induce progress in the popular mainstream frameworks such as Rails and Sinatra.
-
 ## OAuth2 and other Helpers
 
 Plezi has a few helpers that help with common tasks.
@@ -366,6 +372,13 @@ Plezi has a some more goodies under the hood.
 
 Whether such goodies are part of the Plezi-App Template (such as rake tasks for ActiveRecord without Rails) or part of the Plezi Framework core (such as descried in the Plezi::ControllerMagic documentation: #flash, #url_for, #render, #send_data, etc'), these goodies are fun to work with and make completion of common tasks a breeze.
 
+
+## Plezi Settings
+
+Plezi is meant to be very flexible. please take a look at the Plezi Module for settings you might want to play with (max_threads, idle_sleep, create_logger) or any monkey patching you might enjoy.
+
+Feel free to fork or contribute. right now I am one person, but together we can make something exciting that will help us enjoy Ruby in this brave new world and (hopefully) set an example that will induce progress in the popular mainstream frameworks such as Rails and Sinatra.
+
 ## Contributing
 
 1. Fork it ( https://github.com/boazsegev/plezi/fork )

data/bin/plezi

@@ -76,9 +76,9 @@ class AppTemplate
 		# set up config files
 		app_tree["config"] ||= {}
 		app_tree["config"]["oauth.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"oauth_config.rb"),  __FILE__))
-		app_tree["config"]["db_active_record.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_ac_config.rb"),  __FILE__))
-		app_tree["config"]["db_sequel.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_sequel_config.rb"),  __FILE__))
-		app_tree["config"]["db_datamapper.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_dm_config.rb"),  __FILE__))
+		app_tree["config"]["active_record.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_ac_config.rb"),  __FILE__))
+		app_tree["config"]["sequel.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_sequel_config.rb"),  __FILE__))
+		app_tree["config"]["datamapper.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"db_dm_config.rb"),  __FILE__))
 		app_tree["config"]["haml.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"haml_config.rb"),  __FILE__))
 		app_tree["config"]["i18n.rb"] ||= IO.read(::File.expand_path(File.join("..", "..", "resources" ,"i18n_config.rb"),  __FILE__))
 		app_tree["config"]["redis.rb"] ||= (IO.read(::File.expand_path(File.join("..", "..", "resources" ,"redis_config.rb"),  __FILE__))).gsub('appsecret', "#{ARGV[1]}_#{SecureRandom.hex}")

data/lib/plezi.rb

@@ -2,73 +2,51 @@
 
 require 'singleton'
 require 'pathname'
-require 'logger'
-require 'socket'
-require 'openssl'
-require 'strscan'
 require 'base64'
 require 'digest/sha1'
 require 'securerandom'
 require 'time'
 require 'json'
+require 'yaml'
 require 'uri'
 require 'set'
 
+# GRHttp servet
+require 'grhttp'
+
+
 ## erb templating
 begin
 	require 'erb'
-rescue Exception => e
-	
+rescue => e
+
 end
 
 ### version
 
 require "plezi/version"
 
-### common helpers
+### common
 
-require 'plezi/common/logging.rb'
+require 'plezi/common/defer.rb'
 require 'plezi/common/cache.rb'
 require 'plezi/common/dsl.rb'
+require 'plezi/common/redis.rb'
+require 'plezi/common/settings.rb'
 
-### event machine
-
-require "plezi/eventmachine/em.rb"
-
-require 'plezi/eventmachine/queue.rb'
-require 'plezi/eventmachine/workers.rb'
-require 'plezi/eventmachine/timers.rb'
-require 'plezi/eventmachine/io.rb'
-require 'plezi/eventmachine/protocol.rb'
-require 'plezi/eventmachine/connection.rb'
-require 'plezi/eventmachine/ssl_connection.rb'
-
-### http and websocket server
-
-
-require 'plezi/server/mime_types.rb'
-
-require 'plezi/server/http.rb'
-require 'plezi/server/http_protocol.rb'
-require 'plezi/server/http_request.rb'
-require 'plezi/server/http_response.rb'
-
-require 'plezi/server/websocket.rb'
-require 'plezi/server/ws_response.rb'
-
-### websocket client
-require 'plezi/server/websocket_client.rb'
-### Handlers / Framework
+### helpers
 
-require "plezi/handlers/http_echo"
-require "plezi/handlers/http_host"
-require "plezi/handlers/http_router"
+require 'plezi/helpers/http_sender.rb'
+require 'plezi/helpers/magic_helpers.rb'
+require 'plezi/helpers/mime_types.rb'
 
-require "plezi/handlers/controller_magic"
-require "plezi/handlers/magic_helpers"
-require "plezi/handlers/route"
 
-require "plezi/handlers/stubs"
+### HTTP and WebSocket Handlers
+require 'plezi/handlers/http_router.rb'
+require 'plezi/handlers/route.rb'
+require 'plezi/handlers/controller_magic.rb'
+require 'plezi/handlers/controller_core.rb'
+require 'plezi/handlers/stubs.rb'
 
 
 ##############################################################################

data/lib/plezi/common/defer.rb

@@ -0,0 +1,21 @@
+
+module Plezi
+
+	module_function
+
+	# Defers any missing methods to the GReactor Library.
+	def method_missing name, *args, &block
+		return super unless REACTOR_METHODS.include? name
+		::GReactor.send name, *args, &block
+	end
+	# Defers any missing methods to the GReactor Library.
+	def respond_to_missing?(name, include_private = false)
+		REACTOR_METHODS.include?(name) or super
+	end
+
+	protected
+
+	REACTOR_METHODS = ::GReactor.public_methods(false)
+
+end
+

data/lib/plezi/common/dsl.rb

@@ -1,109 +1,129 @@
 
 module Plezi
 
-	# holds methods that are called by the DSL.
-	#
 	# this isn't part of the public API.
-	module DSL
-		module_function
+	module Base
 
-		# this module contains the methods that are used as a DSL and sets up easy access to the Plezi framework.
+		# holds methods that are called by the DSL.
 		#
-		# use the`listen`, `host` and `route` functions rather then accessing this object.
-		#
-		@servers = {}
-		@active_router = nil
-
-		# 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)
-			@listeners.values.each {|p| (defined?(PLEZI_ON_RACK) ? p[:handler] : p.params[: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
-
-		# Rack application model support
-
-		# Plezi dresses up for Rack - this is a watered down version missing some features (such as flash and WebSockets).
-		# a full featured Plezi app, with WebSockets, requires the use of the Plezi server
-		# (the built-in server)
-		def call env
-			raise "No Plezi Services" unless @listeners && @listeners.any?
-
-			# re-encode to utf-8, as it's all BINARY encoding at first
-			env['rack.input'].rewind
-			env['rack.input'] = StringIO.new env['rack.input'].read.encode('utf-8', 'binary', invalid: :replace, undef: :replace, replace: '')		 	
-			env.each do |k, v|
-				if k.to_s.match /^[A-Z]/
-					if v.is_a?(String) && !v.frozen?
-						v.force_encoding('binary').encode!('utf-8', 'binary', invalid: :replace, undef: :replace, replace: '') unless v.force_encoding('utf-8').valid_encoding?
+		# this isn't part of the public API.
+		module DSL
+			module_function
+
+			# 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.
+			#
+			@servers = {}
+			@active_router = nil
+
+
+			# public API to add a service to the framework.
+			# accepts a Hash object with any of the following options (Hash keys):
+			# port:: port number. defaults to 3000 or the port specified when the script was called.
+			# 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 two parameters: (request, response) and renders any custom assets. the method should return `false` unless it had set the response.
+			# 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.
+			#
+			# some further options, which are unstable and might be removed in future versions, are:
+			# protocol:: the protocol objects (usually a class, but any object answering `#call` will do).
+			# handler:: an optional handling object, to be called upon by the protocol (i.e. #on_message, #on_connect, etc'). this option is used to allow easy protocol switching, such as from HTTP to Websockets. 
+			#
+			# Duringn normal Plezi behavior, the optional `handler` object will be returned if `listen` is called more than once for the same port.
+			#
+			# assets:
+			#
+			# assets support will render `.sass`, `.scss` and `.coffee` and save them as local files (`.css`, `.css`, and `.js` respectively)
+			# before sending them as static files.
+			#
+			# templates:
+			#
+			# ERB, Slim and Haml are natively supported.
+			#
+			# @returns [Plezi::Router]
+			#
+			def listen parameters = {}
+				# update default values
+				parameters[:index_file] ||= 'index.html'
+				parameters[:assets_public] ||= '/assets'
+				parameters[:assets_public].chomp! '/'
+
+				#keeps information of past ports.
+				@listeners ||= {}
+				@listeners_locker = Mutex.new
+
+				# check if the port is used twice.
+				@listeners_locker.synchronize do
+					if @listeners[parameters[:port]]
+						puts "WARNING: port aleady in use! returning existing service and attemptin to add host (maybe multiple hosts? use `host` instead)."
+						@active_router = @listeners[parameters[:port]].params[:http_handler]
+						@active_router.add_host parameters[:host], parameters if @active_router.is_a?(HTTPRouter)
+						return @active_router
 					end
 				end
-			end
-			# re-key params
-			# new_params = {}
-			# env[:params].each {|k,v| HTTP.add_param_to_hash k, v, new_params}
-			# env[:params] = new_params
+				@listeners[parameters[:port]] = parameters
 
-			# make hashes magical
-			make_hash_accept_symbols(env)
+				# make sure the protocol exists.
+				parameters[:upgrade_handler] = parameters[:http_handler] = HTTPRouter.new
 
-			# use Plezi Cookies
-			env['rack.request.cookie_string'] = env['HTTP_COOKIE']
-			env['rack.request.cookie_hash'] = Plezi::Cookies.new.update(env['rack.request.cookie_hash'] || {})
+				GRHttp.listen parameters
+				# set the active router to the handler or the protocol.
+				@active_router = parameters[:http_handler]
+				@active_router.add_host(parameters[:host], parameters)
 
-			# chomp path
-			env['PATH_INFO'].chomp! '/'
-
-			# get response
-			response = @listeners.first[1][:handler].call env
+				# return the current handler or the protocol..
+				@active_router
+			end
+			# adds a route to the last server created
+			def route(path, controller = nil, &block)
+				raise "Must define a listener before adding a route - use `Plezi.listen`." unless @active_router
+				@active_router.add_route path, controller, &block
+			end
 
-			return response if response.is_a?(Array)
 
-			return [404, {}, ['not found']] if response === true
+			# adds a shared route to all existing services and hosts.
+			def shared_route(path, controller = nil, &block)
+				raise "Must have created at least one Pleze service before calling `shared_route` - use `Plezi.listen`." unless @listeners
+				@listeners.values.each {|p| p[:http_handler].add_shared_route path, controller, &block }
+			end
 
-			response.prep_rack
-			headers = response.headers
-			# headers.delete 'transfer-encoding'
-			# headers.delete 'connection'
-			# set cookie headers
-			unless response.cookies.empty?
-				headers['Set-Cookie'] = []
-				response.cookies.each {|k,v| headers['Set-Cookie'] << ("#{k.to_s}=#{v.to_s}")}
+			# 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)
+				raise "Must define a listener before adding a route - use `Plezi.listen`." unless @active_router
+				@active_router.add_host host_name, params
 			end
-			[response.status, headers, response.body]
-		end
 
-		# tweeks a hash object to read both :symbols and strings (similar to Rails but without).
-		def make_hash_accept_symbols hash
-			@magic_hash_proc ||= Proc.new do |hs,k|
-				if k.is_a?(Symbol) && hs.has_key?( k.to_s)
-					hs[k.to_s]
-				elsif k.is_a?(String) && hs.has_key?( k.to_sym)
-					hs[k.to_sym]
-				elsif k.is_a?(Numeric) && hs.has_key?(k.to_s.to_sym)
-					hs[k.to_s.to_sym]
+
+			# tweeks a hash object to read both :symbols and strings (similar to Rails but without).
+			def make_hash_accept_symbols hash
+				@magic_hash_proc ||= Proc.new do |hs,k|
+					if k.is_a?(Symbol) && hs.has_key?( k.to_s)
+						hs[k.to_s]
+					elsif k.is_a?(String) && hs.has_key?( k.to_sym)
+						hs[k.to_sym]
+					elsif k.is_a?(Numeric) && hs.has_key?(k.to_s.to_sym)
+						hs[k.to_s.to_sym]
+					end
 				end
-			end
-			hash.default_proc = @magic_hash_proc
-			hash.values.each do |v|
-				if v.is_a?(Hash)
-					make_hash_accept_symbols v
+				hash.default_proc = @magic_hash_proc
+				hash.values.each do |v|
+					if v.is_a?(Hash)
+						make_hash_accept_symbols v
+					end
 				end
 			end
 		end
-
 	end
 end
 
@@ -116,7 +136,7 @@ PL = Plezi
 # shortcut for Plezi::DSL.listen.
 #
 def listen(params = {})
-	Plezi::DSL.listen params
+	Plezi::Base::DSL.listen params
 end
 
 # adds a virtul host to the current service (the last `listen` call) or switches to an existing host within the active service.
@@ -125,7 +145,7 @@ end
 # 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
+	Plezi::Base::DSL.host host_name, params
 end
 
 # adds a route to the last server object
@@ -162,14 +182,14 @@ end
 # json serving apps are advised to use required parameters, empty sections indicating missing required parameters (i.e. /path///foo/bar///).
 #
 def route(path, controller = nil, &block)
-	Plezi::DSL.route(path, controller, &block)
+	Plezi::Base::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)
+	Plezi::Base::DSL.shared_route(path, controller, &block)
 end
 
 # defines a method with a special name, such as "humens.txt".
@@ -199,7 +219,11 @@ def start_services
 	undef route
 	undef shared_route
 	undef start_services
-	Plezi::DSL.start_services
+	puts "Starting Plezi #{Plezi::VERSION} Services using the GRHttp #{GRHttp::VERSION} server."
+	puts "Press ^C to exit."
+	GReactor.on_shutdown { puts "Plezi shutdown. It was fun to serve you."  }
+	GReactor.start unless GReactor.running?
+	GReactor.join { puts "\r\nStarting shutdown sequesnce. Press ^C to force quit."}
 end
 
 # restarts the Plezi app with the same arguments as when it was started.