wamp_client 0.1.4 → 0.2.0

data/lib/wamp/client/manager/establish.rb

@@ -0,0 +1,168 @@
+require_relative "base"
+
+module Wamp
+  module Client
+    module Manager
+
+      class Establish < Base
+        attr_accessor :goodbye_sent, :id, :realm
+
+        WAMP_FEATURES = {
+            caller: {
+                features: {
+                    caller_identification: true,
+                    call_timeout: true,
+                    call_canceling: true,
+                    progressive_call_results: true
+                }
+            },
+            callee: {
+                features: {
+                    caller_identification: true,
+                    ##call_trustlevels: true,
+                    pattern_based_registration: true,
+                    shared_registration: true,
+                    ##call_timeout: true,
+                    call_canceling: true,
+                    progressive_call_results: true,
+                    registration_revocation: true
+                }
+            },
+            publisher: {
+                features: {
+                    publisher_identification: true,
+                    subscriber_blackwhite_listing: true,
+                    publisher_exclusion: true
+                }
+            },
+            subscriber: {
+                features: {
+                    publisher_identification: true,
+                    ##publication_trustlevels: true,
+                    pattern_based_subscription: true,
+                    subscription_revocation: true
+                    ##event_history: true,
+                }
+            }
+        }
+
+        # Constructor
+        #
+        def initialize(session, send_message)
+          super session, send_message
+
+          self.id = nil
+          self.realm = nil
+          self.goodbye_sent = false
+        end
+
+        # Returns true if the session is open
+        #
+        def is_open?
+          self.id != nil
+        end
+
+        # Will attempt to join a router
+        #
+        def join(realm)
+
+          # Set the realm
+          self.realm = realm
+
+          # Create the details
+          details = {}
+          details[:roles] = WAMP_FEATURES
+          details[:agent] = "Ruby-Wamp::Client-#{VERSION}"
+          details[:authid] = self.session.options[:authid] if self.session.options[:authid]
+          details[:authmethods] = self.session.options[:authmethods] if self.session.options[:authmethods]
+
+          # Create the message
+          hello = Message::Hello.new(realm, details)
+
+          # Send it
+          send_message(hello)
+        end
+
+        # Leave the session
+        def leave(reason, message)
+
+          # Create the details
+          details = {}
+          details[:message] = message
+
+          # Create the goobdbye message
+          goodbye = Message::Goodbye.new(details, reason)
+
+          # Send it
+          send_message(goodbye)
+
+          # Send it
+          self.goodbye_sent = true
+        end
+
+        # Handles the goodbye message
+        #
+        def goodbye(message)
+          # If we didn't send the goodbye, respond
+          unless self.goodbye_sent
+            goodbye = Message::Goodbye.new({}, 'wamp.error.goodbye_and_out')
+            send_message(goodbye)
+          end
+
+          # Close out session
+          self.id = nil
+          self.realm = nil
+          self.goodbye_sent = false
+
+          # Trigger leave event
+          trigger :leave, message.reason, message.details
+        end
+
+        # Handles the welcome message
+        #
+        def welcome(message)
+          # Get the session ID
+          self.id = message.session
+
+          # Log the message
+          logger.info("#{self.session.class.name} joined session with realm '#{message.details[:realm]}'")
+
+          # Trigger join event
+          trigger :join, message.details
+        end
+
+        # Handles a challenge message
+        #
+        def challenge(message)
+          # Log challenge received
+          logger.debug("#{self.session.class.name} auth challenge '#{message.authmethod}', extra: #{message.extra}")
+
+          # Call the callback if set
+          signature, extra = trigger :challenge, message.authmethod, message.extra
+
+          # Set with initial values
+          signature ||= ''
+          extra ||= {}
+
+          # Create the message
+          authenticate = Message::Authenticate.new(signature, extra)
+
+          # Send it
+          send_message(authenticate)
+        end
+
+        # Handles an abort message
+        #
+        def abort(message)
+          # Log leaving the session
+          logger.info("#{self.session.class.name} left session '#{message.reason}'")
+
+          # Trigger the leave event
+          trigger :leave, message.reason, message.details
+        end
+
+      end
+
+    end
+  end
+end

data/lib/wamp/client/manager/registration.rb

@@ -0,0 +1,183 @@
+require_relative "base_multiple"
+require 'wamp/client/response'
+
+module Wamp
+  module Client
+    module Manager
+
+      class RegistrationObject
+        attr_accessor :procedure, :handler, :i_handler, :options, :session, :id
+
+        def initialize(procedure, handler, options, i_handler, session, id)
+          self.procedure = procedure
+          self.handler = handler
+          self.options = options
+          self.i_handler = i_handler
+          self.session = session
+          self.id = id
+        end
+
+        def unregister
+          self.session.unregister(self)
+        end
+
+      end
+
+      class Registration < BaseMultiple
+        attr_reader :defers
+
+        # Constructor
+        #
+        # @param session [Wamp::Client::Session] - The session
+        # @param success [Block] - A block to run when the request was successful
+        def initialize(session, send_message)
+          super session, send_message
+          @defers = {}
+        end
+
+        # Processes an incoming call
+        #
+        # @param message [Message::Event] - The incoming invoke message
+        def invoke(message)
+
+          # Get the arguments
+          registration_id = message.registered_registration
+          request_id = message.request
+          args = message.call_arguments || []
+          kwargs = message.call_argumentskw || {}
+
+          # If we have a registration, execute it
+          registration = self.objects[registration_id]
+          if registration
+
+            # Create the details
+            details = message.details || {}
+            details[:request] = request_id
+            details[:procedure] = registration.procedure
+            details[:session] = self
+
+            handler = registration.handler
+            if handler
+              # Use the invoke wrapper to process the result
+              value = Response.invoke_handler do
+                handler.call(args, kwargs, details)
+              end
+
+              # If a defer was returned, handle accordingly
+              if value.is_a? Response::CallDefer
+                value.request = request_id
+                value.registration = registration_id
+
+                # Store the defer
+                self.defers[request_id] = value
+
+                # On complete, send the result
+                value.on :complete do |defer, result|
+                  result = Response::CallResult.ensure(result)
+                  self.yield(defer.request, result, {}, true)
+                end
+
+                # On error, send the error
+                value.on :error do |defer, error|
+                  error = Response::CallError.ensure(error)
+                  self.yield(defer.request, error, {}, true)
+                end
+
+                # For progressive, return the progress
+                if value.is_a? Response::ProgressiveCallDefer
+                  value.on :progress do |defer, result|
+                    result = Response::CallResult.ensure(result)
+                    self.yield(defer.request, result, { progress: true }, true)
+                  end
+                end
+
+                # Else it was a normal response
+              else
+                self.yield(request_id, value)
+              end
+            end
+          end
+        end
+
+        # Processes a yield request
+        #
+        def yield(request_id, result, options={}, check_defer=false)
+          # Prevent responses for defers that have already completed or had an error
+          if check_defer and not self.defers[request_id]
+            return
+          end
+
+          # Wrap the result accordingly
+          result = Response::CallResult.ensure(result, allow_error: true)
+
+          # Send either the error or the response
+          if result.is_a?(Response::CallError)
+            send_error(request_id, result)
+          else
+            yield_msg = Message::Yield.new(request_id, options, result.args, result.kwargs)
+            send_message(yield_msg)
+          end
+
+          # Remove the defer if this was not a progress update
+          if check_defer and not options[:progress]
+            self.defers.delete(request_id)
+          end
+
+        end
+
+        # Call Interrupt Handler
+        #
+        def interrupt(message)
+
+          # Get parameters
+          request_id = message.invocation_request
+          mode = message.options[:mode]
+
+          # Check if we have a pending request
+          defer = self.defers[request_id]
+          if defer
+            registration = self.objects[defer.registration]
+            if registration
+              # If it exists, call the interrupt handler to inform it of the interrupt
+              i_handler = registration.i_handler
+              error = nil
+              if i_handler
+                error = Response.invoke_handler error: true do
+                  i_handler.call(request_id, mode)
+                end
+
+                # Add a default reason if none was supplied
+                error.args << "interrupt" if error.args.count == 0
+              end
+
+              # Send the error back to the client
+              send_error(request_id, error)
+            end
+
+            # Delete the defer
+            self.defers.delete(request_id)
+          end
+
+        end
+
+        private
+
+        def send_error(request_id, error)
+          # Make sure the response is an error
+          error = Response::CallError.ensure(error)
+
+          # Create error message
+          error_msg = Message::Error.new(
+              Message::Types::INVOCATION,
+              request_id, {},
+              error.error, error.args, error.kwargs)
+
+          # Send it
+          send_message(error_msg)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/wamp/client/manager/require.rb

@@ -0,0 +1,3 @@
+require 'wamp/client/manager/subscription'
+require 'wamp/client/manager/registration'
+require 'wamp/client/manager/establish'

data/lib/wamp/client/manager/subscription.rb

@@ -0,0 +1,55 @@
+require_relative "base_multiple"
+
+module Wamp
+  module Client
+    module Manager
+
+      class SubscriptionObject
+        attr_accessor :topic, :handler, :options, :session, :id
+
+        def initialize(topic, handler, options, session, id)
+          self.topic = topic
+          self.handler = handler
+          self.options = options
+          self.session = session
+          self.id = id
+        end
+
+        def unsubscribe
+          self.session.unsubscribe(self)
+        end
+
+      end
+
+      class Subscription < BaseMultiple
+
+        # Processes and incoming event
+        #
+        # @param message [Message::Event] - The incoming event message
+        def event(message)
+
+          # Get the arguments
+          subscription_id = message.subscribed_subscription
+          args = message.publish_arguments || []
+          kwargs = message.publish_argumentskw || {}
+
+          # If we have a subscription, execute it
+          subscription = self.objects[subscription_id]
+          if subscription
+
+            # Create the detials
+            details = message.details || {}
+            details[:publication] = message.published_publication
+            details[:topic] = subscription.topic
+            details[:session] = self.session
+
+            # Call the handler
+            handler = subscription.handler
+            handler.call(args, kwargs, details) if handler
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/wamp/client/request/base.rb

@@ -0,0 +1,125 @@
+module Wamp
+  module Client
+    module Request
+
+      class Message::Error
+        def request_id
+          self.request_request
+        end
+      end
+
+      # The request base class is used to abstract all of the requests that
+      # will go to the broker/dealer.  The model supports a request followed
+      # by a response that is either a "success" or an error
+      class Base
+        attr_reader :requests, :session, :send_message_callback, :on_success
+
+        # Constructor
+        #
+        # @param session [Wamp::Client::Session] - The session
+        # @param send_message [lambda] - A lambda to send the message
+        # @param success [Block] - A block to run when the request was successful
+        def initialize(session, send_message, &on_success)
+          @requests = {}
+          @session = session
+          @send_message_callback = send_message
+          @on_success = on_success
+        end
+
+        # Generates a new ID for the request according to the specification
+        # (Section 5.1.2)
+        #
+        # @param [Int] - A new ID
+        def generate_id
+          rand(0..9007199254740992)
+        end
+
+        # Makes the request to the broker/dealer
+        #
+        # @return [Int] - request_id
+        def request(*args, &callback)
+
+          # Generate an ID
+          request_id = self.generate_id
+
+          # Get the unique lookup/message for the request
+          lookup, message = self.create_request(request_id, *args, &callback)
+
+          # Store in the pending requests
+          self.requests[request_id] = lookup if lookup
+
+          # Send the message
+          send_message(message)
+
+          request_id
+        end
+
+        # Called when the response was a success
+        #
+        def success(message)
+          # Get the request_id
+          request_id = message.request_id
+
+          # Get the lookup
+          lookup = self.requests[request_id]
+
+          # Parse the result
+          callback, result, details, should_keep = self.process_success(message, lookup)
+
+          if callback and details
+            # Add items to details
+            details[:session] = self.session
+
+            # Call the callback
+            callback.call(result, nil, details) if callback
+          end
+
+          # Delete if "should_keep" if false
+          self.requests.delete(request_id) unless should_keep
+        end
+
+        def error(message)
+          # Get the request_id
+          request_id = message.request_id
+
+          # Get the lookup
+          lookup = self.requests.delete(request_id)
+
+          # Parse the result
+          callback, details = self.process_error(message, lookup)
+
+          if callback and details
+            # Add items to details
+            details[:session] = self.session
+
+            # Create the error
+            error = Response::CallError.from_message(message)
+
+            # Call the callback
+            callback.call(nil, error.to_hash, details) if callback
+          end
+        end
+
+        #region Override Methods
+        def create_request(*args)
+        end
+
+        def process_success(message, lookup)
+        end
+
+        def process_error(message, lookup)
+        end
+        #endregion
+
+        private
+
+        # Sends a message
+        #
+        def send_message(message)
+          self.send_message_callback.call(message) if self.send_message_callback
+        end
+
+      end
+    end
+  end
+end

data/lib/wamp/client/request/call.rb

@@ -0,0 +1,111 @@
+require_relative "base"
+require "wamp/client/message"
+
+module Wamp
+  module Client
+    module Request
+
+      class Message::Result
+        def request_id
+          self.call_request
+        end
+      end
+
+      class CallObject
+        attr_accessor :session, :id
+
+        def initialize(session, id)
+          self.session = session
+          self.id = id
+        end
+
+        def cancel(mode='skip')
+          self.session.cancel(self, mode)
+        end
+
+      end
+
+      class Call < Base
+
+        # Method specific to this request that will cancel it
+        #
+        def cancel(request_id, mode='skip')
+
+          # If the request is still in flight
+          if self.requests[request_id]
+            # Create the message
+            message = Message::Cancel.new(request_id, { mode: mode })
+
+            # Send it
+            send_message(message)
+          end
+
+        end
+
+        def create_request(request_id, procedure, args=nil, kwargs=nil, options={}, &callback)
+
+          # Create the lookup
+          lookup = {p: procedure, a: args, k: kwargs, o: options, c: callback}
+
+          # Create the message
+          message = Message::Call.new(request_id, options, procedure, args, kwargs)
+
+          # Return
+          [lookup, message]
+        end
+
+        def process_success(message, lookup)
+          if lookup
+            # Get the params
+            procedure = lookup[:p]
+            options = lookup[:o] || {}
+            callback = lookup[:c]
+
+            # Create the details
+            details = message.details || {}
+            details[:procedure] = procedure unless details[:procedure]
+            details[:type] = 'call'
+
+            # Set the should keep flag if this is a progress message
+            should_keep = details[:progress]
+
+            # Only return the information if not progress or receive progress is true
+            if not details[:progress] or (details[:progress] and options[:receive_progress])
+
+              # Create the response
+              result = Response::CallResult.from_yield_message(message)
+
+              # Return the values
+              [callback, result.to_hash, details, should_keep]
+
+            else
+              [nil, nil, nil, should_keep]
+            end
+          else
+            [nil, nil, nil]
+          end
+        end
+
+        def process_error(message, lookup)
+          if lookup
+            # Get the params
+            procedure = lookup[:p]
+            callback = lookup[:c]
+
+            # Create the details
+            details = message.details || {}
+            details[:procedure] = procedure unless details[:procedure]
+            details[:type] = 'call'
+
+            # Return the values
+            [callback, details]
+          else
+            [nil, nil]
+          end
+        end
+
+      end
+
+    end
+  end
+end