plezi 0.7.7 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 549ca7646d6226a6beb69854ecd8076fba8fbd62
-  data.tar.gz: 52fa9fe134cbcbb7bdd018e1c0d36d9cd0bcc7f9
+  metadata.gz: 1850b2cae3cd76cdda78e0c52b8437c923625085
+  data.tar.gz: 671b9720bea6f662c77cc7806ecd86cd5bb0c7c7
 SHA512:
-  metadata.gz: 5833877cd84d581d347d97ee28bc7fb8b82c8f702d11f5f0989a2aa12c2a21507103c147af928ad929020683d3e6219661a09267a413e36ce3b9e9b8976f328f
-  data.tar.gz: d322ad5cfd6de248e5f018b0de2fa98289b8f0753aaa10b2cee9599c95fd30b0edbeebb235c7d573f3c03eed7766cb2cb4d455c78a0dfc8101c64dbbca16cf0b
+  metadata.gz: 0f9083419bd7c5dcd3f10dfa1004e247b8960e711a85568546a5cfd59643bca952b042f1a3db9e9c9cac763a90da8e84e69f101e265fc5809a5dc265d8e21552
+  data.tar.gz: aea670217030a98ad2e3329ceb65ef59b18356535d71c9c75bd510ec098e26dc95079e627ea04aaee593da0c71293caa1e8405760d36ed1b65afafc6edd6e48e

data/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ***
 
+Change log v.0.8.1
+
+**fix**: fixed an issue that silently prevented SSL connections from working properly. SSL was mistakenly disabled and normal connections were attempted. This issue should have cause a no-service situation, as attempting to connect using SSL to a non-SSL connection would fail.
+
+**fix**: fixed Websocket connections. An extra EOL marker at the end of the HTTP upgrade responce caused websockets to fail. The excess new line marker was removed.
+
+***
+
+Change log v.0.8.0
+
+**Refactoring**: core code was refractored. Older code __might__ not work.
+
+Most apps should be able to upgrade with no issues.
+
+**Rack support might be broken** (again)... Rack support has changed and it's probably boken. It might come back, and it might not - it was originally only for testing. Plezi is a pure Ruby Rack alternative. It runs it's own web server (since, unlike Rack, the response objects are part of the server and this allows for a whole lot of magic and concurrency to happen). I hadn't had the time to test the Rack support under the new code.
+
+**Events API changes**: the method Plezi.push_event has been removed. Plezi.run_async and Plezi.callback are the preffered methods to be used for event handling.
+
+**Timers API changes**: The API for timed events has changed. It is now both more streamlined and allows setting a repeat limit for events that repeat themselves (i.e. schedule an event to repeat every 60 seconds and limit it to perform only 5 times).
+
+**fix**: Fixed an issue with attachments. Attachments were mistakenly enforced to comply with UTF-8 encoding, preventing binary attachments from successfully uploading.
+
+unstable API warning - **Effects only advanced users**: v.0.8.0 is a time for change. The regular API (the DSL and some Plezi helpers) will remain stable (and if it breaks, we will fix it), but the core API - which some users might have used even though they probably shouldn't have - will change.
+
+***
+
 Change log v.0.7.7
 
 **fix**: fixed a header issue in the HTTPResponse that prevented websocket connections.

data/README.md

@@ -153,7 +153,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 woth the parameter `:id` ( `"/user" == "/user/(:id)"` ).
+Plezi assummes all simple string routes to be RESTful routes with the parameter `:id` ( `"/user" == "/user/(:id)"` ).
 
     require 'plezi'
     listen
@@ -232,7 +232,7 @@ Asynchronous callbacks (works only while services are active and running):
     require 'plezi'
 
     def my_shutdown_proc time_start
-        puts "Services were running for #{Time.now - time_start} ms."
+        puts "Services were running for #{Time.now - time_start} seconds."
     end
 
     # shutdown callbacks
@@ -321,7 +321,7 @@ Feel free to fork or contribute. right now I am one person, but together we can
 
 ## Contributing
 
-1. Fork it ( https://github.com/boazsegev/plezi-server/fork )
+1. Fork it ( https://github.com/boazsegev/plezi/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/plezi.rb

@@ -13,28 +13,51 @@ require 'time'
 require 'json'
 require 'uri'
 require 'set'
+
+## erb templating
+begin
+	require 'erb'
+rescue Exception => e
+	
+end
+
 ### version
 
 require "plezi/version"
 
+### common helpers
+
+require 'plezi/common/logging.rb'
+require 'plezi/common/cache.rb'
+require 'plezi/common/dsl.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'
 
-### Server requirements
+### http and websocket server
 
-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/mime_types.rb'
 
-require "plezi/server/helpers/http"
-require "plezi/server/helpers/mime_types"
+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/protocols/websocket"
-require 'plezi/server/protocols/ws_response'
+require 'plezi/server/websocket.rb'
+require 'plezi/server/ws_response.rb'
+
+### Handlers / Framework
 
-## Server-Framework Bridges
 require "plezi/handlers/http_echo"
 require "plezi/handlers/http_host"
 require "plezi/handlers/http_router"
@@ -45,30 +68,6 @@ 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
-
-
 
 ##############################################################################
 #

data/lib/plezi/common/cache.rb

@@ -0,0 +1,94 @@
+
+module Plezi
+
+	# File and Object Caching for Plezi
+	module Cache
+		# contains the cached data, in the format: CACHE_STORE["filename"] = CacheObject
+		CACHE_STORE = {}
+		CACHE_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
+			CACHE_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
+
+		# Remove data from the cache, if it exists.
+		def clear_cached filename
+			CACHE_LOCK.synchronize { CACHE_STORE.delete filename } # if CACHE_STORE[filename]
+		end
+
+		# clears all cached data.
+		def clear_cache! filename
+			CACHE_LOCK.synchronize { CACHE_STORE.clear } # 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
+
+	public
+
+	extend Plezi::Cache
+end

data/lib/plezi/{base → common}/dsl.rb

@@ -1,55 +1,19 @@
 
 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.
+	# holds methods that are called by the DSL.
 	#
+	# 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
 
-		# 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
@@ -58,7 +22,7 @@ module Plezi
 
 		# 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 }
+			@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
@@ -68,36 +32,91 @@ module Plezi
 		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?
+					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
+
+			# make hashes magical
+			make_hash_accept_symbols(env)
+
+			# 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'] || {})
+
+			# chomp path
+			env['PATH_INFO'].chomp! '/'
+
+			# get response
+			response = @listeners.first[1][:handler].call env
+
+			return response if response.is_a?(Array)
+
+			return [404, {}, ['not found']] if response === true
+
+			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}")}
+			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]
+				end
+			end
+			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
 
 Encoding.default_internal = 'utf-8'
 Encoding.default_external = 'utf-8'
 
-# Set a shortcut for the Plezi module.
+# PL is a shortcut for the Plezi module, so that `PL == Plezi`.
 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 parameters, 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
+# shortcut for Plezi.listen.
+#
+def listen(params = {})
+	Plezi::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.
@@ -180,7 +199,7 @@ def start_services
 	undef route
 	undef shared_route
 	undef start_services
-	Plezi.start_services
+	Plezi::DSL.start_services
 end
 
 # restarts the Plezi app with the same arguments as when it was started.
@@ -193,7 +212,7 @@ 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).
+# sets information to be used when restarting
 $PL_SCRIPT = $0
 $PL_ARGV = $*.dup
-$0="Plezi (Ruby)"
+# $0="Plezi (Ruby)"