automateit 0.70923

data/lib/automateit/shell_manager/symlink.rb

@@ -0,0 +1,32 @@
+# == ShellManager::Symlink
+#
+# A ShellManager driver providing access to the symbolic link +ln_s+ command
+# found on Unix-like systems.
+class AutomateIt::ShellManager::Symlink < AutomateIt::ShellManager::BaseLink
+  depends_on \
+    :libraries => %w(pathname),
+    :callbacks => [lambda{
+      # JRuby can make symlinks but can't read them.
+      RUBY_PLATFORM !~ /java|mswin/i and File.respond_to?(:symlink)
+    }]
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Portable
+    return available? ? 2 : 0
+  end
+
+  # See ShellManager#provides_symlink?
+  def provides_symlink?
+    available? ? true : false
+  end
+
+  # See ShellManager#ln_s
+  def ln_s(sources, target, opts={})
+    _ln(sources, target, {:symbolic => true}.merge(opts))
+  end
+
+  # See ShellManager#ln_sf
+  def ln_sf(sources, target, opts={})
+    _ln(sources, target, {:symbolic => true, :force => true}.merge(opts))
+  end
+end

data/lib/automateit/shell_manager/which.rb

@@ -0,0 +1,25 @@
+# == ShellManager::Which
+#
+# A ShellManager driver providing access to the +which+ command found on
+# Unix-like systems.
+class AutomateIt::ShellManager::Which < AutomateIt::ShellManager::BaseDriver
+  depends_on :programs => %w(which)
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Portable
+    return available? ? 2 : 0
+  end
+
+  # See ShellManager#which
+  def which(command)
+    data = `which "#{command}" 2>&1`.chomp
+    return (! data.blank? && File.exists?(data)) ? data : nil
+  end
+
+  # See ShellManager#which!
+  def which!(command)
+    if which(command).nil?
+      raise ArgumentError.new("command not found: #{command}")
+    end
+  end
+end

data/lib/automateit/tag_manager.rb

@@ -0,0 +1,63 @@
+# == TagManager
+#
+# The TagManager provides a way of querying tags. Tags are keywords
+# associated with a specific hostname or group. These are useful for grouping
+# together hosts and defining common behavior for them. The tags are
+# typically stored in a Project's <tt>config/tags.yml</tt> file.
+#
+# For example, consider a <tt>tags.yml</tt> file that contains YAML like:
+#   desktops:
+#     - satori
+#     - sunyata
+#     - michiru
+#   notebooks:
+#     - rheya
+#     - avijja
+#
+# With the above file, if we're on the host called "satori", we can query the
+# fields like this:
+#   tags # => ["satori", "desktops", "localhost", ...]
+#
+#   tagged?("desktops") # => true
+#   tagged?("notebooks") # => false
+#   tagged?(:satori) # => true
+#   tagged?("satori") # => true
+#   tagged?("satori || desktops") # => true
+#   tagged?("(satori || desktops) && !notebooks") # => true
+class AutomateIt::TagManager < AutomateIt::Plugin::Manager
+  alias_methods :hosts_tagged_with, :tags, :tagged?, :tags_for
+
+  # Return a list of hosts that match the query. See #tagged? for information
+  # on query syntax.
+  def hosts_tagged_with(query) dispatch(query) end
+
+  # Return a list of tags for this host.
+  def tags() dispatch() end
+
+  # Is this host tagged with the +query+?
+  #
+  # Examples:
+  #   tags # => ["localhost", "foo", "bar", ...]
+  #
+  #   tagged?(:localhost) # => true
+  #   tagged?("localhost") # => true
+  #   tagged?("localhost && foo") # => true
+  #   tagged?("localhost || foo") # => true
+  #   tagged?("!foo") # => false
+  #   tagged?("(localhost || foo) && bar") # => true
+  def tagged?(query, hostname=nil) dispatch(query, hostname) end
+
+  # Return a list of tags for the host.
+  def tags_for(hostname) dispatch(hostname) end
+end
+
+# == TagManager::BaseDriver
+#
+# Base class for all TagManager drivers.
+class AutomateIt::TagManager::BaseDriver < AutomateIt::Plugin::Driver
+end
+
+# Drivers
+require 'automateit/tag_manager/tag_parser'
+require 'automateit/tag_manager/struct'
+require 'automateit/tag_manager/yaml'

data/lib/automateit/tag_manager/struct.rb

@@ -0,0 +1,101 @@
+# == TagManager::Struct
+#
+# A TagManager driver for querying a data structure. It's not useful on its
+# own, but can be subclassed by other drivers that actually load tags.
+class AutomateIt::TagManager::Struct < AutomateIt::TagManager::BaseDriver
+  depends_on :nothing
+
+  def suitability(method, *args) # :nodoc:
+    return 1
+  end
+
+  # Options:
+  # * :struct -- Hash to use for queries.
+  def setup(opts={})
+    super(opts)
+
+    if opts[:struct]
+      @struct = AutomateIt::TagManager::TagParser.expand(opts[:struct])
+      @tags   = Set.new
+    else
+      @struct ||= {}
+      @tags   ||= Set.new
+    end
+  end
+
+  # Return tags, populate them if necessary.
+  def tags
+    if @tags.empty?
+      begin
+        hostnames = interpreter.address_manager.hostnames # SLOW 0.4s
+        @tags.merge(hostnames)
+        @tags.merge(tags_for(hostnames))
+        @tags.merge(interpreter.address_manager.addresses)
+      rescue NotImplementedError => e
+        log.debug("Can't find AddressManager for this platform: #{e}")
+      end
+
+      begin
+        @tags.merge(interpreter.platform_manager.tags)
+      rescue NotImplementedError => e
+        log.debug("Can't find PlatformManager for this platform: #{e}")
+      end
+    end
+    @tags
+  end
+
+  # See TagManager#hosts_tagged_with
+  def hosts_tagged_with(query)
+    hosts = @struct.values.flatten.uniq
+    return hosts.select{|hostname| tagged?(query, hostname)}
+  end
+
+  # See TagManager#tagged?
+  def tagged?(query, hostname=nil)
+    query = query.to_s
+    selected_tags = hostname ? tags_for(hostname) : tags
+    # XXX This tokenization process discards unknown characters, which may hide errors in the query
+    tokens = query.scan(%r{\!|\(|\)|\&+|\|+|!?[\.\w]+})
+    if tokens.size > 1
+      booleans = tokens.map do |token|
+        if matches = token.match(/^(!?)([\.\w]+)$/)
+          selected_tags.include?(matches[2]) && matches[1].empty?
+        else
+          token
+        end
+      end
+      code = booleans.join(" ")
+
+      begin
+        return eval(code) # XXX What could possibly go wrong?
+      rescue Exception => e
+        raise ArgumentError.new("Invalid query -- #{query}")
+      end
+    else
+      return selected_tags.include?(query)
+    end
+  end
+
+  # See TagManager#tags_for
+  def tags_for(hostnames)
+    hostnames = \
+      case hostnames
+      when String
+        interpreter.address_manager.hostnames_for(hostnames)
+      when Array, Set
+        hostnames.inject(Set.new) do |sum, hostname|
+          sum.merge(interpreter.address_manager.hostnames_for(hostname)); sum
+        end
+      else
+        raise TypeError.new("invalid hostnames argument type: #{hostnames.class}")
+      end
+    return @struct.inject(Set.new) do |sum, role_and_members|
+      role, members = role_and_members
+      members_aliases = members.inject(Set.new) do |aliases, member|
+        aliases.merge(interpreter.address_manager.hostnames_for(member)); aliases
+      end.to_a
+      sum.add(role) unless (hostnames & members_aliases).empty?
+      sum
+    end
+  end
+end

data/lib/automateit/tag_manager/tag_parser.rb

@@ -0,0 +1,91 @@
+# == TagManager::TagParser
+#
+# Helper class for parsing tags. Not useful for users -- for internal use only.
+class AutomateIt::TagManager::TagParser
+  attr_accessor :struct
+  attr_accessor :is_trace
+
+  # Create a parser for the +struct+, a hash of tag keys to values with arrays of items.
+  def initialize(struct, is_trace=false)
+    self.struct = struct
+    self.is_trace = is_trace
+    normalize!
+  end
+
+  # Normalize a block of text to replace shortcut symbols that cause YAML to choke.
+  def self.normalize(text)
+    return text \
+      .gsub(/^(\s*-\s+)(!@)/, '\1EXCLUDE_TAG ') \
+      .gsub(/^(\s*-\s+)(!)/, '\1EXCLUDE_HOST ') \
+      .gsub(/^(\s*-\s+)(@)/, '\1INCLUDE_TAG ')
+  end
+
+  # Normalize the contents of the internal struct.
+  def normalize!
+    for tag, items in struct
+      next unless items
+      for item in items
+        next unless item
+        item.gsub!(/^(\!@|\^@)\s*/, 'EXCLUDE_TAG ')
+        item.gsub!(/^(\!|\^)\s*/, 'EXCLUDE_HOST ')
+        item.gsub!(/^(@)\s*/, 'INCLUDE_TAG ')
+      end
+    end
+  end
+
+  # Display debugging information if +is_trace+ is enabled.
+  def trace(msg)
+    puts msg if is_trace
+  end
+
+  # Return array of hosts for the +tag+.
+  def hosts_for(tag)
+    raise IndexError.new("Unknown tag - #{tag}") unless struct[tag]
+    trace "\nAA %s" % tag
+    hosts = Set.new
+    for item in struct[tag]
+      case item
+      when /^INCLUDE_TAG (\w+)$/
+        trace "+g %s" % $1
+        hosts.merge(hosts_for($1))
+      when /^EXCLUDE_TAG (\w+)$/
+        trace "-g %s" % $1
+        hosts.subtract(hosts_for($1))
+      when /^EXCLUDE_HOST (\w+)$/
+        trace "-h %s" % $1
+        hosts.delete($1)
+      else
+        trace "+h %s" % item
+        hosts << item
+      end
+    end
+    result = hosts.to_a
+    trace "ZZ %s for %s" % [result.inspect, tag]
+    return result
+  end
+
+  # Return array of tags.
+  def tags
+    return struct.keys
+  end
+
+  # Expand the include/exclude/group rules and return a struct with only the
+  # hosts these rules produce.
+  def expand
+    result = {}
+    for tag in tags
+      result[tag] = hosts_for(tag)
+    end
+    result
+  end
+
+  # Replace the internal struct with an expanded version, see #expand.
+  def expand!
+    struct.replace(expand)
+  end
+
+  # Expand the +struct+.
+  def self.expand(struct, is_trace=false)
+    self.new(struct, is_trace).expand
+  end
+end

data/lib/automateit/tag_manager/yaml.rb

@@ -0,0 +1,29 @@
+# == TagManager::YAML
+#
+# A TagManager driver that reads tags from a YAML file.
+class AutomateIt::TagManager::YAML < AutomateIt::TagManager::Struct
+  depends_on :nothing
+
+  def suitability(method, *args) # :nodoc:
+    return 5
+  end
+
+  # Options:
+  # * :file -- File to read tags from. The file is preprocessed with ERB and
+  #   must produce YAML content.
+  def setup(opts={})
+    if filename = opts.delete(:file)
+      contents = _read(filename)
+      output = HelpfulERB.new(contents, filename).result
+
+      text = AutomateIt::TagManager::TagParser.normalize(output)
+      opts[:struct] = ::YAML::load(text)
+    end
+    super(opts)
+  end
+
+  def _read(filename)
+    return File.read(filename)
+  end
+  private :_read
+end

data/lib/automateit/template_manager.rb

@@ -0,0 +1,55 @@
+# == TemplateManager
+#
+# TemplateManager renders templates to files.
+#
+# See the #render method for details.
+class AutomateIt::TemplateManager < AutomateIt::Plugin::Manager
+  alias_methods :render
+
+  # Render a template.
+  #
+  # You may specify the +source+ and +target+ as arguments or options. For
+  # example, <tt>render(:file => "input", :to => "output")</tt> is the same as
+  # <tt>render("input", "output")</tt>.
+  #
+  # Options:
+  # * :file -- Read the template from this file.
+  # * :text -- Read the template from this string.
+  # * :to -- Render to a file, otherwise returns the rendered string.
+  # * :locals -- Hash of variables passed to template as local variables.
+  # * :dependencies -- When checking timestamps, include this Array of
+  #   filenames when checking timestamps.
+  # * :force -- Boolean to force rendering without checking timestamps.
+  # * :check -- Determines when to render, otherwise uses value of
+  #   +default_check+, possible values:
+  #   * :compare -- Only render if rendered template is different than the
+  #     target's contents or if the target doesn't exist.
+  #   * :timestamp -- Only render if the target is older than the template and
+  #     dependencies.
+  #   * :exists -- Only render if the target doesn't exist.
+  #
+  # For example, if the file +my_template_file+ contains:
+  #
+  #   Hello <%=entity%>!
+  #
+  # You could then execute:
+  #
+  #   render("my_template_file", "/tmp/out", :check => :compare,
+  #          :locals => {:entity => "world"})
+  #
+  # And this will create a <tt>/tmp/out</tt> file with:
+  #
+  #   Hello world!
+  def render(*options) dispatch(*options) end
+
+  # Get name of default algorithm for performing checks.
+  def default_check() dispatch() end
+
+  # Set name of default algorithms to perform checks, e.g., :compare. See the
+  # #render :check option for list of check algorithms.
+  def default_check=(value) dispatch(value) end
+end # class TemplateManager
+
+# Drivers
+require 'automateit/template_manager/base.rb'
+require 'automateit/template_manager/erb.rb'

data/lib/automateit/template_manager/base.rb

@@ -0,0 +1,172 @@
+# == TemplateManager::BaseDriver
+#
+# Base class for all TemplateManager drivers.
+class AutomateIt::TemplateManager::BaseDriver < AutomateIt::Plugin::Driver
+  # Name of default algorithm for performing checks, e.g., :compare
+  attr_accessor :default_check
+
+  # Options:
+  # * :default_check - Set the #default_check, e.g., :compare
+  def setup(opts={})
+    super(opts)
+    if opts[:default_check]
+      @default_check = opts[:default_check]
+    else
+      @default_check ||= :compare
+    end
+  end
+
+  # Return Array of +dependencies+ newer than +filename+. Will be empty if
+  # +filename+ is newer than all of the +dependencies+.
+  def _newer(filename, *dependencies)
+    updated = []
+    timestamp = _mtime(filename)
+    for dependency in dependencies
+      updated << dependency if _mtime(dependency) > timestamp
+    end
+    return updated
+  end
+  protected :_newer
+
+  # Does +filename+ exist?
+  def _exists?(filename)
+    return File.exists?(filename)
+  end
+  protected :_exists?
+
+  # Return the contents of +filename+.
+  def _read(filename)
+    begin
+      result = File.read(filename)
+      return result
+    rescue Errno::ENOENT => e
+      if writing?
+        raise e
+      else
+        return ""
+      end
+    end
+  end
+  protected :_read
+
+  # Write +contents+ to +filename+.
+  def _write(filename, contents)
+    File.open(filename, "w+"){|writer| writer.write(contents)} if writing?
+    return true
+  end
+  protected :_write
+
+  # Return the modification date for +filename+.
+  def _mtime(filename)
+    return _exists? ? File.mtime(filename) : nil
+  end
+  protected :_mtime
+
+  # Render a template specified in the block. It takes the same arguments and
+  # returns the same results as the #render call.
+  #
+  # This method is used by the #render methods for different template drivers
+  # and provides all the logic for parsing arguments, figuring out if a
+  # template should be rendered, what to do with the rendering, etc.
+  #
+  # This method calls the supplied +block+ with a hash containing:
+  # * :text -- Template's text.
+  # * :filename -- Template's filename, or nil if none. The template
+  # * :binder -- Binding containing the locals as variables.
+  # * :locals -- Hash of locals.
+  # * :opts -- Hash of options passed to the #_render_helper.
+  #
+  # The supplied block must return the text of the rendered template.
+  #
+  # See the TemplateManager::ERB#render method for a usage example.
+  def _render_helper(*options, &block) # :yields: block_opts
+    args, opts = args_and_opts(*options)
+    source_filename = args[0] || opts[:file]
+    target_filename = args[1] || opts[:to]
+    source_text = opts[:text]
+
+    raise ArgumentError.new("No source specified with :file or :text") if not source_filename and not source_text
+    raise Errno::ENOENT.new(source_filename) if writing? and source_filename and not _exists?(source_filename)
+    raise ArgumentError.new("No target specified with :to") if not target_filename
+
+    begin
+      # source_filename, target_filename, opts={}
+      opts[:check] ||= @default_check
+      target_exists = _exists?(target_filename)
+      updates = []
+
+      unless opts[:force]
+        case opts[:check]
+        when :exists
+          if target_exists
+            log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because it already exists")
+            return false
+          else
+            log.info(PNOTE+"Rendering '#{target_filename}' because of it doesn't exist")
+          end
+        when :timestamp
+          if target_exists
+            updates = _newer(target_filename, \
+                *[source_filename, opts[:dependencies]].reject{|t| t.nil?}.flatten)
+            if updates.empty?
+              log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because dependencies haven't been updated")
+              return false
+            end
+          end
+        end
+      end
+
+      target_contents = target_exists ? _read(target_filename) : ""
+      source_text ||= _read(source_filename)
+
+      if source_text.blank? and preview?
+        return true
+      end
+
+      binder = nil
+      if opts[:locals]
+        # Create a binding that the template can get variables from without
+        # polluting the Driver's namespace.
+        callback = lambda{
+          code = ""
+          for key in opts[:locals].keys
+            code << "#{key} = opts[:locals][:#{key}]\n"
+          end
+          eval code
+          binding
+        }
+        binder = callback.call
+      end
+
+      block_opts = {
+        :binder => binder,
+        :filename => source_filename,
+        :text => source_text,
+        :locals => opts[:locals],
+        :opts => opts,
+      }
+      output = block.call(block_opts)
+
+      case opts[:check]
+      when :compare
+        if not target_exists
+          log.info(PNOTE+"Rendering '#{target_filename}' because of it doesn't exist")
+        elsif output == target_contents
+          log.debug(PNOTE+"Rendering for '#{target_filename}' skipped because contents are the same")
+          return false
+        else
+          log.info(PNOTE+"Rendering '#{target_filename} because its contents changed")
+        end
+      when :timestamp
+        log.info(PNOTE+"Rendering '#{target_filename}' because of updated: #{updates.join(' ')}")
+      end
+      result = _write(target_filename, output)
+      return result
+    ensure
+      if opts[:mode] or opts[:user] or opts[:group]
+        interpreter.chperm(target_filename, :mode => opts[:mode], :user => opts[:user], :group => opts[:group])
+      end
+    end
+  end
+  protected :_render_helper
+end