plezi 0.9.2 → 0.10.1

data/lib/plezi/handlers/stubs.rb

@@ -94,7 +94,7 @@ module Plezi
 		end
 
 		# called immediately after a WebSocket connection has been established.
-		def on_connect
+		def on_open
 			true
 		end
 
@@ -108,7 +108,7 @@ module Plezi
 
 		# called when a disconnect packet has been recieved or the connection has been cut
 		# (ISN'T called after a disconnect message has been sent).
-		def on_disconnect
+		def on_close
 		end
 
 		# a demo event method that recieves a broadcast from instance siblings.

data/lib/plezi/helpers/http_sender.rb

@@ -0,0 +1,72 @@
+module Plezi
+	module Base
+
+		# Sends common basic HTTP responses.
+		module HTTPSender
+			module_function
+
+			######
+			## basic responses
+			## (error codes and static files)
+
+			# sends a response for an error code, rendering the relevent file (if exists).
+			def send_by_code request, response, code, headers = {}
+				begin
+					base_code_path = request.io[:params][:templates] || File.expand_path('.')
+					if defined?(::Slim) && Plezi.file_exists?(fn = File.join(base_code_path, "#{code}.html.slim"))
+						Plezi.cache_data fn, Slim::Template.new( fn ) unless Plezi.cached? fn
+						return send_raw_data request, response, Plezi.get_cached( fn ).render( self, request: request ), 'text/html', code, headers
+					elsif defined?(::Haml) && Plezi.file_exists?(fn = File.join(base_code_path, "#{code}.html.haml"))
+						Plezi.cache_data fn, Haml::Engine.new( IO.read( fn ) ) unless Plezi.cached? fn
+						return send_raw_data request, response, Plezi.get_cached( File.join(base_code_path, "#{code}.html.haml") ).render( self ), 'text/html', code, headers
+					elsif defined?(::ERB) && Plezi.file_exists?(fn = File.join(base_code_path, "#{code}.html.erb"))
+						return send_raw_data request, response, ERB.new( Plezi.load_file( fn ) ).result(binding), 'text/html', code, headers
+					elsif Plezi.file_exists?(fn = File.join(base_code_path, "#{code}.html"))
+						return send_file(request, response, fn, code, headers)
+					end
+					return true if send_raw_data(request, response, GRHttp::HTTPResponse::STATUS_CODES[code], 'text/plain', code, headers)
+				rescue Exception => e
+					Plezi.error e
+				end
+				false
+			end
+
+			# attempts to send a static file by the request path (using `send_file` and `send_raw_data`).
+			#
+			# returns true if data was sent.
+			def send_static_file request, response
+				root = request.io[:params][:root]
+				return false unless root
+				file_requested = request[:path].to_s.split('/')
+				unless file_requested.include? '..'
+					file_requested.shift
+					file_requested = File.join(root, *file_requested)
+					return true if send_file request, response, file_requested
+					return send_file request, response, File.join(file_requested, request.io[:params][:index_file])
+				end
+				false
+			end
+
+			# sends a file/cacheed data if it exists. otherwise returns false.
+			def send_file request, response, filename, status_code = 200, headers = {}
+				if Plezi.file_exists?(filename) && !::File.directory?(filename)
+					return send_raw_data request, response, Plezi.load_file(filename), MimeTypeHelper::MIME_DICTIONARY[::File.extname(filename)], status_code, headers
+				end
+				return false
+			end
+			# sends raw data through the connection. always returns true (data send).
+			def send_raw_data request, response, data, mime, status_code = 200, headers = {}
+				headers.each {|k, v| response[k] = v}
+				response.status = status_code
+				response['content-type'] = mime
+				response['cache-control'] ||= 'public, max-age=86400'					
+				response << data
+				response['content-length'] = data.bytesize
+				true
+			end##########
+
+
+		end
+
+	end
+end

data/lib/plezi/helpers/magic_helpers.rb

@@ -0,0 +1,12 @@
+module Plezi
+
+	module Base
+		module Helpers
+			# a proc that allows Hashes to search for key-value pairs while also converting keys from objects to symbols and from symbols to strings.
+			#
+			# (key type agnostic search Hash proc)
+			 HASH_SYM_PROC = Proc.new {|h,k| k = (Symbol === k ? k.to_s : k.to_s.to_sym); h[k] if h.has_key?(k) }
+		end
+	end
+
+end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.9.2"
+    VERSION = "0.10.1"
 end

data/plezi.gemspec

@@ -18,19 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "grhttp", "~> 0.0.6"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 
-  # spec.post_install_message = "Thank you for installing Plezi, the native Ruby Framework for real time web-apps."
-  spec.post_install_message = "** Deprecation Warning:\n
-  V.0.10.0 will be a major revision. It will also change the Websocket API so that it conforms to the Javascript API, making it clearer.
-
-Also, V. 0.10.0 will utilize the GReactor IO reactor and the GRHttp HTTP and Websocket server gems. Both are native Ruby, so no C or Java extentions should be introduced.
-
-This means that asynchronous tasking will now be handled by GReactor's API.
-
-Make sure to test your app before upgrading to the 0.10.0 version.
-
-Thank you for installing Plezi, the native Ruby Framework for real time web-apps."
+  spec.post_install_message = "Thank you for installing Plezi, the native Ruby Framework for real time web-apps."
+  # spec.post_install_message = "** Deprecation Warning:\n\nThank you for installing Plezi, the native Ruby Framework for real time web-apps."
 
 end

data/resources/Gemfile

@@ -8,15 +8,6 @@
 ## use rake tasks with bundle exec?
 # gem 'rake'
 
-## active support can run without rails and extends the Ruby language.
-## it might be heavy, be warned.
-## see: http://guides.rubyonrails.org/active_support_core_extensions.html
-# 
-# gem 'activesupport', :require => ['active_support', 'active_support/core_ext'] 
-## or:
-# gem 'activesupport', :require => ['active_support', 'active_support/all'] 
-
-
 ####################
 # gems for easy markup
 
@@ -26,29 +17,22 @@
 ## Sass makes CSS easy
 # gem "sass"
 
-## erb for HTML fanatics:
-# gem 'erb'
-
 ## we love Haml, even though it can be slow:
 # gem 'haml'
 
-## and maybe coffee script? (although, we just use javascript, really)
+## Coffee Script makes Javascript more fun to code.
 # gem "coffee-script"
 
 ####################
 # Internationalization
 
-## I18n is the only one I know of.
 # gem 'i18n'
 
 ####################
 # WebSocket Scaling
 
-## redis servers are used to allow websocket scaling.
-## the Controller#collect method will work only for the current process.
-## the Controller#broadcast can be configured to automatically use Redis, but some inter-process limitation apply.
-## using Redis, we can publish messages and subscribe to 'chunnels' across processes
-## (limited support for :broadcast and NO support for :collect while Redis is running).
+## Redis servers are used to allow websocket scaling.
+## Plezi can be configured to automatically use Redis for easy scaling.
 
 # gem 'redis'
 
@@ -62,21 +46,36 @@
 
 ## MongoDB is a very well known NoSQL DB
 ## https://github.com/mongodb/mongo-ruby-driver
+#
 # gem 'mongo'
+#
 ## for a performance boost, the C extentions can be used (NOT JRuby - bson_ext isn't used with JRuby).
+#
 # gem 'bson_ext'
+#
 ## you can also have a look at the Mongo Mapper ORM
 ## http://mongomapper.com
+#
 # gem 'mongo_mapper'
 
-## someone told me good things about sequel:
+## Sequel:
 ## http://sequel.jeremyevans.net/rdoc/files/README_rdoc.html
 ## http://sequel.jeremyevans.net/rdoc/files/doc/cheat_sheet_rdoc.html
 ## this seems greate, but we left out any auto-config for this one... seems to work out of the box.
+#
 # gem 'sequel'
 
 ## if you want to use ActiveRecord, uncomment the following line(s)...
 ## but first, please remember that AcriveRecord needs extra attention when multi-threading
 # gem 'activerecord', :require => 'active_record'
 # gem 'bcrypt', '~> 3.1.7'
-# gem 'standalone_migrations' # will provide better rake tasks support for ActiveRecord
+# gem 'standalone_migrations' # will more rake tasks support for ActiveRecord
+
+## active support can run without rails and extends the Ruby language.
+## it could be heavy, be warned.
+## see: http://guides.rubyonrails.org/active_support_core_extensions.html
+#
+# gem 'activesupport', :require => ['active_support', 'active_support/core_ext'] 
+## or:
+# gem 'activesupport', :require => ['active_support', 'active_support/all'] 
+

data/resources/controller.rb

@@ -107,7 +107,7 @@ class SampleController
 	end
 
 	# called immediately after a WebSocket connection has been established.
-	def on_connect
+	def on_open
 		# response.close
 		# false
 	end
@@ -125,7 +125,7 @@ class SampleController
 
 	# called when a disconnect packet has been recieved or the connection has been cut
 	# (ISN'T called after a disconnect message has been sent).
-	def on_disconnect
+	def on_close
 	end
 
 	# a demo event method that recieves a broadcast from instance siblings.

data/resources/oauth_config.rb

@@ -20,5 +20,5 @@
 # create_auth_shared_route do |service_name, auth_token, remote_user_id, remote_user_email, remote_response|
 #         # ...callback for authentication.
 #         # This callback should return the app user object or false
-#         # This callback hass access to the magic controller methods (request, cookies, etc')
+#         # This callback has access to the magic controller methods (request, cookies, etc')
 # end

data/resources/redis_config.rb

@@ -2,6 +2,8 @@
 
 if defined? Redis
 
+	Plezi::Settings.redis_channel_name = 'appsecret'
+
 	# ## Plezi Redis Automation
 	# ## ====
 	# ##

data/test/plezi_tests.rb

@@ -81,8 +81,7 @@ class TestCtrl
 	end
 	# path to test for chuncked encoding and response streaming.
 	def streamer
-		response.start_http_streaming
-		PL.callback(self, :_stream_out) { PL.callback(response, :finish) }
+		response.stream_async &method(:_stream_out)
 		true
 	end
 	def _stream_out
@@ -102,7 +101,7 @@ class TestCtrl
 	## WebSockets
 
 	# called once the websocket was connected
-	def on_connect
+	def on_open
 		response << "connected"
 	end
 
@@ -126,7 +125,7 @@ class TestCtrl
 
 	# called when a disconnect packet has been recieved or the connection has been cut
 	# (ISN'T called after a disconnect message has been sent).
-	def on_disconnect
+	def on_close
 	end
 
 	# a demo event method that recieves a broadcast from instance siblings.
@@ -243,54 +242,54 @@ module PleziTestTasks
 	def test_websocket
 		connection_test = broadcast_test = echo_test = unicast_test = false
 		begin
-			ws4 = Plezi::WebsocketClient.connect_to("wss://localhost:3030") do |msg|
-				if msg == "unicast"
+			ws4 = GRHttp::WSClient.connect_to("wss://localhost:3030") do |ws|
+				if ws.data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[false]}"
 					unicast_test = :failed
 				end
 			end
-			ws2 = Plezi::WebsocketClient.connect_to("wss://localhost:3030") do |msg|
+			ws2 = GRHttp::WSClient.connect_to("wss://localhost:3030") do |ws|
 				next unless @is_connected || !(@is_connected = true)
-				if msg == "unicast"
+				if ws.data == "unicast"
 					puts "    * Websocket unicast message test: #{RESULTS[false]}"
 					unicast_test = :failed
 					next
 				else
-					puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test = (msg == 'echo test')]}"
+					puts "    * Websocket broadcast message test: #{RESULTS[broadcast_test = (ws.data == 'echo test')]}"
 					go_test = false
 				end
 			end
-			ws3 = Plezi::WebsocketClient.connect_to("ws://localhost:3000") do |msg|
-				if msg.match /uuid: ([^s]*)/
-					ws2 << "to: #{msg.match(/^uuid: ([^s]*)/)[1]}"
-					puts "    * Websocket UUID for unicast testing: #{msg.match(/^uuid: ([^s]*)/)[1]}"
-				elsif msg == "unicast"
+			ws3 = GRHttp::WSClient.connect_to("ws://localhost:3000") do |ws|
+				if ws.data.match /uuid: ([^s]*)/
+					ws2 << "to: #{ws.data.match(/^uuid: ([^s]*)/)[1]}"
+					puts "    * Websocket UUID for unicast testing: #{ws.data.match(/^uuid: ([^s]*)/)[1]}"
+				elsif ws.data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[:waiting]}"
 					unicast_test ||= true
 				end
 			end
 			ws3 << 'get uuid'
 			puts "    * Websocket SSL client test: #{RESULTS[ws2 && true]}"
-			ws1 = Plezi::WebsocketClient.connect_to("ws://localhost:3000") do |msg|
+			ws1 = GRHttp::WSClient.connect_to("ws://localhost:3000") do |ws|
 				unless @connected
-					puts "    * Websocket connection message test: #{RESULTS[connection_test = (msg == 'connected')]}"
+					puts "    * Websocket connection message test: #{RESULTS[connection_test = (ws.data == 'connected')]}"
 					@connected = true
 					response << "echo test"
 					next
 				end
-				if msg == "unicast"
+				if ws.data == "unicast"
 					puts "    * Websocket unicast testing: #{RESULTS[false]}"
 					unicast_test = :failed
 					next
 				end
-				puts "    * Websocket echo message test: #{RESULTS[echo_test = (msg == 'echo test')]}"
+				puts "    * Websocket echo message test: #{RESULTS[echo_test = (ws.data == 'echo test')]}"
 			end
 			
 		rescue => e
 			puts "    **** Websocket tests FAILED TO RUN!!!"
 			puts e.message
 		end
-		remote = Plezi::WebsocketClient.connect_to("wss://echo.websocket.org/") {|msg| puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[msg == 'Hello websockets!']}"; response.close}
+		remote = GRHttp::WSClient.connect_to("wss://echo.websocket.org/") {|ws| puts "    * Extra Websocket Remote test (SSL: echo.websocket.org): #{RESULTS[ws.data == 'Hello websockets!']}"; response.close}
 		remote << "Hello websockets!"
 		sleep 0.5
 		[ws1, ws2, ws3, ws4, remote].each {|ws| ws.close}
@@ -301,23 +300,23 @@ module PleziTestTasks
 	end
 	def test_websocket_sizes
 			should_disconnect = false
-			ws = Plezi::WebsocketClient.connect_to("ws://localhost:3000/ws/size") do |msg|
+			ws = GRHttp::WSClient.connect_to("ws://localhost:3000/ws/size") do |ws|
 				if should_disconnect
 					puts "    * Websocket size disconnection test: #{RESULTS[false]}"
 				else
-					puts "    * Websocket message size test: got #{msg.bytesize} bytes"
+					puts "    * Websocket message size test: got #{ws.data.bytesize} bytes"
 				end
 
 			end
-			ws.on_disconnect do
+			ws.on_close do
 				puts "    * Websocket size disconnection test: #{RESULTS[should_disconnect]}"
 			end
 			str = 'a'
 			time_now = Time.now
-			6.times {|i| str = str * 2**i;puts "    * Websocket message size test: sending #{str.bytesize} bytes"; ws.send str; sleep 0.2 }
+			6.times {|i| str = str * 2**i;puts "    * Websocket message size test: sending #{str.bytesize} bytes"; ws << str; sleep 0.2 }
 			sleep (Time.now - time_now + 1)
 			should_disconnect = true
-			Plezi.ws_message_size_limit = 1024
+			Plezi::Settings.ws_message_size_limit = 1024
 			ws << str
 	end
 	def test_404
@@ -328,24 +327,24 @@ module PleziTestTasks
 		puts e
 	end
 	def test_500
-		workers = Plezi::EventMachine.count_living_workers
-		print "    * 500 internal error test: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code == '500' ]}"
-		# cause 10 more exceptions to be raised... testing thread survival.
-		10.times { putc "."; Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code }
-		putc "\n"
-		workers_after_test = Plezi::EventMachine.count_living_workers
-		puts "    * Worker survival test: #{RESULTS[workers_after_test == workers]} (#{workers_after_test} out of #{workers})"
-
-		rescue => e
-		puts "    **** 500 internal error test FAILED TO RUN!!!"
-		puts e
+		# workers = GReactor.instance_exec {@threads.select {|t| t.alive?} .count}
+		# print "    * 500 internal error test: #{RESULTS[ Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code == '500' ]}"
+		# # cause 10 more exceptions to be raised... testing thread survival.
+		# 10.times { putc "."; Net::HTTP.get_response(URI.parse "http://localhost:3000/fail" ).code }
+		# putc "\n"
+		# workers_after_test = GReactor.instance_exec {@threads.select {|t| t.alive?} .count}
+		# puts "    * Worker survival test: #{RESULTS[workers_after_test == workers]} (#{workers_after_test} out of #{workers})"
+
+		# rescue => e
+		# puts "    **** 500 internal error test FAILED TO RUN!!!"
+		# puts e
 	end
 end
 
 NO_PLEZI_AUTO_START = true
 
 PL.create_logger '/dev/null'
-# PL.max_threads = 4
+# PL::Settings.max_threads = 4
 
 listen port: 3000
 
@@ -359,7 +358,9 @@ shared_route '/some/:multi{path|another_path}/(:option){route|test}/(:id)/(:opti
 shared_route '/', TestCtrl
 
 
-Plezi::EventMachine.start Plezi.max_threads
+GRHttp.start Plezi::Settings.max_threads
+
+# start_services
 
 shoutdown_test = false
 Plezi.on_shutdown { shoutdown_test = true }
@@ -373,15 +374,7 @@ PleziTestTasks.run_tests
 
 sleep PLEZI_TEST_TIME if defined? PLEZI_TEST_TIME
 
-Plezi::DSL.stop_services
-puts "#{Plezi::EventMachine::EM_IO.count} connections awaiting shutdown."
-Plezi::EventMachine.stop_connections
-puts "#{Plezi::EventMachine::EM_IO.count} connections awaiting shutdown after connection close attempt."
-if Plezi::EventMachine::EM_IO.count > 0
-	Plezi::EventMachine.forget_connections
-	puts "#{Plezi::EventMachine::EM_IO.count} connections awaiting shutdown after connections were forgotten."
-end
-Plezi::EventMachine.shutdown
+Plezi.stop
 
 
 puts "    * Shutdown test: #{ PleziTestTasks::RESULTS[shoutdown_test] }"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.10.1
 platform: ruby
 authors:
 - Boaz Segev
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2015-07-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: grhttp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.6
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -56,33 +70,20 @@ files:
 - bin/plezi
 - lib/plezi.rb
 - lib/plezi/common/cache.rb
+- lib/plezi/common/defer.rb
 - lib/plezi/common/dsl.rb
-- lib/plezi/common/logging.rb
-- lib/plezi/eventmachine/connection.rb
-- lib/plezi/eventmachine/em.rb
-- lib/plezi/eventmachine/io.rb
-- lib/plezi/eventmachine/protocol.rb
-- lib/plezi/eventmachine/queue.rb
-- lib/plezi/eventmachine/ssl_connection.rb
-- lib/plezi/eventmachine/timers.rb
-- lib/plezi/eventmachine/workers.rb
+- lib/plezi/common/redis.rb
+- lib/plezi/common/settings.rb
+- lib/plezi/handlers/controller_core.rb
 - lib/plezi/handlers/controller_magic.rb
-- lib/plezi/handlers/http_echo.rb
-- lib/plezi/handlers/http_host.rb
 - lib/plezi/handlers/http_router.rb
-- lib/plezi/handlers/magic_helpers.rb
 - lib/plezi/handlers/route.rb
 - lib/plezi/handlers/stubs.rb
+- lib/plezi/helpers/http_sender.rb
+- lib/plezi/helpers/magic_helpers.rb
+- lib/plezi/helpers/mime_types.rb
 - lib/plezi/oauth.rb
 - lib/plezi/oauth/auth_controller.rb
-- lib/plezi/server/http.rb
-- lib/plezi/server/http_protocol.rb
-- lib/plezi/server/http_request.rb
-- lib/plezi/server/http_response.rb
-- lib/plezi/server/mime_types.rb
-- lib/plezi/server/websocket.rb
-- lib/plezi/server/websocket_client.rb
-- lib/plezi/server/ws_response.rb
 - lib/plezi/version.rb
 - plezi.gemspec
 - resources/404.erb
@@ -118,18 +119,8 @@ homepage: http://boazsegev.github.io/plezi/
 licenses:
 - MIT
 metadata: {}
-post_install_message: |-
-  ** Deprecation Warning:
-
-    V.0.10.0 will be a major revision. It will also change the Websocket API so that it conforms to the Javascript API, making it clearer.
-
-  Also, V. 0.10.0 will utilize the GReactor IO reactor and the GRHttp HTTP and Websocket server gems. Both are native Ruby, so no C or Java extentions should be introduced.
-
-  This means that asynchronous tasking will now be handled by GReactor's API.
-
-  Make sure to test your app before upgrading to the 0.10.0 version.
-
-  Thank you for installing Plezi, the native Ruby Framework for real time web-apps.
+post_install_message: Thank you for installing Plezi, the native Ruby Framework for
+  real time web-apps.
 rdoc_options: []
 require_paths:
 - lib