heroku-commander 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+0.2.0 (02/14/2013)
+==================
+
+* When the process exit status cannot be determined the error message says "The command failed without returning an exit status." - [@dblock](https://github.com/dblock).
+* Added the process ID into the `Heroku::Commander::Errors::CommandError` problem description - [@dblock](https://github.com/dblock).
+* Fix: Heroku `run` or `run:detached` output does not always combine "attached to terminal" and "up" status, which causes the runner to incorrectly parse the Heroku PID - [@dblock](https://github.com/dblock).
+* Added `Heroku::Commander.processes` that returns or yields an array of `Heroku::Process` by running `heroku ps` - [@dblock](https://github.com/dblock).
+* Added a `tail_timeout` option to `Heroku::Commander.run` with `detached: true` that suspends tail process termination for a chance to receive additional `heroku logs --tail` output - [@dblock](https://github.com/dblock).
+
 0.1.0 (01/31/2013)
 ==================
 

data/README.md

@@ -25,6 +25,18 @@ commander = Heroku::Commander.new({ :app => "heroku-commander" })
 commander.config # => a hash of all settings for the heroku-commander app
 ```
 
+Heroku Processes
+----------------
+
+Returns or yields an array of processes by running `heroku ps`.
+
+``` ruby
+commander = Heroku::Commander.new({ :app => "heroku-commander" })
+commander.processes do |process|
+  # try process.pid and process.status
+end
+```
+
 Heroku Run
 ----------
 
@@ -53,6 +65,10 @@ commander.run("ls -R", { :detached => true }) do |line|
 end
 ```
 
+You can pass the following options along with `:detached`:
+
+* **tail_timeout**: number of seconds to wait before terminating `heroku logs --tail`, expecting more output (default to 5).
+
 For more information about Heroku one-off dynos see [this documentation](https://devcenter.heroku.com/articles/one-off-dynos).
 
 More Examples

data/examples/executor-run.rb

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+require 'heroku-commander'
+
+logger = Logger.new($stdout)
+logger.level = Logger::INFO
+
+uname = Heroku::Executor.run "uname -a", { :logger => logger }
+logger.info "Local system is #{uname.join('\n')}."
+
+files = []
+Heroku::Executor.run "ls -1", { :logger => logger } do |line|
+  files << line
+end
+logger.info "Local file system has #{files.count} file(s): #{files.join(', ')}"

data/examples/heroku-processes.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.setup(:default, :development)
+
+require 'heroku-commander'
+
+logger = Logger.new($stdout)
+logger.level = Logger::DEBUG
+commander = Heroku::Commander.new({ :logger => logger })
+
+commander.processes.each do |process|
+  logger.info "Process: #{process.pid} (#{process.status})"
+end

data/lib/config/locales/en.yml

@@ -8,7 +8,7 @@ en:
             summary: "The heroku client stopped sending output before exiting."
             resolution: "This is unexpected and represents a Heroku server error. Try again."
           command_error:
-            message: "The command `%{cmd}` failed with exit status %{status}."
+            message: "The command `%{cmd}`%{pid} failed%{status_message}."
             summary: "%{message}%{lines}"
             resolution: "Examine the command line and refer to the command documentation."
           unexpected_output:
@@ -20,7 +20,16 @@ en:
             summary: "The instance of Heroku::Runner is missing a command argument."
             resolution: "Specify a command, for example:\n
             \_\_Heroku::Runner.new({ :command => 'ls -1' })"
+          missing_pid_error:
+            message: "Missing pid."
+            summary: "The instance of Heroku::Status is missing a pid argument."
+            resolution: "Specify a pid, for example:\n
+            \_\_Heroku::Status.new({ :pid => 'run.1234' })"
           already_running_error:
             message: "The process is already running with pid %{pid}."
             summary: "You can only run! or detach! an instance of Heroku::Runner once."
             resolution: "This is a bug in your code."
+          no_such_process:
+            message: "The process `%{pid}` does not exist."
+            summary: "The output of heroku ps did not list the requested process."
+            resolution: "Verify that the process is running."

data/lib/heroku-commander.rb

@@ -11,5 +11,5 @@ require 'heroku/commander/errors'
 require 'heroku/config'
 require 'heroku/commander'
 require 'heroku/executor'
+require 'heroku/process'
 require 'heroku/runner'
-

data/lib/heroku/commander.rb

@@ -15,6 +15,23 @@ module Heroku
       end
     end
 
+    def processes(&block)
+      processes = []
+      cmdline = [ "heroku", "ps", @app ? "--app #{@app}" : nil ].compact.join(" ")
+      Heroku::Executor.run cmdline, { :logger => logger } do |line|
+        next if ! line || line[0] == '=' || line.length == 0
+        if (match = line.match /(\w+\.\d+): (\w+)/)
+          process = Heroku::Process.new({ :logger => logger, :pid => match[1], :status => match[2], :app => app })
+          processes << process
+          logger.info "Process: #{process.pid} (#{process.status}) from '#{line}'" if logger
+          yield process if block_given?
+        else
+          logger.warn "Unexpected line from heroku ps: #{line}" if logger
+        end
+      end
+      processes
+    end
+
     # Run a process synchronously
     def run(command, options = {}, &block)
       runner = Heroku::Runner.new({ :app => app, :logger => logger, :command => command })

data/lib/heroku/commander/errors.rb

@@ -2,5 +2,7 @@ require 'heroku/commander/errors/base'
 require 'heroku/commander/errors/client_eio_error'
 require 'heroku/commander/errors/command_error'
 require 'heroku/commander/errors/missing_command_error'
+require 'heroku/commander/errors/missing_pid_error'
 require 'heroku/commander/errors/unexpected_output_error'
 require 'heroku/commander/errors/already_running_error'
+require 'heroku/commander/errors/no_such_process_error'

data/lib/heroku/commander/errors/command_error.rb

@@ -7,27 +7,40 @@ module Heroku
 
         def initialize(opts = {})
           @inner_exception = opts[:inner_exception]
-          super(compose_message("command_error", prepare_lines(opts)))
+          opts = opts.dup
+          prepare_lines(opts)
+          prepare_status_message(opts)
+          prepare_pid(opts)
+          super(compose_message("command_error", opts))
         end
 
         private
 
+          def prepare_status_message(opts)
+            if opts[:status] && opts[:status] != ""
+              opts[:status_message] = " with exit status #{opts[:status]}"
+            else
+              opts[:status_message] = " without reporting an exit status"
+            end
+          end
+
           def prepare_lines(opts)
             if opts[:lines] && opts[:lines].size > 4
               lines = opts[:lines][0..2]
               lines.push "... skipping #{opts[:lines].size - 4} line(s) ..."
               lines.concat opts[:lines][-2..-1]
-              result = opts.dup
-              result[:lines] = "\n\t" + lines.join("\n\t")
-              result
+              opts[:lines] = "\n\t" + lines.join("\n\t")
             elsif opts[:lines]
-              result = opts.dup
-              result[:lines] = "\n\t" + result[:lines].join("\n\t")
-              result
-            else
-              opts
+              opts[:lines] = "\n\t" + opts[:lines].join("\n\t")
             end
           end
+
+          def prepare_pid(opts)
+            if opts[:pid]
+              opts[:pid] = " (pid: #{opts[:pid]})"
+            end
+          end
+
       end
     end
   end

data/lib/heroku/commander/errors/missing_pid_error.rb

@@ -0,0 +1,13 @@
+module Heroku
+  class Commander
+    module Errors
+      class MissingPidError < Heroku::Commander::Errors::Base
+
+        def initialize
+          super(compose_message("missing_pid_error"))
+        end
+
+      end
+    end
+  end
+end

data/lib/heroku/commander/errors/no_such_process_error.rb

@@ -0,0 +1,13 @@
+module Heroku
+  class Commander
+    module Errors
+      class NoSuchProcessError < Heroku::Commander::Errors::Base
+
+        def initialize(opts = {})
+          super(compose_message("no_such_process", opts))
+        end
+
+      end
+    end
+  end
+end

data/lib/heroku/commander/version.rb

@@ -1,5 +1,5 @@
 module Heroku
   class Commander
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/heroku/executor.rb

@@ -2,6 +2,12 @@ module Heroku
   class Executor
 
     class Terminate < StandardError
+
+      attr_accessor :timeout
+
+      def initialize(timeout = 0)
+        @timeout = timeout
+      end
     end
 
     class << self
@@ -9,47 +15,41 @@ module Heroku
       # Executes a command and yields output line-by-line.
       def run(cmd, options = {}, &block)
         lines = []
+        running_pid = nil
         logger = options[:logger]
         logger.debug "Running: #{cmd}" if logger
         PTY.spawn(cmd) do |r, w, pid|
+          running_pid = pid
           logger.debug "Started: #{pid}" if logger
           terminated = false
           begin
             r.sync = true
-            r.each do |line|
-              line.strip! if line
-              logger.debug "#{pid}: #{line}" if logger
-              if block_given?
-                yield line
-              end
-              lines << line
-            end
-          rescue Heroku::Executor::Terminate
-            logger.debug "Terminating #{pid}." if logger
-            Process.kill("TERM", pid)
+            read_from(r, pid, options, lines, &block)
+          rescue Heroku::Executor::Terminate => e
+            logger.debug "Waiting: #{e.timeout} second(s) to terminate #{pid}" if logger
+            terminate_process! pid, e.timeout
             terminated = true
           rescue Errno::EIO, IOError => e
-            logger.debug "#{e.class}: #{e.message}" if logger
+            # ignore
           rescue PTY::ChildExited => e
             logger.debug "Terminated: #{pid}" if logger
-            terminted = true
+            terminated = true
             raise e
           ensure
             unless terminated
+              # wait for process
               logger.debug "Waiting: #{pid}" if logger
-              Process.wait(pid) rescue Errno::ECHILD
+              ::Process.wait(pid)
             end
           end
         end
-        check_exit_status! cmd, $?.exitstatus, lines
+        check_exit_status! cmd, running_pid, $?.exitstatus, lines
         lines
       rescue Errno::ECHILD => e
-        logger.debug "#{e.class}: #{e.message}" if logger
-        check_exit_status! cmd, $?.exitstatus, lines
+        check_exit_status! cmd, running_pid, $?.exitstatus, lines
         lines
       rescue PTY::ChildExited => e
-        logger.debug "#{e.class}: #{e.message}" if logger
-        check_exit_status! cmd, $!.status.exitstatus, lines
+        check_exit_status! cmd, running_pid, $!.status.exitstatus, lines
         lines
       rescue Heroku::Commander::Errors::Base => e
         logger.debug "Error: #{e.problem}" if logger
@@ -58,6 +58,7 @@ module Heroku
         logger.debug "#{e.class}: #{e.respond_to?(:problem) ? e.problem : e.message}" if logger
         raise Heroku::Commander::Errors::CommandError.new({
           :cmd => cmd,
+          :pid => running_pid,
           :status => $?.exitstatus,
           :message => e.message,
           :inner_exception => e,
@@ -67,16 +68,45 @@ module Heroku
 
       private
 
-        def check_exit_status!(cmd, status, lines = nil)
+        def read_from(r, pid, options, lines, &block)
+          logger = options[:logger]
+          while ! r.eof do
+            line = r.readline
+            line.strip! if line
+            logger.debug "#{pid}: #{line}" if logger
+            if block_given?
+              yield line
+            end
+            lines << line
+          end
+        end
+
+        def check_exit_status!(cmd, pid, status, lines = nil)
           return if ! status || status == 0
           raise Heroku::Commander::Errors::CommandError.new({
             :cmd => cmd,
+            :pid => pid,
             :status => status,
             :message => "The command #{cmd} failed with exit status #{status}.",
             :lines => lines
           })
         end
 
+        def terminate_process!(pid, timeout)
+          if timeout
+            # Delay terminating of the process, usually to let the output flush.
+            Thread.new(pid, timeout) do |pid, timeout|
+              begin
+                sleep(timeout) if timeout
+                ::Process.kill("TERM", pid)
+              rescue
+              end
+            end
+          else
+            ::Process.kill("TERM", pid)
+          end
+        end
+
     end
   end
 end

data/lib/heroku/process.rb

@@ -0,0 +1,25 @@
+module Heroku
+  class Process
+
+    attr_accessor :app, :logger, :pid, :status
+
+    def initialize(options = {})
+      @app = options[:app]
+      @logger = options[:logger]
+      @pid = options[:pid]
+      @status = options[:status]
+      raise Heroku::Commander::Errors::MissingPidError unless @pid
+    end
+
+    def refresh_status!
+      refreshed = false
+      Heroku::Commander.new({ :logger => logger, :app => app }).processes.each do |process|
+        next unless ! refreshed && process.pid == pid
+        @status = process.status
+        refreshed = true
+      end
+      refreshed
+    end
+
+  end
+end

data/lib/heroku/runner.rb

@@ -17,38 +17,40 @@ module Heroku
 
     def run!(options = {}, &block)
       if options && options[:detached]
-        run_detached! &block
+        run_detached! options, &block
       else
-        run_attached! &block
+        run_attached! options, &block
       end
     end
 
     protected
 
-      def run_attached!(&block)
+      def run_attached!(options = {}, &block)
         @pid = nil
         previous_line = nil # delay by 1 to avoid rc=status line
+        lines_until_pid = 0
         lines = Heroku::Executor.run cmdline, { :logger => logger } do |line|
           if ! @pid
             check_pid(line)
+            lines_until_pid += 1
           elsif block_given?
             yield previous_line if previous_line
             previous_line = line
           end
         end
-        lines.shift # remove Running `...` attached to terminal... up, run.xyz
+        lines.shift(lines_until_pid) # remove Running `...` attached to terminal... up, run.xyz
         check_exit_status! lines
         lines
       end
 
-      def run_detached!(&block)
+      def run_detached!(options = {}, &block)
         raise Heroku::Commander::Errors::AlreadyRunningError.new({ :pid => @pid }) if running?
         @running = true
         @pid = nil
         @tail = nil
         lines = Heroku::Executor.run cmdline({ :detached => true }), { :logger => logger } do |line|
           check_pid(line) unless @pid
-          @tail ||= tail!(&block) if @pid
+          @tail ||= tail!(options, &block) if @pid
         end
         check_exit_status! @tail || lines
         @running = false
@@ -64,37 +66,36 @@ module Heroku
         lines.pop if status
         raise Heroku::Commander::Errors::CommandError.new({
           :cmd => @command,
+          :pid => @pid,
           :status => status,
-          :message => "The command #{@command} failed with exit status #{status}.",
+          :message => "The command #{@command} failed.",
           :lines => lines
         }) unless status && status == "0"
       end
 
       def check_pid(line)
-        if (match = line.match /attached to terminal... up, (run.\d+)$/)
+        if (match = line.match /up, (run.\d+)$/)
           @pid = match[1]
           logger.debug "Heroku pid #{@pid} up." if logger
-        elsif (match = line.match /detached... up, (run.\d+)$/)
-          @pid = match[1]
-          logger.debug "Heroku detached pid #{@pid} up." if logger
-        else
-          @pid = ''
         end
       end
 
-      def tail!(&block)
+      def tail!(options = {}, &block)
         lines = []
         tail_cmdline = [ "heroku", "logs", "-p #{@pid}", "--tail", @app ? "--app #{@app}" : nil ].compact.join(" ")
-        previous_line = nil # delay by 1 to avoid rc=status line
+        previous_line = nil # delay by 1 to avoid rc=status lines
         Heroku::Executor.run tail_cmdline, { :logger => logger } do |line|
+          line ||= ""
           # remove any ANSI output
           line = line.gsub /\e\[(\d+)m/, ''
           # lines are returned as [date/time] app/heroku[pid]: output
-          line = line.split("[#{@pid}]:")[-1].strip
+          if (line_after_prefix = line.split("[#{@pid}]:")[-1])
+            line = line_after_prefix.strip
+          end
           if line.match(/Starting process with command/) || line.match(/State changed from \w+ to up/)
             # ignore
           elsif line.match(/State changed from \w+ to complete/) || line.match(/Process exited with status \d+/)
-            terminate_executor!
+            terminate_executor!(options[:tail_timeout] || 5)
           else
             if block_given?
               yield previous_line if previous_line
@@ -106,8 +107,8 @@ module Heroku
         lines
       end
 
-      def terminate_executor!
-        raise Heroku::Executor::Terminate
+      def terminate_executor!(timeout = 10)
+        raise Heroku::Executor::Terminate.new(timeout)
       end
 
   end

data/spec/heroku/commander_spec.rb

@@ -73,8 +73,48 @@ describe Heroku::Commander do
           "2013-01-31T01:39:33+00:00 heroku[run.8748]: Process exited with status 0",
           "2013-01-31T01:39:33+00:00 heroku[run.8748]: State changed from up to complete"
         ])
-      Heroku::Runner.any_instance.should_receive(:terminate_executor!).twice
-      subject.run("ls -1", { :detached => true }).should == [ "bin", "app" ]
+      Heroku::Runner.any_instance.should_receive(:terminate_executor!).with(42).twice
+      subject.run("ls -1", { :detached => true, :tail_timeout => 42 }).should == [ "bin", "app" ]
+    end
+  end
+  context "processes" do
+    context "without processes" do
+      before :each do
+        Heroku::Executor.stub(:run).with("heroku ps", { :logger => nil })
+      end
+      its(:processes) { should be_empty }
+    end
+    context "a web process" do
+      before :each do
+        Heroku::Executor.stub(:run).with("heroku ps", { :logger => nil }).
+          and_yield("=== web: `bundle exec ruby config.ru`").
+          and_yield("web.1: idle 2013/02/04 13:23:40 (~ 4h ago)")
+      end
+      its(:processes) { should_not be_empty }
+      it "has correct pid and status" do
+        processes = subject.processes
+        processes.count.should == 1
+        process = processes.first
+        process.pid.should eq "web.1"
+        process.status.should eq "idle"
+      end
+    end
+    context "a combination of one-off and web processes" do
+      before :each do
+        Heroku::Executor.stub(:run).with("heroku ps", { :logger => nil }).
+          and_yield("=== run: one-off processes").
+          and_yield("run.9174: up 2013/02/04 17:37:37 (~ 9m ago): `bundle exec rails console`").
+          and_yield(nil).
+          and_yield("").
+          and_yield("=== web: `bundle exec ruby config.ru`").
+          and_yield("web.1: up 2013/02/04 11:14:53 (~ 6h ago)").
+          and_yield("web.2: up 2013/02/04 11:14:17 (~ 6h ago)")
+      end
+      it "has correct pid and status" do
+        processes = subject.processes
+        processes.count.should == 3
+        processes.map(&:pid).should == [ "run.9174", "web.1", "web.2" ]
+      end
     end
   end
 end

data/spec/heroku/executor_spec.rb

@@ -7,7 +7,15 @@ describe Heroku::Executor do
   end
   context "command does not exist" do
     subject { lambda { Heroku::Executor.run "executor_spec.rb" } }
-    it { should raise_error Heroku::Commander::Errors::CommandError, /The command `executor_spec.rb` failed with exit status \d+./ }
+    it { should raise_error Heroku::Commander::Errors::CommandError, /The command `executor_spec.rb`(.*)failed with exit status \d+./ }
+  end
+  context "command does not return exit status" do
+    before do
+      PTY.stub(:spawn).and_raise("foobar!")
+      Process::Status.any_instance.stub(:exitstatus).and_return(nil)
+    end
+    subject { lambda { Heroku::Executor.run "executor_spec.rb" } }
+    it { should raise_error Heroku::Commander::Errors::CommandError, /The command `executor_spec.rb` failed without reporting an exit status./ }
   end
   context "command exists" do
     subject { lambda { Heroku::Executor.run "ls -1" } }
@@ -25,7 +33,8 @@ describe Heroku::Executor do
     it "doesn't yield nil lines" do
       r = double(IO)
       r.stub(:sync=)
-      r.stub(:each).and_yield("line1").and_yield(nil).and_yield("rc=0")
+      r.stub(:eof).and_return(false, false, false, true)
+      r.stub(:readline).and_return("line1", nil, "rc=0")
       Process.stub(:wait)
       PTY.stub(:spawn).and_yield(r, nil, 42)
       Heroku::Executor.run("foobar").should == [ "line1", nil, "rc=0" ]

data/spec/heroku/process_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Heroku::Process do
+  context "without pid" do
+    subject { lambda { Heroku::Process.new } }
+    it { should raise_error Heroku::Commander::Errors::MissingPidError, /Missing pid./ }
+  end
+  context "with pid" do
+    subject do
+      Heroku::Process.new({ :pid => "run.1234", :status => "idle" })
+    end
+    its(:pid) { should eq "run.1234" }
+    its(:status) { should eq "idle" }
+    context "refresh_status!" do
+      before do
+        Heroku::Executor.stub(:run).with("heroku ps", { :logger => nil }).
+          and_yield("run.1234: up for ~ 1m")
+        subject.refresh_status!
+      end
+      its(:status) { should eq "up" }
+    end
+  end
+end
+

data/spec/heroku/runner_spec.rb

@@ -17,14 +17,29 @@ describe Heroku::Runner do
     its(:command) { should eq "ls -1" }
     its(:cmdline) { should eq "heroku run \"(ls -1 2>&1 ; echo rc=\\$?)\"" }
     its(:running?) { should be_false }
+    context "check_pid" do
+      it "parses up, run.1234" do
+        subject.send(:check_pid, "up, run.1234")
+        subject.pid.should == "run.1234"
+      end
+      it "parses attached to terminal ... up, run.1234" do
+        subject.send(:check_pid, "parses attached to terminal ... up, run.1234")
+        subject.pid.should == "run.1234"
+      end
+      it "parses detached ... up, run.1234" do
+        subject.send(:check_pid, "detached ... up, run.1234")
+        subject.pid.should == "run.1234"
+      end
+    end
     context "run!" do
       before :each do
         Heroku::Executor.stub(:run).with(subject.send(:cmdline), { :logger => nil }).
-          and_yield("Running `...` attached to terminal... up, run.9783").
+          and_yield("Running `...`").
+          and_yield("attached to terminal... up, run.9783").
           and_yield("app").
           and_yield("bin").
           and_yield("rc= 0").
-          and_return([ "Running `...` attached to terminal... up, run.9783", "app", "bin", "rc=0" ])
+          and_return([ "Running `...`", "attached to terminal... up, run.9783", "app", "bin", "rc=0" ])
       end
       it "runs the command w/o a block" do
         subject.run!.should == [ "app", "bin" ]
@@ -59,6 +74,7 @@ describe Heroku::Runner do
           and_yield("2013-01-31T01:39:30+00:00 heroku[run.8748]: Starting process with command `ls -1`").
           and_yield("2013-01-31T01:39:31+00:00 app[run.8748]: bin").
           and_yield("2013-01-31T01:39:31+00:00 app[run.8748]: app").
+          and_yield(nil).
           and_yield("2013-01-31T00:56:13+00:00 app[run.8748]: rc=0").
           and_yield("2013-01-31T01:39:33+00:00 heroku[run.8748]: Process exited with status 0").
           and_yield("2013-01-31T01:39:33+00:00 heroku[run.8748]: State changed from up to complete").
@@ -73,7 +89,7 @@ describe Heroku::Runner do
         Heroku::Runner.any_instance.should_receive(:terminate_executor!).twice
       end
       it "runs the command w/o a block" do
-        subject.run!({ :detached => true }).should == [ "bin", "app" ]
+        subject.run!({ :detached => true }).should == [ "bin", "app", "" ]
         subject.pid.should == "run.8748"
         subject.should_not be_running
       end
@@ -82,7 +98,7 @@ describe Heroku::Runner do
         subject.run!({ :detached => true }).each do |line|
           lines << line
         end
-        lines.should == [ "bin", "app" ]
+        lines.should == [ "bin", "app", "" ]
         subject.pid.should == "run.8748"
         subject.should_not be_running
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heroku-commander
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-02 00:00:00.000000000 Z
+date: 2013-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -43,7 +43,9 @@ files:
 - README.md
 - Rakefile
 - assets/heroku-commander.png
+- examples/executor-run.rb
 - examples/heroku-config.rb
+- examples/heroku-processes.rb
 - examples/heroku-run-detached.rb
 - examples/heroku-run.rb
 - heroku-commander.gemspec
@@ -56,16 +58,20 @@ files:
 - lib/heroku/commander/errors/client_eio_error.rb
 - lib/heroku/commander/errors/command_error.rb
 - lib/heroku/commander/errors/missing_command_error.rb
+- lib/heroku/commander/errors/missing_pid_error.rb
+- lib/heroku/commander/errors/no_such_process_error.rb
 - lib/heroku/commander/errors/unexpected_output_error.rb
 - lib/heroku/commander/version.rb
 - lib/heroku/config.rb
 - lib/heroku/executor.rb
+- lib/heroku/process.rb
 - lib/heroku/pty.rb
 - lib/heroku/runner.rb
 - lib/heroku_commander.rb
 - spec/heroku/commander_spec.rb
 - spec/heroku/config_spec.rb
 - spec/heroku/executor_spec.rb
+- spec/heroku/process_spec.rb
 - spec/heroku/runner_spec.rb
 - spec/heroku/version_spec.rb
 - spec/spec_helper.rb
@@ -84,7 +90,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 155166833
+      hash: -3503047870647109606
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -93,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Control Heroku from Ruby via its `heroku` shell command.