heroku_hatchet 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f6fe23a7e5a091233694be4bc546232d45b13fe
-  data.tar.gz: 4c161fbcb5e7b5140b6025caa6a1b511635617c1
+  metadata.gz: cbe186a27b0018f41b0ab9338925c09acdf9a52b
+  data.tar.gz: b7dcdd7fdf884f4e6773e6ae5c34fc731b615876
 SHA512:
-  metadata.gz: 22409adecd80f6761593dd2f4cfb68696722903294cc08e7b5fb45183661d12e7b16ed1f67dd51a726c57e6249a9105a331ab9f0e1e3541a90c381384a1454ec
-  data.tar.gz: 1c95c1a1777355e891760054b1b75ec3cf4c70963271bd492cfc1beb9496e6e811e3e288650041a0ec0583a5c358266ac17b3060cce4f292efa0f0fb7580855b
+  metadata.gz: 66ae54f148dfde98f77515fedc1401aee42820084de8846d0dae3c1a350f0b3e19393033ecac347e14096b945adc5c7f84d3f0c26d1e72cbde78fbfd0b3b114a
+  data.tar.gz: 8f2fc16b6a0aaa668eed1efd53b1807bbbceb15afc4a298bf8a081086bcb53c7e2afe3bb1539d605d943368ff7926d46dfa4678e36b292366e0f06f3949e41c2

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## HEAD
 
+## 1.0.0
+
+- Move remote console running code to https://github.com/schneems/repl_runner
+  This changes the API for running interactive code. README has been updated
 
 ## 0.2.0
 
@@ -26,4 +30,4 @@
 
 ## 0.0.1
 
-- Initial Release
+- Initial Release

data/README.md

@@ -32,160 +32,231 @@ it will be pulled automatically via shelling out, but this is slower.
 
     $ bundle exec rake test
 
+## Why Test a Buildpack?
 
-## Writing Tests
+To prevent regressions and to make pushing out new features faster and easier.
 
-Hatchet is meant for running integration tests, which means we actually have to deploy a real live honest to goodness app on Heroku and see how it behaves.
+## What can Hatchet Test?
 
-First you'll need a repo to an app you know works on Heroku, add it to the proper folder in repos. Such as `repos/rails3/`. Once you've done that make a corresponding test file in the `test` dir such as `test/repos/rails3`. I've already got a project called "codetriage" and the test is "triage_test.rb".
+Hatchet can easily test deployment of buildpacks, getting the build output, and running arbitrary interactive processes such as `heroku run bash`.
 
-Now that you have an app, we'll need to create a heroku instance, and deploy our code to that instance you can do that with this code:
+## Testing a Buildpack
 
-    Hatchet::App.new("repos/rails3/codetriage").deploy do |app|
-      ##
-    end
+Hatchet was built for testing the Ruby buildpack, but you can use it to test any buildpack you desire provided you don't mind writing your tests written in Ruby.
 
-The first argument to the app is the directory where you can find the code. Once your test is done, the app will automatically be destroyed.
+You will need copies of applications that can be deployed by your buildpack. You can see the ones for the Hatchet unit tests (and the Ruby buildpack) https://github.com/sharpstone. Hatchet does not require that you keep these apps checked into your git repo which would make fetching your buildpack slow instead declare them in a `hatchet.json` file (see below).
 
-Now that you've deployed your app you'll want to make sure that the deploy worked correctly. Since we're using `test/unit` you can use regular assertions such as `assert` and `refute`. Since we're yielding to an `app` variable we can check the `deployed?` status of the app:
+Hatchet will automate retrieving these files `$ hatchet install`, as well as deploying them using your local copy of the buildpack, retrieving the build output and running commands against deploying applications.
 
-    Hatchet::App.new("repos/rails3/codetriage").deploy do |app|
-      assert app.deployed?
-    end
 
-The primary purpose of the buildpack is configuring and deploying apps, so if it deployed chances are the buildpack is working correctly, but sometimes you may want more information. You can run arbitrary commands such as `heroku bash` and then check for the existence of a file.
+## Hatchet.json
 
-    Hatchet::App.new("repos/rails3/codetriage").deploy do |app|
-      app.run("bash") do |cmd|
-        assert cmd.run("ls public/assets").include?("application.css")
-      end
-    end
+Hatchet expects a json file in the root of your buildpack called `hatchet.json`. You can configure install options using the `"hatchet"` key. In this example we're telling hatchet to install the given repos to our `test/fixtures` directory instead of the default current directory.
 
-Anything you put in `cmd.run` at this point will be executed from with in the app that you are in.
+```
+{
+  "hatchet": {"directory": "test/fixtures"},
+  "rails3":  ["sharpstone/rails3_mri_193"],
+  "rails2":  ["sharpstone/rails2blog"],
+  "bundler": ["sharpstone/no_lockfile"]
+}
+```
 
-    cmd.run("cat")
-    cmd.run("cd")
-    cmd.run("cd .. ; ls | grep foo")
+When you run `$ hatchet install` it will grab the git repos from github and place them on your local machine in a file structure that looks like this:
 
-It behaves exactly as if you were in a remote shell. If you really wanted you could even run the tests:
+```
+test/
+  fixtures/
+    repos/
+      rails3/
+        rails3_mri_193/
+      rails2/
+        rails2blog/
+      bundler/
+        no_lockfile/
+```
 
-    cmd.run("rake test")
+Now in your test you can reference one of these applications by using it's git name:
 
-But since cmd.run doesn't return the exit status now, that wouldn't be
-so useful (also there is a default timeout to all commands). If you want
-you can configure the timeout by passing in a second parameter
+```ruby
+Hatchet::AnvilApp.new('no_lockfile')
+```
 
-    cmd.run("rake test", 180.seconds)
+If you have conflicting names, use full paths.
 
+A word of warning on including repos inside of your test
+directory, if you're using a runner that looks for patterns such as
+`*_test.rb` to run your hatchet tests, it may incorrectly think you want
+to run the tests inside of the repos. To get rid of this
+problem move your repos direcory out of `test/` or be more specific
+with your tests such as moving them to a `test/hatchet` directory and
+changing your pattern if you are using `Rake::TestTask` it might look like this:
 
-## Running One off Commands
+    t.pattern = 'test/hatchet/**/*_test.rb'
 
-If you only want to run one command you can call `app.run` without
-passing a block
+A note on external repos: since you're basing tests on these repos, it
+is in your best interest to not change them or your tests may
+spontaneously fail. In the future we may create a hatchet.lockfile or
+something to declare the commit
 
-    Hatchet::AnvilApp.new("/codetriage").deploy do |app|
-      assert_match "1.9.3", app.run("ruby -v")
-    end
+## Deploying apps
 
+Now that you've got your apps locally you can have hatchet deploy them for you. Hatchet can deploy using one of two ways Anvil and Git. A `Hatchet::AnvilApp` will deploy using Anvil against the current directory. This means that the buildpack you have locally will be used when deploying, due to this we recommend using Anvil to run your tests.
 
-## Testing A Different Buildpack
+A `Hatchet::GitApp` will deploy using the standard `git push heroku master`, if you use this option you need to have a publicly accessible copy of your buildpack. Using Git to test your buildpack may be slow and require you to frequently push your buildpack to a public git repo. For this reason we recommend using Anvil to run your tests:
 
-You can specify buildpack to deploy with like so:
+```ruby
+Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
 
-    Hatchet::App.new("repos/rails3/codetriage", buildpack: "https://github.com/schneems/heroku-buildpack-ruby.git").deploy do |app|
+end
+```
 
-## Hatchet Config
+Deploys are expected to work, if the `ENV['HATCHET_RETRIES']` is set, then deploys will be automatically retried that number of times. Due to testing using a network and random Anvil failures, setting this value to `3` retries seems to work well. If an app cannot be deployed within its allotted number of retries an error will be raised.
 
-Hatchet is designed to test buildpacks, and requires full repositories
-to deploy to Heroku. Web application repos, especially Rails repos, aren't known for
-being small, if you're testing a custom buildpack and have
-`BUILDPACK_URL` set in your app config, it needs to be cloned each time
-you deploy your app. If you've `git add`-ed a bunch of repos then this
-clone would be pretty slow, we're not going to do this. Do not commit
-your repos to git.
+If you are testing an app that is supposed to fail deployment you can set the `allow_failure: true` flag when creating the app:
 
-Instead we will keep a structured file called
-inventively `hatchet.json` at the root of your project. This file will
-describe the structure of your repos, have the name of the repo, and a
-git url. We will use it to sync remote git repos with your local
-project. It might look something like this
+```ruby
+Hatchet::AnvilApp.new("no_lockfile", allow_failure: true).deploy do |app|
+```
 
-    {
-      "hatchet": {},
-      "rails3": ["git@github.com:codetriage/codetriage.git"],
-      "rails2": ["git@github.com:heroku/rails2blog.git"]
-    }
+After the block finishes your app will be removed from heroku. If you are investigating a deploy, you can add the `debug: true` flag to your app:
 
-the 'hatchet' object accessor is reserved for hatchet settings.
-. To copy each repo in your `hatchet.json`
-run the command:
+```ruby
+Hatchet::AnvilApp.new("rails3_mri_193", debug: true).deploy do |app|
+```
 
-    $ hatchet install
+Now after Hatchet is done deploying your app it will remain on Heroku. It will also output the name of the app into your test logs so that you can `heroku run bash` into it for detailed postmortem.
 
-The above `hatchet.json` will produce a directory structure like this:
+If you are wanting to run a test against a specific app without deploying to it, you can set the app name like this:
 
-    repos/
-      rails3/
-        codetriage/
-          #...
-      rails2/
-        rails2blog/
-          # ...
+```ruby
+app = Hatchet::AnvilApp.new("rails3_mri_193", name: "testapp")
+```
 
-While you are running your tests if you reference a repo that isn't
-synced locally Hatchet will raise an error. Since you're using a
-standard file for your repos, you can now reference the name of the git
-repo, provided you don't have conflicting names:
+Deploying the app takes a few minutes, so you may want to skip that part to make debugging a problem easier since you're iterating much faster.
 
-    Hatchet::App.new("codetriage").deploy do |app|
 
-If you do have conflicting names, use full paths.
+If you need to deploy using a buildpack that is not in the root of your directory you can specify a path in the `buildpack` option:
 
-A word of warning on including rails/ruby repos inside of your test
-directory, if you're using a runner that looks for patterns such as
-`*_test.rb` to run your hatchet tests, it may incorrectly think you want
-to run the tests inside of the rails repositories. To get rid of this
-problem move your repos direcory out of `test/` or be more specific
-with your tests such as moving them to a `test/hatchet` directory and
-changing your pattern if you are using `Rake::TestTask` it might look like this:
 
-    t.pattern = 'test/hatchet/**/*_test.rb'
+```ruby
+buildpack_path = File.expand_path 'test/fixtures/buildpacks/heroku-buildpack-ruby'
 
-A note on external repos: since you're basing tests on these repos, it
-is in your best interest to not change them or your tests may
-spontaneously fail. In the future we may create a hatchet.lockfile or
-something to declare the commit
+def test_deploy
+  Hatchet::AnvilApp.new("rails3_mri_193", buildpack: buildpack_path).deploy do |app|
+  # ...
+```
 
-## Hatchet CLI
+If you are using a `Hatchet::GitApp` this is where you specify the publicly avaialble location of your buildpack, such as `https://github.com/heroku/heroku-buildpack-ruby.git#mybranch`
 
-Hatchet has a CLI for installing and maintaining external repos you're
-using to test against. If you have Hatchet installed as a gem run
 
-    $ hatchet --help
+## Getting Deploy Output
 
-For more info on commands. If you're using the source code you can run
-the command by going to the source code directory and running:
+After Hatchet deploys your app you can get the output by using `app.output`
 
-    $ ./bin/hatchet --help
+```ruby
+Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+  puts app.output
+end
+```
+
+If you told Hatchet to `allow_failure: true` then the full output of the failed build will be in `app.output` even though the app was not deployed. It is a good idea to test against the output for text that should be present. Using a testing framework such as `Test::Unit` a failed test output may look like this
+
+```ruby
+Hatchet::AnvilApp.new("no_lockfile", allow_failure: true).deploy do |app|
+  assert_match "Gemfile.lock required", app.output
+end
+```
+
+Since an error will be raised on failed deploys you don't need to check for a deployed status (the error will automatically fail the test for you).
+
+## Running Processes
+
+Often times asserting output of a build can only get you so far, and you will need to actually run a task on the dyno. To run a non-interactive command such as `heroku run ls` you can do this using the `app.run()` command and do not pass it a block
+
+```ruby
+Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+  assert_match "applications.css", app.run("ls public/assets")
+```
+
+This is useful for checking the existence of generated files such as assets. If you need to run an interactive session such as `heroku run bash` or `heroku run rails console` you can use the run command and pass a block:
+
+```ruby
+Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+  app.run("bash") do |bash|
+    bash.run("ls")           {|result| assert_match "Gemfile.lock", result }
+    bash.run("cat Procfile") {|result| assert_match "web:", result }
+  end
+end
+```
+
+or
+
+```ruby
+Hatchet::AnvilApp.new("rails3_mri_193").deploy do |app|
+  app.run("rails console") do |console|
+    console.run("a = 1 + 2")  {|result| assert_match "3", result }
+    console.run("'foo' * a")  {|result| assert_match "foofoofoo", result }
+  end
+end
+```
+
+This functionality is provided by [repl_runner](http://github.com/schneems/repl_runner). Please read the docs on that readme for more info. The only interactive commands that are supported out of the box are `rails console`, `bash`, and `irb` it is fairly easy to add your own though:
+
+```
+ReplRunner.register_commands(:python)  do |config|
+  config.terminate_command "exit()"        # the command you use to end the 'python' console
+  config.startup_timeout 60                # seconds to boot
+  config.return_char "\n"                  # the character that submits the command
+end
+```
+
+If you have questions on setting running other interactive commands message [@schneems](http://twitter.com/schneems)
+
+## Writing Tests
 
+Hatchet is test framework agnostic. [This project](https://github.com/heroku/hatchet) uses `Test::Unit` to run it's own tests. While the [heroku-ruby-buildpack](https://github.com/heroku/heroku-buildpack-ruby) uses rspec.
 
-## Retries
+Rspec has a number of advantages, the ability to run `focused: true` to only run the exact test you want as well as the ability to tag tests. Rspec also has a number of useful plugins, one especialy useful one is `gem 'rspec-retry'` which will re-run any failed tests a given number of times (I recommend setting this to at least 2) this decrease the number of false negatives your tests will have.
 
-Phantom errors happen. To auto retry deploy failures set the environment variable `HATCHET_RETRIES=3` which will auto retry deploys 3 times. By default deploys will not be retried. Once the number of retries has occurred the last exception will be raised.
+Whatever testing framework you chose, we recommend using a parallel test runner when running the full suite [parallel_tests](https://github.com/grosser/parallel_tests) works with rspec and test::unit and is amazing.
 
-## The Future
+If you're unfamiliar with the ruby testing eco-system or want some help with boilerplate and work for Heroku: [@schneems](http://twitter.com/schneems) can help you get started. Looking at existing projects is a good place to get started
 
-### Speed
+## Testing on Travis
 
-Efforts may be spent optimizing / parallelizing the process, almost all of the time of the test is spent waiting for IO, so hopefully we should be able to parallelize many tests / deploys at the same time. The hardest part of this (i believe) would be splitting out the different runs into different log streams so that the output wouldn't be completely useless.
+Once you've got your tests working locally, you'll likely want to get them running on Travis because a) CI is awesome, and b) you can use pull requests to run your all your tests in parallel without having to kill your network connection.
 
-Right now running 1 deploy test takes about 3 min on my machine.
+To run on travis you will need to configure your `.travis.yml` to run the appropriate commands and to set up encrypted data so you can run tests against a valid heroku user.
 
-## Git Based Deploys
+For reference see the `.travis.yml` from [hatchet](https://github.com/heroku/hatchet/blob/master/.travis.yml) and the [heroku-ruby-buildpack](https://github.com/heroku/heroku-buildpack-ruby/blob/master/.travis.yml). To make running on travis easier there is a rake task in Hatchet that can be run before your tests are executed
+
+```
+before_script: bundle exec rake hatchet:setup_travis
+```
+
+I recommend signing up for a new heroku account for running your tests on travis, otherwise you will quickly excede your API limit. Once you have the new api token you can use this technique to [securely send travis the data](http://about.travis-ci.org/docs/user/build-configuration/#Secure-environment-variables).
+
+
+## Extra App Commands
+
+```
+app.add_database # adds a database to specified app
+app.heroku       # returns a Herou Api client https://github.com/heroku/heroku.rb
+```
+
+## Hatchet CLI
+
+Hatchet has a CLI for installing and maintaining external repos you're
+using to test against. If you have Hatchet installed as a gem run
+
+    $ hatchet --help
+
+For more info on commands. If you're using the source code you can run
+the command by going to the source code directory and running:
+
+    $ ./bin/hatchet --help
 
-It would be great to allow hatchet to deploy apps off of git url, however if we do that we could open ourselves up to false negatives, if we are pointing at an external repo that gets broken.
 
 
-## Features?
 
-What else do we want to test? Config vars, addons, etc. Let's write some tests.

data/hatchet.gemspec

@@ -24,6 +24,8 @@ Gem::Specification.new do |gem|
   gem.add_dependency "anvil-cli"
   gem.add_dependency "excon"
   gem.add_dependency "thor"
+  gem.add_dependency 'repl_runner'
+
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "mocha"

data/lib/hatchet/app.rb

@@ -39,7 +39,10 @@ module Hatchet
     # runs a command on heroku similar to `$ heroku run #foo`
     # but programatically and with more control
     def run(command, timeout = nil, &block)
-      ProcessSpawn.new(command, self, timeout).run(&block)
+      heroku_command = "heroku run #{command} -a #{name}"
+      return `#{heroku_command}` if block.blank?
+
+      ReplRunner.new(command, heroku_command, startup_timeout: timeout).run(&block)
     end
 
     # set debug: true when creating app if you don't want it to be
@@ -115,14 +118,13 @@ module Hatchet
       @output
     end
 
-    private
-      def api_key
-        @api_key ||= ENV['HEROKU_API_KEY'] || `heroku auth:token`.chomp
-      end
+    def api_key
+      @api_key ||= ENV['HEROKU_API_KEY'] || `heroku auth:token`.chomp
+    end
 
-      def heroku
-        @heroku ||= Heroku::API.new(api_key: api_key)
-      end
+    def heroku
+      @heroku ||= Heroku::API.new(api_key: api_key)
+    end
   end
 end
 

data/lib/hatchet/version.rb

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

data/lib/hatchet.rb

@@ -2,6 +2,7 @@ require 'heroku/api'
 require 'anvil/engine'
 require 'active_support/core_ext/object/blank'
 require 'rrrretry'
+require 'repl_runner'
 
 require 'json'
 require 'stringio'
@@ -20,8 +21,4 @@ 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/anvil_test.rb

@@ -11,8 +11,8 @@ class AnvilTest < Test::Unit::TestCase
 
       assert_match '1.9.3', app.run("ruby -v")
       app.run("bash") do |cmd|
-        assert cmd.run("cat Gemfile").include?("gem 'pg'")
-        assert cmd.run("ls public/assets").include?("application.css")
+        cmd.run("cat Gemfile")      {|r| assert_match "gem 'pg'", r}
+        cmd.run("ls public/assets") {|r| assert_match "application.css", r}
       end
     end
   end

data/test/hatchet/git_test.rb

@@ -8,7 +8,7 @@ class GitAppTest < Test::Unit::TestCase
 
       app.run("bash") do |cmd|
         # cmd.run("cd public/assets")
-        assert cmd.run("ls public/assets").include?("application.css")
+        cmd.run("ls public/assets") {|r| assert_match "application.css", r}
       end
     end
   end

data/test/hatchet/multi_cmd_runner_test.rb

@@ -11,18 +11,26 @@ class MultiCmdRunnerTest < Test::Unit::TestCase
     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")
+      assert_raise ReplRunner::UnregisteredCommand do
+        app.run("ls", 2) do |ls| # will return right away, should raise error
+          ls.run("cat")
         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'")
+          console.run("`ls`")
+          console.run("'foo' * 5")          {|r| assert_match "foofoofoofoofoo", r }
+          console.run("'hello ' + 'world'") {|r| assert_match "hello world", r }
+        end
+      end
+
+      rand(3..7).times do
+        app.run("bash") do |bash|
+          bash.run("ls") { |r| assert_match "Gemfile", r }
         end
       end
+
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroku_hatchet
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-22 00:00:00.000000000 Z
+date: 2013-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: heroku-api
@@ -94,6 +94,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: repl_runner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -157,12 +171,8 @@ 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
 - test/fixtures/buildpacks/heroku-buildpack-ruby/.gitignore
@@ -204,12 +214,9 @@ 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:
@@ -275,10 +282,7 @@ 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

data/lib/hatchet/command_parser.rb

@@ -1,39 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-require 'pty'
-module Hatchet
-  # spawns a process on Heroku, and keeps it open for writing
-  # like `heroku run bash`
-  class ProcessSpawn
-    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)
-      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(/#{@ready_regex}/).present?
-    end
-
-    def not_ready?
-      !ready?
-    end
-
-    def wait_for_spawn!
-      while not_ready?
-        sleep 1
-      end
-      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 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?
-
-      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
-      repl.close if repl.present?
-    end
-  end
-end

data/lib/hatchet/repl_runner.rb

@@ -1,61 +0,0 @@
-# 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,62 +0,0 @@
-require 'timeout'
-
-module Hatchet
-  # runs arbitrary commands within a Heroku process
-  class StreamExec
-    attr_reader :input, :output, :pid
-    TIMEOUT = 1 # seconds to run an arbitrary command on a heroku process like `$ls`
-
-    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, timeout = TIMEOUT)
-      write(cmd)
-      return read(timeout)
-    end
-
-    def close
-      timeout("closing stream") do
-        input.close
-        output.close
-      end
-    ensure
-      Process.kill('TERM', pid)   if pid.present?
-    end
-
-    # There be dragons - (You're playing with process deadlock)
-    #
-    # We want to read the whole output of the command
-    # 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
-    #
-    def read(timeout = TIMEOUT)
-      str = ""
-      while true
-        Timeout::timeout(timeout) do
-          str << output.readline
-        end
-      end
-
-      return str
-    rescue Timeout::Error, EOFError
-      return str
-    end
-
-    def timeout(msg = nil, val = TIMEOUT, &block)
-      Timeout::timeout(val) do
-        yield
-      end
-    rescue Timeout::Error
-      puts "timeout #{msg}" if msg
-    end
-  end
-end

data/test/hatchet/command_parser_test.rb

@@ -1,54 +0,0 @@
-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/repl_runner_test.rb

@@ -1,20 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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
-