wamp-worker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 100ca25f15cff8d32a52b162a735f31cdb2753ef
+  data.tar.gz: a9895ee49189e59cfc5a90d7466da65cca11cd09
+SHA512:
+  metadata.gz: f001f796d69ea9e0e076035efaa45c6f759f2cd573c5252a8aa083806e41eb506e8b56052d5e88e24e2ec357ee5e2564caa69a8acacc379f86586ce6d5b28d5b
+  data.tar.gz: 45d4550224b221af0e22d2164f5ea48dacd38442e017d286687eef8bcf5ac81e68f17005b3965c804b9f40e39aa09b14d5ff37e93abd262fdf1b16277b32f337

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/test/.crossbar/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/test/wamp_test/tmp/
+/test/wamp_test/log/
+*.pyc
+.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.0

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.13.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wamp-worker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Eric Chapman
+
+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.

data/README.md

@@ -0,0 +1,204 @@
+# Wamp::Worker
+
+[![Gem Version](https://badge.fury.io/rb/wamp-worker.svg)](https://badge.fury.io/rb/wamp_client)
+[![Circle CI](https://circleci.com/gh/ericchapman/ruby_wamp_worker/tree/master.svg?&style=shield&circle-token=92813c17f9c9510c4c644e41683e7ba2572e0b2a)](https://circleci.com/gh/ericchapman/ruby_wamp_worker/tree/master)
+[![Codecov](https://img.shields.io/codecov/c/github/ericchapman/ruby_wamp_worker/master.svg)](https://codecov.io/github/ericchapman/ruby_wamp_worker)
+
+Rails worker for talking to a WAMP Router which is described [here](https://tools.ietf.org/html/draft-oberstet-hybi-tavendo-wamp-02)
+
+This GEM is intended to replace [wamp_rails](https://github.com/ericchapman/ruby_wamp_rails).
+ 
+This GEM is written using [wamp_client](https://github.com/ericchapman/ruby_wamp_client) to connect
+to a WAMP router.
+
+This GEM operates by using Redis to handle communication between your standard
+Rails instances and the main Wamp::Worker "runner".
+
+This GEM uses [Wamp::Client](https://github.com/ericchapman/ruby_wamp_client) to connect 
+to a WAMP router.  Wamp::Client operates on top of EventMachine.  One nuance of EventMachine 
+is that if an operation is blocking, it will block handling of all incoming operations until 
+it completes.  To remedy this, Wamp::Worker supports integration with a Sidekiq worker in your 
+Rails application to push the operation to a background process.  This will allow Sidekiq to 
+handle the operation while new requests come in.
+
+This GEM operates using 2 different threads
+
+ - The main thread is responsible for executing the Wamp::Client EventMachine operation which
+   will establish the connection to the router.  It also listens to the 2 other threads
+   looking for commands from Redis
+ - The other thread connects to Redis waiting for jobs to be pushed from either a Rails source
+   or jobs that were pushed to a background worker.  As it receives responses, it will pass
+   them to the main thread for processing.
+
+Some notes about Wamp::Worker
+
+ - intended to run as a Rails worker like 'Sidekiq'
+ - requires a Redis connection
+ - requires Sidekiq if background handlers are intended to be used
+ - supports WAMP call/publish from your standard Rails classes
+ - supports WAMP register/subscribe by including the "Handler" or "BackgroundHandler" modules
+   to classes you create
+   - BackgroundHandler requires Sidekiq
+   
+## Revision History
+
+ - v0.0.1:
+   - Initial Release
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wamp-worker'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wamp-worker
+
+## Usage
+
+### Configuration
+
+To configure Wamp::Worker, create a "config/initializers/wamp-worker.rb" file with the
+following options
+
+``` ruby
+Wamp::Worker.configure do
+  timeout 30
+  redis Redis.new
+  connection uri: 'ws://127.0.0.1:8080/ws', realm: 'realm1'
+end
+```
+
+The attributes are defined as follows
+
+ - timeout - (default: 60) number of seconds a "call" will wait before timing out
+ - redis - (default: Redis.new) either a Redis object or parameters to pass to 
+   creating a Redis object
+ - connection - options to pass to the "Wamp::Client::Connection".  See 
+   [wamp_client](https://github.com/ericchapman/ruby_wamp_client) for more details
+
+You can also "subscribe" and "register" in the configuration object.  That will be 
+described later.
+
+**Note that you MUST make sure "config.eager_load = true" is set in the environment files**
+
+### Multiple Workers
+
+Wamp::Worker supports creating multiple workers with different options.  To do this,
+pass a "name" to the "configure" method like below
+
+``` ruby
+Wamp::Worker.configure do
+  connection uri: 'ws://127.0.0.1:8080/ws', realm: 'realm1'
+end
+
+Wamp::Worker.configure :other do
+  connection uri: 'ws://127.0.0.1:8080/ws', realm: 'realm2'
+end
+```
+
+When the name is omitted, it will use the name ":default".
+
+### Handlers
+
+Handlers are controllers used to implement "subscribe" and "register" callbacks. An 
+example of one is shown below
+
+**app/handlers/my_handler.rb**
+
+``` ruby
+class MyHandler
+  include Wamp::Worker::Handler
+
+  register "com.example.add", :add, { invoke: "roundrobin" }
+  register "com.example.subtract", :subtract, { invoke: "roundrobin" }
+  subscribe "com.example.listener", :listener
+
+  def add
+    args[0] + args[1]
+  end
+  
+  def subtract
+    args[0] - args[1]
+  end
+  
+  def listener
+    # Do something
+  end
+
+end
+```
+
+You can also "register" and "subscribe" in the configure block
+
+``` ruby
+Wamp::Worker.configure do
+  connection uri: 'ws://127.0.0.1:8080/ws', realm: 'realm1'
+  
+  register "com.example.add", MyHandler, :add, { invoke: "roundrobin" }
+  register "com.example.subtract", MyHandler, :subtract, { invoke: "roundrobin" }
+  subscribe "com.example.listener", MyHandler, :listener
+end
+```
+
+#### Background Handlers
+
+For Rails applications that have Sidekiq, you can push the processing of the handler
+to the background by including "Wamp::Worker::BackgroundHandler" instead of
+"Wamp::Worker::Handler".
+
+### Rails Access
+
+The library also supports "call" and "publish" methods from Rails objects.  This is
+done by including "Wamp::Worker::Session" in your class.  For example
+
+**app/controllers/application_controller.rb**
+
+``` ruby
+class ApplicationController < ActionController::Base
+  include Wamp::Worker::Session.new
+end
+```
+
+**app/controllers/add_controller.rb**
+
+``` ruby
+class AddController < ApplicationController
+  def index
+    response = nil
+
+    self.wamp_session.call "com.example.back.add", [params[:a].to_i, params[:b].to_i] do |result, error, details|
+      response = result
+    end
+
+    render json: { result: response }
+  end
+end
+```
+
+Note that the name defaults to ":default" and the method ":wamp_session".  These
+can be overridden by including in the "include"
+
+``` ruby
+class ApplicationController < ActionController::Base
+  include Wamp::Worker::Session.new :other, method: :different_session
+end
+```
+
+### Starting the Worker
+
+To start the worker, use the "wamp-worker" executable
+
+    $ bundle exec wamp-worker
+    
+this executable supports the following options
+
+ - "-l" (default: "info"): logging level (debug, info, warn, error)
+ - "-n" (default: "default"): name of the worker

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wamp/worker"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/wamp-worker

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require "wamp/worker/rails"
+require "wamp/worker"
+require "optparse"
+require 'fileutils'
+
+options = {
+    :log_level => :info,
+    :environment => "development",
+    :require => "./",
+}
+
+# Parse the options from the command line
+OptionParser.new do |opts|
+  opts.banner = "Usage: wamp-worker [options]"
+
+  opts.on("-l", "--log-level LEVEL", "Sets the logging level") do |arg|
+    options[:log_level] = arg.strip.to_sym
+  end
+
+  opts.on("-n", "--name NAME", "Worker name") do |arg|
+    options[:name] = arg.strip.to_sym
+  end
+
+  opts.on '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require" do |arg|
+    options[:require] = arg.strip
+  end
+
+  opts.on '-e', '--environment ENV', "Application environment" do |arg|
+    options[:environment] = arg.strip
+  end
+end.parse!
+
+# Set the logging level of the worker
+log_level = options[:log_level]
+Wamp::Worker.logger.info("Wamp::Worker using log level '#{log_level}'")
+Wamp::Worker.log_level = log_level
+
+# Load rails
+environment = options[:environment]
+Wamp::Worker.logger.info("Wamp::Worker using Rails environment '#{environment}'")
+Wamp::Worker::Rails.load_app(environment, options[:require])
+
+# Start the runner
+Wamp::Worker.run(options[:name], **options)

data/lib/wamp/worker.rb

@@ -0,0 +1,132 @@
+require "wamp/worker/version"
+require "wamp/worker/proxy/requestor"
+require "wamp/worker/proxy/dispatcher"
+require "wamp/worker/proxy/backgrounder"
+require "wamp/worker/queue"
+require "wamp/worker/ticker"
+require "wamp/worker/handler"
+require "wamp/worker/config"
+require "wamp/worker/runner"
+require "wamp/client"
+require "redis"
+
+module Wamp
+  module Worker
+
+    # Used to include a requestor in a rails class
+    #
+    class Session
+      def self.new(name=nil, method: :wamp_session)
+        name ||= DEFAULT
+        Module.new do
+          define_method(method) { Wamp::Worker.requestor(name) }
+        end
+      end
+    end
+
+    # Returns the config object
+    #
+    def self.config
+      unless defined?(@config)
+        @config = Config.new
+      end
+      @config
+    end
+
+    # Returns the logger object
+    #
+    def self.logger
+      unless defined?(@logger)
+        $stdout.sync = true unless ENV['RAILS_ENV'] == "production"
+        @logger = Logger.new $stdout
+        @logger.level = Logger::INFO
+      end
+      @logger
+    end
+
+    # Sets the log level
+    #
+    # @param log_level [Symbol] - the desired log level
+    def self.log_level=(log_level)
+      Wamp::Client.log_level = log_level
+      level =
+          case log_level
+          when :error
+            Logger::ERROR
+          when :debug
+            Logger::DEBUG
+          when :fatal
+            Logger::FATAL
+          when :warn
+            Logger::WARN
+          else
+            Logger::INFO
+          end
+      self.logger.level = level
+    end
+
+    # Method to configure the worker
+    #
+    # @param name [Symbol] - The name of the connection
+    def self.configure(name=nil, &callback)
+      ConfigProxy.new(self.config, name).configure(&callback)
+    end
+
+    # Method to start a worker
+    #
+    # @param name [Symbol] - The name of the connection
+    def self.run(name, **args)
+      name ||= DEFAULT
+
+      # Get the connection info
+      options = Wamp::Worker.config.connection(name).merge(args)
+
+      # Create the runner and start it
+      Runner::Main.new(name, **options).start
+    end
+
+    # Returns a requestor for objects to perform calls to the worker
+    #
+    # @param name [Symbol] - The name of the connection
+    # @return [Wamp::Worker::Proxy::Requestor] - An object that can be used to make requests
+    def self.requestor(name)
+      name ||= DEFAULT
+
+      # Create a requestor proxy for the connection
+      Proxy::Requestor.new(name)
+    end
+
+    # Registers procedures
+    #
+    # @param name [Symbol] - The name of the connection
+    # @param proxy [Wamp::Worker::Proxy] - The proxy that will be used by the handler
+    # @param session [Wamp::Client::Session] - The session
+    def self.register_procedures(name, proxy, session)
+      Wamp::Worker.config.registrations(name).each do |r|
+        handler = -> a,k,d  {
+          self.logger.debug("#{self.name} invoking handler '#{r.klass}##{r.method}' for procedure '#{r.procedure}'")
+          r.klass.create(proxy, :procedure, a, k, d).invoke(r.method)
+        }
+        session.register(r.procedure, handler, r.options)
+        self.logger.info("#{self.name} register '#{r.klass}##{r.method}' for procedure '#{r.procedure}'")
+      end
+    end
+
+    # Subscribe to topics
+    #
+    # @param name [Symbol] - The name of the connection
+    # @param proxy [Wamp::Worker::Proxy] - The proxy that will be used by the handler
+    # @param session [Wamp::Client::Session] - The session
+    def self.subscribe_topics(name, proxy, session)
+      Wamp::Worker.config.subscriptions(name).each do |s|
+        handler = -> a, k, d {
+          self.logger.debug("#{self.name} invoking handler '#{s.klass}##{s.method}' for subscription '#{s.topic}'")
+          s.klass.create(proxy, :subscription, a, k, d).invoke(s.method)
+        }
+        session.subscribe(s.topic, handler, s.options)
+        self.logger.info("#{self.name} subscribe '#{s.klass}##{s.method}' for topic '#{s.topic}'")
+      end
+    end
+
+  end
+end