wamp-worker 0.1.0

data/lib/wamp/worker/ticker.rb

@@ -0,0 +1,30 @@
+module Wamp
+  module Worker
+
+    class Ticker
+      attr_reader :redis, :ticker_key
+
+      # Constructor
+      #
+      # @param name [Symbol] - The name of the worker
+      def initialize(name)
+        @redis = Wamp::Worker.config.redis(name)
+        @ticker_key = "wamp:#{name}:tick"
+      end
+
+      # Returns the tick for the worker
+      #
+      # @return [Int] - The value of the tick
+      def get
+        self.redis.get(self.ticker_key) || 0
+      end
+
+      # Increments the tick
+      #
+      def increment
+        self.redis.incr(self.ticker_key)
+      end
+
+    end
+  end
+end

data/lib/wamp/worker/version.rb

@@ -0,0 +1,5 @@
+module Wamp
+  module Worker
+    VERSION = "0.1.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec/'
+end
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "wamp/worker"
+
+Dir[File.expand_path('spec/support/**/*.rb')].each { |f| require f }
+
+require 'sidekiq/testing'
+Sidekiq::Testing.inline!
+
+Wamp::Worker.log_level = :error
+
+RSpec.configure do |config|
+  config.before(:each) {
+    stub_redis
+    stub_client
+  }
+end
+
+def stub_redis
+  allow(::Redis).to receive(:new).and_return(RedisStub.new)
+end
+
+def stub_client
+  allow(::Wamp::Client::Connection).to receive(:new).and_return(ClientStub.new({}))
+end

data/spec/support/client_stub.rb

@@ -0,0 +1,47 @@
+class ClientStub
+  attr_accessor :session, :options, :is_open
+
+  def transport_class
+    Wamp::Client::Transport::EventMachineBase
+  end
+
+  def initialize(options)
+    self.options = options
+    self.is_open = false
+    self.session = SessionStub.new
+    @callbacks = {}
+  end
+
+  def open
+    self.is_open = true
+
+    # Fake connect
+    trigger(:connect) { |handler| handler.call }
+
+    # Fake challenge
+    trigger(:challenge) { |handler| handler.call('wampcra', {}) } if self.options[:should_challenge]
+
+    # Fake join
+    trigger(:join) { |handler| handler.call(self.session, {}) }
+  end
+
+  def close
+    # Fake leave
+    trigger(:leave) { |handler| handler.call('left', {}) }
+
+    # Fake disconnect
+    trigger(:disconnect) { |handler| handler.call('left') }
+
+    self.is_open = false
+  end
+
+  def on(event, &callback)
+    @callbacks[event] = callback
+  end
+
+  def trigger(event, &callback)
+    handler = @callbacks[event]
+    callback.call(handler) if handler
+  end
+
+end

data/spec/support/handler_stub.rb

@@ -0,0 +1,105 @@
+class Handler
+
+  def topic
+    self.class.increment_run_count
+  end
+
+  def return_error
+    self.class.increment_run_count
+    Wamp::Client::Response::CallError.new("error")
+  end
+
+  def throw_error
+    self.class.increment_run_count
+    raise Wamp::Client::Response::CallError.new("error")
+  end
+
+  def throw_exception
+    self.class.increment_run_count
+    raise StandardError.new("error")
+  end
+
+  def call_result
+    self.class.increment_run_count
+    Wamp::Client::Response::CallResult.new([(self.args[0] + 2)])
+  end
+
+  def normal_result
+    self.class.increment_run_count
+    self.args[0] + 3
+  end
+
+  def nil_result
+    self.class.increment_run_count
+    nil
+  end
+
+  def proxy_result
+    self.class.increment_run_count
+    response = nil
+    self.session.call("normal_result", self.args, self.kwargs) do |result, error, details|
+      response = result[:args][0]
+    end
+    response
+  end
+
+  def progress_result
+    self.class.increment_run_count
+    self.progress(0)
+    self.progress(0.5)
+    self.progress(1.0)
+    self.args[0] + 4
+  end
+
+end
+
+
+class NormalHandler < Handler
+  include Wamp::Worker::Handler
+
+  @@run_count = 0
+  def self.increment_run_count
+    @@run_count += 1
+  end
+  def self.run_count
+    @@run_count
+  end
+
+  subscribe "topic", :topic
+  subscribe "other.topic", :topic, :name => :other
+  register "return_error", :return_error
+  register "throw_error", :throw_error
+  register "throw_exception", :throw_exception
+  register "call_result", :call_result
+  register "other.call_result", :call_result, :name => :other
+  register "normal_result", :normal_result
+  register "nil_result", :nil_result
+  register "proxy_result", :proxy_result
+  register "progress_result", :progress_result
+end
+
+class BackgroundHandler < Handler
+  include Wamp::Worker::BackgroundHandler
+
+  @@run_count = 0
+  def self.increment_run_count
+    @@run_count += 1
+  end
+  def self.run_count
+    @@run_count
+  end
+
+  subscribe "back.topic", :topic
+  subscribe "back.other.topic", :topic, :name => :other
+  register "back.return_error", :return_error
+  register "back.throw_error", :throw_error
+  register "back.throw_exception", :throw_exception
+  register "back.call_result", :call_result
+  register "back.other.call_result", :call_result, :name => :other
+  register "back.normal_result", :normal_result
+  register "back.nil_result", :nil_result
+  register "back.proxy_result", :proxy_result
+  register "back.progress_result", :progress_result
+end
+
+

data/spec/support/redis_stub.rb

@@ -0,0 +1,89 @@
+require 'thread'
+
+class RedisStub
+  attr_reader :data, :semaphore
+
+  def initialize
+    @data = {}
+    @semaphore = Mutex.new
+  end
+
+  def lpush(key, data)
+    self.semaphore.synchronize {
+      list = self.data[key] || []
+      list.unshift data
+      self.data[key] = list
+    }
+  end
+
+  def exists(key)
+    self.semaphore.synchronize {
+      self.data[key] != nil
+    }
+  end
+
+  def get(key)
+    self.semaphore.synchronize {
+      self.data[key]
+    }
+  end
+
+  def set(key, value, options={})
+    self.semaphore.synchronize {
+      self.data[key] = value
+    }
+  end
+
+  def del(key)
+    self.semaphore.synchronize {
+      self.data.delete(key)
+      1
+    }
+  end
+
+  def rpop(key)
+    self.semaphore.synchronize {
+      (self.data[key] || []).pop
+    }
+  end
+
+  def brpop(key, **args)
+    value = nil
+    timeout = false
+    start_time = Time.new.to_i
+
+    # BRPOP also supports an array of keys
+    keys = key.is_a?(Array) ? key : [key]
+    matched_key = nil
+
+    while value == nil and not timeout
+      self.semaphore.synchronize {
+        keys.each do |temp_key|
+          value = (self.data[temp_key] || []).pop
+          if value != nil
+            matched_key = temp_key
+            break
+          end
+        end
+      }
+
+      if args[:timeout] != nil
+        current_time = Time.new.to_i
+        if current_time > args[:timeout]+start_time
+          timeout = true
+        end
+      end
+    end
+
+    value != nil ? [matched_key, value] : nil
+  end
+
+  def incr(key)
+    self.semaphore.synchronize {
+      value = self.data[key] || 0
+      value += 1
+      self.data[key] = value
+    }
+  end
+
+end

data/spec/support/session_stub.rb

@@ -0,0 +1,101 @@
+class SessionStub
+  attr_reader :subscriptions, :registrations, :defers, :calls
+
+  def initialize
+    @subscriptions = {}
+    @registrations = {}
+    @defers = {}
+    @calls = {}
+  end
+
+  def publish(topic, args=nil, kwargs=nil, options={}, &callback)
+    subscription = self.subscriptions[topic]
+    error = nil
+
+    if subscription
+      subscription.call(args, kwargs, {})
+    else
+      error = Wamp::Client::Response::CallError.new("wamp.no_subscriber").to_hash
+    end
+
+    if callback and options[:acknowledge]
+      callback.call(1234, error, { topic: topic })
+    end
+  end
+
+  def call(procedure, args=nil, kwargs=nil, options={}, &callback)
+    registration = self.registrations[procedure]
+    request = SecureRandom.uuid
+
+    self.calls[request] = callback
+
+    if registration
+      details = options.clone
+      details[:request] = request
+
+      result = Wamp::Client::Response.invoke_handler do
+        registration.call(args, kwargs, details)
+      end
+    else
+      result = Wamp::Client::Response::CallError.new("wamp.no_procedure")
+    end
+
+    if callback
+      if result.is_a?(Wamp::Client::Response::CallDefer)
+        self.defers[request] = callback
+      else
+        self.yield(request, result, options)
+      end
+    end
+
+    self.calls.delete(request)
+  end
+
+  def register(procedure, handler, options=nil, interrupt=nil, &callback)
+    self.registrations[procedure] = handler
+
+    if callback
+      callback.call({procedure: procedure, handler: handler}, nil, nil)
+    end
+  end
+
+  def subscribe(topic, handler, options={}, &callback)
+    self.subscriptions[topic] = handler
+
+    if callback
+      callback.call({topic: topic, handler: handler}, nil, nil)
+    end
+  end
+
+  def yield(request, result, options={}, check_defer=false)
+
+    # Get the callback
+    callback =
+        if check_defer
+          callback = self.defers[request]
+          self.defers.delete(request) unless options[:progress]
+          callback
+        else
+          self.calls[request]
+        end
+
+    # If there is a callback, handle it
+    if callback
+
+      # Create the response object
+      result = Wamp::Client::Response::CallResult.ensure(result, allow_error: true)
+
+      # Create the details
+      details = { request: request, progress: options[:progress] }
+
+      # Call the callback
+      if result.is_a?(Wamp::Client::Response::CallError)
+        callback.call(nil, result.to_hash, details)
+      else
+        callback.call(result.to_hash, nil, details)
+      end
+    end
+
+  end
+
+end

data/spec/wamp/worker/config_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+class Handler1
+  include Wamp::Worker::Handler
+
+  def handler
+  end
+end
+
+describe Wamp::Worker::Config do
+  let(:config) { described_class.new }
+  let(:proxy) { Wamp::Worker::ConfigProxy.new(config) }
+  let(:other_proxy) { Wamp::Worker::ConfigProxy.new(config, :other) }
+
+  it "sets everything to the default" do
+    proxy.configure do
+      timeout 100
+      connection option: true
+
+      subscribe "topic", Handler1, :handler, match: true
+      register "procedure", Handler1, :handler
+    end
+
+    expect(config.connection).to eq({option: true})
+    expect(config.timeout).to eq(100)
+    expect(config.redis.is_a?(RedisStub)).to eq(true)
+    expect(config.registrations.count).to eq(1)
+    expect(config.subscriptions.count).to eq(1)
+
+    expect(config.connection(:default)).to eq({option: true})
+    expect(config.timeout(:default)).to eq(100)
+    expect(config.redis(:default).is_a?(RedisStub)).to eq(true)
+    expect(config.registrations(:default).count).to eq(1)
+    expect(config.subscriptions(:default).count).to eq(1)
+  end
+
+  it "sets everything to other" do
+    other_proxy.configure do
+      timeout 100
+      connection option: true
+
+      subscribe "topic", Handler1, :handler, match: true
+      register "procedure", Handler1, :handler
+    end
+
+    # Defaults
+    expect(config.connection).to eq({})
+    expect(config.timeout).to eq(60)
+    expect(config.redis.is_a?(RedisStub)).to eq(true)
+    expect(config.registrations.count).to eq(0)
+    expect(config.subscriptions.count).to eq(0)
+
+    expect(config.connection(:other)).to eq({option: true})
+    expect(config.timeout(:other)).to eq(100)
+    expect(config.redis(:other).is_a?(RedisStub)).to eq(true)
+    expect(config.registrations(:other).count).to eq(1)
+    expect(config.subscriptions(:other).count).to eq(1)
+  end
+
+  it "does both" do
+    proxy.configure do
+      timeout 100
+      connection option: true
+
+      subscribe "topic", Handler1, :handler, match: true
+      register "procedure", Handler1, :handler
+    end
+
+    other_proxy.configure do
+      timeout 110
+      connection option: false
+
+      subscribe "topic", Handler1, :handler, match: true
+      register "procedure", Handler1, :handler
+    end
+
+    expect(config.connection).to eq({option: true})
+    expect(config.timeout).to eq(100)
+    expect(config.redis.is_a?(RedisStub)).to eq(true)
+    expect(config.registrations.count).to eq(1)
+    expect(config.subscriptions.count).to eq(1)
+
+    expect(config.connection(:other)).to eq({option: false})
+    expect(config.timeout(:other)).to eq(110)
+    expect(config.redis(:other).is_a?(RedisStub)).to eq(true)
+    expect(config.registrations(:other).count).to eq(1)
+    expect(config.subscriptions(:other).count).to eq(1)
+  end
+end
+