process_handler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2530d6f931ed0ff1a7f617c7e04fdbf4be28a4ee
+  data.tar.gz: fb6d3c7f5e79fb988df866084dfc0ea116ca4c6c
+SHA512:
+  metadata.gz: 1781ed0ee1cf6fa992a64c1a0cb4bf49a4ed002346b8b705df2de9013ce0c8390c16249af2ed4e5da07f01030bc75060760caeaff32d9b8d1657086dd84e2c4a
+  data.tar.gz: 40e9b2d747eadfe6f423ca37667c802e79a441eecb7bbc7ffe5c06abc6d2dbdeb01cc6bd2e60d6e2333fa5625d6d8536a47a1633e83ce1d0ab512b0151035b3a

data/.ruby-gemset

@@ -0,0 +1 @@
+process_handler

data/.ruby-version

@@ -0,0 +1 @@
+2.1

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'rufus-scheduler'
+gem 'logasm'
+
+group :test do
+  gem 'rspec', '~> 3.1'
+  gem 'pry'
+end
+
+# Specify your gem's dependencies in process_handler.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    process_handler (0.1.0)
+      airbrake
+      sucker_punch (~> 1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    airbrake (4.1.0)
+      builder
+      multi_json
+    builder (3.2.2)
+    celluloid (0.15.2)
+      timers (~> 1.1.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    inflecto (0.0.2)
+    logasm (0.1.0)
+      inflecto
+      logstash-event (~> 1.2)
+    logstash-event (1.2.02)
+    method_source (0.8.2)
+    multi_json (1.10.1)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.3.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.5)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.2)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.1)
+    rufus-scheduler (3.0.9)
+      tzinfo
+    slop (3.4.7)
+    sucker_punch (1.2.1)
+      celluloid (~> 0.15.2)
+    thread_safe (0.3.4)
+    timers (1.1.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  logasm
+  process_handler!
+  pry
+  rake
+  rspec (~> 3.1)
+  rufus-scheduler

data/README.md

@@ -0,0 +1,66 @@
+# ProcessHandler
+
+[![Code Climate](https://codeclimate.com/github/salemove/process_handler/badges/gpa.svg)](https://codeclimate.com/github/salemove/process_handler)
+
+ProcessHandler helps to spawn and manage services. There are multiple types of processes. Every process knows how to handle `SIGINT` and `SIGTERM` signals.
+
+## PivotProcess
+This process is used for services that need one or more threads and use the request-response model [Freddy](https://github.com/salemove/freddy).
+
+Example of using pivot process:
+```ruby
+  service = MyService.new
+  freddy = Freddy.new
+
+  process = Salemove::ProcessHandler::PivotProcess.new(freddy)
+  process.spawn(service)
+```
+
+### Service
+If you want to use pivot process, then the given service must implement `call` method that takes `input` as an argument.
+
+Example of a service:
+```ruby
+  class Echo
+    def call(input)
+      result = # do something with input
+      {success: true, output: result} # return result
+    end
+  end
+end
+```
+
+## CronProcess
+This process allows a service to run recurringly either at times specified by a [cron expression](http://en.wikipedia.org/wiki/Cron#CRON_expression) or at a fixed time interval: "1" for seconds, "2h" for hours and "2d" for days.
+
+Example of using cron process with cron expressions:
+```ruby
+  service = MyService.new
+
+  # every five minutes between 7:00 and 7:55 on Mon to Fri
+  process = Salemove::ProcessHandler::CronProcess.new('0/5 7  * * 1-5')
+  process.spawn(service)
+```
+
+Example of using cron process with interval expressions:
+```ruby
+  service = MyService.new
+
+  # every second hour
+  process = Salemove::ProcessHandler::CronProcess.new('2h')
+  process.spawn(service)
+```
+
+## Service
+If you want to use a cron process, then you only must implement `call` method that does not take any arguments.
+
+Example of a service:
+```ruby
+  class MemWatcher
+    def call
+      result = `sysctl -a | grep 'hw.usermem'`
+
+      # e.g write this result to a file
+    end
+  end
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task ci: :spec
+task default: :spec

data/config.reek

@@ -0,0 +1,3 @@
+---
+  IrresponsibleModule:
+    enabled: false

data/lib/salemove/process_handler.rb

@@ -0,0 +1,6 @@
+module Salemove
+  module ProcessHandler
+  end
+end
+
+require_relative 'process_handler/version'

data/lib/salemove/process_handler/composite_process.rb

@@ -0,0 +1,54 @@
+require_relative 'process_monitor'
+
+module Salemove
+  module ProcessHandler
+
+    def self.start_composite(&block)
+      CompositeProcess.new(&block).start
+    end
+
+    class CompositeProcess
+      
+      def initialize(&block)
+        @process_spawners = []
+        @monitor = CompositeProcessMonitor.new
+        instance_eval &block if block_given?
+      end
+
+      def add(process, service)
+        @monitor.add process.process_monitor
+        @process_spawners << Proc.new { process.spawn service, blocking: false }
+      end
+
+      def start
+        @process_spawners.each(&:call)
+        @monitor.start
+        block
+      end
+
+      def block
+        sleep 1 while @monitor.running?
+      end
+
+    end
+
+    class CompositeProcessMonitor < ProcessMonitor
+
+      def initialize
+        @monitors = []
+      end
+
+      def add(monitor)
+        @monitors << monitor
+      end
+
+      def stop
+        @monitors.each(&:stop)
+        sleep 1 while @monitors.any?(&:alive?)
+        super
+      end
+
+    end
+
+  end
+end

data/lib/salemove/process_handler/cron_process.rb

@@ -0,0 +1,71 @@
+require 'rufus-scheduler'
+require_relative 'cron_process_monitor'
+require_relative 'notifier_factory'
+
+module Salemove
+  module ProcessHandler
+
+    class CronScheduler < Rufus::Scheduler
+
+      def initialize(exception_notifier, options)
+        super options
+        @exception_notifier = exception_notifier
+      end
+
+      def on_error(job, error)
+        if @exception_notifier
+          @exception_notifier.notify_or_ignore(error, cgi_data: ENV.to_hash)
+        end
+        super
+      end
+
+    end
+
+    class CronProcess
+
+      attr_reader :process_monitor
+
+      def initialize(env: 'development',
+                     notifier: nil,
+                     notifier_factory: NotifierFactory,
+                     scheduler_options: {})
+        @schedules = []
+        @exception_notifier = notifier_factory.get_notifier(env, notifier)
+        @scheduler = CronScheduler.new @exception_notifier, scheduler_options
+        @process_monitor = CronProcessMonitor.new(self)
+      end
+
+      # @param [String] expression
+      #   can either be a any cron expression like every five minutes: '5 * * * *'
+      #   or interval like '1' for seconds, '2h' for hours and '2d' for days
+      def schedule(expression, params={}, overlap=false)
+        @schedules << { expression: expression, params: params, overlap: overlap }
+      end
+
+      def spawn(service, blocking: true)
+        @process_monitor.start
+        @schedules.each do |schedule|
+          spawn_schedule(service, schedule)
+        end
+        @scheduler.join if blocking
+      end
+
+      def spawn_schedule(service, expression:, params:, overlap:)
+        if params.empty?
+          @scheduler.repeat expression, {overlap: overlap} { service.call }
+        else
+          @scheduler.repeat expression, {overlap: overlap} { service.call(params) }
+        end
+      end
+
+      def stop
+        #Separate thread to avoid Ruby 2.0+ trap context 'synchronize' exception
+        Thread.new do
+          @scheduler.shutdown(:wait)
+          @process_monitor.shutdown
+        end
+      end
+
+    end
+  end
+end

data/lib/salemove/process_handler/cron_process_monitor.rb

@@ -0,0 +1,18 @@
+require_relative 'process_monitor'
+
+module Salemove
+  module ProcessHandler
+    class CronProcessMonitor < ProcessMonitor
+
+      def initialize(process)
+        @process = process
+      end
+
+      def stop
+        super
+        @process.stop
+      end
+
+    end
+  end
+end

data/lib/salemove/process_handler/notifier_factory.rb

@@ -0,0 +1,21 @@
+require 'airbrake'
+
+module Salemove
+  module ProcessHandler
+    class NotifierFactory
+
+      def self.get_notifier(env, conf)
+        if conf && conf[:type] == 'airbrake'
+          Airbrake.configure do |airbrake|
+            airbrake.async = true
+            airbrake.environment_name = env
+            airbrake.host = conf.fetch(:host)
+            airbrake.api_key = conf.fetch(:api_key)
+          end
+          Airbrake
+        end
+      end     
+
+    end
+  end
+end

data/lib/salemove/process_handler/pivot_process.rb

@@ -0,0 +1,108 @@
+require 'logger'
+require 'benchmark'
+require_relative 'process_monitor'
+require_relative 'notifier_factory'
+
+module Salemove
+  module ProcessHandler
+    class PivotProcess
+
+      attr_reader :process_monitor, :exception_notifier
+
+      def self.logger
+        @logger ||= Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+      end
+
+      def self.logger=(logger)
+        @logger = logger
+      end
+
+      def initialize(messenger,
+                     env: 'development',
+                     notifier: nil,
+                     notifier_factory: NotifierFactory,
+                     process_monitor: ProcessMonitor.new)
+        @messenger = messenger
+        @process_monitor = process_monitor
+        @exception_notifier = notifier_factory.get_notifier(env, notifier)
+      end
+
+      def spawn(service, blocking: true)
+        @process_monitor.start
+
+        @service_thread = ServiceSpawner.spawn(service, @messenger, @exception_notifier)
+        blocking ? wait_for_monitor : Thread.new { wait_for_monitor }
+      end
+
+      private
+
+      def wait_for_monitor
+        sleep 1 while @process_monitor.running?
+        @service_thread.shutdown
+        @service_thread.join
+        @process_monitor.shutdown
+      end
+
+      class ServiceSpawner
+        def self.spawn(service, messenger, exception_notifier)
+          new(service, messenger, exception_notifier).spawn
+        end
+
+        def initialize(service, messenger, exception_notifier)
+          @service = service
+          @messenger = messenger
+          @exception_notifier = exception_notifier
+        end
+
+        def spawn
+          @messenger.respond_to(@service.class::QUEUE) do |input, handler|
+            response = handle_request(input)
+
+            if response.is_a?(Hash) && (response[:success] == false || response[:error])
+              handler.error(response)
+            else
+              handler.success(response)
+            end
+          end
+        end
+
+        def handle_request(input)
+          if input.has_key?(:ping)
+            { success: true, pong: 'pong' }
+          else
+            delegate_to_service(input)
+          end
+        rescue => exception
+          handle_exception(exception, input)
+        end
+
+        def delegate_to_service(input)
+          result = benchmark(input) { @service.call(input) }
+          PivotProcess.logger.info "Result: #{result.inspect}"
+          result
+        end
+
+        def handle_exception(e, input)
+          PivotProcess.logger.error(e.inspect + "\n" + e.backtrace.join("\n"))
+          if @exception_notifier
+            @exception_notifier.notify_or_ignore(e, cgi_data: ENV.to_hash, parameters: input)
+          end
+          { success: false, error: e.message }
+        end
+
+        def benchmark(input, &block)
+          type = input[:type] if input.is_a?(Hash)
+          result = nil
+
+          bm = Benchmark.measure { result = block.call }
+          if defined?(Logasm) && PivotProcess.logger.is_a?(Logasm)
+            PivotProcess.logger.debug "Execution time",
+              type: type, real: bm.real, user: bm.utime, system: bm.stime
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/salemove/process_handler/process_monitor.rb

@@ -0,0 +1,68 @@
+module Salemove
+  module ProcessHandler
+    class ProcessMonitor
+      def start
+        init_signal_handlers
+        @state = :running
+      end
+
+      def stop
+        @state = :stopping if alive?
+      end
+
+      def shutdown
+        @state = :stopped
+      end
+
+      def running?
+        @state == :running
+      end
+
+      def alive?
+        @state != :stopped
+      end
+
+      private
+
+      def init_signal_handlers
+        init_hup_signal
+        init_quit_signal
+        init_int_signal
+        init_term_signal
+      end
+
+      # Many daemons will reload their configuration files and reopen their
+      # logfiles instead of exiting when receiving this signal.
+      def init_hup_signal
+        trap :HUP do
+          puts 'SIGHUP: not implemented'
+        end
+      end
+
+      # Interrupts a process. (The default action is to terminate gracefully).
+      def init_int_signal
+        trap :INT do
+          puts 'Exiting process gracefully!'
+          stop
+        end
+      end
+
+      # Terminates a process immediately.
+      def init_term_signal
+        trap :TERM do
+          exit
+        end
+      end
+
+      # Terminates a process. This is different from both SIGKILL and SIGTERM
+      # in the sense that it generates a core dump of the process and also
+      # cleans up resources held up by a process. Like SIGINT, this can also
+      # be sent from the terminal as input characters.
+      def init_quit_signal
+        trap :QUIT do
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/salemove/process_handler/version.rb

@@ -0,0 +1,5 @@
+module Salemove
+  module ProcessHandler
+    VERSION = '0.1.0'
+  end
+end

data/process_handler.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'salemove/process_handler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'process_handler'
+  spec.version       = Salemove::ProcessHandler::VERSION
+  spec.authors       = ['Indrek Juhkam']
+  spec.email         = ['indrek@salemove.com']
+  spec.description   = %q{This gem helps to monitor and manage processes}
+  spec.summary       = %q{}
+  spec.homepage      = ''
+  spec.license       = 'Private'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'airbrake'
+  spec.add_dependency 'sucker_punch', '~> 1.1' # for async airbrake notifications
+end

data/spec/fixtures/composite_service.rb

@@ -0,0 +1,44 @@
+require 'salemove/process_handler'
+require 'salemove/process_handler/composite_process'
+require 'salemove/process_handler/cron_process'
+require 'salemove/process_handler/pivot_process'
+
+module Salemove
+
+  class EchoResultService
+    QUEUE = 'Dummy'
+
+    def call(params={})
+      puts "RESULT"
+    end
+  end
+
+  class Messenger
+    def respond_to(*)
+      ResponderHandler.new
+    end
+  end
+
+  class ResponderHandler
+    
+    def shutdown
+    end
+    
+    def join
+    end
+    
+  end
+
+  cron_process = ProcessHandler::CronProcess.new
+  cron_process.schedule('0.5')
+  cron_process.schedule('5', some: 'params')
+
+  ProcessHandler::PivotProcess.logger = Logger.new('/dev/null')
+  pivot_process = ProcessHandler::PivotProcess.new(Messenger.new)
+
+  ProcessHandler.start_composite do
+    add cron_process, EchoResultService.new
+    add pivot_process, EchoResultService.new
+  end
+
+end

data/spec/fixtures/cron_service.rb

@@ -0,0 +1,15 @@
+require 'salemove/process_handler/cron_process'
+
+module Salemove
+
+  class EchoResultService
+    def call
+      puts "RESULT"
+    end
+  end
+
+  cron_process = ProcessHandler::CronProcess.new
+  cron_process.schedule('0.5')
+  cron_process.spawn(EchoResultService.new, blocking: true)
+
+end

data/spec/process_handler/composite_process_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'salemove/process_handler/composite_process'
+
+describe ProcessHandler::CompositeProcess do
+
+  it 'can be gracefully stopped' do
+    result = run_and_signal_fixture(fixture: 'composite_service.rb', signal: 'INT', sleep_period: 1)
+    expect(result).to eq("RESULT\nExiting process gracefully!\n")
+  end
+
+  it 'can be terminated' do
+    result = run_and_signal_fixture(fixture: 'composite_service.rb', signal: 'TERM', sleep_period: 1)
+    expect(result).to eq("RESULT\n")
+  end
+
+end

data/spec/process_handler/cron_process_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'salemove/process_handler/cron_process'
+
+describe ProcessHandler::CronProcess do
+
+  class AppenderService
+
+    def initialize(messages, queue)
+      @messages = messages
+      @queue = queue
+    end
+
+    def call(name)
+      @messages << name
+      @queue << nil # unblock main thread
+      sleep 0.4 # simulate expense
+    end
+
+  end
+
+  class ExceptionService
+
+    def initialize(queue)
+      @queue = queue
+    end
+
+    def call
+      raise "A Runtimino Exceptino"
+    ensure
+      @queue << nil # unblock main thread
+    end
+  end
+
+  it 'can be gracefully stopped' do
+    result = run_and_signal_fixture(fixture: 'cron_service.rb', signal: 'INT', sleep_period: 1)
+    expect(result).to eq("RESULT\nExiting process gracefully!\n")
+  end
+
+  it 'can be terminated' do
+    result = run_and_signal_fixture(fixture: 'cron_service.rb', signal: 'TERM', sleep_period: 1)
+    expect(result).to eq("RESULT\n")
+  end
+
+  describe 'scheduler' do
+    let(:process) { ProcessHandler::CronProcess.new(scheduler_options: {frequency: 0.1}) }
+    let(:messages) { [] }
+    let(:queue) { Queue.new }
+
+    it 'does not trigger 2 jobs at once' do
+      process.schedule('0.1', 'first')
+      process.schedule('0.4', 'second')
+      Thread.new do
+        process.spawn(AppenderService.new(messages, queue))
+      end
+       # block main thread until 3 schedules have run
+      (1..3).map { queue.pop }
+      expect(messages).to eq(['first', 'second', 'first'])
+    end
+
+  end
+
+  describe 'exception handler' do
+    let(:process) { ProcessHandler::CronProcess.new(params) }
+    let(:params) {{ env: 'test', notifier_factory: notifier_factory,
+      scheduler_options: {frequency: 0.1} }}
+    let(:notifier_factory) { double('NotifierFactory') }
+    let(:exception_notifier) { double('Airbrake') }
+    let(:queue) { Queue.new }
+
+    before(:each) do
+      allow(notifier_factory).to receive(:get_notifier) { exception_notifier }
+    end
+
+    it 'notifies of exception' do
+      process.schedule('0.2')
+      expect(exception_notifier).to receive(:notify_or_ignore)
+      Thread.new do
+        process.spawn(ExceptionService.new(queue))
+      end
+      queue.pop
+      sleep 0.1
+    end
+
+  end
+
+end

data/spec/process_handler/pivot_process_spec.rb

@@ -0,0 +1,137 @@
+require 'logasm'
+require 'spec_helper'
+require 'salemove/process_handler/pivot_process'
+
+class ResultService
+  QUEUE = 'Dummy'
+end
+
+describe ProcessHandler::PivotProcess do
+  let(:monitor)   { double('Monitor') }
+  let(:messenger) { double('Messenger') }
+  let(:handler)   { double('Handler') }
+  let(:thread)    { double('Thread') }
+
+  subject { process.spawn(service) }
+  let(:service) { ResultService.new }
+
+  let(:process) { ProcessHandler::PivotProcess.new(messenger, process_params) }
+  let(:process_params) {{ process_monitor: monitor , notifier_factory: notifier_factory, env: 'test' }}
+  let(:notifier_factory) { double('NotifierFactory') }
+  let(:responder) { double(shutdown: true, join: true) }
+
+  let(:input) {{}}
+  let(:result) { {success: true, result: 'RESULT'} }
+
+  let(:logger) { Logasm.new([]) }
+
+  def expect_monitor_to_behave
+    expect(monitor).to receive(:start)
+    expect(monitor).to receive(:running?) { false }
+    expect(monitor).to receive(:shutdown)
+  end
+
+  def expect_message
+    expect(messenger).to receive(:respond_to) {|destination, &callback|
+      callback.call(input, handler)
+    }.and_return(responder)
+  end
+
+  def expect_handler_thread_to_behave
+    allow(handler).to receive(:success) { thread }
+    allow(handler).to receive(:error) { thread }
+    expect(responder).to receive(:shutdown)
+    expect(responder).to receive(:join)
+  end
+
+  before do
+    ProcessHandler::PivotProcess.logger = logger
+    allow(notifier_factory).to receive(:get_notifier) { nil }
+    expect_monitor_to_behave
+    expect_message
+    expect_handler_thread_to_behave
+    allow(service).to receive(:call).with(input) { result }
+  end
+
+  describe 'when service responds correctly' do
+
+    it 'can be executed with logger' do
+      expect(handler).to receive(:success).with(result)
+      expect(service).to receive(:call).with(input)
+      subject()
+    end
+
+  end
+
+  describe 'when service responds with an error' do
+    let(:result) { { success: false, error: 'hey' } }
+
+    before do
+      expect(service).to receive(:call).with(input) { result }
+    end
+
+    it 'acks the message properly' do
+      expect(handler).to receive(:error).with(result)
+      subject()
+    end
+  end
+
+  shared_examples 'an error_handler' do
+
+    it 'logs error' do
+      expect(logger).to receive(:error)
+      subject()
+    end
+
+    describe 'with exception_notifier' do
+
+      let(:exception_notifier) { double('Airbrake') }
+
+      before do
+        allow(notifier_factory).to receive(:get_notifier) { exception_notifier }
+      end
+
+      it 'triggers exception_notifier' do
+        expect(exception_notifier).to receive(:notify_or_ignore)
+        subject()
+      end
+    end
+
+  end
+
+  describe 'when service raises exception' do
+
+    let(:result) { { success: false, error: exception } }
+    let(:exception) { "what an unexpected exception!" }
+
+    before do
+      expect(service).to receive(:call).with(input) { raise exception }
+    end
+
+    it 'acks the message properly' do
+      expect(handler).to receive(:error).with(result)
+      subject()
+    end
+
+    it_behaves_like 'an error_handler'
+
+  end
+
+  describe 'when exception raises after service call' do
+
+    let(:result) { { success: false, output: exception } }
+    let(:exception) { "no no no ... no inspect for you!" }
+
+    before do
+      expect(result).to receive(:inspect) { raise exception }
+    end
+
+    it 'still acks the message properly' do
+      subject()
+    end
+
+    it_behaves_like 'an error_handler'
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'pry' # for debugging
+require 'rspec'
+require 'salemove/process_handler'
+
+include Salemove
+
+RSpec.configure do |rspec_config|
+  rspec_config.filter_run focus: true
+  rspec_config.run_all_when_everything_filtered = true
+
+  def fixture_path(name)
+    File.join(File.dirname(__FILE__), "fixtures", name)
+  end
+
+  def run_and_signal_fixture(fixture:, signal:, sleep_period:)
+    output_read, output_write = IO.pipe
+
+    pid = Process.spawn('ruby ' + fixture_path(fixture), out: output_write)
+    sleep sleep_period
+    Process.kill(signal, pid)
+    Process.wait2(pid)
+    output_write.close
+
+    output_read.read
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: process_handler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Indrek Juhkam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: airbrake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sucker_punch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: This gem helps to monitor and manage processes
+email:
+- indrek@salemove.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- config.reek
+- lib/salemove/process_handler.rb
+- lib/salemove/process_handler/composite_process.rb
+- lib/salemove/process_handler/cron_process.rb
+- lib/salemove/process_handler/cron_process_monitor.rb
+- lib/salemove/process_handler/notifier_factory.rb
+- lib/salemove/process_handler/pivot_process.rb
+- lib/salemove/process_handler/process_monitor.rb
+- lib/salemove/process_handler/version.rb
+- process_handler.gemspec
+- spec/fixtures/composite_service.rb
+- spec/fixtures/cron_service.rb
+- spec/process_handler/composite_process_spec.rb
+- spec/process_handler/cron_process_spec.rb
+- spec/process_handler/pivot_process_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- Private
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- spec/fixtures/composite_service.rb
+- spec/fixtures/cron_service.rb
+- spec/process_handler/composite_process_spec.rb
+- spec/process_handler/cron_process_spec.rb
+- spec/process_handler/pivot_process_spec.rb
+- spec/spec_helper.rb