automate-it 0.9.0

data/lib/automateit/account_manager/etc.rb

@@ -0,0 +1,128 @@
+# == AccountManager::Etc
+#
+# An AccountManager driver for Unix-like OSes that have the Ruby Etc module. It
+# is only suitable for doing queries and lacks methods that perform
+# modifications, such as +add_user+. Platform-specific drivers inherit from
+# this class and provide methods that perform modifications.
+class ::AutomateIt::AccountManager::Etc< ::AutomateIt::AccountManager::BaseDriver
+  depends_on :libraries => %w(etc),
+    :callbacks => lambda{
+      begin
+        ! ::Etc.getpwnam(::Etc.getlogin).nil?
+      rescue
+        false
+      end
+    }
+
+  def suitability(method, *args) # :nodoc:
+    return available? ? 1 : 0
+  end
+
+  #.......................................................................
+
+  # == UserQuery
+  #
+  # A class used for querying users. See AccountManager#users.
+  class UserQuery
+    # See AccountManager#users
+    def [](query)
+      ::Etc.endpwent
+      begin
+        case query
+        when String
+          return ::Etc.getpwnam(query)
+        when Fixnum
+          return ::Etc.getpwuid(query)
+        else
+          raise TypeError.new("unknonwn type for query: #{query.class}")
+        end
+      rescue ArgumentError
+        return nil
+      end
+    end
+  end
+
+  # See AccountManager#users
+  def users
+    return UserQuery.new
+  end
+
+  # See AccountManager#has_user?
+  def has_user?(query)
+    return ! users[query].nil?
+  end
+
+  #.......................................................................
+
+  # == GroupQuery
+  #
+  # A class used for querying groups. See AccountManager#groups.
+  class GroupQuery
+    # See AccountManager#groups
+    def [](query)
+      ::Etc.endgrent
+      begin
+        case query
+        when String
+          return ::Etc.getgrnam(query)
+        when Fixnum
+          return ::Etc.getgrgid(query)
+        else
+          raise TypeError.new("unknonwn type for query: #{query.class}")
+        end
+      rescue ArgumentError
+        return nil
+      end
+    end
+  end
+
+  # See AccountManager#groups
+  def groups
+    return GroupQuery.new
+  end
+
+  # See AccountManager#has_group?
+  def has_group?(query)
+    return ! groups[query].nil?
+  end
+
+  # See AccountManager#groups_for_user
+  def groups_for_user(query)
+    pwent = users[query]
+    return [] if preview? and not pwent
+    username = pwent.name
+    result = Set.new
+    result << groups[pwent.gid].name if groups[pwent.gid]
+    ::Etc.group do |grent|
+      result << grent.name if grent.mem.include?(username)
+    end
+    return result.to_a
+  end
+
+  # See AccountManager#users_for_group
+  def users_for_group(query)
+    grent = groups[query]
+    return (preview? || ! grent) ? [] : grent.mem
+  end
+
+  # See AccountManager#users_to_groups
+  def users_to_groups
+    result = {}
+    ::Etc.group do |grent|
+      grent.mem.each do |username|
+        result[username] ||= Set.new
+        result[username] << grent.name
+      end
+    end
+    ::Etc.passwd do |pwent|
+      grent = groups[pwent.gid]
+      unless grent
+        log.fatal(PNOTE+"WARNING: User's default group doesn't exist: user %s, gid %s" % [pwent.name, pwent.gid])
+        next
+      end
+      result[pwent.name] ||= Set.new
+      result[pwent.name] << grent.name
+    end
+    return result
+  end
+end

data/lib/automateit/account_manager/nscd.rb

@@ -0,0 +1,33 @@
+# == AccountManager::NSCD
+#
+# AccountManager driver for invalidating records stored in the NSCD, Name
+# Service Cache Daemon, found on Unix-like systems.
+class ::AutomateIt::AccountManager::NSCD < ::AutomateIt::AccountManager::BaseDriver
+  depends_on :programs => %w(nscd ps),
+    # FIXME AccountManager.nscd - "ps -ef" isn't portable, may need to be "ps aux" or such
+    :callbacks => lambda{`ps -ef`.match(%r{/usr/sbin/nscd$})}
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Portable
+    return available? ? 5 : 0
+  end
+
+  # Returns the NSCD database for the specified shorthand +query+.
+  def database_for(query)
+    case query.to_sym
+    when :user, :users, :passwd, :password
+      :passwd
+    when :group, :groups
+      :group
+    else
+      raise ArgumentError.new("Unknown cache database: #{query}")
+    end
+  end
+
+  # Invalidates the NSCD database, thus forcing a cache reload.
+  def invalidate(database)
+    return false unless available?
+
+    interpreter.sh("nscd -i #{database_for(database)}")
+  end
+end

data/lib/automateit/account_manager/passwd_expect.rb

@@ -0,0 +1,40 @@
+# == AccountManager::PasswdExpect
+#
+# An AccountManager driver for the +passwd+ command found on Unix-like systems
+# using the +expect+ program as a wrapper because the Ruby PTY implementation
+# is unreliable.
+class ::AutomateIt::AccountManager::PasswdExpect < ::AutomateIt::AccountManager::BaseDriver
+  depends_on :programs => %w(passwd expect)
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than PasswdPTY
+    return available? ? 9 : 0
+  end
+
+  # See AccountManager#passwd
+  def passwd(user, password, opts={})
+    _passwd_helper(user, password, opts) do |user, password, opts|
+      log.silence(Logger::WARN) do
+        interpreter.mktemp do |filename|
+          # Script derived from /usr/share/doc/expect/examples/autopasswd
+          interpreter.render(:text => <<-HERE, :to => filename)
+set password "#{password}"
+spawn passwd "#{user}"
+expect "assword:"
+sleep 0.1
+send "$password\\r"
+expect "assword:"
+sleep 0.1
+send "$password\\r"
+expect eof
+          HERE
+
+          cmd = "expect #{filename}"
+          cmd << " > /dev/null" if opts[:quiet]
+          return(interpreter.sh cmd)
+        end
+      end
+    end
+  end
+end
+

data/lib/automateit/account_manager/passwd_pty.rb

@@ -0,0 +1,69 @@
+# == AccountManager::PasswdPTY
+#
+# An AccountManager driver for +passwd+ command found on Unix-like systems
+# using the Ruby PTY implementation.
+#
+# *WARNING*: The Ruby PTY module is unreliable or unavailable on most
+# platforms. It may hang indefinitely or report incorrect results. Every
+# attempt has been made to work around these problems, but this is a low-level
+# problem. You are strongly encouraged to install the +expect+ program, which
+# works flawlessly. Once the +expect+ program is installed, passwords will be
+# changed using the AccountManager::PasswdExpect driver, which works properly.
+class ::AutomateIt::AccountManager::PasswdPTY < ::AutomateIt::AccountManager::BaseDriver
+  depends_on \
+    :programs => %w(passwd uname),
+    :libraries => %w(open3 expect pty),
+    # Something is horribly wrong with Ruby PTY on Sun
+    :callbacks => lambda { `uname -s`.strip !~ /sunos|solaris|openbsd|freebsd/i }
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Linux
+    return available? ? 3 : 0
+  end
+
+  # See AccountManager#passwd
+  def passwd(user, password, opts={})
+    log.info(PERROR+"Setting password with flaky Ruby PTY, which hangs or fails randomly. Install 'expect' (http://expect.nist.gov/) for reliable operation.")
+    _passwd_helper(user, password, opts) do
+      log.silence(Logger::WARN) do
+        interpreter.mktemp do |filename|
+          tries = 5
+          exitstatus = nil
+          begin
+            exitstruct = _passwd_raw(user, password, opts)
+            if exitstatus and not exitstruct.exitstatus.zero?
+              # FIXME AccountManager::Linux#passwd -- The `passwd` command randomly returns exit status 10 even when it succeeds. What does this mean and how to deal with it?! Temporary workaround is to throw an error and force a retry.
+              raise Errno::EPIPE.new("bad exitstatus %s" % exitstruct.exitstatus)
+            end
+          rescue Errno::EPIPE => e
+            # FIXME AccountManager::Linux#passwd -- EPIPE exception randomly thrown even when `passwd` succeeds. How to eliminate it? How to differentiate between this false error and a real one?
+            if tries <= 0
+              raise e
+            else
+              tries -= 1
+              retry
+            end
+          end
+          return exitstruct.exitstatus.zero?
+        end
+      end
+    end
+
+  end
+
+  def _passwd_raw(user, password, opts={})
+    quiet = (opts[:quiet] or not log.info?)
+
+    require 'open4'
+    return Open4::popen4("passwd %s 2>&1" % user) do |pid, sin, sout, serr|
+      $expect_verbose = ! quiet
+      2.times do
+        sout.expect(/:/)
+        sleep 0.1 # Reduce chance of passwd thinking we're a robot :(
+        sin.puts password
+        puts "*" * 12 unless quiet
+      end
+    end
+  end
+  protected :_passwd_raw
+end

data/lib/automateit/account_manager/posix.rb

@@ -0,0 +1,138 @@
+# == AccountManager::POSIX
+#
+# A POSIX driver for the AccountManager.
+class ::AutomateIt::AccountManager::POSIX < ::AutomateIt::AccountManager::BaseDriver
+  depends_on :programs => %w(useradd usermod userdel groupadd groupmod groupdel)
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Portable
+    return available? ? 2 : 0
+  end
+
+  #.......................................................................
+
+  # See AccountManager#add_user
+  def add_user(username, opts={})
+    return _add_user_helper(username, opts) do |username, opts|
+      cmd = "useradd"
+      cmd << " -c #{opts[:description] || username}"
+      cmd << " -d #{opts[:home]}" if opts[:home]
+      cmd << " -m" unless opts[:create_home] == false
+      cmd << " -G #{opts[:groups].join(',')}" if opts[:groups]
+      cmd << " -s #{opts[:shell] || "/bin/bash"}"
+      cmd << " -u #{opts[:uid]}" if opts[:uid]
+      cmd << " -g #{opts[:gid]}" if opts[:gid]
+      cmd << " #{username} < /dev/null"
+      cmd << " > /dev/null 2>&1 | grep -v blocks" if opts[:quiet]
+      interpreter.sh(cmd)
+    end
+  end
+
+  # TODO AccountManager#update_user -- implement
+  ### def update_user(username, opts={}) dispatch(username, opts) end
+
+  # See AccountManager#remove_user
+  def remove_user(username, opts={})
+    return _remove_user_helper(username, opts) do |username, opts|
+      # Options: -r -- remove the home directory and mail spool
+      cmd = "userdel"
+      cmd << " -r" unless opts[:remove_home] == false
+      cmd << " #{username}"
+      cmd << " > /dev/null" if opts[:quiet]
+      interpreter.sh(cmd)
+    end
+  end
+
+  # See AccountManager#add_groups_to_user
+  def add_groups_to_user(groups, username)
+    return _add_groups_to_user_helper(groups, username) do |missing, username|
+      targets = (groups_for_user(username) + missing).uniq
+
+      cmd = "usermod -G #{targets.join(',')} #{username}"
+      interpreter.sh(cmd)
+    end
+  end
+
+  # See AccountManager#remove_groups_from_user
+  def remove_groups_from_user(groups, username)
+    return _remove_groups_from_user_helper(groups, username) do |present, username|
+      matches = (groups_for_user(username) - [groups].flatten).uniq
+      cmd = "usermod -G #{matches.join(',')} #{username}"
+      interpreter.sh(cmd)
+    end
+  end
+
+  #.......................................................................
+
+  # See AccountManager#add_group
+  def add_group(groupname, opts={})
+    modified = false
+    unless has_group?(groupname)
+      modified = true
+
+      cmd = "groupadd"
+      cmd << " -g #{opts[:gid]}" if opts[:gid]
+      cmd << " #{groupname}"
+      interpreter.sh(cmd)
+
+      manager.invalidate(:groups)
+    end
+
+    if opts[:members]
+      modified = true
+      add_users_to_group(opts[:members], groupname)
+    end
+
+    return modified ? groups[groupname] : false
+  end
+
+  # TODO AccountManager#update_group -- implement
+  ### def update_group(groupname, opts={}) dispatch(groupname, opts) end
+
+  # See AccountManager#remove_group
+  def remove_group(groupname, opts={})
+    return false unless has_group?(groupname)
+    cmd = "groupdel #{groupname}"
+    interpreter.sh(cmd)
+
+    manager.invalidate(:groups)
+
+    return true
+  end
+
+  # See AccountManager#add_users_to_group
+  def add_users_to_group(users, groupname)
+    _add_users_to_group_helper(users, groupname) do |missing, groupname|
+      for username in missing
+        targets = (groups_for_user(username) + [groupname]).uniq
+        cmd = "usermod -G #{targets.join(',')} #{username}"
+        interpreter.sh(cmd)
+      end
+    end
+  end
+
+  # See AccountManager#remove_users_from_group
+  def remove_users_from_group(users, groupname)
+    _remove_users_from_group_helper(users, groupname) do |present, groupname|
+      u2g = users_to_groups
+      for username in present
+        user_groups = u2g[username]
+        # FIXME tries to include non-present groups, should use some variant of present
+        cmd = "usermod -G #{(user_groups.to_a-[groupname]).join(',')} #{username}"
+        interpreter.sh(cmd)
+      end
+    end
+  end
+
+  # Dispatch common names to Etc, but don't define these methods here because
+  # that would make available? and suitability think these exist, when in fact,
+  # they're just wrappers.
+  def method_missing(symbol, *args, &block)
+    case symbol
+    when :users, :has_user?, :groups, :has_group?, :groups_for_user, :users_for_group, :users_to_groups
+      manager.send(symbol, *args, &block)
+    else
+      super(symbol, *args, &block)
+    end
+  end
+end

data/lib/automateit/address_manager.rb

@@ -0,0 +1,88 @@
+# == AddressManager
+#
+# The AddressManager provides a way to query, add and remove network
+# addresses on a host.
+class AutomateIt::AddressManager < AutomateIt::Plugin::Manager
+  # Does host have an address or interface? Arguments hash must include
+  # either a :device (e.g., "eth0") or :address (e.g., "10.0.0.10"), and an
+  # optional :label (e.g., "foo"). Note that an interface is the combination
+  # of a :device and :label, so "eth0" isn't the same as "eth0:foo".
+  #
+  # Examples on a host with address "10.0.0.10" on interface "eth0:foo":
+  #   has?(:address => "10.0.0.10")
+  #   => true
+  #   has?(:address => "10.0.0.10", :device => "eth0")
+  #   => false
+  #   has?(:address => "10.0.0.10", :device => "eth0", :label => "foo")
+  #   => true
+  #   has?(:device => "eth0")
+  #   => false
+  #   has?(:device => "eth0", :label => "foo")
+  #   => true
+  def has?(opts) dispatch(opts) end
+
+  # Add address to host if it doesn't have it. Requires root-level access.
+  # Returns +true+ if action was taken and succeeded.
+  #
+  # Arguments hash must include either a :device (e.g., "eth0") or :address
+  # (e.g., "10.0.0.10"), and an optional :label (e.g., "foo") and :mask (e.g.
+  # "24").
+  #
+  # An optional number of ARP :announcements may be specified, defaulting to
+  # AutomateIt::AddressManager::DEFAULT_ANNOUNCEMENTS. Drivers that handle
+  # announcements will block an extra second while making each announcement.
+  #
+  # Example:
+  #   add(:address => "10.0.0.10", :mask => 24, :device => "eth0",
+  #     :label => "foo", :announcements => 3)
+  def add(opts) dispatch(opts) end
+
+  # Number of ARP announcements to make by default during #add.
+  DEFAULT_ANNOUNCEMENTS = 3
+
+  # Remove address from host if it has it. Requires root-level access.
+  # Returns +true+ if action was taken and succeeded.
+  #
+  # Arguments hash must include either a :device (e.g., "eth0") or :address
+  # (e.g., "10.0.0.10"), and an optional :label (e.g., "foo") and :mask (e.g.
+  # "24").
+  #
+  # Example:
+  #   remove(:address => "10.0.0.10", :mask => 24, :device => "eth0",
+  #     :label => "foo")
+  def remove(opts) dispatch(opts) end
+
+  # Array of addresses for this host. Example:
+  #   addresses
+  #   => ["10.0.0.10", "127.0.0.1"]
+  def addresses() dispatch() end
+
+  # Array of interfaces for this host. Example:
+  #   interfaces
+  #   => ["eth0", "lo"]
+  def interfaces() dispatch() end
+
+  # Array of hostnames for this host, including variants by trying to resolve
+  # names for all addresses owned by this host. Example:
+  #   hostnames
+  #   => ["kagami", "kagami.lucky-channel", "kagami.lucky-channel.jp"]
+  def hostnames() dispatch() end
+
+  # Array of hostname variants for this +hostname+. This method performs no
+  # name resolution and simply infers a less qualified name from a more
+  # qualified hostname argument. Example:
+  #   hostnames_for("kagami.lucky-channel")
+  #   => ["kagami", "kagami.lucky-channel"]
+  #   hostnames_for("kagami")
+  #   => ["kagami"]
+  def hostnames_for(hostname) dispatch(hostname) end
+end
+
+# Drivers
+require 'automateit/address_manager/base'
+require 'automateit/address_manager/portable'
+require 'automateit/address_manager/bsd'
+require 'automateit/address_manager/linux'
+require 'automateit/address_manager/sunos'
+require 'automateit/address_manager/openbsd'
+require 'automateit/address_manager/freebsd'