zeus 0.3.1 → 0.4.0

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+

data/Gemfile

@@ -3,4 +3,6 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in zeus.gemspec
 gemspec
 
+gem 'rspec'
+gem 'rake'
 gem 'pry'

data/README.md

@@ -1,8 +1,8 @@
-# Zeus
+# Zeus [![Build Status](https://secure.travis-ci.org/burke/zeus.png?branch=master)](http://travis-ci.org/burke/zeus) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/burke/zeus)
 
 ## What is Zeus?
 
-Zeus preloads your app so that your normal development tasks such as `console`, `server`, `generate`, and tests take **less than one second**.
+Zeus preloads your app so that your normal development tasks such as `console`, `server`, `generate`, and specs/tests take **less than one second**.
 
 This screencast gives a quick overview of how to use zeus:
 
@@ -17,7 +17,7 @@ Pretty specific:
 * Rails 3.0+ (Support for other versions is not difficult and is planned.)
 * Backported GC from Ruby 2.0.
 
-You can install the GC-patched ruby from [this gist](https://gist.github.com/1688857) or from RVM.
+You can install the GC-patched ruby from [this gist](https://gist.github.com/1688857) or from RVM.  This is not actually 100% necessary, especially if you have a lot of memory. Feel free to give it a shot first without, but if you're suddenly out of RAM, switching to the GC-patched ruby will fix it.
 
 ## Installation
 
@@ -39,7 +39,8 @@ Run some commands:
 
     zeus console
     zeus server
-    zeus testrb -Itest -I. test/unit/omg_test.rb
+    zeus testrb test/unit/widget_test.rb
+    zeus rspec spec/widget_spec.rb
     zeus generate model omg
     zeus rake -T
     zeus runner omg.rb

data/Rakefile

@@ -1,2 +1,7 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+
+require 'rspec'
+task :default do
+  RSpec::Core::Runner.run(Dir.glob("spec/**/*_spec.rb"))
+end

data/lib/zeus/client.rb

@@ -9,7 +9,7 @@ module Zeus
     attr_accessor :pid
 
     SIGNALS = {
-      "\x03" => "TERM",
+      "\x03" => "INT",
       "\x1C" => "QUIT"
     }
     SIGNAL_REGEX = Regexp.union(SIGNALS.keys)

data/lib/zeus/dsl.rb

@@ -1,18 +1,83 @@
+require 'set'
+
 module Zeus
   module DSL
 
     class Evaluator
       def stage(name, &b)
         stage = DSL::Stage.new(name)
+        stage.root = true
         stage.instance_eval(&b)
+        stage
+      end
+    end
+
+    class Node
+      attr_reader :name, :stages, :features
+      attr_accessor :pid, :root
+
+      def initialize(name)
+        @name     = name
+        @stages   = []
+        @features = Set.new # hash might be faster than ruby's inane impl of set.
+      end
+
+      def stage_has_feature(name, file)
+        node_for_name(name).features << file
+      end
+
+      def stage_has_pid(name, pid)
+        node_for_name(name).pid = pid
       end
+
+      def kill_nodes_with_feature(file)
+        if features.include?(file)
+          if root
+            Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
+          else
+            kill!
+          end
+        else
+          stages.each do |child|
+            child.kill_nodes_with_feature(file)
+          end
+        end
+      end
+
+      private
+
+      # We send STOP before actually killing the processes here.
+      # This is to prevent parents from respawning before all the children
+      # are killed. This prevents a race condition.
+      def kill!
+        Process.kill("STOP", pid) if pid
+        # Protected methods don't work with each(&:m) notation.
+        stages.each { |stage| stage.kill! }
+        old_pid  = pid
+        self.pid = nil
+        Process.kill("KILL", old_pid) if old_pid
+      end ; protected :kill!
+
+      def node_for_name(name)
+        @nodes_by_name ||= __nodes_by_name
+        @nodes_by_name[name]
+      end
+
+      def __nodes_by_name
+        nodes = {name => self}
+        stages.each do |child|
+          nodes.merge!(child.__nodes_by_name)
+        end
+        nodes
+      end ; protected :__nodes_by_name
+
     end
 
-    class Acceptor
+    class Acceptor < Node
 
       attr_reader :name, :aliases, :description, :action
       def initialize(name, aliases, description, &b)
-        @name = name
+        super(name)
         @description = description
         @aliases = aliases
         @action = b
@@ -29,7 +94,7 @@ module Zeus
         self
       end
 
-      def to_domain_object(server)
+      def to_process_object(server)
         Zeus::Server::Acceptor.new(server).tap do |stage|
           stage.name = @name
           stage.aliases = @aliases
@@ -40,12 +105,12 @@ module Zeus
 
     end
 
-    class Stage
+    class Stage < Node
 
-      attr_reader :pid, :stages, :actions
+      attr_reader :actions
       def initialize(name)
-        @name = name
-        @stages, @actions = [], []
+        super(name)
+        @actions = []
       end
 
       def action(&b)
@@ -75,10 +140,10 @@ module Zeus
         stages.map(&:acceptors).flatten
       end
 
-      def to_domain_object(server)
+      def to_process_object(server)
         Zeus::Server::Stage.new(server).tap do |stage|
           stage.name = @name
-          stage.stages = @stages.map { |stage| stage.to_domain_object(server) }
+          stage.stages = @stages.map { |stage| stage.to_process_object(server) }
           stage.actions = @actions
         end
       end

data/lib/zeus/server.rb

@@ -9,7 +9,7 @@ module Zeus
     autoload :Stage,                       'zeus/server/stage'
     autoload :Acceptor,                    'zeus/server/acceptor'
     autoload :FileMonitor,                 'zeus/server/file_monitor'
-    autoload :ProcessTree,                 'zeus/server/process_tree'
+    autoload :LoadTracking,                'zeus/server/load_tracking'
     autoload :ForkedProcess,               'zeus/server/forked_process'
     autoload :ClientHandler,               'zeus/server/client_handler'
     autoload :ProcessTreeMonitor,          'zeus/server/process_tree_monitor'
@@ -26,11 +26,10 @@ module Zeus
     def initialize
       @file_monitor                  = FileMonitor::FSEvent.new(&method(:dependency_did_change))
       @acceptor_registration_monitor = AcceptorRegistrationMonitor.new
-      @process_tree_monitor          = ProcessTreeMonitor.new(@file_monitor)
-      acceptor_commands = self.class.acceptors.map(&:commands).flatten
+      @process_tree_monitor          = ProcessTreeMonitor.new(@file_monitor, @@definition)
       @client_handler                = ClientHandler.new(acceptor_commands, self)
 
-      @plan = @@definition.to_domain_object(self)
+      @plan = @@definition.to_process_object(self)
     end
 
     def dependency_did_change(file)
@@ -43,22 +42,32 @@ module Zeus
 
     def run
       $0 = "zeus master"
-      trap("INT") { exit 0 }
+      trap("TERM") { exit 0 }
+      trap("INT") {
+        puts "\n\x1b[31mExiting\x1b[0m"
+        exit 0
+      }
+
+      LoadTracking.inject!(self)
 
       @plan.run(true) # boot the actual app
       monitors.each(&:close_child_socket)
 
-      loop do
-        ready, = IO.select(monitors.map(&:datasource), [], [], 1)
-        next unless ready
-        monitors.each do |m|
-          m.on_datasource_event if ready.include?(m.datasource)
-        end
-      end
+      runloop!
     ensure
       File.unlink(Zeus::SOCKET_NAME)
     end
 
+    # this is used in conjunction with Zeus::LoadTracking to track files loaded
+    # using `load` rather than `require`.
+    def add_extra_feature(full_expanded_path)
+      @extra_loaded_features ||= []
+      @extra_loaded_features << full_expanded_path
+    end
+
+    def extra_features
+      @extra_loaded_features || []
+    end
 
     # Child process API
     def __CHILD__close_parent_sockets
@@ -70,8 +79,24 @@ module Zeus
       :__CHILD__find_acceptor_for_command
 
     def_delegators :@process_tree_monitor,
-      :__CHILD__pid_has_ppid,
-      :__CHILD__pid_has_feature
+      :__CHILD__stage_starting_with_pid,
+      :__CHILD__stage_has_feature
+
+    private
+
+    def acceptor_commands
+      self.class.acceptors.map(&:commands).flatten
+    end
+
+    def runloop!
+      loop do
+        ready, = IO.select(monitors.map(&:datasource), [], [], 1)
+        next unless ready
+        monitors.each do |m|
+          m.on_datasource_event if ready.include?(m.datasource)
+        end
+      end
+    end
 
   end
 end

data/lib/zeus/server/acceptor.rb

@@ -28,6 +28,7 @@ module Zeus
 
       def __RUNNER__run(terminal, arguments)
         $0 = "zeus runner: #{@name}"
+        Process.setsid
         postfork_action!
         @s_acceptor << $$ << "\n"
         $stdin.reopen(terminal)
@@ -37,11 +38,14 @@ module Zeus
 
         @action.call
       ensure
+        # TODO this is a whole lot of voodoo that I don't really understand.
+        # I need to figure out how best to make the process disconenct cleanly.
         dnw, dnr = File.open("/dev/null", "w+"), File.open("/dev/null", "r+")
-        $stdin.reopen(dnw)
-        $stdout.reopen(dnr)
         $stderr.reopen(dnr)
+        $stdout.reopen(dnr)
         terminal.close
+        $stdin.reopen(dnw)
+        Process.kill(9, $$)
         exit 0
       end
 

data/lib/zeus/server/forked_process.rb

@@ -1,5 +1,6 @@
 module Zeus
   class Server
+    # base class for Stage and Acceptor
     class ForkedProcess
       HasNoChildren = Class.new(Exception)
 
@@ -10,7 +11,7 @@ module Zeus
       end
 
       def notify_feature(feature)
-        @server.__CHILD__pid_has_feature(Process.pid, feature)
+        @server.__CHILD__stage_has_feature(@name, feature)
       end
 
       def descendent_acceptors
@@ -21,27 +22,41 @@ module Zeus
         raise "NotImplementedError"
       end
 
+      def notify_started
+        @server.__CHILD__stage_starting_with_pid(@name, Process.pid)
+        Zeus.ui.info("starting #{process_type} `#{@name}`")
+      end
+
+      def notify_terminated
+        # @server.__CHILD__stage_terminating(@name)
+        Zeus.ui.info("killing #{process_type} `#{@name}`")
+      end
+
       def setup_forked_process(close_parent_sockets)
         @server.__CHILD__close_parent_sockets if close_parent_sockets
-        @server.__CHILD__pid_has_ppid(Process.pid, Process.ppid)
+
+        notify_started
 
         $0 = "zeus #{process_type}: #{@name}"
 
-        Zeus.ui.info("starting #{process_type} `#{@name}`")
-        trap("INT") {
-          Zeus.ui.info("killing #{process_type} `#{@name}`")
-          exit 0
+        trap("INT") { exit }
+        trap("TERM") {
+          notify_terminating
+          exit
         }
 
-        new_features = $LOADED_FEATURES - previously_loaded_features
-        $previously_loaded_features = $LOADED_FEATURES.dup
+        defined?(ActiveRecord::Base) and ActiveRecord::Base.clear_all_connections!
+
+        new_features = newly_loaded_features()
+        $previously_loaded_features = new_features
         Thread.new {
           new_features.each { |f| notify_feature(f) }
         }
       end
 
-      def previously_loaded_features
-        defined?($previously_loaded_features) ? $previously_loaded_features : []
+      def newly_loaded_features
+        old_features = defined?($previously_loaded_features) ? $previously_loaded_features : []
+        ($LOADED_FEATURES + @server.extra_features) - old_features
       end
 
       def kill_pid_on_exit(pid)

data/lib/zeus/server/load_tracking.rb

@@ -0,0 +1,43 @@
+module Zeus
+  class Server
+    class LoadTracking
+
+      def self.inject!(server)
+        mod = module_for_server(server)
+        Object.class_eval { include mod }
+      end
+
+      def self.module_for_server(server)
+        Module.new.tap do |load_tracking|
+          load_tracking.send(:define_method, :load) { |file, *a|
+            if ret = super(file, *a)
+              LoadTracking.add_feature(server, file)
+            end
+            ret
+          }
+        end
+      end
+
+      def self.add_feature(server, file)
+        if absolute_path?(file)
+          server.add_extra_feature(file)
+        elsif File.exist?("./#{file}")
+          server.add_extra_feature(File.expand_path("./#{file}"))
+        else
+          path = find_in_load_path(file)
+          server.add_extra_feature(path) if path
+        end
+      end
+
+      def self.find_in_load_path(file)
+        path = $LOAD_PATH.detect { |path| File.exist?("#{path}/#{file}") }
+        "#{path}/#{file}" if path
+      end
+
+      def self.absolute_path?(file)
+        file =~ /^\// && File.exist?(file)
+      end
+
+    end
+  end
+end

data/lib/zeus/server/process_tree_monitor.rb

@@ -1,41 +1,44 @@
 module Zeus
   class Server
     class ProcessTreeMonitor
-      PID_TYPE = "P"
-      FEATURE_TYPE = "F"
+      STARTING_MARKER = "P"
+      FEATURE_MARKER  = "F"
 
       def datasource          ; @sock ; end
       def on_datasource_event ; handle_messages ; end
       def close_child_socket  ; @__CHILD__sock.close ; end
       def close_parent_socket ; @sock.close ; end
 
-      def initialize(file_monitor, tree=ProcessTree.new)
-        @tree = tree
+      def initialize(file_monitor, tree)
+        @root = tree
         @file_monitor = file_monitor
 
         @sock, @__CHILD__sock = open_socketpair
       end
 
       def kill_nodes_with_feature(file)
-        @tree.kill_nodes_with_feature(file)
+        @root.kill_nodes_with_feature(file)
       end
 
       module ChildProcessApi
-        def __CHILD__pid_has_ppid(pid, ppid)
-          @__CHILD__sock.send("#{PID_TYPE}:#{pid}:#{ppid}", 0)
-        rescue Errno::ENOBUFS
-          sleep 0.2
-          retry
+        def __CHILD__stage_starting_with_pid(name, pid)
+          buffer_send("#{STARTING_MARKER}#{name}:#{pid}")
+        end
+
+        def __CHILD__stage_has_feature(name, feature)
+          buffer_send("#{FEATURE_MARKER}#{name}:#{feature}")
         end
 
-        def __CHILD__pid_has_feature(pid, feature)
-          @__CHILD__sock.send("#{FEATURE_TYPE}:#{pid}:#{feature}", 0)
+        private
+
+        def buffer_send(msg)
+          @__CHILD__sock.send(msg, 0)
         rescue Errno::ENOBUFS
           sleep 0.2
           retry
         end
-      end ; include ChildProcessApi
 
+      end ; include ChildProcessApi
 
       private
 
@@ -47,10 +50,10 @@ module Zeus
       def handle_message
         data = @sock.recv_nonblock(4096)
         case data[0]
-        when FEATURE_TYPE
+        when STARTING_MARKER
+          handle_starting_message(data[1..-1])
+        when FEATURE_MARKER
           handle_feature_message(data[1..-1])
-        when PID_TYPE
-          handle_pid_message(data[1..-1])
         end
       end
 
@@ -58,20 +61,19 @@ module Zeus
         Socket.pair(:UNIX, :DGRAM)
       end
 
-      def handle_pid_message(data)
-        data =~ /(\d+):(\d+)/
-          pid, ppid = $1.to_i, $2.to_i
-        @tree.process_has_parent(pid, ppid)
+      def handle_starting_message(data)
+        data =~ /(.+):(\d+)/
+        name, pid = $1.to_sym, $2.to_i
+        @root.stage_has_pid(name, pid)
       end
 
       def handle_feature_message(data)
-        data =~ /(\d+):(.*)/
-          pid, file = $1.to_i, $2
-        @tree.process_has_feature(pid, file)
+        data =~ /(.+?):(.*)/
+        name, file = $1.to_sym, $2
+        @root.stage_has_feature(name, file)
         @file_monitor.watch(file)
       end
 
-
     end
   end
 end

data/lib/zeus/templates/rails.rb

@@ -1,10 +1,11 @@
 require 'socket'
 
+ROOT_PATH = File.expand_path(Dir.pwd)
+
 Zeus::Server.define! do
   stage :boot do
 
     action do
-      ROOT_PATH = File.expand_path(Dir.pwd)
       ENV_PATH  = File.expand_path('config/environment',  ROOT_PATH)
       BOOT_PATH = File.expand_path('config/boot',  ROOT_PATH)
       APP_PATH  = File.expand_path('config/application',  ROOT_PATH)
@@ -25,6 +26,11 @@ Zeus::Server.define! do
         end
 
         command :generate, :g do
+          begin
+            require 'rails/generators'
+            Rails.application.load_generators
+          rescue LoadError # Rails 3.0 doesn't require this block to be run, but 3.2+ does
+          end
           require 'rails/commands/generate'
         end
 
@@ -67,19 +73,39 @@ Zeus::Server.define! do
           $rails_rake_task = 'yup' # lie to skip eager loading
           Rails.application.require_environment!
           $rails_rake_task = nil
-
-          test = File.join(ROOT_PATH, 'test')
-          $LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
           $LOAD_PATH.unshift(ROOT_PATH) unless $LOAD_PATH.include?(ROOT_PATH)
+
+          if Dir.exist?(ROOT_PATH + "/test")
+            test = File.join(ROOT_PATH, 'test')
+            $LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
+          end
+
+          if Dir.exist?(ROOT_PATH + "/spec")
+            spec = File.join(ROOT_PATH, 'spec')
+            $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
+          end
+
+        end
+
+        if Dir.exist?(ROOT_PATH + "/test")
+          stage :test_helper do
+            action { require 'test_helper' }
+
+            command :testrb do
+              (r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
+                abort r.options.banner + " tests..."
+              exit r.run
+            end
+          end
         end
 
-        stage :test_helper do
-          action { require 'test_helper' }
+        if Dir.exist?(ROOT_PATH + "/spec")
+          stage :spec_helper do
+            action { require 'spec_helper' }
 
-          command :testrb do
-            (r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
-              abort r.options.banner + " tests..."
-            exit r.run
+            command :rspec do
+              exit RSpec::Core::Runner.run(ARGV)
+            end
           end
         end
 

data/lib/zeus/version.rb

@@ -1,3 +1,3 @@
 module Zeus
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/spec/server/process_tree_monitor_spec.rb

@@ -28,17 +28,17 @@ class Zeus::Server
 
     it "passes process inheritance information to the tree" do
       IO.select([monitor.datasource], [], [], 0).should be_nil
-      monitor.__CHILD__pid_has_ppid(1, 2)
+      monitor.__CHILD__stage_starting_with_pid(:name, 1)
       IO.select([monitor.datasource], [], [], 0.5).should_not be_nil
-      tree.should_receive(:process_has_parent).with(1, 2)
+      tree.should_receive(:stage_has_pid).with(:name, 1)
       monitor.on_datasource_event
     end
 
     it "passes process feature information to the tree" do
       IO.select([monitor.datasource], [], [], 0).should be_nil
-      monitor.__CHILD__pid_has_feature(1, "rails")
+      monitor.__CHILD__stage_has_feature(:name, "rails")
       IO.select([monitor.datasource], [], [], 0.5).should_not be_nil
-      tree.should_receive(:process_has_feature).with(1, "rails")
+      tree.should_receive(:stage_has_feature).with(:name, "rails")
       file_monitor.should_receive(:watch).with("rails")
       monitor.on_datasource_event
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-08 00:00:00.000000000 Z
+date: 2012-08-09 00:00:00.000000000 Z
 dependencies: []
 description: Boot any rails app in under a second
 email:
@@ -20,6 +20,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - .zeus.rb
 - Gemfile
 - LICENSE
@@ -40,7 +41,7 @@ files:
 - lib/zeus/server/file_monitor.rb
 - lib/zeus/server/file_monitor/fsevent.rb
 - lib/zeus/server/forked_process.rb
-- lib/zeus/server/process_tree.rb
+- lib/zeus/server/load_tracking.rb
 - lib/zeus/server/process_tree_monitor.rb
 - lib/zeus/server/stage.rb
 - lib/zeus/templates/rails.rb
@@ -49,7 +50,6 @@ files:
 - spec/cli_spec.rb
 - spec/server/file_monitor/fsevent_spec.rb
 - spec/server/process_tree_monitor_spec.rb
-- spec/server/process_tree_spec.rb
 - spec/ui_spec.rb
 - zeus.gemspec
 homepage: http://github.com/burke/zeus
@@ -81,6 +81,5 @@ test_files:
 - spec/cli_spec.rb
 - spec/server/file_monitor/fsevent_spec.rb
 - spec/server/process_tree_monitor_spec.rb
-- spec/server/process_tree_spec.rb
 - spec/ui_spec.rb
 has_rdoc: 

data/lib/zeus/server/process_tree.rb

@@ -1,76 +0,0 @@
-module Zeus
-  class Server
-    class ProcessTree
-
-      def initialize
-        @root = Node.new(Process.pid)
-        @nodes_by_pid = {Process.pid => @root}
-      end
-
-      def process_has_parent(pid, ppid)
-        curr = node_for_pid(pid)
-        base = node_for_pid(ppid)
-        base.add_child(curr)
-      end
-
-      def process_has_feature(pid, feature)
-        node = node_for_pid(pid)
-        node.add_feature(feature)
-      end
-
-      def kill_nodes_with_feature(file, base = @root)
-        if base.has_feature?(file)
-          kill_node(base)
-        else
-          base.children.dup.each do |node|
-            if kill_nodes_with_feature(file, node)
-              base.children.delete(node)
-            end
-          end
-          return false
-        end
-      end
-
-      private
-
-      def node_for_pid(pid)
-        @nodes_by_pid[pid.to_i] ||= Node.new(pid.to_i)
-      end
-
-      def kill_node(node)
-        if node == @root.children[0] || node == @root
-          Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
-          return false
-        end
-        @nodes_by_pid.delete(node.pid)
-        node.kill
-      end
-
-      class Node
-        attr_accessor :pid, :children, :features
-        def initialize(pid)
-          @pid, @children, @features = pid, [], {}
-        end
-
-        def kill
-          # recall that this process explicitly traps INT -> exit 0
-          Process.kill("INT", pid)
-        end
-
-        def add_child(node)
-          self.children << node
-        end
-
-        def add_feature(feature)
-          self.features[feature] = true
-        end
-
-        def has_feature?(feature)
-          self.features[feature] == true
-        end
-
-      end
-
-    end
-  end
-end

data/spec/server/process_tree_spec.rb

@@ -1,65 +0,0 @@
-require 'zeus'
-
-class Zeus::Server
-
-  describe ProcessTree do
-
-    ROOT_PID = Process.pid
-    CHILD_1 = ROOT_PID + 1
-    CHILD_2 = ROOT_PID + 2
-    GRANDCHILD_1 = ROOT_PID + 3
-    GRANDCHILD_2 = ROOT_PID + 4
-
-    let(:process_tree) { ProcessTree.new }
-
-    before do
-      build_tree
-      add_features
-    end
-
-    it "doesn't kill the root node" do
-      Zeus.ui.should_receive(:error).with(/not killing zeus/i)
-      Process.should_not_receive(:kill)
-      process_tree.kill_nodes_with_feature("zeus")
-    end
-
-    it "kills a node that has a feature" do
-      expect_kill(CHILD_2)
-      process_tree.kill_nodes_with_feature("rails")
-    end
-
-    it "kills multiple nodes at the same level with a feature" do
-      expect_kill(GRANDCHILD_1)
-      expect_kill(GRANDCHILD_2)
-      process_tree.kill_nodes_with_feature("model")
-    end
-
-    private
-
-    def expect_kill(pid)
-      Process.should_receive(:kill).with("INT", pid)
-    end
-
-    def build_tree
-      process_tree.process_has_parent(CHILD_1, ROOT_PID)
-      process_tree.process_has_parent(CHILD_2, CHILD_1)
-      process_tree.process_has_parent(GRANDCHILD_1, CHILD_2)
-      process_tree.process_has_parent(GRANDCHILD_2, CHILD_2)
-    end
-
-    def add_features
-      [CHILD_2, GRANDCHILD_1, GRANDCHILD_2].each do |pid|
-        process_tree.process_has_feature(pid, "rails")
-      end
-
-      process_tree.process_has_feature(GRANDCHILD_1, "model")
-      process_tree.process_has_feature(GRANDCHILD_2, "model")
-
-      [ROOT_PID, CHILD_1, CHILD_2, GRANDCHILD_1, GRANDCHILD_2].each do |pid|
-        process_tree.process_has_feature(pid, "zeus")
-      end
-    end
-
-  end
-
-end