automateit 0.70923

data/lib/automateit/address_manager.rb

@@ -0,0 +1,165 @@
+# == AddressManager
+#
+# The AddressManager provides a way to query, add and remove network
+# addresses on a host.
+class AutomateIt::AddressManager < AutomateIt::Plugin::Manager
+  # Does host have an address or interface? Arguments hash must include
+  # either a :device (e.g., "eth0") or :address (e.g., "10.0.0.10"), and an
+  # optional :label (e.g., "foo"). Note that an interface is the combination
+  # of a :device and :label, so "eth0" isn't the same as "eth0:foo".
+  #
+  # Examples on a host with address "10.0.0.10" on interface "eth0:foo":
+  #   has?(:address => "10.0.0.10")
+  #   => true
+  #   has?(:address => "10.0.0.10", :device => "eth0")
+  #   => false
+  #   has?(:address => "10.0.0.10", :device => "eth0", :label => "foo")
+  #   => true
+  #   has?(:device => "eth0")
+  #   => false
+  #   has?(:device => "eth0", :label => "foo")
+  #   => true
+  def has?(opts) dispatch(opts) end
+
+  # Add address to host if it doesn't have it. Requires root-level access.
+  # Returns +true+ if action was taken and succeeded.
+  #
+  # Arguments hash must include either a :device (e.g., "eth0") or :address
+  # (e.g., "10.0.0.10"), and an optional :label (e.g., "foo") and :mask (e.g.
+  # "24").
+  #
+  # An optional number of ARP :announcements may be specified, defaulting to
+  # AutomateIt::AddressManager::DEFAULT_ANNOUNCEMENTS. Drivers that handle
+  # announcements will block an extra second while making each announcement.
+  #
+  # Example:
+  #   add(:address => "10.0.0.10", :mask => 24, :device => "eth0",
+  #     :label => "foo", :announcements => 3)
+  def add(opts) dispatch(opts) end
+
+  # Number of ARP announcements to make by default during #add.
+  DEFAULT_ANNOUNCEMENTS = 3
+
+  # Remove address from host if it has it. Requires root-level access.
+  # Returns +true+ if action was taken and succeeded.
+  #
+  # Arguments hash must include either a :device (e.g., "eth0") or :address
+  # (e.g., "10.0.0.10"), and an optional :label (e.g., "foo") and :mask (e.g.
+  # "24").
+  #
+  # Example:
+  #   remove(:address => "10.0.0.10", :mask => 24, :device => "eth0",
+  #     :label => "foo")
+  def remove(opts) dispatch(opts) end
+
+  # Array of addresses for this host. Example:
+  #   addresses
+  #   => ["10.0.0.10", "127.0.0.1"]
+  def addresses() dispatch() end
+
+  # Array of interfaces for this host. Example:
+  #   interfaces
+  #   => ["eth0", "lo"]
+  def interfaces() dispatch() end
+
+  # Array of hostnames for this host, including variants by trying to resolve
+  # names for all addresses owned by this host. Example:
+  #   hostnames
+  #   => ["kagami", "kagami.lucky-channel", "kagami.lucky-channel.jp"]
+  def hostnames() dispatch() end
+
+  # Array of hostname variants for this +hostname+. This method performs no
+  # name resolution and simply infers a less qualified name from a more
+  # qualified hostname argument. Example:
+  #   hostnames_for("kagami.lucky-channel")
+  #   => ["kagami", "kagami.lucky-channel"]
+  #   hostnames_for("kagami")
+  #   => ["kagami"]
+  def hostnames_for(hostname) dispatch(hostname) end
+
+  # Convert a mask to a CIDR.
+  #
+  # Example:
+  #  mask_to_cidr("255.255.255.0") # => 24
+  def mask_to_cidr(mask) dispatch(mask) end
+
+  # Convert CIDR to mask.
+  #
+  # Example:
+  #  cidr_to_mask(24) # => "255.255.255.0"
+  def cidr_to_mask(cidr) dispatch(cidr) end
+
+  # Convert a decimal number to binary notation.
+  #
+  # Example:
+  #  dec2bin(255) # => "11111111"
+  def dec2bin(n) dispatch(n) end
+
+  # Convert a binary number to decimal.
+  #
+  # Example:
+  #  bin2dec("11111111") # => 255
+  def bin2dec(s) dispatch(s) end
+end
+
+# == AddressManager::BaseDriver
+#
+# Base class for all AddressManager drivers.
+class AutomateIt::AddressManager::BaseDriver< AutomateIt::Plugin::Driver
+  # See AddressManager#hostnames
+  def hostnames()
+    # NOTE: depends on driver's implementation of addresses
+    names = addresses.inject(Set.new) do |sum, address|
+      # Some addresses can't be resolved, bummer.
+      sum.merge(Resolv.getnames(address)) rescue Resolv::ResolvError; sum
+    end
+    names << Socket.gethostname
+    names.merge(Socket.gethostbyname(Socket.gethostname)[1]) rescue SocketError
+
+    names.each{|name| names.merge(hostnames_for(name))}
+    names << "localhost"
+    return names.to_a.sort
+  end
+
+  # See AddressManager#hostname_for
+  def hostnames_for(hostname)
+    results = []
+    elements = hostname.split(".")
+    for i in 1..elements.size
+      results << elements[0..i-1].join(".")
+    end
+    return results.to_a.sort
+  end
+
+  # See AddressManager#mask_to_cidr
+  def mask_to_cidr(mask)
+    # TODO Find less horrible solution which can handle IPv6.
+    result = ''
+    for chunk in mask.split(".")
+      result += dec2bin(chunk.to_i)
+    end
+    return result.scan(/1/).size
+  end
+
+  # See AddressManager#cidr_to_mask
+  def cidr_to_mask(cidr)
+    # TODO Find less horrible solution which can handle IPv6.
+    require 'ipaddr'
+    IPAddr.new("0.0.0.0/#{cidr}").inspect.match(%r{/([\d\.]+)>})[1]
+  end
+
+  # See AddressManager#dec2bin
+  def dec2bin(n)
+    # dec2bin(255)
+    return "%b" % n
+  end
+
+  # See AddressManager#bin2dec
+  def bin2dec(s)
+    return s.to_i(2)
+  end
+end
+
+# Drivers
+require 'automateit/address_manager/portable'
+require 'automateit/address_manager/linux'

data/lib/automateit/address_manager/linux.rb

@@ -0,0 +1,80 @@
+# == AddressManager::Linux
+#
+# A Linux-specific driver for the AddressManager provides complete support for
+# querying, adding and removing addresses on platforms that feature Linux-like
+# tools.
+class AutomateIt::AddressManager::Linux < AutomateIt::AddressManager::BaseDriver
+  depends_on :programs => "ifconfig", 
+    :callbacks => lambda{`ifconfig --version 2>&1`.match(/net-tools/)}
+
+  def suitability(method, *args) # :nodoc:
+    available? ? 2 : 0
+  end
+
+  # See AddressManager#has?
+  def has?(opts)
+    raise ArgumentError.new(":device or :address must be specified") unless opts[:device] or opts[:address]
+    result = true
+    result &= interfaces.include?(opts[:device]) if opts[:device] and not opts[:label]
+    result &= interfaces.include?(opts[:device]+":"+opts[:label]) if opts[:device] and opts[:label]
+    result &= addresses.include?(opts[:address]) if opts[:address]
+    return result
+  end
+
+  # See AddressManager#add
+  def add(opts)
+    announcements = opts[:announcements].to_i || AutomateIt::AddressManager::DEFAULT_ANNOUNCEMENTS
+    raise SecurityError.new("you must be root") unless superuser?
+    raise ArgumentError.new(":device and :address must be specified") unless opts[:device] and opts[:address]
+    return false if has?(opts)
+    interpreter.sh(_add_or_remove_command(:add, opts))
+    if interpreter.which("arping")
+      interpreter.sh("arping -q -c #{announcements} -w #{announcements} -I #{opts[:device]} #{opts[:address]}")
+    end
+    return true
+  end
+
+  # See AddressManager#remove
+  def remove(opts)
+    return false unless has?(opts)
+    raise SecurityError.new("you must be root") unless superuser?
+    raise ArgumentError.new(":device and :address must be specified") unless opts[:device] and opts[:address]
+    return interpreter.sh(_add_or_remove_command(:remove, opts))
+  end
+
+  def _add_or_remove_command(action, opts)
+    _raise_unless_available
+    action = :del if action.to_sym == :remove
+
+    # Accept common alternative names
+    opts[:mask] ||= opts[:netmask] if opts[:netmask]
+    opts[:alias] ||= opts[:alias] if opts[:alias]
+    opts[:device] ||= opts[:interface] if opts[:interface]
+
+    if opts[:mask] and not opts[:mask].match(/\./)
+      opts[:mask] = cidr_to_mask(opts[:mask])
+    end
+
+    ipcmd = "ifconfig"
+    ipcmd << " %s" % opts[:device] if opts[:device] and not opts[:label]
+    ipcmd << " %s:%s" % [opts[:device], opts[:label]] if opts[:device] and opts[:label]
+    ipcmd << " %s" % opts[:address]
+    ipcmd << " netmask %s" % opts[:mask] if opts[:mask]
+    ipcmd << " up" if action == :add
+    ipcmd << " down" if action == :del
+    return ipcmd
+  end
+  private :_add_or_remove_command
+
+  # See AddressManager#interfaces
+  def interfaces()
+    _raise_unless_available
+    return `ifconfig`.scan(/^(\w+?(?::\w+)?)\b\s+Link/).flatten
+  end
+
+  # See AddressManager#addresses
+  def addresses()
+    _raise_unless_available
+    return `ifconfig`.scan(/inet6? addr:\s*(.+?)\s+/).flatten
+  end
+end

data/lib/automateit/address_manager/portable.rb

@@ -0,0 +1,37 @@
+# == AddressManager::Portable
+#
+# A pure-Ruby, portable driver for the AddressManager which provides
+# minimal support for querying the hostname using sockets. Although it
+# lacks advanced features found in other drivers, it will work on all
+# platforms.
+class AutomateIt::AddressManager::Portable < AutomateIt::AddressManager::BaseDriver
+  def suitability(method, *args) # :nodoc:
+    return 1
+  end
+
+  # See AddressManager#has?
+  def has?(opts)
+    raise NotImplementedError.new("this driver doesn't support queries for devices or labels") if opts[:device] or opts[:label]
+    result = true
+    result &= addresses.include?(opts[:address]) if opts[:address]
+    return result
+  end
+
+  # See AddressManager#hostnames
+  def hostnames
+    results = Set.new
+    results << Socket.gethostname
+    results.merge(Socket.gethostbyname(Socket.gethostname)[1]) rescue SocketError
+
+    results.each{|name| results.merge(hostnames_for(name))}
+    results << "localhost"
+    return results.to_a.sort
+  end
+
+  # See AddressManager#addresses
+  def addresses
+    results = Set.new("127.0.0.1")
+    results.merge(TCPSocket.gethostbyname(Socket.gethostname)[3]) rescue SocketError
+    return results.flatten
+  end
+end

data/lib/automateit/cli.rb

@@ -0,0 +1,80 @@
+module AutomateIt
+  # == CLI
+  #
+  # The CLI class provides AutomateIt's command-line interface. It's
+  # responsible for invoking recipes from the command line, starting the
+  # interactive shell and creating projects. It's run from
+  # <tt>bin/automate</tt>.
+  class CLI < Common
+    # Create a new CLI interpreter. If no :recipe or :eval option is provided,
+    # it starts an interactive IRB session for the Interpreter.
+    # 
+    # Examples:
+    #   AutomateIt::CLI.run("myrecipe.rb")
+    #   AutomateIt::CLI.run(:recipe => "myrecipe.rb")
+    #   AutomateIt::CLI.run(:eval => "42")
+    #
+    # Options:
+    # * :project -- Project directory to load.
+    # * :recipe -- Recipe file to execute.
+    # * :eval -- Evaluate this string.
+    # * :quiet -- Don't print shell header.
+    def self.run(*a)
+      args, opts = args_and_opts(*a)
+      recipe = args.first || opts[:recipe]
+      if recipe and not opts[:project]
+        opts[:project] = File.join(File.dirname(recipe), "..")
+        opts[:guessed_project] = true
+      end
+      opts[:verbosity] ||= Logger::INFO
+      if opts[:create]
+        Project::create(opts)
+      elsif code = opts.delete(:eval)
+        interpreter = AutomateIt.new(opts)
+        interpreter.instance_eval(code)
+      elsif recipe
+        AutomateIt.invoke(recipe, opts)
+      else
+        # Welcome messages
+        display = lambda{|msg| puts msg if opts[:verbosity] <= Logger::INFO}
+        display.call PNOTE+"AutomateIt Shell v#{AutomateIt::VERSION} #{$0}"
+
+        # Create and connect instances
+        require "irb"
+        IRB.setup(__FILE__)
+        # XXX irb: warn: can't alias context from irb_context.
+        irb = IRB::Irb.new
+        opts[:irb] = irb
+        IRB.conf[:MAIN_CONTEXT] = irb.context
+        interpreter = AutomateIt.new(opts)
+        irb.context.workspace.instance_variable_set(:@binding, interpreter.send(:binding))
+
+        # Tab completion
+        begin
+          require 'irb/completion'
+          irb.context.auto_indent_mode = true
+          irb.context.load_modules << 'irb/completion' unless irb.context.load_modules.include?('irb/completion')
+          irb.context.instance_eval{ @use_readline = true }
+          display.call PNOTE+"<CTRL-D> to quit, <Tab> to auto-complete"
+        rescue LoadError
+          display.call PNOTE+"<CTRL-D> to quit"
+        end
+
+        # Set prompt
+        unless opts[:custom_prompt] == false
+          irb.context.prompt_i = "ai> "
+          irb.context.prompt_s = "ai%l "
+          irb.context.prompt_c = "ai* "
+          begin
+            irb.context.prompt_n = "ai%i " 
+          rescue NoMethodError
+            # Not available on Ruby 1.8.2 bundled with Mac OS X 10.4 Tiger
+          end
+        end
+
+        # Run loop to read user input
+        irb.eval_input
+      end
+    end
+  end
+end

data/lib/automateit/common.rb

@@ -0,0 +1,65 @@
+module AutomateIt
+  # == Common
+  #
+  # Common is the abstract class that most AutomateIt classes inherit from.
+  class Common
+    include AutomateIt::Constants
+
+    # Interpreter instance for this class.
+    attr_accessor :interpreter
+
+    # Calls #setup with +options+ for processing.
+    def initialize(options={})
+      setup(options)
+    end
+
+    # Setup the class. Options:
+    # * :interpreter - Set the Interpreter.
+    def setup(options={})
+      @interpreter = options[:interpreter] if options[:interpreter]
+    end
+
+    #---[ Interpreter aliases ]---------------------------------------------
+
+    unless defined?(AutomateIt::Interpreter) and AutomateIt::Interpreter === self
+      # See Interpreter#log
+      def log() @interpreter.log end
+
+      # See Interpreter#noop=
+      def noop=(value) @interpreter.noop=(value) end
+
+      # See Interpreter#noop
+      def noop(value) @interpreter.noop(value) end
+
+      # See Interpreter#noop?
+      def noop?() @interpreter.noop?() end
+
+      # See Interpreter#writing=
+      def writing=(value) @interpreter.writing=(value) end
+
+      # See Interpreter#writing
+      def writing(value) @interpreter.writing(value) end
+
+      # See Interpreter#writing?
+      def writing?() @interpreter.writing?() end
+
+      # See Interpreter#preview?
+      def preview?() @interpreter.preview?() end
+
+      # See Interpreter#preview
+      def preview(value=nil) @interpreter.preview(value) end
+
+      # See Interpreter#preview=
+      def preview=(value) @interpreter.preview=(value) end
+
+      # See Interpreter#preview_for
+      def preview_for(message, &block) @interpreter.preview_for(message, &block) end
+
+      # See Interpreter#superuser?
+      def superuser?() @interpreter.superuser? end
+      
+      # See Interpreter#nitpick
+      def nitpick(value=nil) @interpreter.nitpick(value) end
+    end
+  end
+end

data/lib/automateit/constants.rb

@@ -0,0 +1,33 @@
+module AutomateIt # :nodoc:
+  # === AutomateIt::Constants
+  #
+  # Various constants.
+  module AutomateIt::Constants
+    # AutomateIt version
+    VERSION=Gem::Version.new("0.70923")
+
+    # Output prefix for command execution, e.g., "** ls -la"
+    PEXEC = "** "
+
+    # Output prefix for notes, e.g., "=> Something happened"
+    PNOTE = "=> "
+
+    # Output prefix for errors, e.g., "!! Something bad happened"
+    PERROR = "!! "
+
+    # Boilerplate to add to tops of generated files, warning people not to edit
+    # them directly.
+    WARNING_BOILERPLATE = "# +---------------------------------------------------------------------+
+# | WARNING: Do NOT edit this file directly or your changes will be     |
+# | lost. If you need to change this file, you must incorporate your    |
+# | changes into the AutomateIt project that created it. If you don't   |
+# | know what this means, please talk to your system administrator.     |
+# +---------------------------------------------------------------------+
+#
+"
+  end
+
+  # Inject constants back into top, providing AutomateIt::VERSION and such.
+  module_eval { include Constants }
+end
+