message_bus 2.0.0.beta.2 → 2.0.0.beta.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a32c3e5353a1c04d239f2ddba14caf80cc63eafa
-  data.tar.gz: 271d25c01760c1e04d9bd4aca26524629d42b12f
+  metadata.gz: 13a3191447206ef44053ab24b6ae199b7e18d11e
+  data.tar.gz: 2b5037efdc6052aec3e6087461b26d5902ea0971
 SHA512:
-  metadata.gz: 17214e44a821ca146db76a7e22ae3eeada69024c6eaea5351aac4aaaa78bcaf4bebb68aa5cb460c77bc9c172aef5e5ac7e932a040b935e27210a4584f701f7d2
-  data.tar.gz: 259dafb9a6538358b03a63bad0cb521d89ea3e680be667fb4fb85ffdeea3ee4aeedba31db9e843d209bda73dbc0765000c75ad68fcfc9b888294cc18b97615de
+  metadata.gz: 6a3d536e64f1efd37eec538cbef41b794a083cb9516d4457b26d0c2b4d24af886162720a46896951e6921333be15abce7c573898ac0b277a38f90681b1612a1e
+  data.tar.gz: 9aabc10913a3816708fc808893d98cfea290940af41b0ab19478633db2abfcdc2091df8c8140c3fdfc9f82ea3e7f27970688c0310536003bb259dd3c3db7e14c

data/.travis.yml

@@ -3,9 +3,17 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.2
-  - 2.2
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
 gemfile:
   - Gemfile
+addons:
+  postgresql: "9.4"
+env:
+  - PGUSER=postgres
+before_script:
+  - psql -c 'create database message_bus_test;' -U postgres
 services:
   - redis-server
+  - postgresql

data/CHANGELOG

@@ -1,3 +1,13 @@
+29-02-2016
+
+- Version 2.0.0.beta.3
+
+- Feature: Postgresql backend @jeremyevans
+- Breaking Change: Configuration API changed see Readme for details @jeremyevans
+- Breaking Change: Remove runtime dependency on Redis @jeremyevans
+- Dev: Convert all specs to minitest @jeremyevans
+- Feature: Support passing channels to Rack middleware via env['message_bus.channels'] via @jeremyevans
+
 03-01-2016
 
 - Version 2.0.0.beta.2

data/Gemfile

@@ -4,13 +4,8 @@ source 'https://rubygems.org'
 gemspec
 
 group :test do
-  gem 'rspec'
-  gem 'redis'
+  gem 'minitest'
   gem 'rake'
-  gem 'rbtrace'
-  gem 'guard-rspec'
-  gem 'rb-inotify', require: RUBY_PLATFORM =~ /linux/i ? 'rb-inotify' : false
-  gem 'rack'
   gem 'http_parser.rb'
   gem 'thin'
   gem 'rack-test', require: 'rack/test'

data/README.md

@@ -1,6 +1,6 @@
 # MessageBus
 
-A reliable, robust messaging bus for Ruby processes and web clients built on Redis.
+A reliable, robust messaging bus for Ruby processes and web clients.
 
 MessageBus implements a Server to Server channel based protocol and Server to Web Client protocol (using polling, long-polling or long-polling + streaming)
 
@@ -49,21 +49,21 @@ MessageBus.backlog "/channel", id
 # returns all messages after the id
 
 # messages can be targetted at particular users or groups
-MessageBus.publish "/channel", user_ids: [1,2,3], group_ids: [4,5,6]
+MessageBus.publish "/channel", "hello", user_ids: [1,2,3], group_ids: [4,5,6]
 
 # messages can be targetted at particular clients (using MessageBus.clientId)
-MessageBus.publish "/channel", client_ids: ["XXX","YYY"]
+MessageBus.publish "/channel", "hello", client_ids: ["XXX","YYY"]
 
 # message bus determines the user ids and groups based on env
 
-MessageBus.user_id_lookup do |env|
+MessageBus.configure(user_id_lookup: proc do |env|
   # return the user id here
-end
+end)
 
-MessageBus.group_ids_lookup do |env|
+MessageBus.configure(group_ids_lookup: proc do |env|
   # return the group ids the user belongs to
   # can be nil or []
-end
+end)
 ```
 
 ### Transport
@@ -100,7 +100,7 @@ MessageBus.enableChunkedEncoding = false; // in your JavaScript
 Or
 
 ```
-MessageBus.chunked_encoding_enabled = false // in Ruby
+MessageBus.configure(chunked_encoding_enabled: false) // in Ruby
 ```
 
 Long Polling requires no special setup, as soon as new data arrives on the channel the server delivers the data and closes the connection.
@@ -113,9 +113,9 @@ MessageBus can be used in an environment that hosts multiple sites by multiplexi
 
 ```ruby
 # define a site_id lookup method
-MessageBus.site_id_lookup do
+MessageBus.configure(site_id_lookup: proc do
   some_method_that_returns_site_id_string
-end
+end)
 
 # you may post messages just to this site
 MessageBus.publish "/channel", "some message"
@@ -137,6 +137,11 @@ JavaScript can listen on any channel (and receive notification via polling or lo
 ```
 Note, the message-bus.js file is located in the assets folder.
 
+**Rails**
+```javascript
+//= require message-bus
+```
+
 ```javascript
 MessageBus.start(); // call once at startup
 
@@ -148,6 +153,10 @@ MessageBus.subscribe("/channel", function(data){
 
 ```
 
+There is also a Ruby implementation of the client library, at
+[message_bus-client](https://github.com/lowjoel/message_bus-client) with the API very similar to
+that of the JavaScript client.
+
 **Client settings**:
 
 
@@ -179,6 +188,13 @@ ajax|$.ajax|The only dependency on jQuery, you may set up a custom ajax function
 
 `MessageBus.unsubscribe(channel,func)` : Unsubscribe callback from a particular channel
 
+## Running tests
+
+To run tests you need both Postgres and Redis installed. By default we will connect to the database `message_bus_test` with the current username. If you wish to override this:
+
+```
+PGUSER=some_user PGDATABASE=some_db bundle exec rake
+```
 
 
 ## Configuration
@@ -188,13 +204,23 @@ ajax|$.ajax|The only dependency on jQuery, you may set up a custom ajax function
 You can configure redis setting in `config/initializers/message_bus.rb`, like
 
 ```ruby
-MessageBus.redis_config = { url: "redis://:p4ssw0rd@10.0.1.1:6380/15" }
+MessageBus.configure(backend: :redis, url: "redis://:p4ssw0rd@10.0.1.1:6380/15")
 ```
 The redis client message_bus uses is [redis-rb](https://github.com/redis/redis-rb), so you can visit it's repo to see what options you can configure.
 
+### PostgreSQL
+
+message_bus also supports PostgreSQL as the backend:
+
+```ruby
+MessageBus.configure(backend: :postgres, backend_options: {user: 'message_bus', dbname: 'message_bus'})
+```
+
+The PostgreSQL client message_bus uses is [ruby-pg](https://bitbucket.org/ged/ruby-pg), so you can visit it's repo to see what options you can configure.
+
 ### Forking/threading app servers
 
-If you're using a forking or threading app server and you're not getting immediate updates from published messages, you might need to reconnect Redis in your app server config:
+If you're using a forking or threading app server and you're not getting immediate updates from published messages, you might need to reconnect Redis/PostgreSQL in your app server config:
 
 #### Passenger
 ```ruby
@@ -229,14 +255,15 @@ after_fork do |server, worker|
 end
 ```
 
+### 
+
 ## Want to help?
 
 If you are looking to contribute to this project here are some ideas
 
-- Build an in-memory storage backend to ease testing and for very simple deployments
-- Build a PostgreSQL backend using NOTIFY and LISTEN
-- Improve general documentation
-- Port the test suite to MiniTest
+- Build backends for other providers (zeromq, rabbitmq, disque)
+- Improve and properly document admin dashboard (add opt-in stats, better diagnostics into queues)
+- Improve general documentation (Add examples, refine existing examples)
 - Make MessageBus a nice website
 
 

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'rake/testtask'
 require 'bundler'
 require 'bundler/gem_tasks'
 require 'bundler/setup'
@@ -7,8 +8,21 @@ Bundler.require(:default, :test)
 
 task :default => [:spec]
 
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-    spec.pattern = FileList['spec/**/*_spec.rb']
+run_spec = proc do |backend|
+  begin
+    ENV['MESSAGE_BUS_BACKEND'] = backend
+    sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| load f}\" #{Dir['spec/**/*_spec.rb'].to_a.join(' ')}"
+  ensure
+    ENV.delete('MESSAGE_BUS_BACKEND')
+  end
+end
+
+task :spec => [:spec_redis, :spec_postgres]
+
+task :spec_redis do
+  run_spec.call('redis')
+end
+
+task :spec_postgres do
+  run_spec.call('postgres')
 end

data/lib/message_bus.rb

@@ -7,7 +7,6 @@ require "message_bus/connection_manager"
 require "message_bus/diagnostics"
 require "message_bus/rack/middleware"
 require "message_bus/rack/diagnostics"
-require "message_bus/redis/reliable_pub_sub"
 require "message_bus/timer_thread"
 
 # we still need to take care of the logger
@@ -16,10 +15,13 @@ if defined?(::Rails)
 end
 
 module MessageBus; end
+MessageBus::BACKENDS = {}
 class MessageBus::InvalidMessage < StandardError; end
 class MessageBus::BusDestroyed < StandardError; end
 
 module MessageBus::Implementation
+  # Configuration options hash
+  attr_reader :config
 
   # Like Mutex but safe for recursive calls
   class Synchronizer
@@ -27,87 +29,90 @@ module MessageBus::Implementation
   end
 
   def initialize
+    @config = {}
     @mutex = Synchronizer.new
   end
 
   def cache_assets=(val)
-    @cache_assets = val
+    configure(cache_assets: val)
   end
 
   def cache_assets
-    if defined? @cache_assets
-      @cache_assets
+    if defined? @config[:cache_assets]
+      @config[:cache_assets]
     else
       true
     end
   end
 
   def logger=(logger)
-    @logger = logger
+    configure(logger: logger)
   end
 
   def logger
-    return @logger if @logger
+    return @config[:logger] if @config[:logger]
     require 'logger'
-    @logger = Logger.new(STDOUT)
-    @logger.level = Logger::INFO
-    @logger
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    configure(logger: logger)
+    logger
   end
 
   def chunked_encoding_enabled?
-    @chunked_encoding_enabled == false ? false : true
+    @config[:chunked_encoding_enabled] == false ? false : true
   end
 
   def chunked_encoding_enabled=(val)
-    @chunked_encoding_enabled = val
+    configure(chunked_encoding_enabled: val)
   end
 
   def long_polling_enabled?
-    @long_polling_enabled == false ? false : true
+    @config[:long_polling_enabled] == false ? false : true
   end
 
   def long_polling_enabled=(val)
-    @long_polling_enabled = val
+    configure(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
+    configure(max_active_clients: val)
   end
 
   def max_active_clients
-    @max_active_clients || 1000
+    @config[:max_active_clients] || 1000
   end
 
   def rack_hijack_enabled?
-    if @rack_hijack_enabled.nil?
-      @rack_hijack_enabled = true
+    if @config[:rack_hijack_enabled].nil?
+      enable = true
 
       # without this switch passenger will explode
       # it will run out of connections after about 10
       if defined? PhusionPassenger
-        @rack_hijack_enabled = false
+        enable = false
         if PhusionPassenger.respond_to? :advertised_concurrency_level
           PhusionPassenger.advertised_concurrency_level = 0
-          @rack_hijack_enabled = true
+          enable = true
         end
       end
+      configure(rack_hijack_enabled: enable)
     end
 
-    @rack_hijack_enabled
+    @config[:rack_hijack_enabled]
   end
 
   def rack_hijack_enabled=(val)
-    @rack_hijack_enabled = val
+    configure(rack_hijack_enabled: val)
   end
 
   def long_polling_interval=(millisecs)
-    @long_polling_interval = millisecs
+    configure(long_polling_interval: millisecs)
   end
 
   def long_polling_interval
-    @long_polling_interval || 25 * 1000
+    @config[:long_polling_interval] || 25 * 1000
   end
 
   def off
@@ -118,56 +123,58 @@ module MessageBus::Implementation
     @off = false
   end
 
+  def configure(config)
+    @config.merge!(config)
+  end
+
   # Allow us to inject a redis db
   def redis_config=(config)
-    @redis_config = config
+    configure(config.merge(:backend=>:redis))
   end
 
-  def redis_config
-    @redis_config ||= {}
-  end
+  alias redis_config config
 
   def site_id_lookup(&blk)
-    @site_id_lookup = blk if blk
-    @site_id_lookup
+    configure(site_id_lookup: blk) if blk
+    @config[:site_id_lookup]
   end
 
   def user_id_lookup(&blk)
-    @user_id_lookup = blk if blk
-    @user_id_lookup
+    configure(user_id_lookup: blk) if blk
+    @config[:user_id_lookup]
   end
 
   def group_ids_lookup(&blk)
-    @group_ids_lookup = blk if blk
-    @group_ids_lookup
+    configure(group_ids_lookup: blk) if blk
+    @config[:group_ids_lookup]
   end
 
   def is_admin_lookup(&blk)
-    @is_admin_lookup = blk if blk
-    @is_admin_lookup
+    configure(is_admin_lookup: blk) if blk
+    @config[:is_admin_lookup]
   end
 
   def extra_response_headers_lookup(&blk)
-    @extra_response_headers_lookup = blk if blk
-    @extra_response_headers_lookup
+    configure(extra_response_headers_lookup: blk) if blk
+    @config[:extra_response_headers_lookup]
   end
 
   def on_connect(&blk)
-    @on_connect = blk if blk
-    @on_connect
+    configure(on_connect: blk) if blk
+    @config[:on_connect]
   end
 
   def on_disconnect(&blk)
-    @on_disconnect = blk if blk
-    @on_disconnect
+    configure(on_disconnect: blk) if blk
+    @config[:on_disconnect]
   end
 
   def allow_broadcast=(val)
-    @allow_broadcast = val
+    configure(allow_broadcast: val)
   end
 
   def allow_broadcast?
-    @allow_broadcast ||=
+    @config[:allow_broadcast] ||=
       if defined? ::Rails
         ::Rails.env.test? || ::Rails.env.development?
       else
@@ -176,16 +183,24 @@ module MessageBus::Implementation
   end
 
   def reliable_pub_sub=(pub_sub)
-    @reliable_pub_sub = pub_sub
+    configure(reliable_pub_sub: pub_sub)
   end
 
   def reliable_pub_sub
     @mutex.synchronize do
       return nil if @destroyed
-      @reliable_pub_sub ||= MessageBus::Redis::ReliablePubSub.new redis_config
+      @config[:reliable_pub_sub] ||= begin
+        @config[:backend_options] ||= {}
+        require "message_bus/backends/#{backend}"
+        MessageBus::BACKENDS[backend].new @config
+      end
     end
   end
 
+  def backend
+    @config[:backend] || :redis
+  end
+
   def enable_diagnostics
     MessageBus::Diagnostics.enable
   end
@@ -333,11 +348,11 @@ module MessageBus::Implementation
   # a keepalive will run every N seconds, if it fails
   # process is killed
   def keepalive_interval=(interval)
-    @keepalive_interval = interval
+    configure(keepalive_interval: interval)
   end
 
   def keepalive_interval
-    @keepalive_interval || 60
+    @config[:keepalive_interval] || 60
   end
 
   protected
@@ -459,6 +474,8 @@ module MessageBus::Implementation
 
         @mutex.synchronize do
           raise MessageBus::BusDestroyed if @destroyed
+          next unless @subscriptions
+
           globals = @subscriptions[nil]
           locals = @subscriptions[msg.site_id] if msg.site_id