automate-it 0.9.0

data/helpers/cpan_wrapper.pl

@@ -0,0 +1,220 @@
+# This file can be used as both a Perl library (read the POD below) and a
+# stand-alone program (run it with "--help" for instructions).
+
+=head1 NAME
+
+CpanWrapper - Provides a simpler wrapper for the CPAN package manager.
+
+=head1 DESCRIPTION
+
+This module provides easy-to-use methods for installing, uninstalling and
+querying the status of CPAN modules.
+
+=over
+
+=cut
+
+use warnings "all";
+
+package CpanWrapper;
+
+require CPAN;
+require ExtUtils::Packlist;
+require ExtUtils::Installed;
+require Tie::Handle;
+
+=head1 CLASS VARIABLES
+
+=item $CpanWrapper::DRYRUN
+
+Should actions really happen? E.g., in dry-run mode, the uninstall will only
+pretend to delete files.
+
+=cut
+
+our $DRYRUN = 0;
+
+=head1 CLASS METHODS
+
+=item CpanWrapper->query($module_name)
+
+Query the module and return 1 if it's installed, 0 if not.
+
+=cut
+sub query {
+  my($class, $module) = @_;
+  no warnings;
+  my $result = $CPAN::META->has_inst($module);
+  use warnings "all";
+  return $result;
+}
+
+=item CpanWrapper->uninstall($module_name)
+
+Uninstall the module. Returns an array of files removed.
+
+=cut
+sub uninstall {
+  # /usr/local/lib/perl/5.8.8/auto/ack/.packlist
+  my($class, $module) = @_;
+  my $packlists = ExtUtils::Installed->new;
+  my @result;
+  foreach my $file ($packlists->files($module)) {
+    push(@result, $file);
+    unlink $file unless $DRYRUN;
+  }
+  my $packlist = $packlists->packlist($module)->packlist_file();
+  push(@result, $packlist);
+  unlink $packlist unless $DRYRUN;
+  return @result;
+}
+
+=item CpanWrapper->install($module_name)
+
+Install the module. Returns 0 if can't find module.
+
+=cut
+sub install {
+  no warnings;
+  my($class, $module) = @_;
+  tie *NO, 'NoHandle';
+  open(SAVEIN, ">&STDIN");
+  open(STDIN, ">&NO"); # TODO why isn't this enough?
+  *STDIN = *NO;
+  my $result;
+  if (my $module_ref = CPAN::Shell->expand('Module', $module)) {
+    $module_ref->install unless $DRYRUN;
+    $result = 1;
+  } else {
+    $result = 0;
+  }
+  open(STDIN, ">&SAVEIN");
+  close NO;
+  use warnings "all";
+  return $result;
+}
+
+=item NoHandle
+
+File handle that responds with "no" to all readline queries. This is used
+during the install process to reject CPAN's unreasonable defaults.
+
+=cut
+package NoHandle;
+sub TIEHANDLE { my $self; bless \$self, shift }
+sub WRITE { die }
+sub PRINT { die }
+sub PRINTF { die }
+sub READ { die }
+sub READLINE { print "no\n"; return "no\n" }
+sub GETC { die }
+sub CLOSE { }
+sub OPEN { }
+sub BINMODE { }
+sub EOF { 0 }
+sub TELL { }
+sub DESTROY { }
+
+#===[ command-line usage ]==============================================
+
+package main;
+if ($0 eq __FILE__) {
+  sub usage {
+    my($message) = @_;
+    print <<HERE;
+USAGE: cpan_wrapper.pl [OPTIONS] ACTION module [modules...]
+
+OPTIONS:
+--help
+    Show this help
+--quiet
+    Don't print anything other than what CPAN generates
+--dryrun
+    Don't actually perform actions, just pretend to
+
+ACTIONS:
+
+--install
+    Install modules
+--uninstall
+    Uninstall modules
+--query
+    Display which packages are installed and which aren't
+HERE
+
+    if ($message) {
+      print "ERROR: $message\n";
+      exit 1;
+    } else {
+      exit 0;
+    }
+  }
+
+  use Getopt::Long;
+  our $quiet = 0;
+  our $dryrun = 0;
+  our $help = 0;
+  our $install = 0;
+  our $uninstall = 0;
+  our $query = 0;
+  GetOptions(
+    'quiet' => \$quiet,
+    'dryrun' => \$dryrun,
+    'n' => \$dryrun,
+    'help' => \$help,
+    'install' => \$install,
+    'uninstall' => \$uninstall,
+    'query' => \$query,
+    'q' => \$query
+  );
+  my @modules = @ARGV;
+
+  usage(0) if 1 == $help;
+  usage("No action specified") unless $install or $uninstall or $query;
+  usage("No modules specified") unless $#modules >= 0;
+
+  if ($install) {
+    foreach my $module (@modules) {
+      if (CpanWrapper->install($module)) {
+        print "* Installed: $module\n" unless $quiet;
+      } else {
+        print "! Can't find CPAN module: $module\n";
+        exit 1
+      }
+    }
+  } elsif ($uninstall) {
+    foreach my $module (@modules) {
+      print "* Uninstalling module: $module\n" unless $quiet;
+
+      my(@files) = CpanWrapper->uninstall($module);
+      foreach my $file (@files) {
+        print "- $file\n" unless $quiet;
+      }
+    }
+  } elsif ($query) {
+    my @available;
+    my @unavailable;
+    foreach my $module (@modules) {
+      if (CpanWrapper->query($module)) {
+        push(@available, $module);
+      } else {
+        push(@unavailable, $module);
+      }
+    }
+
+    sub print_contents {
+      my($name, @modules) = @_;
+      return if $#modules < 0;
+      print "$name:\n";
+      foreach my $module (@modules) {
+        print "  - $module\n";
+      }
+    }
+
+    print "--- %YAML:1.0\n";
+    print_contents 'available', @available;
+    print_contents 'unavailable', @unavailable;
+  }
+}
+
+1;

data/helpers/which.cmd

@@ -0,0 +1,7 @@
+@ rem "which" workalike for Windows. Searches current directory and PATH for all extensions, stops after first match, and returns meaningful exit value for "system" or "ERRORLEVEL" checks.
+@setlocal
+@set P2=.;%PATH%
+@for %%e in (%PATHEXT%) do @for %%i in (%1%%e) do @if NOT "%%~$P2:i"=="" echo %%~$P2:i && goto end
+@rem REM This exits the shell on failure, so don't use it directly
+@exit 1
+:end

data/lib/automateit.rb

@@ -0,0 +1,55 @@
+# == 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 'erb'
+
+# Extensions
+require 'inactive_support'
+require 'ext/object.rb'
+require 'ext/metaclass.rb'
+require 'ext/shell_escape.rb'
+
+# Helpers
+require 'hashcache'
+require 'queued_logger'
+require 'tempster'
+require 'helpful_erb'
+require 'nested_error'
+require 'nitpick'
+
+# 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'
+require 'automateit/download_manager'

data/lib/automateit/account_manager.rb

@@ -0,0 +1,114 @@
+# == AccountManager
+#
+# The AccountManager provides a way of managing system accounts, such as Unix
+# users and groups.
+class AutomateIt::AccountManager < AutomateIt::Plugin::Manager
+  # Invalidate system cache for +database+. The +database+ can be either :users
+  # or :groups. This is necessary on operating systems that lack logic to
+  # notify their caching system that an entry changed. If the OS doesn't need
+  # invalidation, will do nothing and return false.
+  #
+  # This method is primarily for the sake of driver authors, recipe authors
+  # will probably never need to use this.
+  def invalidate(database) dispatch_safely(database) end
+
+  #-----------------------------------------------------------------------
+
+  # 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, opts={}) dispatch(user, password, opts) 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
+
+# Drivers
+require 'automateit/account_manager/base'
+require 'automateit/account_manager/passwd_pty'
+require 'automateit/account_manager/passwd_expect'
+require 'automateit/account_manager/nscd'
+require 'automateit/account_manager/etc'
+require 'automateit/account_manager/posix'

data/lib/automateit/account_manager/base.rb

@@ -0,0 +1,138 @@
+# == AccountManager::BaseDriver
+#
+# Base class for all AccountManager drivers.
+class ::AutomateIt::AccountManager::BaseDriver < ::AutomateIt::Plugin::Driver
+  protected
+
+  def _passwd_helper(user, password, opts={}, &block)
+    users = 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
+
+    return block.call(user, password, opts)
+  end
+
+  def _add_user_helper(username, opts={}, &block)
+    return false if has_user?(username)
+
+    # Create group first, then the user. Necessary because some OSes can't add users with non-existent groups.
+
+    if opts[:personal_group].nil? and not opts[:group] and not opts[:gid]
+      opts[:personal_group] = true
+    end
+
+    # FIXME how to default personal_group to false?
+    # FIXME what if want to add user to a specific group, rather than creating?
+    # FIXME what if want or not want to crease user group?
+    # FIXME how to find an unused gid/uid combo?
+
+    unless opts[:group] == false
+      groupname = opts[:group] || username
+      unless has_group?(groupname)
+        if not opts[:uid] and not opts[:gid] and group = add_group(groupname, opts)
+          opts[:uid] = opts[:gid] = group.gid
+        end
+      end
+    end
+
+    block.call(username, opts)
+    manager.invalidate(:passwd)
+
+    passwd_opts = {:quiet => opts[:quiet]}
+    manager.passwd(username, opts[:passwd], passwd_opts) if opts[:passwd]
+
+    manager.invalidate(:passwd)
+    return users[username]
+  end
+
+  def _remove_user_helper(username, opts={}, &block)
+    return false unless has_user?(username)
+
+    block.call(username, opts)
+    manager.invalidate(:passwd)
+    remove_group(username) if has_group?(username)
+
+    return true
+  end
+
+  def _add_groups_to_user_helper(groups, username, &block)
+    groups = [groups].flatten
+    present = groups_for_user(username)
+    missing = groups - present
+    return false if missing.empty?
+
+    block.call(missing, username)
+    manager.invalidate(:group)
+
+    return missing
+  end
+
+  def _remove_groups_from_user_helper(groups, username, &block)
+    groups = [groups].flatten
+    matched = groups_for_user(username)
+    present = groups & matched
+    return false if present.empty?
+
+    block.call(present, username)
+    manager.invalidate(:group)
+
+    return present
+  end
+
+  def _add_users_to_group_helper(users, groupname, &block)
+    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?
+
+    block.call(missing, groupname)
+    manager.invalidate(:groups)
+
+    return missing
+  end
+
+  def _remove_users_from_group_helper(users, groupname, &block)
+    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?
+
+    block.call(present, groupname)
+    manager.invalidate(:groups)
+
+    return present
+  end
+end