heroku_hatchet 6.0.0 → 7.0.0

data/lib/hatchet/reaper/app_age.rb

@@ -0,0 +1,49 @@
+module Hatchet
+  class Reaper
+    # Class for figuring out how old a given time is relative to another time
+    #
+    # Expects inputs as a DateTime instance
+    #
+    # Example:
+    #
+    #   time_now = DateTime.parse("2020-07-28T14:40:00Z")
+    #   age = AppAge.new(created_at: DateTIme.parse("2020-07-28T14:40:00Z"), time_now: time_now, ttl_minutes: 1)
+    #   age.in_minutes => 0.0
+    #   age.too_young_to_die? # => true
+    #   age.can_delete? # => false
+    #   age.sleep_for_ttl #=> 60
+    class AppAge
+      SECONDS_IN_A_DAY = 24 * 60 * 60
+
+      attr_reader :ttl_minutes
+
+      def initialize(created_at:, ttl_minutes:, time_now: DateTime.now.new_offset(0))
+        @seconds_ago = date_time_diff_in_seconds(time_now, created_at)
+        @ttl_minutes = ttl_minutes
+        @ttl_seconds = ttl_minutes * 60
+      end
+
+      def date_time_diff_in_seconds(now, whence)
+        (now - whence) * SECONDS_IN_A_DAY
+      end
+
+      def too_young_to_die?
+        !can_delete?
+      end
+
+      def can_delete?
+        @seconds_ago > @ttl_seconds
+      end
+
+      def sleep_for_ttl
+        return 0 if can_delete?
+
+        @ttl_seconds - @seconds_ago
+      end
+
+      def in_minutes
+        (@seconds_ago / 60.0).round(2)
+      end
+    end
+  end
+end

data/lib/hatchet/reaper/reaper_throttle.rb

@@ -0,0 +1,55 @@
+module Hatchet
+  class Reaper
+    # This class retains and increments a sleep value between executions
+    #
+    # Every time we pause, we increase the duration of the pause 2x. If we
+    # do not sleep for long enough then we will burn API requests that we don't need to make.
+    #
+    # To help prevent sleeping for too long, the reaper will sleep for a maximum amount of time
+    # equal to the age_sleep_for_ttl. If that happens, it's likely a fairly large value and the
+    # internal incremental value can be reset
+    #
+    # Example:
+    #
+    #   reaper_throttle = ReaperThrottle.new(initial_sleep: 2)
+    #   reaper_throttle.call(max_sleep: 5) do |sleep_for|
+    #     puts sleep_for # => 2
+    #   end
+    #   reaper_throttle.call(max_sleep: 5) do |sleep_for|
+    #     puts sleep_for # => 4
+    #   end
+    #   reaper_throttle.call(max_sleep: 5) do |sleep_for|
+    #     puts sleep_for # => 5
+    #   end
+    #
+    #   # The throttle is now reset since it hit the max_sleep value
+    #
+    #   reaper_throttle.call(max_sleep: 5) do |sleep_for|
+    #     puts sleep_for # => 2
+    #   end
+    class ReaperThrottle
+      def initialize(initial_sleep: )
+        @initial_sleep = initial_sleep
+        @sleep_for = @initial_sleep
+      end
+
+      def call(max_sleep: )
+        raise "Must call with a block" unless block_given?
+
+        sleep_for = [@sleep_for, max_sleep].min
+
+        yield sleep_for
+
+        if sleep_for < @sleep_for
+          reset!
+        else
+          @sleep_for *= 2
+        end
+      end
+
+      def reset!
+        @sleep_for = @initial_sleep
+      end
+    end
+  end
+end

data/lib/hatchet/shell_throttle.rb

@@ -0,0 +1,71 @@
+module Hatchet
+  # A class for throttling non-http resources
+  #
+  # Non-http calls can be rate-limited for example shell calls to `heroku run ` and `git push heroku`
+  # this class provides an easy interface to leverage the rate throttling behavior baked into `PlatformAPI`
+  # for calls things that do not have a real associated web request
+  #
+  # Example:
+  #
+  #   output = ""
+  #   ShellThrottle.new(platform_api: @platform_api).call
+  #     output = `git push heroku main`
+  #     throw(:throttle) if output.match?(/reached the API rate limit/)
+  #   end
+  #   puts output
+  #
+  # In this example `git push heroku main` will retry and backoff until the output no longer matches `reached the API rate limit`.
+  #
+  class ShellThrottle
+    def initialize(platform_api: )
+      @platform_api = platform_api
+    end
+
+    def call
+      out = nil
+      PlatformAPI.rate_throttle.call do
+        catch(:throttle) do
+          out = yield
+          return
+        end
+
+        try_again
+      end
+      return out
+    end
+
+    private def success
+      FakeResponse.new(status: 200, remaining: remaining)
+    end
+
+    private def try_again
+      FakeResponse.new(status: 429, remaining: remaining)
+    end
+
+    private def remaining
+      @platform_api.rate_limit.info["remaining"]
+    end
+
+
+    # Helper class to be used along with the PlatformAPI.rate_throttle interface
+    # that expects a response object
+    #
+    # Example:
+    #
+    #   FakeResponse.new(status: 200, remaining: 2).status #=> 200
+    #   FakeResponse.new(status: 200, remaining: 2).headers["RateLimit-Remaining"] #=> 2
+    class FakeResponse
+      attr_reader :status, :headers
+
+      def initialize(status:, remaining: )
+        @status = status
+
+        @headers = {
+          "RateLimit-Remaining" => remaining,
+          "RateLimit-Multiplier" => 1,
+          "Content-Type" => "text/plain".freeze
+        }
+      end
+    end
+  end
+end

data/lib/hatchet/test_run.rb

@@ -218,12 +218,13 @@ module Hatchet
         "Content-Type"  => "application/json"
       }.merge(options[:headers] || {})
       options[:body] = JSON.generate(options[:body]) if options[:body]
+      options[:expects] << 429 if options[:expects]
 
       Hatchet::RETRIES.times.retry do
         PlatformAPI.rate_throttle.call do
           connection = Excon.new("https://api.heroku.com")
 
-          return connection.request(options)
+          connection.request(options)
         end
       end
     end

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "6.0.0"
+  VERSION = "7.0.0"
 end

data/spec/hatchet/allow_failure_git_spec.rb

@@ -1,15 +1,40 @@
 require("spec_helper")
 
 describe "AllowFailureGitTest" do
+  describe "release failures" do
+    let(:release_fail_proc) {
+      Proc.new do
+        File.open("Procfile", "w+") do |f|
+          f.write <<~EOM
+            release: echo "failing on release" && exit 1
+          EOM
+        end
+      end
+    }
+
+    it "is marked as a failure if the release fails" do
+      expect {
+        Hatchet::GitApp.new("default_ruby", before_deploy: release_fail_proc).deploy {}
+      }.to(raise_error(Hatchet::App::FailedReleaseError))
+    end
+
+    it "works when failure is allowed" do
+      Hatchet::GitApp.new("default_ruby", before_deploy: release_fail_proc, allow_failure: true).deploy do |app|
+        expect(app.output).to match("failing on release")
+      end
+    end
+  end
+
   it "allowed failure" do
     Hatchet::GitApp.new("no_lockfile", allow_failure: true).deploy do |app|
-      puts app.output
       expect(app.deployed?).to be_falsey
       expect(app.output).to match("Gemfile.lock required")
     end
   end
 
   it "failure with no flag" do
-    expect { Hatchet::GitApp.new("no_lockfile").deploy }.to(raise_error(Hatchet::App::FailedDeploy))
+    expect {
+      Hatchet::GitApp.new("no_lockfile").deploy {}
+    }.to(raise_error(Hatchet::App::FailedDeploy))
   end
 end

data/spec/hatchet/app_spec.rb

@@ -1,6 +1,42 @@
 require("spec_helper")
 
 describe "AppTest" do
+  it "rate throttles `git push` " do
+    app = Hatchet::GitApp.new("default_ruby")
+    def app.git_push_heroku_yall
+      @_git_push_heroku_yall_call_count ||= 0
+      @_git_push_heroku_yall_call_count += 1
+      if @_git_push_heroku_yall_call_count >= 2
+        "Success"
+      else
+        raise Hatchet::App::FailedDeployError.new(self, "message", output: "Your account reached the API rate limit Please wait a few minutes before making new requests")
+      end
+    end
+
+    def app.sleep_called?; @sleep_called; end
+
+    def app.what_is_git_push_heroku_yall_call_count; @_git_push_heroku_yall_call_count; end
+    app.push_without_retry!
+
+    expect(app.what_is_git_push_heroku_yall_call_count).to be(2)
+  end
+
+  it "calls reaper if cannot create an app" do
+    app = Hatchet::App.new("default_ruby", buildpacks: [:default])
+    def app.heroku_api_create_app(*args); raise StandardError.new("made you look"); end
+
+    reaper = app.reaper
+
+    def reaper.cycle(app_exception_message: ); @app_exception_message = app_exception_message; end
+    def reaper.recorded_app_exception_message; @app_exception_message; end
+
+    expect {
+      app.create_app
+    }.to raise_error("made you look")
+
+    expect(reaper.recorded_app_exception_message).to match("made you look")
+  end
+
   it "app with default" do
     app = Hatchet::App.new("default_ruby", buildpacks: [:default])
     expect(app.buildpacks.first).to match("https://github.com/heroku/heroku-buildpack-ruby")
@@ -13,6 +49,37 @@ describe "AppTest" do
     expect(app.platform_api.app.info(app.name)["build_stack"]["name"]).to eq(stack)
   end
 
+  it "marks itself 'finished' when done in block mode" do
+    app = Hatchet::Runner.new("default_ruby")
+
+    def app.push_with_retry!; nil; end
+    app.deploy do |app|
+      expect(app.platform_api.app.info(app.name)["maintenance"]).to be_falsey
+    end
+
+    # After the app is updated, there's no guarantee it will still exist
+    # so we cannot rely on an api call to determine maintenance mode
+    app_update_info = app.instance_variable_get(:"@app_update_info")
+    expect(app_update_info["name"]).to eq(app.name)
+    expect(app_update_info["maintenance"]).to be_truthy
+  end
+
+  it "marks itself 'finished' when done in non-block mode" do
+    app = Hatchet::Runner.new("default_ruby")
+
+    def app.push_with_retry!; nil; end
+    app.deploy
+    expect(app.platform_api.app.info(app.name)["maintenance"]).to be_falsey
+
+    app.teardown!
+
+    # After the app is updated, there's no guarantee it will still exist
+    # so we cannot rely on an api call to determine maintenance mode
+    app_update_info = app.instance_variable_get(:"@app_update_info")
+    expect(app_update_info["name"]).to eq(app.name)
+    expect(app_update_info["maintenance"]).to be_truthy
+  end
+
   it "before deploy" do
     @called = false
     @dir = false
@@ -65,23 +132,95 @@ describe "AppTest" do
   end
 
   it "run" do
-    app = Hatchet::GitApp.new("default_ruby")
+    skip("Must set HATCHET_EXPENSIVE_MODE") unless ENV["HATCHET_EXPENSIVE_MODE"]
+
+    app = Hatchet::GitApp.new("default_ruby", run_multi: true)
     app.deploy do
       expect(app.run("ls -a Gemfile 'foo bar #baz'")).to match(/ls: cannot access 'foo bar #baz': No such file or directory\s+Gemfile/)
       expect((0 != $?.exitstatus)).to be_truthy
-      sleep(4)
+
       app.run("ls erpderp", heroku: ({ "exit-code" => (Hatchet::App::SkipDefaultOption) }))
       expect((0 == $?.exitstatus)).to be_truthy
-      sleep(4)
+
       app.run("ls erpderp", heroku: ({ "no-tty" => nil }))
       expect((0 != $?.exitstatus)).to be_truthy
-      sleep(4)
+
       expect(app.run("echo \\$HELLO \\$NAME", raw: true, heroku: ({ "env" => "HELLO=ohai;NAME=world" }))).to match(/ohai world/)
-      sleep(4)
+
       expect(app.run("echo \\$HELLO \\$NAME", raw: true, heroku: ({ "env" => "" }))).to_not match(/ohai world/)
-      sleep(4)
+
       random_name = SecureRandom.hex
       expect(app.run("mkdir foo; touch foo/#{random_name}; ls foo/")).to match(/#{random_name}/)
     end
   end
+
+  class AtomicCount
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+      @mutex = Mutex.new
+    end
+
+    # In MRI the `+=` is not atomic, it is two seperate virtual machine
+    # instructions. To protect against race conditions, we can lock with a mutex
+    def add(val)
+      @mutex.synchronize do
+        @value += val
+      end
+    end
+  end
+
+  it "run multi" do
+    skip("Must set HATCHET_EXPENSIVE_MODE") unless ENV["HATCHET_EXPENSIVE_MODE"]
+
+    @run_count = AtomicCount.new(0)
+    app = Hatchet::GitApp.new("default_ruby", run_multi: true)
+    app.deploy do
+      app.run_multi("ls") { |out| expect(out).to include("Gemfile"); @run_count.add(1) }
+      app.run_multi("blerg -v") { |_, status| expect(status.success?).to be_falsey; @run_count.add(1) }
+      app.run_multi("ruby -v") do |out, status|
+        expect(out).to include("ruby")
+        expect(status.success?).to be_truthy
+
+        @run_count.add(1)
+      end
+
+      expect(app.platform_api.formation.list(app.name).detect {|ps| ps["type"] == "web"}["size"].downcase).to_not eq("free")
+    end
+
+    # After the deploy block exits `teardown!` is called
+    # this ensures all `run_multi` commands have exited and the dyno should be scaled down
+    expect(@run_count.value).to eq(3)
+  end
+
+  describe "running concurrent tests in different examples works" do
+    # This is not a great pattern if we're running tests via a parallel runner
+    #
+    # For example this will be guaranteed to be called, not just once, but at least once for every process
+    # that needs to run a test. In the best case it will only fire once, in the worst case it will fire N times
+    # if there are N tests. It is effectively the same as a `before(:each)`
+    #
+    # Documented here: https://github.com/grosser/parallel_split_test/pull/22/files
+    before(:all) do
+      skip("Must set HATCHET_EXPENSIVE_MODE") unless ENV["HATCHET_EXPENSIVE_MODE"]
+
+      @app = Hatchet::GitApp.new("default_ruby", run_multi: true)
+      @app.deploy
+    end
+
+    after(:all) do
+      @app.teardown! if @app
+    end
+
+    it "test one" do
+      expect(@app.run("ls")).to include("Gemfile")
+      expect(@app.platform_api.formation.list(@app.name).detect {|ps| ps["type"] == "web"}["size"].downcase).to_not eq("free")
+    end
+
+    it "test two" do
+      expect(@app.run("ruby -v")).to include("ruby")
+      expect(@app.platform_api.formation.list(@app.name).detect {|ps| ps["type"] == "web"}["size"].downcase).to_not eq("free")
+    end
+  end
 end

data/spec/hatchet/ci_spec.rb

@@ -4,7 +4,8 @@ describe "CIFourTest" do
   it "error with bad app" do
     string = SecureRandom.hex
 
-    Hatchet::GitApp.new("default_ruby").run_ci do |test_run|
+    app = Hatchet::GitApp.new("default_ruby")
+    app.run_ci do |test_run|
       expect(test_run.output).to_not match(string)
       expect(test_run.output).to match("Installing rake")
 
@@ -14,7 +15,15 @@ describe "CIFourTest" do
       expect(test_run.output).to match(string)
       expect(test_run.output).to match("Using rake")
       expect(test_run.output).to_not match("Installing rake")
+
+      expect(app.platform_api.app.info(app.name)["maintenance"]).to be_falsey
     end
+
+    # After the app is updated, there's no guarantee it will still exist
+    # so we cannot rely on an api call to determine maintenance mode
+    app_update_info = app.instance_variable_get(:"@app_update_info")
+    expect(app_update_info["name"]).to eq(app.name)
+    expect(app_update_info["maintenance"]).to be_truthy
   end
 
   it "error with bad app" do