heroku-commander 0.2.0 → 0.3.0

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+0.3.0 (04/15/2013)
+==================
+* Fixed an infinite loop in the tail restart method used by `Heroku::Commander.run` with `detached: true` - [@macreery](https://github.com/macreery).
+* The `Heroku::Commander.run` with `detached: true` will now restart the tail process when aborted without having received a process exit message - [@dblock](https://github.com/dblock).
+* Added a `tail_retries` that defines the maximum number of tail restarts, default is 3 - [@dblock](https://github.com/dblock).
+* Added a `size` option to `Heroku::Runner` and `Heroku::Commander.run`, supporting `2X` dynos - [@dblock](https://github.com/dblock).
+
 0.2.0 (02/14/2013)
 ==================
 

data/README.md

@@ -47,6 +47,12 @@ commander = Heroku::Commander.new({ :app => "heroku-commander" })
 commander.run "uname -a" # => [ "Linux 2.6.32-348-ec2 #54-Ubuntu SMP x86_64 GNU" ]
 ```
 
+You can specify the dyno size with `size`.
+
+``` ruby
+commander.run "uname -a", { size: "2X" }
+```
+
 Heroku Detached Run
 -------------------
 
@@ -67,7 +73,9 @@ 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).
+* **size**: dyno size, eg. `2X` for double-dynos.
+* **tail_timeout**: number of seconds to wait before terminating `heroku logs --tail`, expecting more output (defaults to 5).
+* **tail_retries**: number of times to restart the tail process on error (defaults to 3).
 
 For more information about Heroku one-off dynos see [this documentation](https://devcenter.heroku.com/articles/one-off-dynos).
 

data/examples/heroku-run.rb

@@ -7,7 +7,7 @@ logger = Logger.new($stdout)
 logger.level = Logger::DEBUG
 commander = Heroku::Commander.new({ :logger => logger })
 
-uname = commander.run "uname -a"
+uname = commander.run "uname -a", { :size => "2X" }
 logger.info "Heroku dyno is a #{uname.join('\n')}."
 
 files = []

data/lib/config/locales/en.yml

@@ -33,3 +33,7 @@ en:
             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."
+          invalid_option:
+            message: "Invalid option `%{name}`."
+            summary: "The value of the option is invalid: `%{value}`. Must be %{range}."
+            resolution: "Refer to the documentation for acceptable values."

data/lib/heroku/commander.rb

@@ -34,7 +34,8 @@ module Heroku
 
     # Run a process synchronously
     def run(command, options = {}, &block)
-      runner = Heroku::Runner.new({ :app => app, :logger => logger, :command => command })
+      size = options.delete(:size) if options
+      runner = Heroku::Runner.new({ :app => app, :logger => logger, :command => command, size: size })
       runner.run!(options, &block)
     end
 

data/lib/heroku/commander/errors.rb

@@ -6,3 +6,4 @@ 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'
+require 'heroku/commander/errors/invalid_option_error'

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

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

data/lib/heroku/commander/version.rb

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

data/lib/heroku/runner.rb

@@ -1,13 +1,14 @@
 module Heroku
   class Runner
 
-    attr_accessor :app, :logger, :command
+    attr_accessor :app, :logger, :command, :size
     attr_reader :pid, :running, :tail
 
     def initialize(options = {})
       @app = options[:app]
       @logger = options[:logger]
       @command = options[:command]
+      @size = options[:size]
       raise Heroku::Commander::Errors::MissingCommandError unless @command
     end
 
@@ -58,7 +59,12 @@ module Heroku
       end
 
       def cmdline(options = {})
-        [ "heroku", options[:detached] ? "run:detached" : "run", "\"(#{command} 2>&1 ; echo rc=\\$?)\"", @app ? "--app #{@app}" : nil ].compact.join(" ")
+        [
+          "heroku", options[:detached] ? "run:detached" : "run",
+          @size ? "--size #{@size}" : nil,
+          "\"(#{command} 2>&1 ; echo rc=\\$?)\"",
+          @app ? "--app #{@app}" : nil
+        ].compact.join(" ")
       end
 
       def check_exit_status!(lines)
@@ -84,24 +90,61 @@ module Heroku
         lines = []
         tail_cmdline = [ "heroku", "logs", "-p #{@pid}", "--tail", @app ? "--app #{@app}" : nil ].compact.join(" ")
         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
-          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!(options[:tail_timeout] || 5)
-          else
-            if block_given?
-              yield previous_line if previous_line
-              previous_line = line
+        process_completed = false
+        # tail retries
+        tail_retries_left = (options[:tail_retries] || 3).to_i
+        if tail_retries_left < 0
+          raise Heroku::Commander::Errors::InvalidOptionError.new({
+            :name => "tail_retries",
+            :value => options[:tail_retries],
+            :range => "greater or equal to 0"
+          })
+        end
+        # tail timeout
+        tail_timeout = (options[:tail_timeout] || 5).to_i
+        if tail_timeout < 0
+          raise Heroku::Commander::Errors::InvalidOptionError.new({
+            :name => "tail_timeout",
+            :value => options[:tail_timeout],
+            :range => "greater or equal to 0"
+          })
+        end
+        # tail
+        process_completed = false
+        while ! process_completed
+          tail_retries_left -= 1
+          begin
+            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
+              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+/)
+                process_completed = true
+                terminate_executor!(options[:tail_timeout] || 5)
+              else
+                if block_given?
+                  yield previous_line if previous_line
+                  previous_line = line
+                end
+                lines << line
+              end
+            end
+          rescue
+            @running = false
+            raise if tail_retries_left <= 0
+          ensure
+            if tail_retries_left <= 0
+              @running = false
+              raise
+            elsif !process_completed
+              logger.debug "Restarting #{tail_cmdline}, #{tail_retries_left} #{tail_retries_left == 1 ? 'retry' : 'retries'} left." if logger
             end
-            lines << line
           end
         end
         lines

data/spec/heroku/commander_spec.rb

@@ -76,6 +76,15 @@ describe Heroku::Commander do
       Heroku::Runner.any_instance.should_receive(:terminate_executor!).with(42).twice
       subject.run("ls -1", { :detached => true, :tail_timeout => 42 }).should == [ "bin", "app" ]
     end
+    it "passes size option" do
+      Heroku::Executor.stub(:run).with("heroku run --size 2X \"(ls -1 2>&1 ; echo rc=\\$?)\"", { :logger => nil }).
+        and_yield("Running `...` attached to terminal... up, run.1234").
+        and_yield("app").
+        and_yield("bin").
+        and_yield("rc=0").
+        and_return([ "Running `...` attached to terminal... up, run.1234", "app", "bin", "rc=0" ])
+      subject.run("ls -1", { size: "2X" }).should == [ "app", "bin" ]
+    end
   end
   context "processes" do
     context "without processes" do

data/spec/heroku/runner_spec.rb

@@ -103,6 +103,88 @@ describe Heroku::Runner do
         subject.should_not be_running
       end
     end
+    context "tail_retries" do
+      before :each do
+        Heroku::Executor.stub(:run).with(subject.send(:cmdline, { :detached => true }), { :logger => nil }).
+          and_yield("Running `ls -1` detached... up, run.8748").
+          and_yield("Use `heroku logs -p run.8748` to view the output.").
+          and_yield("rc=0").
+          and_return([ "Running `ls -1` detached... up, run.8748", "Use `heroku logs -p run.8748` to view the output.", "rc=0" ])
+        # first iteration
+        Heroku::Executor.should_receive(:run).with("heroku logs -p run.8748 --tail", { :logger => nil }).
+          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_return([
+            "2013-01-31T01:39:30+00:00 heroku[run.8748]: Starting process with command `ls -1`",
+            "2013-01-31T01:39:31+00:00 app[run.8748]: bin",
+          ])
+      end
+      context "with a successful second iteration" do
+        before :each do
+          # second iteration
+          Heroku::Executor.should_receive(:run).with("heroku logs -p run.8748 --tail", { :logger => nil }).
+            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").
+            and_return([
+              "2013-01-31T01:39:31+00:00 app[run.8748]: app",
+              "2013-01-31T00:56:13+00:00 app[run.8748]: rc=0",
+              "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
+        end
+        it "restarts tailer" do
+          lines = []
+          subject.run!({ :detached => true }).each do |line|
+            lines << line
+          end
+          lines.should == [ "bin", "app", "" ]
+          subject.pid.should == "run.8748"
+          subject.should_not be_running
+        end
+      end
+      context "with a caught exception on second iteration" do
+        before :each do
+          # second iteration that raises a caught exception
+          Heroku::Executor.should_receive(:run).exactly(2).times.with("heroku logs -p run.8748 --tail", { :logger => nil }).
+            and_return(nil)
+        end
+        it "raises exception" do
+          lines = []
+          expect {
+            subject.run!({ :detached => true }).each do |line|
+              lines << line
+            end
+          }.to raise_error RuntimeError
+          subject.should_not be_running
+        end
+      end
+    end
+    context "options" do
+      before :each do
+        Heroku::Executor.stub(:run).
+          and_yield("Running `ls -1` detached... up, run.8748").
+          and_return([])
+      end
+      it "raises an error for an invalid tail_timeout option" do
+        expect {
+          subject.run!({ :detached => true, :tail_timeout => -1 })
+        }.to raise_error Heroku::Commander::Errors::InvalidOptionError, /Invalid option `tail_timeout`./
+      end
+      it "raises an error for an invalid tail_retries option" do
+        expect {
+          subject.run!({ :detached => true, :tail_retries => -1 })
+        }.to raise_error Heroku::Commander::Errors::InvalidOptionError, /Invalid option `tail_retries`./
+      end
+    end
+  end
+  context "with size" do
+    subject do
+      Heroku::Runner.new({ :command => "ls -1", size: "2X" })
+    end
+    its(:cmdline) { should eq "heroku run --size 2X \"(ls -1 2>&1 ; echo rc=\\$?)\"" }
   end
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heroku-commander
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -57,6 +57,7 @@ files:
 - lib/heroku/commander/errors/base.rb
 - lib/heroku/commander/errors/client_eio_error.rb
 - lib/heroku/commander/errors/command_error.rb
+- lib/heroku/commander/errors/invalid_option_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
@@ -90,7 +91,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3503047870647109606
+      hash: 3343082937396916843
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: