automate-it 0.9.0

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_base.rb

@@ -0,0 +1,30 @@
+# == ShellManager::WhichBase
+#
+# Provides abstract helper methods for other drivers implementing the +which+.
+class AutomateIt::ShellManager::WhichBase < AutomateIt::ShellManager::BaseDriver
+  abstract_driver
+
+  def suitability(method, *args) # :nodoc:
+    # Level must be higher than Portable
+    return available? ? 2 : 0
+  end
+
+  # See ShellManager#which!
+  def which!(command)
+    result = which(command)
+    if result.nil?
+      raise ArgumentError.new("command not found: #{command}")
+    else
+      true
+    end
+  end
+
+protected
+
+  def _which_helper(&block)
+    data = block.call
+    data.strip! if data
+    return (! data.blank? && File.exists?(data)) ? data : nil
+  end
+
+end

data/lib/automateit/shell_manager/which_unix.rb

@@ -0,0 +1,16 @@
+# == ShellManager::WhichUnix
+#
+# A ShellManager driver providing access to the +which+ command found on
+# Unix-like systems.
+class AutomateIt::ShellManager::WhichUnix < AutomateIt::ShellManager::WhichBase
+  depends_on :programs => %w(which)
+
+  # Inherits WhichBase#suitability
+
+  # See ShellManager#which
+  def which(command)
+    _which_helper do
+      `which #{command} 2>&1`
+    end
+  end
+end

data/lib/automateit/shell_manager/which_windows.rb

@@ -0,0 +1,20 @@
+# == ShellManager::WhichWindows
+#
+# A ShellManager driver providing access to +which+ command by faking it on
+# Windows systems.
+class ::AutomateIt::ShellManager::WhichWindows < ::AutomateIt::ShellManager::WhichBase
+  WHICH_HELPER = File.join(::AutomateIt::Constants::HELPERS_DIR, "which.cmd")
+
+  # FIXME how to detect windows through Java?
+  depends_on :callbacks => lambda { RUBY_PLATFORM =~ /mswin/i }
+
+  # Inherits WhichBase#suitability
+
+  # See ShellManager#which
+  def which(command)
+    _which_helper do
+      data = `#{WHICH_HELPER} #{command} 2>&1`
+    end
+  end
+end
+

data/lib/automateit/tag_manager.rb

@@ -0,0 +1,127 @@
+# == 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.
+#
+# === Basics
+#
+# The tags are typically stored in a Project's <tt>config/tags.yml</tt> file.
+#
+# For example, consider this <tt>config/tags.yml</tt> file:
+#   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
+#
+# === Traits
+#
+# Your system may also automatically add tags that describe your system's
+# traits, such as the name of the operating system, distribution release,
+# hardware architecture, hostnames, IP addresses, etc.
+#
+# For example, here is a full set of tags for a system:
+#
+#  ai> pp tags.sort                # Pretty print the tags in sorted order
+#  ["10.0.0.6",                    # IPv4 addresses
+#   "127.0.0.1",                   # ...
+#   "192.168.130.1",               # ...
+#   "::1/128",                     # IPv6 addresses
+#   "fe80::250:56ff:fec0:8/64",    # ...
+#   "fe80::250:8dff:fe95:8fe9/64", # ...
+#   "i686",                        # Hardware architecture
+#   "linux",                       # OS
+#   "linux_i686",                  # OS and architecture
+#   "localhost",                   # Variants of hostname
+#   "localhost.localdomain",       # ...
+#   "michiru",                     # ...
+#   "michiru.koshevoy",            # ...
+#   "michiru.koshevoy.net",        # ...
+#   "myapp_servers",               # User defined tags
+#   "rails_servers",               # ...
+#   "ubuntu",                      # OS distribution name
+#   "ubuntu_6.06"]                 # OS distribution name and release version
+#
+# To execute code only on an Ubuntu system:
+#
+#   if tagged?("ubuntu")
+#     # Code will only be run on Ubuntu systems
+#   end
+#
+# These additional tags are retrieved from the PlatformManager and
+# AddressManager. If your platform does not provide drivers for these, you will
+# not get these tags. If you're on an unsupported platform and do not want to
+# write drivers, you can work around this by manually declaring the missing
+# tags in <tt>config/tags.yml</tt> on a host-by-host basis.
+#
+# === Inclusion and negation
+#
+# You can include and negate tags declaratively by giving "@" and "!" prefixes
+# to arguments.
+#
+# For example, consider this <tt>config/tags.yml</tt> file:
+#
+#   apache_servers:
+#     - kurou
+#     - shirou
+#   apache_servers_except_kurou:
+#     - @apache_servers
+#     - !kurou
+#
+# This will produce the following results:
+#
+#   ai> hosts_tagged_with("apache_servers")
+#   => ["kurou", "shirou"]
+#   ai> hosts_tagged_with("apache_servers_except_kurou")
+#   => ["shirou"]
+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,121 @@
+# == 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)
+    @struct ||= {}
+    @tags   ||= Set.new
+    @struct_updated = false
+    @our_hostname_tags ||= Set.new
+    @our_platform_tags ||= Set.new
+
+    if opts[:struct]
+      @struct_updated = true
+      @struct.merge!(AutomateIt::TagManager::TagParser.expand(opts[:struct]))
+    end
+  end
+
+  # Return tags, populate them if necessary.
+  def tags
+    if @our_hostname_tags.empty?
+      @struct_updated = true
+
+      begin
+        @our_hostname_tags.merge(interpreter.address_manager.hostnames) # SLOW 0.4s
+        @our_hostname_tags.merge(interpreter.address_manager.addresses)
+      rescue NotImplementedError => e
+        log.debug("Can't find AddressManager for this platform: #{e}")
+      end
+
+      @tags.merge(@our_hostname_tags)
+    end
+
+    if @our_platform_tags.empty?
+      @struct_updated = true
+
+      begin
+        @our_platform_tags = interpreter.platform_manager.tags
+        @tags.merge(@our_platform_tags)
+      rescue NotImplementedError => e
+        log.debug("Can't find PlatformManager for this platform: #{e}")
+      end
+    end
+
+    if @struct_updated
+      @tags.merge(tags_for(@our_hostname_tags))
+      @struct_updated = false
+    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
+
+  TAG_NEGATION = %r{!?}
+  TAG_WORD = %r{[\w\.\-]+}
+  TAG_TOKENIZER = %r{\!|\(|\)|\&{1,2}|\|{1,2}|#{TAG_NEGATION}#{TAG_WORD}}
+
+  # See TagManager#tagged?
+  def tagged?(query, hostname=nil)
+    query = query.to_s
+    selected_tags = hostname ? tags_for(hostname) : tags
+    # XXX Tokenizer discards unknown characters, which may hide errors in the query
+    tokens = query.scan(TAG_TOKENIZER)
+    if tokens.size > 1
+      booleans = tokens.map do |token|
+        if matches = token.match(/^(#{TAG_NEGATION})(#{TAG_WORD})$/)
+          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
+    result = @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
+    return result.to_a.sort
+  end
+end

data/lib/automateit/tag_manager/tag_parser.rb

@@ -0,0 +1,93 @@
+# == TagManager::TagParser
+#
+# Helper class for parsing tags. Not useful for users -- for internal use only.
+class AutomateIt::TagManager::TagParser
+  include Nitpick
+
+  attr_accessor :struct
+
+  # Create a parser for the +struct+, a hash of tag keys to values with arrays of items.
+  def initialize(struct)
+    self.struct = struct
+    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
+
+  HOSTS_FOR_VALUE = /(.+?)/
+  HOSTS_FOR_INCLUDE_TAG_RE = /^INCLUDE_TAG #{HOSTS_FOR_VALUE}$/
+  HOSTS_FOR_EXCLUDE_TAG_RE = /^EXCLUDE_TAG #{HOSTS_FOR_VALUE}$/
+  HOSTS_FOR_EXCLUDE_HOST_RE = /^EXCLUDE_HOST #{HOSTS_FOR_VALUE}$/
+
+  # Return array of hosts for the +tag+.
+  def hosts_for(tag)
+    raise IndexError.new("Unknown tag - #{tag}") unless struct.has_key?(tag)
+    return [] if struct[tag].nil? # Tag has no leaves
+
+    nitpick "\nAA %s" % tag
+    hosts = Set.new
+    for item in struct[tag]
+      case item
+      when HOSTS_FOR_INCLUDE_TAG_RE
+        nitpick "+g %s" % $1
+        hosts.merge(hosts_for($1))
+      when HOSTS_FOR_EXCLUDE_TAG_RE
+        nitpick "-g %s" % $1
+        hosts.subtract(hosts_for($1))
+      when HOSTS_FOR_EXCLUDE_HOST_RE
+        nitpick "-h %s" % $1
+        hosts.delete($1)
+      else
+        nitpick "+h %s" % item
+        hosts << item
+      end
+    end
+    result = hosts.to_a
+    nitpick "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)
+    self.new(struct).expand
+  end
+end