zeusd 0.0.1 → 0.1.0

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+*.log

data/Gemfile

@@ -3,6 +3,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in zeusd.gemspec
 gemspec
 
+gem 'simplecov', :require => false
+
 group :tool do
   gem "guard-rspec"
   gem "pry"

data/Guardfile

@@ -1,7 +1,6 @@
 guard :rspec, :failed_mode => :none do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch(%r{^lib/zeusd/(.+)\.rb$})     { |m| "spec/lib/zeusd/#{m[1]}_spec.rb" }
+  watch(%r{^lib/zeusd/(.+)\.rb$})     { |m| "spec/zeusd/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 end
 

data/README.md

@@ -1,48 +1,52 @@
-# Zeusd
+# Zeusd [![Gem Version](https://badge.fury.io/rb/zeusd.png)](http://badge.fury.io/rb/zeusd) [![Build Status](https://travis-ci.org/veloper/zeusd.png?branch=master)](https://travis-ci.org/veloper/zeusd) [![Code Climate](https://codeclimate.com/github/veloper/zeusd.png)](https://codeclimate.com/github/veloper/zeusd)
 
-Run the Zeud Gem as a daemon
+*Run Zeus as a daemon.*
 
-[![Build Status](https://travis-ci.org/veloper/zeusd.png?branch=master)](https://travis-ci.org/veloper/zeusd) [![Code Climate](https://codeclimate.com/github/veloper/zeusd.png)](https://codeclimate.com/github/veloper/zeusd)
+## Introduction
 
+Zeus**d** lets you work with the [Zeus Gem](https://github.com/burke/zeus) like it's a daemon -- allowing greater control and easier scripting
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'zeusd'
+### Primary Commands
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+```
+$ zeusd start   [--cwd=/path/to/rails/root]
+                [--block | -b]
+                [--verbose | -v]
 
-    $ gem install zeusd
+$ zeusd restart [--cwd=/path/to/rails/root]
+                [--block | -b]
+                [--verbose | -v]
 
-## Usage
+$ zeusd stop    [--cwd=/path/to/rails/root]
+                [--verbose | -v]
+```
 
-### Commands
+### Utility Commands
 
 ```
-zeusd start [--block]
-zeusd stop
-zeusd restart
+$ zeusd tail    [--cwd=/path/to/rails/root]
+                [--follow | -f]
 ```
 
-### Global Flags
-* `--cwd=current/work/directory/of/rails/app` or alias `-d`
-* `--verbose` or `-v`
+## Installation
 
+```
+$ gem install zeusd
+```
 
 ## Contributing
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Write and test your changes
+3. Write passing specs that test your changes
 3. Commit your changes and specs (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
+## Author
+
+[Daniel Doezema](http://dan.doezema.com)
+
 ## License
 
 * Zeusd is released under the New BSD license. http://dan.doezema.com/licenses/new-bsd/

data/Rakefile

@@ -1,7 +1,6 @@
 require "bundler/gem_tasks"
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new('spec')
+RSpec::Core::RakeTask.new(:spec)
 
-# If you want to make this the default task
 task :default => :spec

data/bin/zeusd

@@ -4,37 +4,35 @@ require "zeusd"
 class ZeusdCLI < Thor
   class_option :verbose,  :type => :boolean,  :aliases => :v
   class_option :block,    :type => :boolean,  :aliases => :b
-  class_option :cwd,      :type => :string,   :aliases => :d
-  class_option :log,      :type => :string,   :aliases => :l
+  class_option :cwd,      :type => :string
 
-  desc "start", "."
+  desc "start", "Start the daemon."
   def start
-    daemon.start! :block => options[:block]
+    daemon.start!(:block => options[:block])
   end
 
-  desc "restart", "."
+  desc "restart", "Restart the daemon."
   def restart
-    stop
-    start
+    daemon.restart!(:block => options[:block])
   end
 
-  desc "stop", "."
+  desc "stop", "Stop the daemon."
   def stop
     daemon.stop!
   end
 
-  desc "status", "."
-  def status
-    # Zeusd::Daemon.new(options).stop!
+  desc "tail", "Tail the daemon's log."
+  method_option :follow, :type => :boolean, :aliases => :f
+  def tail
+    cmd = "tail#{options[:follow] ? ' -f' : ''} -n 25 #{daemon.log_file.to_path}"
+    puts "\n\n[Zeusd] exec(#{cmd})\n\n"
+    exec(cmd)
   end
 
   protected
 
   def daemon
-    Zeusd::Daemon.new(
-      :verbose  => options[:verbose],
-      :cwd      => options[:cwd]
-    )
+    Zeusd::Daemon.new(:verbose => options[:verbose], :cwd => options[:cwd])
   end
 
 end

data/lib/zeusd.rb

@@ -1,6 +1,6 @@
 require 'zeusd/version'
 require 'zeusd/process'
-require 'zeusd/state_interpreter'
+require 'zeusd/interpreter'
 require 'zeusd/daemon'
 
 module Zeusd

data/lib/zeusd/daemon.rb

@@ -1,78 +1,113 @@
 require 'thread'
 require 'childprocess'
 require 'pathname'
+require 'hooks'
 
 module Zeusd
   class DaemonException < StandardError; end
 
   class Daemon
-    attr_reader :cwd, :verbose
-    attr_reader :queue
-    attr_reader :state
-    attr_reader :child_process, :reader, :writer
+    include Hooks
+    define_hooks :after_output, :after_start!, :after_stop!, :after_start_process!
 
-    def initialize(options = {})
-      @cwd     = Pathname.new(options.fetch(:cwd, Dir.pwd)).realpath
-      @verbose = options.fetch(:verbose, false)
-      @queue   = Queue.new
-      @state   = StateInterpreter.new
-      on_update(&method(:puts)) if verbose
-    end
+    after_start!  { log(:start) }
+    after_stop!   { log(:stop) }
+    after_output  {|x| log(x, :zeus) }
 
-    def stop!
-      processes = process ? Array([process.descendants, process]).flatten : []
-      if processes.any?
-        Zeusd::Process.kill!(processes.map(&:pid))
-      end
+    after_start_process! :ensure_log_worker
+
+    after_stop! do
       (socket_file.delete rescue nil) if socket_file.exist?
-      if (alive_processes = processes).all?(&:alive?)
-        raise DaemonException, "Unable to KILL processes: " + alive_processes.join(', ')
-      else
-        @process = nil
-        true
-      end
+      @process = nil
+    end
+
+    after_output do |output|
+      interpreter.translate(output)
+      puts(output) if verbose?
+    end
+
+    attr_reader :cwd, :verbose, :log_file, :log_queue, :interpreter, :child_process
+
+    def initialize(options = {})
+      @cwd         = Pathname.new(options.fetch(:cwd, Dir.pwd)).realpath
+      @verbose     = options.fetch(:verbose, false)
+      @interpreter = Interpreter.new
     end
 
     def start!(options = {})
-      @process = Zeusd::Process.find(start_child_process!.pid)
+      @process = Zeusd::Process.find(start_process!.pid)
 
       if options.fetch(:block, false)
-        loop do
-          if loaded?
-            puts state.last_status
-            break
-          end
-          sleep(0.1)
-        end
+        sleep(0.1) until loaded?
       end
 
-      process
+      self
+    ensure
+      run_hook :after_start!
     end
 
-    def process
-      @process ||= Process.all.find do |p|
-        !!p.command[/zeus.*start$/] && p.cwd == cwd
+    def restart!(options = {})
+      stop!.start!(options)
+    end
+
+    def stop!
+      return self unless process
+
+      # Kill Pids and Wait
+      process.kill!(:recursive => true, :wait => true)
+
+      # Check for remaining processes
+      if[process, process.descendants].flatten.select(&:alive?).any?
+        raise DaemonException, "Unable to KILL processes: " + alive_processes.join(', ')
       end
+
+      self
+    ensure
+      run_hook :after_stop!
+    end
+
+    def process
+      @process ||= Process.all.find {|p| !!p.command[/zeus.*start$/] && p.cwd == cwd }
     end
 
     def loaded?
-      process.descendants.all?(&:asleep?)
+      interpreter.complete?
     end
 
-    def on_update(&block)
-      @on_update = block if block_given?
-      @on_update
+
+    def log_file
+      cwd.join('log/zeusd.log')
     end
 
     def socket_file
       cwd.join('.zeus.sock')
     end
 
+    def verbose?
+      !!verbose
+    end
+
     protected
 
-    def start_child_process!
+    def log(entry, type = :zeusd)
+      log_queue << "<#{type.to_s} utc='#{Time.now.utc}'>#{entry}</#{type.to_s}>\n"
+    end
+
+    def log_queue
+      @log_queue ||= Queue.new
+    end
+
+    def ensure_log_worker
+      @log_worker ||= Thread.new do
+        while value = log_queue.shift
+          log_file.open("a+") {|f| f.write(value) }
+        end
+      end
+    end
+
+    def start_process!
       @reader, @writer = IO.pipe
-      @child_process = ChildProcess.build("zeus", "start")
+      @child_process   = ChildProcess.build("zeus", "start")
       @child_process.environment["BUNDLE_GEMFILE"] = cwd.join("Gemfile").to_path
       @child_process.io.stdout = @child_process.io.stderr = @writer
       @child_process.cwd       = cwd.to_path
@@ -80,22 +115,15 @@ module Zeusd
       @child_process.start
       @writer.close
 
-      Thread.new do
-        while (buffer = (reader.readpartial(10000) rescue nil)) do
-          state << buffer
-          queue << buffer
-        end
-      end
+      run_hook :after_start_process!
 
-      if on_update.is_a?(Proc)
-        Thread.new do
-          while output = queue.pop
-            on_update.call(output)
-          end
+      Thread.new do
+        while (buffer = (@reader.readpartial(10000) rescue nil)) do
+          run_hook :after_output, buffer
         end
       end
 
-      sleep(0.1) until state.commands.any?
+      sleep 0.1 until interpreter.commands.any?
 
       @child_process
     end

data/lib/zeusd/{state_interpreter.rb → interpreter.rb}

@@ -1,23 +1,22 @@
-require 'stringio'
 module Zeusd
-  class StateInterpreter
+  class Interpreter
     STATES = %w[ready crashed running connecting waiting]
 
     attr_reader :lines
     attr_reader :state_colors, :commands, :errors
+    attr_reader :last_status
 
     def initialize(*args)
       @state_colors = Hash[STATES.zip([nil]*STATES.length)]
       @commands     = {}
       @errors       = []
       @lines        = []
-      super(*args)
     end
 
-    def <<(input)
-      input.split("\n").map{|x| Line.new(x) }.each do |line|
+    def translate(zeus_output)
+      zeus_output.split("\n").map{|x| Line.new(x) }.each do |line|
         # State Colors
-        if @state_colors.values.any?(&:nil?) && line.legend?
+        if @state_colors.values.any?(&:nil?) && line.state_legend?
           STATES.each do |state|
             state_colors[state] = line.color_of(state)
           end
@@ -32,15 +31,22 @@ module Zeusd
         # Add Line
         @lines << line
       end
+
+      # Garbage Collection
+      if @lines.length > 100
+        @lines = @lines.last(100)
+      end
     end
 
-    def is_complete?
+    def complete?
       return false if errors.any?
-      return true if commands.all? {|command, status| %[crashed running].include?(status)}
+      return true if commands.all? {|command, status| %[crashed ready].include?(status)}
       false
     end
 
-    def last_status
+
+
+    def last_update
       @lines[@lines.rindex(&:update?)..-1].join("\n").to_s
     end
 
@@ -55,12 +61,12 @@ module Zeusd
       end
 
       def command
-        if match = self.match(/^(\e.*?)zeus\s(.*?)(\s|\e)/)
-          { :name => match[2], :color => match[1] }
+        if @match ||= self.match(/^(\e.*?)zeus\s(.*?)(\s|\e)/)
+          { :name => @match[2], :color => @match[1] }
         end
       end
 
-      def legend?
+      def state_legend?
         STATES.all?{|state| !!self[state]}
       end
 

data/lib/zeusd/process.rb

@@ -7,11 +7,15 @@ module Zeusd
       "stat"    => ->(x){x.to_s},
       "command" => ->(x){x.to_s}
     }
-    attr_accessor :attributes
-    attr_accessor :children
+    attr_accessor :attributes, :children
 
-    def initialize(attributes = {})
-      self.attributes = attributes
+    def initialize(attributes_or_pid)
+      if attributes_or_pid.is_a? Hash
+        self.attributes = attributes_or_pid
+      else
+        self.attributes = {"pid" => attributes_or_pid.to_i}
+        reload!
+      end
     end
 
     def self.ps(options = {})
@@ -35,17 +39,10 @@ module Zeusd
       end
     end
 
-    # Note: Non-chinable, AND joined, Proc allowed for value
-    # {"attr" => value}
     def self.where(criteria, options = {})
       all(options).select do |process|
         criteria.all? do |key, value|
-          case value
-          when Array then value.include?(process.send(key))
-          when Proc  then !!value.call(process)
-          else
-            process.send(key) == value
-          end
+          process.send(key) == value
         end
       end
     end
@@ -56,12 +53,24 @@ module Zeusd
       end
     end
 
+    def self.wait(pids = [])
+      pids = Array(pids).map(&:to_s)
+      loop do
+        break if (self.ps.map{|x| x["pid"]} & pids).length.zero?
+        sleep(0.1)
+      end
+    end
+
     def self.kill!(pids, options = {})
-      signal = options.fetch(:signal, "INT")
-      pids   = Array(pids).map(&:to_i).select{|x| x > 0}
-      if pids.any?
-        system("kill -#{signal} #{pids.join(' ')}")
-        $?.success?
+      pids      = Array(pids).map(&:to_i).select{|x| x > 0}
+      processes = pids.map{|pid| self.new(pid)}
+      signal    = options.fetch(:signal, "TERM")
+      wait      = options.fetch(:wait, false)
+      return false if processes.any?(&:dead?)
+
+      if system("kill -#{signal} #{processes.map(&:pid).join(' ')}")
+        self.wait(pids) if wait
+        true
       else
         false
       end
@@ -69,7 +78,7 @@ module Zeusd
 
     def reload!
       self.attributes = self.class.ps(:pid => pid).first || {}
-      @children   = nil
+      @children       = nil
       !attributes.empty?
     end
 
@@ -112,8 +121,14 @@ module Zeusd
     end
 
     def kill!(options = {})
-      self.class.kill!(pid, options)
-      reload!
+      return false if dead?
+      opts = options.dup
+
+      pids = [pid].tap do |x|
+        x.concat(descendants.map(&:pid)) if !!opts.delete(:recursive)
+      end
+
+      self.class.kill!(pids, opts)
     end
 
     def descendants(options = {})
@@ -123,11 +138,7 @@ module Zeusd
     end
 
     def children(options = {})
-      @children = self.class.where("ppid" => pid).tap do |processes|
-        if options.fetch(:recursive, false)
-          processes.each{|p| p.children(options)}
-        end
-      end
+      @children = self.class.where("ppid" => pid)
     end
 
     def attributes=(hash)

data/lib/zeusd/version.rb

@@ -1,3 +1,3 @@
 module Zeusd
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
-require 'bundler/setup'
+require 'simplecov'
+SimpleCov.start
+
 require 'zeusd'
 
 DUMMY_APP_PATH = File.expand_path('../dummy', __FILE__)

data/spec/support/dummy_process.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+Signal.trap('USR1') do
+  sleep (ARGV[1] || 1).to_f
+  exit 0
+end
+
+stop_time = Time.now.to_f + (ARGV[0] || 2).to_f
+
+sleep 0.01 until Time.now.to_i.to_f >= stop_time

data/spec/zeusd/daemon_spec.rb

@@ -3,23 +3,51 @@ require 'spec_helper'
 describe Zeusd::Daemon do
   let(:daemon) { Zeusd::Daemon.new(:cwd => DUMMY_APP_PATH) }
   after(:each) { daemon.stop! }
+
   describe ".start!" do
+    subject { daemon.start!(:verbose => true) }
+    it { should be daemon }
+    it { should_not be_loaded }
 
-    context "blocking" do
+    describe ":block option" do
       subject { daemon.start!(:block => true) }
-      it { should be_a Zeusd::Process }
+      it { should be_loaded }
+    end
+  end
 
-      it "should be a zeus start process" do
-        process = daemon.start!(:block => true)
-        process.command[/zeus.*?start$/].should_not be_nil, "Process Command: " + process.command
-      end
+  describe ".stop!" do
+    subject { daemon.start!.stop! }
+    it { should be daemon }
+    it { should_not be_loaded }
+  end
+
+  describe ".restart!" do
+    subject { daemon }
+    context "when daemon is already running" do
+      before { subject.start!.restart!(:block => true) }
+      it { should be_loaded }
     end
+  end
 
-    context "non-blocking" do
-      subject { daemon.start! }
-      it { should be_a Zeusd::Process }
+  describe ".process" do
+    context "before start" do
+      subject { daemon.process }
+      it { should be_nil }
     end
 
+    context "after start" do
+      subject { daemon.start!.process }
+      it { should be_a Zeusd::Process}
+      it { should be_alive }
+      its "a zeus start process" do
+        subject.command.should match(/zeus.*?start$/)
+      end
+    end
+
+    context "after start and stop" do
+      subject { daemon.start!.stop!.process }
+      it { should be_nil }
+    end
   end
 
 end

data/spec/zeusd/process_spec.rb

@@ -1,16 +1,83 @@
 require 'spec_helper'
+require 'benchmark'
 require 'zeusd'
 
 describe Zeusd::Process do
 
-  def spawn_dummy_process(ttl_seconds = 1)
-    spawn("while [ $(date +\"%s\") -le #{Time.now.to_i + ttl_seconds} ]; do continue; done")
+  def spawn_dummy_process(ttl = 1, usr1delay = 0.5, options = {})
+    ttl       = ttl.to_f.to_s
+    usr1delay = usr1delay.to_f.to_s
+    script    = File.expand_path("../../support/dummy_process.rb", __FILE__)
+    p         = ChildProcess.build(script, ttl, usr1delay)
+    p.cwd     = options[:cwd] if options[:cwd]
+    p.detach  = true
+    p.start
+    p
   end
 
+  before(:each) do
+    @dummy_ttl       = 1
+    @dummy_usr1delay = 0.5
+    @dummy_process   = spawn_dummy_process(@dummy_ttl, @dummy_usr1delay)
+  end
   subject(:model) { Zeusd::Process }
 
-  describe "process management class methods" do
-    before(:each) { @dummy_pid = spawn_dummy_process }
+
+  describe "process instance" do
+    subject { model.find(@dummy_process.pid) }
+    it { should be_a Zeusd::Process }
+    it { should be_alive }
+    it { should_not be_dead }
+  end
+
+  describe "instance methods" do
+    subject { model.find(@dummy_process.pid) }
+
+    describe ".cwd" do
+      it "return the current working directory" do
+        subject.cwd.to_path == Dir.pwd
+      end
+    end
+
+    describe ".kill!" do
+      context "when process exists" do
+        it "kills the process and returns true" do
+          subject.kill!(:wait => true).should be_true
+          subject.should be_dead
+        end
+      end
+
+      context "when processes does not exists" do
+        it "returns false" do
+          subject.kill!(:wait => true).should be_true
+          subject.kill!.should be_false
+        end
+      end
+    end
+  end
+
+
+  describe "class methods" do
+
+    describe "::kill!" do
+      it "kills a process in under 0.1 seconds" do
+        model.kill!(@dummy_process.pid)
+        sleep 0.1
+        model.find(@dummy_process.pid).should be_nil
+      end
+
+      it "blocks until the process exits" do
+        Benchmark.realtime do
+          model.kill!(@dummy_process.pid, :signal => "USR1", :wait => true).should be_true
+        end.should be < 1.0
+      end
+    end
+
+    describe "::wait" do
+      it "blocks until the process exits" do
+        Benchmark.realtime { model.wait(@dummy_process.pid) }.should be > 1
+      end
+    end
 
     describe "::ps" do
       subject { model.ps }
@@ -19,7 +86,7 @@ describe Zeusd::Process do
         subject.all?{|x| x.is_a?(Hash)}.should be_true
       end
       it "includes the dummy process" do
-        subject.map{|x|x["pid"]}.should include(@dummy_pid.to_s)
+        subject.map{|x|x["pid"]}.should include(@dummy_process.pid.to_s)
       end
       it "allows additional -o keywords" do
         model.ps(:keywords => "user").first.should include("user")
@@ -60,7 +127,7 @@ describe Zeusd::Process do
           it { should have_at_least(2).items }
         end
         context "criteria not met" do
-          subject {model.where(:pid => @dummy_pid, :pgid => 9999999999999)}
+          subject {model.where(:pid => @dummy_process.pid, :pgid => 9999999999999)}
           it { should be_an Array }
           it { should be_empty }
         end
@@ -68,14 +135,14 @@ describe Zeusd::Process do
     end
 
     describe "::find" do
-      subject { model.find(@dummy_pid) }
+      subject { model.find(@dummy_process.pid) }
       context "existing process" do
         it { should be_a Zeusd::Process }
         it { should be_alive }
-        it { subject.pid.should eq(@dummy_pid) }
+        it { subject.pid.should eq(@dummy_process.pid) }
       end
       context "non-existant process" do
-        before(:each) { ::Process.kill("KILL", @dummy_pid); ::Process.waitpid(@dummy_pid) }
+        before(:each) { @dummy_process.stop }
         it { should be_nil }
       end
     end

data/zeusd.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "thor"
   spec.add_runtime_dependency "childprocess"
+  spec.add_runtime_dependency "hooks"
   spec.add_runtime_dependency "zeus"
 
   spec.add_development_dependency "bundler", "~> 1.3"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeusd
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-07 00:00:00.000000000 Z
+date: 2014-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -43,6 +43,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: hooks
+  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: zeus
   requirement: !ruby/object:Gem::Requirement
@@ -126,8 +142,8 @@ files:
 - bin/zeusd
 - lib/zeusd.rb
 - lib/zeusd/daemon.rb
+- lib/zeusd/interpreter.rb
 - lib/zeusd/process.rb
-- lib/zeusd/state_interpreter.rb
 - lib/zeusd/version.rb
 - spec/dummy/.gitignore
 - spec/dummy/Gemfile
@@ -180,6 +196,7 @@ files:
 - spec/dummy/vendor/plugins/.gitkeep
 - spec/dummy/zeus.json
 - spec/spec_helper.rb
+- spec/support/dummy_process.rb
 - spec/zeusd/daemon_spec.rb
 - spec/zeusd/process_spec.rb
 - zeusd.gemspec
@@ -198,7 +215,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2296072518175803333
+      hash: -3204481942119935445
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -207,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2296072518175803333
+      hash: -3204481942119935445
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -266,5 +283,6 @@ test_files:
 - spec/dummy/vendor/plugins/.gitkeep
 - spec/dummy/zeus.json
 - spec/spec_helper.rb
+- spec/support/dummy_process.rb
 - spec/zeusd/daemon_spec.rb
 - spec/zeusd/process_spec.rb