automateit 0.71230 → 0.80116

data/CHANGES.txt

@@ -1,3 +1,11 @@
+0.80116:
+    Date: Wed, 16 Jan 2008 23:55:44 -0800
+    Desc:
+    - (!) Fixed bug that prevented AutomateIt from working without the Builder gem's "blankslate" library. This fix should completely eliminate AutomateIt's dependence on Builder and ActiveSupport, like 0.71230 was supposed to do. This error was missed because other gems provide a "blankslate"-workalike and thus merely uninstalling Builder wasn't enough to confirm the previous fix.
+    - (+) Improved PackageManager::Gem, it can now use commands other than "gem" to manage RubyGem packages, such as "gem1.8". It now detects the best available command, but also lets you specify a default or choose one on a per-call basis. See the PackageManager::Gem documentation for examples. Comments are sought on the new syntax.
+    - Improved PackageManager#_list_normalizer, it now accepts comments mid-way through a line and can parse arrays of strings.
+    - Updated misc/setup_rubygems.sh, a simple shell script that downloads and install RubyGems 1.0.1, useful for bootstrapping a system to get AutomateIt running on it.
+
 0.71230:
     Date: Sun, 30 Dec 2007 14:05:31 -0800
     Desc:

data/TODO.txt

@@ -3,6 +3,7 @@ KEY: Important? Urgent? Easy? 1=yes, 0=no
 #===[ App ]=============================================================
 
 #---[ Quality issues ]--------------------------------------------------
+111 TagManager -- Catch bad YAML using friendly exceptions
 !!! ServiceManager -- Create new #stop_and_start, and add new #restart as #tell wrapper
 111 ServiceManager -- Write tests for start_and_enable and such
 !!! AccountManager -- Solaris fails 5% of the time on the last spec.
@@ -34,7 +35,7 @@ KEY: Important? Urgent? Easy? 1=yes, 0=no
 000 Shell -- Incorporate which.cmd so #which can work on Windows
 
 000 Interpreter#invoke and HelpfulERB -- Extract error context code into class
-000 Interpeter -- Implement #clear, #dirty? #track_changes
+000 Interpeter -- Implement #track_changes, #changed?
 000 DatabaseManager -- Design
 000 SourceManager -- Design
 000 ScheduleManager -- Design

data/examples/basic/recipes/install.rb

@@ -26,7 +26,7 @@ if tagged?(:myapp_servers)
   mkdir_p(lookup(:path)) do
     # Run shell commands to create the app and database
     unless File.exists?("config/routes.rb")
-      sh("rails --database=sqlite3 . > /dev/null")
+      sh("rails --database=sqlite3 . > /dev/null") or raise "Rails isn't fully installed"
     end
 
     # Create the database if it doesn't exist.

data/lib/automateit/package_manager.rb

@@ -214,7 +214,7 @@ class AutomateIt::PackageManager::BaseDriver < AutomateIt::Plugin::Driver
         packages = [packages.to_s]
       when String
         nitpick "LN Ss"
-        packages = packages.grep(LIST_NORMALIZER_RE).join(" ").split
+        packages = _string_to_packages(packages)
       when Hash
         # Don't do anything
         nitpick "LN Sh"
@@ -227,7 +227,7 @@ class AutomateIt::PackageManager::BaseDriver < AutomateIt::Plugin::Driver
 
     case packages
     when Array
-      result = packages.map(&:to_s).grep(LIST_NORMALIZER_RE)
+      result = packages.map(&:to_s).map{|t| _string_to_packages(t)}.flatten.uniq
     when Hash
       result = packages.stringify_keys
     when Symbol, String
@@ -240,8 +240,9 @@ class AutomateIt::PackageManager::BaseDriver < AutomateIt::Plugin::Driver
     return result
   end
 
-  # Expression for matching packages in arguments
-  LIST_NORMALIZER_RE = /^\s*([^\s#]+)/
+  def _string_to_packages(string)
+    string.scan(/^\s*([^#]+)\s*/).flatten.map{|t| t.split}.flatten.uniq
+  end
 end
 
 # Drivers

data/lib/automateit/package_manager.rb.orig

@@ -0,0 +1,256 @@
+# == PackageManager
+#
+# The PackageManager provides a way to manage packages, e.g., install,
+# uninstall and query if the Apache package is installed with APT.
+#
+# Examples:
+#
+#   package_manager.installed?("apache2") # => false
+#   package_manager.install("apache2") # => true
+#   package_manager.installed?("apache2") # => true
+#   package_manager.uninstall("apache2") # => true
+#   package_manager.not_installed("apache2") # => true
+#
+# Commands can accept arrays:
+#
+#   package_manager.install("apache2", "bash")
+#   package_manager.installed? %w(apache2 bash)
+#
+# Commands can also accept a single, annotated string as a manifest -- useful
+# for installing large numbers of packages at once:
+#
+#   package_manager.install <<HERE, :with => :apt
+#     # One per line
+#     apache
+#     bash
+#
+#     # Or many on the same line
+#     sysvconfig sysv-rc-conf
+#   HERE
+#
+# Commands can also accept a hash of names to paths -- necessary for installing
+# packages stored on the filesystem:
+#
+#   # Is the package called "TracTags" installed? If not, run the installer
+#   # with the "/tmp/tractags_latest" path as an argument:
+#   package.manager.install({"TracTags" => "/tmp/tractags_latest"}, :with => :egg)
+class AutomateIt::PackageManager < AutomateIt::Plugin::Manager
+  # Alias for #install
+  def add(*packages) dispatch_to(:install, *packages) end
+
+  # Alias for #uninstall
+  def remove(*packages) dispatch_to(:uninstall, *packages) end
+
+  # Are these +packages+ installed?
+  #
+  # Options:
+  # * :details -- Returns an array containing the boolean result value and an
+  #   array with a subset of installed +packages+. Boolean, defaults to false.
+  def installed?(*packages) dispatch(*packages) end
+
+  # Are these +packages+ not installed? 
+  #
+  # Options:
+  # * :details -- Returns an array containing the boolean result value and an
+  #   array with a subset of +packages+ not installed. Boolean, defaults to false.
+  def not_installed?(*packages) dispatch(*packages) end
+
+  # Install these +packages+. Returns +true+ if any packages are installed
+  # successfully; or +false+ if all packages were already installed.
+  def install(*packages) dispatch(*packages) end
+
+  # Uninstall these +packages+. Returns +true+ if any packages are uninstalled
+  # successfully; or +false+ if none of the packages are installed.
+  def uninstall(*packages) dispatch(*packages) end
+end
+
+# == PackageManager::BaseDriver
+#
+# Base class for all PackageManager drivers.
+class AutomateIt::PackageManager::BaseDriver < AutomateIt::Plugin::Driver
+  protected
+
+  # Are these +packages+ installed? Works like PackageManager#installed?
+  # but calls a block that actually checks whether the packages are
+  # installed and returns an array of packages installed.
+  #
+  # For example:
+  #   _installed_helper?("package1", "package2", :details => true) do |packages, opts|
+  #     # Dummy code which reports that these packages are installed:
+  #     ["package1]
+  #   end
+  def _installed_helper?(*packages, &block) # :yields: filtered_packages, opts
+    _raise_unless_available
+
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+    packages = packages.keys if Hash === packages
+
+    available = block.call(packages, opts)
+    truth = (packages - available).empty?
+    result = opts[:details] ? [truth, available] : truth
+    log.debug(PNOTE+"installed?(#{packages.inspect}) => #{truth}: #{available.inspect}")
+    return result
+  end
+
+  # Are these +packages+ not installed?
+  def _not_installed_helper?(*packages)
+    _raise_unless_available
+
+    # Requires that your PackageManager#installed? method is implemented.
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+    packages = packages.keys if Hash === packages
+
+    available = [installed?(packages, :details => true)].flatten
+    missing = packages - available
+    truth = (packages - missing).empty?
+    result = opts[:details] ? [truth, missing] : truth
+    log.debug(PNOTE+"not_installed?(#{packages.inspect}) => #{truth}: #{missing.inspect}")
+    return result
+  end
+
+  # Install these +packages+. Works like PackageManager#install but calls a
+  # block that's responsible for actually installing the packages and
+  # returning true if the installation succeeded. This block is only called
+  # if packages need to be installed and receives a filtered list of
+  # packages that are guaranteed not to be installed on the system already.
+  #
+  # For example:
+  #   _install_helper("package1", "package2", :quiet => true) do |packages, opts|
+  #     # Dummy code that installs packages here, e.g:
+  #     system("apt-get", "install", "-y", packages)
+  #   end
+  def _install_helper(*packages, &block) # :yields: filtered_packages, opts
+    _raise_unless_available
+
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+
+    check_packages = \
+      case packages
+      when Hash
+        packages.keys
+      else 
+        packages
+      end
+
+    missing = not_installed?(check_packages, :details => true)[1]
+    return false if missing.blank?
+
+    install_packages = \
+      case packages
+      when Hash
+        missing.map{|t| packages[t]}
+      else 
+        missing
+      end
+    block.call(install_packages, opts)
+
+    return true if preview?
+    unless (failed = not_installed?(check_packages, :details => true)[1]).empty?
+      raise ArgumentError.new("Couldn't install: #{failed.join(' ')}")
+    else
+      return true
+    end
+  end
+
+  # Uninstall these +packages+. Works like PackageManager#uninstall but calls a
+  # block that's responsible for actually uninstalling the packages and
+  # returning true if the uninstall succeeded. This block is only called
+  # if packages need to be uninstalled and receives a filtered list of
+  # packages that are guaranteed to be installed on the system.
+  #
+  # For example:
+  #   _uninstall_helper("package1", "package2", :quiet => true) do |packages, opts|
+  #     # Dummy code that removes packages here, e.g:
+  #     system("apt-get", "remove", "-y", packages)
+  #   end
+  def _uninstall_helper(*packages, &block) # :yields: filtered_packages, opts
+    _raise_unless_available
+
+    packages, opts = args_and_opts(*packages)
+    packages = _list_normalizer(packages)
+
+    check_packages = \
+      case packages
+      when Hash
+        packages.keys
+      else 
+        packages
+      end
+
+    present = installed?(check_packages, :details => true)[1]
+    return false if present.blank?
+
+    uninstall_packages = \
+      case packages
+      when Hash
+        present.map{|t| packages[t]}
+      else 
+        present
+      end
+    block.call(uninstall_packages, opts)
+
+    return true if preview?
+    unless (failed = installed?(check_packages, :details => true)[1]).empty?
+      raise ArgumentError.new("Couldn't uninstall: #{failed.join(' ')}")
+    else
+      return true
+    end
+  end
+
+  # Returns a normalized array of packages. Transforms manifest string into
+  # packages. Turns symbols into string, strips blank lines and comments.
+  def _list_normalizer(*packages)
+    packages = [packages].flatten
+    if packages.size == 1
+      packages = packages.first
+      nitpick "LN SI %s" % packages.inspect
+      nitpick "LN Sc %s" % packages.class
+      case packages
+      when Symbol
+        nitpick "LN Sy"
+        packages = [packages.to_s]
+      when String
+        nitpick "LN Ss"
+        packages = packages.scan(LIST_NORMALIZER_RE).join(" ").split
+      when Hash
+        # Don't do anything
+        nitpick "LN Sh"
+      else
+        nitpick "LN S?"
+        raise TypeError.new("Unknown input type: #{packages.class}")
+      end
+      nitpick "LN SO %s" % packages.inspect
+    end
+
+    case packages
+    when Array
+      result = packages.map(&:to_s).grep(LIST_NORMALIZER_RE)
+    when Hash
+      result = packages.stringify_keys
+    when Symbol, String
+      result = packages.to_s
+    else
+      raise TypeError.new("Unknown input type: #{packages.class}")
+    end
+
+    nitpick "LN RR %s" % result.inspect
+    return result
+  end
+
+  # Expression for matching packages in arguments
+  LIST_NORMALIZER_RE = /^\s*([^\s#]+)/
+end
+
+# Drivers
+require 'automateit/package_manager/dpkg'
+require 'automateit/package_manager/apt'
+require 'automateit/package_manager/yum'
+require 'automateit/package_manager/gem'
+require 'automateit/package_manager/egg'
+require 'automateit/package_manager/portage'
+require 'automateit/package_manager/pear'
+require 'automateit/package_manager/pecl'
+require 'automateit/package_manager/cpan'

data/lib/automateit/package_manager/gem.rb

@@ -2,10 +2,35 @@
 #
 # The Gem driver for the PackageManager provides a way to manage software
 # packages for RubyGems using the +gem+ command.
+#
+# === Specifying version of gem to use
+#
+# You can specify the command to use with each call using the gem option, e.g., the "gem1.8" below:
+#
+#   package_manager.install 'rails', :with => :gem, :gem => "gem1.8"
+#
+# Or set a default and all subsequent calls will use it:
+#
+#   package_manager[:gem].setup(:gem => "gem1.8")
+#   package_manager.install 'rails', :with => :gem
 class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
+  attr_accessor :gem
+
+  # FIXME Can't tell which gem program is used until we can use #which, need a new paradigm for #available?
   depends_on \
-    :programs => %w(gem), 
     :libraries => %w(expect pty)
+    ### :programs => %w(gem),
+
+  def setup(*args)
+    super(*args)
+
+    args, opts = args_and_opts(*args)
+    if opts[:gem]
+      @gem = opts[:gem]
+    else
+      @gem ||= %w(gem gem1.8 gem1.9).inject(nil){|s,v| s ? s : interpreter.which(v)}
+    end
+  end
 
   def suitability(method, *args) # :nodoc:
     # Never select GEM as the default driver
@@ -15,7 +40,8 @@ class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
   # See PackageManager#installed?
   def installed?(*packages)
     return _installed_helper?(*packages) do |list, opts|
-      cmd = "gem list --local 2>&1"
+      gem = opts[:gem] || self.gem
+      cmd = "#{gem} list --local 2>&1"
 
       log.debug(PEXEC+cmd)
       data = `#{cmd}`
@@ -44,6 +70,8 @@ class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
   # See PackageManager#install
   def install(*packages)
     return _install_helper(*packages) do |list, opts|
+      gem = opts[:gem] || self.gem
+
       # Why is the "gem" utility such a steaming pile of offal? Lameness include:
       # - Requires interactive input to install a package, with no way to prevent this
       # - Repeatedly updates indexes even when there's no reason to, and can't be told to stop
@@ -60,7 +88,7 @@ class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
       # gem options:
       # -y : Include dependencies,
       # -E : use /usr/bin/env for installed executables; but only with >= 0.9.4
-      cmd = "gem install -y"
+      cmd = "#{gem} install -y"
       cmd << " --no-ri" if opts[:ri] == false or opts[:docs] == false
       cmd << " --no-rdoc" if opts[:rdoc] == false or opts[:docs] == false
       cmd << " --source #{opts[:source]}" if opts[:source]
@@ -125,6 +153,8 @@ class AutomateIt::PackageManager::Gem < AutomateIt::PackageManager::BaseDriver
   # See PackageManager#uninstall
   def uninstall(*packages)
     return _uninstall_helper(*packages) do |list, opts|
+      gem = opts[:gem] || self.gem
+
       # TODO PackageManager::gem#uninstall -- add logic to handle prompts during removal
 =begin
 # idiotic program MAY prompt you like this on uninstall:
@@ -161,7 +191,7 @@ root@ubuntu:/mnt/satori/svnwork/automateit/src/examples/myapp_rails#
       for package in list
         # gem options:
         # -x : remove installed executables
-        cmd = "gem uninstall -x #{package} < /dev/null"
+        cmd = "#{gem} uninstall -x #{package} < /dev/null"
         cmd << " > /dev/null" if opts[:quiet]
         cmd << " 2>&1"
         interpreter.sh(cmd)

data/lib/automateit/root.rb

@@ -1,7 +1,7 @@
 # See AutomateIt::Interpreter for usage information.
 module AutomateIt # :nodoc:
   # AutomateIt version
-  VERSION=Gem::Version.new("0.71230")
+  VERSION=Gem::Version.new("0.80116")
 
   # Instantiates a new Interpreter. See documentation for
   # Interpreter#setup.

data/lib/inactive_support/basic_object.rb

@@ -1,5 +1,7 @@
-# Ruby 1.9 introduces BasicObject. Use Builder's BlankSlate until then.
+# Ruby 1.9 introduces BasicObject, until then use this approximation from here:
+# http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
 unless defined? BasicObject
-  require 'blankslate'
-  BasicObject = BlankSlate
+  class BasicObject
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
 end

data/misc/setup_rubygems.sh

@@ -1,21 +1,21 @@
 #!/usr/bin/env bash
 
+# SUMMARY: Installs the rubygems system for managing Ruby libraries
+
 # RELEASES: http://rubyforge.org/frs/?group_id=126
 
-PACKAGE="rubygems-0.9.3"
-URL="http://rubyforge.org/frs/download.php/20585/rubygems-0.9.3.tgz"
+URL="http://rubyforge.org/frs/download.php/29548/rubygems-1.0.1.tgz"
+PACKAGE=$(echo $URL | sed "s/\.[^\.]*$//; s/^.*\///")
 
 pushd "/tmp"
-
-CACHE=`mktemp -d install_rubygems.XXXXXXXXXX`
-pushd "$CACHE"
-
-wget -c -T20 -q "$URL"
-tar xfz "$PACKAGE.tgz"
-cd "$PACKAGE"
-sudo ruby setup.rb
-
+  CACHE=`mktemp -d install_rubygems.XXXXXXXXXX`
+  pushd "$CACHE"
+    wget -c -T20 -q "$URL"
+    tar xfz "$PACKAGE.tgz"
+    cd "$PACKAGE"
+    sudo ruby setup.rb
+  popd
 popd
-rm -rf "$CACHE"
 
-popd
+# Uninstall, only run this if there's no other version of rubygems on the system or it'll destroy those up too:
+### rm -rf /usr/bin/{gem{,1.*},update_rubygems*} /usr/local/lib/site_ruby/1.8/{{,r}ubygems.rb,rubygems} /usr/lib/ruby/gems

data/spec/integration/examples_spec.rb

@@ -17,34 +17,42 @@ else
 
     # Get the fully qualified filename for the interpreter.
     # XXX What bad things will this do if, say, running with JRuby?
-    ruby = begin
+    INTERPRETER.params[:ruby] = begin
       c = ::Config::CONFIG
       File::join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
     end
 
+    def wrap_command(cmd, &block)
+      INTERPRETER.instance_eval do
+        log.silence(Logger::WARN) do
+          output = `#{params[:ruby]} #{cmd} 2>&1`
+          begin
+            block.call
+          rescue Exception => e
+            puts "ERROR, failed while running command:\n#{cmd}\n#{output}"
+            raise e
+          end
+        end
+      end
+    end
+
     begin
       # Preview examples to cause a NotImplemented error on unsupported platforms
       AutomateIt::invoke(params[:installer], :verbosity => Logger::WARN, :preview => true, :friendly_exceptions => false)
 
       it "should install the example" do
-        INTERPRETER.instance_eval do
-          log.silence(Logger::WARN) do
-            sh("#{ruby} bin/automateit #{params[:installer]} > /dev/null 2>&1")
-            File.exists?("/etc/init.d/myapp_server").should be_true
-            File.directory?("/tmp/myapp_server").should be_true
-            service_manager.started?("myapp_server", :wait => 5).should be_true
-          end
+        wrap_command("bin/automateit #{params[:installer]}") do
+          File.exists?("/etc/init.d/myapp_server").should be_true
+          File.directory?("/tmp/myapp_server").should be_true
+          INTERPRETER.service_manager.started?("myapp_server", :wait => 5).should be_true
         end
       end
 
       it "should uninstall the example" do
-        INTERPRETER.instance_eval do
-          log.silence(Logger::WARN) do
-            sh("#{ruby} bin/automateit #{params[:uninstaller]} > /dev/null 2>&1")
-            File.exists?("/etc/init.d/myapp_server").should be_false
-            File.directory?("/tmp/myapp_server").should be_false
-            service_manager.stopped?("myapp_server", :wait => 5).should be_true
-          end
+        wrap_command("bin/automateit #{params[:uninstaller]}") do
+          File.exists?("/etc/init.d/myapp_server").should be_false
+          File.directory?("/tmp/myapp_server").should be_false
+          INTERPRETER.service_manager.stopped?("myapp_server", :wait => 5).should be_true
         end
       end
     rescue NotImplementedError => e

data/spec/unit/package_manager_spec.rb

@@ -7,6 +7,34 @@ describe AutomateIt::PackageManager::DPKG do
     @d = @m.drivers[:dpkg]
   end
 
+  it "should parse a string of package names" do
+    # Given
+    string = <<-HERE
+      foo bar # ignore
+      baz
+      # feh
+      meh quux
+      quux
+    HERE
+
+    @d.send(:_list_normalizer, string).sort.should == %w(bar baz foo meh quux)
+  end
+
+
+  it "should parse an array of package names" do
+    # Given
+    array = [
+      "foo bar # ignore",
+      "baz",
+      "# feh",
+      "meh quux",
+      "quux",
+    ]
+
+    @d.send(:_list_normalizer, array).sort.should == %w(bar baz foo meh quux)
+  end
+
+
   it "should handle hash arguments" do
     # Given
     @d.should_receive(:_raise_unless_available).any_number_of_times.and_return(true)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: automateit
 version: !ruby/object:Gem::Version 
-  version: "0.71230"
+  version: "0.80116"
 platform: ruby
 authors: 
 - Igal Koshevoy
@@ -30,7 +30,7 @@ cert_chain:
   COR01yWDcVLdM89nNLk=
   -----END CERTIFICATE-----
 
-date: 2007-12-30 00:00:00 -08:00
+date: 2008-01-17 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -168,6 +168,7 @@ files:
 - lib/automateit/tag_manager/yaml.rb
 - lib/automateit/tag_manager/tag_parser.rb
 - lib/automateit/download_manager.rb
+- lib/automateit/package_manager.rb.orig
 - lib/automateit/template_manager/base.rb
 - lib/automateit/template_manager/erb.rb
 - lib/tempster.rb