wamp 0.0.0 → 0.0.1

data/lib/wamp/protocols/version_1.rb

@@ -0,0 +1,128 @@
+require 'json'
+
+module WAMP::Protocols
+
+  # Describes the WAMP protocol messages per http://www.wamp.ws/spec#call_message
+  class Version1
+    # @return [Integer] The version of the WAMP protocol defined in this class.
+    def version
+      1
+    end
+
+    # Builds the WELCOME message (server to client)
+    # 	[ TYPE_ID_WELCOME , sessionId , protocolVersion, serverIdent ]
+    # @param client_id [String] The server generated ID that the WELCOME message
+    #   is to be sent to.
+    # @return [String] The WELCOME message as a JSON string.
+    def welcome(id)
+      [type[:WELCOME], id, version, server_ident].to_json
+    end
+
+    # Builds the PREFIX message (client to server)
+    # 	[ TYPE_ID_PREFIX , prefix , URI ]
+    # @param prefix [String] The shortened CURIE prefix to be registered.
+    # @param uri    [String] The full URI to register the prefix to.
+    # @return [String] The PREFIX message as a JSON string.
+    def prefix(prefix, uri)
+      [type[:PREFIX], prefix, uri].to_json
+    end
+
+    # Builds the RPC CALL message (client to server)
+    # 	[ TYPE_ID_CALL , callID , procURI , ... ]
+    # @param call_id [String] This should be a randomly generated string to
+    # 	identify the RPC call, the call ID will be returned to the client in the
+    #   RPC CALLRESULT or CALLERROR messages.
+    # @param proc_uri [String] The procURI is a string that identifies the remote
+    #   procedure to be called and MUST be a valid URI or CURIE.
+    # @param *args [Array] Zero or more additional arguments to be sent with the
+    #   CALL message.
+    # @return [String] The CALL message as a JSON string
+    def call(call_id, proc_uri, *args)
+      [type[:CALL], call_id, proc_uri, *args].to_json
+    end
+
+    # Builds the RPC CALLRESULT message (server to client)
+    # 	[ TYPE_ID_CALLRESULT , callID , result ]
+    # @param call_id [String] This should match the call ID given by the client
+    # 	by the client.
+    # @param result [String, Integer, Hash, Array] The results of the RPC procedure
+    #   initiated by the CALL. Defaults to nil of non is given.
+    # @return [String] The CALLRESULT message as a JSON string.
+    def call_result(call_id, result = nil)
+      [type[:CALLRESULT], call_id, result].to_json
+    end
+
+    # Builds the RPC CALLERROR message (server to client)
+    # 	[ TYPE_ID_CALLERROR , callID , errorURI , errorDesc , errorDetails(Optional) ]
+    # @param call_id [String] This should match the call ID given by the client
+    # 	by the client.
+    # @param error_uri [String]  A CURIE or URI identifying the error.
+    # @param error_desc [String] A description of the error that occured.
+    # @param error_details [String] Optional. Used to communicate application
+    #   error details, defined by the error_uri.
+    # @return [String] The ERRORRESULT message as a JSON string.
+    def call_error(call_id, error_uri, error_desc, error_details = nil)
+      msg = [type[:CALLERROR], call_id, error_uri, error_desc, error_details]
+      msg.delete_if { |x| x.nil? }
+      msg.to_json
+    end
+
+    # Builds the PubSub SUBSCRIBE message (client to server)
+    # 	[ TYPE_ID_SUBSCRIBE , topicURI ]
+    # @param topic_uri [String] The topic URI or CURIE (from PREFIX) to receive
+    #   published events to the given topic.
+    # @return [String] The SUBSCRIBE message as a JSON string.
+    def subscribe(topic_uri)
+      [type[:SUBSCRIBE], topic_uri].to_json
+    end
+
+    # Builds the PubSub UNSUBSCRIBE message (client to server)
+    # 	[ TYPE_ID_UNSUBSCRIBE , topicURI ]
+    # @param topic_uri [String] The topic URI or CURIE to unsubscribe from.
+    # @return [String] The UNSUBSCRIBE message as a JSON string.
+    def unsubscribe(topic_uri)
+      [type[:UNSUBSCRIBE], topic_uri].to_json
+    end
+
+    # Builds the PubSub PUBLISH message (client to server)
+    # 	[ TYPE_ID_PUBLISH , topicURI , event ]
+    # 	[ TYPE_ID_PUBLISH , topicURI , event , excludeMe ]
+    # 	[ TYPE_ID_PUBLISH , topicURI , event , exclude , eligible ]
+    # @param topic_uri [String] The topic URI or CURIE to publish the event to.
+    # @param payload [String, Array, Hash] The payload to be delivered to the
+    #   server.
+    # @param exclude [true, false, Array<String>] Optional. Determines which
+    #   clients to exclude from the delivery of the event from the server, you
+    #   can give true or false will exclude/include the sending client, or give
+    #   an Array of client ID's to exclude.
+    # @param elgible [Array<String>] Optional. An array lf client ID's elgible
+    #   to receive the published message.
+    # @return [String] The PUBLISH message as a JSON string.
+    def publish(topic_uri, event, exclude = nil, elgible = nil)
+      msg = [type[:PUBLISH], topic_uri, event]
+      msg[3] = exclude unless exclude.nil?
+      msg[4] = elgible unless elgible.nil?
+
+      msg.to_json
+    end
+
+    # Builds the PubSub EVENT message (server to client)
+    #   [ TYPE_ID_EVENT , topicURI , event ]
+    # @param topic_uri [String] The topic URI or CURIE to publish the event to.
+    # @param event [String, Array, Hash] The payload to be delivered to the clients
+    # @return [String] The EVENT message as a JSON string.
+    def event(topic_uri, event)
+      [type[:EVENT], topic_uri, event].to_json
+    end
+
+    private
+
+    def server_ident
+      WAMP.identity
+    end
+
+    def type
+      WAMP::MessageType
+    end
+  end
+end

data/lib/wamp/server.rb

@@ -3,21 +3,26 @@ require 'json'
 
 module WAMP
   class Server
-    attr_accessor :options, :sockets, :topics
+    include WAMP::Bindable
 
-    CALLBACKS = [:subscribe, :unsubscribe, :publish, :call, :prefix, :connect, :disconnect]
+    attr_accessor :options, :topics, :callbacks
 
     def initialize(options = {})
-      @options = options
-      @sockets = {}
-      @topics  = {}
+      @options   = options
 
+      @topics    = {}
       @callbacks = {}
+      @engine    = WAMP::Engines::Memory.new
+      @protocol  = WAMP::Protocols::Version1.new
+    end
+
+    def available_bindings
+      [:subscribe, :unsubscribe, :publish, :call, :prefix, :connect, :disconnect]
     end
 
     def start
       lambda do |env|
-        # Faye::WebSocket.load_adapter('thin')
+        Faye::WebSocket.load_adapter('thin')
         if Faye::WebSocket.websocket?(env)
           ws = Faye::WebSocket.new(env, ['wamp'], ping: 25)
 
@@ -33,114 +38,86 @@ module WAMP
       end
     end
 
-    def bind(name, &callback)
-      raise "Invalid callback name: #{name}" unless CALLBACKS.include? name
-      @callbacks[name] = callback
-    end
-
-    def trigger(name, *args)
-      @callbacks[name].call *args if @callbacks[name]
-    end
-
-    def send_event_to_all
-      msg = [8, 'ws://localhost:9292/', "Here I am, Rock you like a hurricane"]
-      @sockets.each_pair do |s, c|
-        s.send msg.to_json
-      end
-    end
-
   private
 
     def handle_open(websocket, event)
-      socket = @sockets[websocket] = WAMP::Socket.new(websocket)
+      client = @engine.create_client(websocket)
+              client.websocket.send @protocol.welcome(client.id)
 
-      trigger(:connect, socket)
+      trigger(:connect, client)
     end
 
     def handle_message(websocket, event)
-      socket = @sockets[websocket]
+      client = @engine.find_clients(websocket: websocket).first
 
-      parsed_msg = JSON.parse(event.data)
-      msg_type   = parsed_msg[0]
+      data     = JSON.parse(event.data)
+      msg_type = data.shift
 
       case WAMP::MessageType[msg_type]
       when :PREFIX
-        prefix = parsed_msg[1]
-        uri    = parsed_msg[2]
-
-        socket.add_prefix(prefix, uri)
-
-        trigger(:prefix, socket, prefix, uri)
+        handle_prefix(client, data)
       when :CALL
-        # TODO handle RPC Call
+        handle_call(client, data)
       when :SUBSCRIBE
-        handle_subscribe(socket, parsed_msg)
+        handle_subscribe(client, data)
       when :UNSUBSCRIBE
-        topic_name = parsed_msg[1]
-        topic = @topics[topic_name]
-
-        trigger(:unsubscribe, socket, topic.name)
+        handle_unsubscribe(client, data)
       when :PUBLISH
-        handle_publish(socket, parsed_msg)
+        handle_publish(client, data)
       end
     end
 
-    # Handle a subscribe message from a client
-    # SUBSCRIBE data structure [5, TOPIC]
-    def handle_subscribe(socket, data)
-      topic_uri = data[1]
+    # Handle a prefix message from a client
+    # PREFIX data structure [PREFIX, URI]
+    def handle_prefix(client, data)
+      prefix, uri = data
 
-      @topics[topic_uri] ||= WAMP::Topic.new(topic_uri)
-      socket.add_topic(@topics[topic_uri])
+      topic = @engine.find_or_create_topic(uri)
+      client.add_prefix(prefix, topic)
 
-      trigger(:subscribe, socket, topic.name)
+      trigger(:prefix, client, prefix, uri)
     end
 
-    # Handle an unsubscribe message from client
-    # UNSUBSCRIBE data structure [6, TOPIC]
-    def handle_unsubscribe(socket, data)
-      topic_uri = data[1]
-      topic     = @topics[topic_uri]
+    # Handle RPC call message from a client
+    # CALL data structure [callID, procURI, ... ]
+    def handle_call(client, data)
+      call_id, proc_uri, *args = data
+
+      trigger(:call, client, call_id, proc_uri, args)
+    end
 
-      socket.remove_topic(topic) if topic
+    # Handle a subscribe message from a client
+    # SUBSCRIBE data structure [TOPIC]
+    def handle_subscribe(client, data)
+      topic = @engine.subscribe_client_to_topic client, data[0]
 
-      trigger(:unsubscribe, socket, topic.name)
+      trigger(:subscribe, client, topic.uri)
     end
 
-    # Handle a message published by a client
-    # PUBLISH data structure [7, TOPIC, DATA, EXCLUDE, INCLUDE]
-    def handle_publish(socket, data)
-      topic   = topics[data[1]]
-      payload = data[2]
-      exclude = data[3]
-      include = data[4]
-
-      if exclude == true
-        exclude = [socket.id]
-      elsif exclude == false
-        exclude = []
-      end
+    # Handle an unsubscribe message from client
+    # UNSUBSCRIBE data structure [TOPIC]
+    def handle_unsubscribe(client, data)
+      topic = @engine.unsubscribe_client_from_topic(client, data[0])
 
-      # Send payload to all sockets subscribed to topic
-      @sockets.each_pair do |k, v|
-        next if exclude.include? k
+      trigger(:unsubscribe, client, topic.uri)
+    end
 
-        if v.topics.include? topic
-          k.send [WAMP::MessageType[:EVENT], topic.name, payload].to_json
-        end
-      end
+    # Handle a message published by a client
+    # PUBLISH data structure [TOPIC, DATA, EXCLUDE, INCLUDE]
+    def handle_publish(client, data)
+      topic_name, payload, exclude, include = data
+      topic = @engine.find_or_create_topic(topic_name)
 
-      # Todo: Filter send with include
+      topic.publish(client, @protocol, payload, exclude, include)
 
-      trigger(:publish, socket, topic.name, payload, exclude, include)
+      trigger(:publish, client, topic.uri, payload, exclude, include)
     end
 
     def handle_close(websocket, event)
-      socket = @sockets.delete(websocket)
-
-      p [socket.id, :close, event.code, event.reason]
+      # client = @engine.find_clients(websocket: websocket).first
+      client = @engine.delete_client(websocket)
 
-      trigger(:disconnect, socket)
+      trigger(:disconnect, client)
     end
   end
 end

data/lib/wamp/socket.rb

@@ -1,12 +1,11 @@
-require 'securerandom'
 require 'json'
 
 module WAMP
   class Socket
     attr_accessor :id, :websocket, :topics, :prefixes
 
-    def initialize(websocket)
-      @id        = SecureRandom.uuid
+    def initialize(id, websocket)
+      @id        = id
       @topics    = []
       @prefixes  = {}
       @websocket = websocket
@@ -30,7 +29,7 @@ module WAMP
 
     def send_welcome_message
       welcome_msg = [WAMP::MessageType[:WELCOME], id, WAMP.protocol_version, WAMP.identity]
-      websocket.send welcome_msg.to_json
+      # websocket.send welcome_msg.to_json
     end
   end
 end

data/lib/wamp/topic.rb

@@ -1,9 +1,38 @@
 module WAMP
   class Topic
-    attr_accessor :name
+    attr_accessor :uri, :clients
 
-    def initialize(name)
-      @name = name
+    def initialize(uri)
+      @uri     = uri
+      @clients = []
+    end
+
+    def add_client(client)
+      clients << client unless clients.include? client
+    end
+
+    def remove_client(client)
+      clients.delete client
+    end
+
+    def publish(client, protocol, payload, excluded, included)
+      rec_clients = clients.dup
+
+      if excluded == true
+        excluded = [client.id]
+      elsif excluded == false || excluded.nil?
+        excluded = []
+      end
+
+      rec_clients.delete_if { |c| excluded.include? c.id }
+
+      if included
+        rec_clients.delete_if { |c| !included.include?(c.id) }
+      end
+
+      rec_clients.each do |c|
+        c.websocket.send protocol.event(self.uri, payload)
+      end
     end
   end
 end

data/spec/lib/wamp/client_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe WAMP::Client do
+  let(:client) { WAMP::Client.new }
+
+  it "should start with an empty id" do
+    expect(client.id).to be_nil
+  end
+end

data/spec/lib/wamp/engines/memory_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe WAMP::Engines::Memory do
+  let(:memory)       { WAMP::Engines::Memory.new }
+
+  context "#initialization" do
+    it "should initialize with some empty hashes" do
+      expect(memory.clients).to eq({})
+      expect(memory.topics).to eq({})
+      expect(memory.options).to eq({})
+    end
+  end
+
+  context "client management" do
+    context "#create_client" do
+      it "should create a new instance of a socket" do
+        expect { memory.create_client(DummySocket) }
+          .to change(memory.clients, :size).by(1)
+      end
+    end
+
+    context "with existing clients" do
+      before do
+        @ds1 = DummySocket.new(1)
+        @ds2 = DummySocket.new(2)
+
+        @id1 = memory.create_client(@ds1).id
+        @id2 = memory.create_client(@ds2).id
+      end
+
+      context "#delete_client" do
+        it "should delete a client" do
+          expect { memory.delete_client @ds1 }
+            .to change(memory.clients, :size).by(-1)
+        end
+
+        it "should return the removed client" do
+          client = memory.find_clients(websocket: @ds1).first
+          expect(memory.delete_client @ds1).to eq client
+        end
+      end
+
+      context "#all_clients" do
+        it "should return an array of all the clients" do
+          expect(memory.all_clients.size).to eq 2
+
+          expect(memory.all_clients).to eq memory.clients.values
+        end
+      end
+
+      context "#find_clients" do
+        it "should find a client by the given parameter" do
+          expect(memory.find_clients(id: @id1).first.websocket).to eq @ds1
+          expect(memory.find_clients(id: @id2).first.websocket).to eq @ds2
+        end
+
+        it "should return all the clients that match" do
+          expect(memory.find_clients(topics: []).size).to eq 2
+        end
+      end
+    end
+  end
+
+  context "topic management" do
+    context "find or create a new topic" do
+      it "should create a new topic" do
+        expect { memory.find_or_create_topic("http://localhost/sample_topic") }
+          .to change(memory.topics, :size).by(1)
+      end
+
+      it "should return an existing topic if one already exists" do
+        new_topic = memory.find_or_create_topic("http://localhost/sample_topic")
+        expect(memory.find_or_create_topic "http://localhost/sample_topic")
+          .to eq new_topic
+      end
+    end
+
+    context "topic subscription" do
+      before do
+        @client = memory.create_client(@ds1)
+        @topic  = memory.find_or_create_topic("http://localhost/sample_topic")
+
+        @sub = memory.subscribe_client_to_topic @client, @topic.uri
+      end
+
+      it "should add a client to a topic" do
+        expect(@client.topics).to include @topic
+      end
+
+      it "should add a topic to a client" do
+        expect(@topic.clients).to include @client
+      end
+
+      it "should return the topic the client subscribed to" do
+        expect(@sub).to eq @topic
+      end
+    end
+
+    context "topic unsubscription" do
+      before do
+        @client = memory.create_client(@ds1)
+        @topic  = memory.find_or_create_topic("http://localhost/sample_topic")
+
+        @sub = memory.subscribe_client_to_topic @client, @topic.uri
+      end
+
+      it "should remove the client from the topic" do
+        expect { memory.unsubscribe_client_from_topic @client, @topic.uri }
+          .to change(@topic.clients, :size).by(-1)
+      end
+
+      it "should remove the topic from the client" do
+        expect { memory.unsubscribe_client_from_topic @client, @topic.uri }
+          .to change(@client.topics, :size).by(-1)
+      end
+    end
+  end
+end