sys-proctree 0.0.1

data/lib/sys/proctree/process.rb

@@ -0,0 +1,21 @@
+module Sys
+  module ProcTree
+
+    module Process
+
+      def kill_tree(signal, pid)
+        pids = ::Sys::ProcTree::Tree.find(pid)
+        pids.collect do |pid|
+          begin
+            ::Process.kill(signal, pid)
+            ::Process.wait(pid)
+          rescue
+            [pid, nil]
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/sys/proctree/process_status_list.rb

@@ -0,0 +1,17 @@
+module Sys
+  module ProcTree
+
+    class ProcessStatusList < Array
+
+      def initialize
+        super(::Sys::ProcTable.ps)
+      end
+
+      def exists?(pid)
+        !!find { |proc| proc.pid == pid }
+      end
+
+    end
+
+  end
+end

data/lib/sys/proctree/tree.rb

@@ -0,0 +1,38 @@
+module Sys
+  module ProcTree
+
+    class Tree
+
+      class << self
+
+        def find(pid)
+          ::Sys::ProcTree::Tree.new(pid).pids
+        end
+
+      end
+
+      def initialize(pid)
+        @pid = pid
+      end
+
+      def pids
+        process_status_list.exists?(@pid) ? with_children([@pid]) : []
+      end
+
+      private
+
+      def with_children(pids)
+        child_pids = process_status_list.map do |proc|
+          pids.include?(proc.ppid) ? proc.pid : nil
+        end.compact
+        child_pids.empty? ? pids : with_children(child_pids) + pids
+      end
+
+      def process_status_list
+        @process_status_list ||= ::Sys::ProcTree::ProcessStatusList.new
+      end
+
+    end
+
+  end
+end

data/lib/sys/proctree/version.rb

@@ -0,0 +1,5 @@
+module Sys
+  module ProcTree
+    VERSION = "0.0.1"
+  end
+end

data/lib/sys/proctree.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default)
+
+require_relative "proctree/process_status_list"
+require_relative "proctree/tree"
+require_relative "proctree/process"
+
+::Process.extend(::Sys::ProcTree::Process)
+
+module Sys
+
+  module ProcTree
+
+    def self.find(pid)
+      ::Sys::ProcTree::Tree.find(pid)
+    end
+
+  end
+
+end

data/spec/lib/sys/proctree/process_spec.rb

@@ -0,0 +1,69 @@
+describe ::Sys::ProcTree::Process do
+
+  class TestableProcess
+    extend Sys::ProcTree::Process
+  end
+
+  describe "#kill_tree" do
+
+    let(:kill_signal) { 7 }
+    let(:tree_pids) { [2, 6, 8] }
+
+    before(:each) do
+      ::Sys::ProcTree::Tree.stub!(:find).and_return([2, 6, 8])
+      ::Process.stub!(:kill)
+      ::Process.stub!(:wait)
+    end
+
+    it "should discover the pids of the process tree" do
+      ::Sys::ProcTree::Tree.should_receive(:find).with(8).and_return(tree_pids)
+
+      TestableProcess.kill_tree(kill_signal, 8)
+    end
+
+    it "should attempt to kill each process with the provided kill signal in tree order" do
+      tree_pids.each { |pid| ::Process.should_receive(:kill).with(kill_signal, pid) }
+
+      TestableProcess.kill_tree(kill_signal, 8)
+    end
+
+
+    it "should wait for all processes to complete" do
+      tree_pids.each { |pid| ::Process.should_receive(:wait).with(pid) }
+
+      TestableProcess.kill_tree(kill_signal, 8)
+    end
+
+    it "should return the exit status of all killed processes" do
+      wait_results = tree_pids.map do |pid|
+        [pid, double(Process::Status)].tap { |result| ::Process.stub!(:wait).with(pid).and_return(result) }
+      end
+
+      TestableProcess.kill_tree(kill_signal, 8).should eql(wait_results)
+    end
+
+    describe "when a process has already been killed" do
+
+      let(:kill_signal) { 9 }
+
+      before(:each) { ::Process.stub!(:kill).with(kill_signal, 6).and_raise("No such process") }
+
+      it "should continue to kill subsequent processes" do
+        [2, 8].each { |pid| ::Process.should_receive(:kill).with(kill_signal, pid) }
+
+        TestableProcess.kill_tree(kill_signal, 8)
+      end
+
+      it "should return an exit status of nil" do
+        wait_results = [[2, double(Process::Status)], [6, nil], [8, double(Process::Status)]]
+        ::Process.stub!(:wait).with(2).and_return(wait_results[0])
+        ::Process.stub!(:wait).with(8).and_return(wait_results[2])
+
+        TestableProcess.kill_tree(kill_signal, 8).should eql(wait_results)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/sys/proctree/process_status_list_spec.rb

@@ -0,0 +1,47 @@
+describe ::Sys::ProcTree::ProcessStatusList do
+
+  before(:each) { ::Sys::ProcTable.stub!(:ps).and_return(proc_list) }
+
+  let(:proc_list) do
+    [double("ProcTableStruct", pid: 1, ppid: 2),
+     double("ProcTableStruct", pid: 2, ppid: 3),
+     double("ProcTableStruct", pid: 3, ppid: nil)]
+  end
+
+  let(:list) { ::Sys::ProcTree::ProcessStatusList.new }
+
+  it "should be an array" do
+    list.should be_an(Array)
+  end
+
+  it "should contain proc table process status results" do
+    ::Sys::ProcTable.should_receive(:ps).and_return(proc_list)
+
+    list.should eql(proc_list)
+  end
+
+  describe "exists?" do
+
+    describe "when the process exists" do
+
+      let(:pid) { 2 }
+
+      it "should return true" do
+        list.exists?(pid).should be_true
+      end
+
+    end
+
+    describe "when the process does not exist" do
+
+      let(:pid) { -1 }
+
+      it "should return false" do
+        list.exists?(pid).should be_false
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/sys/proctree/tree_spec.rb

@@ -0,0 +1,68 @@
+describe ::Sys::ProcTree::Tree do
+
+  let(:tree) { ::Sys::ProcTree::Tree }
+
+  describe "#find" do
+
+    before(:each) do
+      ::Sys::ProcTree::ProcessStatusList.should_receive(:new).and_return(process_status_list)
+    end
+
+    let(:process_status_list) do
+      create_proc_table_entries([{ pid: 2, ppid: 1 },
+                                 { pid: 1, ppid: nil },
+                                 { pid: 3, ppid: 2 },
+                                 { pid: 4, ppid: nil },
+                                 { pid: 5, ppid: 6 },
+                                 { pid: 6, ppid: nil },
+                                 { pid: 7, ppid: 6 },
+                                 { pid: 8, ppid: 6 }])
+    end
+
+    describe "when the provided process exists" do
+
+      before(:each) { process_status_list.stub!(:exists?).with(pid).and_return(true) }
+
+      describe "when the tree is more than one level deep" do
+
+        describe "with one process on each level" do
+
+          let(:pid) { 1 }
+
+          it "should return an array representing the tree in order from child first to parent last" do
+            tree.find(pid).should eql([3, 2, 1])
+          end
+
+        end
+
+        describe "with multiple processes on a level" do
+
+          let(:pid) { 6 }
+
+          it "should return an array containing processes order from child to parent, then as they appear in the underlying process table" do
+            tree.find(pid).should eql([5, 7, 8, 6])
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "when the provided process does not exist" do
+
+      before(:each) { process_status_list.stub!(:exists?).and_return(false) }
+
+      it "should return an empty array" do
+        tree.find(0).should be_empty
+      end
+
+    end
+
+    def create_proc_table_entries(options_array)
+      options_array.map { |options| double("ProcTableStruct", options) }
+    end
+
+  end
+
+end

data/spec/lib/sys/proctree_spec.rb

@@ -0,0 +1,13 @@
+describe ::Sys::ProcTree do
+
+  describe "#find" do
+
+    it "should find a tree via a Sys::ProcTree::Tree" do
+      ::Sys::ProcTree::Tree.should_receive(:find).with(7).and_return([1, 3, 7])
+
+      ::Sys::ProcTree.find(7).should eql([1, 3, 7])
+    end
+
+  end
+
+end

data/spec/process_integration_spec.rb

@@ -0,0 +1,64 @@
+describe ::Process, "integrating with real processes" do
+
+  RESOURCE_DIR = File.expand_path("../resources", __FILE__)
+
+  FIVE_SECONDS = 5
+
+  describe "#kill_tree" do
+
+    describe "when one process is running" do
+
+      let(:pid) { ::Process.spawn("irb") }
+
+      it "should kill the process" do
+        ::Process.kill_tree(9, pid)
+
+        wait_until_killed([pid])
+      end
+
+    end
+
+    describe "when multiple processes are running" do
+
+      let(:ppid) { start_multiple_processes }
+
+      before(:each) do
+        wait_until_true("process tree has started") { ::Sys::ProcTree::Tree.find(ppid).length == 3 }
+      end
+
+      it "should kill all processes in the tree" do
+        tree_pids = ::Sys::ProcTree::Tree.find(ppid)
+
+        ::Process.kill_tree(9, ppid)
+
+        wait_until_killed(tree_pids)
+      end
+
+    end
+
+  end
+
+  def start_multiple_processes
+    ::Process.spawn("#{RESOURCE_DIR}/start_parent.#{::OS.windows? ? "bat" : "sh"}")
+  end
+
+  def wait_until_killed(pids)
+    wait_until_true("processes #{pids.join(", ")} have been killed") do
+      process_statuses = ::Sys::ProcTree::ProcessStatusList.new
+      pids.reduce(true) { |all_killed_flag, pid| all_killed_flag && !process_statuses.exists?(pid) }
+    end
+  end
+
+  def wait_until_true(description, &block)
+    start_time = Time.now
+    while true
+      begin
+        return if block.call
+      rescue
+        # Intentionally blank
+      end
+      raise "Timed-out waiting until '#{description}'" if Time.now - start_time > FIVE_SECONDS
+    end
+  end
+
+end

data/spec/process_spec.rb

@@ -0,0 +1,7 @@
+describe ::Process do
+
+  it "should have the capability to kill a process tree" do
+    ::Process.should be_a(::Sys::ProcTree::Process)
+  end
+
+end

data/spec/resources/start_child.bat

@@ -0,0 +1,3 @@
+@echo off
+
+start /b irb.exe

data/spec/resources/start_child.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+irb

data/spec/resources/start_parent.bat

@@ -0,0 +1,3 @@
+@echo off
+
+start /b %CD%/start_child.bat

data/spec/resources/start_parent.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+BASEDIR=$(dirname $0)
+$BASEDIR/start_child.sh

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'cover_me'
+
+require_relative "../lib/sys/proctree"
+Bundler.require(:test)
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |file| require file }

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: sys-proctree
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matthew Ueckerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+description: Discovers and kills process trees via process lists provided by the sys-proctable
+  gem
+email: matthew.ueckerman@myob.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./lib/sys/proctree/process.rb
+- ./lib/sys/proctree/process_status_list.rb
+- ./lib/sys/proctree/tree.rb
+- ./lib/sys/proctree/version.rb
+- ./lib/sys/proctree.rb
+- ./spec/lib/sys/proctree/process_spec.rb
+- ./spec/lib/sys/proctree/process_status_list_spec.rb
+- ./spec/lib/sys/proctree/tree_spec.rb
+- ./spec/lib/sys/proctree_spec.rb
+- ./spec/process_integration_spec.rb
+- ./spec/process_spec.rb
+- ./spec/resources/start_child.bat
+- ./spec/resources/start_child.sh
+- ./spec/resources/start_parent.bat
+- ./spec/resources/start_parent.sh
+- ./spec/spec_helper.rb
+homepage: http://github.com/MYOB-Technology/sys-proctree
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: sys-proctree
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Discovers and can attempt to lay waste to a process tree
+test_files:
+- ./spec/lib/sys/proctree/process_spec.rb
+- ./spec/lib/sys/proctree/process_status_list_spec.rb
+- ./spec/lib/sys/proctree/tree_spec.rb
+- ./spec/lib/sys/proctree_spec.rb
+- ./spec/process_integration_spec.rb
+- ./spec/process_spec.rb
+- ./spec/resources/start_child.bat
+- ./spec/resources/start_child.sh
+- ./spec/resources/start_parent.bat
+- ./spec/resources/start_parent.sh
+- ./spec/spec_helper.rb