message_bus 0.0.2 → 0.9.3

data/assets/message-bus.js

@@ -0,0 +1,247 @@
+/*jshint bitwise: false*/
+
+/**
+  Message Bus functionality.
+
+  @class MessageBus
+  @namespace Discourse
+  @module Discourse
+**/
+window.MessageBus = (function() {
+  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
+  var callbacks, clientId, failCount, interval, shouldLongPoll, queue, responseCallbacks, uniqueId, baseUrl;
+  var me, started, stopped, longPoller, pollTimeout;
+
+  uniqueId = function() {
+    return 'xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      var r, v;
+      r = Math.random() * 16 | 0;
+      v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  };
+
+  clientId = uniqueId();
+  responseCallbacks = {};
+  callbacks = [];
+  queue = [];
+  interval = null;
+  failCount = 0;
+  baseUrl = "/";
+
+  /* TODO: The plan is to force a long poll as soon as page becomes visible
+  // MIT based off https://github.com/mathiasbynens/jquery-visibility/blob/master/jquery-visibility.js
+  initVisibilityTracking =  function(window, document, $, undefined) {
+    var prefix;
+    var property;
+    // In Opera, `'onfocusin' in document == true`, hence the extra `hasFocus` check to detect IE-like behavior
+    var eventName = 'onfocusin' in document && 'hasFocus' in document ? 'focusin focusout' : 'focus blur';
+    var prefixes = ['webkit', 'o', 'ms', 'moz', ''];
+    var $event = $.event;
+
+    while ((prefix = prefixes.pop()) !== undefined) {
+      property = (prefix ? prefix + 'H': 'h') + 'idden';
+      var supportsVisibility = typeof document[property] === 'boolean';
+      if (supportsVisibility) {
+        eventName = prefix + 'visibilitychange';
+        break;
+      }
+    }
+
+    $(/blur$/.test(eventName) ? window : document).on(eventName, function(event) {
+      var type = event.type;
+      var originalEvent = event.originalEvent;
+
+      // Avoid errors from triggered native events for which `originalEvent` is
+      // not available.
+      if (!originalEvent) {
+              return;
+      }
+
+      var toElement = originalEvent.toElement;
+
+      // If it’s a `{focusin,focusout}` event (IE), `fromElement` and `toElement`
+      // should both be `null` or `undefined`; else, the page visibility hasn’t
+      // changed, but the user just clicked somewhere in the doc. In IE9, we need
+      // to check the `relatedTarget` property instead.
+      if (
+              !/^focus./.test(type) || (
+                      toElement === undefined &&
+                      originalEvent.fromElement === undefined &&
+                      originalEvent.relatedTarget === undefined
+              )
+      ) {
+          visibilityChanged(property && document[property] || /^(?:blur|focusout)$/.test(type) ? 'hide' : 'show');
+      }
+    });
+
+  };
+  */
+
+  var hiddenProperty;
+
+  $.each(["","webkit","ms","moz","ms"], function(index, prefix){
+    var check = prefix + (prefix === "" ? "hidden" : "Hidden");
+    if(document[check] !== undefined ){
+      hiddenProperty = check;
+    }
+  });
+
+  var isHidden = function() {
+    if (hiddenProperty !== undefined){
+      return document[hiddenProperty];
+    } else {
+      return !document.hasFocus;
+    }
+  };
+
+  shouldLongPoll = function() {
+    return me.alwaysLongPoll || !isHidden();
+  };
+
+  longPoller = function(poll,data){
+    var gotData = false;
+    var lastAjax = new Date();
+
+    return $.ajax(baseUrl + "message-bus/" + clientId + "/poll?" + (!shouldLongPoll() || !me.enableLongPolling ? "dlp=t" : ""), {
+      data: data,
+      cache: false,
+      dataType: 'json',
+      type: 'POST',
+      headers: {
+        'X-SILENCE-LOGGER': 'true'
+      },
+      success: function(messages) {
+        failCount = 0;
+        $.each(messages,function(_,message) {
+          gotData = true;
+          $.each(callbacks, function(_,callback) {
+            if (callback.channel === message.channel) {
+              callback.last_id = message.message_id;
+              callback.func(message.data);
+            }
+            if (message.channel === "/__status") {
+              if (message.data[callback.channel] !== undefined) {
+                callback.last_id = message.data[callback.channel];
+              }
+            }
+          });
+        });
+      },
+      error: failCount += 1,
+      complete: function() {
+        if (gotData) {
+          pollTimeout = setTimeout(poll, 100);
+        } else {
+          interval = me.callbackInterval;
+          if (failCount > 2) {
+            interval = interval * failCount;
+          } else if (!shouldLongPoll()) {
+            // slowning down stuff a lot when hidden
+            // we will need to add a lot of fine tuning here
+            interval = interval * 4;
+          }
+          if (interval > me.maxPollInterval) {
+            interval = me.maxPollInterval;
+          }
+
+          interval -= (new Date() - lastAjax);
+          if (interval < 100) {
+            interval = 100;
+          }
+
+          pollTimeout = setTimeout(poll, interval);
+        }
+        me.longPoll = null;
+      }
+    });
+  };
+
+  me = {
+    enableLongPolling: true,
+    callbackInterval: 15000,
+    maxPollInterval: 3 * 60 * 1000,
+    callbacks: callbacks,
+    clientId: clientId,
+    alwaysLongPoll: false,
+    baseUrl: baseUrl,
+
+    stop: function() {
+      stopped = true;
+      started = false;
+    },
+
+    // Start polling
+    start: function(opts) {
+      var poll;
+
+      if (started) return;
+      started = true;
+      stopped = false;
+
+      if (!opts) opts = {};
+
+      poll = function() {
+        var data;
+
+        if(stopped) {
+          return;
+        }
+
+        if (callbacks.length === 0) {
+          setTimeout(poll, 500);
+          return;
+        }
+
+        data = {};
+        $.each(callbacks, function(_,callback) {
+          data[callback.channel] = callback.last_id;
+        });
+        me.longPoll = longPoller(poll,data);
+      };
+      poll();
+    },
+
+    // Subscribe to a channel
+    subscribe: function(channel, func, lastId) {
+
+      if(!started && !stopped){
+        me.start();
+      }
+
+      if (typeof(lastId) !== "number" || lastId < -1){
+        lastId = -1;
+      }
+      callbacks.push({
+        channel: channel,
+        func: func,
+        last_id: lastId
+      });
+      if (me.longPoll) {
+        return me.longPoll.abort();
+      }
+    },
+
+    // Unsubscribe from a channel
+    unsubscribe: function(channel) {
+      // TODO proper globbing
+      var glob;
+      if (channel.indexOf("*", channel.length - 1) !== -1) {
+        channel = channel.substr(0, channel.length - 1);
+        glob = true;
+      }
+      callbacks = $.grep(callbacks,function(callback) {
+        if (glob) {
+          return callback.channel.substr(0, channel.length) !== channel;
+        } else {
+          return callback.channel !== channel;
+        }
+      });
+      if (me.longPoll) {
+        return me.longPoll.abort();
+      }
+    }
+  };
+
+  return me;
+})();

data/examples/bench/ab.sample

@@ -0,0 +1 @@
+ab -n 1000 -c 25 -p payload.post -T "application/x-www-form-urlencoded" "http://localhost:3000/message-bus/poll"

data/examples/bench/config.ru

@@ -0,0 +1,24 @@
+require 'message_bus'
+
+if defined?(PhusionPassenger)
+    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+        if forked
+            # We're in smart spawning mode.
+            MessageBus.after_fork
+        else
+            # We're in conservative spawning mode. We don't need to do anything.
+        end
+    end
+end
+
+
+# require 'rack-mini-profiler'
+
+# Rack::MiniProfiler.config.storage = Rack::MiniProfiler::MemoryStore
+
+# use Rack::MiniProfiler
+MessageBus.long_polling_interval = 1000 * 2
+MessageBus.rack_hijack_enabled = true
+MessageBus.max_active_clients = 3
+use MessageBus::Rack::Middleware
+run lambda { |env| [200, {"Content-Type" => "text/html"}, ["Howdy"]]  }

data/examples/bench/payload.post

@@ -0,0 +1 @@
+foo=222&bob=1

data/examples/bench/unicorn.conf.rb

@@ -0,0 +1,4 @@
+require 'message_bus'
+after_fork do |server, worker|
+  MessageBus.after_fork
+end

data/examples/chat/chat.rb

@@ -0,0 +1,74 @@
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+require 'message_bus'
+require 'sinatra'
+require 'sinatra/base'
+
+
+class Chat < Sinatra::Base
+
+  set :public_folder,  File.expand_path('../../../assets',__FILE__)
+
+  use MessageBus::Rack::Middleware
+
+  post '/message' do
+    MessageBus.publish '/message', params
+
+    "OK"
+  end
+
+  get '/' do
+
+<<HTML
+
+<html>
+  <head>
+    <script src="/jquery-1.8.2.js"></script>
+    <script src="/message-bus.js"></script>
+  </head>
+  <body>
+    <p>Chat Demo</p>
+    <div id='messages'></div>
+    <div id='panel'>
+      <form>
+        <textarea cols=80 rows=2></textarea>
+      </form>
+    </div>
+    <div id='your-name'>Enter your name: <input type='text'/>
+
+    <script>
+      $(function() {
+        var name;
+
+        $('#messages, #panel').hide();
+
+        $('#your-name input').keyup(function(e){
+          if(e.keyCode == 13) {
+            name = $(this).val();
+            $('#your-name').hide();
+            $('#messages, #panel').show();
+          }
+        });
+
+
+        MessageBus.subscribe("/message", function(msg){
+          $('#messages').append("<p>"+ msg.name + " said: " + msg.data + "</p>");
+        }, 0); // last id is zero, so getting backlog
+
+
+        $('textarea').keyup(function(e){
+          if(e.keyCode == 13) {
+            $.post("/message", { data: $('form textarea').val(), name: name} );
+            $('textarea').val("");
+          }
+        });
+
+      });
+    </script>
+  </body>
+</html>
+
+HTML
+  end
+
+  run! if app_file == $0
+end

data/examples/chat/config.ru

@@ -0,0 +1,2 @@
+require './chat'
+run Chat

data/lib/message_bus.rb

@@ -51,6 +51,38 @@ module MessageBus::Implementation
     @long_polling_enabled = val
   end
 
+  # The number of simultanuous clients we can service
+  #  will revert to polling if we are out of slots
+  def max_active_clients=(val)
+    @max_active_clients = val
+  end
+
+  def max_active_clients
+    @max_active_clients || 1000
+  end
+
+  def rack_hijack_enabled?
+    if @rack_hijack_enabled.nil?
+      @rack_hijack_enabled = true
+
+      # without this switch passenger will explode
+      # it will run out of connections after about 10
+      if defined? PhusionPassenger
+        @rack_hijack_enabled = false
+        if PhusionPassenger.respond_to? :advertised_concurrency_level
+          PhusionPassenger.advertised_concurrency_level = 0
+          @rack_hijack_enabled = true
+        end
+      end
+    end
+
+    @rack_hijack_enabled
+  end
+
+  def rack_hijack_enabled=(val)
+    @rack_hijack_enabled = val
+  end
+
   def long_polling_interval=(millisecs)
     @long_polling_interval = millisecs
   end
@@ -96,6 +128,18 @@ module MessageBus::Implementation
     @is_admin_lookup
   end
 
+  def client_filter(channel, &blk)
+    @client_filters ||= {}
+    @client_filters[channel] = blk if blk
+    @client_filters[channel]
+  end
+
+  def around_client_batch(channel, &blk)
+    @around_client_batches ||= {}
+    @around_client_batches[channel] = blk if blk
+    @around_client_batches[channel]
+  end
+
   def on_connect(&blk)
     @on_connect = blk if blk
     @on_connect
@@ -158,9 +202,9 @@ module MessageBus::Implementation
 
   # encode channel name to include site
   def encode_channel_name(channel)
-    if MessageBus.site_id_lookup
+    if site_id_lookup
       raise ArgumentError.new channel if channel.include? ENCODE_SITE_TOKEN
-      "#{channel}#{ENCODE_SITE_TOKEN}#{MessageBus.site_id_lookup.call}"
+      "#{channel}#{ENCODE_SITE_TOKEN}#{site_id_lookup.call}"
     else
       channel
     end
@@ -179,13 +223,13 @@ module MessageBus::Implementation
   end
 
   def local_unsubscribe(channel=nil, &blk)
-    site_id = MessageBus.site_id_lookup.call if MessageBus.site_id_lookup
+    site_id = site_id_lookup.call if site_id_lookup
     unsubscribe_impl(channel, site_id, &blk)
   end
 
   # subscribe only on current site
   def local_subscribe(channel=nil, &blk)
-    site_id = MessageBus.site_id_lookup.call if MessageBus.site_id_lookup
+    site_id = site_id_lookup.call if site_id_lookup
     subscribe_impl(channel, site_id, &blk)
   end
 
@@ -208,6 +252,16 @@ module MessageBus::Implementation
     reliable_pub_sub.last_id(encode_channel_name(channel))
   end
 
+
+  def destroy
+    reliable_pub_sub.global_unsubscribe
+  end
+
+  def after_fork
+    reliable_pub_sub.after_fork
+    ensure_subscriber_thread
+  end
+
   protected
 
   def decode_message!(msg)
@@ -239,10 +293,11 @@ module MessageBus::Implementation
     end
   end
 
+
   def ensure_subscriber_thread
     @mutex ||= Mutex.new
     @mutex.synchronize do
-      return if @subscriber_thread
+      return if @subscriber_thread && @subscriber_thread.alive?
       @subscriber_thread = Thread.new do
         reliable_pub_sub.global_subscribe do |msg|
           begin