automateit 0.70923

data/lib/automateit.rb

@@ -0,0 +1,66 @@
+# == Dependencies
+
+# Standard libraries
+require 'etc'
+require 'fileutils'
+require 'find'
+require 'logger'
+require 'open3'
+require 'pp'
+require 'pathname'
+require 'resolv'
+require 'set'
+require 'socket'
+require 'yaml'
+
+# Gems
+require 'rubygems'
+require 'open4'
+require 'erb'
+
+# Load ActiveSupport pieces individually to save ~0.5s
+### require 'active_support'
+require 'active_support/core_ext/blank' # foo.blank?
+require 'active_support/core_ext/class/attribute_accessors' # cattr_accessor
+require 'active_support/core_ext/class/inheritable_attributes' # inheritable_cattr_accessor
+require 'active_support/core_ext/module/aliasing' # alias_method_chain
+require 'active_support/core_ext/string' # "asdf".demodulize.underscore
+require 'active_support/clean_logger' # cleans up Logger output
+require 'active_support/core_ext/symbol' # [:foo, :bar].map(&:to_s)
+
+# Handle ActiveSupport includes
+require 'active_support/core_ext/hash/keys' # {:foo => :bar}.stringify_keys
+Hash.module_eval{include ActiveSupport::CoreExtensions::Hash::Keys}
+
+# Extensions
+require 'ext/object.rb'
+require 'ext/metaclass.rb'
+
+# Helpers
+require 'hashcache'
+require 'queued_logger'
+require 'tempster'
+require 'helpful_erb'
+require 'nested_error'
+
+# Core
+require 'automateit/root'
+require 'automateit/constants'
+require 'automateit/error'
+require 'automateit/common'
+require 'automateit/interpreter'
+require 'automateit/plugin'
+require 'automateit/cli'
+require 'automateit/project'
+
+# Plugins which must be loaded early
+require 'automateit/shell_manager'
+require 'automateit/platform_manager' # requires shell
+require 'automateit/address_manager' # requires shell
+require 'automateit/tag_manager' # requires address, platform
+require 'automateit/field_manager' # requires shell
+require 'automateit/service_manager' # requires shell
+require 'automateit/package_manager' # requires shell
+require 'automateit/template_manager'
+require 'automateit/edit_manager'
+require 'automateit/account_manager'

data/lib/automateit/account_manager.rb

@@ -0,0 +1,106 @@
+# == AccountManager
+#
+# The AccountManager provides a way of managing system accounts, such as Unix
+# users and groups.
+class AutomateIt::AccountManager < AutomateIt::Plugin::Manager
+  # Find a user account. Method returns a query helper which takes a
+  # +username+ as an index argument and returns a Struct::Passwd entry as
+  # described in Etc::getpwent if the user exists or a nil if not.
+  #
+  # Example:
+  #   users["root"] # => #<struct Struct::Passwd name="root"...
+  #
+  #   users["does_not_exist"] # => nil
+  def users() dispatch() end
+
+  # Add the +username+ if not already created.
+  #
+  # Options:
+  # * :description -- User's full name. Defaults to username.
+  # * :home -- Path to user's home directory. If not specified, uses system
+  #   default like "/home/username".
+  # * :create_home -- Create homedir. Defaults to true.
+  # * :groups -- Array of group names to add this user to.
+  # * :shell -- Path to login shell. If not specified, uses system default
+  #   like "/bin/bash".
+  # * :uid -- Fixnum user ID for user. Default chooses an unused id.
+  # * :gid -- Fixnum group ID for user. Default chooses same gid as uid.
+  #
+  # Example:
+  #   add_user("bob", :description => "Bob Smith")
+  def add_user(username, opts={}) dispatch(username, opts) end
+
+  # TODO AccountManager#update_user -- implement
+  ### def update_user(username, opts={}) dispatch(username, opts) end
+
+  # Remove the +username+ if present.
+  #
+  # Options:
+  # * :remove_home -- Delete user's home directory and mail spool. Default is
+  #   true.
+  def remove_user(username, opts={}) dispatch(username, opts) end
+
+  # Is +user+ present?
+  def has_user?(user) dispatch(user) end
+
+  # Add +groups+ (array of groupnames) to +user+.
+  def add_groups_to_user(groups, user) dispatch(groups, user) end
+
+  # Remove +groups+ (array of groupnames) from +user+.
+  def remove_groups_from_user(groups, user) dispatch(groups, user) end
+
+  # Change the +password+ for the +user+.
+  def passwd(user, password) dispatch(user, password) end
+
+  #.......................................................................
+
+  # Find a group. Method returns a query helper which takes a
+  # +groupname+ as an index argument and returns a Struct::Group entry as
+  # described in Etc::getgrent if the group exists or a nil if not.
+  #
+  # Example:
+  #   groups["root"] # => #<struct Struct::Group name="root"...
+  #
+  #   groups["does_not_exist"] # => nil
+  def groups() dispatch() end
+
+  # Add +groupname+ if it doesn't exist. Options:
+  # * :members -- Array of usernames to add as members.
+  # * :gid -- Group ID to use. Default is to find an unused id.
+  def add_group(groupname, opts={}) dispatch(groupname, opts) end
+
+  # TODO AccountManager#update_group -- implement
+  ### def update_group(groupname, opts={}) dispatch(groupname, opts) end
+
+  # Remove +groupname+ if it exists.
+  def remove_group(groupname, opts={}) dispatch(groupname, opts) end
+
+  # Does +group+ exist?
+  def has_group?(group) dispatch(group) end
+
+  # Add +users+ (array of usernames) to +group+.
+  def add_users_to_group(users, group) dispatch(users, group) end
+
+  # Remove +users+ (array of usernames) from +group+.
+  def remove_users_from_group(users, group) dispatch(users, group) end
+
+  # Array of groupnames this user is a member of.
+  def groups_for_user(query) dispatch(query) end
+
+  # Array of usernames in group.
+  def users_for_group(query) dispatch(query) end
+
+  # Hash of usernames and the groupnames they're members of.
+  def users_to_groups() dispatch() end
+end # class AccountManager
+
+# == AccountManager::BaseDriver
+#
+# Base class for all AccountManager drivers.
+class ::AutomateIt::AccountManager::BaseDriver < AutomateIt::Plugin::Driver
+end
+
+# Drivers
+require 'automateit/account_manager/portable'
+require 'automateit/account_manager/linux'
+require 'automateit/account_manager/passwd'

data/lib/automateit/account_manager/linux.rb

@@ -0,0 +1,171 @@
+# == AccountManager::Linux
+#
+# A Linux-specific driver for the AccountManager.
+class ::AutomateIt::AccountManager::Linux < ::AutomateIt::AccountManager::Portable
+  depends_on \
+    :programs => %w(useradd usermod userdel groupadd groupmod groupdel),
+    :callbacks => [lambda{AutomateIt::AccountManager::Portable.has_etc?}]
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Portable
+    return available? ? 2 : 0
+  end
+
+  def setup(*args) # :nodoc:
+    super(*args)
+  end
+
+  # Is "nscd" available on this platform?
+  def nscd?
+    @nscd ||= interpreter.which("nscd")
+  end
+
+  #.......................................................................
+
+  # See AccountManager#add_user
+  def add_user(username, opts={})
+    return false if has_user?(username)
+    cmd = "useradd"
+    cmd << " --comment #{opts[:description] || username}"
+    cmd << " --home #{opts[:home]}" if opts[:home]
+    cmd << " --create-home" unless opts[:create_home] == false
+    cmd << " --groups #{opts[:groups].join(' ')}" if opts[:groups]
+    cmd << " --shell #{opts[:shell] || "/bin/bash"}"
+    cmd << " --uid #{opts[:uid]}" if opts[:uid]
+    cmd << " --gid #{opts[:gid]}" if opts[:gid]
+    cmd << " #{username} < /dev/null"
+    cmd << " > /dev/null" if opts[:quiet]
+    interpreter.sh(cmd)
+    interpreter.sh("nscd --invalidate passwd") if nscd?
+
+    unless opts[:group] == false
+      groupname = opts[:group] || username
+      unless has_group?(groupname)
+        opts = {:members => [username]}
+        # In preview mode, user doesn't exist and has no UID
+        opts[:gid] = users[username].uid if writing?
+        add_group(groupname, opts)
+      end
+    end
+
+    interpreter.account_manager.passwd(username, opts[:passwd]) if opts[:passwd]
+
+    return users[username]
+  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 false unless has_user?(username)
+    # 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)
+    interpreter.sh("nscd --invalidate passwd") if nscd?
+    remove_group(username) if has_group?(username)
+    return true
+  end
+
+  # See AccountManager#add_groups_to_user
+  def add_groups_to_user(groups, username)
+    groups = [groups].flatten
+    present = groups_for_user(username)
+    missing = groups - present
+    return false if missing.empty?
+
+    cmd = "usermod -a -G #{missing.join(',')} #{username}"
+    interpreter.sh(cmd)
+    interpreter.sh("nscd --invalidate group") if nscd?
+    return missing
+  end
+
+  # See AccountManager#remove_groups_from_user
+  def remove_groups_from_user(groups, username)
+    groups = [groups].flatten
+    present = groups_for_user(username)
+    removeable = groups & present
+    return false if removeable.empty?
+
+    cmd = "usermod -G #{(present-groups).join(',')} #{username}"
+    interpreter.sh(cmd)
+    interpreter.sh("nscd --invalidate group") if nscd?
+    return removeable
+  end
+
+  #.......................................................................
+
+  # See AccountManager#add_group
+  def add_group(groupname, opts={})
+    return false if has_group?(groupname)
+    cmd = "groupadd"
+    cmd << " -g #{opts[:gid]}" if opts[:gid]
+    cmd << " #{groupname}"
+    interpreter.sh(cmd)
+    interpreter.sh("nscd --invalidate group") if nscd?
+    add_users_to_group(opts[:members], groupname) if opts[:members]
+    return groups[groupname]
+  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)
+    interpreter.sh("nscd --invalidate group") if nscd?
+    return true
+  end
+
+  # See AccountManager#add_users_to_group
+  def add_users_to_group(users, groupname)
+    users = [users].flatten
+    # XXX Include pwent.gid?
+    grent = groups[groupname]
+    missing = \
+      if writing? and not grent
+        raise ArgumentError.new("no such group: #{groupname}")
+      elsif writing? or grent
+        users - grent.mem
+      else
+        users
+      end
+    return false if missing.empty?
+
+    for username in missing
+      cmd = "usermod -a -G #{groupname} #{username}"
+      interpreter.sh(cmd)
+    end
+    interpreter.sh("nscd --invalidate group") if nscd?
+    return missing
+  end
+
+  # See AccountManager#remove_users_from_group
+  def remove_users_from_group(users, groupname)
+    users = [users].flatten
+    grent = groups[groupname]
+    present = \
+      if writing? and not grent
+        raise ArgumentError.new("no such group: #{groupname}")
+      elsif writing? or grent
+        grent.mem & users
+      else
+        users
+      end
+    return false if present.empty?
+
+    u2g = users_to_groups
+    for username in present
+      user_groups = u2g[username]
+      cmd = "usermod -G #{(user_groups.to_a-[groupname]).join(',')} #{username}"
+      interpreter.sh(cmd)
+    end
+    interpreter.sh("nscd --invalidate group") if nscd?
+    return present
+  end
+end

data/lib/automateit/account_manager/passwd.rb

@@ -0,0 +1,69 @@
+# == AccountManager::Passwd
+#
+# An AccountManager driver for the +passwd+ command found on Unix-like systems.
+class ::AutomateIt::AccountManager::Passwd < ::AutomateIt::AccountManager::BaseDriver
+  depends_on \
+    :programs => %w(passwd),
+    :libraries => %w(open3 expect pty)
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Linux
+    return available? ? 3 : 0
+  end
+
+  # See AccountManager#passwd
+  def passwd(user, password, opts={})
+    users = interpreter.account_manager.users
+
+    unless users[user]
+      if preview?
+        log.info(PNOTE+"Setting password for user: #{user}")
+        return true
+      else
+        raise ArgumentError.new("No such user: #{user}")
+      end
+    end
+
+    case user
+    when Symbol: user = user.to_s
+    when Integer: user = users[user]
+    when String: # leave it alone
+    else raise TypeError.new("Unknown user type: #{user.class}")
+    end
+
+    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
+
+  def _passwd_raw(user, password, opts={})
+    quiet = (opts[:quiet] or not log.info?)
+
+    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/portable.rb

@@ -0,0 +1,136 @@
+# == AccountManager::Portable
+#
+# A pure-Ruby, portable driver for the AccountManager. It is only suitable
+# for doing queries and lacks methods such as +add_user+. Platform-specific
+# drivers inherit from this class and provide these methods.
+class ::AutomateIt::AccountManager::Portable < ::AutomateIt::AccountManager::BaseDriver
+  depends_on :callbacks => [lambda{AutomateIt::AccountManager::Portable.has_etc?}]
+
+  def suitability(method, *args) # :nodoc:
+    return 1
+  end
+  
+  # Does this platform provide a way of querying users and groups through 
+  # the 'etc' module?
+  def self.has_etc?
+    begin
+      require 'etc'
+      return defined?(Etc)
+    rescue LoadError
+      return false
+    end
+  end
+  
+  # Alias for AccountManager::Portable.has_etc?
+  def has_etc?
+    self.has_etc?
+  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