wamp_server 0.1

data/README.md

@@ -0,0 +1,8 @@
+wamp_server
+===========
+
+[![Build Status](https://secure.travis-ci.org/rubencaro/wamp_server.png?branch=master)](http://travis-ci.org/rubencaro/wamp_server)
+
+[WAMPv1](http://wamp.ws/spec) compliant server to be used
+as a template for nice and shining Ruby apps, based on
+[WebSocket EventMachine Server](https://github.com/imanel/websocket-eventmachine-server).

data/Rakefile

@@ -0,0 +1,9 @@
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.warning = false
+  test.pattern = 'test/**/*_test.rb'
+end
+
+task :default => :test

data/lib/version.rb

@@ -0,0 +1,3 @@
+module WAMP
+  VERSION = '0.1'
+end

data/lib/wamp_server.rb

@@ -0,0 +1,122 @@
+require 'websocket-eventmachine-server'
+require 'json'
+require_relative 'version'
+
+#
+# see http://wamp.ws/spec
+#
+module WAMP
+
+  WELCOME = 0
+  PREFIX = 1
+  CALL = 2
+  CALLRESULT = 3
+  CALLERROR = 4
+  SUBSCRIBE = 5
+  UNSUBSCRIBE = 6
+  PUBLISH = 7
+  EVENT = 8
+
+  RESPONSES = { :not_json => { :error => 'Message is not JSON !' }.to_json }
+
+  def self.stamp
+    "#{self.name} #{VERSION}"
+  end
+
+  def self.stop_server
+    puts "Terminating WebSocket Server"
+    EM.stop
+  end
+
+  # Start a new Server
+  #
+  # You should pass some callbacks:
+  #
+  #   :before_start => To be called before actually starting the server, but already within EM reactor.
+  #   :onwelcome => To be called for WELCOME calls.
+  #   :onprefix => To be called for PREFIX calls.
+  #   :oncall => To be called when server receives a CALL call.
+  #   :onpublish => To be called when server receives a PUBLISH call.
+  #   :onclose => To be called when a client closes connection.
+  #   :onsubscribe => Called for SUBSCRIBE calls.
+  #   :onunsubscribe => On UNSUBSCRIBE calls.
+  #
+  def self.start_server(a_module, opts = {})
+
+    # avoid more instances
+    a = a_module
+    a.extend a
+
+    host = opts[:host] || '0.0.0.0'
+    port = opts[:port] || '3000'
+
+    EM.run do
+
+      trap("INT") { WAMP.stop_server }
+      trap("TERM") { WAMP.stop_server }
+      trap("KILL") { WAMP.stop_server }
+
+      a.before_start if a.respond_to?(:before_start)
+
+      puts "Listening on #{host}:#{port}"
+      WebSocket::EventMachine::Server.start(:host => host, :port => port) do |ws|
+
+        ws.onopen do
+          Fiber.new do
+            sid = a.onwelcome ws: ws
+            ws.send [WAMP::WELCOME, sid, 1, WAMP.stamp].to_json
+          end.resume
+        end
+
+        ws.onmessage do |msg, type|
+          Fiber.new do
+            begin
+              call = JSON.parse msg
+            rescue JSON::ParserError
+              ws.send( WAMP::RESPONSES[:not_json] )
+            end
+
+            if call.first == WAMP::CALL then
+              # [ TYPE_ID_CALL , callID , procURI , ... ]
+              _, callid, curie, *args = call
+              begin
+                result = a.oncall ws: ws, curie: curie, args: args
+                ws.send [WAMP::CALLRESULT, callid, result].to_json
+              rescue => ex
+                ws.send [WAMP::CALLERROR, callid, "http://error", ex.to_s].to_json
+              end
+            elsif call.first == WAMP::PUBLISH then
+              # [ TYPE_ID_PUBLISH , topicURI , event , exclude , eligible ]
+              _, curie, event, excluded, eligible = call
+              result = a.onpublish curie: curie
+              dest = (result[:subscribed] & eligible) - excluded
+              package = [WAMP::EVENT, result[:uri], event].to_json
+              dest.each do |d|
+                ObjectSpace._id2ref(d).send( package )
+              end
+            elsif call.first == WAMP::SUBSCRIBE then
+              # [ TYPE_ID_SUBSCRIBE , topicURI ]
+              a.onsubscribe ws: ws, curie: call[1]
+            elsif call.first == WAMP::UNSUBSCRIBE then
+              # [ TYPE_ID_UNSUBSCRIBE , topicURI ]
+              a.onunsubscribe ws: ws, curie: call[1]
+            elsif call.first == WAMP::PREFIX then
+              # [ TYPE_ID_PREFIX , prefix, URI ]
+              _, prefix, uri = call
+              a.onprefix ws: ws, uri: uri, prefix: prefix
+            end
+          end.resume
+        end
+
+        ws.onclose do
+          Fiber.new do
+            a.onclose ws: ws
+          end.resume
+        end
+
+      end # Server.start
+    end # EM.run
+
+  end
+
+end

data/test/log_helpers.rb

@@ -0,0 +1,104 @@
+
+module Helpers
+  module Log
+
+    @@next_color = 0 # for alternate
+    @@palette = [:dark_gray, :light_gray]
+
+    def log(msg, opts = {})
+
+      if not opts[:clean] then
+        opts[:location] ||= caller_locations(1,1)[0].label # much faster than 'caller'
+        msg = "[#{opts[:location]}] #{msg}"
+      end
+
+      if opts[:color] then
+        msg = send(opts[:color],msg)
+      end
+
+      msg = "[#{Time.now.strftime('%F %T')}]" + msg if not opts[:clean]
+      puts msg
+      $stdout.flush # as soon as possible
+    end
+
+    def log_ex(ex, opts = {})
+      trace = opts[:trace] || true
+      msg = opts[:msg] || ''
+      msg += light_purple(" \n Exception: #{ex} \n ")
+      msg << purple(" Backtrace: #{ex.backtrace.join("\n")} ") if trace
+      log msg
+    end
+
+    def spit(msg, opts = {}) # allow hashes as msg
+      opts[:color] ||= :light_red
+      opts[:clean] = true
+      l = caller_locations(1,1)[0]
+      log "\n[#{l.label}:#{l.lineno}] \n " + msg.inspect + " \n ", opts
+    end
+
+    def announce(msg = nil, opts = {})
+      label = caller_locations(1,1)[0].label
+      place = File.basename(caller_locations(1,1)[0].path) + ":" + caller_locations(1,1)[0].lineno.to_s
+      msg ||= "\n ==> Entering #{label} (#{place})..."
+      opts[:color] ||= :cyan
+      opts[:clean] = true
+      log msg, opts
+    end
+
+    def yellow(str)
+      " \033[1;33m " + str + " \033[00m "
+    end
+
+    def cyan(str)
+      " \033[0;36m " + str + " \033[00m "
+    end
+
+    def light_cyan(str)
+      " \033[1;36m " + str + " \033[00m "
+    end
+
+    def purple(str)
+      " \033[0;35m " + str + " \033[00m "
+    end
+
+    def light_purple(str)
+      " \033[1;35m " + str + " \033[00m "
+    end
+
+    def brown(str)
+      " \033[0;33m " + str + " \033[00m "
+    end
+
+    def red(str)
+      " \033[0;31m " + str + " \033[00m "
+    end
+
+    def light_red(str)
+      " \033[1;31m " + str + " \033[00m "
+    end
+
+    def light_gray(str)
+      " \033[0;37m " + str + " \033[00m "
+    end
+
+    def dark_gray(str)
+      " \033[1;30m " + str + " \033[00m "
+    end
+
+    def white(str)
+      " \033[1;37m " + str + " \033[00m "
+    end
+
+    def alternate(str)
+      color = @@palette[@@next_color]
+      @@next_color += 1
+      @@next_color = 0 if @@next_color >= @@palette.size
+      send(color,str)
+    end
+
+  end
+
+  extend Log
+end
+
+H = Helpers if not defined? H

data/test/main_test.rb

@@ -0,0 +1,187 @@
+require_relative 'test_helper'
+require_relative '../lib/wamp_server'
+
+class TestMain < TestCase
+
+  def test_plain_ws
+    cb = lambda do |ws,msg,type,info|
+      ws.close
+    end
+    info = run_ws_client onmessage: cb
+    assert_equal 1, info[:messages].count
+  end
+
+  def test_welcome
+    cb = lambda do |ws,msg,type,info|
+      data = check_is_json msg
+      check_is_welcome data
+      result = call(ws,'get_db','sessions')
+      assert_equal 1, result.count, "#{result}"
+      assert result.first['_id'], result
+      ws.close
+    end
+    info = run_ws_client onmessage: cb
+    assert_equal 1, info[:messages].count, info
+  end
+
+  def test_prefix
+    cb = lambda do |ws,msg,type,info|
+      data = check_is_json msg
+
+      assert_equal WAMP::WELCOME, data.first, "#{data}"
+
+      uri = "http://test#"
+      prefix = 'test'
+
+      ws.send [WAMP::PREFIX, prefix, uri].to_json
+      result = call(ws,'get_db','sessions')
+      assert_equal 1, result.count, result
+      assert_equal uri, result.first['prefixes'][prefix], "#{result}"
+      ws.close
+    end
+    info = run_ws_client onmessage: cb
+    assert_equal 1, info[:messages].count, info
+  end
+
+  def test_rpc
+    controller = 'test' # TestController
+    action = 'get_db'   # get_db_action
+    args = ['sessions'] # 'table' argument for get_db_action
+    callid = 'right one'
+    cmd = [WAMP::CALL, callid, "http://#{controller}##{action}"] + args
+
+    cb = lambda do |ws,msg,type,info|
+      data = check_is_json msg
+      if data.first == WAMP::WELCOME then
+        # send the right request right after welcome
+        ws.send cmd.to_json
+      elsif data.first == WAMP::CALLRESULT then
+        # assert the right answer for the right request
+        assert_equal 'right one', data[1], data
+        result = data.last
+        assert_equal 1, result.count, "#{result}"
+        assert result.first['_id'], result
+
+        # send the wrong request to force error
+        callid = 'wrong one'
+        controller = 'not_existing'
+        cmd = [WAMP::CALL, callid, "http://#{controller}##{action}"] + args
+        ws.send cmd.to_json
+      else # WAMP::CALLERROR
+        # assert the right answer for the wrong request
+        assert_equal WAMP::CALLERROR, data.first, "#{data}"
+        assert_equal 'wrong one', data[1], data
+        assert data.last =~ /Not Found/
+        ws.close
+      end
+    end
+    info = run_ws_client onmessage: cb
+    assert_equal 3, info[:messages].count, info
+  end
+
+  def test_subscribe_unsubscribe
+
+    uri = 'http://test/subscribe_test'
+
+    cb = lambda do |ws,msg,type,info|
+      data = check_is_json msg
+      assert_equal WAMP::WELCOME, data.first, data
+
+      # send the subscribe request
+      ws.send [WAMP::SUBSCRIBE,uri].to_json
+
+      # ensure it's subscribed
+      #   subscription is saved within the session
+      #   in a hash where the uri is the key
+      result = call(ws,'get_db','sessions')
+      session = result.select{|r| r['_id'] == data[1]}.first
+      assert session, "#{result} \n #{data}"
+      subs = session['subscriptions']
+      assert subs && (subs.count == 1), session
+      assert subs[uri], subs
+
+      # send the unsubscribe request
+      ws.send [WAMP::UNSUBSCRIBE,uri].to_json
+
+      # ensure it's subscribed
+      result = call(ws,'get_db','sessions')
+      session = result.select{|r| r['_id'] == data[1]}.first
+      subs = session['subscriptions']
+      assert subs && subs.none?, session
+
+      ws.close
+    end
+    info = run_ws_client onmessage: cb
+    assert_equal 1, info[:messages].count, info
+  end
+
+  def test_publish
+
+    sat_info = { :sats => {}, :sent => 0, :received => {} }
+    n = 5
+    uri = 'http://test/subscribe_test'
+    lucky_ones = banned_ones = []
+
+    cb = lambda do |ws,msg,type,info|
+      data = check_is_json msg
+      assert_equal WAMP::WELCOME, data.first, data
+      sid = data[1]
+
+      # run n satellite clients and subscribe them to our topic
+      subscribe_cb = lambda do |ws_sat,msg,type,info|
+        data = check_is_json msg
+        if data.first == WAMP::WELCOME then
+          sat_info[:sats][data[1]] = ws_sat # save it to be closed afterwards
+          ws_sat.send [WAMP::SUBSCRIBE,uri].to_json
+          sat_info[:sent] += 1
+        elsif data.first == WAMP::EVENT then
+          sat_info[:received][ws_sat.object_id] ||= []
+          sat_info[:received][ws_sat.object_id] << msg
+        end
+      end
+      n.times do
+        run_satellite_ws_client info, :onmessage => subscribe_cb
+      end
+
+      # ensure we have audience
+      wait_for { sat_info[:sent] >= n } # until everyone makes the request
+      sessions = call(ws,'get_db','sessions')
+      assert_equal n+1, sessions.count, sessions
+      sessions.reject{|s| s['_id'] == sid}.each do |s|
+        subs = s['subscriptions']
+        assert subs && (subs.count == 1), s
+        assert subs[uri], subs
+      end
+
+      # publish only within the lucky_ones, but not the banned_ones
+      lucky_ones = sat_info[:sats].keys[0..-1] # all but last are allowed
+      banned_ones = sat_info[:sats].keys[0..0] # first is banned
+      ws.send [WAMP::PUBLISH,uri,'hello',banned_ones,lucky_ones].to_json
+
+      # wait until everyone get the event
+      wait_for { sat_info[:received].count >= (lucky_ones - banned_ones).count }
+
+      # test is received by the lucky_ones, not the banned_ones
+      int = sat_info[:received].keys & lucky_ones
+      assert_equal 0, int.count, int
+
+      sat_info[:sats].values.each{ |s| s.close }
+      ws.close
+    end
+    info = run_ws_client onmessage: cb
+
+    # test is published to the lucky_ones, not the banned_ones
+    events = info[:messages].select{ |i| i.first == WAMP::EVENT }
+    assert_equal (lucky_ones - banned_ones).count, events.count, events
+  end
+
+  private
+
+  def check_is_welcome(data)
+    # [ TYPE_ID_WELCOME , sessionId , protocolVersion, serverIdent ]
+    assert_equal 4, data.count
+    assert_equal WAMP::WELCOME, data[0]
+    assert_equal 1, data[2] # protocol version
+  end
+
+end

data/test/test_app/helpers.rb

@@ -0,0 +1,11 @@
+
+class String
+  # simplified version of rails', only get asdf_gfre from AsdfGfre
+  def underscore
+    word = dup
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+  end
+end