automate-it 0.9.0

data/lib/automateit/root.rb

@@ -0,0 +1,17 @@
+# See AutomateIt::Interpreter for usage information.
+module AutomateIt # :nodoc:
+  # AutomateIt version
+  VERSION=Gem::Version.new("0.80624")
+
+  # Instantiates a new Interpreter. See documentation for
+  # Interpreter#setup.
+  def self.new(opts={})
+    Interpreter.new(opts)
+  end
+
+  # Invokes an Interpreter on the recipe. See documentation for
+  # Interpreter::invoke.
+  def self.invoke(recipe, opts={})
+    Interpreter.invoke(recipe, opts)
+  end
+end

data/lib/automateit/service_manager.rb

@@ -0,0 +1,93 @@
+# == ServiceManager
+#
+# ServiceManager provides a way of managing services, such starting and
+# stopping Unix daemons.
+class AutomateIt::ServiceManager < AutomateIt::Plugin::Manager
+  # Is this +service+ started?
+  #
+  # Options:
+  # * :wait -- Maximum number of seconds to wait until service starts. Useful
+  #   when a service accepts a #start and returns immediately before the service
+  #   has finished starting.
+  def started?(service, opts={}) dispatch(service, opts) end
+
+  # Is this +service+ stopped?
+  #
+  # Options:
+  # * :wait -- Maximum number of seconds to wait until service stops. Useful
+  #   when a service accepts a #stop and returns immediately while the service
+  #   continues running for a few seconds.
+  def stopped?(service, opts={}) dispatch(service, opts) end
+
+  # Alias for #started?
+  def running?(service, opts={}) dispatch_to(:started?, service, opts) end
+
+  # Start this +service+ if it's not running.
+  #
+  # Options:
+  # * :wait -- Same as :wait option for #started?
+  # * :force -- Start service without checking if it's running.
+  def start(service, opts={}) dispatch(service, opts) end
+
+  # Stop this +service+ if it's running.
+  #
+  # Options:
+  # * :wait -- Same as :wait option for #stopped?
+  # * :force -- Stop service without checking if it's running.
+  def stop(service, opts={}) dispatch(service, opts) end
+
+  # Restart this +service+ if it's running, or start it if it's stopped.
+  #
+  # Options:
+  # * :wait -- Maxmimum seconds to wait for service to STOP.
+  # * :pause -- Maximum seconds to wait for service to START before stopping
+  #   it. Only set this if you just started the service and then decided to
+  #   restart it.
+  def restart(service, opts={}) dispatch(service, opts) end
+
+  # If +is_restart+, #restart the service, otherwise #start it.
+  #
+  # Example:
+  #  modified = edit "/etc/myapp.conf" {#...}
+  #  service_manager.start_or_restart("myapp", modified)
+  def start_or_restart(service, is_restart, opts={}) dispatch(service, is_restart, opts) end
+
+  # Start and enable the service using #start and #enable.
+  def start_and_enable(service, opts={}) dispatch(service, opts) end
+
+  # Tell the +service+ to take a specific +action+, e.g., "condrestart".
+  def tell(service, action, opts={}) dispatch(service, action, opts={}) end
+
+  # Will this +service+ start when the computer is rebooted?
+  def enabled?(service) dispatch(service) end
+
+  # Make this +service+ start when the computer is rebooted, but only if it's
+  # not already enabled.
+  def enable(service, opts={}) dispatch(service, opts) end
+
+  # Don't make this +service+ start when the computer is rebooted, but only
+  # if it's already enabled.
+  def disable(service, opts={}) dispatch(service, opts) end
+end
+
+# == ServiceManager::BaseDriver
+#
+# Base class for all ServiceManager drivers.
+class AutomateIt::ServiceManager::BaseDriver < AutomateIt::Plugin::Driver
+  # See ServiceManager#start_or_restart
+  def start_or_restart(service, is_restart, opts={})
+    send(is_restart ? :restart : :start, service, opts)
+  end
+
+  # See ServiceManager#start_and_enable
+  def start_and_enable(service, opts={})
+    start(service, opts)
+    enable(service, opts)
+  end
+end
+
+# Drivers
+require 'automateit/service_manager/sysv'
+require 'automateit/service_manager/update_rcd'
+require 'automateit/service_manager/chkconfig'
+require 'automateit/service_manager/rc_update'

data/lib/automateit/service_manager/chkconfig.rb

@@ -0,0 +1,39 @@
+# == ServiceManager::Chkconfig
+#
+# The Chkconfig driver implements the ServiceManager methods for #enabled?,
+# #enable and #disable on RedHat-like platforms. It uses the SYSV driver
+# for handling the methods #running?, #start and #stop.
+class AutomateIt::ServiceManager::Chkconfig < AutomateIt::ServiceManager::SYSV
+  depends_on :programs => %w(chkconfig)
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 2 : 0
+  end
+
+  # See ServiceManager#enabled?
+  def enabled?(service)
+    _raise_unless_available
+    # "chkconfig --list service" may produce output like the below:
+    # service httpd supports chkconfig, but is not referenced in any runlevel (run 'chkconfig --add automateit_service_sysv_test')
+    # => httpd           0:off   1:off   2:off   3:off   4:off   5:off   6:off
+    if matcher = `chkconfig --list #{service} < /dev/null 2>&1` \
+        .match(/^(#{service}).+?(\d+:(on|off).+?)$/)
+      return true if matcher[2].match(/\b\d+:on\b/)
+    end
+    return false
+  end
+
+  # See ServiceManager#enable
+  def enable(service, opts={})
+    _raise_unless_available
+    return false if enabled?(service)
+    interpreter.sh("chkconfig --add #{service}")
+  end
+
+  # See ServiceManager#disable
+  def disable(service, opts={})
+    _raise_unless_available
+    return false unless enabled?(service)
+    interpreter.sh("chkconfig --del #{service}")
+  end
+end

data/lib/automateit/service_manager/rc_update.rb

@@ -0,0 +1,37 @@
+# == ServiceManager::RC_Update
+#
+# RC_Update implements the #enabled?, #enable and #disable features of the
+# ServiceManager on Gentoo-like systems.
+class AutomateIt::ServiceManager::RC_Update < AutomateIt::ServiceManager::SYSV
+  depends_on :programs => %w(rc-update)
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 2 : 0
+  end
+
+  # See ServiceManager#enabled?
+  def enabled?(service)
+    _raise_unless_available
+    # Do NOT use Gentoo's rc-update because the idiot that wrote that utility
+    # truncates service names to look "prettier" and provides no way to disable
+    # this annoyance for people that need to query services by name.
+    result = %w(boot default).select do |runlevel|
+      File.exists?(File.join("/etc/runlevels", runlevel, service))
+    end
+    return ! result.empty?
+  end
+
+  # See ServiceManager#enable
+  def enable(service, opts={})
+    _raise_unless_available
+    return false if enabled?(service)
+    interpreter.sh("rc-update add #{service} default > /dev/null 2>&1")
+  end
+
+  # See ServiceManager#disable
+  def disable(service, opts={})
+    _raise_unless_available
+    return false unless enabled?(service)
+    interpreter.sh("rc-update del #{service} default > /dev/null 2>&1")
+  end
+end

data/lib/automateit/service_manager/sysv.rb

@@ -0,0 +1,139 @@
+# == ServiceManager::SYSV
+#
+# The SYSV driver implements the ServiceManager methods for #running?,
+# #start and #stop on Unix-like platforms that use the System V init
+# process using a <tt>/etc/init.d</tt> directory.
+#
+# It also implements a basic #enabled? method that's very fast but may not
+# work correctly on all SysV platforms. This method should be overridden by
+# more specific drivers when reasonable.
+#
+# It does not implement the #enable and #disable methods because these are
+# not standardized and must be implemented using platform-specific drivers,
+# e.g., Chkconfig on RedHat-like platforms.
+class AutomateIt::ServiceManager::SYSV < AutomateIt::ServiceManager::BaseDriver
+  ETC_INITD = "/etc/init.d"
+
+  depends_on :directories => [ETC_INITD]
+
+  def suitability(method, *args) # :nodoc:
+    return 0 if %w(enabled? enable disable).include?(method.to_s)
+    return available? ? 1 : 0
+  end
+
+  def _run_command(args, opts={})
+    _raise_unless_available
+    cmd = String === args ? args : args.join(' ')
+    if opts[:silent] or opts[:check]
+      cmd += " > /dev/null 2>&1" # Discard STDOUT and STDERR
+    elsif opts[:quiet]
+      cmd += " > /dev/null" # Discard only STDOUT
+    end
+
+    level = (opts[:quiet] || opts[:silent] || opts[:check]) ? :debug : :info
+    log.send(level, PEXEC+cmd)
+    if writing? or opts[:check]
+      system(cmd)
+      return $?.exitstatus.zero?
+    else
+      false
+    end
+  end
+  private :_run_command
+
+  # See ServiceManager#tell
+  def tell(service, action, opts={})
+    sudo = opts[:sudo] ? 'sudo' : ''
+    return _run_command(["#{sudo} #{ETC_INITD}/#{service}", action.to_s], opts)
+  end
+
+  # See ServiceManager#running?
+  def running?(service, opts={})
+    return started?(service, opts)
+  end
+
+  def _started_and_stopped_helper(kind, service, opts={})
+    expected = \
+      case kind
+      when :started?
+        true
+      when :stopped?
+        false
+      else
+        raise ArgumentError.new("unknown kind argument: #{kind}")
+      end
+
+    result = tell(service, :status, :check => true)
+    nitpick("_sash top: k=%s r=%s e=%s" % [kind, result, expected])
+    return result if expected == result
+    if opts[:wait]
+      timeout = Time.now + opts[:wait]
+      while timeout > Time.now
+        log.info(PNOTE+" ServiceManager#%s waiting on '%s' for %0.1f more seconds" %
+          [kind, service, timeout - Time.now])
+        sleep 0.5
+        result = tell(service, :status, :check => true)
+        nitpick("_sash rep: k=%s r=%s e=%s" % [kind, result, expected])
+        break if expected == result
+      end
+      log.info(PNOTE+" ServiceManager#%s finished waiting for '%s', got: %s" %
+        [kind, service, result])
+    end
+    return result
+  end
+  protected :_started_and_stopped_helper
+
+  # See ServiceManager#started?
+  def started?(service, opts={})
+    return _started_and_stopped_helper(:started?, service, opts)
+  end
+
+  # See ServiceManager#stopped?
+  def stopped?(service, opts={})
+    return ! _started_and_stopped_helper(:stopped?, service, opts)
+  end
+
+  # See ServiceManager#start
+  def start(service, opts={})
+    if not opts[:force] and started?(service, :wait => opts[:wait])
+      # Already started
+      return false
+    else
+      # Needs starting or forced
+      tell(service, :start, opts)
+      return true
+    end
+  end
+
+  # See ServiceManager#stop
+  def stop(service, opts={})
+    if not opts[:force] and stopped?(service, :wait => opts[:wait])
+      # Already stopped
+      return false
+    else
+      # Needs stopping or forced
+      tell(service, :stop, opts)
+      return true
+    end
+  end
+
+  # See ServiceManager#restart
+  def restart(service, opts={})
+    if started?(service, :wait => opts[:pause])
+      # We're certain that service is started
+      stop_opts = opts.clone
+      stop_opts[:force] = true # Don't check again
+      stop(service, stop_opts)
+    end
+
+    # We're certain that service is stopped
+    start_opts = opts.clone
+    start_opts[:force] = true # Don't check again
+    return start(service, start_opts)
+  end
+
+  # See ServiceManager#enabled?
+  def enabled?(service)
+    return ! Dir["/etc/rc*.d/*"].grep(/\/S\d{2}#{service}$/).empty?
+  end
+end

data/lib/automateit/service_manager/update_rcd.rb

@@ -0,0 +1,35 @@
+# == ServiceManager::UpdateRCD
+#
+# The UpdateRCD driver implements the ServiceManager methods for #enabled?,
+# #enable and #disable on Debian-like platforms. It uses the SYSV driver
+# for handling the methods #running?, #start and #stop.
+class AutomateIt::ServiceManager::UpdateRCD < AutomateIt::ServiceManager::SYSV
+  TOOL = "update-rc.d"
+
+  depends_on :programs => [TOOL]
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 3 : 0
+  end
+
+  # See ServiceManager#enable
+  def enable(service, opts={})
+    _raise_unless_available
+    return false if enabled?(service)
+    interpreter.sh("#{TOOL} #{service} defaults < /dev/null > /dev/null")
+  end
+
+  # See ServiceManager#disable
+  def disable(service, opts={})
+    _raise_unless_available
+    return false unless enabled?(service)
+    interpreter.sh("#{TOOL} -f #{service} remove < /dev/null > /dev/null")
+  end
+
+  def enabled?(service, opts={})
+    _raise_unless_available
+    cmd = "#{TOOL} -n -f #{service} remove < /dev/null"
+    output = `#{cmd}`
+    return ! output.match(/etc\/rc[\dS].d|Nothing to do\./).nil?
+  end
+end

data/lib/automateit/shell_manager.rb

@@ -0,0 +1,316 @@
+# == ShellManager
+#
+# The ShellManager provides Unix-like shell commands for manipulating files and
+# executing commands.
+#
+# *WARNING*: Previewing code can be dangerous. Read
+# previews.txt[link:files/docs/previews_txt.html] for instructions on how to
+# write code that can be safely previewed.
+class AutomateIt::ShellManager < AutomateIt::Plugin::Manager
+  alias_methods :backup, :sh, :which, :which!, :mktemp, :mktempdir, :mktempdircd, :chperm, :umask
+  alias_methods :cd, :pwd, :mkdir, :mkdir_p, :rmdir, :ln, :ln_s, :ln_sf, :cp, :cp_r, :cp_R, :mv, :rm, :rm_r, :rm_rf, :install, :chmod, :chmod_R, :chown, :chown_R, :touch
+
+  #...[ Detection commands ]..............................................
+
+  # See ShellManager#provides_mode?
+  def provides_mode?() dispatch_safely end
+
+  # See ShellManager#provides_mode?
+  def provides_ownership?() dispatch_safely end
+
+  # See ShellManager#provides_mode?
+  def provides_symlink?() dispatch_safely end
+
+  # See ShellManager#provides_mode?
+  def provides_link?() dispatch_safely end
+
+  #...[ Custom commands ].................................................
+
+  # Backup +sources+ if they exist. Returns the names of the backups created.
+  #
+  # Options:
+  # * :quiet -- Don't display output? Default is false.
+  #
+  # These backups are copies of the original sources saved into the same
+  # directories as the originals. The pathnames of these copies are timestamped
+  # and guaranteed to be unique, so you can have multiple backups of the same
+  # sources.
+  #
+  # *WARNING*: This method is not conditional. It will make a backup every time
+  # it's called if the sources exist. Therefore, only execute this method when
+  # its needed.
+  #
+  # For example, backup a file:
+  #
+  #   backup("/tmp/myfile") # => "/tmp/myfile.1190994237_M2xhLrC6Sj.bak
+  #
+  # In the above example, the backup's name contains two special strings. The
+  # "1190994237" is the time the backup was made in seconds since the Epoch.
+  # The "M2xhLrC6Sj" is a random string used to guarantee the uniqueness of
+  # this backup in case two are made at exactly the same time.
+  def backup(*sources) dispatch(*sources) end
+
+  # Execute a shell command.
+  def sh(*commands) dispatch(*commands) end
+
+  # What is the path for this command? Returns +nil+ if command isn't found.
+  #
+  # Example:
+  #   which("ls") # => "/bin/ls"
+  def which(command) dispatch(command) end
+
+  # Same as #which but throws an ArgumentError if command isn't found.
+  def which!(command) dispatch(command) end
+
+  # Creates a temporary file. Optionally takes a +name+ argument which is
+  # purely cosmetic, e.g., if the +name+ is "foo", the routine may create a
+  # temporary file named <tt>/tmp/foo_qeKo7nJk1s</tt>.
+  #
+  # When called with a block, invokes the block with the path of the temporary
+  # file and deletes the file at the end of the block.
+  #
+  # Without a block, returns the path of the temporary file and you're
+  # responsible for removing it when done.
+  def mktemp(name=nil, &block) # :yields: path
+    dispatch(name, &block)
+  end
+
+  # Creates a temporary directory. See #mktemp for details on the +name+
+  # argument.
+  #
+  # When called with a block, invokes the block with the path of the
+  # temporary directory and recursively deletes the directory and its
+  # contents at the end of the block.
+  #
+  # Without a block, returns the path of the temporary directory and you're
+  # responsible for removing it when done.
+  #
+  # CAUTION: Read notes at the top of ShellManager for potentially
+  # problematic situations that may be encountered if using this command in
+  # preview mode!
+  def mktempdir(name=nil, &block) # :yields: path
+    dispatch(name, &block)
+  end
+
+  # Same as #mktempdir but performs a #cd into the directory for the duration
+  # of the block.
+  #
+  # Example:
+  #
+  #   puts pwd # => "/home/bubba"
+  #   mktempdircd do |path|
+  #     puts path # => "/tmp/tempster_qeKo7nJk1s"
+  #     puts pwd  # => "/tmp/tempster_qeKo7nJk1s"
+  #   end
+  #   puts File.exists?("/tmp/tempster_qeKo7nJk1s") # => false
+  def mktempdircd(name=nil, &block) # :yields: path
+    dispatch(name, &block)
+  end
+
+  # Change the permissions of the +targets+. This command is like the #chmod
+  # and #chown in a single command.
+  #
+  # Options:
+  # * :recursive -- Change files and directories recursively. Defaults to false.
+  # * :user -- User name to change ownership to.
+  # * :group -- Group name to change ownership to.
+  # * :mode -- Mode to use as octal, e.g., <tt>0400</tt> to make a file
+  #   readable only to its owner.
+  # * :details -- Reports the files modified, rather than the arguments
+  #   modified. An argument might be a single directory, but this may result in
+  #   modifications to many files within that directory. Use :details for
+  #   situations when there's a need to see all files actually changed. The
+  #   reason :details is off by default is that it will flood the screen with a
+  #   list of all files modified in a large directory, which is overwhelming
+  #   and probably unnecessary unless you actually need to see these details.
+  #   Defaults to false.
+  def chperm(targets, opts={}) dispatch(targets, opts) end
+
+  # Set the umask to +mode+. If given a block, changes the umask only for the
+  # duration of the block and changes it back to its previous setting at the
+  # end.
+  def umask(mode=nil, &block) dispatch(mode, &block) end
+
+  #...[ FileUtils wrappers ]...............................................
+
+  # Changes the directory into the specified +dir+. If called with a block,
+  # changes to the directory for the duration of the block, and then changes
+  # back to the previous directory at the end.
+  #
+  # *WARNING*: Previewing code can be dangerous. Read
+  # previews.txt[link:files/docs/previews_txt.html] for instructions on how to
+  # write code that can be safely previewed.
+  def cd(dir, opts={}, &block) dispatch(dir, opts, &block) end
+
+  # Returns the current directory.
+  def pwd() dispatch() end
+
+  # Create a directory or directories. Returns an array of directories
+  # created or +false+ if all directories are already present.
+  #
+  # Options:
+  # * :parents -- Create parents, like "mkdir -p". Boolean.
+  # * :mode, :user, :group -- See #chperm
+  #
+  # *WARNING*: Previewing code can be dangerous. Read
+  # previews.txt[link:files/docs/previews_txt.html] for instructions on how to
+  # write code that can be safely previewed.
+  def mkdir(dirs, opts={}, &block) dispatch(dirs, &block) end
+
+  # Create a directory or directories with their parents. Returns an array of
+  # directories created or +false+ if all directories are already present.
+  #
+  # Options same as #mkdir.
+  #
+  # Example:
+  #   File.exists?("/tmp/foo") # => false
+  #   mkdir_p("/tmp/foo/bar")
+  #   File.exists?("/tmp/foo") # => true
+  #   File.exists?("/tmp/foo/bar") # => true
+  #
+  # *WARNING*: Previewing code can be dangerous. Read
+  # previews.txt[link:files/docs/previews_txt.html] for instructions on how to
+  # write code that can be safely previewed.
+  def mkdir_p(dirs, opts={}, &block) dispatch(dirs, &block) end
+
+  # Remove a directory or directories. The directories must be empty or an
+  # exception is thrown. Returns the directories removed or +false+ if none
+  # of the directories exist.
+  def rmdir(dirs) dispatch(dirs) end
+
+  # Create a hard link between the +source+ and +target+. Your platform must
+  # support hard links to use this. Returns the target created or +false+ if
+  # the link is already present.
+  def ln(source, target, opts={}) dispatch(source, target, opts) end
+
+  # Create a symbolic link between the +sources+ and +target+. Your platform
+  # must support symbolic links to use this. Returns an array of sources
+  # linked or +false+ if all are already present.
+  def ln_s(sources, target, opts={}) dispatch(sources, target, opts) end
+
+  # Create a symbolic link between the +sources+ and +target+. If the
+  # +target+ already exists, will remove it and recreate it. Your platform
+  # must support symbolic links to use this. Returns an array of sources
+  # linked or +false+ if all are already present.
+  def ln_sf(sources, target, opts={}) dispatch(sources, target, opts) end
+
+  # Copy the +sources+ to the +target+. Returns an array of sources copied or
+  # +false+ if all are present.
+  #
+  # Options:
+  # * :preserve -- Preserve file modification time and ownership. Defaults to
+  #   false. Can be +true+, +false+, or :try. If :try, the properties will be
+  #   preserved if possible on the platform, whereas +true+ will raise an
+  #   exception if not available.
+  # * :recursive -- Copy files and directories recursively, boolean.
+  def cp(sources, target, opts={}) dispatch(sources, target, opts) end
+
+  # Copy the +sources+ to the +target+ recursively. Returns an array of
+  # sources copied or +false+ if all are present.
+  def cp_r(sources, target, opts={}) dispatch(sources, target, opts) end
+
+  # Copy the +sources+ to the +target+ recursively. Returns an array of
+  # sources copied or +false+ if all are present.
+  def cp_R(sources, target, opts={}) dispatch(sources, target, opts) end
+
+  # Move the +sources+ to the +target+. Returns an array of sources copied or
+  # +false+ if none of the sources exist.
+  def mv(sources, target) dispatch(sources, target) end
+
+  # Remove the +targets+. Returns a list of targets removed or +false+ if
+  # none of them exist.
+  def rm(targets, opts={}) dispatch(targets, opts) end
+
+  # Remove the +targets+ recursively. Returns a list of targets removed or
+  # +false+ if none of them exist.
+  def rm_r(targets, opts={}) dispatch(targets, opts) end
+
+  # Remove the +targets+ recursively and forcefully. Returns a list of
+  # targets removed or +false+ if none of them exist.
+  def rm_rf(targets, opts={}) dispatch(targets, opts) end
+
+  # Copy the +source+ to the +target+ and set its +mode+. Returns true if the
+  # file was installed or +false+ if already present.
+  def install(source, target, mode) dispatch(source, target, mode) end
+
+  # Change the permission +mode+ of the +targets+. Returns an array of
+  # targets modified or +false+ if all have the desired mode.
+  def chmod(mode, targets, opts={}) dispatch(mode, targets, opts) end
+
+  # Change the permission +mode+ of the +targets+ recursively. Returns an
+  # array of targets modified or +false+ if all have the desired mode.
+  def chmod_R(mode, targets, opts={}) dispatch(mode, targets, opts) end
+
+  # Change the +user+ and +group+ ownership of the +targets+. You can leave
+  # either the user or group as nil if you don't want to change it. Returns
+  # an array of targets modified or +false+ if all have the desired
+  # ownership.
+  def chown(user, group, targets, opts={}) dispatch(user, group, targets, opts) end
+
+  # Change the +user+ and +group+ ownership of the +targets+ recursively. You
+  # can leave either the user or group as nil if you don't want to change it.
+  # Returns an array of targets modified or +false+ if all have the desired
+  # ownership.
+  def chown_R(user, group, targets, opts={}) dispatch(user, group, targets, opts) end
+
+  # Create the +targets+ as files if needed and update their modification
+  # time. Unlike most other commands provided by ShellManager, this one will
+  # always modify the targets. Returns an array of targets modified.
+  #
+  # Options:
+  # * :like -- Touch the targets like this file. Defaults to none.
+  # * :stamp -- Set the targets to the specified timestamp. Defaults to Time.now.
+  def touch(targets, opts={}) dispatch(targets, opts) end
+end
+
+# == ShellManager::BaseDriver
+#
+# Base class for all ShellManager drivers.
+class AutomateIt::ShellManager::BaseDriver < AutomateIt::Plugin::Driver
+  # Returns derived filename to use as a peer given the +source+ and +target+.
+  # This is necessary for differentiating between directory and file targets.
+  #
+  # For example:
+  #
+  #   # Get the peer for an extant target directory:
+  #   peer_for("foo", "/tmp") # => "/tmp/foo"
+  #
+  #   # Get the peer for anything else:
+  #   peer_for("foo", "/bar") # => "/bar"
+  def peer_for(source, target)
+    return FileUtils.send(:fu_each_src_dest0, source, target){|a, b| b}
+  end
+
+protected
+  def _replace_owner_with_user(opts)
+    value = opts.delete(:owner)
+    opts[:user] = value  if value and not opts[:user]
+    return opts
+  end
+
+  # Returns hash of verbosity and preview settings for FileUtils commands.
+  def _fileutils_opts
+    opts = {}
+    opts[:verbose] = false # Generate our own log messages
+    opts[:noop] = true if preview?
+    return opts
+  end
+
+  # Return array of all the directory's top-level contents, including hidden
+  # files with "." prefix on UNIX. Directories are returned just as a name,
+  # you'll need to expand those separately if needed.
+  def _directory_contents(directory)
+    return Dir[directory+"/{,.}*"].reject{|t| t =~ /(^|#{File::SEPARATOR})\.{1,2}$/}
+  end
+end
+
+# Drivers
+require 'automateit/shell_manager/portable'
+
+require 'automateit/shell_manager/which_base'
+require 'automateit/shell_manager/which_unix'
+require 'automateit/shell_manager/which_windows'
+
+require 'automateit/shell_manager/base_link'
+require 'automateit/shell_manager/symlink'
+require 'automateit/shell_manager/link'