wamp_server 0.1

data/test/test_app/main.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler/setup'
+require_relative '../../lib/wamp_server'
+require_relative 'test_app'
+
+module MyServer
+
+  def before_start
+    TestApp.init
+  end
+
+  def onprefix(opts)
+    TestApp.save_prefix opts[:ws], opts[:prefix], opts[:uri]
+  end
+
+  def onwelcome(opts)
+    TestApp.init_session opts[:ws]
+  end
+
+  def oncall(opts)
+    uri = TestApp.solve_uri opts[:ws], opts[:curie]
+    controller, action = TestApp.parse_uri uri
+    TestApp.route(controller, action, *opts[:args])
+  end
+
+  def onpublish(opts)
+    uri = TestApp.solve_uri opts[:ws], opts[:curie]
+    subscribed = TestApp.get_suscriptions uri
+    { :uri => uri, :subscribed => subscribed }
+  end
+
+  def onsubscribe(opts)
+    uri = TestApp.solve_uri opts[:ws], opts[:curie]
+    TestApp.subscribe opts[:ws], uri
+  end
+
+  def onunsubscribe(opts)
+    uri = TestApp.solve_uri opts[:ws], opts[:curie]
+    TestApp.unsubscribe opts[:ws], uri
+  end
+
+  def onclose(opts)
+    TestApp.remove_session opts[:ws]
+  end
+
+end
+
+WAMP.start_server MyServer

data/test/test_app/memory.rb

@@ -0,0 +1,60 @@
+module TestApp
+  module Drivers
+    class Memory
+      @@db = {}
+
+      def self.get_db(table); @@db[table].map{|k,v| v[:_id] = k; v};end
+
+      def self.init
+        @@db = {}
+        clear_sessions
+      end
+
+      def self.init_session(ws)
+        @@db['sessions'] ||= {}
+        @@db['sessions'][ws.object_id] = {}
+        ws.object_id
+      end
+
+      def self.save_prefix(ws,prefix,uri)
+        @@db['sessions'][ws.object_id][:prefixes] ||= {}
+        @@db['sessions'][ws.object_id][:prefixes][prefix] = uri
+      end
+
+      def self.solve_uri(ws,uri)
+        return uri if @@db['sessions'][ws.object_id].nil? or
+                        @@db['sessions'][ws.object_id][:prefixes].nil?
+
+        prefix, action = uri.split(':') # 'prefix:action'
+        solved = @@db['sessions'][ws.object_id][:prefixes][prefix]
+        solved ? "#{solved}#{action}" : uri
+      end
+
+      def self.clear_sessions
+        @@db['sessions'] = {}
+      end
+
+      def self.remove_session(ws)
+        @@db['sessions'].delete ws.object_id
+      end
+
+      def self.subscribe(ws,uri)
+        @@db['sessions'][ws.object_id][:subscriptions] ||= {}
+        @@db['sessions'][ws.object_id][:subscriptions][uri] = {}
+      end
+
+      def self.unsubscribe(ws,uri)
+        return if @@db['sessions'][ws.object_id][:subscriptions].nil?
+        @@db['sessions'][ws.object_id][:subscriptions].delete uri
+      end
+
+      def self.get_suscriptions(uri)
+        @@db['sessions'].select do |id,sess|
+          subs = sess[:subscriptions]
+          subs and subs[uri]
+        end.keys
+      end
+
+    end
+  end
+end

data/test/test_app/test_app.rb

@@ -0,0 +1,64 @@
+require 'forwardable'
+require_relative 'helpers'
+require_relative 'memory'
+require_relative 'test_controller'
+
+module TestApp
+  extend SingleForwardable
+
+  def self.delegate
+    def_delegators @@driver, :init_session, :save_prefix, :solve_uri,
+                         :clear_sessions, :remove_session,
+                         :subscribe, :unsubscribe, :get_suscriptions
+  end
+
+  def self.driver; @@driver; end
+
+  def self.init(driver = TestApp::Drivers::Memory)
+    @@driver = driver
+    delegate
+    @@driver.init
+    @@driver.clear_sessions
+    @@routes = {}
+    fill_routes @@routes
+  end
+
+=begin
+  Rellena el hash routes usando todos los constants *Controller como primer nivel
+  y los métodos *_action como segundo nivel, y guardando el método como valor final:
+
+  routes = {
+    'a_controller' => {
+      'a_action' => AController.a_action
+    }
+  }
+
+  El enrutamiento se reduce a buscar una key en un hash.
+=end
+  def self.fill_routes(routes)
+    controllers = TestApp.constants.grep /^.+Controller$/
+    controllers.each do |c|
+      controller = TestApp.const_get(c)
+      c = c.to_s.sub(/Controller$/,'')
+      actions = controller.methods.grep(/^.+_action$/)
+      actions.each do |a|
+        routes[c.to_s.underscore] ||= {}
+        routes[c.to_s.underscore][a.to_s.sub(/_action$/,'')] = controller.method(a)
+      end
+    end
+  end
+
+  def self.route(controller, action, *args)
+    if @@routes[controller].nil? or
+        @@routes[controller][action].nil? then
+      raise "Not Found #{controller}##{action}"
+    end
+
+    return @@routes[controller][action].call(*args)
+  end
+
+  def self.parse_uri(uri)
+    uri =~ %r_http://([^#]+)#(.+)_
+    [$1, $2]
+  end
+end

data/test/test_app/test_controller.rb

@@ -0,0 +1,11 @@
+module TestApp
+  module TestController
+    def self.get_db_action(*args)
+      TestApp.driver.get_db(*args)
+    end
+
+    def self.subscribe_test(*args)
+      TestApp.driver.subscribe(*args)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,202 @@
+require 'minitest/pride'
+require 'minitest/autorun'
+require 'websocket-eventmachine-client'
+require 'pty'
+require 'socket'
+require 'timeout'
+require 'json'
+require 'em-synchrony'
+
+require_relative 'log_helpers'
+
+class TestCase < Minitest::Test
+
+  # hijack a satellite client to be the main client
+  def run_ws_client(opts = {})
+
+    info = {} # hash to gather info
+
+    prev_onclose = opts[:onclose]
+    opts[:onclose] = lambda do |ws,info|
+      prev_onclose.call(ws,info) if prev_onclose
+      EM.stop # stop after this client closes
+    end
+
+    EM.run do
+      run_satellite_ws_client info, opts
+    end
+    info
+  end
+
+  # run a WebSocket::EventMachine::Client assuming to be a satellite client,
+  # i.e. inside an EM.run loop and not stopping it
+  def run_satellite_ws_client(info, opts = {})
+
+    opts[:onopen] ||= lambda{ |ws,info| }
+    opts[:onmessage] ||= lambda{ |ws,msg,type,info| ws.close } # remember to close ws !
+    opts[:onclose] ||= lambda{ |ws,info| }
+
+    connection_timeout = opts[:connection_timeout] || 1 # timeout until onopen
+    message_timeout = opts[:message_timeout] || 5       # timeout between messages
+
+    timer = EM::Timer.new(connection_timeout){ raise Timeout::Error.new "Waited #{connection_timeout} seconds !" }
+    ws = WebSocket::EventMachine::Client.connect(:uri => 'ws://0.0.0.0:3000')
+
+    ws.onopen do
+      timer.cancel
+      Fiber.new do opts[:onopen].call(ws,info) end.resume
+      timer = EM::Timer.new(message_timeout){ raise Timeout::Error.new "Waited #{message_timeout} seconds !" }
+    end
+
+    ws.onmessage do |msg, type|
+      timer.cancel
+      info[:messages] ||= []
+      info[:messages] << JSON.parse(msg)
+      Fiber.new do opts[:onmessage].call(ws,msg,type,info) end.resume
+      timer = EM::Timer.new(message_timeout){ raise Timeout::Error.new "Waited #{message_timeout} seconds !" }
+    end
+
+    ws.onclose do
+      timer.cancel
+      Fiber.new do opts[:onclose].call(ws,info) end.resume
+    end
+  end
+
+  def wait_for(timeout = 3)
+    loc = caller_locations(1,1)[0]
+    place = loc.path + ":" + loc.lineno.to_s
+    timer = EM::Timer.new(timeout){ assert false, "Waited #{timeout} seconds on #{place}" }
+    while(!yield) do EM::Synchrony.sleep(0.1) end
+    timer.cancel
+  end
+
+  def check_is_json(txt)
+    begin
+      data = JSON.parse(txt)
+    rescue => err
+      H.log_ex err, msg: "Is not JSON: #{txt}"
+    end
+    assert !data.nil?, msg: "Is not JSON: #{txt}"
+    data
+  end
+
+  # make a call to test controller from within the same client
+  # assumes no one is making any calls while it's acting
+  #
+  def call(ws, action, *args)
+    cmd = [WAMP::CALL, 'id', "http://test##{action}"] + args
+    result = nil
+
+    # save current callback
+    prev_onmessage = ws.instance_variable_get(:@onmessage)
+
+    calling_fiber = Fiber.current
+
+    # put in place a temp callback to get the result
+    new_onmessage = Proc.new do |msg, type|
+      data = check_is_json msg
+      result = data.last
+      calling_fiber.resume
+    end
+    ws.instance_variable_set(:@onmessage, new_onmessage)
+
+    # make the call
+    ws.send cmd.to_json
+
+    # yield until the callback resumes this fiber
+    Fiber.yield
+
+    # return the original callback
+    ws.instance_variable_set(:@onmessage, prev_onmessage)
+
+    result
+  end
+
+  # make a request to test controller running a new ws_client
+  def request(action, *args)
+    cmd = [WAMP::CALL, 'id', "http://test##{action}"] + args
+    result = nil
+    cb = lambda do |ws,msg,type,info|
+      data = check_is_json msg
+      if data.first == WAMP::WELCOME then
+        ws.send cmd.to_json
+      else # CALLRESULT or CALLERROR
+        result = data.last
+        ws.close
+      end
+    end
+    run_ws_client onmessage: cb
+    result
+  end
+
+  def assert(boolean, message=nil)
+    message = message.call if message.respond_to?(:call)
+    message = H.yellow(message.to_s) + H.brown("\n#{caller}")
+    super(boolean, message)
+  end
+
+  def todo(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 TODO: #{label} (#{place})..."
+    opts[:color] ||= :yellow
+    opts[:clean] = true
+    H.log msg, opts
+    skip msg
+  end
+
+end
+
+##
+# Start a server before running tests and cleanup afterwards
+
+SERVER_CMD="ruby test/test_app/main.rb"
+
+def is_online?
+  s = TCPSocket.new 'localhost', 3000
+  s.close
+  true
+rescue Errno::ECONNREFUSED, Errno::ECONNRESET
+  false
+end
+
+def wait_for_server_to_be_online(timeout = 5)
+  print "Waiting for server to be online..."
+  t = Time.now
+  while not is_online? do
+    print '.'
+    raise Timeout::Error.new "Waited #{timeout} seconds !" if Time.now - t > timeout
+    sleep 0.2
+  end
+end
+
+def wait_for_server_to_be_offline(timeout = 5)
+  print "Ensuring server is offline..."
+  t = Time.now
+  while is_online? do
+    print '.'
+    raise Timeout::Error.new "Waited #{timeout} seconds !" if Time.now - t > timeout
+    sleep 0.2
+  end
+  puts 'ok'
+end
+
+def clean_test_stuff
+  `pkill -f '#{SERVER_CMD}'`
+  wait_for_server_to_be_offline
+end
+
+Minitest.after_run{ clean_test_stuff }
+trap("INT") { clean_test_stuff; exit 0 }
+
+clean_test_stuff # just in case
+
+Thread.new do
+  begin
+    PTY.spawn( "bundle exec " + SERVER_CMD + " 2>&1" ) do |stdin, stdout, pid|
+      begin; stdin.each { |line| print line }; rescue Errno::EIO; end
+    end
+  rescue PTY::ChildExited; puts "The child process exited!";  end
+end
+
+wait_for_server_to_be_online

data/wamp_server.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/version"
+
+Gem::Specification.new do |s|
+  s.name        = "wamp_server"
+  s.version     = WAMP::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ruben Caro"]
+  s.email       = ["ruben.caro@lanuez.org"]
+  s.homepage    = "https://github.com/rubencaro/wamp_server"
+  s.summary = "Simple WAMPv1 compliant server"
+  s.description = "WAMPv1 compliant server to be used "+
+                  "as a skeleton for nice and shining Ruby apps, based on "+
+                  "WebSocket EventMachine Server."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.license = "GPLv3"
+
+  s.required_ruby_version     = '>= 2.0.0'
+
+  s.add_dependency 'websocket-eventmachine-server'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'websocket-eventmachine-client'
+  s.add_development_dependency 'em-synchrony'
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: wamp_server
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Ruben Caro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-server
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: WAMPv1 compliant server to be used as a skeleton for nice and shining
+  Ruby apps, based on WebSocket EventMachine Server.
+email:
+- ruben.caro@lanuez.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/version.rb
+- lib/wamp_server.rb
+- test/log_helpers.rb
+- test/main_test.rb
+- test/test_app/helpers.rb
+- test/test_app/main.rb
+- test/test_app/memory.rb
+- test/test_app/test_app.rb
+- test/test_app/test_controller.rb
+- test/test_helper.rb
+- wamp_server.gemspec
+homepage: https://github.com/rubencaro/wamp_server
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Simple WAMPv1 compliant server
+test_files:
+- test/log_helpers.rb
+- test/main_test.rb
+- test/test_app/helpers.rb
+- test/test_app/main.rb
+- test/test_app/memory.rb
+- test/test_app/test_app.rb
+- test/test_app/test_controller.rb
+- test/test_helper.rb
+has_rdoc: