salticid 0.9.0

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Kyle Kingsbury
+
+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.markdown

@@ -0,0 +1,11 @@
+Salticid
+=====
+
+Salticid is a deployment tool I wrote for Vodpod and Showyou in a couple of weekends. Its only design goals were:
+
+1. Magic
+2. More Magic
+
+It violates every principle of good software development possible. It is clunky, slow, buggy, and dangerous.
+
+It also worked surprisingly well. YMMV. d=('_~)=b

data/lib/monkeypatch.rb

@@ -0,0 +1,21 @@
+module Net
+  module SSH
+    class Shell
+      # Like execute! but returns an array: the status and the output.
+      def exec!(command, klass=Net::SSH::Shell::Process, &callback)
+        result = ''
+
+        process = klass.new(self, command, callback)
+        process.on_output do |p, output|
+          result << output
+        end
+        
+        process.run if processes.empty?
+        processes << process
+        wait!
+        
+        [process.exit_status, result]
+      end
+    end
+  end
+end

data/lib/salticid.rb

@@ -0,0 +1,205 @@
+require 'rubygems'
+require 'net/ssh'
+require 'net/scp'
+require 'net/ssh/gateway'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'salticid/version'
+
+class Salticid
+  def self.log(str)
+    File.open('salticid.log', 'a') do |f|
+      f.puts str
+    end
+  end
+
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'net-ssh-shell', 'lib'))
+  require 'monkeypatch'
+  require 'snippets/init'
+  require 'salticid/message'
+  require 'salticid/task'
+  require 'salticid/role'
+  require 'salticid/role_proxy'
+  require 'salticid/host'
+  require 'salticid/gateway'
+  require 'salticid/group'
+
+  attr_accessor :gw, :groups, :hosts, :roles, :tasks
+
+  def initialize
+    @gw = nil
+    @hosts = []
+    @groups = []
+    @roles = []
+    @tasks = []
+  end
+
+  # Define a gateway.
+  def gw(name = nil, &block)
+    if name == nil
+      return @gw
+    end
+
+    # Get gateway from cache or set new one.
+    name = name.to_s
+
+    unless gw = @hosts.find{|h| h.name == name}
+      gw = Salticid::Gateway.new(name, :salticid => self)
+      @hosts << gw
+      # Set default gw
+      @gw = gw 
+    end
+
+
+    if block_given?
+      gw.instance_exec &block
+    end
+
+    gw
+  end
+
+  def host(name, &block)
+    name = name.to_s
+    unless host = @hosts.find{|h| h.name == name}
+      host = Salticid::Host.new(name, :salticid => self)
+      @hosts << host
+    end
+
+    if block_given?
+      host.instance_exec &block
+    end
+
+    host
+  end
+
+  # Tries to guess what hosts we would run the given string on.
+  def hosts_for(string)
+    first = string[/^(\w+)\.\w+/, 1]
+    if role = @roles.find { |r| r.name == first }
+      return role.hosts
+    else
+      raise "Sorry, I didn't understand what hosts to run #{string.inspect} on."
+    end
+  end
+
+  # Assigns a group to this Salticid. Runs the optional block in the group's
+  # context.  Returns the group.
+  def group(name, &block)
+    # Get group
+    group = name if name.kind_of? Salticid::Group 
+    name = name.to_s
+    group ||= @groups.find{|g| g.name == name}
+    group ||= Salticid::Group.new(name, :salticid => self)
+
+    # Store
+    @groups |= [group]
+
+    # Run block
+    if block_given?
+      group.instance_exec &block
+    end
+
+    group
+  end
+
+  # Loads one or more file globs into the current salticid.
+  def load(*globs)
+    skips = globs.grep(/^-/)
+    (globs - skips).each do |glob|
+      glob += '.rb' if glob =~ /\*$/
+      Dir.glob(glob).sort.each do |path|
+        next unless File.file? path
+        next if skips.find {|pat| path =~ /#{pat[1..-1]}$/}
+        instance_eval(File.read(path), path)
+      end
+    end
+  end
+
+  # Defines a new role. A role is a package of tasks.
+  def role(name, &block)
+    name = name.to_s
+
+    unless role = @roles.find{|r| r.name == name}
+      role = Salticid::Role.new(name, :salticid => self)
+      @roles << role
+    end
+
+    if block_given?
+      role.instance_eval &block
+    end
+
+    role
+  end
+ 
+  # Finds (and optionally defines) a task.
+  # task :foo => returns a Task
+  # task :foo do ... end => defines a Task with given block
+  def task(name, &block)
+    name = name.to_s
+
+    unless task = @tasks.find{|t| t.name == name}
+      task = Salticid::Task.new(name, :salticid => self)
+      @tasks << task
+    end
+  
+    if block_given?
+      task.block = block
+    end
+
+    task 
+  end
+
+  def to_s
+    "Salticid"
+  end
+
+  # An involved description of the salticid
+  def to_string
+    h = ''
+    h << "Groups\n"
+    groups.each do |group|
+      h << "  #{group}\n"
+    end
+    
+    h << "\nHosts:\n"
+    hosts.each do |host|
+      h << "  #{host}\n"
+    end
+    
+    h << "\nRoles\n"
+    roles.each do |role|
+      h << "  #{role}\n"
+    end
+
+    h << "\nTop-level tasks\n"
+    tasks.each do |task|
+      h << "  #{task}\n"
+    end
+
+    h
+  end
+
+  # Unknown methods are resolved as groups, then hosts, then roles, then tasks.
+  # Can you think of a better order?
+  #
+  # Blocks are instance_exec'd in the context of the found object.
+  def method_missing(meth, &block)
+    name = meth.to_s
+
+    found = @groups.find { |g| g.name == name }
+    found ||= @hosts.find { |h| h.name == name }
+    found ||= @roles.find { |r| r.name == name }
+    found ||= @tasks.find { |t| t.name == name }
+
+    unless found
+      raise NoMethodError
+    end
+
+    if block
+      found.instance_exec &block
+    end
+
+    found
+  end
+end

data/lib/salticid/config.rb

@@ -0,0 +1,17 @@
+module Salticid
+  def self.config
+    @config
+  end
+
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.load_config(file)
+    @config = Construct.load(file)
+
+    @config.define :hosts, :default => []
+
+    @config
+  end
+end

data/lib/salticid/gateway.rb

@@ -0,0 +1,23 @@
+class Salticid::Gateway < Salticid::Host
+  def initialize(*args)
+    @tunnel_lock = Mutex.new
+    super *args
+  end
+
+  # Gateways don't need gateways.
+  def gw
+  end
+
+  # Tunnel for connecting to other hosts.
+  def gateway_tunnel
+    # Multiple hosts will be asking for this tunnel at the same time.
+    # We need to only create one.
+    @tunnel_lock.synchronize do
+      @gateway_tunnel ||= Net::SSH::Gateway.new(name, user)
+    end
+  end
+
+  # We don't need tunnels either
+  def tunnel
+  end
+end

data/lib/salticid/group.rb

@@ -0,0 +1,99 @@
+class Salticid::Group
+  # A collection of hosts and other groups.
+  
+  attr_reader :name
+  attr_accessor :parent
+  attr_accessor :groups, :hosts
+
+  def initialize(name, opts = {})
+    @name = name.to_s
+    @salticid = opts[:salticid]
+    @parent = opts[:parent]
+    @hosts = []
+    @groups = []
+  end
+
+  def ==(other)
+    self.class == other.class and 
+      self.name == other.name and 
+      self.parent == other.parent
+  end
+
+  # Runs the block in the context of each.
+  def each_host(&block)
+    hosts.each do |host|
+      host.instance_exec &block
+    end
+  end
+
+  # Finds all hosts (recursively) that are members of this group or subgroups.
+  def hosts
+    @hosts + @groups.map { |m|
+      m.hosts
+    }.flatten.uniq
+  end
+
+  # Creates a sub-group of this group.
+  def group(name, &block)
+    # Get group
+    name = name.to_s
+    group = @groups.find{|g| g.name == name}
+    group ||= Salticid::Group.new(name, :salticid => @salticid, :parent => self)
+
+    # Store
+    @groups |= [group]
+
+    # Run block
+    if block
+      group.instance_exec &block
+    end
+
+    group
+  end
+
+  # Adds a host (by name) to the group. Returns the host.
+  def host(name)
+    host = @salticid.host name
+    host.groups |= [self]
+    @hosts |= [host]
+  end
+  
+  def inspect
+    "#<Salticid::Group #{path}>"
+  end
+
+  # Unknown methods are resolved as groups, then hosts. Blocks are instance_exec'd in the found context.
+  def method_missing(meth, &block)
+    name = meth.to_s
+    found = @groups.find { |g| g.name == name }
+    found ||= @hosts.find { |h| h.name == name }
+
+    unless found
+      raise NoMethodError
+    end
+
+    if block
+      found.instance_exec &block
+    end
+
+    found
+  end
+
+  def path
+    if @parent
+      @parent.path + '/' + @name
+    else
+      '/' + @name
+    end
+  end
+
+  def to_s
+    @name
+  end
+
+  def to_string
+    h = "Group #{@name}:\n"
+    h << "  Hosts:\n"
+    h << hosts.map { |h| "    #{h}" }.join("\n")
+  end
+end

data/lib/salticid/host.rb

@@ -0,0 +1,600 @@
+class Salticid::Host
+  attr_accessor :env, :name, :user, :groups, :roles, :tasks, :salticid, :password
+
+  def initialize(name, opts = {})
+    @name = name.to_s
+    @user = opts[:user].to_s
+    @groups = opts[:groups] || []
+    @roles = opts[:roles] || []
+    @tasks = opts[:tasks] || []
+    @salticid = opts[:salticid]
+    @sudo = nil
+
+    @on_log = proc { |message| }
+
+    @ssh_lock = Mutex.new
+
+    @env = {}
+    @cwd = nil
+    @role_proxies = {}
+  end
+
+  def ==(other)
+    self.name == other.name
+  end
+
+  # Appends the given string to a file.
+  # Pass :uniq => true to only append if the string is not already present in
+  # the file.
+  def append(str, file, opts = {})
+    file = expand_path(file)
+    if opts[:uniq] and exists? file
+      # Check to ensure the file does not contain the line already.
+      begin
+        grep(str, file) or raise
+      rescue
+        # We're clear, go ahead.
+        tee '-a', file, :stdin => str
+      end
+    else
+      # No need to check, just append.
+      tee '-a', file, :stdin => str
+    end
+  end
+
+  # All calls to exec! within this block are prefixed by sudoing to the user.
+  def as(user = nil)
+    old_sudo, @sudo = @sudo, (user || 'root')
+    yield
+    @sudo = old_sudo
+  end
+
+  # Changes our working directory.
+  def cd(dir = nil)
+    dir ||= homedir
+    dir = expand_path(dir)
+    @cwd = dir
+  end
+
+  # Changes the mode of a file. Mode is numeric.
+  def chmod(mode, path)
+    exec! "chmod #{mode.to_s(8)} #{escape(expand_path(path))}"
+  end
+
+  # Changes the mode of a file, recursively. Mode is numeric.
+  def chmod_r(mode, path)
+    exec! "chmod -R #{mode.to_s(8)} #{escape(expand_path(path))}"
+  end
+
+  # Returns current working directory. Tries to obtain it from exec 'pwd',
+  # but falls back to /.
+  def cwd
+    @cwd ||= begin
+      exec! 'pwd'
+    rescue => e
+      raise e
+      '/'
+    end
+  end
+
+  # Returns true if a directory exists
+  def dir?(path)
+    begin
+      ftype(path) == 'directory'
+    rescue
+      false
+    end
+  end
+
+  # Downloads a file from the remote server. Local defaults to remote filename
+  # (in current path) if not specified.
+  def download(remote, local = nil, opts = {})
+    remote_filename ||= File.split(remote).last
+    if File.directory? local
+      local = File.join(local, remote_filename)
+    else
+      local = remote_filename
+    end
+
+    remote = expand_path remote
+    log "downloading from #{remote.inspect} to #{local.inspect}"
+    ssh.scp.download!(remote, local, opts)
+  end
+  
+  # Quotes a string for inclusion in a bash command line
+  def escape(string)
+    return '' if string.nil?
+    return string unless string.to_s =~ /[\\\$`" ]/
+    '"' + string.to_s.gsub(/[\\\$`"]/) { |match| '\\' + match } + '"'
+  end
+  
+  # Runs a remote command.  If a block is given, it is run in a new thread
+  # after stdin is sent. Its sole argument is the SSH channel for this command:
+  # you may use send_data to write to the processes stdin, and use ch.eof! to
+  # close stdin. ch.close will stop the remote process.
+  #
+  # Options:
+  #   :stdin => Data piped to the process' stdin.
+  #   :stdout => A callback invoked when stdout is received from the process.
+  #              The argument is the data received.
+  #   :stderr => Like stdout, but for stderr.
+  #   :echo => Prints stdout and stderr using print, if true.
+  #   :to => Shell output redirection to file. (like cmd >/foo)
+  #   :from => Shell input redirection from file. (like cmd </foo)
+  def exec!(command, opts = {}, &block)
+    # Options
+    stdout = ''
+    stderr = ''
+    defaults = {
+      :check_exit_status => true
+    }
+    
+    opts = defaults.merge opts
+
+    # First, set up the environment...
+    if @env.size > 0
+      command = (
+        @env.map { |k,v| k.to_s.upcase + '=' + v } << command
+      ).join(' ')
+    end
+
+    # Before execution, cd to cwd
+    command = "cd #{escape(@cwd)}; " + command
+
+    # Input redirection
+    if opts[:from]
+      command += " <#{escape(opts[:from])}"
+    end
+
+    # Output redirection
+    if opts[:to]
+      command += " >#{escape(opts[:to])}"
+    end
+
+    # After command, add a semicolon...
+    unless command =~ /;\s*$/
+      command += ';'
+    end
+
+    # Then echo the exit status.
+    command += ' echo $?; '
+
+
+    # If applicable, wrap the command in a sudo subshell...
+    if @sudo
+      command = "sudo -S -u #{@sudo} bash -c #{escape(command)}"
+      opts[:stdin] = @password + "\n" + opts[:stdin].to_s
+    end
+
+    buffer = ''
+    echoed = 0
+    status = nil
+    written = false
+
+    # Run ze command with callbacks.
+    # Return status.
+    channel = ssh.open_channel do |ch|
+      ch.exec command do |ch, success|
+        raise "could not execute command" unless success
+
+        # Handle STDOUT
+        ch.on_data do |c, data|
+          # Could this data be the status code?
+          if pos = (data =~ /(\d{1,3})\n$/)
+            # Set status
+            status = $1
+
+            # Flush old buffer
+            opts[:stdout].call(buffer) if opts[:stdout]
+            stdout << buffer
+
+            # Save candidate status code
+            buffer = data[pos .. -1]
+
+            # Write the other part of the string to the callback
+            opts[:stdout].call(data[0...pos]) if opts[:stdout]
+            stdout << data[0...pos]
+          else
+            # Write buffer + data to callback
+            opts[:stdout].call(buffer + data) if opts[:stdout]
+            stdout << buffer + data
+            buffer = ''
+          end
+          
+          if opts[:echo] and echoed < stdout.length
+            stdout[echoed..-1].split("\n")[0..-2].each do |fragment|
+              echoed += fragment.length + 1
+              log fragment
+            end
+          end
+        end
+
+        # Handle STDERR
+        ch.on_extended_data do |c, type, data|
+          if type == 1
+            # STDERR
+            opts[:stderr].call(data) if opts[:stderr]
+            stderr << data
+            log :stderr, stderr if opts[:echo]
+          end
+        end
+        
+        # Write stdin
+        if opts[:stdin]
+          ch.on_process do
+            unless written
+              ch.send_data opts[:stdin]
+              written = true
+            else
+              # Okay, we wrote stdin
+              unless block or ch.eof?
+                ch.eof!
+              end
+            end
+          end
+        end
+
+        # Handle close
+        ch.on_close do
+          if opts[:echo]
+            # Echo last of input data
+            stdout[echoed..-1].split("\n").each do |fragment|
+              echoed += fragment.length + 1
+              log fragment
+            end
+          end
+        end
+      end
+    end
+    
+    if block
+      # Run the callback
+      callback_thread = Thread.new do
+        if opts[:stdin]
+          # Wait for stdin to be written before calling...
+          until written
+            sleep 0.1
+          end
+        end
+
+        block.call(channel)
+      end
+    end
+
+    # Wait for the command to complete.
+    channel.wait
+
+    # Let the callback thread finish as well
+    callback_thread.join if callback_thread
+
+    if opts[:check_exit_status]
+      # Make sure we have our status.
+      if status.nil? or status.empty?
+        raise "empty status in host#exec() for #{command}, hmmm"
+      end
+
+      # Check status.
+      status = status.to_i
+      if  status != 0
+        raise "#{command} exited with non-zero status #{status}!\nSTDERR:\n#{stderr}\nSTDOUT:\n#{stdout}"
+      end
+    end
+
+    stdout.chomp
+  end
+
+  # Returns true when a file exists, otherwise false
+  def exists?(path)
+    true if ftype(path) rescue false
+  end
+
+  # Generates a full path for the given remote path.
+  def expand_path(path)
+    path = path.to_s.gsub(/~(\w+)?/) { |m| homedir($1) }
+    File.expand_path(path, cwd.to_s)
+  end
+  
+  # Returns true if a regular file exists.
+  def file?(path)
+    ftype(path) == 'file' rescue false
+  end
+
+  # Returns the filetype, as string. Raises exceptions on failed stat.
+  def ftype(path)
+    path = expand_path(path)
+    begin
+      str = self.stat('-c', '%F', path).strip
+      case str
+      when /no such file or directory/i
+        raise Errno::ENOENT, "#{self}:#{path} does not exist"
+      when 'regular file'
+        'file'
+      when 'regular empty file'
+        'file'
+      when 'directory'
+        'directory'
+      when 'character special file'
+        'characterSpecial'
+      when 'block special file'
+        'blockSpecial'
+      when /link/
+        'link'
+      when /socket/
+        'socket'
+      when /fifo|pipe/
+        'fifo'
+      else
+        raise RuntimeError, "unknown filetype #{str}"
+      end
+    rescue
+      raise RuntimeError, "stat #{self}:#{path} failed - #{str}"
+    end
+  end
+
+  # Abusing convention slightly...
+  # Returns the group by name if this host belongs to it, otherwise false.
+  def group?(name)
+    name = name.to_s
+    @groups.find{ |g| g.name == name } || false
+  end
+
+  # Adds this host to a group.
+  def group(name)
+    group = name if name.kind_of? Salticid::Group
+    group ||= @salticid.group name
+    group.hosts |= [self]
+    @groups |= [group]
+    group
+  end
+
+  # Returns the gateway for this host.
+  def gw(gw = nil)
+    if gw
+      @gw = @salticid.host(gw)
+    else
+      @gw
+    end
+  end
+
+  # Returns the home directory of the given user, or the current user if
+  # none specified.
+  def homedir(user = (@sudo||@user))
+    exec! "awk -F: -v v=#{escape(user)} '{if ($1==v) print $6}' /etc/passwd"
+  end
+ 
+  def inspect
+    "#<#{@user}@#{@name} roles=#{@roles.inspect} tasks=#{@tasks.inspect}>"
+  end
+
+  # Issues a logging statement to this host's log.
+  # log :error, "message"
+  # log "message" is the same as log "info", "message"
+  def log(*args)
+    begin
+      @on_log.call Message.new(*args)
+    rescue
+      # If the log handler is broken, keep going.
+    end
+  end
+
+  # Missing methods are resolved as follows:
+  # 0. Create a RoleProxy from a Role on this host
+  # 1. From task_resolve
+  # 2. Converted to a command string and exec!'ed
+  def method_missing(meth, *args, &block)
+    if meth.to_s == "to_ary"
+      raise NoMethodError
+    end
+
+    if args.empty? and rp = role_proxy(meth)
+      rp
+    elsif task = resolve_task(meth)
+      task.run(self, *args, &block)
+    else
+      if args.last.kind_of? Hash
+        opts = args.pop
+      else
+        opts = {}
+      end
+      str = ([meth] + args.map{|a| escape(a)}).join(' ')
+      exec! str, opts, &block
+    end
+  end
+
+  # Returns the file mode of a remote file.
+  def mode(path)
+    stat('-c', '%a', path).oct
+  end
+
+  # Sets or gets the name of this host.
+  def name(name = nil)
+    if name
+      @name = name.to_s
+    else
+      @name
+    end
+  end
+
+  def on_log(&block)
+    @on_log = block
+  end
+
+  # Finds a task for this host, by name.
+  def resolve_task(name)
+    name = name.to_s
+    @tasks.each do |task|
+      return task if task.name == name
+    end
+    @salticid.tasks.each do |task|
+      return task if task.name == name
+    end
+    nil
+  end
+
+  # Assigns roles to a host from the Salticid. Roles are unique in hosts; repeat
+  # assignments will not result in more than one copy of the role.
+  def role(role)
+    @roles = @roles | [@salticid.role(role)]
+  end
+
+  # Does this host have the given role?
+  def role?(role)
+    @roles.any? { |r| r.name == role.to_s }
+  end
+
+  # Returns a role proxy for role on this host, if we have the role.
+  def role_proxy(name)
+    if role = roles.find { |r| r.name == name.to_s }
+      @role_proxies[name.to_s] ||= RoleProxy.new(self, role)
+    end
+  end
+
+  # Runs the specified task on the given role. Raises NoMethodError if
+  # either the role or task do not exist.
+  def run(role, task, *args)
+    if rp = role_proxy(role)
+      rp.__send__(task, *args)
+    else
+      raise NoMethodError, "No such role #{role.inspect} on #{self}"
+    end
+  end
+
+  # Opens an SSH connection and stores the connection in @ssh.
+  def ssh
+    @ssh_lock.synchronize do
+      if @ssh and not @ssh.closed?
+        return @ssh
+      end
+
+      if tunnel
+        @ssh = tunnel.ssh(name, user)
+      else
+        @ssh = Net::SSH.start(name, user)
+      end
+    end
+  end
+
+  # If a block is given, works like #as. Otherwise, just execs sudo with the
+  # given arguments.
+  def sudo(*args, &block)
+    if block_given?
+      as *args, &block
+    else
+      method_missing(:sudo, *args)
+    end
+  end
+
+  # Uploads a file and places it in the final destination as root.
+  # If the file already exists, its ownership and mode are used for
+  # the replacement. Otherwise it inherits ownership from the parent directory.
+  def sudo_upload(local, remote, opts={})
+    remote = expand_path remote
+
+    # TODO: umask this?
+    local_mode = File.stat(local).mode & 07777
+    File.chmod 0600, local
+  
+
+    # Get temporary filename
+    tmpfile = '/'
+    while exists? tmpfile
+      tmpfile = '/tmp/sudo_upload_' + Time.now.to_f.to_s
+    end
+
+    # Upload
+    upload local, tmpfile, opts
+
+    # Get remote mode/user/group
+    sudo do
+      if exists? remote
+        mode = self.mode remote
+        user = stat('-c', '%U', remote).strip
+        group = stat('-c', '%G', remote).strip
+      else
+        user = stat('-c', '%U', File.dirname(remote)).strip
+        group = stat('-c', '%G', File.dirname(remote)).strip
+        mode = local_mode
+      end
+
+      # Move and chmod
+      mv tmpfile, remote
+      chmod mode, remote
+      chown "#{user}:#{group}", remote
+    end
+  end
+
+  # Finds (and optionally defines) a task.
+  # 
+  # Tasks are first resolved in the host's task list, then in the Salticid's task
+  # list. Finally, tasks are created from scratch. Any invocation of task adds
+  # that task to this host.
+  # 
+  # If a block is given, the block is assigned to the local (host) task. The
+  # task is dup'ed to prevent modifying a possible global task.
+  #
+  # The task is returned at the end of the method.
+  def task(name, &block)
+    name = name.to_s
+
+    if task = @tasks.find{|t| t.name == name}
+      # Found in self
+    elsif (task = @salticid.tasks.find{|t| t.name == name}) and not block_given?
+      # Found in salticid
+      @tasks << task
+    else
+      # Create new task in self
+      task = Salticid::Task.new(name, :salticid => @salticid)
+      @tasks << task
+    end
+
+    if block_given?
+      # Remove the task from our list, and replace it with a copy.
+      # This is to prevent local declarations from clobbering global tasks.
+      i = @tasks.index(task) || @task.size
+      task = task.dup
+      task.block = block
+      @tasks[i] = task
+    end
+
+    task
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+  def to_string
+    h = "Host #{@name}:\n"
+    h << "  Groups: #{groups.map(&:to_s).sort.join(', ')}\n" 
+    h << "  Roles: #{roles.map(&:to_s).sort.join(', ')}\n" 
+    h << "  Tasks:\n"
+    tasks = self.tasks.map(&:to_s)
+    tasks += roles.map { |r| r.tasks.map { |t| "    #{r}.#{t}" }}
+    h << tasks.flatten!.sort!.join("\n")
+  end
+
+  # Returns an SSH::Gateway object for connecting to this host, or nil if no
+  # gateway is needed.
+  def tunnel
+    if gw
+      # We have a gateway host.
+      @tunnel ||= gw.gateway_tunnel
+    end
+  end
+
+  # Upload a file to the server. Remote defaults to local's filename (without
+  # path) if not specified.
+  def upload(local, remote = nil, opts={})
+    remote ||= File.split(local).last
+    remote = expand_path remote
+    ssh.scp.upload!(local, remote, opts)
+  end
+
+  def user(user = nil)
+    if user
+      @user = user
+    else
+      @user
+    end
+  end
+end