automate-it 0.9.0

data/automate-it.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name               = "automate-it"
+  s.version            = '0.9.0'
+  s.default_executable = "automateit"
+  s.license            = 'GNU-GPL'
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Igal Koshevoy", "Pavel Novotny"]
+  s.date = %q{2013-05-16}
+  s.description = %q{AutomateIt is an open source tool for automating the setup and maintenance of servers, applications and their dependencies. This is updated fork.}
+  s.email = %q{fandisek@gmail.com}
+  s.homepage = %q{http://rubygems.org/gems/better-automateit}
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Fork of AutomateIt}
+  s.bindir = 'bin'
+
+  s.add_dependency 'hoe'
+  s.add_dependency 'open4'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end

data/bin/ai

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+load File.join(File.dirname(__FILE__), "automateit")

data/bin/aifield

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+# XXX What can go wrong with this loading approach?
+libdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+if File.directory?(libdir) and File.exists?(File.join(libdir, "automateit.rb"))
+  $LOAD_PATH.unshift(libdir)
+end
+
+require 'rubygems'
+require 'optparse'
+require 'automateit'
+
+OptionParser.new do |parser|
+  PROG = File.basename($0)
+  opts = {}
+  parser.banner = <<EOB
+#{PROG} - tool for querying AutomateIt fields
+
+Usage: #{PROG} [options] query
+
+Examples:
+  # Load 'myproject' and get value of 'user' field in 'myapp' hash:
+  #{PROG} -p myproject myapp#user
+
+  # Same but using environmental variable to specify project:
+  AUTOMATEIT_PROJECT=myproject
+  #{PROG} myapp#user
+
+  # Dump the 'myapp' hash contents as YAML
+  #{PROG} -y myapp#user
+
+Options:
+EOB
+  parser.on("-p", "--project PATH", "Set project path") do |v|
+    opts[:project] = v
+  end
+
+  parser.on("-Y", "--yaml", "Dump as YAML") do |v|
+    opts[:yaml] = v
+  end
+
+  parser.on("-a", "--add TAGS", "Add list of space separated tags") do |v|
+    opts[:tags] = [v.split].flatten
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  end
+
+  parser.on("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  args = parser.parse!.dup
+
+  # Clear ARGV so that IRB doesn't try to parse our options
+  opts[:args] = args
+  ARGV.clear
+
+  query = args.first unless args.empty?
+
+  interpreter = AutomateIt.new(:project => opts[:project])
+  result = interpreter.lookup(query)
+  if result.nil?
+    puts result.inspect
+    exit 1
+  elsif opts[:yaml]
+    puts result.to_yaml
+  else
+    puts result.is_a?(String) ? result : result.inspect
+  end
+  exit 0
+end

data/bin/aissh

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+# XXX What can go wrong with this loading approach?
+libdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+if File.directory?(libdir) and File.exists?(File.join(libdir, "automateit.rb"))
+  $LOAD_PATH.unshift(libdir)
+end
+
+require 'rubygems'
+require 'optparse'
+require 'automateit'
+include AutomateIt::Constants
+
+OptionParser.new do |parser|
+  PROG = File.basename($0)
+  opts = {}
+  parser.banner = <<EOB
+#{PROG} - tool for running command via SSH on hosts matching AutomateIt tags
+
+Usage: #{PROG} [options] [arguments...]
+
+IMPORTANT:
+  #{PROG} can only match against tags specified in tags.yml. It cannot
+  match against automatically generated tags like the OS, architecture and such
+  which are created at runtime by PlatformManager or AddressManager. So if you
+  want to run a command against all Ubuntu servers, you must define them
+  explicitly in tags.yml.
+
+Examples:
+  # Read tags from project in current directory and run "ls" on all hosts
+  # tagged with "apache_servers" or "rails_servers":
+  #{PROG} --project . 'apache_servers | rails_servers' ls
+
+  # Preview SSH commands needed to run "ls" on "apache_servers":
+  #{PROG} -p . -n apache_servers ls
+
+  # Pass arguments to "ls", rather than #{PROG}:
+  #{PROG} -p . -n apache_servers -- ls -la
+
+  # Same as previous but using a quoted string:
+  #{PROG} -p . -n apache_servers 'ls -la'
+
+  # Execute a command which requires the target server to redirect output:
+  #{PROG} -p . -n apache_servers 'ps -ef | grep apache'
+
+Options:
+EOB
+  parser.on("-n", "--preview", "Preview without executing commands") do |v|
+    opts[:preview] = v
+  end
+
+  parser.on("-p", "--project PATH", "Set project path") do |v|
+    opts[:project] = v
+  end
+
+  parser.on("-q", "--quiet", "Don't display commands executed") do |v|
+    opts[:verbosity] = Logger::ERROR
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  end
+
+  parser.on("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  args = parser.parse!.dup
+  query = args.shift
+  commands = args
+
+  if commands.blank?
+    puts parser
+    puts "\nERROR: No commands specified"
+    exit 1
+  end
+
+  interpreter = AutomateIt.new(
+    :project => opts[:project],
+    :verbosity => opts[:verbosity]
+  )
+
+  interpreter.preview true if opts[:preview]
+
+  for host in interpreter.hosts_tagged_with(query).sort
+    cmd = "ssh %s %s" % [host, commands.join(" ").shell_escape]
+    interpreter.sh(cmd)
+  end
+
+  exit 0
+end

data/bin/aitag

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+
+# XXX What can go wrong with this loading approach?
+libdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+if File.directory?(libdir) and File.exists?(File.join(libdir, "automateit.rb"))
+  $LOAD_PATH.unshift(libdir)
+end
+
+require 'rubygems'
+require 'optparse'
+require 'automateit'
+
+OptionParser.new do |parser|
+  PROG = File.basename($0)
+  opts = {}
+  parser.banner = <<EOB
+#{PROG} - tool for querying AutomateIt tags
+
+Usage: #{PROG} [options] [arguments...]
+
+IMPORTANT:
+  #{PROG} can only match against tags specified in tags.yml. It cannot
+  match against automatically generated tags like the OS, architecture and such
+  which are created at runtime by PlatformManager or AddressManager. So if you
+  want to run a command against all Ubuntu servers, you must define them
+  explicitly in tags.yml.
+
+Examples:
+  # Load 'myproject' and see if it's tagged with 'apache' or 'svn':
+  #{PROG} -p myproject 'apache || svn'
+  echo $?
+
+  # Same but using environmental variable to specify project:
+  AUTOMATEIT_PROJECT=myproject
+  #{PROG} 'apache || svn'
+  echo $?
+
+  # Dump the results of a query as YAML
+  #{PROG} -Y myapp#user
+
+Options:
+EOB
+  parser.on("-s", "--tags", "List tags for this host") do |v|
+    opts[:list_tags] = v
+  end
+
+  parser.on("-f", "--tags_for HOST", "List tags for a specific host") do |v|
+    opts[:tags_for] = v
+  end
+
+  parser.on("-t", "--tagged? QUERY", "Is this host tagged with the query?") do |v|
+    opts[:tagged?] = v
+  end
+
+  parser.on("-w", "--hosts_tagged_with QUERY", "List hosts tagged with query") do |v|
+    opts[:hosts_tagged_with] = v
+  end
+
+  parser.on("-p", "--project PATH", "Set project path") do |v|
+    opts[:project] = v
+  end
+
+  parser.on("-Y", "--yaml", "Dump as YAML") do |v|
+    opts[:yaml] = v
+  end
+
+  parser.on("-a", "--add TAGS", "Add list of space separated tags") do |v|
+    opts[:add_tags] = [v.split].flatten
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  end
+
+  parser.on("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  args = parser.parse!.dup
+
+  # Clear ARGV so that IRB doesn't try to parse our options
+  opts[:args] = args
+  ARGV.clear
+
+  interpreter = AutomateIt.new(
+    :project => opts[:project],
+    :tags => opts[:add_tags]
+  )
+  result = nil
+
+  unless opts[:list_tags] or opts[:tags_for] or opts[:tagged?] or opts[:hosts_tagged_with]
+    if args.first
+      opts[:tagged?] = args.first
+    else
+      puts parser
+      puts "\nERROR: insufficient arguments"
+      exit 1
+    end
+  end
+
+  result = \
+    if opts[:list_tags]
+      interpreter.tags.to_a.sort
+    elsif opts[:tags_for]
+      interpreter.tags_for(opts[:tags_for])
+    elsif opts[:tagged?]
+      exit(interpreter.tagged?(opts[:tagged?]) ? 0 : 1)
+    elsif opts[:hosts_tagged_with]
+      interpreter.hosts_tagged_with(opts[:hosts_tagged_with])
+    end
+
+  puts(
+    if result.nil?
+      result.inspect
+    elsif opts[:yaml]
+      result.to_yaml
+    else
+      case result
+      when String
+        result
+      when Set
+        result.sort.to_a.join(' ')
+      when Array
+        result.sort.join(' ')
+      else
+        result.inspect
+      end
+    end
+  )
+
+  exit 0
+end

data/bin/automateit

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+# XXX What can go wrong with this loading approach?
+libdir = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+if File.directory?(libdir) and File.exists?(File.join(libdir, "automateit.rb"))
+  $LOAD_PATH.unshift(libdir)
+end
+
+require 'rubygems'
+require 'logger'
+require 'optparse'
+require 'automateit'
+
+include AutomateIt::Constants
+
+OptionParser.new do |parser|
+  PROG = File.basename($0)
+  opts = {}
+  parser.banner = <<EOB
+#{PROG} - tool for automating the setup and maintenance of servers
+
+Usage: #{PROG} [options] [recipe]
+
+Examples:
+  # Start an interactive shell session
+  #{PROG}
+
+  # Execute a recipe
+  #{PROG} myrecipe.rb
+
+  # Preview the commands a recipe will run without running them
+  #{PROG} -n myrecipe.rb
+
+  # Eval a string
+  #{PROG} -e "puts tags.to_a.inspect"
+
+  # Add a tag
+  #{PROG} -a mytag -e "puts tags.to_a.inspect"
+
+  # Add tags
+  #{PROG} -a 'mytag othertag' -e "puts tags.to_a.inspect"
+
+Options:
+EOB
+  parser.on("-c", "--create PATH", "Create project at path") do |v|
+    opts[:create] = v
+  end
+
+  parser.on("-p", "--project PATH", "Set project path") do |v|
+    opts[:project] = v
+  end
+
+  parser.on("-n", "--preview", "Preview without executing commands") do |v|
+    opts[:preview] = v
+  end
+
+  parser.on("-e", "--eval STRING", "Evaluate string") do |v|
+    opts[:eval] = v
+  end
+
+  parser.on("-a", "--add TAGS", "Add list of space separated tags") do |v|
+    opts[:tags] = [v.split].flatten
+  end
+
+  parser.on("-q", "--quiet", "Print only errors") do |v|
+    opts[:verbosity] = Logger::ERROR
+  end
+
+  parser.on("-d", "--debug", "Print debugging information") do |v|
+    opts[:verbosity] = Logger::DEBUG
+  end
+
+  parser.on("-T", "--trace", "Display raw exception traces") do |v|
+    opts[:friendly_exceptions] = ! v
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  end
+
+  parser.on("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  args = parser.parse!.dup
+
+  # Clear ARGV so that IRB doesn't try to parse our options
+  opts[:args] = args
+  ARGV.clear
+
+  opts[:recipe] = args.first unless args.empty?
+
+  # Save vars because +run+ will delete opts
+  argscopy = args.clone
+  optscopy = opts.clone
+
+  # Display newline at the end
+  newline = true
+
+  begin
+    rv = AutomateIt::CLI.run(opts)
+  rescue SystemExit
+    # Don't display errors when 'exit' is run
+    newline = false
+  rescue Exception => e
+    msg = nil
+    if e.is_a?(AutomateIt::Error) and e.cause.to_s =~ /IRB_EXIT/
+      # Don't display errors interpreter is closed with 'CTRL-D'
+    elsif opts[:friendly_exceptions] != false and e.is_a?(AutomateIt::Error)
+      # Friendly message
+      msg = PERROR+e.message
+      msg << "\n\n"+PNOTE+"Use 'automateit --trace' to see complete backtrace"
+    else
+      # Raw backtrace
+      puts PERROR+"AutomateIt error trace:"
+      stack = e.backtrace.clone
+      msg = "#{stack.shift}: #{e.message} (#{e.exception.class})}";
+      for line in stack
+        msg << "\n  "+line
+      end
+    end
+    puts msg
+    exit 1
+  end
+  if optscopy[:create] or optscopy[:eval] or argscopy.size > 0
+    exit rv ? 0 :1
+  elsif newline
+    # CTRL-D ends the line prematurely, so add a newline
+    puts
+  end
+end