remy 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea/*
+junk*.*

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.8.7-p352@remy --create

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Gregory S. Woodward
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,235 @@
+# [Remy](http://www.github.com/gregwoodward/remy)
+
+Remy permits you to easily run chef-solo (one of the tools that is part of [Chef](http://www.opscode.com/chef/) from
+[Opscode](http://www.opscode.com/)), whether from within a stand-alone Ruby application, or from within a Rails project.
+Remy is "a little chef"; our contention is that you get 95-98% of the benefits of Chef without 95-98% of the hassles
+by **NOT** using [chef-client](http://wiki.opscode.com/display/chef/Chef+Client) &
+[chef-server](http://wiki.opscode.com/display/chef/Chef+Server), but rather just using
+[chef-solo](http://wiki.opscode.com/display/chef/Chef+Solo); Remy provides the missing tools which are required to
+easily use chef-solo. Remy allows you to build a remote cloud
+server box easily (whether from Rackspace or from some other cloud service provider), and then bootstrap it so that it
+can run chef-solo (the bootstrap will also run on physical, not cloud, boxes; all that's required is remote host at a valid IP address
+for Remy to use). Remy then provides an easy and convenient way to run chef-solo against these remote boxes, either
+programmatically or from some rake tasks that are provided. The ability to support a cluster of boxes plus multiple config files
+& directories (where some of these config files might contain passwords on encrypted drives) is what distinguishes Remy
+from [soloist](https://github.com/mkocher/soloist) and other chef-solo utilities; these multiple config files and
+directories are then "blended" together to create an overall chef configuration (as JSON) for a particular chef node.
+
+We also do Test-Driven Chef (TDC) in our example recipes; rspec specs are run on the remote boxes to verify that the
+packages and configuration are installed properly; we use these specs to drive the creation of the Chef recipes.
+
+Note that the Chef bootstrap portion of Remy is currently limited to Ubuntu (it contains references to 'apt-get'), but the
+chef-solo part of Remy can run on any type of Unix if the box has been properly bootstrapped for Chef. Also note that it
+would be relatively simple to extend Remy to support yum and CentOS/RedHat and other Unix OS's.
+
+
+## Basic usage:
+
+See [the Remy simple Rails example](http://www.github.com/gregwoodward/remy_simple_rails_example) for the absolute simplest
+Remy installation with a "Hello world" recipe; you can be up and running with chef-solo in under 5 minutes.
+[The Remy cluster rails example](http://www.github.com/gregwoodward/remy_cluster_rails_example) shows a full Rails
+installation with a clustered environment for staging and production, and a single box which hosts the entire Rails app
+for the demo environment; multiple config files are used because passwords are stored separately on an encrypted drive.
+These are the actual recipes we use for our clustered server environment at [SharesPost](http://www.sharespost.com/).
+
+
+## Concepts
+
+Remy is configured as shown in an example Remy configuration file [config/initializers/remy.rb](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/config/initializers/remy.rb),
+along with the example yml files in [chef/config/chef.yml](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/config/chef.yml) and
+[SecureEncryptedDrive/chef/config/chef.yml](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/SecureEncryptedDrive/chef/config/chef.yml)
+(this 'SecureEncryptedDrive' would normally not be a part of the Rails project, but rather an encrypted disk volume which is mounted such as
+/Volumes/SecureEncryptedDrive).  To use Remy, create a cookbooks directory which contains all of your recipes (see
+[chef/cookbooks](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/cookbooks) as an example;
+these cookbook directories should be in the [standard Opscode Chef cookbooks format](http://wiki.opscode.com/display/chef/Cookbooks) ).
+The location of the chef cookbooks directory is specified in the Remy configuration (see
+[remy.rb](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/config/initializers/remy.rb)); the default
+location is /var/chef on the remote boxes, and is typically put in RAILS_ROOT/chef/cookbooks in your local Rails app.
+Within one of these YAML files, create an array of servers as specified by :servers (see
+[chef/config/chef.yml](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/config/chef.yml) ). The values in the yml config files
+which are loaded last take precedence over those which were loaded earlier, and options passed directly into Remy take
+precedence over values in the yml config files.
+
+Remy is typically used programmatically in a Capistrano deploy file or other Rails code
+(see [deploy.rb](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/deploy.rb)), or by using the supplied Remy rake tasks
+(see [remy.rake](http://www.github.com/gregwoodward/remy/blob/master/lib/tasks/remy.rake)).
+
+### Remy yml config files
+
+The Remy yml files can be pretty much in whatever format you desire with a few constraints; see
+[this example for simple usage](https://github.com/gregwoodward/remy_simple_rails_example/blob/master/chef/config/chef.yml), and this one for
+[an advanced example to support a cluster](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/config/chef.yml).
+
+These are keys which have special significance in the Remy config files; see :ip_address, :servers, and :cloud_configuration
+[here](https://github.com/gregwoodward/remy_simple_rails_example/blob/master/chef/config/chef.yml),
+[here](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/config/chef.yml), and
+[here](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/SecureEncryptedDrive/chef/config/chef.yml) for examples.
+
+#### :ip_address
+
+:ip_address is the IP address of the box which chef-solo will run against. Normally, this is given to Remy as part of the options
+arguments (either programmatically, or from a rake task) and is not in the yml config files, but it could also come in from one of the Remy yml config file(s).
+The simplest usage of Remy to run chef-solo is:
+
+`Remy::Chef.new(:ip_address => '123.123.123.123').run`
+
+where '123.123.123.123' is the IP address that chef-solo will run on. Note that:
+
+`Remy::Chef.new.run`
+
+would also work if :ip_address was specified somewhere in the Remy configuration (i.e., it was specified in one of the Remy yml files); this is
+the case in the [chef.yml in the "hello world" Remy example](http://www.github.com/gregwoodward/remy_simple_rails_example/blob/master/chef/config/chef.yml)
+
+
+#### :servers
+
+If you are configuring a cluster of boxes, look at the [chef/config/chef.yml](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/config/chef.yml)
+file as an example. You'll see a :servers section; each server should specify its :ip_address. When Remy runs, Remy will
+find the section of the :servers in the yml file which has the same :ip_address as the currently specified value, and
+those values will get "promoted" to the top level, and applied against this chef node (i.e., JSON will be generated which
+contains these values).
+
+#### :cloud_configuration
+
+You can specify the cloud server configuration in a :cloud_configuration section in one of the Remy config yml files;
+see [SecureEncryptedDrive/chef/config/chef.yml](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/SecureEncryptedDrive/chef/config/chef.yml) for an example.
+Alternatively, these cloud values can also be passed into the various Remy rake commands; see :server_name, :cloud_api_key, :cloud_username,
+etc., in the Rake commands in [remy.rake](http://www.github.com/gregwoodward/remy/blob/master/lib/tasks/remy.rake).
+
+#### :bootstrap
+
+You can specify the Ruby version that gets installed on a new remote box, along with the versions of the various bootstrap
+Ruby gems (chef, bundler, and rspec) in the yml config files; see
+[chef.yml](http://www.github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/config/chef.yml) for an example
+of these parameters.
+
+
+## Remy usage from Rake
+
+### Create a new cloud server
+
+Use the following rake command to create a new cloud server:
+
+`rake remy:server:create[:server_name, :flavor_id, :cloud_api_key, :cloud_username, :cloud_provider, :image_id]`
+
+e.g.,
+
+`rake remy:server:create[foobar.sharespost.com,4,abcdefg1234,sharespost,Rakespace,49]`
+
+Note that if you have the :cloud_api_key, etc., specified in your Remy configuration yml files, you can omit those arguments to the
+rake command:
+
+`rake remy:server:create[foobar.sharespost.com,4]`
+
+[See here](http://obn.me/2011/04/rackspace-cloud-images-and-flavors-id/) for a list of Rackspace flavor IDs and image
+IDs (they might differ for other cloud providers).
+
+### Bootstrap your new cloud server to run Remy and chef-solo
+
+This bootstrap task installs the prerequisites necessary to run chef on this new remote box, such as updating the Linux
+distribution, installing RVM, installing the Chef gem and its prerequisites, and installing rspec (which is required
+because we do test-driven Chef):
+
+`rake remy:chef:bootstrap[:ip_address, :password]`
+
+
+### Build and bootstrap your cloud server
+
+You can both build a box and bootstrap it for chef-solo all in one step:
+
+`rake remy:server:create_and_bootstrap[:server_name, :flavor_id, :cloud_api_key, :cloud_username, :cloud_provider, :image_id]`
+
+### Run chef-solo
+
+`rake remy:chef:run['123.123.123.123']`
+
+will run chef-solo on the remote host at 123.123.123.123. You can also specify the rake arguments as properties:
+
+`rake remy:chef:run['ip_address:123.123.123.123']`
+
+Run Remy against a collection of remote nodes:
+
+`rake remy:chef:run['rails_env:staging role:app']`
+
+This will run Remy against all app servers for the staging environment; i.e., all servers in the :servers section of the Remy config files
+that match :rails_env = :staging and :role = :app will have Remy (i.e., chef-solo) run on them.  Run Remy against a
+specific named node:
+
+`rake remy:chef:run['demo.sharespost.com']`
+
+This assumes that 'demo.sharespost.com' is specified in the :servers section of a Remy yml config file.
+
+
+## Remy usage from Ruby code (i.e., from within Capistrano or elsewhere)
+
+### Run chef-solo on a single box:
+
+The simplest usage of Remy (Note: this only works if the Remy.configuration has already been specified, such as within
+a Rails application):
+
+`Remy::Chef.new(:ip_address => '123.123.123.123').run`
+
+Note that the :ip_address could also have been specified in the yml config files, although more commonly it's passed in
+as an argument.
+
+Example: update your production database box:
+
+    server_config = Remy.find_server_config(:rails_env => :production, :role => :db)
+    Remy::Chef.new(server_config).run
+
+Other arguments can be passed into chef and will get applied against this node:
+
+`Remy::Chef.new(:ip_address => '123.123.123.123', :color => :blue, :height => :short).run`
+
+means that you can access node['color'] and node['height'] from within your Chef recipes, which will be :blue and :short,
+respectively. You can also give arguments which will be passed to chef-solo:
+
+`Remy::Chef.new(:ip_address => '123.123.123.123', :chef_arguments => '-l debug').run`
+
+which will make chef-solo run in debug mode.
+
+
+### Run chef-solo on a collection of boxes:
+
+From within your Capistrano file, you do a variety of things, such as the following:
+
+    Remy.servers.find_servers(:rails_env => :staging, :role => :app) do |server|
+        Remy::Chef.new(server).run
+    end
+
+## Chef location on the remote box
+
+The chef files are installed in /var/chef by default (this can be overridden to be another location in the
+[Remy configuration](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/config/initializers/remy.rb)).
+
+### Running chef-solo manually on the remote box
+
+You can always ssh into the remote box, cd into the chef directory (/var/chef by default; it could have been overridden in the
+Remy configuration), and run chef-solo by typing
+
+`/var/chef/run_chef_solo`
+
+as root. You can pass in debug arguments for chef-solo, e.g.:
+
+`/var/chef/run_chef_solo -l debug`
+
+If you ssh to the remote box, you can see the glob of JSON that was created by blending together all of the various
+Remy yml config files at /var/chef/node.json.
+
+
+
+## Test-Driven Chef (TDC)
+
+Look at the example specs in [chef/spec](http://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/spec) to see how we do
+Test-Driven Chef (TDC). When writing our recipes, we first write a failing spec, and then write the Chef recipe to
+make this test pass; we then refactor the recipe as needed. Each time Remy (i.e., chef-solo) is run on a remote box, the
+specs for this recipe are also run. As an example of this, see the
+[bottom of this recipe](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/cookbooks/server_bootstrap/recipes/create_user.rb)
+for where spot where the specs are invoked for the Chef recipe 'create_user'.  The
+[specs for this recipe are here](https://github.com/gregwoodward/remy_cluster_rails_example/blob/master/chef/spec/server_bootstrap/create_user_spec.rb)
+and consist of the various things that one would want to check for when this recipe executes. Note that these specs run on the remote box,
+not the local box.
+
+## License
+
+Remy is released under the MIT license.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+Dir['lib/tasks/**/*.rake'].each {|file| load file }
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+end
+
+task :default => :spec

data/chef/cookbooks/hello_world/recipes/default.rb

@@ -0,0 +1,13 @@
+template "/tmp/hello_world.txt" do
+  source "hello_world.txt.erb"
+  owner 'root'
+  group 'staff'
+  mode "644"
+  variables(:color => node['color'], :ip_address => node['ip_address'], :rails_env => node['rails_env'])
+end
+
+ruby_block "test" do
+  block do
+    puts `rspec -f progress #{File.expand_path(File.join(File.dirname(__FILE__), '../../../spec/hello_world/default_spec.rb'))}`
+  end
+end

data/chef/cookbooks/hello_world/templates/default/hello_world.txt.erb

@@ -0,0 +1,6 @@
+hello, world! I am feeling <%= @color %>!
+My rails env is <%= @rails_env %>
+My IP is <%= @ip_address %>
+
+Node info: <%= node.to_yaml %>
+

data/chef/roles/test_role.rb

@@ -0,0 +1,3 @@
+name 'test_role'
+description 'This is a test role'
+run_list 'recipe[hello_world]'

data/chef/roles/test_role2.json

@@ -0,0 +1,9 @@
+{
+  "name": "test_role2",
+  "default_attributes": { },
+  "override_attributes": { },
+  "json_class": "Chef::Role",
+  "description": "A 2nd test role",
+  "chef_type": "role",
+  "run_list": [ "recipe[hello_world]" ]
+}

data/chef/spec/hello_world/default_spec.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+
+describe 'hello_world/default' do
+  it { File.exist?('/tmp/hello_world.txt').should be_true }
+  it { File.read('/tmp/hello_world.txt').should include('blue') }
+end

data/lib/remy/bootstrap.rb

@@ -0,0 +1,82 @@
+module Remy
+  class Bootstrap
+    include ::Remy::Shell
+
+    attr_reader :ip_address, :ruby_version, :password, :gems
+
+    def initialize(options = { })
+      @ip_address = options[:ip_address]
+      @password = options[:password]
+      options = (Remy.bootstrap || {}).merge(options).symbolize_keys
+      @ruby_version = options[:ruby_version] || '1.8.7'
+      @gems = options[:gems] || {}
+      @quiet = options[:quiet] || false
+    end
+
+    def run
+      copy_ssh_key_to_remote
+      update_linux_distribution
+      install_rvm
+      install_gems_to_bootstrap_chef
+    end
+
+    private
+
+    def apt_get_rvm_packages
+      # This list of required packages came from doing "rvm requirements"
+      remote_apt_get 'build-essential openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison'
+    end
+
+    def install_gems_to_bootstrap_chef
+      remote_gem 'bundler', :version => gems[:bundler]
+      remote_gem 'chef',    :version => gems[:chef]
+      remote_gem 'rspec',   :version => gems[:rspec] # Required because we do Test-Driven Chef (TDC)!
+    end
+
+    def install_rvm
+      remote_execute rvm_multi_user_install
+      apt_get_rvm_packages
+      remote_execute "/usr/local/rvm/bin/rvm install #{ruby_version}"
+      remote_execute "/usr/local/rvm/bin/rvm #{ruby_version} --default"
+    end
+
+    def rvm_multi_user_install
+      'curl -s https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer -o rvm-installer ; chmod +x rvm-installer ; sudo -s ./rvm-installer --version latest'
+    end
+
+    def is_ssh_copy_id_installed_locally?
+      `which ssh-copy-id`.length > 0
+    end
+
+    def copy_ssh_key_to_remote
+      raise "ssh-copy-id is not installed locally! On the Mac, do 'brew install ssh-copy-id'" unless is_ssh_copy_id_installed_locally?
+      is_ssh_key_in_local_known_hosts_file = `grep "#{ip_address}" ~/.ssh/known_hosts`.length > 0
+      if is_ssh_key_in_local_known_hosts_file
+        execute %Q{expect -c 'spawn ssh-copy-id #{user}@#{ip_address}; expect assword ; send "#{password}\\n" ; interact'}
+      else
+        execute %Q{expect -c 'spawn ssh-copy-id #{user}@#{ip_address}; expect continue; send "yes\\n"; expect assword ; send "#{password}\\n" ; interact'}
+      end
+    end
+
+    def quiet?
+      @quiet
+    end
+
+    def remote_gem(gem_name, options={ })
+      if options[:version]
+        version = options[:version]
+        raise ArgumentError.new unless version.match(/^\d[.\d]+\d/)
+        version_info = "-v #{version}"
+      end
+      remote_execute "/usr/local/rvm/bin/gem install #{gem_name} #{version_info} --no-rdoc --no-ri"
+    end
+
+    def remote_apt_get(package_name)
+      remote_execute "apt-get install -y #{package_name}"
+    end
+
+    def update_linux_distribution
+      remote_execute 'apt-get update && apt-get --yes upgrade'
+    end
+  end
+end

data/lib/remy/chef.rb

@@ -0,0 +1,135 @@
+module Remy
+  class Chef
+    # For chef-solo info, see: http://wiki.opscode.com/display/chef/Chef+Solo
+    include ::Remy::Shell
+    include FileUtils
+    attr_reader :ip_address
+
+    def initialize(options = {})
+      options = JSON.parse(options).symbolize_keys! if options.is_a?(String)
+      @chef_args = options.delete(:chef_args)
+      @quiet = options.delete(:quiet)
+      @node_configuration = Remy.configuration.dup
+      @ip_address = options[:ip_address] ? options[:ip_address] : @node_configuration.ip_address
+      server_config = Remy.find_server_config(:ip_address => ip_address) || Hashie::Mash.new
+      @node_configuration.deep_merge!(server_config)
+      @node_configuration.merge!(options)
+    end
+
+    def run
+      create_temp_dir_which_contains_cookbooks_roles_and_scripts
+      rsync_temp_dir_with_cookbooks_to_remote_host
+      run_chef_solo_on_remote_host
+    end
+
+    def self.rake_run(rake_options)
+      ip_addresses = Remy.determine_ip_addresses_for_remy_run(rake_options)
+      ip_addresses.each do |ip_address|
+        Remy::Chef.new(:ip_address => ip_address).run
+      end
+    end
+
+    private
+
+    def create_temp_dir_which_contains_cookbooks_roles_and_scripts
+      create_temp_dir
+      copy_spec_cookbook_and_role_dirs_to_tmp_dir
+      create_solo_rb
+      create_bash_script_which_runs_chef
+      create_node_json_from_node_configuration
+    end
+
+    def rsync_temp_dir_with_cookbooks_to_remote_host
+      remote_execute "mkdir -p #{remote_chef_dir}"
+      olddir = pwd
+      begin
+        chdir(tmp_dir)
+        execute "rsync -a #{rsync_delete_flag} * #{user}@#{ip_address}:#{remote_chef_dir}"
+      ensure
+        chdir(olddir)
+      end
+    end
+
+    def run_chef_solo_on_remote_host
+      remote_execute "bash --login -c #{remote_chef_dir}/#{run_chef_solo_bash_script}"
+    end
+
+    def create_temp_dir
+      @tmpdir = Dir.mktmpdir
+    end
+
+    def rsync_delete_flag
+      if remote_execute("test -e #{remote_chef_dir}")
+        chef_dir_contains_valid_chef_content = remote_execute("test -e #{remote_chef_dir}/#{node_json} && test -e #{remote_chef_dir}/#{solo_rb}")
+        chef_dir_contains_valid_chef_content ? '--delete' : nil
+      end
+    end
+
+    def copy_spec_cookbook_and_role_dirs_to_tmp_dir
+      [@node_configuration.roles_path, @node_configuration.cookbook_path, @node_configuration.spec_path].each do |path|
+        if path
+          full_path = path.map{|p| File.expand_path(p) }
+          full_path.each do |a_path|
+            cp_r a_path, tmp_dir
+          end
+        end
+      end
+    end
+
+    def create_solo_rb
+      solo_rb_contents = <<-EOF
+file_cache_path "#{remote_chef_dir}"
+cookbook_path ["#{remote_chef_dir}/cookbooks"]
+role_path "#{remote_chef_dir}/roles"
+cache_options({ :path => "#{remote_chef_dir}/cache/checksums", :skip_expires => true })
+EOF
+      File.open(File.join(tmp_dir, solo_rb), 'w+') do |f|
+        f << solo_rb_contents
+      end
+    end
+
+    def create_bash_script_which_runs_chef
+      run_chef = <<-EOF
+#!/bin/bash
+# Pass "-l debug" to this script to get more debug output
+
+# $@ gets the array of args from Bash
+chef-solo $@ #{@chef_args} -j #{remote_chef_dir}/#{node_json} -c #{remote_chef_dir}/#{solo_rb}
+EOF
+      File.open(File.join(tmp_dir, run_chef_solo_bash_script), 'w+') do |f|
+        f << run_chef
+      end
+      chmod(0755, File.join(tmp_dir, run_chef_solo_bash_script))
+    end
+
+    def create_node_json_from_node_configuration
+      File.open(File.join(tmp_dir, node_json), 'w+') do |f|
+        f << @node_configuration.to_json
+      end
+    end
+
+    def node_json
+      'node.json'
+    end
+
+    def solo_rb
+      'solo.rb'
+    end
+
+    def remote_chef_dir
+      @node_configuration.remote_chef_dir
+    end
+
+    def tmp_dir
+      File.expand_path(@tmpdir)
+    end
+
+    def run_chef_solo_bash_script
+      'run_chef_solo'
+    end
+
+    def quiet?
+      @quiet
+    end
+  end
+end