chef-solr 0.9.18 → 0.10.0.beta.0

data/bin/{chef-solr-indexer → chef-solr-installer}

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009, 2011 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,11 +18,8 @@
 #
 
 require 'rubygems'
-
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")))
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "chef", "lib")))
-
-require 'chef/solr/application/indexer'
+require 'chef/solr/solr_installer'
 
-Chef::Solr::Application::Indexer.new.run
+Chef::SolrInstaller.new(ARGV).run
 

data/lib/chef/solr.rb

@@ -1,234 +1 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'chef/mixin/xml_escape'
-require 'chef/log'
-require 'chef/config'
-require 'chef/couchdb'
-require 'net/http'
-require 'libxml'
-require 'uri'
-
-class Chef
-  class Solr
-
-    include Chef::Mixin::XMLEscape
-
-    attr_accessor :solr_url, :http
-
-    def initialize(solr_url=Chef::Config[:solr_url])
-      @solr_url = solr_url
-      uri = URI.parse(@solr_url)
-      @http = Net::HTTP.new(uri.host, uri.port)
-    end
-
-    def solr_select(database, type, options={})
-      options[:wt] = :ruby
-      options[:indent] = "off"
-      options[:fq] = if type.kind_of?(Array)
-                       "+X_CHEF_database_CHEF_X:#{database} +X_CHEF_type_CHEF_X:#{type[0]} +data_bag:#{type[1]}"
-                     else
-                       "+X_CHEF_database_CHEF_X:#{database} +X_CHEF_type_CHEF_X:#{type}"
-                     end
-      select_url = "/solr/select?#{to_params(options)}"
-      Chef::Log.debug("Sending #{select_url} to Solr")
-      req = Net::HTTP::Get.new(select_url)
-
-      description = "Search Query to Solr '#{solr_url}#{select_url}'"
-
-      res = http_request_handler(req, description)
-      Chef::Log.debug("Parsing Solr result set:\n#{res.body}")
-      eval(res.body)
-    end
-
-    def post_to_solr(doc)
-      Chef::Log.debug("POSTing document to SOLR:\n#{doc}")
-      req = Net::HTTP::Post.new("/solr/update", "Content-Type" => "text/xml")
-      req.body = doc.to_s
-
-      description = "POST to Solr '#{solr_url}'"
-
-      http_request_handler(req, description)
-    end
-
-    START_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<add><doc>"
-    END_XML   = "</doc></add>\n"
-    FIELD_ATTR = '<field name="'
-    FIELD_ATTR_END = '">'
-    CLOSE_FIELD = "</field>"
-
-    def solr_add(data)
-      Chef::Log.debug("adding to SOLR: #{data.inspect}")
-
-      xml = ""
-      xml << START_XML
-
-      data.each do |field, values|
-        values.each do |v|
-          xml << FIELD_ATTR
-          xml << xml_escape(field)
-          xml << FIELD_ATTR_END
-          xml <<  xml_escape(v)
-          xml << CLOSE_FIELD
-        end
-      end
-      xml << END_XML
-      xml
-
-      post_to_solr(xml)
-    end
-
-    def solr_commit(opts={})
-      post_to_solr(generate_single_element("commit", opts))
-    end
-
-    def solr_optimize(opts={})
-      post_to_solr(generate_single_element("optimize", opts))
-    end
-
-    def solr_rollback
-      post_to_solr(generate_single_element("rollback"))
-    end
-
-    def solr_delete_by_id(ids)
-      post_to_solr(generate_delete_document("id", ids))
-    end
-
-    def solr_delete_by_query(queries)
-      post_to_solr(generate_delete_document("query", queries))
-    end
-
-    def rebuild_index(url=Chef::Config[:couchdb_url], db=Chef::Config[:couchdb_database])
-      solr_delete_by_query("X_CHEF_database_CHEF_X:#{db}")
-      solr_commit
-
-      results = {}
-      [Chef::ApiClient, Chef::Node, Chef::Role].each do |klass|
-        results[klass.name] = reindex_all(klass) ? "success" : "failed"
-      end
-      databags = Chef::DataBag.cdb_list(true)
-      Chef::Log.info("Reloading #{databags.size.to_s} #{Chef::DataBag} objects into the indexer")
-      databags.each { |i| i.add_to_index; i.list(true).each { |x| x.add_to_index } }
-      results[Chef::DataBag.name] = "success"
-      results
-    end
-
-    private
-
-    def reindex_all(klass, metadata={})
-      begin
-        items = klass.cdb_list(true)
-        Chef::Log.info("Reloading #{items.size.to_s} #{klass.name} objects into the indexer")
-        items.each { |i| i.add_to_index }
-      rescue Net::HTTPServerException => e
-        # 404s are okay, there might not be any of that kind of object...
-        if e.message =~ /Not Found/
-          Chef::Log.warn("Could not load #{klass.name} objects from couch for re-indexing (this is ok if you don't have any of these)")
-          return false
-        else
-          raise e
-        end
-      rescue Exception => e
-        Chef::Log.fatal("Chef encountered an error while attempting to load #{klass.name} objects back into the index")
-        raise e
-      end
-      true
-    end
-
-    def generate_single_element(elem, opts={})
-      xml_document = LibXML::XML::Document.new
-      xml_elem = LibXML::XML::Node.new(elem)
-      opts.each { |k,v| xml_elem[k.to_s] = xml_escape(v.to_s) }
-      xml_document.root = xml_elem
-      xml_document.to_s(:indent => false)
-    end
-
-    def generate_delete_document(type, list)
-      list = [list] unless list.is_a?(Array)
-      xml_document = LibXML::XML::Document.new
-      xml_delete = LibXML::XML::Node.new("delete")
-      xml_document.root = xml_delete
-      list.each do |id|
-        xml_id = LibXML::XML::Node.new(type)
-        xml_id.content = id.to_s
-        xml_delete << xml_id
-      end
-      xml_document.to_s(:indent => false)
-    end
-
-    # Thanks to Merb!
-    def to_params(params_hash)
-      params = ''
-      stack = []
-
-      params_hash.each do |k, v|
-        if v.is_a?(Hash)
-          stack << [k,v]
-        else
-          params << "#{k}=#{escape(v)}&"
-        end
-      end
-
-      stack.each do |parent, hash|
-        hash.each do |k, v|
-          if v.is_a?(Hash)
-            stack << ["#{parent}[#{k}]", escape(v)]
-          else
-            params << "#{parent}[#{k}]=#{escape(v)}&"
-          end
-        end
-      end
-
-      params.chop! # trailing &
-      params
-    end
-
-    # escapes a query key/value for http
-    # Thanks to RSolr!
-    def escape(s)
-      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
-        '%'+$1.unpack('H2'*$1.size).join('%').upcase
-      }.tr(' ', '+')
-    end
-    
-    # handles multiple net/http exceptions and no method closed? bug
-    def http_request_handler(req, description='HTTP call')
-      res = @http.request(req)
-      unless res.kind_of?(Net::HTTPSuccess)
-        Chef::Log.fatal("#{description} failed (#{res.class} #{res.code} #{res.message})")
-        res.error!
-      end
-      res
-    rescue Timeout::Error, Errno::EINVAL, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT, NoMethodError => e
-      # http://redmine.ruby-lang.org/issues/show/2708
-      # http://redmine.ruby-lang.org/issues/show/2758
-      if e.to_s =~ /#{Regexp.escape(%q|undefined method 'closed?' for nil:NilClass|)}/
-        Chef::Log.fatal("#{description} failed.  Chef::Exceptions::SolrConnectionError exception: Errno::ECONNREFUSED (net/http undefined method closed?) attempting to contact #{@solr_url}")
-        Chef::Log.debug("rescued error in http connect, treating it as Errno::ECONNREFUSED to hide bug in net/http")
-        Chef::Log.debug(e.backtrace.join("\n"))
-        raise Chef::Exceptions::SolrConnectionError, "Errno::ECONNREFUSED: Connection refused attempting to contact #{@solr_url}"
-      end
-
-      Chef::Log.fatal("#{description} failed.  Chef::Exceptions::SolrConnectionError exception: #{e.class.name}: #{e.to_s} attempting to contact #{@solr_url}")
-      Chef::Log.debug(e.backtrace.join("\n"))
-
-      raise Chef::Exceptions::SolrConnectionError, "#{e.class.name}: #{e.to_s}"
-    end
-
-  end
-end
+require 'chef/solr/version'

data/lib/chef/solr/application/solr.rb

@@ -15,12 +15,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'chef'
+
+require 'rexml/document'
 require 'chef/log'
 require 'chef/config'
 require 'chef/application'
 require 'chef/daemon'
-require 'chef/client'
 require 'chef/solr'
 
 class Chef
@@ -116,7 +116,76 @@ class Chef
           super
         end
 
+        def schema_file_path
+          @schema_file_path ||= File.join(Chef::Config[:solr_home_path], 'conf', 'schema.xml')
+        end
+
+
+        def schema_document
+          @schema_document ||= begin
+            File.open(schema_file_path, 'r') do |xmlsux|
+              REXML::Document.new(xmlsux)
+            end
+          end
+        end
+
+        def schema_attributes
+          @schema_attributes ||= REXML::XPath.first(schema_document, '/schema').attributes
+        end
+
+        def solr_schema_name
+          schema_attributes["name"]
+        end
+
+        def solr_schema_version
+          schema_attributes["version"]
+        end
+
+        def valid_schema_name?
+          solr_schema_name == Chef::Solr::SCHEMA_NAME
+        end
+
+        def valid_schema_version?
+          solr_schema_version == Chef::Solr::SCHEMA_VERSION
+        end
+
+        def solr_home_exist?
+          File.directory?(Chef::Config[:solr_home_path])
+        end
+
+        def solr_data_dir_exist?
+          File.directory?(Chef::Config[:solr_data_path])
+        end
+
+        def solr_jetty_home_exist?
+          File.directory?(Chef::Config[:solr_jetty_path])
+        end
+
+        def assert_solr_installed!
+          unless solr_home_exist? && solr_data_dir_exist? && solr_jetty_home_exist?
+            Chef::Log.fatal "Chef Solr is not installed or solr_home_path, solr_data_path, and solr_jetty_path are misconfigured."
+            Chef::Log.fatal "Your current configuration is:"
+            Chef::Log.fatal "solr_home_path:  #{Chef::Config[:solr_home_path]}"
+            Chef::Log.fatal "solr_data_path:  #{Chef::Config[:solr_data_path]}"
+            Chef::Log.fatal "solr_jetty_path: #{Chef::Config[:solr_jetty_path]}"
+            Chef::Log.fatal "You can install Chef Solr using the chef-solr-installer script."
+            exit 1
+          end
+        end
+
+        def assert_valid_schema!
+          unless valid_schema_name? && valid_schema_version?
+            Chef::Log.fatal "Your Chef Solr installation needs to be upgraded."
+            Chef::Log.fatal "Expected schema version #{Chef::Solr::SCHEMA_VERSION} but version #{solr_schema_version} is installed."
+            Chef::Log.fatal "Use chef-solr-installer to upgrade your Solr install after backing up your data."
+            exit 1
+          end
+        end
+
         def setup_application
+          assert_solr_installed!
+          assert_valid_schema!
+
           # Need to redirect stdout and stderr so Java process inherits them.
           # If -L wasn't specified, Chef::Config[:log_location] will be an IO
           # object, otherwise it will be a String.
@@ -128,47 +197,7 @@ class Chef
 
           Chef::Log.level = Chef::Config[:log_level]
 
-          # Build up a client
-          node = Chef::Node.new
-          node.platform = :default
-          node.platform_version = 42
-
           Chef::Daemon.change_privilege
-
-          solr_base = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "..", "solr"))
-
-          run_context = Chef::RunContext.new(node, {})
-          # Create the Jetty container
-          unless File.directory?(Chef::Config[:solr_jetty_path])
-            Chef::Log.warn("Initializing the Jetty container")
-            solr_jetty_dir = Chef::Resource::Directory.new(Chef::Config[:solr_jetty_path], run_context)
-            solr_jetty_dir.recursive(true)
-            solr_jetty_dir.run_action(:create)
-            solr_jetty_untar = Chef::Resource::Execute.new("untar_jetty", run_context)
-            solr_jetty_untar.command("tar zxvf #{File.join(solr_base, 'solr-jetty.tar.gz')}")
-            solr_jetty_untar.cwd(Chef::Config[:solr_jetty_path])
-            solr_jetty_untar.run_action(:run)
-          end
-
-          # Create the solr home
-          unless File.directory?(Chef::Config[:solr_home_path])
-            Chef::Log.warn("Initializing Solr home directory")
-            solr_home_dir = Chef::Resource::Directory.new(Chef::Config[:solr_home_path], run_context)
-            solr_home_dir.recursive(true)
-            solr_home_dir.run_action(:create)
-            solr_jetty_untar = Chef::Resource::Execute.new("untar_solr_home", run_context)
-            solr_jetty_untar.command("tar zxvf #{File.join(solr_base, 'solr-home.tar.gz')}")
-            solr_jetty_untar.cwd(Chef::Config[:solr_home_path])
-            solr_jetty_untar.run_action(:run)
-          end
-
-          # Create the solr data path
-          unless File.directory?(Chef::Config[:solr_data_path])
-            Chef::Log.warn("Initializing Solr data directory")
-            solr_data_dir = Chef::Resource::Directory.new(Chef::Config[:solr_data_path], run_context)
-            solr_data_dir.recursive(true)
-            solr_data_dir.run_action(:create)
-          end
         end
 
         def run_application
@@ -191,7 +220,6 @@ class Chef
 
               STDOUT.reopen(@logfile)
               STDERR.reopen(@logfile)
-              @logfile.close
             end
 
             Kernel.exec(command)

data/lib/chef/solr/solr_installer.rb

@@ -0,0 +1,385 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com)
+# Copyright:: Copyright (c) 2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'pp'
+require 'optparse'
+require 'chef/solr/version'
+require 'chef/shell_out'
+require 'chef/mixin/shell_out'
+
+class Chef
+  class SolrInstaller
+
+    class Config
+      class CompatConfig
+        def initialize
+          @config_settings = {}
+        end
+
+        def from_file(file)
+          file = File.expand_path(file)
+          if File.readable?(file)
+            instance_eval(IO.read(file), file, 1)
+          else
+            STDERR.puts "Cannot open config file #{file} default settings will be used"
+          end
+          self
+        end
+
+        def method_missing(method_name, *args, &block)
+          if args.size == 1
+            @config_settings[method_name] = args.first
+          elsif args.empty?
+            @config_settings[method_name] or super
+          else
+            super
+          end
+        end
+
+        def to_hash
+          @config_settings
+        end
+      end
+
+
+      def self.default_values
+        @default_values ||= {}
+      end
+
+      def self.configurables
+        @configurables ||= []
+      end
+
+      def self.configurable(value, default=nil)
+        configurables << value
+        attr_accessor value
+        default_values[value] = default if default
+      end
+
+      def each_configurable
+        self.class.configurables.each do |config_param|
+          yield [config_param, send(config_param)]
+        end
+      end
+
+      configurable :config_file, '/etc/chef/solr.rb'
+
+      # Defaults to /var/chef
+      configurable :solr_base_path, nil
+
+      def solr_base_path
+        @solr_base_path || '/var/chef'
+      end
+
+      # Sets the solr_base_path. Also resets solr_home_path, solr_jetty_path,
+      # and solr_data_path.
+      def solr_base_path=(base_path)
+        @solr_home_path, @solr_jetty_path, @solr_data_path = nil,nil,nil
+        @solr_base_path = base_path
+      end
+
+
+      # Computed from base path, defaults to /var/chef/solr
+      configurable :solr_home_path, nil
+
+      def solr_home_path
+        @solr_home_path || File.join(solr_base_path, 'solr')
+      end
+
+      # Computed from base path, defaults to /var/chef/solr-jetty
+      configurable :solr_jetty_path, nil
+
+      def solr_jetty_path
+        @solr_jetty_path || File.join(solr_base_path, 'solr-jetty')
+      end
+
+      # Computed from base path, defaults to /var/chef/solr/data
+      configurable :solr_data_path, nil
+
+      def solr_data_path
+        @solr_data_path || File.join(solr_base_path, 'solr', 'data')
+      end
+
+
+      configurable :user, nil
+
+      configurable :group, nil
+
+      configurable :force, false
+
+      alias :force? :force
+
+      configurable :noop, false
+
+      alias :noop? :noop
+
+      def initialize
+        apply_hash(self.class.default_values)
+      end
+
+      def configure_from(argv)
+        cli_config = CLI.parse_options(argv)
+        #pp :cli_config => cli_config.to_hash
+        config_file_config = CompatConfig.new.from_file(cli_config.config_file).to_hash
+        #pp :config_file_config => config_file_config
+        apply_hash(config_file_config)
+        apply_hash(cli_config.to_hash)
+        #pp :combined_config => self.to_hash
+        self
+      end
+
+      def to_hash
+        self.class.configurables.inject({}) do |hash, config_option|
+          value = instance_variable_get("@#{config_option}".to_sym)
+          hash[config_option] = value if value
+          hash
+        end
+      end
+
+      def apply_hash(hash)
+        hash.each do |key, value|
+          method_for_key = "#{key}=".to_sym
+          if respond_to?(method_for_key)
+            send(method_for_key, value)
+          else
+            STDERR.puts("Configuration setting #{key} is unknown and will be ignored")
+          end
+        end
+      end
+
+      module CLI
+        @config = Config.new
+
+        @option_parser = OptionParser.new do |o|
+          o.banner = "Usage: chef-solr-installer [options]"
+
+          o.on('-c', '--config CONFIG_FILE', 'The configuration file to use') do |conf|
+            @config.config_file = File.expand_path(conf)
+          end
+
+          o.on('-u', '--user USER', "User who will own Solr's data directory") do |u|
+            @config.user = u
+          end
+
+          o.on('-g', '--group GROUP', "Group that will own Solr's data directory") do |g|
+            @config.group = g
+          end
+
+          o.on('-p', '--base-path PATH', "The base path for the installation. Must be given before any -H -W or -D options") do |path|
+            @config.solr_base_path = path
+          end
+
+          o.on('-H', '--solr-home-dir PATH', 'Where to create the Solr home directory. Defaults to BASE_PATH/solr') do |path|
+            @config.solr_home_path = path
+          end
+
+          o.on('-W', '--solr-jetty-path PATH', 'Where to install Jetty for Solr. Defaults to BASE_PATH/solr-jetty ') do |path|
+            @config.solr_jetty_path = path
+          end
+
+          o.on('-D', '--solr-data-path PATH', 'Where to create the Solr data directory. Defaults to BASE_PATH/solr/data') do |path|
+            @config.solr_data_path = path
+          end
+
+          o.on('-n', '--noop', "Don't actually install, just show what would be done by the install") do
+            @config.noop = true
+          end
+
+          o.on('-f', '--force', 'Overwrite any existing installation without asking for confirmation') do
+            @config.force = true
+          end
+
+          o.on_tail('-h', '--help', 'show this message') do
+            puts "chef-solr-installer #{Chef::Solr::VERSION}"
+            puts ''
+            puts o
+            puts ''
+            puts 'Default Settings:'
+            @config.each_configurable do |param, value|
+              value_for_display = value || "none/false"
+              puts "  #{param}:".ljust(20) + " #{value_for_display}"
+            end
+            exit 1
+          end
+
+          o.on_tail('-v', '--version', 'show the version and exit') do
+            puts "chef-solr-installer #{Chef::Solr::VERSION}"
+            exit 0
+          end
+
+        end
+
+        def self.parse_options(argv)
+          @option_parser.parse!(argv.dup)
+          @config
+        end
+
+        def self.config
+          @config
+        end
+
+      end
+
+    end
+
+    include Chef::Mixin::ShellOut
+
+    PACKAGED_SOLR_DIR = File.expand_path( "../../../../solr", __FILE__)
+
+    attr_reader :config
+
+    def initialize(argv)
+      @indent = 0
+      @config = Config.new.configure_from(argv.dup)
+      @overwriting = false
+    end
+
+    def overwriting?
+      @overwriting
+    end
+
+    def chef_solr_installed?
+      File.exist?(config.solr_home_path)
+    end
+
+    def run
+      say ''
+      say "*** DRY RUN ***" if config.noop?
+
+      if chef_solr_installed?
+        @overwriting = true
+        confirm_overwrite unless config.force? || config.noop?
+        scorch_the_earth
+      end
+
+      create_solr_home
+      create_solr_data_dir
+      unpack_solr_jetty
+
+      say ""
+      say "Successfully installed Chef Solr."
+
+      if overwriting?
+        say "You can restore your search index using `knife index rebuild`"
+      end
+    end
+
+    def confirm_overwrite
+      if STDIN.tty? && STDOUT.tty?
+        say "Chef Solr is already installed in #{config.solr_home_path}"
+        print "Do you want to overwrite the current install? All existing Solr data will be lost. [y/n] "
+        unless STDIN.gets =~ /^y/
+          say "Quitting. Try running this with --noop to see what it will change."
+          exit 1
+        end
+      else
+        say(<<-FAIL)
+ERROR: Chef Solr is already installed in #{config.solr_home_path} and you did not use the
+--force option. Use --force to overwrite an existing installation in a non-
+interactive terminal.
+FAIL
+        exit 1
+      end
+    end
+
+    def scorch_the_earth
+      group("Removing the existing Chef Solr installation") do
+        rm_rf(config.solr_home_path)
+        rm_rf(config.solr_jetty_path)
+        rm_rf(config.solr_data_path)
+      end
+    end
+
+    def create_solr_home
+      group("Creating Solr Home Directory") do
+        mkdir_p(config.solr_home_path)
+        chdir(config.solr_home_path) do
+          sh("tar zxvf #{File.join(PACKAGED_SOLR_DIR, 'solr-home.tar.gz')}")
+        end
+      end
+    end
+
+    def create_solr_data_dir
+      group("Creating Solr Data Directory") do
+        mkdir_p(config.solr_data_path)
+        chown(config.solr_data_path)
+      end
+    end
+
+    def unpack_solr_jetty
+      group("Unpacking Solr Jetty") do
+        mkdir_p(config.solr_jetty_path)
+        chdir(config.solr_jetty_path) do
+          sh("tar zxvf #{File.join(PACKAGED_SOLR_DIR, 'solr-jetty.tar.gz')}")
+        end
+      end
+    end
+
+    def mkdir_p(directory)
+      say "mkdir -p #{directory}"
+      FileUtils.mkdir_p(directory, :mode => 0755) unless config.noop?
+    end
+
+    def chdir(dir, &block)
+      say "entering #{dir}"
+      if config.noop?
+        yield if block_given? # still call the block so we get the noop output.
+      else
+        Dir.chdir(dir) { yield if block_given? }
+      end
+    end
+
+    def sh(*args)
+      opts = args[1, args.size - 1]
+      opts_msg = opts.empty? ? '' : " #{opts.to_s}"
+      say "#{args.first}#{opts_msg}"
+      shell_out!(*(args << {:cwd => false})) unless config.noop?
+    end
+
+    def chown(file)
+      if config.user
+        msg = "chown #{config.user}"
+        msg << ":#{config.group}" if config.group
+        msg << " #{file}"
+        say msg
+        FileUtils.chown(config.user, config.group) unless config.noop?
+      end
+    end
+
+    def rm_rf(path)
+      say "rm -rf #{path}"
+      FileUtils.rm_rf(path) unless config.noop?
+    end
+
+    def indent
+      @indent += 1
+      yield
+      @indent -= 1
+    end
+
+    def group(message, &block)
+      say(message)
+      indent(&block)
+    end
+
+    def say(message)
+      puts "#{' ' * (2 * @indent)}#{message}"
+    end
+
+  end
+end
+