mssh 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b1dc5731928a0e6c9bbefb194d034f4156c2ec7
-  data.tar.gz: 008cbed76335b038760840f85167bcb9ef2c2829
+  metadata.gz: ff5ab53b19325189d26958ba44305d99d38a6a58
+  data.tar.gz: 957c71e1f478c67882899721be1b210ade946c87
 SHA512:
-  metadata.gz: df5592d1342941ff5988bd047a96d82679c49b53a51340ccbf042f0e13c53a3a3dfd254105ca2f54f37407107cfdaca57c7b483c5d61d0055663c64d14c519ba
-  data.tar.gz: b4174d36c61d8ff535525d98a7df0defdffc32214681a19d6680d8299afc36c2d2f16940043c82da082655a6664576225b7c15f26692d255930368a819818a8c
+  metadata.gz: f7d6388c50fd34c95d9e4258907265384c9ea8961d94e13e15ce89da5feefa29644dc35273a92335c4e62c980fbb047a0d00bf4e30839e90568bcb9e22ce46cb
+  data.tar.gz: ebfeb295fadbf60a0ebfd4b8fcf102371efdbf69046d1c4e03ebc1bf227d9f76eab47fb6abfe1fc983bc7f4a9779f8d6c083f6af7858894834e5ada84123fd1f

data/bin/mcmd

@@ -1,97 +1,25 @@
 #!/usr/bin/env ruby
 
-require 'pp'
+require_relative '../lib/cli'
 
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
-require 'mcmd'
-
-require 'optparse'
-options = {
+cli = CommonCli.new({
+  # defaults
   :maxflight => 200,
   :timeout => 60,
   :global_timeout => 0,
-}
+})
 
-optparse = OptionParser.new do |opts|
-  opts.on('-r', '--range RANGE', 'currently takes a CSV list') do |arg|
-    options[:range] = arg 
-  end
-  opts.on('-m', '--maxflight 50', 'How many subprocesses? 50 by default') do |arg|
-    options[:maxflight] = arg 
-  end
-  opts.on('-t', '--timeout 60', 'How many seconds may each individual process take? 0 for no timeout') do |arg|
-    options[:timeout] = arg 
-  end
-  opts.on('-g', '--global_timeout 600', 'How many seconds for the whole shebang 0 for no timeout') do |arg|
-    options[:global_timeout] = arg 
-  end
-  opts.on('--noshell', "Don't invoke a shell. Args will be passed to exec verbatim ") do |arg|
-    options[:noshell] = arg 
-  end
-  opts.on('-c', '--collapse', "Collapse similar output ") do |arg|
-    options[:collapse] = arg 
-  end
-  opts.on('-v', '--verbose', "Verbose output") do |arg|
-    options[:verbose] = arg 
-  end
-  opts.on('-d', '--debug', "Debug output") do |arg|
-    options[:debug] = arg 
+cli.extra_options = lambda do |parser, options|
+  parser.on('--noshell', "Don't invoke a shell. Args will be passed to exec verbatim ") do |arg|
+    options[:noshell] = arg
   end
-  # option to merge stdin/stdout into one buf? how should this work?
-  # option to ignore as-we-go yield output - this is off by default now except for success/fail
 end
-optparse.parse!
 
-raise "Error, need -r argument" if options[:range].nil? or options[:range].empty?
-raise "Error, need command to run" if ARGV.size.zero?
+cli.parse ARGV
 
-m = MultipleCmd.new
-
-targets = options[:range].split ","
-
-m.commands = targets.map { |t| ["/bin/sh", "-c"].push ARGV.map { |arg| arg.gsub('HOSTNAME', t)}.join " " }
-command_to_target = Hash.new
-targets.size.times do |i|
-  command_to_target[m.commands[i].object_id] = targets[i]
+result = cli.runcmd do |cmd, t|
+	if cli.options[:noshell] then [cmd] else ["/bin/sh", "-c"].push cmd end
 end
-m.yield_startcmd = lambda { |p| puts "#{command_to_target[p.command.object_id]}: starting" } if options[:verbose]
-m.yield_wait = lambda { |p| puts "#{p.success? ? 'SUCCESS' : 'FAILURE'} #{command_to_target[p.command.object_id]}: '#{p.stdout_buf}'" }
-# m.yield_proc_timeout = lambda { |p| puts "am killing #{p.inspect}"}
-
-m.perchild_timeout = options[:timeout].to_i
-m.global_timeout = options[:global_timeout].to_i
-m.maxflight = options[:maxflight].to_i
-m.verbose = options[:verbose]
-m.debug = options[:debug]
-
-result = m.run
 
-if options[:collapse]
-  # print a collapsed summary
-  stdout_matches_success = Hash.new
-  stdout_matches_failure = Hash.new
-  result.each do |r|
-    if r[:retval].success?
-      stdout_matches_success[r[:stdout_buf]] = [] if stdout_matches_success[r[:stdout_buf]].nil?
-      stdout_matches_success[r[:stdout_buf]] << command_to_target[r[:command].object_id]
-    else
-      stdout_matches_failure[r[:stdout_buf]] = [] if stdout_matches_failure[r[:stdout_buf]].nil?
-      stdout_matches_failure[r[:stdout_buf]] << command_to_target[r[:command].object_id]
-    end
-  end
-  # output => [targets ...]
-  stdout_matches_success.each_pair do |k,v|
-    puts "SUCCESS: #{v.join ','}: #{k}"
-  end
-  stdout_matches_failure.each_pair do |k,v|
-    puts "FAILURE: #{v.join ','}: #{k}"
-  end
-else
-  # we already printed while in-flight; do nothing
-    # not collapse, print one per host
-#  result.each do |r|
-#    target = command_to_target[r[:command].object_id]
-#    puts "#{target}: '#{r[:stdout_buf].chomp}'\n"
-#  end
-end
+cli.output result
 

data/bin/mssh

@@ -1,128 +1,31 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 
-require 'rubygems'
-require 'pp'
-require 'mcmd'
+require_relative '../lib/cli'
 
-require 'optparse'
-require 'ostruct'
-options = {
+cli = CommonCli.new({
+  # defaults
   :maxflight => 50,
   :timeout => 60,
   :global_timeout => 600,
-}
-optparse = OptionParser.new do |opts|
-  opts.on('-r', '--range RANGE', 'Requires a configured Range::Client. Use --hostlist if you do not use range') do |arg|
-    options[:range] = arg 
-  end
-  opts.on('--hostlist x,y,z', Array, 'List of hostnames to execute on') do |arg|
-    options[:hostlist] = arg 
-  end
-  opts.on('-f', '--file FILE', 'List of hostnames in a FILE use (/dev/stdin) for reading from stdin') do |arg|
-    options[:file] = arg 
-  end
-  opts.on('-m', '--maxflight 50', 'How many subprocesses? 50 by default') do |arg|
-    options[:maxflight] = arg 
-  end
-  opts.on('-t', '--timeout 60', 'How many seconds may each individual process take? 0 for no timeout') do |arg|
-    options[:timeout] = arg 
-  end
-  opts.on('-g', '--global_timeout 600', 'How many seconds for the whole shebang 0 for no timeout') do |arg|
-    options[:global_timeout] = arg 
-  end
-  opts.on('-c', '--collapse', "Collapse similar output ") do |arg|
-    options[:collapse] = arg 
-  end
-  opts.on('-v', '--verbose', "verbose ") do |arg|
-    options[:verbose] = arg 
-  end
-  opts.on('-d', '--debug', "Debug output") do |arg|
-    options[:debug] = arg 
-  end
-  opts.on('--sshopt OPT',  "ssh options, default [-2, -oBatchMode=yes, -A]. Can be used multiple times.") do |arg|
+  :sshcmd => "/usr/bin/ssh",
+  :sshopt => ["-2", "-oBatchMode=yes", "-A"]
+})
+
+## Extra options for the SSH version
+cli.extra_options = lambda do |parser, options|
+  parser.on('--sshopt OPT',  "ssh options, default [-2, -oBatchMode=yes, -A]. Can be used multiple times.") do |arg|
     options[:sshopt] ||= []
     options[:sshopt] << arg
   end
-  opts.on('--sshcmd BINARY', "Path to the ssh binary") do |arg|
+  parser.on('--sshcmd BINARY', "Path to the ssh binary (default /usr/bin/ssh)") do |arg|
     options[:sshcmd] = arg
   end
-  # option to merge stdin/stdout into one buf?
-  # option to ignore as-we-go yield output
 end
-optparse.parse!
 
-# default options
-options[:sshopt] ||= ["-2", "-oBatchMode=yes", "-A"]
-options[:sshcmd] = "/usr/bin/ssh"
+cli.parse ARGV
 
-targets = []
-if (options[:range].nil? and options[:file].nil? and options[:hostlist].nil?)
-  raise "Error, need -r or -f or --hostlist option"
+result = cli.runcmd do |command, target|
+  [cli.options[:sshcmd], *cli.options[:sshopt]].push target, command
 end
 
-if (!options[:range].nil?)
-  require 'rangeclient'
-  range = Range::Client.new
-  targets.push *range.expand(options[:range])
-end
-if (!options[:file].nil?)
-  targets_fd = File.open(options[:file])
-  targets_fd.read.each_line { |x| targets << x.chomp }
-end
-if (!options[:hostlist].nil?)
-  targets.push *options[:hostlist]
-end
-
-raise "no targets specified. Check your -r, -f or --hostlist inputs" if targets.size.zero?
-raise "need command to run" if ARGV.size.zero?
-raise "too many arguments" if ARGV.size != 1
-
-
-
-m = MultipleCmd.new
-m.commands = targets.map { |t| [options[:sshcmd], *options[:sshopt] ].push t, ARGV.first }
-command_to_target = Hash.new
-targets.size.times do |i|
-  command_to_target[m.commands[i].object_id] = targets[i]
-end
-m.yield_startcmd = lambda { |p| puts "#{command_to_target[p.command.object_id]}: starting" } if options[:verbose]
-m.yield_wait = lambda { |p| puts "#{command_to_target[p.command.object_id]}: finished" } if options[:verbose]
-
-m.perchild_timeout = options[:timeout].to_i
-m.global_timeout = options[:global_timeout].to_i
-m.maxflight = options[:maxflight].to_i
-m.verbose = options[:verbose]
-m.debug = options[:debug]
-
-result = m.run
-
-if (options[:collapse] and options[:range])
-  # print a collapsed summary
-  out_matches = Hash.new
-  result.each do |r|
-    out = "" 
-    out += r[:stdout_buf].chomp if(!r[:stdout_buf].nil?)
-    out += r[:stderr_buf].chomp if(!r[:stderr_buf].nil?)
-    out_matches[out] = [] if out_matches[out].nil?
-    out_matches[out] << command_to_target[r[:command].object_id]
-  end
-  # output => [targets ...]
-  out_matches.each_pair do |k,v|
-    hosts = range.compress v
-    puts "#{hosts}: '#{k.chomp}'"
-  end
-else
-  # not collapse, print one per host
-  result.each do |r|
-    target = command_to_target[r[:command].object_id]
-    out = "" 
-    out += r[:stdout_buf].chomp if(!r[:stdout_buf].nil?)
-    out += r[:stderr_buf].chomp if(!r[:stderr_buf].nil?)
-    if (r[:retval] == 0 )
-        puts "#{target}:SUCCESS: #{out}\n"
-    else
-        exit_code = r[:retval].exitstatus.to_s if(!r[:retval].nil?)
-        puts "#{target}:FAILURE[#{exit_code}]: #{out}\n"
-    end
-  end
-end
+cli.output result

data/lib/cli.rb

@@ -0,0 +1,182 @@
+require 'optparse'
+require_relative './mcmd'
+
+##
+# Implements what is shared
+# between mssh and mcmd.
+class CommonCli
+  attr_accessor :options, :result, :command_to_target, :targets
+  attr_writer   :extra_options
+
+  def initialize(defaults)
+    @options = defaults
+    @options[:hostname_token] = 'HOSTNAME'
+  end
+
+  ##
+  # Parses a list of arguments, and yells
+  # at us if any are wrong.
+  def parse(argv)
+
+    @defs = Hash[@options.map{|k,v| [k, " (default: #{v})"] } ]
+
+    optparse = OptionParser.new do |opts|
+      opts.on('-r', '--range RANGE', 'currently takes a CSV list' + @defs[:range].to_s ) do |arg|
+        @options[:range] = arg
+      end
+      opts.on('--hostlist x,y,z', Array, 'List of hostnames to execute on' + @defs[:hostlist].to_s) do |arg|
+        @options[:hostlist] = arg
+      end
+      opts.on('-f', '--file FILE', 'List of hostnames in a FILE use (/dev/stdin) for reading from stdin' + @defs[:file].to_s) do |arg|
+        @options[:file] = arg
+      end
+      opts.on('-m', '--maxflight 200', 'How many subprocesses? 50 by default' + @defs[:maxflight].to_s) do |arg|
+        @options[:maxflight] = arg
+      end
+      opts.on('-t', '--timeout 60', 'How many seconds may each individual process take? 0 for no timeout' + @defs[:timeout].to_s) do |arg|
+        @options[:timeout] = arg
+      end
+      opts.on('-g', '--global_timeout 0', 'How many seconds for the whole shebang 0 for no timeout' + @defs[:global_timeout].to_s) do |arg|
+        @options[:global_timeout] = arg
+      end
+      opts.on('-c', '--collapse', "Collapse similar output " + @defs[:collapse].to_s) do |arg|
+        @options[:collapse] = arg
+      end
+      opts.on('-v', '--verbose', "Verbose output" + @defs[:verbose].to_s) do |arg|
+        @options[:verbose] = arg
+      end
+      opts.on('-d', '--debug', "Debug output" + @defs[:debug].to_s) do |arg|
+        @options[:debug] = arg
+      end
+      opts.on('--json', "Output results as JSON" + @defs[:json_out].to_s) do |arg|
+        @options[:json_out] = arg
+      end
+      opts.on('--hntoken HOSTNAME', "Token used for HOSTNAME substitution" + @defs[:hostname_token].to_s) do |arg|
+        @options[:hostname_token] = arg
+      end
+
+      @extra_options.call(opts, @options) if !@extra_options.nil?
+
+      # option to merge stdin/stdout into one buf? how should this work?
+      # option to ignore as-we-go yield output - this is off by default now except for success/fail
+    end
+
+    optparse.parse! argv
+
+    if options[:range] || options[:collapse]
+      require 'rangeclient'
+      @rangeclient = Range::Client.new
+    end
+
+    ## Get targets from -r or -f or --hostlist
+    @targets = []
+    if (options[:range].nil? and options[:file].nil? and options[:hostlist].nil?)
+      raise "Error, need -r or -f or --hostlist option"
+    end
+
+    if (!options[:range].nil?)
+      @targets.push *@rangeclient.expand(options[:range])
+    end
+
+    if (!options[:file].nil?)
+      targets_fd = File.open(options[:file])
+      targets_fd.read.each_line { |x| @targets << x.chomp }
+    end
+
+    if (!options[:hostlist].nil?)
+      @targets.push *options[:hostlist]
+    end
+
+    raise "no targets specified. Check your -r, -f or --hostlist inputs" if @targets.size.zero?
+    raise "need command to run"                                          if argv.size.zero?
+    raise "too many arguments"                                           if argv.size != 1
+
+    @command = argv.first
+
+  end
+
+  def runcmd
+
+    m = MultipleCmd.new
+
+    # We let the caller build the command
+    m.commands = @targets.map do |t|
+      yield(@command.gsub(@options[:hostname_token], t), t)
+    end
+
+    @command_to_target = Hash.new
+    @targets.size.times do |i|
+      @command_to_target[m.commands[i].object_id] = @targets[i]
+    end
+
+    m.yield_startcmd = lambda { |p| puts "#{@command_to_target[p.command.object_id]}: starting" } if @options[:verbose]
+    m.yield_wait     = lambda { |p| puts "#{p.success? ? 'SUCCESS' : 'FAILURE'} #{@command_to_target[p.command.object_id]}: '#{p.stdout_buf}'" } if @options[:verbose]
+    # todo, from mssh m.yield_wait = lambda { |p| puts "#{@command_to_target[p.command.object_id]}: finished" } if @options[:verbose]
+
+    # was commented out in mcmd already: m.yield_proc_timeout = lambda { |p| puts "am killing #{p.inspect}"}
+
+    m.perchild_timeout = @options[:timeout].to_i
+    m.global_timeout   = @options[:global_timeout].to_i
+    m.maxflight        = @options[:maxflight].to_i
+    m.verbose          = @options[:verbose]
+    m.debug            = @options[:debug]
+
+    return m.run
+  end
+
+  def output result
+
+    ## Print as JSON array
+    if (@options[:json_out])
+      require 'json'
+      puts JSON.generate(result)
+      return
+    end
+
+    # Concat stdout / stderr -> :all_buf
+    result.each do |r|
+      r[:all_buf] = ""
+      r[:all_buf] += r[:stdout_buf].chomp if(!r[:stdout_buf].nil?)
+      r[:all_buf] += r[:stderr_buf].chomp if(!r[:stderr_buf].nil?)
+    end
+
+    ## Collapse similar results
+    if @options[:collapse]
+      stdout_matches_success = Hash.new
+      stdout_matches_failure = Hash.new
+      result.each do |r|
+
+        if r[:retval].success?
+          stdout_matches_success[r[:all_buf]] = [] if stdout_matches_success[r[:all_buf]].nil?
+          stdout_matches_success[r[:all_buf]] << @command_to_target[r[:command].object_id]
+        else
+          stdout_matches_failure[r[:all_buf]] = [] if stdout_matches_failure[r[:all_buf]].nil?
+          stdout_matches_failure[r[:all_buf]] << @command_to_target[r[:command].object_id]
+        end
+      end
+      # output => [targets ...]
+      stdout_matches_success.each_pair do |k,v|
+        hosts = @rangeclient.compress v
+        # puts "#{hosts}: '#{k.chomp}'"
+        puts "SUCCESS: #{hosts}: #{k}"
+      end
+      stdout_matches_failure.each_pair do |k,v|
+        hosts = @rangeclient.compress v
+        puts "FAILURE: #{hosts}: #{k}"
+      end
+
+    ## Dont collapse similar resutls
+    else
+      result.each do |r|
+        target = @command_to_target[r[:command].object_id]
+        if (r[:retval].success?)
+            puts "#{target}:SUCCESS: #{r[:all_buf]}\n"
+        else
+            exit_code = r[:retval].exitstatus.to_s if(!r[:retval].nil?)
+            puts "#{target}:FAILURE[#{exit_code}]: #{r[:all_buf]}\n"
+        end
+      end
+    end
+
+  end
+end

data/lib/mcmd.rb

@@ -10,6 +10,9 @@ class MultipleCmd
   attr_accessor :yield_wait, :yield_startcmd, :debug, :yield_proc_timeout
   attr_accessor :verbose, :poll_period, :max_read_size
 
+  # TODO: move these to cattrs on MultipleCmd::SubProc
+  attr_accessor :subproc_by_pid, :subproc_by_fd
+
   def initialize
     # these are re-initialized after every run
     @subproc_by_pid = Hash.new
@@ -28,9 +31,9 @@ class MultipleCmd
 
   def noshell_exec(cmd)
     if cmd.length == 1
-      Kernel.exec([cmd[0], cmd[0]])
+      exec([cmd[0], cmd[0]])
     else 
-      Kernel.exec([cmd[0], cmd[0]], *cmd[1..-1])
+      exec([cmd[0], cmd[0]], *cmd[1..-1])
     end
   end
   
@@ -48,18 +51,18 @@ class MultipleCmd
     subproc.command = cmd
     
     pid = fork
-    if not pid.nil?
+    if pid
       # parent
       # for mapping to subproc by pid
       subproc.pid = pid
-      @subproc_by_pid[pid] = subproc
+      subproc_by_pid[pid] = subproc
       # for mapping to subproc by i/o handle (returned from select)
-      @subproc_by_fd[stdin_rd] = subproc
-      @subproc_by_fd[stdin_wr] = subproc
-      @subproc_by_fd[stdout_rd] = subproc
-      @subproc_by_fd[stdout_wr] = subproc
-      @subproc_by_fd[stderr_rd] = subproc
-      @subproc_by_fd[stderr_wr] = subproc
+      subproc_by_fd[stdin_rd] = subproc
+      subproc_by_fd[stdin_wr] = subproc
+      subproc_by_fd[stdout_rd] = subproc
+      subproc_by_fd[stdout_wr] = subproc
+      subproc_by_fd[stderr_rd] = subproc
+      subproc_by_fd[stderr_wr] = subproc
       
       self.yield_startcmd.call(subproc) unless self.yield_startcmd.nil?
     else
@@ -76,10 +79,10 @@ class MultipleCmd
   def process_read_fds(read_fds)
     read_fds.each do |fd|
       # read available bytes, add to the subproc's read buf
-      if not @subproc_by_fd.has_key?(fd)
+      if not subproc_by_fd.has_key?(fd)
         raise "Select returned a fd which I have not seen! fd: #{fd.inspect}"
       end
-      subproc = @subproc_by_fd[fd]
+      subproc = subproc_by_fd[fd]
       buf = ""
       begin
         buf = fd.sysread(4096)
@@ -119,8 +122,8 @@ class MultipleCmd
   end # process_read_fds()
   def process_write_fds(write_fds)
     write_fds.each do |fd|
-      raise "working on an unknown fd #{fd}" unless @subproc_by_fd.has_key?(fd)
-      subproc = @subproc_by_fd[fd]
+      raise "working on an unknown fd #{fd}" unless subproc_by_fd.has_key?(fd)
+      subproc = subproc_by_fd[fd]
       buf = ""
       # add writing here, todo. not core feature
     end
@@ -130,8 +133,8 @@ class MultipleCmd
   
   # iterate and service fds in child procs, collect data and status
   def service_subprocess_io
-    write_fds = @subproc_by_pid.values.select {|x| not x.stdin_fd.nil? and not x.terminated}.map {|x| x.stdin_fd}
-    read_fds = @subproc_by_pid.values.select {|x| not x.terminated}.map {|x| [x.stdout_fd, x.stderr_fd].select {|x| not x.nil? } }.flatten
+    write_fds = subproc_by_pid.values.select {|x| not x.stdin_fd.nil? and not x.terminated}.map {|x| x.stdin_fd}
+    read_fds = subproc_by_pid.values.select {|x| not x.terminated}.map {|x| [x.stdout_fd, x.stderr_fd].select {|x| not x.nil? } }.flatten
 
     read_fds, write_fds, err_fds = IO.select_using_poll(read_fds, write_fds, nil, self.poll_period)
 
@@ -143,7 +146,7 @@ class MultipleCmd
 
   def process_timeouts
     now = Time.now.to_i
-    @subproc_by_pid.values.each do |p|
+    subproc_by_pid.values.each do |p|
       if ((now - p.time_start) > self.perchild_timeout) and self.perchild_timeout > 0
         # expire this child process
         
@@ -155,9 +158,9 @@ class MultipleCmd
 
   def kill_process(p)
     # do not remove from pid list until waited on
-    @subproc_by_fd.delete(p.stdin_fd)
-    @subproc_by_fd.delete(p.stdout_fd)
-    @subproc_by_fd.delete(p.stderr_fd)
+    subproc_by_fd.delete(p.stdin_fd)
+    subproc_by_fd.delete(p.stdout_fd)
+    subproc_by_fd.delete(p.stderr_fd)
     # must kill after deleting from maps
     # kill closes fds
     p.kill
@@ -168,7 +171,7 @@ class MultipleCmd
     done = false
     while not done
       # start up as many as maxflight processes
-      while @subproc_by_pid.length < self.maxflight and not @commands.empty?
+      while subproc_by_pid.length < self.maxflight and not @commands.empty?
         # take one from @commands and start it
         commands = @commands.shift
         self.add_subprocess(commands)
@@ -179,19 +182,19 @@ class MultipleCmd
       self.process_timeouts
       # service process cleanup
       self.wait
-      puts "have #{@subproc_by_pid.length} left to go" if self.debug
+      puts "have #{subproc_by_pid.length} left to go" if self.debug
       # if we have nothing in flight (active pid)
       # and nothing pending on the input list
       # then we're done
-      if @subproc_by_pid.length.zero? and @commands.empty?
+      if subproc_by_pid.length.zero? and @commands.empty?
         done = true
       end
     end
     
     data = self.return_rundata
     # these are re-initialized after every run
-    @subproc_by_pid = Hash.new
-    @subproc_by_fd = Hash.new
+    subproc_by_pid = Hash.new
+    subproc_by_fd = Hash.new
     @processed_commands = []
     # end items which are re-initialized
     return data
@@ -226,10 +229,10 @@ class MultipleCmd
         else
           # pid is now gone. remove from subproc_by_pid and
           # add to the processed commands list
-          p = @subproc_by_pid[pid]
+          p = subproc_by_pid[pid]
           p.time_end = Time.now.to_i
           p.retval = $?
-          @subproc_by_pid.delete(pid)
+          subproc_by_pid.delete(pid)
           @processed_commands << p
           just_reaped << p
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mssh
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Evan Miller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-29 00:00:00.000000000 Z
+date: 2017-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple library for running jobs and sshing to many hosts at once.
 email:
 - github@squareup.com
@@ -52,6 +66,7 @@ files:
 - README.md
 - bin/mcmd
 - bin/mssh
+- lib/cli.rb
 - lib/mcmd.rb
 homepage: http://github.com/square/mssh
 licenses: []
@@ -73,9 +88,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Parallel ssh and command execution.
 test_files: []
-has_rdoc: