wamp_client 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89777a1693c71983f0e12863bc34c6c6976549b4
-  data.tar.gz: 87ffbcbdf160a92bb92436f316b87030cebf5ac3
+  metadata.gz: 5401c514eb36f3adbfa52b9f2f5d218a3f884ee5
+  data.tar.gz: fae4ea4045398f596d7f67262a121b29c754c724
 SHA512:
-  metadata.gz: 516a31f32f64e581290f8629668632510c79ef8bdccc0c5be04e2bb6eb3d8fde65048ec5ec3e74d2522003d71c5dafeaec09b31f9ae70088b9acd57c8e99a393
-  data.tar.gz: 144113bc2572aebb2d19a883523f50695ad08b0263e842cf3f07863fb683295e84cc5469f4b1b65d052c347f2edcae2cbfd45094b9a9bc23b9c9abd994b5ea6f
+  metadata.gz: 833e3a42b79b5de4624fab8ecdc989a4af23db6aba17352ad399f7614e12754ced273cef8419dd257423cfcc736f5ea2ccfb2c4945158b02b07703f650b8736b
+  data.tar.gz: 35ccc1c3bead4d40b9ff21c55caf44c69b1ca85474461f43fac9d9fc1777193be4147b2fba4d2e865af7de9b1f3c7879a5d37fc37ecba81c7b9d803d1f871a6f

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2016 Eric Chapman
+Copyright (c) 2018 Eric Chapman
 
 MIT License
 

data/README.md

@@ -10,6 +10,10 @@ Please use [wamp_rails](https://github.com/ericchapman/ruby_wamp_rails) to integ
 
 ## Revision History
 
+ - v0.0.9:
+   - Added support for transport override and 'faye-websocket' transport
+   - Added "on(event)" callback (still support legacy methods)
+   - Increased Test Coverage for 'Transport' and 'Connection' classes
  - v0.0.8:
    - Exposed 'yield' publicly to allow higher level libraries to not use the 'defer'
    - Removed library version dependency
@@ -70,7 +74,7 @@ options = {
 }
 connection = WampClient::Connection.new(options)
 
-connection.on_join do |session, details|
+connection.on(:join) do |session, details|
   puts "Session Open"
 
   # Register for something
@@ -101,46 +105,84 @@ A connection is closed by simply calling "close"
 connection.close
 ```
 
-Note that the connection will still call "on_leave" and "on_disconnect" as it closes the session and the transport
+Note that the connection will still call "on(:leave)" and "on(:disconnect)" as it closes the session and the transport
 
 #### Callbacks
 A connection has the following callbacks
 
-**on_connect** - Called when the transport is opened
+**on(:connect)** - Called when the transport is opened
 ```ruby
-connection.on_connect do
+connection.on(:connect) do
 
 end
 ```
 
-**on_join** - Called when the session is established
+**on(:join)** - Called when the session is established
 ```ruby
-connection.on_join do |session, details|
+connection.on(:join) do |session, details|
 
 end
 ```
 
-**on_leave** - Called when the session is terminated
+**on(:leave)** - Called when the session is terminated
 ```ruby
-connection.on_leave do |reason, details|
+connection.on(:leave) do |reason, details|
 
 end
 ```
 
-**on_disconnect** - Called when the connection is terminated
+**on(:disconnect)** - Called when the connection is terminated
 ```ruby
-connection.on_disconnect do |reason|
+connection.on(:disconnect) do |reason|
 
 end
 ```
 
-**on_challenge** - Called when an authentication challenge is created
+**on(:challenge)** - Called when an authentication challenge is created
 ```ruby
-connection.on_challenge do |authmethod, extra|
+connection.on(:challenge) do |authmethod, extra|
 
 end
 ```
 
+#### Overriding Transport
+By default, the library will use the "websocket-eventmachine-client" Gem as the websocket transport.
+However the library also supports overriding this.
+
+##### GEM: faye-websocket
+To use this library, do the following
+
+Install the "faye-websocket" Gem:
+
+    $ gem install faye-websocket
+
+Override the transport by doing the following:
+
+```ruby
+require 'wamp_client'
+
+options = {
+    uri: 'ws://127.0.0.1:8080/ws',
+    realm: 'realm1',
+    proxy: { # See faye-websocket documentation
+      :origin  => 'http://username:password@proxy.example.com',
+      :headers => {'User-Agent' => 'ruby'}
+    },  
+    transport: WampClient::Transport::FayeWebSocket
+}
+
+connection = WampClient::Connection.new(options)
+
+# More code
+``` 
+
+Note that the "faye-wesbsocket" transport supports passing in a "proxy" as shown above.
+ 
+##### Custom
+You can also create your own transports by wrapping them in a "Transport" object
+and including as shown above.  For more details on this, see the files in
+"lib/wamp_client/transport"
+
 ### Authentication
 The library supports authentication.  Here is how to perform the different methods
 
@@ -158,7 +200,7 @@ options = {
 }
 connection = WampClient::Connection.new(options)
 
-connection.on_challenge do |authmethod, extra|
+connection.on(:challenge) do |authmethod, extra|
   puts 'Challenge'
   if authmethod == 'wampcra'
     WampClient::Auth::Cra.sign('secret', extra[:challenge])
@@ -167,7 +209,7 @@ connection.on_challenge do |authmethod, extra|
   end
 end
 
-connection.on_join do |session, details|
+connection.on(:join) do |session, details|
   puts "Session Open"
 end
 

data/lib/wamp_client.rb

@@ -28,8 +28,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 require 'wamp_client/version'
 require 'wamp_client/message'
 require 'wamp_client/serializer'
-require 'wamp_client/transport'
 require 'wamp_client/connection'
 require 'wamp_client/session'
 require 'wamp_client/auth'
-require 'wamp_client/defer'
+require 'wamp_client/defer'

data/lib/wamp_client/connection.rb

@@ -25,13 +25,13 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 =end
 
-require 'websocket-eventmachine-client'
 require 'wamp_client/session'
-require 'wamp_client/transport'
+require 'wamp_client/transport/web_socket_event_machine'
+require 'wamp_client/transport/faye_web_socket'
 
 module WampClient
   class Connection
-    attr_accessor :options, :transport, :session
+    attr_accessor :options, :transport_class, :transport, :session, :verbose
 
     @reconnect = true
 
@@ -77,8 +77,27 @@ module WampClient
       @on_disconnect = on_disconnect
     end
 
+    # Simple setter for callbacks
+    def on(event, &callback)
+      case event
+        when :connect
+          self.on_connect(&callback)
+        when :join
+          self.on_join(&callback)
+        when :challenge
+          self.on_challenge(&callback)
+        when :leave
+          self.on_leave(&callback)
+        when :disconnect
+          self.on_disconnect(&callback)
+        else
+          raise RuntimeError, "Unknown on(event) '#{event}'"
+      end
+    end
+
     # @param options [Hash] The different options to pass to the connection
     # @option options [String] :uri The uri of the WAMP router to connect to
+    # @option options [String] :proxy The proxy to get to the router
     # @option options [String] :realm The realm to connect to
     # @option options [String,nil] :protocol The protocol (default if wamp.2.json)
     # @option options [String,nil] :authid The id to authenticate with
@@ -86,7 +105,9 @@ module WampClient
     # @option options [Hash] :headers Custom headers to include during the connection
     # @option options [WampClient::Serializer::Base] :serializer The serializer to use (default is json)
     def initialize(options)
+      self.transport_class = options.delete(:transport) || WampClient::Transport::WebSocketEventMachine
       self.options = options || {}
+      self.verbose = options[:verbose] || false
     end
 
     # Opens the connection
@@ -98,7 +119,7 @@ module WampClient
       @retry_timer = 1
       @retrying = false
 
-      EM.run do
+      self.transport_class.start_event_machine do
         # Create the transport
         self._create_transport
       end
@@ -112,6 +133,7 @@ module WampClient
 
       # Leave the session
       @reconnect = false
+      @retrying = false
       session.leave
 
     end
@@ -120,17 +142,17 @@ module WampClient
       self.session = WampClient::Session.new(self.transport, self.options)
 
       # Setup session callbacks
-      self.session.on_challenge do |authmethod, extra|
+      self.session.on(:challenge) do |authmethod, extra|
         self._finish_retry
         @on_challenge.call(authmethod, extra) if @on_challenge
       end
 
-      self.session.on_join do |details|
+      self.session.on(:join) do |details|
         self._finish_retry
         @on_join.call(self.session, details) if @on_join
       end
 
-      self.session.on_leave do |reason, details|
+      self.session.on(:leave) do |reason, details|
 
         unless @retrying
           @on_leave.call(reason, details) if @on_leave
@@ -156,14 +178,11 @@ module WampClient
       end
 
       # Initialize the transport
-      if self.options[:transport]
-        self.transport = self.options[:transport]
-      else
-        self.transport = WampClient::Transport::WebSocketTransport.new(self.options)
-      end
+      self.transport = self.transport_class.new(self.options)
 
       # Setup transport callbacks
-      self.transport.on_open do
+      self.transport.on(:open) do
+        puts "TRANSPORT OPEN" if self.verbose
 
         # Call the callback
         @on_connect.call if @on_connect
@@ -173,7 +192,8 @@ module WampClient
 
       end
 
-      self.transport.on_close do |reason|
+      self.transport.on(:close) do |reason|
+        puts "TRANSPORT CLOSED: #{reason}" if self.verbose
         @open = false
 
         unless @retrying
@@ -188,10 +208,14 @@ module WampClient
           self._retry unless @retrying
         else
           # Stop the Event Machine
-          EM.stop
+          self.transport_class.stop_event_machine
         end
       end
 
+      self.transport.on(:error) do |message|
+        puts "TRANSPORT ERROR: #{message}"
+      end
+
       @open = true
 
       self.transport.connect
@@ -205,16 +229,16 @@ module WampClient
 
     def _retry
 
-      unless self.session and self.session.is_open?
+      if self.session == nil or not self.session.is_open?
         @retry_timer = 2*@retry_timer unless @retry_timer == 32
         @retrying = true
 
         self._create_transport
 
-        puts "Attempting Reconnect... Next attempt in #{@retry_timer} seconds"
-        EM.add_timer(@retry_timer) {
+        puts "Attempting Reconnect... Next attempt in #{@retry_timer} seconds" if self.verbose
+        self.transport_class.add_timer(@retry_timer*1000) do
           self._retry if @retrying
-        }
+        end
       end
 
     end

data/lib/wamp_client/session.rb

@@ -25,7 +25,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 =end
 
-require 'wamp_client/transport'
+require 'wamp_client/transport/base'
 require 'wamp_client/message'
 require 'wamp_client/check'
 require 'wamp_client/version'
@@ -167,6 +167,20 @@ module WampClient
       @on_challenge = on_challenge
     end
 
+    # Simple setter for callbacks
+    def on(event, &callback)
+      case event
+        when :join
+          self.on_join(&callback)
+        when :challenge
+          self.on_challenge(&callback)
+        when :leave
+          self.on_leave(&callback)
+        else
+          raise RuntimeError, "Unknown on(event) '#{event}'"
+      end
+    end
+
     attr_accessor :id, :realm, :transport, :verbose, :options
 
     # Private attributes
@@ -212,6 +226,7 @@ module WampClient
       # Setup session callbacks
       @on_join = nil
       @on_leave = nil
+      @on_challenge = nil
 
     end
 
@@ -908,7 +923,7 @@ module WampClient
 
       # Timeout Logic
       if options[:timeout] and options[:timeout] > 0
-        self.transport.timer(options[:timeout]) do
+        self.transport.add_timer(options[:timeout]) do
           # Once the timer expires, if the call hasn't completed, cancel it
           if self._requests[:call][call.id]
             call.cancel

data/lib/wamp_client/{transport.rb → transport/base.rb}

@@ -52,16 +52,34 @@ module WampClient
       end
 
       # Callback when there is an error.  Parameters are
+      # @param msg [String] The message from the error
       @on_error
       def on_error(&on_error)
         @on_error = on_error
       end
 
-      attr_accessor :type, :uri, :headers, :protocol, :serializer, :connected
+      # Simple setter for callbacks
+      def on(event, &callback)
+        case event
+          when :open
+            self.on_open(&callback)
+          when :close
+            self.on_close(&callback)
+          when :message
+            self.on_message(&callback)
+          when :error
+            self.on_error(&callback)
+          else
+            raise RuntimeError, "Unknown on(event) '#{event}'"
+        end
+      end
+
+      attr_accessor :uri, :proxy, :headers, :protocol, :serializer, :connected
 
       # Constructor for the transport
       # @param options [Hash] The connection options.  the different options are as follows
       # @option options [String] :uri The url to connect to
+      # @option options [String] :proxy The proxy to use
       # @option options [String] :protocol The protocol
       # @option options [Hash] :headers Custom headers to include during the connection
       # @option options [WampClient::Serializer::Base] :serializer The serializer to use
@@ -70,6 +88,7 @@ module WampClient
         # Initialize the parameters
         self.connected = false
         self.uri = options[:uri]
+        self.proxy = options[:proxy]
         self.headers = options[:headers] || {}
         self.protocol = options[:protocol] || 'wamp.2.json'
         self.serializer = options[:serializer] || WampClient::Serializer::JSONSerializer.new
@@ -109,62 +128,24 @@ module WampClient
       # Process the callback when the timer expires
       # @param [Integer] milliseconds - The number
       # @param [block] callback - The callback that is fired when the timer expires
-      def timer(milliseconds, &callback)
+      def self.add_timer(milliseconds, &callback)
         # Implement in subclass
       end
-
-    end
-
-    # This implementation uses the 'websocket-eventmachine-client' Gem.  This is the default if no transport is included
-    class WebSocketTransport < Base
-      attr_accessor :socket
-
-      def initialize(options)
-        super(options)
-        self.type = 'websocket'
-        self.socket = nil
-      end
-
-      def connect
-        self.socket = WebSocket::EventMachine::Client.connect(
-            :uri => self.uri,
-            :headers => self.headers
-        )
-
-        self.socket.onopen do
-          self.connected = true
-          @on_open.call unless @on_open.nil?
-        end
-
-        self.socket.onmessage do |msg, type|
-          @on_message.call(self.serializer.deserialize(msg)) unless @on_message.nil?
-        end
-
-        self.socket.onclose do |code, reason|
-          self.connected = false
-          @on_close.call(reason) unless @on_close.nil?
-        end
-      end
-
-      def disconnect
-        self.connected = !self.socket.close  # close returns 'true' if the connection was closed immediately
+      def add_timer(milliseconds, &callback)
+        self.class.add_timer(milliseconds, &callback)
       end
 
-      def send_message(msg)
-        if self.connected
-          self.socket.send(self.serializer.serialize(msg), {type: 'text'})
-        else
-          raise RuntimeError, "Socket must be open to call 'send_message'"
-        end
+      # Method to start the event machine for the socket
+      def self.start_event_machine(&block)
+        # Implement in subclass
       end
 
-      def timer(milliseconds, &callback)
-        delay = (milliseconds.to_f/1000.0).ceil
-        EM.add_timer(delay) {
-          callback.call
-        }
+      # Method to stop the vent machine
+      def self.stop_event_machine
+        # Implement in subclass
       end
 
     end
+
   end
 end