plezi 0.7.7 → 0.8.1

data/lib/plezi/server/{protocols/ws_response.rb → ws_response.rb}

@@ -21,22 +21,53 @@ module Plezi
 			@request, @service = request,request.service
 		end
 
-		# pushes data to the body of the response. this is the preffered way to add data to the response.
+		# sends data through the websocket connection in a non-blocking way.
+		#
+		# Plezi will try a best guess at the type of the data (binary vs. clear text).
+		#
+		# This should be the preferred way.
 		def << str
 			service.send_nonblock self.class.frame_data(str.dup)
 			self
 		end
 
-		# sends the response object. headers will be frozen (they can only be sent at the head of the response).
+		# sends data through the websocket connection in a blocking way.
+		#
+		# Plezi will try a best guess at the type of the data (binary vs. clear text).
 		#
-		# the response will remain open for more data to be sent through (using `response << data` and `response.send`).
 		def send str
-			service.send_nonblock self.class.frame_data(str.dup)
+			service.send self.class.frame_data(str.dup)
+			self
+		end
+		# sends binary data through the websocket connection in a blocking way.
+		#
+		def binsend str
+			service.send self.class.frame_data(str.dup, 2)
+			self
+		end
+		# sends clear text data through the websocket connection in a blocking way.
+		#
+		def txtsend str
+			service.send self.class.frame_data(str.dup, 1)
+			self
 		end
 
+
 		# makes sure any data held in the buffer is actually sent.
 		def flush
 			service.flush
+			self
+		end
+
+		# pings the connection
+		def ping
+			service.send_nonblock self.class.frame_data('', 9)
+			self
+		end
+		# pings the connection
+		def pong
+			service.send_nonblock self.class.frame_data('', 10)
+			self
 		end
 
 		# sends any pending data and closes the connection.
@@ -49,10 +80,10 @@ module Plezi
 		def self.frame_data data, op_code = nil, fin = true
 			# set up variables
 			frame = ''.force_encoding('binary')
-			op_code ||= data.encoding.name == 'UTF-8' ? 1 : 2
+			op_code ||= (data.encoding.name == 'UTF-8' ? 1 : 2)
 			data.force_encoding('binary')
 
-			# fragment big data chuncks into smaller frames
+			# fragment big data chuncks into smaller frames - op-code reset for 0 for all future frames.
 			[frame << frame_data(data.slice!(0..1048576), op_code, false), op_code = 0] while data.length > 1048576
 
 			# apply extenetions to the frame
@@ -77,16 +108,3 @@ module Plezi
 		end
 	end
 end
-
-
-######
-## example requests
-
-# GET / HTTP/1.1
-# Host: localhost:2000
-# Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
-# Cookie: user_token=2INa32_vDgx8Aa1qe43oILELpSdIe9xwmT8GTWjkS-w
-# User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10) AppleWebKit/600.1.25 (KHTML, like Gecko) Version/8.0 Safari/600.1.25
-# Accept-Language: en-us
-# Accept-Encoding: gzip, deflate
-# Connection: keep-alive

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.7.7"
+    VERSION = "0.8.1"
 end

data/plezi.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Plezi::VERSION
   spec.authors       = ["Boaz Segev"]
   spec.email         = ['boaz@2be.co.il']
-  spec.summary       = %q{The Ruby Framework for real time web-apps, with Websockets, REST and HTTP streaming support.}
-  spec.description   = %q{Plezi is a Rack free Ruby Framework for real time web-apps, with native Websocket, HTTP streaming, and REST routing support.}
+  spec.summary       = %q{Plezi is the native Ruby Framework for real time web-apps, with Websockets, RESTful routing and HTTP streaming support.}
+  spec.description   = %q{Plezi is the native Ruby Framework for real time web-apps, with Websockets, RESTful routing and HTTP streaming support.}
   spec.homepage      = "http://boazsegev.github.io/plezi/"
   spec.license       = "MIT"
 
@@ -22,6 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
 
   # spec.post_install_message = "This update might break existing code - please review ChangeLog.md before upgrading any apps."
-  spec.post_install_message = "Thank you for installing Plezi, the 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."
 
 end

data/resources/config.ru

@@ -22,18 +22,16 @@
 # 2. you have better control over Middleware then you could have with Plezi.
 # ("wait", you might say, "there is no Middleware in Plezi!"... "Ahhh", I will answer, "so much to discover...")
 
-
-working_dir = ::File.expand_path(Dir.pwd)
-app_path = ::File.expand_path(File.join(".."),  __FILE__)
-app_file_name = app_path.split(/[\\\/]/).last + ".rb"
-
-# # make sure plezi doesn't set up sockets nor starts the event cycle.
 PLEZI_ON_RACK = true
 
-#load the Plezi application file
-Dir.chdir app_path
-require File.join(app_path, app_file_name)
+# load all framework and gems
+load ::File.expand_path(File.join("..", "environment.rb"),  __FILE__)
+
+# set up the routes
+load ::File.expand_path(File.join("..", "routes.rb"),  __FILE__)
 
-Dir.chdir working_dir
+# start the plezi EM, to make sure that the plezi async code doesn't break.
+Plezi::EventMachine.start Plezi.max_threads
 
-run Plezi
+# run the Rack app
+run Plezi::DSL

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.8.1
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-23 00:00:00.000000000 Z
+date: 2015-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,8 +38,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Plezi is a Rack free Ruby Framework for real time web-apps, with native
-  Websocket, HTTP streaming, and REST routing support.
+description: Plezi is the native Ruby Framework for real time web-apps, with Websockets,
+  RESTful routing and HTTP streaming support.
 email:
 - boaz@2be.co.il
 executables:
@@ -56,16 +56,17 @@ files:
 - TODO.md
 - bin/plezi
 - lib/plezi.rb
-- lib/plezi/base/cache.rb
-- lib/plezi/base/connections.rb
-- lib/plezi/base/dsl.rb
-- lib/plezi/base/engine.rb
-- lib/plezi/base/events.rb
-- lib/plezi/base/io_reactor.rb
-- lib/plezi/base/logging.rb
-- lib/plezi/base/rack_app.rb
-- lib/plezi/base/services.rb
-- lib/plezi/base/timers.rb
+- lib/plezi/common/cache.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/handlers/controller_magic.rb
 - lib/plezi/handlers/http_echo.rb
 - lib/plezi/handlers/http_host.rb
@@ -73,17 +74,13 @@ files:
 - lib/plezi/handlers/magic_helpers.rb
 - lib/plezi/handlers/route.rb
 - lib/plezi/handlers/stubs.rb
-- lib/plezi/server/README.md
-- lib/plezi/server/helpers/http.rb
-- lib/plezi/server/helpers/mime_types.rb
-- lib/plezi/server/protocols/http_protocol.rb
-- lib/plezi/server/protocols/http_request.rb
-- lib/plezi/server/protocols/http_response.rb
-- lib/plezi/server/protocols/websocket.rb
-- lib/plezi/server/protocols/ws_response.rb
-- lib/plezi/server/services/basic_service.rb
-- lib/plezi/server/services/no_service.rb
-- lib/plezi/server/services/ssl_service.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/ws_response.rb
 - lib/plezi/version.rb
 - plezi.gemspec
 - resources/404.erb
@@ -116,8 +113,8 @@ homepage: http://boazsegev.github.io/plezi/
 licenses:
 - MIT
 metadata: {}
-post_install_message: Thank you for installing Plezi, the 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
@@ -133,9 +130,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
-summary: The Ruby Framework for real time web-apps, with Websockets, REST and HTTP
-  streaming support.
+summary: Plezi is the native Ruby Framework for real time web-apps, with Websockets,
+  RESTful routing and HTTP streaming support.
 test_files: []

data/lib/plezi/base/cache.rb

@@ -1,89 +0,0 @@
-
-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
-
-	# Remove data from the cache, if it exists.
-	def clear_cached filename
-		LOCK.synchronize { CACHE_STORE.delete filename } # if CACHE_STORE[filename]
-	end
-
-	# clears all cached data.
-	def clear_cache! filename
-		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

data/lib/plezi/base/connections.rb

@@ -1,33 +0,0 @@
-
-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/engine.rb

@@ -1,77 +0,0 @@
-
-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
-		raise "Plezi will hang and do nothing if there isn't at least one (1) working thread. Cannot set Plezi.max_threads = #{value}" if value.to_i <= 0
-		@max_threads = value.to_i
-	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)." })
-		# run_every 10 , -> {Plezi.info "Cache report: #{CACHE_STORE.length} objects cached." } 
-		(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 Plezi version #{Plezi::VERSION}. Press ^C to stop"
-		puts %q{**deprecation notice**:
-
-v.0.8.0 will consist of many changes that will also influence the API. The 0.8.0 version will mark the begining of some major rewrites, so that the code will be even easier to maintain.
-
-If your code depends on Timers and other advanced API, please review your code before updating to the 0.8.0 version.
-
-		}
-		# 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
-		# # raise if e.is_a?(SignalException) || e.is_a?(SystemExit)
-	end
-end

data/lib/plezi/base/events.rb

@@ -1,93 +0,0 @@
-
-module Plezi
-
-	module_function
-
-	#######################
-	## Events (Callbacks) / Multi-tasking Platform
-
-	# DANGER ZONE - Plezi Engine. an Array containing all the shutdown callbacks that need to be called.
-	SHUTDOWN_CALLBACKS = []
-	# DANGER ZONE - Plezi Engine. an Array containing all the current events.
-	EVENTS = []
-	# DANGER ZONE - Plezi Engine. the Mutex locker for the event machine.
-	LOCKER = Mutex.new
-
-	# returns true if there are any unhandled events
-	def events?
-		LOCKER.synchronize {!EVENTS.empty?}
-	end
-
-	# Public API. pushes an event to the event's stack
-	#
-	# accepts:
-	# handler:: an object that answers to `call`, usually a Proc or a method.
-	# *arg:: any arguments that will be passed to the handler's `call` method.
-	#
-	# if a block is passed along, it will be used as a callback: the block will be called with the values returned by the handler's `call` method.
-	def push_event handler, *args, &block
-		if block
-			LOCKER.synchronize {EVENTS << [(Proc.new {|a| Plezi.push_event block, handler.call(*a)} ), args]}
-		else
-			LOCKER.synchronize {EVENTS << [handler, args]}
-		end
-	end
-
-	# Public API. Runs the block asynchronously by pushin it as an event to the event's stack
-	#
-	# accepts a block to be executed asynchronously.
-	#
-	def run_async *args, &block
-		LOCKER.synchronize {EVENTS << [ block, args ]} if block
-		block
-	end
-
-	# Public API. creates an asynchronous call to a method, with an optional callback:
-	# demo use:
-	# `callback( Kernel, :sleep, 1 ) { puts "this is a demo" }`
-	# callback sets an asynchronous method call with a callback.
-	#
-	# parameters:
-	# object:: the object holding the method to be called (use `Kernel` for global methods).
-	# method:: the method's name (Symbol). this is the method that will be called.
-	# *arguments:: any additional arguments that should be sent to the method (the main method, not the callback).
-	#
-	# this method also accepts an optional block (the callback) that will be called once the main method has completed.
-	# the block will recieve the method's returned value.
-	#
-	# i.e.
-	#    puts 'while we wait for my work to complete, can you tell me your name?'
-	#    Plezi.callback(STDIO, :gets) do |name|
-	#         puts "thank you, #{name}. I'm working on your request as we speak."
-	#    end
-	#    # do more work without waiting for the chat to start nor complete.
-	def callback object, method, *args, &block
-		push_event object.method(method), *args, &block
-	end
-
-	# Public API. adds a callback to be called once the services were shut down. see: callback for more info.
-	def on_shutdown object=nil, method=nil, *args, &block
-		if block && !object && !method
-			LOCKER.synchronize {SHUTDOWN_CALLBACKS << [block, args]}
-		elsif block
-			LOCKER.synchronize {SHUTDOWN_CALLBACKS << [(Proc.new {|*a| block.call(object.method(method).call(*a))} ), args]}
-		elsif object && method
-			LOCKER.synchronize {SHUTDOWN_CALLBACKS << [object.method(method), args]}
-		end
-	end
-
-	# Plezi Engine, DO NOT CALL. pulls an event from the event's stack and processes it.
-	def fire_event
-		event = LOCKER.synchronize {EVENTS.shift}
-		return false unless event
-		begin
-			event[0].call(*event[1])
-		rescue OpenSSL::SSL::SSLError => e
-			warn "SSL Bump - SSL Certificate refused?"
-		rescue Exception => e
-			raise if e.is_a?(SignalException) || e.is_a?(SystemExit)
-			error e
-		end
-		true
-	end
-end