roundhouse-x 0.1.0

data/Gemfile

@@ -0,0 +1,27 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'rails', '~> 4.2'
+gem 'simplecov'
+gem 'minitest'
+gem 'awesome_print', require: 'ap'
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'         # if using anything in the ruby standard library
+  gem 'psych'                    # if using yaml
+  gem 'minitest'                 # if using minitest
+  gem 'rubinius-developer_tools' # if using any of coverage, debugger, profiler
+end
+
+platforms :ruby do
+  gem 'sqlite3'
+end
+
+platforms :mri do
+  gem 'pry-byebug'
+end
+
+platforms :jruby do
+  gem 'jruby-openssl'
+  gem 'activerecord-jdbcsqlite3-adapter'
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Original Sidekiq License:
+
+Copyright (c) Contributed Systems LLC
+
+Sidekiq is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.

data/README.md

@@ -0,0 +1,52 @@
+Roundhouse
+==============
+
+Roundhouse is based on Sidekiq 3.5.0 (HEAD: f8ee0896076671b73739099e3c1eb7d8814e407d)
+
+It uses the basic framework of a multi-threaded workers and managers to solve a different
+kind of problem. This problem resembles that of a load balancing problem: only one worker
+should be working on a work for a given user. This requires:
+
+1. A queue for each user
+2. A circular buffer to cycle through all user queues
+3. A way to track how many pieces of jobs to process per user, before moving to the next user's queue.
+
+Other things Roundhouse should be able to do:
+
+1. It should be able to run side-by side with Sidekiq client
+2. Be able to suspend, resume, and defer work
+3. Metrics to measure lead times and give estimates on when work might be completed
+4. Coordinate across a number of worker processes, across machines
+
+Install
+----------------
+
+```
+gem 'roundhouse-x', require: 'roundhouse'
+```
+
+Workers
+----------------
+
+```
+class APIWorker
+  include Roundhouse::Worker
+
+  def perform(id)
+    # something
+  end
+end
+
+APIWorker.perform_async(api_token.id, item.id)
+```
+
+Sidekiq License
+-----------------
+
+Please see [LICENSE](https://github.com/mperham/sidekiq/blob/master/LICENSE) for licensing details.
+
+
+Sidekiq Original Author
+-----------------
+
+Mike Perham, [@mperham](https://twitter.com/mperham) / [@sidekiq](https://twitter.com/sidekiq), [http://www.mikeperham.com](http://www.mikeperham.com) / [http://www.contribsys.com](http://www.contribsys.com)

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  #SO MUCH NOISE
+  #test.warning = true
+  test.pattern = 'test/**/test_*.rb'
+end
+
+task :default => :test

data/bin/roundhouse

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+# Quiet some warnings we see when running in warning mode:
+# RUBYOPT=-w bundle exec sidekiq
+$TESTING = false
+$CELLULOID_DEBUG = false
+
+require_relative '../lib/roundhouse/cli'
+
+begin
+  cli = Roundhouse::CLI.instance
+  cli.parse
+  cli.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/bin/roundhousectl

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+class Roundhousectl
+  DEFAULT_KILL_TIMEOUT = 10
+
+  attr_reader :stage, :pidfile, :kill_timeout
+
+  def self.print_usage
+    puts "#{File.basename($0)} - stop a Roundhouse process from the command line."
+    puts
+    puts "Usage: #{File.basename($0)} <command> <pidfile> <kill_timeout>"
+    puts " where <command> is either 'quiet' or 'stop'"
+    puts "       <pidfile> is path to a pidfile"
+    puts "       <kill_timeout> is number of seconds to wait until Roundhouse exits"
+    puts "       (default: #{Roundhousectl::DEFAULT_KILL_TIMEOUT}), after which Roundhouse will be KILL'd"
+    puts
+    puts "Be sure to set the kill_timeout LONGER than Roundhouse's -t timeout.  If you want"
+    puts "to wait 60 seconds for jobs to finish, use `sidekiq -t 60` and `sidekiqctl stop"
+    puts " path_to_pidfile 61`"
+    puts
+  end
+
+  def initialize(stage, pidfile, timeout)
+    @stage = stage
+    @pidfile = pidfile
+    @kill_timeout = timeout
+
+    done('No pidfile given', :error) if !pidfile
+    done("Pidfile #{pidfile} does not exist", :warn) if !File.exist?(pidfile)
+    done('Invalid pidfile content', :error) if pid == 0
+
+    fetch_process
+
+    begin
+      send(stage)
+    rescue NoMethodError
+      done "Invalid command: #{stage}", :error
+    end
+  end
+
+  def fetch_process
+    Process.getpgid(pid)
+  rescue Errno::ESRCH
+    done "Process doesn't exist", :error
+  end
+
+  def done(msg, error = nil)
+    puts msg
+    exit(exit_signal(error))
+  end
+
+  def exit_signal(error)
+    (error == :error) ? 1 : 0
+  end
+
+  def pid
+    @pid ||= File.read(pidfile).to_i
+  end
+
+  def quiet
+    Process.kill(:USR1, pid)
+  end
+
+  def stop
+    Process.kill(:TERM, pid)
+    kill_timeout.times do
+      begin
+        Process.getpgid(pid)
+      rescue Errno::ESRCH
+        FileUtils.rm_f pidfile
+        done 'Roundhouse shut down gracefully.'
+      end
+      sleep 1
+    end
+    Process.kill(:KILL, pid)
+    FileUtils.rm_f pidfile
+    done 'Roundhouse shut down forcefully.'
+  end
+  alias_method :shutdown, :stop
+end
+
+if ARGV.length < 2
+  Roundhousectl.print_usage
+else
+  stage = ARGV[0]
+  pidfile = ARGV[1]
+  timeout = ARGV[2].to_i
+  timeout = Roundhousectl::DEFAULT_KILL_TIMEOUT if timeout == 0
+
+  Roundhousectl.new(stage, pidfile, timeout)
+end

data/lib/generators/roundhouse/templates/worker.rb.erb

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>Worker
+  include Roundhouse::Worker
+
+  def perform(*args)
+    # Do something
+  end
+end
+<% end -%>

data/lib/generators/roundhouse/templates/worker_spec.rb.erb

@@ -0,0 +1,6 @@
+require 'rails_helper'
+<% module_namespacing do -%>
+RSpec.describe <%= class_name %>Worker, :type => :worker do
+    pending "add some examples to (or delete) #{__FILE__}"
+end
+<% end -%>

data/lib/generators/roundhouse/templates/worker_test.rb.erb

@@ -0,0 +1,8 @@
+require_relative 'test_helper'
+<% module_namespacing do -%>
+class <%= class_name %>WorkerTest < MiniTest::Unit::TestCase
+    def test_example
+      skip "add some examples to (or delete) #{__FILE__}"
+    end
+end
+<% end -%>

data/lib/generators/roundhouse/worker_generator.rb

@@ -0,0 +1,49 @@
+require 'rails/generators/named_base'
+
+module Roundhouse
+  module Generators # :nodoc:
+    class WorkerGenerator < ::Rails::Generators::NamedBase # :nodoc:
+      desc 'This generator creates a Roundhouse Worker in app/workers and a corresponding test'
+
+      check_class_collision suffix: 'Worker'
+
+      def self.default_generator_root
+        File.dirname(__FILE__)
+      end
+
+      def create_worker_file
+        template 'worker.rb.erb', File.join('app/workers', class_path, "#{file_name}_worker.rb")
+      end
+
+      def create_test_file
+        if defined?(RSpec)
+          create_worker_spec
+        else
+          create_worker_test
+        end
+      end
+
+      private
+
+      def create_worker_spec
+        template_file = File.join(
+            'spec/workers',
+            class_path,
+            "#{file_name}_worker_spec.rb"
+        )
+        template 'worker_spec.rb.erb', template_file
+      end
+
+      def create_worker_test
+        template_file = File.join(
+            'test/workers',
+            class_path,
+            "#{file_name}_worker_test.rb"
+        )
+        template 'worker_test.rb.erb', template_file
+      end
+
+
+    end
+  end
+end

data/lib/roundhouse/actor.rb

@@ -0,0 +1,39 @@
+module Roundhouse
+  module Actor
+
+    module ClassMethods
+      def trap_exit(*args)
+      end
+      def new_link(*args)
+        new(*args)
+      end
+    end
+
+    module InstanceMethods
+      def current_actor
+        self
+      end
+      def after(interval)
+      end
+      def alive?
+        @dead = false unless defined?(@dead)
+        !@dead
+      end
+      def terminate
+        @dead = true
+      end
+      def defer
+        yield
+      end
+    end
+
+    def self.included(klass)
+      if $TESTING
+        klass.__send__(:include, InstanceMethods)
+        klass.__send__(:extend, ClassMethods)
+      else
+        klass.__send__(:include, Celluloid)
+      end
+    end
+  end
+end