run_rabbit_run 0.0.3

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log
+.rvmrc
+*.swp
+dump.rdb
+*.pid

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Arturs Kreipans
+
+MIT License
+
+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,29 @@
+# RunRabbitRun
+
+git@github.com:fragallia/run_rabbit_run.git
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'run_rabbit_run'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install run_rabbit_run
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/run_rabbit_run/callbacks.rb

@@ -0,0 +1,23 @@
+module RunRabbitRun
+  module Callbacks
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def define_callback *names
+        names.each do | name |
+          define_method name do | &block |
+            @callbacks ||= {}
+            @callbacks[name.to_sym] ||= []
+            @callbacks[name.to_sym] << block
+          end
+        end
+      end
+    end
+
+    def call_callback name, *params
+      @callbacks[name.to_sym].each { | c | c.call *params } if @callbacks
+    end
+  end
+end

data/lib/run_rabbit_run/config/worker.rb

@@ -0,0 +1,36 @@
+module RunRabbitRun
+  module Config
+    class Worker
+      attr_accessor :options
+      
+      def initialize(path, options = {})
+        @options = {
+          path:          File.expand_path(path),
+          log_to_master: true,
+          processes:     1,
+        }.merge(options)
+
+        @options[:processes] = 1 unless @options[:processes].to_i > 0
+
+        raise "File not exists: #{@options[:path]}" unless File.exists?(@options[:path])
+      end
+
+      def options
+        @options ||= {}
+      end
+     
+      def name value
+        options[:name] = value
+      end
+
+      def processes value
+        options[:processes] = value > 0 ? value : 1
+      end
+
+      def log_to_master value
+        options[:log_to_master] = !!value
+      end
+
+    end
+  end
+end

data/lib/run_rabbit_run/config.rb

@@ -0,0 +1,54 @@
+require 'run_rabbit_run/config/worker'
+
+module RunRabbitRun
+  module Config
+    extend self
+
+    attr_accessor :options
+
+    def load(application_path)
+      @options = {
+        application_path: application_path,
+        pid:              "#{application_path}/tmp/pids/run_rabbit_run.pid",
+        environment:      (ENV['RAKE_ENV'] || ENV['RAILS_ENV'] || 'development'),
+        log:              "log/run_rabbit_run.log",
+      }
+
+      load_from_file "#{application_path}/config/rrr.rb"
+      load_from_file "#{application_path}/config/rrr/#{@options[:environment]}.rb"
+
+      options
+    end
+
+    def options
+      @options ||= {}  
+    end
+
+    def log value
+      options[:log] = File.expand_path(value)
+    end
+
+    def pid value
+      options[:pid] = File.expand_path(value)
+    end
+
+    def worker name, path, options = {}, &block
+      worker = RunRabbitRun::Config::Worker.new(path, options)
+      worker.instance_exec &block if block_given?
+
+      self.options[:workers] ||= {}
+      self.options[:workers][name] = worker.options
+    end
+
+    def run *workers
+      options[:run] = workers 
+    end
+
+  private
+
+    def load_from_file(path)
+      instance_eval File.read(path), path
+    end
+
+  end
+end

data/lib/run_rabbit_run/master.rb

@@ -0,0 +1,98 @@
+require 'run_rabbit_run/workers'
+require 'run_rabbit_run/rabbitmq'
+require 'run_rabbit_run/rabbitmq/system_messages'
+require 'run_rabbit_run/pid'
+require 'run_rabbit_run/processes/master'
+
+module RunRabbitRun
+  module Master
+    extend self
+
+    def master_process
+      @master_process ||= begin
+        master = RunRabbitRun::Processes::Master.new
+        master.pid = Pid.pid
+       
+        master
+      end
+    end
+    
+    def start
+      master_process.start do
+        workers = RunRabbitRun::Workers.new
+        workers.start
+
+        add_periodic_timer 2 do
+          begin
+            workers.check unless exiting?
+          rescue => e
+            RunRabbitRun.logger.error e.message
+          end
+        end
+
+        before_exit do
+          workers.stop
+        end
+
+        before_reload do
+          workers.reload
+        end
+
+        on_system_message_received do | from, message, data |
+          begin
+            RunRabbitRun.logger.info "[master] got message [#{message}] from [#{from}] with data [#{data.inspect}]"
+
+            case message.to_sym
+            when :add_worker
+              workers.add(data['worker'])
+            when :remove_worker
+              workers.remove(data['worker'])
+            when :process_started
+              workers.worker(from.to_s).pid = data["pid"].to_i
+            end
+          rescue => e
+            RunRabbitRun.logger.error e.message
+          end
+        end
+
+      end
+
+      Pid.save(master_process.pid)
+    end
+
+    def add_worker name
+      EventMachine.run do
+        rabbitmq = RunRabbitRun::Rabbitmq::Base.new
+
+        system_messages = RunRabbitRun::Rabbitmq::SystemMessages.new(rabbitmq)
+        system_messages.publish(:system, :master, :add_worker, { worker: name })
+
+        EventMachine.add_timer(2) do
+          rabbitmq.stop
+        end
+      end
+    end
+
+    def remove_worker name
+      EventMachine.run do
+        rabbitmq = RunRabbitRun::Rabbitmq::Base.new
+
+        system_messages = RunRabbitRun::Rabbitmq::SystemMessages.new(rabbitmq)
+        system_messages.publish(:system, :master, :remove_worker, { worker: name })
+
+        EventMachine.add_timer(2) do
+          rabbitmq.stop
+        end
+      end
+    end
+
+    def stop
+      RunRabbitRun::Processes::Signals.stop_signal(:master, master_process.pid)
+      Pid.remove
+    end
+
+    def reload
+      RunRabbitRun::Processes::Signals.reload_signal(:master, master_process.pid)
+    end
+  end
+end

data/lib/run_rabbit_run/pid.rb

@@ -0,0 +1,32 @@
+module RunRabbitRun
+  module Pid
+    extend self
+
+    def remove
+      File.delete(path) if File.exists?(path)
+    end
+
+    def pid
+      File.open(path, 'r') { |file| file.read }.to_i if File.exists?(path)
+    end
+
+    def save(pid)
+      create_directory_if_not_exists(File.dirname(path))
+
+      File.open(path, "w") {|file| file.puts(pid) }
+    end
+
+  private 
+
+    def path
+      raise "[ERROR] please specify the pid file path" unless RunRabbitRun.config[:pid]
+
+      RunRabbitRun.config[:pid]
+    end
+
+    def create_directory_if_not_exists(dir)
+      FileUtils.mkdir_p(dir) unless File.exists?(dir)
+    end
+
+  end
+end

data/lib/run_rabbit_run/processes/base.rb

@@ -0,0 +1,82 @@
+require 'run_rabbit_run/callbacks'
+require 'run_rabbit_run/processes/signals'
+
+module RunRabbitRun
+  module Processes
+    class Base
+      include RunRabbitRun::Callbacks
+
+      define_callback :before_exit
+      define_callback :before_reload
+
+      attr_accessor :pid, :name
+
+      def initialize name
+        @name = name
+      end
+
+      def start &block
+        if RunRabbitRun::Processes::Signals.running? @pid
+          raise "The process [#{@name}] is already running"
+        end
+
+        RunRabbitRun.logger.info "[#{@name}] process starting"
+
+        @pid = fork do
+          $0 = "[ruby] [RunRabbitRun] #{@name}"
+
+          signals    = []
+
+          Signal.trap(RunRabbitRun::SIGNAL_EXIT)   { signals << RunRabbitRun::SIGNAL_EXIT   }
+          Signal.trap(RunRabbitRun::SIGNAL_RELOAD) { signals << RunRabbitRun::SIGNAL_RELOAD }
+
+          EventMachine.run do
+
+            instance_exec &block
+
+            EventMachine::add_periodic_timer( 0.5 ) do
+              if signals.include?( RunRabbitRun::SIGNAL_RELOAD )
+                signals.delete( RunRabbitRun::SIGNAL_RELOAD )
+
+                call_callback :before_reload
+              end
+              if signals.include?( RunRabbitRun::SIGNAL_EXIT )
+                @exiting = true
+
+                call_callback :before_exit
+                EventMachine::add_timer( 10 ) do
+                  EventMachine.stop { exit }
+                end
+              end
+            end
+          end
+
+          RunRabbitRun.logger.info "[#{@name}] process finished"
+        end
+
+        Process.detach(@pid)
+
+      end
+
+      def exiting?
+        @exiting ||= false
+      end
+
+      def guid
+        "#{@name}-#{@pid}"
+      end
+
+      def add_timer seconds, &block
+        EventMachine::add_timer( seconds ) do
+          block.call
+        end
+      end
+
+      def add_periodic_timer seconds, &block
+        EventMachine::add_periodic_timer( seconds ) do
+          block.call
+        end
+      end
+    end
+  end
+end

data/lib/run_rabbit_run/processes/master.rb

@@ -0,0 +1,32 @@
+require 'run_rabbit_run/processes/base'
+
+module RunRabbitRun
+
+  module Processes
+    class Master < Base
+
+      define_callback :on_system_message_received
+
+      def initialize name = :master
+        super name
+      end
+
+      def start &block
+        super do
+          instance_exec &block
+
+          rabbitmq = RunRabbitRun::Rabbitmq::Base.new
+          system_messages = RunRabbitRun::Rabbitmq::SystemMessages.new(rabbitmq)
+
+          system_messages.subscribe "master.#" do | headers, payload |
+            call_callback :on_system_message_received, payload["from"].to_sym, payload["message"].to_sym, payload["data"]
+          end
+
+          before_exit do
+            rabbitmq.stop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/run_rabbit_run/processes/signals.rb

@@ -0,0 +1,56 @@
+module RunRabbitRun
+  module Processes
+    module Signals
+      extend self
+
+      def running? pid
+        return false unless pid
+
+        begin
+          Process.getpgid(pid.to_i )
+
+          return true
+        rescue Errno::ESRCH
+        rescue Exception => e
+          RunRabbitRun.logger.error "#{e}, #{e.backtrace.join("\n")}"
+        end
+
+        return false
+      end
+
+      def kill_signal name, pid
+        send_signal name, pid, RunRabbitRun::SIGNAL_KILL
+      end
+
+      def stop_signal name, pid
+        send_signal name, pid, RunRabbitRun::SIGNAL_EXIT
+      end
+
+      def reload_signal name, pid
+        send_signal name, pid, RunRabbitRun::SIGNAL_RELOAD
+      end
+
+    private
+
+      def send_signal name, pid, signal
+        if running? pid
+          RunRabbitRun.logger.info "[#{name}] send #{signal_name(signal)} signal to process"
+          Process.kill(signal, pid)
+        else
+          RunRabbitRun.logger.debug "[#{name}] is not running"
+        end
+      end
+
+      def signal_name code
+        case code
+        when 'QUIT'
+          'exit'
+        when 'USR1'
+          'reload'
+        when 'KILL'
+          'kill'
+        end
+      end
+    end
+  end
+end

data/lib/run_rabbit_run/processes/worker.rb

@@ -0,0 +1,39 @@
+require 'run_rabbit_run/processes/base'
+
+module RunRabbitRun
+  module Processes
+    class Worker < Base
+
+      def initialize name, options
+        @options = options
+
+        super name
+      end
+
+      def start &block
+        super do
+          instance_exec &block if block_given?
+
+          rabbitmq = RunRabbitRun::Rabbitmq::Base.new
+          system_messages = RunRabbitRun::Rabbitmq::SystemMessages.new(rabbitmq)
+
+          system_messages.publish(@name, :master, :process_started, { pid: Process.pid } )
+
+          rabbitmq.on_message_received do | queue |
+            system_messages.publish(@name, :master, :message_received, { queue: queue.name } ) if @options[:log_to_master]
+          end
+          rabbitmq.on_message_processed do | queue |
+            system_messages.publish(@name, :master, :message_processed, { queue: queue.name } ) if @options[:log_to_master]
+          end 
+
+          rabbitmq.instance_eval File.read(@options[:path]), @options[:path]
+
+          before_exit do
+            system_messages.publish(@name, :master, :process_quit)
+            rabbitmq.stop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/run_rabbit_run/rabbitmq/system_messages.rb

@@ -0,0 +1,37 @@
+module RunRabbitRun
+  module Rabbitmq
+    class SystemMessages
+      def initialize(rabbitmq)
+        @rabbitmq = rabbitmq
+      end
+
+      def subscribe routing_key, &block
+        system_queue.bind(system_exchange, routing_key: "profile.#{RunRabbitRun.config[:environment]}.#{routing_key}")
+        system_queue.subscribe do | headers, payload |
+          block.call(headers, JSON.parse(payload))
+        end
+      end
+
+      def publish from, target, message, data = {}
+        system_exchange.publish(
+          JSON.generate({
+            from: from,
+            message: message,
+            data: { time: Time.now.to_f }.merge(data)
+          }),
+          routing_key: "profile.#{RunRabbitRun.config[:environment]}.#{target}")
+      end
+
+    private
+
+      def system_queue
+        @system_queue ||= @rabbitmq.channel.queue("profile.#{RunRabbitRun.config[:environment]}", auto_delete: false)
+      end
+
+      def system_exchange
+        @system_exchange ||= @rabbitmq.channel.topic("runrabbitrun.system", durable: true)
+      end
+
+    end
+  end
+end

data/lib/run_rabbit_run/rabbitmq.rb

@@ -0,0 +1,50 @@
+require 'run_rabbit_run/callbacks'
+
+module RunRabbitRun
+  module Rabbitmq
+    class Base
+      include RunRabbitRun::Callbacks
+      
+      define_callback :on_message_received
+      define_callback :on_message_processed
+
+      def subscribe(queue, options = {}, &block)
+        opts = options.dup
+        time_logging   = opts.delete(:time_logging) || false
+
+        queue.subscribe do | header, payload |
+          RunRabbitRun.logger.info "[#{queue.name}] [#{Time.now.to_f}] started" if time_logging
+          call_callback :on_message_received, queue
+
+          instance_exec(header, JSON.parse(payload), &block)
+
+          call_callback :on_message_processed, queue
+          RunRabbitRun.logger.info "[#{queue.name}] [#{Time.now.to_f}] finished" if time_logging
+        end
+      end
+
+      def publish(queue, data)
+        exchange.publish JSON.generate(data), :routing_key => queue.name
+      end
+
+      def connection
+        @connection ||= AMQP.connect(host: '127.0.0.1', username: "guest", password: "guest")
+      end
+
+      def channel
+        @channel    ||= AMQP::Channel.new(connection, AMQP::Channel.next_channel_id, auto_recovery: true)
+      end
+
+      def exchange
+        @exchange    ||= channel.direct('')
+      end
+
+      def stop
+        connection.close {
+          EventMachine.stop { exit }
+        }
+      end
+
+    end
+  end
+end

data/lib/run_rabbit_run/tasks.rb

@@ -0,0 +1,47 @@
+require "run_rabbit_run"
+
+namespace :rrr do
+  desc 'Starts profile workers'
+  task start: [ :config ] do
+    RunRabbitRun::Master.start
+  end
+
+  desc 'Stops profile workers'
+  task stop: [ :config ] do
+    RunRabbitRun::Master.stop
+  end
+
+  desc 'Reloads config, stops old workers and runs new with new config'
+  task reload: [ :config ] do
+    RunRabbitRun::Master.reload
+  end
+
+  namespace :worker do
+    desc 'Adds one process for given worker'
+    task :add, [ :worker_name ] => [ :config ] do | t, args |
+      raise 'Please specify worker name' unless args[:worker_name]
+      RunRabbitRun::Master.add_worker(args[:worker_name])
+    end
+
+    desc 'Stops one process for given worker'
+    task :remove, [ :worker_name ] => [ :config ] do | t, args |
+      raise 'Please specify worker name' unless args[:worker_name]
+      RunRabbitRun::Master.remove_worker(args[:worker_name])
+    end
+
+    task :new, [ :worker_name, :worker_guid ] => [ :config ] do | t, args |
+      raise 'Please specify worker name' unless args[:worker_name]
+      raise 'Please specify worker guid' unless args[:worker_guid]
+
+      require 'run_rabbit_run/processes/worker'
+
+      options = RunRabbitRun.config[:workers][args[:worker_name].to_sym]
+
+      RunRabbitRun::Processes::Worker.new(args[:worker_guid], options).start
+    end
+  end
+
+  task :config do
+    RunRabbitRun.load_config(Rake.original_dir)
+  end
+end

data/lib/run_rabbit_run/version.rb

@@ -0,0 +1,3 @@
+module RunRabbitRun
+  VERSION = "0.0.3"
+end

data/lib/run_rabbit_run/worker.rb

@@ -0,0 +1,33 @@
+require 'run_rabbit_run/processes/signals'
+
+module RunRabbitRun
+  class Worker
+    attr_accessor :name, :guid, :pid, :status
+    def initialize(name, guid)
+      @name, @guid, @pid = name, guid, nil
+
+      @status = :unknown
+    end
+
+    def run
+      #TODO get path for bundle
+      success = system("RAKE_ENV=#{RunRabbitRun.config[:environment]} bundle exec rake rrr:worker:new[#{@name},#{@guid}]")
+    end
+
+    def kill
+      RunRabbitRun::Processes::Signals.kill_signal(@guid, @pid)
+    end
+
+    def stop
+      RunRabbitRun::Processes::Signals.stop_signal(@guid, @pid)
+    end
+
+    def reload
+      RunRabbitRun::Processes::Signals.reload_signal(@guid, @pid)
+    end
+
+    def running?
+      RunRabbitRun::Processes::Signals.running? @pid
+    end
+  end
+end

data/lib/run_rabbit_run/workers.rb

@@ -0,0 +1,112 @@
+module RunRabbitRun
+  require 'run_rabbit_run/worker'
+
+  class Workers
+    def initialize
+      @workers = {}
+    end
+
+    def worker(guid)
+      @workers.each do | name, workers |
+        workers.each do | current_guid, worker |
+          return worker if current_guid == guid
+        end
+      end
+
+      nil
+    end
+
+    def check
+      @workers.each do | name, workers |
+        workers.each do | guid, worker |
+          worker.run unless worker.running?
+        end
+        diff = RunRabbitRun.config[:workers][name][:processes] - workers.size
+        diff.times{ run_new_worker name } if diff > 0
+      end
+    end
+
+    def add name
+      run_new_worker name
+    end
+
+    def remove name
+      guid = @workers[name.to_sym].keys.sort.first
+      worker = @workers[name.to_sym][guid]
+
+      worker.stop
+
+      sleep 1
+
+      if worker.running?
+        sleep 4
+        worker.kill if worker.running?
+      end
+
+      @workers[name.to_sym].delete(guid)
+    end
+
+    def start
+      RunRabbitRun.config[:run].each do | name |
+        RunRabbitRun.config[:workers][name][:processes].times do | n |
+          run_new_worker name
+        end
+      end
+    end
+
+    def stop
+      # try to stop gracefully 
+      @workers.each { | name, workers | workers.each { | guid, worker | worker.stop } }
+     
+      sleep 1 
+
+      @workers.each do | name, workers |
+        workers.each do | guid, worker | 
+          if worker.running?
+            sleep 4
+            self.kill # kill workers which are still running
+            return
+          end
+        end
+      end
+
+      @workers = {}
+    end
+
+    def kill
+      @workers.each { | name, workers | workers.each { | guid, worker | worker.kill if worker.running? } }
+
+      @workers = {}
+    end
+
+    def reload
+      # reload the config file
+      RunRabbitRun.load_config( RunRabbitRun.config[:application_path] )
+
+      self.stop 
+      self.start
+    end
+
+  private
+
+    def run_new_worker name
+      name   = name.to_sym
+      guid   = generate_guid(name)
+      worker = RunRabbitRun::Worker.new(name, guid)
+
+      @workers[name] ||= {}
+      @workers[name][guid] = worker
+
+      worker.run
+    end
+
+    def generate_guid name
+      last_guid = @workers[name].keys.sort.last if @workers[name]
+
+      index = (last_guid ? last_guid.split('-').last.to_i : 0) + 1
+
+      "#{name}-#{index}"
+    end
+
+  end
+end

data/lib/run_rabbit_run.rb

@@ -0,0 +1,44 @@
+require "run_rabbit_run/version"
+
+require 'amqp'
+require 'bson'
+require 'json'
+require 'logger'
+
+module RunRabbitRun
+  require 'run_rabbit_run/master'
+  require 'run_rabbit_run/config'
+
+  extend self
+
+  SIGNAL_EXIT   = 'QUIT'
+  SIGNAL_RELOAD = 'USR1'
+  SIGNAL_KILL   = 'KILL'
+
+  def load_config application_path
+    @@config = RunRabbitRun::Config.load(application_path)
+  end
+
+  def config
+    @@config
+  end
+
+  def logger
+    @@logger ||= begin
+      path = self.config[:log]
+
+      FileUtils.mkdir_p(File.dirname(path)) unless File.exists?(File.dirname(path))
+
+      logger = Logger.new(path, 10, 1024000)
+
+      if self.config[:environment] == 'development'
+        logger.level = Logger::DEBUG
+      else
+        logger.level = Logger::INFO
+      end
+
+      logger
+    end
+  end
+end
+

data/run_rabbit_run.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+# include gem version
+require 'run_rabbit_run/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Arturs Kreipans"]
+  gem.email         = ["arturs.kreipans@gmail.com"]
+  gem.description   = %q{RunRabbitRun gem lets to run and manage multiple ruby processes for RabbitMQ}
+  gem.summary       = %q{RunRabbitRun gem lets to run and manage multiple ruby processes for RabbitMQ}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "run_rabbit_run"
+  gem.require_paths = ["lib"]
+  gem.version       = RunRabbitRun::VERSION
+
+  gem.add_dependency "rake"
+  gem.add_dependency "bson_ext"
+  gem.add_dependency "amqp"
+
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'pry-remote'
+end

data/spec/dummy/Gemfile

@@ -0,0 +1,3 @@
+gem 'run_rabbit_run', path: '../../'
+gem 'pry'
+gem 'pry-remote'

data/spec/dummy/Rakefile

@@ -0,0 +1,4 @@
+#!/usr/bin/env rake
+require 'rake'
+require "run_rabbit_run/tasks"
+

data/spec/dummy/config/rrr/development.rb

@@ -0,0 +1 @@
+run :worker1, :worker2

data/spec/dummy/config/rrr.rb

@@ -0,0 +1,15 @@
+require 'run_rabbit_run'
+
+#TODO working_directory '/path/to/working/directory'
+
+log "log/run_rabbit_run.log"
+pid "tmp/pids/run_rabbit_run.pid"
+
+worker :worker1, 'workers/worker_name_1.rb', processes: 1
+
+worker :worker2, 'workers/worker_name_2.rb' do
+  name 'Worker name 2'
+  log_to_master true
+
+  processes 1
+end

data/spec/dummy/workers/worker_name_1.rb

@@ -0,0 +1,13 @@
+output = channel.queue('output', auto_delete: false)
+input  = channel.queue('input', auto_delete: false)
+
+publish(output, {some: 'data'})
+
+subscribe(output, time_logging: true) do | header, data |
+  RunRabbitRun.logger.info data.inspect
+  publish(input, {received: 'data'})
+end
+
+subscribe(input) do | header, data |
+  RunRabbitRun.logger.info data.inspect
+end

data/spec/dummy/workers/worker_name_2.rb

@@ -0,0 +1,13 @@
+output = channel.queue('output2', auto_delete: false)
+input  = channel.queue('input2', auto_delete: false)
+
+publish(output, {some: 'data'})
+
+subscribe(output) do | header, data |
+  RunRabbitRun.logger.info data.inspect
+  publish(input, {received: 'data'})
+end
+
+subscribe(input) do | header, data |
+  RunRabbitRun.logger.info data.inspect
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: run_rabbit_run
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Arturs Kreipans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: amqp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RunRabbitRun gem lets to run and manage multiple ruby processes for RabbitMQ
+email:
+- arturs.kreipans@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/run_rabbit_run.rb
+- lib/run_rabbit_run/callbacks.rb
+- lib/run_rabbit_run/config.rb
+- lib/run_rabbit_run/config/worker.rb
+- lib/run_rabbit_run/master.rb
+- lib/run_rabbit_run/pid.rb
+- lib/run_rabbit_run/processes/base.rb
+- lib/run_rabbit_run/processes/master.rb
+- lib/run_rabbit_run/processes/signals.rb
+- lib/run_rabbit_run/processes/worker.rb
+- lib/run_rabbit_run/rabbitmq.rb
+- lib/run_rabbit_run/rabbitmq/system_messages.rb
+- lib/run_rabbit_run/tasks.rb
+- lib/run_rabbit_run/version.rb
+- lib/run_rabbit_run/worker.rb
+- lib/run_rabbit_run/workers.rb
+- run_rabbit_run.gemspec
+- spec/dummy/Gemfile
+- spec/dummy/Rakefile
+- spec/dummy/config/rrr.rb
+- spec/dummy/config/rrr/development.rb
+- spec/dummy/workers/worker_name_1.rb
+- spec/dummy/workers/worker_name_2.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: RunRabbitRun gem lets to run and manage multiple ruby processes for RabbitMQ
+test_files:
+- spec/dummy/Gemfile
+- spec/dummy/Rakefile
+- spec/dummy/config/rrr.rb
+- spec/dummy/config/rrr/development.rb
+- spec/dummy/workers/worker_name_1.rb
+- spec/dummy/workers/worker_name_2.rb