heroku_hatchet 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf055d51d17efef64a57f9d7cc5ba0efdfe29b3a
-  data.tar.gz: b51a1720cf9e6eebf7d0280ebca26efe68f431ac
+  metadata.gz: 7f6fe23a7e5a091233694be4bc546232d45b13fe
+  data.tar.gz: 4c161fbcb5e7b5140b6025caa6a1b511635617c1
 SHA512:
-  metadata.gz: 57a539206481a90f0118242f5af0587fd448abaf45dbcedf2fdf3be6e998d78d22feea5f80e7d7a5f4b652f167ea5467cfffdbbe6020e9b93686c1b1fa3c9000
-  data.tar.gz: 0af1e3c1a8c9a957d6dab4b987da269fef9a69c44adcebc647f4e8ee4965c184472c506ed0bb9e1516dc5ac33692d5335202d35f14bcef2d547ea361d3d19c91
+  metadata.gz: 22409adecd80f6761593dd2f4cfb68696722903294cc08e7b5fb45183661d12e7b16ed1f67dd51a726c57e6249a9105a331ab9f0e1e3541a90c381384a1454ec
+  data.tar.gz: 1c95c1a1777355e891760054b1b75ec3cf4c70963271bd492cfc1beb9496e6e811e3e288650041a0ec0583a5c358266ac17b3060cce4f292efa0f0fb7580855b

data/.gitignore

@@ -4,3 +4,4 @@ test/fixtures/repos/*
 
 
 Gemfile.lock
+debug.rb

data/.travis.yml

@@ -3,8 +3,8 @@ language: ruby
 rvm:
 - 2.0.0
 before_script: bundle exec rake hatchet:setup_travis
-script: bundle exec parallel_test test/hatchet -n 6
-
+script: bundle exec parallel_test test/hatchet -n 9
+after_script: bundle exec rake hatchet:teardown_travis
 
 env:
   global:

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## HEAD
+
+
+## 0.2.0
+
+- Add database method App#add_database
+
+- Drastically improved reliability of `app.run` outputs.
+
+- Add `rake hatchet:teardown_travis` task to put in `travis.yml`:
+
+    after_script: bundle exec rake hatchet:teardown_travis
+
+
 ## 0.1.1
 
 - Allow auto retries of pushes by setting environment variable `HATCHET_RETRIES=3`

data/lib/hatchet/app.rb

@@ -1,5 +1,4 @@
 module Hatchet
-  RETRIES = Integer(ENV['HATCHET_RETRIES'] || 1)
   class App
     attr_reader :name, :directory
 
@@ -28,6 +27,15 @@ module Hatchet
       self.class.config
     end
 
+
+  def add_database(db_name = 'heroku-postgresql:dev', match_val = "HEROKU_POSTGRESQL_[A-Z]+_URL")
+    Hatchet::RETRIES.times.retry do
+      heroku.post_addon(name, db_name)
+      _, value = heroku.get_config_vars(name).body.detect {|k, v| k.match(/#{match_val}/) }
+      heroku.put_config_vars(name, 'DATABASE_URL' => value)
+    end
+  end
+
     # runs a command on heroku similar to `$ heroku run #foo`
     # but programatically and with more control
     def run(command, timeout = nil, &block)

data/lib/hatchet/command_parser.rb

@@ -0,0 +1,39 @@
+# removes the commands from strings retrieved from stuff like `heroku run bash`
+# since likely you care about the output, not the input
+# this is especially useful for seeing if a given input command has finished running
+# if we cannot find a valid input command and output command return the full unparsed string
+module Hatchet
+  class CommandParser
+    attr_accessor :command
+
+    def initialize(command)
+      @command = command
+      @parsed_string = ""
+      @raw_string    = ""
+    end
+
+    def regex
+      /#{Regexp.quote(command)}\r*\n+/
+    end
+
+    def parse(string)
+      @raw_string    = string
+      @parsed_string = string.split(regex).last
+      return self
+    end
+
+    def to_s
+      @parsed_string || @raw_string
+    end
+
+    def missing_valid_output?
+      !has_valid_output?
+    end
+
+    def has_valid_output?
+      return false unless @raw_string.match(regex)
+      return false if @parsed_string.blank? || @parsed_string.strip.blank?
+      true
+    end
+  end
+end

data/lib/hatchet/process_spawn.rb

@@ -3,18 +3,20 @@ module Hatchet
   # spawns a process on Heroku, and keeps it open for writing
   # like `heroku run bash`
   class ProcessSpawn
-    attr_reader :command, :app, :timeout
-
+    attr_reader :command, :app, :timeout, :pid
     TIMEOUT = 60 # seconds to bring up a heroku command like `heroku run bash`
 
     def initialize(command, app, timeout = nil)
-      @command = command
-      @app     = app
-      @timeout = timeout || TIMEOUT
+      raise "need command" unless command.present?
+      raise "need app"     unless app.present?
+      @command        = "heroku run #{command} -a #{app.name}"
+      @ready_regex    = "^run.*up.*#{command}"
+      @app            = app
+      @timeout        = timeout || TIMEOUT
     end
 
     def ready?
-      @ready ||= `heroku ps -a #{app.name}`.match(/^run.*up.*#{command}/).present?
+      @ready ||= `heroku ps -a #{app.name}`.match(/#{@ready_regex}/).present?
     end
 
     def not_ready?
@@ -28,25 +30,38 @@ module Hatchet
       return true
     end
 
+    # some REPL's don't sync standard out by default
+    # try to do it auto-magically
+    def repl_magic(repl)
+      case command
+      when /rails\s*console/, /\sirb\s/
+        # puts "magic for: '#{command}'"
+        repl.run("STDOUT.sync = true")
+      end
+    end
+
     # Open up PTY (pseudo terminal) to command like `heroku run bash`
     # Wait for the dyno to deploy, then allow user to run arbitrary commands
-    #
-    def run(&block)
-      raise "need app"     unless app.present?
-      raise "need command" unless command.present?
-      heroku_command     = "heroku run #{command} -a #{app.name}"
-      return `#{heroku_command}` if block.blank? # one off command, no block given
-
-      output, input, pid = PTY.spawn(heroku_command)
-      stream = StreamExec.new(input, output)
+    def spawn_repl
+      output, input, pid = PTY.spawn(command)
+      stream = StreamExec.new(output, input, pid)
+      repl   = ReplRunner.new(stream)
       stream.timeout("waiting for spawn", timeout) do
         wait_for_spawn!
       end
       raise "Could not run: '#{command}', command took longer than #{timeout} seconds" unless self.ready?
-      yield stream
+
+      repl_magic(repl)
+      repl.wait_for_boot(5) # important to get rid of startup info i.e. "booting rails console ..."
+      return repl
+    end
+
+    def run(&block)
+      return `#{command}` if block.blank? # one off command, no block given
+
+      yield repl = spawn_repl
     ensure
-      stream.close                if stream.present?
-      Process.kill('TERM', pid)   if pid.present?
+      repl.close if repl.present?
     end
   end
 end

data/lib/hatchet/repl_runner.rb

@@ -0,0 +1,61 @@
+# takes a StringExec class and attempts to parse commands out of it
+module Hatchet
+  class ReplRunner
+    TIMEOUT = 1
+    RETRIES = 10
+
+    attr_accessor :repl
+
+    def initialize(repl, command_parser_klass = CommandParser)
+      @repl                 = repl
+      @command_parser_klass = command_parser_klass
+    end
+
+    def command_parser_klass
+      @command_parser_klass
+    end
+
+    # adds a newline cause thats what most repl-s need to run command
+    def write(cmd)
+      repl.write("#{cmd}\n")
+    end
+
+    def run(cmd, options = {})
+      timeout = options[:timeout] || TIMEOUT
+      retries = options[:retries] || RETRIES
+
+      write(cmd)
+      read(cmd, timeout, retries)
+    end
+
+    def wait_for_boot(timeout = 5)
+      repl.read(timeout)
+    end
+
+    def close
+      repl.close
+    end
+
+    # take in a command like "ls", and tries to find it in the output
+    # of the repl (StreamExec)
+    # Example
+    #  output, input, pid = PTY.spawn('sh')
+    #  stream             = StreamExec.new(output, input, pid)
+    #  repl_runner = ReplRunner.new(stream)
+    #  repl_runner.write("ls\n")
+    #  repl_runner.read
+    #     # => "app\tconfig.ru  Gemfile\t LICENSE.txt  public\t script  vendor\r\r\nbin\tdb\t   Gemfile.lock  log\t      Rakefile\t test\r\r\nconfig\tdoc\t   lib\t\t Procfile     README.md  tmp\r\r\n"
+    #
+    # if the command "ls" is not found, repl runner will continue to retry grabbing more output
+    def read(cmd, timeout = TIMEOUT, retries = RETRIES)
+      str = ""
+      command_parser = command_parser_klass.new(cmd)
+      retries.times.each do
+        next if command_parser.has_valid_output?
+        str << repl.read(timeout)
+        command_parser.parse(str)
+      end
+      return command_parser.to_s
+    end
+  end
+end

data/lib/hatchet/stream_exec.rb

@@ -1,19 +1,26 @@
 require 'timeout'
+
 module Hatchet
   # runs arbitrary commands within a Heroku process
   class StreamExec
-    attr_reader :input, :output
+    attr_reader :input, :output, :pid
     TIMEOUT = 1 # seconds to run an arbitrary command on a heroku process like `$ls`
 
-    def initialize(input, output)
+    def initialize(output, input, pid)
       @input  = input
       @output = output
+      @pid    = pid
+    end
+
+    def write(cmd)
+      input.write(cmd)
+    rescue Errno::EIO => e
+      raise e, "#{e.message} | trying to write '#{cmd}'"
     end
 
-    def run(cmd)
-      raise "command expected" if cmd.blank?
-      input.write("#{cmd}\n")
-      return read(cmd)
+    def run(cmd, timeout = TIMEOUT)
+      write(cmd)
+      return read(timeout)
     end
 
     def close
@@ -21,6 +28,8 @@ module Hatchet
         input.close
         output.close
       end
+    ensure
+      Process.kill('TERM', pid)   if pid.present?
     end
 
     # There be dragons - (You're playing with process deadlock)
@@ -29,21 +38,17 @@ module Hatchet
     # First pull all contents from stdout (except we don't know how many there are)
     # So we have to go until our process deadlocks, then we timeout and return the string
     #
-    # Example
-    #   result = ""
-    #   input.write("ls\n")
-    #   Timeout::timeout(1) {output.each {|x| result << x}}
-    #      Timeout::Error: execution expired
-    #   puts result
-    #     # => "ls\r\r\napp\tconfig.ru  Gemfile\t LICENSE.txt  public\t script  vendor\r\r\nbin\tdb\t   Gemfile.lock  log\t      Rakefile\t test\r\r\nconfig\tdoc\t   lib\t\t Procfile     README.md  tmp\r\r\n"
-    #
-    # Now we want to remove the original command ("ls\r\r\n") and return the remainder
-    def read(cmd, str = "")
-      timeout do
-        # this is guaranteed to timeout; output.each will not return
-        output.each { |line| str << line }
+    def read(timeout = TIMEOUT)
+      str = ""
+      while true
+        Timeout::timeout(timeout) do
+          str << output.readline
+        end
       end
-      str.split("#{cmd}\r\r\n").last
+
+      return str
+    rescue Timeout::Error, EOFError
+      return str
     end
 
     def timeout(msg = nil, val = TIMEOUT, &block)
@@ -55,4 +60,3 @@ module Hatchet
     end
   end
 end
-

data/lib/hatchet/tasks.rb

@@ -17,4 +17,11 @@ namespace :hatchet do
     end
     puts "== Done =="
   end
+
+  task :teardown_travis do
+    ['heroku keys:remove ~/.ssh/id_rsa'].each do |command|
+      puts "== Running: #{command}"
+      `#{command}`
+    end
+  end
 end

data/lib/hatchet/version.rb

@@ -1,3 +1,3 @@
 module Hatchet
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/hatchet.rb

@@ -10,6 +10,8 @@ require 'stringio'
 
 
 module Hatchet
+  RETRIES = Integer(ENV['HATCHET_RETRIES'] || 1)
+
   class App
   end
 end
@@ -18,6 +20,8 @@ require 'hatchet/version'
 require 'hatchet/app'
 require 'hatchet/anvil_app'
 require 'hatchet/git_app'
+require 'hatchet/command_parser'
 require 'hatchet/stream_exec'
+require 'hatchet/repl_runner'
 require 'hatchet/process_spawn'
 require 'hatchet/config'

data/test/hatchet/allow_failure_anvil_test.rb

@@ -20,13 +20,13 @@ class AllowFailureAnvilTest < Test::Unit::TestCase
   end
 
   def test_retries
-    Hatchet::App.const_set(:RETRIES, 2)
+    Hatchet.const_set(:RETRIES, 2)
     assert_raise(Anvil::Builder::BuildError) do
       app = Hatchet::AnvilApp.new("no_lockfile", buildpack: @buildpack_path)
       app.expects(:push!).twice.raises(Anvil::Builder::BuildError)
       app.deploy
     end
   ensure
-    Hatchet::App.const_set(:RETRIES, 1)
+    Hatchet.const_set(:RETRIES, 1)
   end
 end

data/test/hatchet/command_parser_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class CommandParserTest < Test::Unit::TestCase
+  def test_removes_command_from_string
+    hash = {command: "1+1",
+            string:  "1+1\r\r\n=> 2\r\r\n",
+            expect:   "=> 2\r\r\n"
+           }
+    cp = Hatchet::CommandParser.new(hash[:command]).parse(hash[:string])
+    assert cp.has_valid_output?
+    assert_equal hash[:expect], cp.to_s
+
+
+    hash = {command: "ls",
+            string: "Running `bash` attached to terminal... up, run.8041\r\n\e[01;34m~\e[00m \e[01;32m$ \e[00mls\r\r\napp  config\tdb   Gemfile\t   lib\tProcfile  Rakefile     script  tmp\r\r\nbin  config.ru\tdoc  Gemfile.lock  log\tpublic\t  README.rdoc  test    vendor\r\r\n",
+            expect: "app  config\tdb   Gemfile\t   lib\tProcfile  Rakefile     script  tmp\r\r\nbin  config.ru\tdoc  Gemfile.lock  log\tpublic\t  README.rdoc  test    vendor\r\r\n"
+           }
+    cp = Hatchet::CommandParser.new(hash[:command]).parse(hash[:string])
+    assert cp.has_valid_output?
+    assert_equal hash[:expect], cp.to_s
+  end
+
+  def test_returns_result_if_no_command_in_result
+    hash = {command: "ls",
+            string:  "1+1\r\r\n=> 2\r\r\n",
+            expect:  "1+1\r\r\n=> 2\r\r\n"
+           }
+    cp = Hatchet::CommandParser.new(hash[:command]).parse(hash[:string])
+    refute cp.has_valid_output?
+    assert_equal hash[:expect], cp.to_s
+  end
+
+  def test_empty_string
+    hash = {command: "ls",
+            string:  "",
+            expect:  ""
+           }
+    cp = Hatchet::CommandParser.new(hash[:command]).parse(hash[:string])
+    refute cp.has_valid_output?
+    assert_equal hash[:expect], cp.to_s
+  end
+
+
+  def test_partial_command_no_result
+    hash = {command: "1+1",
+            string:  "1+1\r\r\n",
+            expect:  "1+1\r\r\n"
+           }
+    cp = Hatchet::CommandParser.new(hash[:command]).parse(hash[:string])
+    assert_equal hash[:expect], cp.to_s
+    refute cp.has_valid_output?
+  end
+end
+

data/test/hatchet/config_test.rb

@@ -20,7 +20,7 @@ class ConfigTest < Test::Unit::TestCase
   def test_config_repos
     expected_repos = { "rails3_mri_193" => "test/fixtures/repos/rails3/rails3_mri_193",
                        "rails2blog"     => "test/fixtures/repos/rails2/rails2blog",
-                       "no_lockfile"    =>"test/fixtures/repos/bundler/no_lockfile"}
+                       "no_lockfile"    => "test/fixtures/repos/bundler/no_lockfile"}
     assert_equal expected_repos, @config.repos
   end
 

data/test/hatchet/multi_cmd_runner_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class MultiCmdRunnerTest < Test::Unit::TestCase
+  def setup
+    @buildpack_path = File.expand_path 'test/fixtures/buildpacks/heroku-buildpack-ruby'
+  end
+
+  # slow but needed, there are ghosts in the machine
+  # by running common command multiple times we can find them
+  def test_multi_repl_commands
+    Hatchet::AnvilApp.new("rails3_mri_193", buildpack: @buildpack_path).deploy do |app|
+      app.add_database
+
+      rand(3..7).times do
+        app.run("bash") do |bash|
+          assert_match /Gemfile/, bash.run("ls")
+        end
+      end
+
+      rand(3..7).times do
+        app.run("rails console") do |console|
+          assert_match /foofoofoofoofoo/, console.run("'foo' * 5")
+          assert_match /hello world/,     console.run("'hello ' + 'world'")
+        end
+      end
+    end
+  end
+end

data/test/hatchet/repl_runner_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+require 'stringio'
+
+class ReplRunnerTest < Test::Unit::TestCase
+
+  def test_returns_full_output_if_command_not_found
+    command            = "irb"
+    input              = StringIO.new("bar")
+    bogus_output       = StringIO.new("foo")
+    stream             = Hatchet::StreamExec.new(bogus_output, input, 1)
+    repl               = Hatchet::ReplRunner.new(stream)
+    repl.write("1+1")
+    assert_equal bogus_output.string, repl.read("1+1")
+
+    Hatchet::CommandParser.any_instance.expects(:parse).times(Hatchet::ReplRunner::RETRIES)
+    Hatchet::CommandParser.any_instance.stubs(:to_s)
+    repl.write("1+1")
+    repl.read("1+1")
+  end
+end

data/test/hatchet/stream_exec_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class StreamExecTest < Test::Unit::TestCase
+  def test_local_irb_stream
+    command            = "irb"
+    output, input, pid = PTY.spawn(command)
+    stream             = Hatchet::StreamExec.new(output, input, pid)
+    stream.run("STDOUT.sync = true\n")
+    assert_equal "1+1\r\n => 2 \r\n", stream.run("1+1\n")
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroku_hatchet
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-23 00:00:00.000000000 Z
+date: 2013-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: heroku-api
@@ -157,9 +157,11 @@ files:
 - lib/hatchet.rb
 - lib/hatchet/anvil_app.rb
 - lib/hatchet/app.rb
+- lib/hatchet/command_parser.rb
 - lib/hatchet/config.rb
 - lib/hatchet/git_app.rb
 - lib/hatchet/process_spawn.rb
+- lib/hatchet/repl_runner.rb
 - lib/hatchet/stream_exec.rb
 - lib/hatchet/tasks.rb
 - lib/hatchet/version.rb
@@ -202,8 +204,12 @@ files:
 - test/hatchet/allow_failure_anvil_test.rb
 - test/hatchet/allow_failure_git_test.rb
 - test/hatchet/anvil_test.rb
+- test/hatchet/command_parser_test.rb
 - test/hatchet/config_test.rb
 - test/hatchet/git_test.rb
+- test/hatchet/multi_cmd_runner_test.rb
+- test/hatchet/repl_runner_test.rb
+- test/hatchet/stream_exec_test.rb
 - test/test_helper.rb
 homepage: https://github.com/heroku/hatchet
 licenses:
@@ -269,6 +275,10 @@ test_files:
 - test/hatchet/allow_failure_anvil_test.rb
 - test/hatchet/allow_failure_git_test.rb
 - test/hatchet/anvil_test.rb
+- test/hatchet/command_parser_test.rb
 - test/hatchet/config_test.rb
 - test/hatchet/git_test.rb
+- test/hatchet/multi_cmd_runner_test.rb
+- test/hatchet/repl_runner_test.rb
+- test/hatchet/stream_exec_test.rb
 - test/test_helper.rb