engineyard-hudson 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+.DS_Store
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in engineyard-hudson.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    engineyard-hudson (0.0.1)
+      thor (~> 0.14.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (0.2.1)
+    builder (2.1.2)
+    cucumber (0.9.3)
+      builder (~> 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.2.9)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.2.9)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    json (1.4.6)
+    rake (0.8.7)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    term-ansicolor (1.0.5)
+    thor (0.14.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  cucumber (~> 0.9.3)
+  engineyard-hudson!
+  json (~> 1.4.0)
+  rake (~> 0.8.7)
+  rspec (~> 2.0.1)
+  thor (~> 0.14.3)

data/History.md

@@ -0,0 +1,6 @@
+# History
+
+## 0.1.0 - 2010-10-30
+
+* Initial 'ey-hudson install .' command
+* 'ey-hudson server' shows 'Coming soon'

data/README.md

@@ -0,0 +1,74 @@
+# Easier to do CI than not to.
+
+Run your continuous integration (CI) tests against your Engine Yard AppCloud environments - the exact same configuration you are using in production!
+
+You're developing on OS X or Windows, deploying to Engine Yard AppCloud (Gentoo/Linux), and you're running your CI on your local machine or a spare Ubuntu machine in the corner of the office, or ... you're not running CI at all?
+
+It's a nightmare. It was for me. [Hudson CI](http://hudson-ci.org/), `engineyard-hudson` and the [hudson](http://github.com/cowboyd/hudson.rb) CLI projects now make CI easier to do than not to. A few commands and your Rails applications' tests are automatically running, no additional setup, and its the same environment you are deploying your Rails applications (Engine Yard AppCloud). Sweet.
+
+## Installation
+
+    gem install engineyard-hudson
+
+## Assumptions
+
+It is assumed you are familiar with the `engineyard` CLI gem.
+
+You **do not** need to be familiar with custom chef recipes. Just follow the simple commands. Easy peasy.
+
+## Warning
+
+In the very first release of `engineyard-hudson`, there is no support for authentication/authorization of Hudson CI.
+
+## Hosting Hudson CI on Engine Yard AppCloud
+
+Instructions *coming soon*.
+
+Hosting Hudson CI on Engine Yard AppCloud is optional. It can be hosted anywhere. You need the following information about your Hudson CI:
+
+* Hudson CI host (& port)
+* Hudson CI's user's public key (probably at /home/hudson/.ssh/id_rsa.pub)
+* Hudson CI's user's private key path (probably /home/hudson/.ssh/id_rsa)
+
+## Running your tests in Hudson against Engine Yard AppCloud
+
+After a couple manual steps, you will have your applications tests running.
+
+    $ cd /my/project
+    $ ey-hudson install .
+    
+    Finally:
+    * edit cookbooks/hudson_slave/attributes/default.rb as necessary.
+    * run: ey recipes upload # use --environment(-e) & --account(-c)
+    * run: ey recipes apply  #   to select environment
+    * Boot your environment if not already booted.
+
+Done! Either visit your Hudson CI site or use `hudson list` to see the status of your projects being tested.
+
+## Automatically triggering job builds
+
+In Hudson CI, a "job" is one of your projects. Each time it runs your tests, it is called a "build".
+
+It is often desirable to have your SCM trigger Hudson CI to run your job build whenever you push new code.
+
+### GitHub Service Hooks
+
+* Go to the "Admin" section of your GitHub project
+* Click "Service Hooks"
+* Click "Post-Receive URLs"
+* Enter the URL `http://HUDSON-CI-URL/job/APP-NAME/build`
+* Click "Update Settings"
+
+You can also use the "Test Hook" link to test this is wired up correctly.
+
+### CLI
+
+Using the `hudson` CLI:
+
+    hudson build APP-NAME
+
+### Curl
+
+You are triggering the build via a GET call to an URL endpoint. So you can also use `curl`:
+
+    curl http://HUDSON-CI-URL/job/APP-NAME/build

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+namespace :cucumber do
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:wip, 'Run features that are being worked on') do |t|
+    t.cucumber_opts = "--tags @wip"
+  end
+  Cucumber::Rake::Task.new(:ok, 'Run features that should be working') do |t|
+    t.cucumber_opts = "--tags ~@wip"
+  end
+  task :all => [:ok, :wip]
+end
+
+desc 'Alias for cucumber:ok'
+task :cucumber => 'cucumber:ok'
+
+desc "Start test server; Run cucumber:ok; Kill Test Server;"
+task :default => ["cucumber"]

data/bin/ey-hudson

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+require 'engineyard-hudson'
+require 'engineyard-hudson/cli'
+
+Engineyard::Hudson::CLI.start

data/engineyard-hudson.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "engineyard-hudson"
+  s.version     = '0.1.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dr Nic Williams"]
+  s.email       = ["drnicwilliams@gmail.com"]
+  s.homepage    = "http://github.com/engineyard/engineyard-hudson"
+  s.summary     = %q{Easier to do CI than not to. Use Hudson CI on Engine Yard AppCloud.}
+  s.description = %q{Run your continuous integration (CI) tests against your Engine Yard AppCloud environments - the exact same configuration you are using in production!}
+
+  s.rubyforge_project = "engineyard-hudson"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("thor", ["~> 0.14.3"])
+  s.add_dependency("engineyard", ["~> 1.3.3"])
+  # s.add_dependency("hudson", ["~> 0.3.0.beta"])
+
+  s.add_development_dependency("rake", ["~> 0.8.7"])
+  s.add_development_dependency("cucumber", ["~> 0.9.3"])
+  s.add_development_dependency("rspec", ["~> 2.0.1"])
+  s.add_development_dependency("json", ["~>1.4.0"])
+  s.add_development_dependency("awesome_print")
+end

data/features/install.feature

@@ -0,0 +1,57 @@
+Feature: Managing a rails project as a Hudson CI job on AppCloud
+  I want to build/test my project in the same environment I run in Engine Yard AppCloud
+  
+  Scenario: Setup first project as a slave for Hudson
+    Given I have an environment "hudson" on account "drnic" on AppCloud
+    And I have an environment "my_app_ci" on account "drnic" on AppCloud
+    And I am in the "rails" project folder
+    When I run local executable "ey-hudson" with arguments "install ."
+    Then file "cookbooks/hudson_slave/attributes/default.rb" is created
+    And file "cookbooks/hudson_slave/recipes/default.rb" is created
+    And file "cookbooks/main/recipes/default.rb" is created
+    And file "cookbooks/main/libraries/ruby_block.rb" is created
+    And I should see exactly
+      """
+            create  cookbooks
+            create  cookbooks/main/attributes/recipe.rb
+            create  cookbooks/main/definitions/ey_cloud_report.rb
+            create  cookbooks/main/libraries/ruby_block.rb
+            create  cookbooks/main/libraries/run_for_app.rb
+            create  cookbooks/hudson_slave/attributes/default.rb
+            create  cookbooks/hudson_slave/recipes/default.rb
+            create  cookbooks/main/recipes/default.rb
+      
+      Finally:
+      * edit cookbooks/hudson_slave/attributes/default.rb as necessary.
+      * run: ey recipes upload # use --environment(-e) & --account(-c)
+      * run: ey recipes apply  #   to select environment
+      * Boot your environment if not already booted.
+      When the recipe completes, your project will commence its first build on Hudson CI.
+      """
+  
+  Scenario: Setup project with existing cookbooks as a slave for Hudson
+    Given I have an environment "hudson" on account "drnic" on AppCloud
+    And I have an environment "my_app_ci" on account "drnic" on AppCloud
+    And I am in the "rails" project folder
+    And I already have cookbooks installed
+    When I run local executable "ey-hudson" with arguments "install ."
+    Then file "cookbooks/hudson_slave/attributes/default.rb" is created
+    And file "cookbooks/hudson_slave/recipes/default.rb" is created
+    And file "cookbooks/main/recipes/default.rb" is created
+    And file "cookbooks/redis/recipes/default.rb" is created
+    And I should see exactly
+      """
+            create  cookbooks/hudson_slave/attributes/default.rb
+            create  cookbooks/hudson_slave/recipes/default.rb
+            append  cookbooks/main/recipes/default.rb
+
+      Finally:
+      * edit cookbooks/hudson_slave/attributes/default.rb as necessary.
+      * run: ey recipes upload # use --environment(-e) & --account(-c)
+      * run: ey recipes apply  #   to select environment
+      * Boot your environment if not already booted.
+      When the recipe completes, your project will commence its first build on Hudson CI.
+      """
+
+  
+  

data/features/server.feature

@@ -0,0 +1,12 @@
+@wip
+Feature: Managing ey hudson server
+  I want to setup and manage a Hudson CI server hosted on Engine Yard AppCloud
+  
+  Scenario: Setup new Hudson CI server on AppCloud
+    Given I have an environment "hudson" on account "drnic" on AppCloud
+    And I am in the "rails" project folder
+    When I run local executable "ey-hudson" with arguments "server -e hudson -c drnic"
+    Then I should see "Hudson CI server recipe installed."
+  
+  
+  

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,191 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to( project path|) "(.*)"/ do |env_var, path, value|
+  in_project_folder {
+    value = File.expand_path(value)
+  } unless path.empty?
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby -rubygems #{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby -rubygems #{executable.inspect} #{arguments} > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "bundle exec rake #{task} --trace > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = get_command_output
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = get_command_output
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = get_command_output
+  actual_output.should contain(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  actual_output =
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = get_command_output
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = get_command_output
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = get_command_output
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = get_command_output
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = get_command_output
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout.inspect} 2> #{@stdout.inspect}"
+  end
+  actual_output = get_command_output
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = get_command_output
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end
+
+Then /^the file "([^\"]*)" is a valid gemspec$/ do |filename|
+  spec = eval(File.read(filename))
+  spec.validate
+end
+
+When /^I create a new node with the following options on "http:\/\/(.+?):(\d+)":$/ do |host, port, table|
+  options = table.raw.inject({}) do |options, (key, value)|
+    options[(key.to_sym rescue key) || key] = value
+    options
+  end
+
+  Hudson::Api.setup_base_url(:host => host, :port => port.to_i)
+  Hudson::Api.add_node(options)
+end

data/features/step_definitions/fixture_project_steps.rb

@@ -0,0 +1,14 @@
+Given /^I am in the "([^\"]*)" project folder$/ do |project|
+  project_folder = File.expand_path(File.join(@fixtures_path, "projects", project))
+  in_tmp_folder do
+    FileUtils.cp_r(project_folder, project)
+    setup_active_project_folder(project)
+  end
+end
+
+Given /^I already have cookbooks installed$/ do
+  cookbooks_folder = File.expand_path(File.join(@fixtures_path, "cookbooks"))
+  in_project_folder do
+    FileUtils.cp_r(cookbooks_folder, ".")
+  end
+end

data/features/step_definitions/hudson_steps.rb

@@ -0,0 +1,3 @@
+Given /^I have an environment "([^"]*)" on account "([^"]*)" on AppCloud$/ do |env, account|
+
+end

data/features/support/common.rb

@@ -0,0 +1,37 @@
+module CommonHelpers
+  def get_command_output
+    strip_color_codes(File.read(@stdout)).chomp
+  end
+
+  def strip_color_codes(text)
+    text.gsub(/\e\[\d+m/, '')
+  end
+
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../../lib'))
+require 'engineyard-hudson'
+require 'bundler/setup'
+
+Before do
+  @tmp_root      = File.dirname(__FILE__) + "/../../tmp"
+  @home_path     = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path      = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  @fixtures_path = File.expand_path(File.dirname(__FILE__) + "/../../fixtures")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end

data/features/support/matchers.rb

@@ -0,0 +1,10 @@
+
+module Matchers
+  RSpec::Matchers.define :contain do |expected_text|
+    match do |text|
+      text.index expected_text
+    end
+  end
+end
+
+World(Matchers)

data/fixtures/cookbooks/main/recipes/default.rb

@@ -0,0 +1 @@
+require_recipe 'redis'

data/fixtures/projects/rails/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.rb"
+
+gem "rake"

data/fixtures/projects/rails/Gemfile.lock

@@ -0,0 +1,10 @@
+GEM
+  remote: http://rubygems.rb/
+  specs:
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake

data/fixtures/projects/rails/Rakefile

@@ -0,0 +1,4 @@
+desc "Default task runs tests"
+task :default do
+  puts "Tests ran successfully!"
+end

data/lib/engineyard-hudson.rb

@@ -0,0 +1,4 @@
+module Engineyard
+  module Hudson
+  end
+end

data/lib/engineyard-hudson/cli.rb

@@ -0,0 +1,44 @@
+require 'thor'
+
+module Engineyard
+  module Hudson
+    class CLI < Thor
+
+      def self.common_options
+        method_option :environment, :type => :string, :aliases => %w(-e), 
+          :desc => "Environment in which to deploy this application", :required => true
+        method_option :account, :type => :string, :aliases => %w(-c), 
+          :desc => "Name of the account you want to deploy in"
+      end
+      
+      desc "install PROJECT_PATH", "Install Hudson node/slave recipes into your project."
+      def install(project_path)
+        require 'engineyard-hudson/cli/install'
+        Engineyard::Hudson::Install.start(ARGV[1..-1])
+      end
+      
+      desc "server", "Setup a Hudson CI server on AppCloud."
+      def server
+        shell.say "Coming soon!", :green
+      end
+      
+      desc "version", "show version information"
+      def version
+        shell.say Engineyard::Hudson::VERSION
+      end
+
+      map "-v" => :version, "--version" => :version, "-h" => :help, "--help" => :help
+
+      private
+      def display(text)
+        shell.say text
+        exit
+      end
+
+      def error(text)
+        shell.say "ERROR: #{text}", :red
+        exit
+      end
+    end
+  end
+end

data/lib/engineyard-hudson/cli/install.rb

@@ -0,0 +1,62 @@
+require 'thor/group'
+
+module Engineyard
+  module Hudson
+    class Install < Thor::Group
+      include Thor::Actions
+      
+      argument :project_path
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), "install", "templates")
+      end
+      
+      def install_cookbooks
+        file       = "cookbooks/main/recipes/default.rb"
+        unless File.exists?(File.join(destination_root, "cookbooks/main/recipes/default.rb"))
+          directory "cookbooks"
+        end
+      end
+      
+      def attributes
+        template "attributes.rb.erb", "cookbooks/hudson_slave/attributes/default.rb"
+      end
+      
+      def recipe
+        copy_file "recipes.rb", "cookbooks/hudson_slave/recipes/default.rb"
+      end
+      
+      def enable_recipe
+        file       = "cookbooks/main/recipes/default.rb"
+        enable_cmd = "\nrequire_recipe 'hudson_slave'"
+        if File.exists?(file_path = File.join(destination_root, file))
+          append_file file, enable_cmd
+        else
+          create_file file, enable_cmd
+        end
+      end
+      
+      # README:
+      #   Finally:
+      #   * edit cookbooks/hudson_slave/attributes/default.rb as necessary
+      #   * run: ey recipes upload
+      #   * run: ey recipes apply
+      #   * Boot your environment if not already booted.
+      #   When the recipe completes, your project will commence its first build on Hudson CI.
+      def readme
+        say ""
+        say "Finally:"
+        say "* edit "; say "cookbooks/hudson_slave/attributes/default.rb ", :yellow; say "as necessary."
+        say "* run: "; say "ey recipes upload ", :green; say "# use --environment(-e) & --account(-c)"
+        say "* run: "; say "ey recipes apply  ", :green; say "#   to select environment"
+        say "* "; say "Boot your environment ", :yellow; say "if not already booted."
+        say "When the recipe completes, your project will commence its first build on Hudson CI."
+      end
+      
+      private
+      def say(msg, color = nil)
+        color ? shell.say(msg, color) : shell.say(msg)
+      end
+    end
+  end
+end

data/lib/engineyard-hudson/cli/install/templates/attributes.rb.erb

@@ -0,0 +1,17 @@
+#
+# Cookbook Name:: hudson_slave
+# Recipe:: default
+#
+
+hudson_slave({
+  :master => {
+    :host => "ec2-174-129-24-134.compute-1.amazonaws.com",
+    :port => 80,
+    :public_key => "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6AWDDDJcsIrY0KA99KPg+UmSjxjPz7+Eu9mO5GaSNn0vvVdsgrgjkh+35AS9k8Gn/DPaQJoNih+DpY5ZHsuY1zlvnvvk+hsCUHOATngARNs6yQMf2IrQqf38SlBPJ/xjt4oopLyqZuZ59xbFMFa0Yr/B7cCpxNpeIMCbwmc8YOtztOG1ZazlxB6eMTwp1V25TxFPh3PqUz9s37NmBEhkRiEyiJzlDSrKwz2y+77VWztQByM30lYAEXc5GwJD1LTaQwlv/thjhwveAzKLIpxzC5TbUjii7L+4iJF/JrjtXAEYmkegXj6lGBpRIdwXTYWMm3jG6gG+MV2nfWmocDzg3Q==",
+    :master_key_location => "/home/hudson/.ssh/id_rsa"
+  },
+  :gem => {
+    :install => "hudson --pre",
+    :version => "hudson-0.3.0.beta.13"
+  }
+})

data/lib/engineyard-hudson/cli/install/templates/cookbooks/main/attributes/recipe.rb

@@ -0,0 +1,3 @@
+recipes('main')
+owner_name(@attribute[:users].first[:username])
+owner_pass(@attribute[:users].first[:password])

data/lib/engineyard-hudson/cli/install/templates/cookbooks/main/definitions/ey_cloud_report.rb

@@ -0,0 +1,6 @@
+define :ey_cloud_report do
+  execute "reporting for #{params[:name]}" do
+    command "ey-enzyme --report '#{params[:message]}'"
+    epic_fail true
+  end
+end

data/lib/engineyard-hudson/cli/install/templates/cookbooks/main/libraries/ruby_block.rb

@@ -0,0 +1,40 @@
+
+class Chef
+  class Resource
+    class RubyBlock < Chef::Resource
+      def initialize(name, collection=nil, node=nil)
+        super(name, collection, node)
+        @resource_name = :ruby_block
+        @action = :create
+        @allowed_actions.push(:create)
+      end
+ 
+      def block(&block)
+        if block
+          @block = block
+        else
+          @block
+        end
+      end
+    end
+  end
+end
+
+
+class Chef
+  class Provider
+    class RubyBlock < Chef::Provider
+      def load_current_resource
+        Chef::Log.debug(@new_resource.inspect)
+        true
+      end
+ 
+      def action_create
+        @new_resource.block.call
+      end
+    end
+  end
+end
+
+Chef::Platform.platforms[:default].merge! :ruby_block => Chef::Provider::RubyBlock
+

data/lib/engineyard-hudson/cli/install/templates/cookbooks/main/libraries/run_for_app.rb

@@ -0,0 +1,12 @@
+class Chef
+  class Recipe
+    def run_for_app(*apps, &block)
+      apps.map! {|a| a.to_s }
+      node[:applications].map{|k,v| [k,v] }.sort_by {|a,b| a }.each do |name, app_data|
+        if apps.include?(name)
+          block.call(name, app_data)
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-hudson/cli/install/templates/recipes.rb

@@ -0,0 +1,83 @@
+#
+# Cookbook Name:: hudson_slave
+# Recipe:: default
+#
+
+env_name = node[:environment][:name]
+username = node[:users].first[:username]
+
+if ['solo','app_master'].include?(node[:instance_role]) && env_name =~ /_(ci|hudson_slave)$/
+  # gem_package "hudson" do
+  #   source "http://gemcutter.org"
+  #   version "0.3.0.beta.3"
+  #   action :install
+  # end
+
+  execute "install_hudson_in_resin" do
+    command "/usr/local/ey_resin/ruby/bin/gem install #{node[:hudson_slave][:gem][:install]}"
+    not_if { FileTest.directory?("/usr/local/ey_resin/ruby/gems/1.8/gems/#{node[:hudson_slave][:gem][:version]}") }
+  end
+  
+  ruby_block "authorize_hudson_master_key" do
+    authorized_keys = "/home/#{node[:users].first[:username]}/.ssh/authorized_keys"
+    block do
+      File.open(authorized_keys, "a") do |f|
+        f.puts node[:hudson_slave][:master][:public_key]
+      end
+    end
+    not_if "grep '#{node[:hudson_slave][:master][:public_key]}' #{authorized_keys}"
+  end
+  
+  execute "setup-git-config-for-tagging" do
+    command %Q{ sudo su #{username} -c "git config --global user.email 'you@example.com' && git config --global user.name 'You are Special'" }
+    not_if  %Q{ sudo su #{username} -c "git config user.email" }
+  end
+  
+  ruby_block "add-slave-to-master" do
+    block do
+      Gem.clear_paths
+      require "hudson"
+      require "hudson/config"
+
+      Hudson::Api.setup_base_url(node[:hudson_slave][:master])
+      
+      # Tell master about this slave
+      Hudson::Api.add_node(
+        :name        => env_name,
+        :description => "Automatically added by Engine Yard AppCloud for environment #{env_name}",
+        :slave_host  => node[:engineyard][:environment][:instances].first[:public_hostname],
+        :slave_user  => username,
+        :executors   => [node[:applications].size, 1].max,
+        :label       => node[:applications].keys.join(" ")
+      )
+    end
+    action :create
+  end
+
+  ruby_block "tell-master-about-new-jobs" do
+    block do
+      begin
+        job_names   = Hudson::Api.summary["jobs"].map {|job| job["name"]} # TODO Hudson::Api.job_names
+        app_names   = node[:applications].keys
+        apps_to_add = app_names - job_names
+
+        # Tell server about each application
+        apps_to_add.each do |app_name|
+          data = node[:applications][app_name]
+
+          job_config = Hudson::JobConfigBuilder.new("rails") do |c|
+            c.scm           = data[:repository_name]
+            c.assigned_node = app_name
+          end
+        
+          Hudson::Api.create_job(app_name, job_config)
+          Hudson::Api.build_job(app_name)
+        end
+      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
+        raise Exception, "No connection available to the Hudson server (#{Hudson::Api.base_uri})."
+      end
+    end
+    action :create
+  end
+
+end

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification 
+name: engineyard-hudson
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Dr Nic Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-30 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 33
+        segments: 
+        - 0
+        - 14
+        - 3
+        version: 0.14.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: engineyard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 1
+        - 3
+        - 3
+        version: 1.3.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
+        version: 0.8.7
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 61
+        segments: 
+        - 0
+        - 9
+        - 3
+        version: 0.9.3
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        - 0
+        version: 1.4.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: awesome_print
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: Run your continuous integration (CI) tests against your Engine Yard AppCloud environments - the exact same configuration you are using in production!
+email: 
+- drnicwilliams@gmail.com
+executables: 
+- ey-hudson
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- History.md
+- README.md
+- Rakefile
+- bin/ey-hudson
+- engineyard-hudson.gemspec
+- features/install.feature
+- features/server.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/fixture_project_steps.rb
+- features/step_definitions/hudson_steps.rb
+- features/support/common.rb
+- features/support/env.rb
+- features/support/matchers.rb
+- fixtures/cookbooks/main/recipes/default.rb
+- fixtures/cookbooks/redis/recipes/default.rb
+- fixtures/projects/rails/Gemfile
+- fixtures/projects/rails/Gemfile.lock
+- fixtures/projects/rails/Rakefile
+- lib/engineyard-hudson.rb
+- lib/engineyard-hudson/cli.rb
+- lib/engineyard-hudson/cli/install.rb
+- lib/engineyard-hudson/cli/install/templates/attributes.rb.erb
+- lib/engineyard-hudson/cli/install/templates/cookbooks/main/attributes/recipe.rb
+- lib/engineyard-hudson/cli/install/templates/cookbooks/main/definitions/ey_cloud_report.rb
+- lib/engineyard-hudson/cli/install/templates/cookbooks/main/libraries/ruby_block.rb
+- lib/engineyard-hudson/cli/install/templates/cookbooks/main/libraries/run_for_app.rb
+- lib/engineyard-hudson/cli/install/templates/recipes.rb
+has_rdoc: true
+homepage: http://github.com/engineyard/engineyard-hudson
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: engineyard-hudson
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easier to do CI than not to. Use Hudson CI on Engine Yard AppCloud.
+test_files: 
+- features/install.feature
+- features/server.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/fixture_project_steps.rb
+- features/step_definitions/hudson_steps.rb
+- features/support/common.rb
+- features/support/env.rb
+- features/support/matchers.rb