plezi 0.12.6 → 0.12.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd6066ad34f74ff29d617a7e1a535b07dfc0608c
-  data.tar.gz: 16ee892e498e466a8b11dabc484f053729b11f81
+  metadata.gz: d91b4b4d0ac176a59cea5da3a27855993b556116
+  data.tar.gz: e441b5f902541c72c17ae1be1c86ac3597f9c111
 SHA512:
-  metadata.gz: e7f514c042d6c7e20c54948b3343765a68a71c2485155de4e14dbb7f2337daf5990a877e37b8e1c0aa65e609d4bfa4859cff221a9e1cdd962df2ee93352d16e5
-  data.tar.gz: 18e245d1ba234960b72ba5ab5a65ecb05843a96097fb30d4480884d1532f79b84ca16bced7f650898fbe2f6b9c8e474d64a823e739b2286f5cc621f0a3693de6
+  metadata.gz: be3313b3e45c65dfbb9fe4d39d03de6af96dce77da8a4fb9e55a43b0637617611c239e0f643ec5e8931411f234d0f3b233b76ea310fae840d4201cce19b95237
+  data.tar.gz: b37aab54598e3e35621648fb5676149b206335b7b22da0d52c197d34943a05dd0fd9d589fc4d3fd4662f343f477c9c1135e1eda2242bd41af639bff494e1a76c

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ***
 
+Change log v.0.12.7
+
+**Identity API**: Identity API now allows you to set a higher number of allowable concurrent connections per identity, rather than the original single connection limit. Also, allows limited functionality when Redis isn't defined (registration lifetime is limited to the process lifetime and scaling will not work without Redis).
+
+**Template**: minor template updates.
+
+**Fix**: fixed an issue with data and (file) sending, introduced when extending the `send_data` method to allow for big File objects (buffering them through the connection instead of loading them to the memory).
+
+***
+
 Change log v.0.12.6
 
 **Template Fix**: Heroku would load the `environment.rb` file while deploying the application. This would cause Plezi's server to kick in and hang deployment. This issue was circumvented by renaming the `environment.rb` file to `initialize.rb`. Thanks to Adrian Gomez for exposing the issue (issue#9)

data/README.md

@@ -7,19 +7,11 @@ Plezi is an easy to use Ruby Websocket Framework, with full RESTful routing supp
 
 With Plezi, you can easily:
 
-1. Add Websocket services and RESTful HTTP Streaming to your existing Web-App, (Rails/Sinatra or any other Rack based Ruby app).
+1. Create a full fledged Ruby web application, taking full advantage of RESTful routing, HTTP streaming and scalable Websocket features;
 
-2. Create an easily scalable backend for your SPA.
+2. Add Websocket services and RESTful HTTP Streaming to your existing Web-App, (Rails/Sinatra or any other Rack based Ruby app);
 
-3. Create a full fledged Ruby web application, taking full advantage of RESTful routing, HTTP streaming and scalable Websocket features.
-
-Plezi leverages [Iodine's server](https://github.com/boazsegev/iodine) new architecture. Iodine is a pure Ruby HTTP and Websocket Server built using [Iodine's](https://github.com/boazsegev/iodine) core library - a multi-threaded pure ruby alternative to EventMachine with process forking support (enjoy forking, if your code is scaling ready).
-
-Plezi and Iodine are written for Ruby versions 2.1.0 or greater (or API compatible variants). Version 2.2.3 is the currently recommended version.
-
-**Plezi version notice**
-
-The `master` branch always refers to the latest edge version, which might also be a broken version. Please refer to the relevent version by using the version's `tag` in the branch selector.
+3. Create an easily scalable backend for your SPA.
 
 ## Installation
 
@@ -35,26 +27,173 @@ Or install it yourself as:
 
 ## Creating a Plezi Application
 
-to create a new barebones app using the Plezi framework, run from terminal:
+I love starting small and growing. So, when I create a Plezi app, I just want the basics that allow me to easily deploy my application. with these goals, I run the following in my terminal:
+
+    $ plezi mini appname
+
+But, some people prefer to have the application template already full blown and ready for heavy lifting, complete with some common settings for common gems and code snippets they can activate. These people open their terminal and execute:
 
     $ plezi new appname
 
-That's it, now you have a ready to use basic web server (with some demo code, such as a websocket chatroom).
+That's it, now we 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:
+On MacOS or linux, simply double click the `appname` script file to run. Or, from the terminal:
 
     $ cd appname
     $ ./appname # ( or: plezi s )
 
-now go, in your browser, to: [http://localhost:3000/](http://localhost:3000/)
+See it work: [http://localhost:3000/](http://localhost:3000/)
+
+## So easy, we can an app in the terminal!
+
+The Plezi framework was designed with intuitive ease of use in mind.
+
+Question - what's the shortest "Hello World" web-application when writing for Sinatra or Rails? ... can you write one in your terminal window?
+
+In Plezi, it looks like this:
+
+    require 'plezi'
+    route('*') { "Hello World!" }
+
+Two lines! You can even start a Plezi application from `irb`, by adding the `exit` at the end:
+
+    require 'plezi'
+    route('*') { "Hello World!" }
+    exit # <- this exits the terminal and starts the server
+
+Now visit [localhost:3000](http://localhost:3000/)
+
+### Object Oriented design is fun!
+
+While Plezi allows you to use methods like we just did, Plezi really shines when we use Controller classes.
+
+Plezi will automatically map instance methods in any class to routes with complete RESTful routing support.
+
+Let's try this terminal (`irb`):
 
-the default port for the app is 3000. you can set the port to listen to by using the `-p ` option (make sure you have permissions for the requested port):
+    require 'plezi'
+    class MyDemo
+        # the index will answer '/'
+        def index
+            "Hello World!"
+        end
+        # a regular method will answer it's own name i.e. '/foo'
+        def foo
+            "Bar!"
+        end
+        # show is RESTful, it will answer '/(:id)'
+        def show
+            "Are you looking for: #{params[:id]}?"
+        end
+    end
+
+    route '/', MyDemo
+    exit
+
+Now visit [index](http://localhost:3000/) and [foo](http://localhost:3000/foo) or request an id, i.e. [http://localhost:3000/1](http://localhost:3000/1).
+
+Did you notice how the controller has natural access to the request's `params`?
 
-    $ ./appname -p 80
+This is because Plezi inherits our controller and adds some magic to it, allowing us to read and set cookies using the `cookies` Hash based cookie-jar, set or read session data using `session`, look into the `request`, set special headers for the `response`, store self destructing cookies using `flash` and so much more!
 
-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.
+### Can websockets do that?!
 
-## Plezi Controller classes
+Plezi was designed for websockets from the ground up. If your controller class defines an `on_message(data)` callback, plezi will automatically enable websocket connections for that route.
+
+Here's a Websocket echo server using Plezi:
+
+    require 'plezi'
+    class MyDemo
+        def on_message data
+            # sanitize the data and write it to the websocket.
+            write ">> #{ERB::Util.html_escape data}"
+        end
+    end
+
+    route '/', MyDemo
+    exit
+
+But that's not all, each controller is also a "channel" which can broadcast to everyone who's connected to it.
+
+Here's a websocket chat-room server using Plezi, comeplete with minor authentication (requires a chat handle):
+
+    require 'plezi'
+    class MyDemo
+        def on_open
+            # there's a better way to require a user handle, but this is good enough for now.
+            close unless params[:id]
+        end
+        def on_message data
+            # sanitize the data.
+            data = ERB::Util.html_escape data
+            # broadcast to everyone else (NOT ourselves):
+            # this will have every connection execute the `chat_message` with the following argument(s).
+            broadcast :chat_message, "#{params[:id]}: #{data}"
+            # write to our own websocket:
+            write "Me: #{data}"
+        end
+        protected
+        # receive and implement the broadcast
+        def chat_message data
+            write data
+        end
+    end
+
+    route '/', MyDemo
+    # You can connect to this chatroom by going to ws://localhost:3000/any_nickname
+    # but you need to write a websocket client too...
+    # try two browsers with the client provided by http://www.websocket.org/echo.html
+    exit
+
+Broadcasting in not the only help Plezi has to offer, we can also send a message to a specific connection using `unicast`, or send a message to everyone (no matter what controller is handling their connection) using `multicast`...
+
+...It's even possible to register a unique identity, such as a specific user or even a `session.id`, so their messages are waiting for them even when they're off-line (you decide how long they wait)!
+
+### Websocket scaling is as easy as one line of code!
+
+A common issue with Websocket scaling is trying to send websocket messages from server X to a user connected to server Y... On Heroku, it's enough add one Dyno (a total of two Dynos) to break some websocket applications.
+
+Plezi leverages the power or Redis to automatically push both websocket messages and Http session data across servers, so that you can easily scale your applications (on Heroku, add Dynos) with only one line of code!
+
+Just tell Plezi how to acess your Redis server and Plezi will make sure that your users get their messages and that your application can access it's session data accross different servers:
+
+    # REDIS_URL is where Herolu-Redis stores it's URL
+    ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || "redis://username:password@my.host:6389"
+
+### Hosts, template rendering, assets...?
+
+Plezi allows us to use different host-names for different routes. i.e.:
+
+    require 'plezi'
+
+    host # this is the default host, it's always last to be checked.
+    route('/') {"this is localhost"}
+
+    host host: '127.0.0.1' # special host, for the IP name
+    route('/') {"this is only for the IP!"}
+    exit
+
+Each host has it's own settings for a public folder, asset rendering, templates etc'. For example:
+
+    require 'plezi'
+
+    class MyDemo
+        def index
+            # to make this work, create a template and set the correct template folder
+            render :index
+        end
+    end
+
+    host public: File.join('my', 'public', 'folder'),
+        templates: File.join('my', 'templates', 'folder'),
+        assets: File.join('my', 'assets', 'folder')
+
+    route '/', MyDemo
+    exit
+
+Plezi supports ERB (i.e. `template.html.erb`), Slim (i.e. `template.html.slim`), Haml (i.e. `template.html.haml`), CoffeeScript (i.e. `template.js.coffee`) and Sass (i.e. `template.css.scss`) right out of the box... but it's expendable using the `Plezi::Renderer.register` and `Plezi::AssetManager.register`
+
+## More about 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_open`, `on_message(data)`, `on_close`, `broadcast`, `unicast`, `multicast`, `on_broadcast(data)`).
 
@@ -68,17 +207,12 @@ Here is a Hello World using a Controller class (run in `irb`):
             end
         end
 
-        # use the host method to set up any specific host options:
-        host :default,
-              public: File.join('my', 'public', 'folder'),
-              templates: File.join('my', 'template', 'folder')
-
 
         route '*' , Controller
 
         exit # Plezi will autostart once you exit irb.
 
-Except while using WebSockets, returning a String will automatically add the string to the response before sending the response - which makes for cleaner code. It's also possible to use the `response` object to set the response or stream HTTP (return true instead of a stream when you're done).
+Except when using WebSockets, returning a String will automatically add the string to the response before sending the response - which makes for cleaner code. It's also possible to use the `response` object to set the response or stream HTTP (return true instead of a stream when you're done).
 
 It's also possible to define a number of controllers for a similar route. The controllers will answer in the order in which the routes are defined (this allows to group code by logic instead of url).
 
@@ -86,7 +220,7 @@ It's also possible to define a number of controllers for a similar route. The co
 
 ## Native Websocket and Redis support
 
-Plezi Controllers have access to native websocket support through the `pre_connect`, `on_open`, `on_message(data)`, `on_close`, `broadcast` and `unicast` methods.
+Plezi Controllers have access to native websocket support through the `pre_connect`, `on_open`, `on_message(data)`, `on_close`, `multicast`, `broadcast`, `unicast` and the Identity API (`register_as` and `notify` 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).
 
@@ -125,7 +259,7 @@ Remember to connect to the service from at least two browser windows - to truly
     route '/', BroadcastCtrl
 ```
 
-method names starting with an underscore ('_') will NOT be made public by the router.
+method names starting with an underscore ('_') are protected from the Http router, even when they are public.
 
 This is why even though both '/hello' and '/humans.txt' are public ( [try it](http://localhost:3000/humans.txt) ), '/_send_message' will return a 404 not found error ( [try it](http://localhost:3000/_send_message) ).
 
@@ -528,9 +662,15 @@ Whether such goodies are part of the Plezi-App Template (such as rake tasks for
 
 ## 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.
+Plezi leverages [Iodine's server](https://github.com/boazsegev/iodine) new architecture. Iodine is a pure Ruby HTTP and Websocket Server built using [Iodine's](https://github.com/boazsegev/iodine) core library - a multi-threaded pure ruby alternative to EventMachine with process forking support (enjoy forking, if your code is scaling ready).
 
-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.
+Plezi and Iodine are meant to be very effective, allowing for much flexability where needed.
+
+Settings for the Iodine's core allow you to change different things, such as the level of concurrency you want (`Iodine.threads = ` or `Iodine.processes = `), logging destination (such as logging to a file) and more.
+
+Settings for Iodine's Http and Websockets server, allow you to change upload limits (which can be super important for security) using `Iodine::Http.max_http_buffer =`, limit websocket message sizes using `Iodine::Http::Websockets.message_size_limit =`, change the Websocket's auto-ping interval using `Iodine::Http::Websockets.default_timeout =` or `Plezi::Settings.ws_message_size_limit` and more... Poke around ;-)
+
+Plezi and Iodine are written for Ruby versions 2.1.0 or greater (or API compatible variants). Version 2.2.3 is the currently recommended version.
 
 ## Who's afraid of multi-threading?
 
@@ -585,6 +725,8 @@ However, th following is unsafe:
 
 ## Contributing
 
+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.
+
 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'`)

data/lib/plezi/common/settings.rb

@@ -15,7 +15,7 @@ module Plezi
 		# Returns the Redis Channel Name used by this app.
 		# @return [String]
 		def redis_channel_name
-			@redis_channel_name ||= "#{File.basename($0, '.*')}_Redis_Channel"
+			@redis_channel_name ||= "#{File.basename($0, '.*')}_redis_channel"
 		end
 
 		# Sets the message byte size limit for a Websocket message. Defaults to 0 (no limit)

data/lib/plezi/handlers/controller_magic.rb

@@ -133,13 +133,13 @@ module Plezi
 					Plezi.warn 'existing response body was cleared by `#send_data`!'
 					response.body.close if response.body.respond_to? :close
 				end
-				response = data
+				response.body = data
 
 				# set headers
 				content_disposition = options[:inline] ? 'inline' : 'attachment'
 				content_disposition << "; filename=#{::File.basename(options[:filename])}" if options[:filename]
 
-				response['content-type'] = (options[:type] ||= MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])])
+				response['content-type'] = (options[:type] ||= options[:filename] && MimeTypeHelper::MIME_DICTIONARY[::File.extname(options[:filename])])
 				response['content-disposition'] = content_disposition
 				true
 			end

data/lib/plezi/handlers/route.rb

@@ -20,6 +20,8 @@ module Plezi
 				if controller
 					ret = controller.new(request, response)._route_path_to_methods_and_set_the_response_
 				elsif proc
+					# proc.init(request, response)
+					# ret = proc.instance_exec(request, response, &proc)
 					ret = proc.call(request, response)
 				elsif controller == false
 					request.path = path.match(request.path).to_a.last.to_s
@@ -54,6 +56,23 @@ module Plezi
 					# add controller magic
 					@controller = self.class.make_controller_magic controller, self
 				end
+				if @proc.is_a?(Proc)
+					# # proc's methods aren't executed since it's binding isn't `self`
+					# @proc.instance_exec do
+					# 	extend ::Plezi::ControllerMagic::InstanceMethods
+					# 	undef :url_for
+					# 	undef :full_url_for
+					# 	undef :requested_method
+					# 	def run request, response
+					# 		@request = request
+					# 		@params = request.params
+					# 		@flash = response.flash
+					# 		@host_params = request[:host_settings]
+					# 		@response = response
+					# 		@cookies = request.cookies
+					# 	end
+					# end
+				end
 			end
 
 			# # returns the url for THIS route (i.e. `url_for :index`)

data/lib/plezi/handlers/ws_identity.rb

@@ -4,6 +4,87 @@ module Plezi
 
 		module WSObject
 
+			module RedisEmultaion
+				public
+				def lrange key, first, last = -1
+					sync do
+						return [] unless @cache[key]
+						@cache[key][first..last] || []
+					end
+				end
+				def llen key
+					sync do
+						return 0 unless @cache[key]
+						@cache[key].count
+					end
+				end
+				def ltrim key, first, last = -1
+					sync do
+						return "OK".freeze unless @cache[key]
+						@cache[key] = @cache[key][first..last]
+						"OK".freeze
+					end
+				end
+				def del *keys
+					sync do
+						ret = 0
+						keys.each {|k| ret += 1 if @cache.delete k }
+						ret
+					end
+				end
+				def lpush key, value
+					sync do
+						@cache[key] ||= []
+						@cache[key].unshift value
+						@cache[key].count
+					end
+				end
+				def rpush key, value
+					sync do
+						@cache[key] ||= []
+						@cache[key].push value
+						@cache[key].count
+					end
+				end
+				def expire key, seconds
+					Iodine.warn "Identity API requires Redis - no persistent storage!"
+					sync do
+						return 0 unless @cache[key]
+						if @timers[key]
+							@timers[key].stop!
+						end
+						@timers[key] = (Iodine.run_after(seconds) { self.del key })
+					end
+				end
+				def multi
+					sync do
+						@results = []
+						yield(self)
+						ret = @results
+						@results = nil
+						ret
+					end
+				end
+				alias :pipelined :multi
+				protected
+				@locker = Mutex.new
+				@cache = Hash.new
+				@timers = Hash.new
+
+				def sync &block
+					if @locker.locked? && @locker.owned?
+						ret = yield
+						@results << ret if @results
+						ret
+					else
+						@locker.synchronize { sync &block }
+					end
+				end
+
+				public
+				extend self
+			end
+
 			# the following are additions to the WebSocket Object module,
 			# to establish identity to websocket realtionships, allowing for a
 			# websocket message bank.
@@ -16,15 +97,17 @@ module Plezi
 				# Like {Plezi::Base::WSObject::SuperClassMethods#notify}, using this method requires an active Redis connection
 				# to be set up. See {Plezi#redis} for more information.
 				#
-				# Only one connection at a time can respond to identity events. If the same identity
+				# By default, only one connection at a time can respond to identity events. If the same identity
 				# connects more than once, only the last connection will receive the notifications.
+				# This default may be controlled by setting the `:max_connections` option to a number greater than 1.
 				#
 				# The method accepts:
 				# identity:: a global application wide unique identifier that will persist throughout all of the identity's connections.
 				# options:: an option's hash that sets the properties of the identity.
 				#
-				# The option's Hash, at the moment, accepts only the following (optional) option:
+				# The option's Hash, at the moment, accepts only the following (optional) options:
 				# lifetime:: sets how long the identity can survive. defaults to `604_800` seconds (7 days).
+				# max_connections:: sets the amount of concurrent connections an identity can have (akin to open browser tabs receiving notifications). defaults to 1 (a single connection).
 				#
 				# Calling this method will also initiate any events waiting in the identity's queue.
 				# make sure that the method is only called once all other initialization is complete.
@@ -32,20 +115,22 @@ module Plezi
 				# Do NOT call this method asynchronously unless Plezi is set to run as in a single threaded mode - doing so
 				# will execute any pending events outside the scope of the IO's mutex lock, thus introducing race conditions.
 				def register_as identity, options = {}
-					redis = Plezi.redis
-					raise "The identity API requires a Redis connection" unless redis
+					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
+					options[:max_connections] ||= 1
+					options[:max_connections] = 1 if options[:max_connections].to_i < 1
+					options[:lifetime] ||= 604_800
 					identity = identity.to_s.freeze
 					@___identity ||= [].to_set
 					@___identity << identity
 					redis.pipelined do
 						redis.lpush "#{identity}_uuid".freeze, uuid
-						redis.ltrim "#{identity}_uuid".freeze, 0, 0
+						redis.ltrim "#{identity}_uuid".freeze, 0, (options[:max_connections]-1)
 					end
-					___review_identity identity
 					redis.lpush(identity, ''.freeze) unless redis.llen(identity) > 0
+					___review_identity identity
 					redis.pipelined do
-						redis.expire identity, (options[:lifetime] || 604_800)
-						redis.expire "#{identity}_uuid".freeze, (options[:lifetime] || 604_800)
+						redis.expire identity, options[:lifetime]
+						redis.expire "#{identity}_uuid".freeze, options[:lifetime]
 					end
 				end
 
@@ -63,21 +148,21 @@ module Plezi
 			module SuperInstanceMethods
 				protected
 				def ___review_identity identity
-					redis = Plezi.redis
-					raise "unknown Redis initiation error" unless redis
+					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
 					identity = identity.to_s.freeze
 					return Iodine.warn("Identity message reached wrong target (ignored).").clear unless @___identity.include?(identity)
-					redis.multi do
-						redis.lpush identity, ''.freeze
-						redis.lpush identity, ''.freeze
-					end
-					msg = redis.rpop(identity)
-					Iodine.error "Unknown Identity Queue error - both messages and identity might be lost!\nExpected no data, but got: #{msg}" unless msg == ''.freeze
-					while (msg = redis.rpop(identity)) && msg != ''.freeze
+					messages = redis.multi do
+						redis.lrange identity, 1, -1
+						redis.ltrim identity, 0, 0
+					end[0]
+					targets = redis.lrange "#{identity}_uuid", 0, -1
+					while msg = messages.shift
 						msg = ::Plezi::Base::WSObject.translate_message(msg)
 						next unless msg
 						Iodine.error("Notification recieved but no method can handle it - dump:\r\n #{msg.to_s}") && next unless self.class.has_super_method?(msg[:method])
-						self.method(msg[:method]).call *msg[:data]
+						# targets.each {|target| target == uuid ? self.method(msg[:method]).call(*msg[:data]) : unicast(target, msg[:method], *msg[:data])}
+						targets.each {|target| unicast(target, msg[:method], *msg[:data])} # this allows for async execution
+						
 					end
 				end
 			end
@@ -87,20 +172,17 @@ module Plezi
 
 				# sends a notification to an Identity. Returns false if the Identity never registered or it's registration expired.
 				def notify identity, event_name, *args
-					redis = Plezi.redis
-					raise "The identity API requires a Redis connection" unless redis
+					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
 					identity = identity.to_s.freeze
 					return false unless redis.llen(identity).to_i > 0
-					redis.lpush identity, ({method: event_name, data: args}).to_yaml
-					target_uuid = redis.lindex "#{identity}_uuid".freeze, 0
-					unicast target_uuid, :___review_identity, identity if target_uuid
+					redis.rpush identity, ({method: event_name, data: args}).to_yaml
+					redis.lrange("#{identity}_uuid".freeze, 0, -1).each {|target| unicast target, :___review_identity, identity }
 					true
 				end
 
 				# returns true if the Identity in question is registered to receive notifications.
 				def registered? identity
-					redis = Plezi.redis
-					return Iodine.warn("Cannot check for Identity registration without a Redis connection (silent).") && false unless redis
+					redis = Plezi.redis || ::Plezi::Base::WSObject::RedisEmultaion
 					identity = identity.to_s.freeze
 					redis.llen(identity).to_i > 0
 				end

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.12.6"
+    VERSION = "0.12.7"
 end

data/plezi.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "iodine", "~> 0.1.9"
+  spec.add_dependency "iodine", "~> 0.1.10"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/resources/mini_app.rb

@@ -5,32 +5,29 @@
 	require 'pathname'
 	## Set up root object, it might be used by the environment and\or the plezi extension gems.
 	Root ||= Pathname.new(File.dirname(__FILE__)).expand_path
-
 	## If this app is independant, use bundler to load gems (including the plezi gem).
-	## otherwise, use the original app's Gemfile and start Plezi's Rack mode.
+	## otherwise, use the original app's Gemfile and Plezi will automatically switch to Rack mode.
 	require 'bundler'
 	Bundler.require(:default, ENV['ENV'].to_s.to_sym)
 
-	## make sure all file access and file loading is relative to the application's root folder
-	# Dir.chdir Root.to_s
-	## load code from a subfolder called 'app'
+# # Optional code auto-loading and logging:
+
+	# # Load code from a subfolder called 'app'?
 	# Dir[File.join "{app}", "**" , "*.rb"].each {|file| load File.expand_path(file)}
-	## OR load code from all the ruby files in the main forlder (subfolder inclussion will fail on PaaS)
-	# Dir[File.join File.dirname(__FILE__), "*.rb"].each {|file| load File.expand_path(file) unless file == __FILE__}
 
-	## Uncomment to create a log file
-	# Iodine.logger = Logger.new File.expand_path(Root.join('server.log').to_s)
+	## Log to a file?
+	# Iodine.logger = Logger.new Root.join('server.log').to_s
+
+# # Optional Scaling (across processes or machines):
+	ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] ||
+							ENV['REDISCLOUD_URL'] ||
+							ENV['REDISTOGO_URL'] ||
+							nil # "redis://username:password@my.host:6389"
+	# # redis channel name should be changed is using Placebo API
+	# Plezi::Settings.redis_channel_name = 'appsecret'
 
-# # Options for Scaling the app (across processes or machines):
 	# # uncomment to set up forking for 3 more processes (total of 4).
 	# Iodine.processes = 4
-	#
-	# # Redis scaling
-	# Plezi::Settings.redis_channel_name = 'appsecret'
-	# ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://username:password@my.host:6389"
-	#
-	# # Consider setting a common session token for Redis supported sessions.
-	# Iodine::Http.session_token = 'appname_uui'
 
 
 # The basic appname controller, to get you started
@@ -48,10 +45,11 @@ class MyController
 	end
 	def on_open
 		print 'Welcome!'
-		broadcast :print, "Somebody joind us :-)"
+		@handle = params[:id] || 'Somebody'
+		broadcast :print, "#{@handle} joind us :-)"
 	end
 	def on_close
-		broadcast :print, "Somebody left us :-("
+		broadcast :print, "#{@handle} left us :-("
 	end
 
 	protected
@@ -63,23 +61,21 @@ end
 
 
 # change some of the default settings here.
-host host: :default,
+host templates: Root.join('templates').to_s,
 	# public: Root.join('public').to_s,
-	assets: Root.join('assets').to_s,
-	templates: Root.join('templates').to_s
-
-# # Optional stuff:
-	# # I18n re-write, i.e.: `/en/home` will be rewriten as `/home`, while setting params[:locale] to "en"
-	# route "/:locale{#{I18n.available_locales.join "|"}}/*" , false if defined? I18n
-	#
-	# # OAuth2 - Facebook / Google authentication
-	# ENV["FB_APP_ID"] ||= "app id"; ENV["FB_APP_SECRET"] ||= "secret"; ENV['GOOGLE_APP_ID'] = "app id"; ENV['GOOGLE_APP_SECRET'] = "secret"
-	# require 'plezi/oauth' # do this AFTER setting ENV variables.
-	# 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 has access to the controller's methods (request, cookies, response, etc')
-	# end
+	assets: Root.join('assets').to_s
+
+# # I18n re-write, i.e.: `/en/home` will be rewriten as `/home`, while setting params[:locale] to "en"
+# route "/:locale{#{I18n.available_locales.join "|"}}/*" , false if defined? I18n
+
+# # OAuth2 - Facebook / Google authentication
+# ENV["FB_APP_ID"] ||= "app id"; ENV["FB_APP_SECRET"] ||= "secret"; ENV['GOOGLE_APP_ID'] = "app id"; ENV['GOOGLE_APP_SECRET'] = "secret"
+# require 'plezi/oauth' # do this AFTER setting ENV variables.
+# 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 has access to the controller's methods (request, cookies, response, etc')
+# end
 
 # Add your routes and controllers by order of priority.
 route '/(:id)', MyController

data/resources/mini_welcome_page.html

@@ -207,7 +207,10 @@ function init_websocket()
             document.getElementById("output").appendChild(msg);
         };
         // you probably want to reopen the websocket if it closes (unless the issue repeats).
-        if(websocket_fail <= 5) {websocket_fail += 1; init_websocket(); };
+        if(websocket_fail <= 5) {
+            websocket_fail += 1;
+            setTimeout( init_websocket, 250);
+        };
     };
     websocket.onerror = function(e) {
         // what do you want to do now?
@@ -249,7 +252,7 @@ function send_text()
             <ul>
                 <li>Review and update MyController in your 'appname.rb'.</li>
                 <li>Edit or delete this file (appname/templates/welcome.html.erb).</li>
-                <li>Write your own controller and code, maybe using a sub-foler as suggested in the 'appname.rb' file.</li>
+                <li>Write your own controller and code, maybe using a sub-folder as suggested in the 'appname.rb' file.</li>
                 <li>Set up your routes in the 'appname.rb' file.</li>
                 <li>Edit the javascript for the client in your 'appname/websockets.js' file and link to it from your html.</li>
             </ul>

data/resources/rakefile

@@ -1,4 +1,4 @@
-# load all framework and gems
+# load all application code and gems
 load ::File.expand_path(File.join("..", "initialize.rb"),  __FILE__)
 
 # Make sure the server doesn't start

data/resources/redis_config.rb

@@ -2,26 +2,26 @@
 
 if defined? Redis
 
-	Plezi::Settings.redis_channel_name = 'appsecret'
-
 	# ## Plezi Redis Automation
 	# ## ====
 	# ##
 	# ## Sets up Plezi to use Radis broadcast.
 	# ##
 	# ## If Plezi Redis Automation is enabled:
-	# ## Plezi creates is own listening thread that listens for each Controller class that broadcasts using Redis.
-	# ## (using the Controller.redis_connection and Controller.redis_channel_name class methods)
+	# ## Plezi creates is own listening thread that listens for messages and broadcasts using Redis.
 	# ##
 	# ## Only one thread will be created and initiated during startup (dynamically created controller routes might be ignored).
 	# ##
-	# ## this overrides the default Controller#broadcast method which is very powerful but
-	# ## is limited to one process.
-	# ##
-	# ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || ENV['REDISTOGO_URL'] || "redis://username:password@my.host:6389"
+	# `redis_channel_name` should be set when using the Placebo API.
+	# (otherwise, it's only optional, as the automatic settings are good enough)
+	Plezi::Settings.redis_channel_name = 'appsecret'
+	ENV['PL_REDIS_URL'] ||= ENV['REDIS_URL'] ||
+							ENV['REDISCLOUD_URL'] ||
+							ENV['REDISTOGO_URL'] || 
+							nil # use: "redis://username:password@my.host:6389"
 
 
-	# ## OR, write your own custom Redis Automation here
+	# ## OR, write your own custom Redis implementation here
 	# ## ====
 	# ##
 	# ## create a listening thread - rewrite the following code for your own Redis tailored solution.

data/resources/welcome_page.html

@@ -207,7 +207,10 @@ function init_websocket()
             document.getElementById("output").appendChild(msg);
         };
         // you probably want to reopen the websocket if it closes (unless the issue repeats).
-        if(websocket_fail <= 5) {websocket_fail += 1; init_websocket(); };
+        if(websocket_fail <= 5) {
+            websocket_fail += 1;
+            setTimeout( init_websocket, 250);
+        };
     };
     websocket.onerror = function(e) {
         // what do you want to do now?

data/test/plezi_tests.rb

@@ -160,27 +160,88 @@ class WSIdentity
 		"identity api testing path\n#{params}"		
 	end
 	def show
-		if notify params[:id], :notification, (params[:message] || 'no message')
-			"Send notification for #{params[:id]}: #{(params[:message] || 'no message')}"
+		if params[:message]
+			if notify params[:id], :notification, params[:message]
+				"Sent notification for #{params[:id]}: #{params[:message]}"
+			else
+				"The identity requested (#{params[:id]}) doesn't exist."
+			end
 		else
-			"The identity requested (#{params[:id]}) doesn't exist."
+			%{<html><head><script>
+// Your websocket URI should be an absolute path. The following sets the base URI.
+// remember to update to the specific controller's path to your websocket URI.
+var ws_controller_path = window.location.pathname;
+var ws_uri = (window.location.protocol.match(/https/) ? 'wss' : 'ws') + '://' + window.document.location.host + ws_controller_path
+var websocket = 100
+var websocket_fail_count = 0
+
+function init_websocket()
+{
+    if(websocket && websocket.readyState == 1) return true; // console.log('no need to renew socket connection');
+    websocket = new WebSocket(ws_uri);
+    websocket.onopen = function(e) {
+        //restart fail count
+        websocket_fail = 0
+        // what do you want to do now?
+        var msg = document.createElement("li");
+        msg.className = 'system_message'
+        msg.innerHTML = "Connected.";
+        document.getElementById("output").appendChild(msg);
+    };
+
+    websocket.onclose = function(e) {
+        // what do you want to do now?
+        if(websocket_fail == 0) {
+            var msg = document.createElement("li");
+            msg.className = 'system_message'
+            msg.innerHTML = "Disconnected.";
+            document.getElementById("output").appendChild(msg);
+        };
+        // you probably want to reopen the websocket if it closes (unless the issue repeats).
+        if(websocket_fail <= 5) {websocket_fail += 1; init_websocket(); };
+    };
+    websocket.onerror = function(e) {
+        // what do you want to do now?
+    };
+    websocket.onmessage = function(e) {
+        // what do you want to do now?
+        console.log(e.data);
+        var msg = document.createElement("li");
+        msg.innerHTML = e.data;
+        document.getElementById("output").appendChild(msg);
+        // to use JSON, use:
+        // msg = JSON.parse(e.data); // remember to use JSON also in your Plezi controller.
+    };
+}
+window.addEventListener("load", init_websocket, false); 
+</script></head>
+<body>
+<h3>You are now #{params[:id]}</h3>
+<ul id='output'>
+</ul>
+</body></html>}
 		end
 	end
 	def pre_connect
 		params[:id] && true
 	end
 	def on_open
-		register_as params[:id]
+		@id_count = self.class.counter
+		register_as params[:id], max_connections: 3, lifetime: 120
 	end
 	def on_message data
-		puts "Got websocket message: #{data}"
+		puts "websocket message (for identity #{@id_count}) : #{data}"
 	end
 
 	protected
 
 	def notification message
 		write message
-		puts "Identity Got: #{message}"
+		puts "Identity #{@id_count} Got: #{message}"
+	end
+	def self.counter
+		@count ||= 0
+		@count += 1		
 	end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.12.6
+  version: 0.12.7
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-02 00:00:00.000000000 Z
+date: 2015-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iodine
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.9
+        version: 0.1.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.9
+        version: 0.1.10
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement