wamp-worker 0.1.0

data/lib/wamp/worker/config.rb

@@ -0,0 +1,184 @@
+require "redis"
+
+module Wamp
+  module Worker
+    DEFAULT = :default
+
+    #region Storage Objects
+    class Handle
+      attr_reader :klass, :method, :options
+
+      def initialize(klass, method, options)
+        @klass = klass
+        @method = method
+        @options = options
+
+        unless klass.ancestors.include? BaseHandler
+          raise(ArgumentError, "'klass' must be a Wamp::Worker::Handler type")
+        end
+      end
+    end
+
+    class Registration < Handle
+      attr_reader :procedure
+
+      def initialize(procedure, klass, method, options)
+        super klass, method, options
+        @procedure = procedure
+      end
+    end
+
+    class Subscription < Handle
+      attr_reader :topic
+
+      def initialize(topic, klass, method, options)
+        super klass, method, options
+        @topic = topic
+      end
+    end
+    #endregion
+
+    # This class is a config proxy that lets you specify the name globally
+    #
+    class ConfigProxy
+      attr_reader :name, :config
+
+      def initialize(config, name=nil)
+        @name = name || DEFAULT
+        @config = config
+      end
+
+      # Sets the timeout value
+      #
+      def timeout(seconds)
+        self[:timeout] = seconds
+      end
+
+      # Sets the Redis connection
+      #
+      def redis(connection)
+        self[:redis] = connection
+      end
+
+      # Connection options
+      #
+      def connection(**options)
+        self[:connection] = options
+      end
+
+      # Subscribe the handler to a topic
+      #
+      # @param topic [String] - The topic to subscribe to
+      # @param klass [Wamp::Worker::Handler] - The class to use
+      # @param method [Symbol] - The name of the method to execute
+      # @param options [Hash] - Options for the subscription
+      def subscribe(topic, klass, method, **options)
+        subscriptions = self[:subscriptions] || []
+        subscriptions << Subscription.new(topic, klass, method, options)
+        self[:subscriptions] = subscriptions
+      end
+
+      # Register the handler for a procedure
+      #
+      # @param procedure [String] - The procedure to register for
+      # @param klass [Wamp::Worker::Handler] - The class to use
+      # @param method [Symbol] - The name of the method to execute
+      # @param options [Hash] - Options for the subscription
+      def register(procedure, klass, method, **options)
+        registrations = self[:registrations] || []
+        registrations << Registration.new(procedure, klass, method, options)
+        self[:registrations] = registrations
+      end
+
+      # Allows the user to configure without typing "config."
+      #
+      def configure(&callback)
+        self.instance_eval(&callback)
+      end
+
+      # Sets the attribute using the name
+      #
+      # @param attribute [Symbol] - The attribute
+      # @param value - The value for the attribute
+      def []=(attribute, value)
+        self.config[self.name][attribute] = value
+      end
+
+      # Gets the attribute using the name
+      #
+      # @param attribute [Symbol] - The attribute
+      def [](attribute)
+        self.config[self.name][attribute]
+      end
+    end
+
+    # This class is used to store the configuration of the worker
+    #
+    class Config
+      attr_reader :settings
+
+      def initialize
+        @settings = {}
+      end
+
+      # Returns the connection options
+      #
+      # @param name [Symbol] - The name of the connection
+      def connection(name=nil)
+        name ||= DEFAULT
+        self[name][:connection] || {}
+      end
+
+      # Returns the timeout value
+      #
+      # @param name [Symbol] - The name of the connection
+      def timeout(name=nil)
+        name ||= DEFAULT
+        self[name][:timeout] || 60
+      end
+
+      # Returns the redis value
+      #
+      # @param name [Symbol] - The name of the connection
+      def redis(name=nil)
+        name ||= DEFAULT
+        redis = self[name][:redis]
+
+        # If it is not a redis object, create one using it as the options
+        if redis == nil
+          redis = ::Redis.new
+        elsif not redis.is_a? ::Redis
+          redis = ::Redis.new(redis)
+        end
+
+        redis
+      end
+
+      # Returns the subscriptions
+      #
+      # @param name [Symbol] - The name of the connection
+      def subscriptions(name=nil)
+        name ||= DEFAULT
+        self[name][:subscriptions] || []
+      end
+
+      # Returns the registrations
+      #
+      # @param name [Symbol] - The name of the connection
+      def registrations(name=nil)
+        name ||= DEFAULT
+        self[name][:registrations] || []
+      end
+
+      # Returns the settings for a particular connection
+      #
+      # @param name [Symbol] - The name of the connection
+      def [](name)
+        settings = self.settings[name] || {}
+        self.settings[name] = settings
+        settings
+      end
+    end
+
+  end
+end

data/lib/wamp/worker/handler.rb

@@ -0,0 +1,196 @@
+require_relative "proxy/backgrounder"
+require 'wamp/client/response'
+require 'json'
+
+module Wamp
+  module Worker
+
+    module BaseHandler
+      def self.included(base)
+        attr_reader :proxy, :command, :args, :kwargs, :details, :background
+
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Instantiates the object
+        #
+        def create(proxy, command, args, kwargs, details)
+          handler = self.new
+          handler.configure(proxy, command, args, kwargs, details)
+          handler
+        end
+
+        # Subscribe the handler to a topic
+        #
+        # @param topic [String] - The topic to subscribe to
+        # @param method [Symbol] - The name of the method to execute
+        # @param options [Hash] - Options for the subscription
+        def subscribe(topic, method, name: nil, **options)
+          klass = self
+          Wamp::Worker::configure name do
+            subscribe topic, klass, method, **options
+          end
+        end
+
+        # Register the handler for a procedure
+        #
+        # @param procedure [String] - The procedure to register for
+        # @param method [Symbol] - The name of the method to execute
+        # @param options [Hash] - Options for the subscription
+        def register(procedure, method, name: nil, **options)
+          klass = self
+          Wamp::Worker::configure name do
+            register procedure, klass, method, **options
+          end
+        end
+      end
+
+      # Configures the handler
+      #
+      def configure(proxy, command, args, kwargs, details, background=false)
+        @proxy = proxy
+        @command = command
+        @args = args || []
+        @kwargs = kwargs || {}
+        @details = details || {}
+        @background = background
+      end
+
+      # This method will send progress of the call to the caller
+      #
+      # @param result - The value you would like to send to the caller for progress
+      def progress(result)
+
+        # Only allow progress if it is a procedure and the client set "receive_progress"
+        if command.to_sym == :procedure and self.details[:receive_progress]
+
+          # Get the request ID
+          request = self.details[:request]
+
+          # Send the data back to the
+          self.session.yield request, result, { progress: true }, self.background
+        end
+
+      end
+
+    end
+
+    module Handler
+
+      def self.included(base)
+        base.class_eval do
+          include BaseHandler
+        end
+      end
+
+      # Returns the session for the call
+      #
+      # @return [Wamp::Client::Session, Wamp::Worker::Proxy::Requestor]
+      def session
+        self.proxy.session
+      end
+
+      # Method that invokes the handler
+      #
+      def invoke(method)
+        self.send(method)
+      end
+
+    end
+
+    module BackgroundHandler
+
+      def self.included(base)
+        base.class_eval do
+          include BaseHandler
+
+          # Use Sidekiq
+          require 'sidekiq'
+          include ::Sidekiq::Worker
+        end
+      end
+
+      # Returns the session for the call
+      #
+      # @return [Wamp::Client::Session, Wamp::Worker::Proxy::Requestor]
+      def session
+        self.proxy
+      end
+
+      # Override the invoke method to push the process to the background
+      #
+      def invoke(method)
+
+        # Also need to remove the session since it is not serializable.
+        # Will add a new one in the background handler
+        self.details.delete(:session)
+
+        # Send the task to Sidekiq
+        #
+        # Note: We are explicitly serializing the args, kwargs, details
+        # so that we can deserialize and have them appear as symbols in
+        # the handler.
+        self.class.perform_async(
+            method,
+            self.proxy.name,
+            self.proxy.background_res_queue,
+            self.command,
+            self.args.to_json,
+            self.kwargs.to_json,
+            details.to_json)
+
+        # If it is a procedure, return a defer
+        if self.command.to_sym == :procedure
+          Wamp::Client::Response::CallDefer.new
+        else
+          nil
+        end
+
+      end
+
+      # Method that is run when the process is invoked on the worker
+      #
+      # @param method [Symbol] - The name of the method to execute
+      # @param command [Symbol] - The command that is being backgrounded
+      # @param args [Array] - The arguments for the handler
+      # @param kwargs [Hash] - The keyword arguments for the handler
+      # @param details [Hash] - Other details about the call
+      def perform(method, proxy_name, proxy_handle, command, args, kwargs, details)
+
+        # Create a proxy to act like the session.  Use a backgrounder so we also
+        # get the "yield" method
+        proxy = Proxy::Backgrounder.new(proxy_name, proxy_handle)
+
+        # Deserialize the arguments as symbols
+        args = JSON.parse(args, :symbolize_names => true)
+        kwargs = JSON.parse(kwargs, :symbolize_names => true)
+        details = JSON.parse(details, :symbolize_names => true)
+
+        # Get the request ID
+        request = details[:request]
+
+        # Add the proxy to the details as a "session"
+        details[:session] = self.session
+
+        # Configure the handler
+        self.configure(proxy, command, args, kwargs, details, true)
+
+        # Call the user code and make sure to catch exceptions
+        result = Wamp::Client::Response.invoke_handler do
+          self.send(method)
+        end
+
+        # Only return the response if it is a procedure
+        if command.to_sym == :procedure
+
+          # Send the data back to the
+          self.session.yield request, result, {}, true
+
+        end
+      end
+
+    end
+  end
+end

data/lib/wamp/worker/proxy/backgrounder.rb

@@ -0,0 +1,38 @@
+require_relative "requestor"
+
+module Wamp
+  module Worker
+    module Proxy
+
+      class Backgrounder < Requestor
+        attr_reader :handle
+
+        # Constructor
+        #
+        def initialize(name, handle, uuid: nil)
+          super name, uuid: uuid
+          @handle = handle
+        end
+
+        # Returns the response to the dispatcher
+        #
+        # @param request [Int] - The ID of the request
+        # @param result [CallResult,CallError] - The result or error for us to serialize
+        # @param options [Hash] - Options for the yield
+        # @param check_defer [Bool] - 'true' is this is linked to a defer call
+        def yield(request, result, options={}, check_defer=false)
+
+          # Create the response object
+          result = Wamp::Client::Response::CallResult.ensure(result, allow_error: true)
+
+          # Create the params
+          params = { request: request, result: result.to_hash, options: options, check_defer: check_defer }
+
+          # Push to the worker who requested the result
+          self.queue.push self.handle, :yield, params
+        end
+
+      end
+    end
+  end
+end

data/lib/wamp/worker/proxy/base.rb

@@ -0,0 +1,101 @@
+require "wamp/client/response"
+require_relative "../ticker"
+require_relative "../queue"
+
+module Wamp
+  module Worker
+    module Proxy
+
+      class Base
+        attr_reader :queue, :ticker, :name, :uuid
+
+        # Constructor
+        #
+        # @param name [Symbol] - The name of the connection
+        # @param uuid [String] - The uuid for the proxy.  This can be passed in as
+        #                        well to allow it to be initialized for hte entire worker
+        def initialize(name, uuid: nil)
+          @name = name
+          @queue = Wamp::Worker::Queue.new(name)
+          @ticker = Wamp::Worker::Ticker.new(name)
+          @uuid = uuid || ENV['DYNO'] || SecureRandom.hex(12)
+        end
+
+        #region Command/Response
+        # ----------------
+        # This workflow is used by a "Requestor" to make a "call"
+        # or "publish" request to the "Dispatcher".  This would for example be in
+        # your rails app where a service or controller needs to make a WAMP call
+        #
+        # The flow is as follows
+        #
+        #  - Requestor performs a "push" operation with the following parameters
+        #     - queue_name - The "command queue"
+        #     - command - The command ("call" or "publish")
+        #     - params - The parameters for the command (args/kwargs/etc.)
+        #     - handle - A unique "response queue" name that the Dispatcher will
+        #       provide the resposne on
+        #  - Requestor then blocks (with timeout) awaiting the response
+        #  - Dispatcher performs a "pop" operation and executes the command
+        #  - Dispatcher "pushes" the response to the "handle" queue
+        #  - Requestor "pops" the response and deletes the temporary "handle" queue
+
+        # Returns the commands queue key for the worker
+        #
+        # @return [String] - The key for the commands list
+        def command_req_queue
+          "wamp:#{self.name}:command"
+        end
+
+        # Returns a new handle
+        #
+        # @return [String] - The key for the new handle
+        def unique_command_resp_queue
+          "wamp:#{self.name}:response:#{SecureRandom.hex(12)}"
+        end
+
+        #endregion
+
+        #region Dispatcher/Backgrounder
+        # ----------------
+        # This workflow is used by a "Dispatcher" to execute a "topic" or "procedure"
+        # on a background thread.  This is used by a "BackgroundHandler" to push a
+        # handler to Sidekiq and get the response from the background job.  This frees
+        # up the Event Machine to process other requests
+        #
+        # The flow is as follows
+        #
+        #  - Dispatcher pushes the task to the background sidekiq worker providing
+        #    the "handle" it will respond on
+        #  - Backgrounder performs the operation
+        #  - Backgrounder performs a "push" with response back to the Dispatcher
+        #  - Dispatcher performs a "pop" and sends the response (if it is a call)
+
+        # Returns the response queue name for the backgrounder
+        #
+        # @return [String] - The key for the worker
+        def background_res_queue
+          "wamp:#{self.name}:background:#{self.uuid}"
+        end
+
+        #endregion
+
+        #region Requestor/Dispatcher Ticker
+        # ----------------
+        # This workflow is used to sense when a worker is no longer running
+        #
+        # The flow is as follows
+        #
+        #  - Dispatcher periodically increments the ticker
+        #  - Requestor does the following when performing a pop
+        #     - stores the value of the ticker
+        #     - blocks waiting for a "pop"
+        #     - if the pop comes back "nil", it means we timed out
+        #     - if the value of the ticker is that same as before, then th worker is not running
+
+        #endregion
+
+      end
+    end
+  end
+end