wamp_client 0.1.4 → 0.2.0

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

@@ -0,0 +1,72 @@
+require_relative "base"
+require "wamp/client/message"
+
+module Wamp
+  module Client
+    module Request
+
+      class Message::Published
+        def request_id
+          self.publish_request
+        end
+      end
+
+      class Publish < Base
+
+        def create_request(request_id, topic, args=nil, kwargs=nil, options={}, &callback)
+
+          # Create the lookup
+          lookup = options[:acknowledge] ? {t: topic, a: args, k: kwargs, o: options, c: callback} : nil
+
+          # Create the message
+          message = Message::Publish.new(request_id, options, topic, args, kwargs)
+
+          # Return
+          [lookup, message]
+        end
+
+        def process_success(message, lookup)
+          if lookup
+            # Get the params
+            topic = lookup[:t]
+            args = lookup[:a]
+            kwargs = lookup[:k]
+            options = lookup[:o]
+            callback = lookup[:c]
+
+            # Create the details
+            details = {}
+            details[:topic] = topic
+            details[:type] = 'publish'
+            details[:publication] = message.publication
+
+            # Return the values
+            [callback, { args: args, kwargs: kwargs, options: options }, details]
+          else
+            [nil, nil, nil]
+          end
+        end
+
+        def process_error(message, lookup)
+          if lookup
+            # Get the params
+            topic = lookup[:t]
+            callback = lookup[:c]
+
+            # Create the details
+            details = message.details || {}
+            details[:topic] = topic unless details[:topic]
+            details[:type] = 'publish'
+
+            # Return the values
+            [callback, details]
+          else
+            [nil, nil]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require_relative "base"
+require "wamp/client/message"
+require "wamp/client/manager/registration"
+
+module Wamp
+  module Client
+    module Request
+
+      class Message::Registered
+        def request_id
+          self.register_request
+        end
+      end
+
+      class Register < Base
+
+        def create_request(request_id, procedure, handler, options=nil, interrupt=nil, &callback)
+
+          # Create the lookup
+          lookup = {p: procedure, h: handler, i: interrupt, o: options, c: callback}
+
+          # Create the message
+          message = Message::Register.new(request_id, options, procedure)
+
+          # Return
+          [lookup, message]
+        end
+
+        def process_success(message, lookup)
+          if lookup
+            # Get the params
+            procedure = lookup[:p]
+            handler = lookup[:h]
+            options = lookup[:o]
+            interrupt = lookup[:i]
+            callback = lookup[:c]
+
+            # Create the subscription
+            r_id = message.registration
+            r = Manager::RegistrationObject.new(procedure, handler, options, interrupt, self.session, r_id)
+
+            # Create the details
+            details = {}
+            details[:procedure] = procedure
+            details[:type] = 'register'
+
+            # Call the on_success method
+            self.on_success.call(r_id, r)
+
+            # Return the values
+            [callback, r, details]
+          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] = 'register'
+
+            # Return the values
+            [callback, details]
+          else
+            [nil, nil]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require 'wamp/client/request/subscribe'
+require 'wamp/client/request/unsubscribe'
+require 'wamp/client/request/register'
+require 'wamp/client/request/unregister'
+require 'wamp/client/request/publish'
+require 'wamp/client/request/call'

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

@@ -0,0 +1,78 @@
+require_relative "base"
+require "wamp/client/message"
+require "wamp/client/manager/subscription"
+
+module Wamp
+  module Client
+    module Request
+
+      class Message::Subscribed
+        def request_id
+          self.subscribe_request
+        end
+      end
+
+      class Subscribe < Base
+
+        def create_request(request_id, topic, handler, options={}, &callback)
+
+          # Create the lookup
+          lookup = {t: topic, h: handler, o: options, c: callback}
+
+          # Create the message
+          message = Message::Subscribe.new(request_id, options, topic)
+
+          # Return
+          [lookup, message]
+        end
+
+        def process_success(message, lookup)
+          if lookup
+            # Get the params
+            topic = lookup[:t]
+            handler = lookup[:h]
+            options = lookup[:o]
+            callback = lookup[:c]
+
+            # Create the subscription
+            s_id = message.subscription
+            s = Manager::SubscriptionObject.new(topic, handler, options, self.session, s_id)
+
+            # Create the details
+            details = {}
+            details[:topic] = topic unless details[:topic]
+            details[:type] = 'subscribe'
+
+            # Call the on_success method
+            self.on_success.call(s_id, s)
+
+            # Return the values
+            [callback, s, details]
+          else
+            [nil, nil, nil]
+          end
+        end
+
+        def process_error(message, lookup)
+          if lookup
+            # Get the params
+            topic = lookup[:t]
+            callback = lookup[:c]
+
+            # Create the details
+            details = message.details || {}
+            details[:topic] = topic unless details[:topic]
+            details[:type] = 'subscribe'
+
+            # Return the values
+            [callback, details]
+          else
+            [nil, nil]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require_relative "base"
+require "wamp/client/message"
+
+module Wamp
+  module Client
+    module Request
+
+      class Message::Unregistered
+        def request_id
+          self.unregister_request
+        end
+      end
+
+      class Unregister < Base
+
+        def create_request(request_id, registration, &callback)
+
+          # Create the lookup
+          lookup = { r: registration, c: callback }
+
+          # Create the message
+          message = Message::Unregister.new(request_id, registration.id)
+
+          # Return
+          [lookup, message]
+        end
+
+        def process_success(message, lookup)
+          if lookup
+            # Get the params
+            registration = lookup[:r]
+            callback = lookup[:c]
+
+            # Create the details
+            details = {}
+            details[:procedure] = registration.procedure
+            details[:type] = 'unregister'
+
+            # Call the on_success method
+            self.on_success.call(registration.id)
+
+            # Return the values
+            [callback, registration, details]
+          else
+            [nil, nil, nil]
+          end
+        end
+
+        def process_error(message, lookup)
+          if lookup
+            # Get the params
+            registration = lookup[:r]
+            callback = lookup[:c]
+
+            # Create the details
+            details = message.details || {}
+            details[:procedure] = registration.procedure unless details[:procedure]
+            details[:type] = 'unregister'
+
+            # Return the values
+            [callback, details]
+          else
+            [nil, nil]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require_relative "base"
+require "wamp/client/message"
+
+module Wamp
+  module Client
+    module Request
+
+      class Message::Unsubscribed
+        def request_id
+          self.unsubscribe_request
+        end
+      end
+
+      class Unsubscribe < Base
+
+        def create_request(request_id, subscription, &callback)
+
+          # Create the lookup
+          lookup = { s: subscription, c: callback }
+
+          # Create the message
+          message = Message::Unsubscribe.new(request_id, subscription.id)
+
+          # Return
+          [lookup, message]
+        end
+
+        def process_success(message, lookup)
+          if lookup
+            # Get the params
+            subscription = lookup[:s]
+            callback = lookup[:c]
+
+            # Create the details
+            details = {}
+            details[:topic] = subscription.topic
+            details[:type] = 'unsubscribe'
+
+            # Call the on_success method
+            self.on_success.call(subscription.id)
+
+            # Return the values
+            [callback, subscription, details]
+          else
+            [nil, nil, nil]
+          end
+        end
+
+        def process_error(message, lookup)
+          if lookup
+            # Get the params
+            subscription = lookup[:s]
+            callback = lookup[:c]
+
+            # Create the details
+            details = message.details || {}
+            details[:topic] = subscription.topic unless details[:topic]
+            details[:type] = 'unsubscribe'
+
+            # Return the values
+            [callback, details]
+          else
+            [nil, nil]
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/wamp/client/response.rb

@@ -0,0 +1,136 @@
+require "wamp/client/event"
+
+module Wamp
+  module Client
+    module Response
+      DEFAULT_ERROR = "wamp.error.runtime"
+
+      # This method wraps the handling of the result from a procedure.
+      # or interrupt.  It is intended to standardize the processing
+      #
+      # @param [Bool] - "true" is we want an error out of this
+      # @return [CallResult, CallError, CallDefer] - A response object
+      def self.invoke_handler(error: false, &callback)
+        logger = Wamp::Client.logger
+
+        # Invoke the request
+        begin
+          result = callback.call
+        rescue CallError => e
+          result = e
+        rescue StandardError => e
+          logger.error("Wamp::Client::Response - #{e.message}")
+          e.backtrace.each { |line| logger.error("   #{line}") }
+          result = CallError.new(DEFAULT_ERROR, [e.message], { backtrace: e.backtrace })
+        end
+
+        # Ensure an expected class is returned
+        if error
+          CallError.ensure(result)
+        else
+          CallResult.ensure(result, allow_error: true, allow_defer: true)
+        end
+      end
+
+      # This method will instantiate either a CallResult or CallError based
+      # on the payload
+      #
+      # @param hash [Hash] - The hash
+      # @return [CallResult, CallError] - The result
+      def self.from_hash(hash)
+        if hash[:error] != nil
+          CallError.from_hash(hash)
+        else
+          CallResult.from_hash(hash)
+        end
+      end
+
+      class CallResult
+        attr_reader :args, :kwargs
+
+        def initialize(args=nil, kwargs=nil)
+          @args = args || []
+          @kwargs = kwargs || {}
+        end
+
+        def self.from_hash(hash)
+          self.new(hash[:args], hash[:kwargs])
+        end
+
+        def to_hash
+          { args: self.args, kwargs: self.kwargs }
+        end
+
+        def self.from_yield_message(msg)
+          self.new(msg.yield_arguments, msg.yield_argumentskw)
+        end
+
+        def self.ensure(result, allow_error: false, allow_defer: false)
+          unless result.is_a?(self) or
+              (allow_error and result.is_a?(CallError)) or
+              (allow_defer and result.is_a?(CallDefer))
+            result = result != nil ? self.new([result]) : self.new
+          end
+
+          result
+        end
+      end
+
+      class CallError < StandardError
+        attr_reader :error, :args, :kwargs
+
+        def initialize(error, args=nil, kwargs=nil)
+          @error = error
+          @args = args || []
+          @kwargs = kwargs || {}
+        end
+
+        def self.from_hash(hash)
+          self.new(hash[:error], hash[:args], hash[:kwargs])
+        end
+
+        def to_hash
+          { error: self.error, args: self.args, kwargs: self.kwargs }
+        end
+
+        def self.from_message(msg)
+          self.new(msg.error, msg.arguments, msg.argumentskw)
+        end
+
+        def self.ensure(result)
+          unless result.is_a?(self)
+            args = result != nil ? [result] : nil
+            result = self.new(DEFAULT_ERROR, args)
+          end
+
+          result
+        end
+      end
+
+      class CallDefer
+        include Event
+        attr_accessor :request, :registration
+
+        create_event [:complete, :error, :progress]
+
+        def succeed(result)
+          trigger :complete, self, result
+        end
+
+        def fail(error)
+          trigger :error, self, error
+        end
+
+      end
+
+      class ProgressiveCallDefer < CallDefer
+
+        def progress(result)
+          trigger :progress, self, result
+        end
+
+      end
+
+    end
+  end
+end

data/lib/wamp/client/serializer.rb

@@ -1,30 +1,3 @@
-=begin
-
-Copyright (c) 2018 Eric Chapman
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-=end
-
 require 'json'
 
 module Wamp
@@ -37,14 +10,12 @@ module Wamp
         # Serializes the object
         # @param object - The object to serialize
         def serialize(object)
-
         end
 
         # Deserializes the object
         # @param string [String] - The string to deserialize
         # @return The deserialized object
         def deserialize(string)
-
         end
 
       end