wamp-worker 0.1.0

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

@@ -0,0 +1,115 @@
+require_relative "base"
+
+module Wamp
+  module Worker
+    module Proxy
+
+      class Dispatcher < Base
+        attr_accessor :session
+
+        # We want to timeout every few seconds so higher level code can
+        # look for a shutdown
+        TIMEOUT = 2
+
+        # Constructor
+        #
+        def initialize(name, session=nil, uuid: nil)
+          super name, uuid: uuid
+          self.session = session
+        end
+
+        # Increments the ticker
+        #
+        def increment_ticker
+          self.ticker.increment
+        end
+
+        # Check the queues
+        #
+        def check_queues
+          check_queue [self.command_req_queue, self.background_res_queue]
+        end
+
+        # Executes the request
+        #
+        # @param request [Descriptor] - The request
+        def process(descriptor)
+          return unless descriptor != nil
+
+          raise(RuntimeError, "must have a session to process a descriptor") unless self.session != nil
+
+          # Create the callback
+          callback = -> result, error, details {
+            # Need to remove the session from the details response
+            details&.delete(:session)
+
+            # Create the params
+            params = { result: result, error: error, details: details }
+
+            # Push the response back
+            self.queue.push descriptor.handle, descriptor.command, params
+          }
+
+          # Call the session
+          if descriptor.command == :call
+
+            # invoke the call method
+            procedure = descriptor.params[:procedure]
+            args = descriptor.params[:args]
+            kwargs = descriptor.params[:kwargs]
+            options = descriptor.params[:options]
+
+            self.session.call(procedure, args, kwargs, options, &callback)
+
+          elsif descriptor.command == :publish
+
+            # invoke the publish method
+            topic = descriptor.params[:topic]
+            args = descriptor.params[:args]
+            kwargs = descriptor.params[:kwargs]
+            options = descriptor.params[:options]
+
+            self.session.publish(topic,  args, kwargs, options, &callback)
+
+          elsif descriptor.command == :yield
+
+            # invoke the yield method
+            request = descriptor.params[:request]
+            options = descriptor.params[:options]
+            check_defer = descriptor.params[:check_defer]
+            result_hash = descriptor.params[:result] || {}
+
+            # Get the response from the descriptor params
+            result = Wamp::Client::Response.from_hash(result_hash)
+
+            self.session.yield(request, result, options, check_defer)
+
+          else
+
+            # Return error if the command is not supported
+            error = Wamp::Client::Response::CallError.new(
+                Wamp::Client::Response::DEFAULT_ERROR,
+                ["unsupported proxy command '#{descriptor.command}'"])
+            callback.call(nil, error.to_hash, {})
+
+          end
+
+        end
+
+        private
+
+        # This methods blocks waiting for a value to appear in the queue
+        #
+        # @param queue_name [String] - the name of the queue
+        def check_queue(queue_name)
+
+          # Wait for a value to appear in the queue.  We have a timeout so
+          # the thread can check if the worker has been killed
+          self.queue.pop(queue_name, wait: true, timeout: TIMEOUT)
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,91 @@
+require_relative "base"
+
+module Wamp
+  module Worker
+    module Proxy
+
+      class Requestor < Base
+
+        # Performs the session "call" method
+        #
+        # @param procedure [String] - The procedure to call
+        # @param args [Array] - Array of arguments
+        # @param kwargs [Hash] - Hash of key/word arguments
+        # @param options [Hash] - Options for the call
+        def call(procedure, args=nil, kwargs=nil, options={}, &callback)
+
+          # Create the params
+          params = { procedure: procedure, args: args, kwargs: kwargs, options: options }
+
+          # Execute the command
+          request_response :call, params, true, &callback
+        end
+
+        # Performs the session "publish" method
+        #
+        # @param topic [String] - The topic to publish
+        # @param args [Array] - Array of arguments
+        # @param kwargs [Hash] - Hash of key/word arguments
+        # @param options [Hash] - Options for the subscribe
+        def publish(topic, args=nil, kwargs=nil, options={}, &callback)
+
+          # Create the params
+          params = { topic: topic , args: args, kwargs: kwargs, options: options }
+
+          # Execute the command
+          request_response :publish, params, options[:acknowledge], &callback
+        end
+
+        private
+
+        # Method to push the request and wait for the response
+        #
+        # @param command [Symbol] - The command
+        # @param params [Hash] - The parameters
+        # @param wait [Bool] - if true, will wait for the response
+        def request_response(command, params, wait=true)
+
+          # Create a response handle
+          handle = self.unique_command_resp_queue
+
+          # Push the request
+          self.queue.push self.command_req_queue, command, params, handle
+
+          # If wait, check the queue and respond
+          if wait
+
+            # Store the start ticker
+            start_tick = self.ticker.get
+
+            # Wait for the response
+            descriptor = self.queue.pop(handle, wait: true, delete: true)
+
+            # check for nil descriptor
+            if descriptor == nil
+
+              # If the ticker never incremented, throw a "worker not responding" error
+              current_tick = self.ticker.get
+              if start_tick == current_tick
+                raise(RuntimeError, "worker '#{self.name}' is not responding")
+              else
+                raise(RuntimeError, "request to #{handle} timed out")
+              end
+
+            else
+
+              # If a block was given, respond
+              if block_given?
+                response = [descriptor.params[:result], descriptor.params[:error], descriptor.params[:details]]
+                yield(*response)
+              end
+
+            end
+
+          end
+        end
+
+
+      end
+    end
+  end
+end

data/lib/wamp/worker/queue.rb

@@ -0,0 +1,135 @@
+require "json"
+
+module Wamp
+  module Worker
+
+    class Queue
+      attr_reader :redis, :default_timeout
+
+      # This class represents the payload that will be stored in Redis
+      class Descriptor
+        attr_reader :command, :handle, :params
+
+        # Constructor
+        #
+        # @param command [Symbol] - The command for the descriptor
+        # @param handle [String] - The handle representing the descriptor
+        # @param params [Hash] - The params for the command
+        def initialize(command, handle, params)
+          @command = command.to_sym
+          @handle = handle
+          @params = params || {}
+        end
+
+        # Create a Descriptor object from the json payload
+        #
+        # @param json_string [String] - The string from the Redis store
+        # @return [Descriptor] - The instantiated descriptor
+        def self.from_json(json_string)
+          return unless json_string
+          parsed = JSON.parse(json_string, :symbolize_names => true)
+          self.new(parsed[:command], parsed[:handle], parsed[:params])
+        end
+
+        # Creates the json payload from the object
+        #
+        # @return [String] - The string that will go into the Redis store
+        def to_json
+          { command: self.command, handle: self.handle, params: self.params }.to_json
+        end
+      end
+
+      # Constructor
+      #
+      def initialize(name)
+        @redis = Wamp::Worker.config.redis(name)
+        @default_timeout = Wamp::Worker.config.timeout(name)
+      end
+
+      # Pushes a command onto the queue
+      #
+      # @param queue_name [String] - The name of the queue
+      # @param command [Symbol] - The command
+      # @param params [Hash] - The params for the request
+      # @param handle [String] - The response handle
+      def push(queue_name, command, params, handle=nil)
+
+        # Create the descriptor
+        descriptor = Descriptor.new(command, handle, params)
+
+        # Log the info
+        log(:push, queue_name, descriptor)
+
+        # Queue the command
+        self.redis.lpush(queue_name, descriptor.to_json)
+      end
+
+      # Pops a command off of the queue
+      #
+      # @param queue_name [String, Array] - The name of the queue (or multiple queues if brpop)
+      # @param wait [Bool] - True if we want to block waiting for the response
+      # @param delete [Bool] - True if we want the queue deleted (only applicable if wait)
+      # @param timeout [Int] - Number of seconds to wait before timing out
+      def pop(queue_name, wait: false, delete: false, timeout: nil)
+
+        # Retrieve the response from the queue
+        if wait
+          # Use the default timeout if non is specified
+          timeout ||= self.default_timeout
+
+          # Make the pop call
+          response = self.redis.brpop(queue_name, timeout: timeout)
+
+          # Returns [queue, value]
+          if response != nil
+            queue_name = response[0]
+            response = response[1]
+          end
+        else
+          # Else just call the method
+          response = self.redis.rpop(queue_name)
+        end
+
+        # If delete was set, delete the queue
+        if delete
+          self.redis.del(queue_name)
+        end
+
+        # Parse the response
+        descriptor = response != nil ? Descriptor.from_json(response) : nil
+
+        # Log the info
+        log(:pop, queue_name, descriptor)
+
+        # Return the queue_name and the descriptor
+        descriptor
+      end
+
+      private
+
+      # Returns the logger
+      #
+      def logger
+        Wamp::Worker.logger
+      end
+
+      # Logs the info
+      #
+      def log(type, queue_name, descriptor)
+        return unless logger.level == Logger::DEBUG
+
+        if descriptor
+          logger.debug("#{self.class.name} #{type.upcase} : #{queue_name}")
+          logger.debug("   command: #{descriptor.command}")
+          logger.debug("   params: #{descriptor.params}")
+          logger.debug("   handle: #{descriptor.handle}")
+        else
+          logger.debug("#{self.class.name} #{type.upcase} : #{queue_name} : EMPTY")
+        end
+      end
+
+
+    end
+  end
+end
+

data/lib/wamp/worker/rails.rb

@@ -0,0 +1,28 @@
+module Wamp
+  module Worker
+    module Rails
+
+      # This method will load Rails
+      #
+      # @param environment [String] - The Rails environment
+      # @param require [String] - The path to the Rails working directory or a file with requires
+      def self.load_app(environment, require)
+        ENV['RACK_ENV'] = ENV['RAILS_ENV'] = environment
+
+        raise ArgumentError, "'#{require}' does not exist" unless File.exist?(require)
+
+        if File.directory?(require)
+          require 'rails'
+          if ::Rails::VERSION::MAJOR < 5
+            raise "only Rails version 5 and higher supported"
+          else
+            require File.expand_path("#{require}/config/environment.rb")
+          end
+        else
+          require(require) || raise(ArgumentError, "no require file found at '#{require}'")
+        end
+      end
+
+    end
+  end
+end

data/lib/wamp/worker/runner.rb

@@ -0,0 +1,240 @@
+require "thread"
+require "wamp/client/connection"
+
+module Wamp
+  module Worker
+    module Runner
+
+      # This is a base class for all of the runners
+      class Base
+        attr_reader :name, :dispatcher
+
+        # Constructor
+        #
+        # @param name [Symbol] - the name of the worker
+        def initialize(name, uuid: nil)
+          # Initialize the dispatcher
+          @name = name || :default
+          @dispatcher = Proxy::Dispatcher.new(self.name, uuid: uuid)
+          @active = false
+        end
+
+        # Returns the logger
+        #
+        def logger
+          Wamp::Worker.logger
+        end
+
+        # Returns if the runner is active
+        #
+        def active?
+          @active
+        end
+
+        # Starts the runner
+        #
+        def start
+          return if self.active?
+          @active = true
+          self._start
+        end
+
+        # Stops the runner
+        #
+        def stop
+          return unless self.active?
+          self._stop
+          @active = false
+        end
+
+        #region Override Methods
+        def _start
+        end
+
+        def _stop
+        end
+        #endregion
+
+      end
+
+      # This class monitors the queue and returns the descriptor
+      class Background < Base
+        attr_reader :callback, :thread
+
+        # Constructor
+        #
+        # @param name [Symbol] - the name of the worker
+        def initialize(name, uuid: nil, &callback)
+          super name, uuid: uuid
+
+          @callback = callback
+
+          # Log the event
+          logger.debug("#{self.class.name} '#{self.name}' created")
+        end
+
+        # Starts the background runner
+        #
+        def _start
+          # Start the background thread
+          Thread.new do
+
+            # The background thread will infinitely call the callback while the
+            # runner is active
+            while self.active?
+              begin
+                self.callback.call(self)
+              rescue => e
+                logger.error("#{self.class.name} #{e.class.name} - #{e.message}")
+              end
+            end
+
+          end
+        end
+      end
+
+      # This class is the main runner
+      class Main < Base
+        attr_reader :challenge, :client, :descriptor_queue, :queue_monitor
+
+        # Constructor
+        #
+        def initialize(name=nil, **options)
+          super name
+
+          # Combine the options
+          options = Wamp::Worker.config.connection(self.name).merge options
+
+          # Setup different options
+          @challenge = options[:challenge]
+          @client = options[:client] || Wamp::Client::Connection.new(options)
+          @active = false
+
+          # Log the event
+          logger.info("#{self.class.name} '#{self.name}' created with options")
+          logger.info("   uri: #{options[:uri]}")
+          logger.info("   realm: #{options[:realm]}")
+
+          # Create a queue for passing messages to the main runner
+          @descriptor_queue = ::Queue.new
+
+          # Note: since the queue monitor is attached to the same worker,
+          # we need to lock the UUIDs together.  This will make sure they
+          # delegate background tasks correctly
+          uuid = self.dispatcher.uuid
+
+          # Create a command queue monitor
+          @queue_monitor = Background.new(self.name, uuid: uuid) do |runner|
+            descriptor = runner.dispatcher.check_queues
+            self.descriptor_queue.push(descriptor) if descriptor
+          end
+
+          # Add the tick loop handler
+          self.client.transport_class.add_tick_loop { self.tick_handler }
+
+          # Initialize the last tick
+          @last_tick = Time.now.to_i
+
+          # Catch SIGINT
+          Signal.trap('INT') { self.stop }
+          Signal.trap('TERM') { self.stop }
+        end
+
+        # Starts the run loop
+        #
+        def _start
+
+          # On join, we need to subscribe and register the different handlers
+          self.client.on :join do |session, details|
+            self.join_handler session, details
+          end
+
+          # On leave, we will print a message
+          self.client.on :leave do |reason, details|
+            self.leave_handler(reason, details)
+          end
+
+          # On challenge, we will run the users challenge code
+          self.client.on :challenge do |authmethod, details|
+            self.challenge_handler(authmethod, details)
+          end
+
+          # Start the monitors
+          self.queue_monitor.start
+
+          # Log info
+          logger.info("#{self.class.name} '#{self.name}' started")
+
+          # Start the connection
+          self.client.open
+        end
+
+        # Stops the run loop
+        #
+        def _stop
+
+          # Stop the other threads
+          self.queue_monitor.stop
+
+          # Stop the event machine
+          self.client.close
+        end
+
+        def join_handler(session, details)
+          logger.info("#{self.class.name} runner '#{self.name}' joined session with realm '#{details[:realm]}'")
+
+          # Set the session
+          self.dispatcher.session = session
+
+          # Register for the procedures
+          Wamp::Worker.register_procedures(self.name, self.dispatcher, session)
+
+          # Subscribe to the topics
+          Wamp::Worker.subscribe_topics(self.name, self.dispatcher, session)
+        end
+
+        def leave_handler(reason, details)
+          logger.info("#{self.class.name} runner '#{self.name}' left session: #{reason}")
+
+          # Clear the session
+          self.dispatcher.session = nil
+        end
+
+        def challenge_handler(authmethod, extra)
+          logger.info("#{self.class.name} runner '#{self.name}' challenge")
+
+          if self.challenge
+            self.challenge.call(authmethod, extra)
+          else
+            self.stop
+            raise(ArgumentError, "client asked for '#{authmethod}' challenge, but no ':challenge' option was provided")
+          end
+        end
+
+        # This method periodically checks if any work has come in from the queues
+        #
+        def tick_handler
+
+          # This code will implement the ticker every second.  This tells the
+          # requestors that the worker is alive
+          current_time = Time.now.to_i
+          if current_time > @last_tick
+            self.dispatcher.increment_ticker
+            @last_tick = current_time
+          end
+
+          # Loop until the queue is empty
+          until self.descriptor_queue.empty? do
+
+            # Pop the value and process it
+            descriptor = self.descriptor_queue.pop
+            self.dispatcher.process(descriptor)
+
+          end
+        end
+
+      end
+
+    end
+  end
+end