automateit 0.70923

data/bin/ai

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

data/bin/aifield

@@ -0,0 +1,82 @@
+#!/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
+
+  # Dump the 'myapp' hash contents as XML
+  #{PROG} -x 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("-X", "--xml", "Dump as XML") do |v|
+    opts[:xml] = v
+  end
+
+  parser.on("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  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
+  elsif opts[:xml]
+    require 'active_support/core_ext/hash'
+    require 'active_support/core_ext/array'
+    puts result.to_xml
+  else
+    puts result.is_a?(String) ? result : result.inspect
+  end
+  exit 0
+end

data/bin/aitag

@@ -0,0 +1,128 @@
+#!/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...]
+
+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
+
+  # Dump the results of a query as XML
+  #{PROG} -X myapp#user
+
+Options:
+EOB
+  parser.on("-s", "--tags", "List tags for this host") do |v|
+    opts[: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("-X", "--xml", "Dump as XML") do |v|
+    opts[:xml] = v
+  end
+
+  parser.on("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  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])
+  result = nil
+
+  unless opts[: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[:tags]
+      interpreter.tags
+    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
+    elsif opts[:xml]
+      require 'active_support/core_ext/hash'
+      require 'active_support/core_ext/array'
+      result.to_xml
+    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,117 @@
+#!/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"
+
+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("-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("-h", "--help", "Display this help message") do |v|
+    puts parser
+    exit
+  end
+
+  parser.on("-v", "--version", "Display version") do |v|
+    puts AutomateIt::VERSION
+    exit 0
+  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
+
+  begin
+    rv = AutomateIt::CLI.run(opts)
+  rescue Exception => e
+    msg = nil
+    if 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
+  rescue SysExit => e
+    # Don't display errors when exit gets called
+  end
+  if optscopy[:create] or optscopy[:eval] or argscopy.size > 0
+    exit rv ? 0 :1
+  else
+    # CTRL-D ends the line prematurely, so add a newline
+    puts
+  end
+end

data/docs/friendly_errors.txt

@@ -0,0 +1,50 @@
+== User-friendly error messages
+
+AutomateIt provides user-friendly error messages that make it easier to fix
+problems in recipes and templates. These pinpoint the cause and show code
+snippets.
+
+For example, one of the sample recipes is executed -- but there's a problem and
+the output is shown below. 
+
+The message is telling us the error happened in the
+'examples/basic/recipes/install.rb' recipe at line 47. The first snippet shows
+the end of a failed TemplateManager +render+ call. 
+
+In the second code snippet, we see there was a problem with the ERB template
+'dist/myapp_server.erb'. This template failed at line 5 because it couldn't
+find a variable called +pat+.
+
+With the help of the second snippet, we quickly see that there's a typo -- that
+bad variable should have been +path+. Problem solved!
+
+  root@kagami> automateit -n examples/basic/recipes/install.rb
+  !! Problem with recipe 'examples/basic/recipes/install.rb' at line 47
+
+     41            :to => "/etc/init.d/myapp_server",
+     42            :mode => 0555,
+     43            :locals => {
+     44               :path => lookup(:path),
+     45               :user => lookup(:user),
+     46               :port => lookup(:port),
+   * 47            }
+     48     )
+     49
+
+  (NestedError) Problem with template 'dist/myapp_server.erb' at line 5:
+
+     1 #!/usr/bin/env ruby
+     2
+     3 user = "<%=user%>"
+     4 port = "<%=port%>"
+   * 5 path = "<%=pat%>"
+     6 pid = "mongrel.pid"
+     7
+
+  (NameError) undefined local variable or method `pat' for #<AutomateIt::TemplateManager::ERB:0xb78a4e8c>
+    /home/igal/workspace/automateit/app/lib/helpful_erb.rb:60:in `result'
+    /home/igal/workspace/automateit/app/lib/automateit/template_manager/erb.rb:105:in `render'
+    (eval):2:in `render'
+    examples/basic/recipes/install.rb:47:in `invoke'
+
+  => Use 'automateit --trace' to see complete backtrace

data/docs/previews.txt

@@ -0,0 +1,86 @@
+== Previews
+
+AutomateIt provides a way to preview commands without actually running them.
+Read the TUTORIAL.txt[link:files/TUTORIAL_txt.html] to learn the basic previewing concepts and commands. 
+
+=== WARNING: Previewing code can be dangerous!
+
+AutomateIt only provides logic for previewing its own commands. Recipe authors
+are responsible for providing previewing logic for their own custom code.
+
+Here's what *not* to do with previews:
+
+  puts "Hello!"
+
+The above +puts+ method will execute in both preview and non-preview modes.
+To execute custom code only in a specific mode, wrap it with conditionals.
+
+For example:
+
+ if preview?
+   puts "This is a preview"
+ end
+
+ preview_for("PREVIEW: Will run custom commands") do
+   puts "Custom commands"
+ end
+
+When in preview mode, the above recipe will display:
+
+ This is a preview
+ => PREVIEW: Will run custom commands
+
+When run normally without preview mode:
+
+ Custom commands
+
+Therefore, wrap all non-AutomateIt commands (e.g. +system+) that shouldn't be
+executed during the preview with conditionals.
+
+=== WARNING: Changing directories during preview can be dangerous!
+
+AutomateIt will only *pretend* to make directories in preview mode. In
+preview mode, it will also only *pretend* to change into non-existent
+directories when using commands like #cd, #mkdir and #mktempdircd.
+
+This can be *disastrous* if you're executing non-AutomateIt commands (e.g.
++system+) that use *relative* *paths* and expect to be run inside the
+newly-created temporary directory because the +chdir+ didn't actually happen.
+
+For example:
+
+  # DON'T EVER DO THIS!!!
+  mkdir_p "/tmp/foo/bar" do
+    system "echo 'I'm going to do: rm -rf *'"
+  end
+
+If that directory didn't already exist, then running the above code in
+preview mode would cause the +system+ command to actually run! If that wasn't
+an +echo+ command, it would have deleted the contents of your *current*
+directory -- not the <tt>/tmp/foo/bar</tt> directory -- because that
+directory wasn't actually created due to the preview mode!
+
+The correct way to write the above example is:
+
+  mkdir_p "/tmp/foo/bar" do
+    preview_for("PREVIEW: Deleting all files in directory /tmp/foo/bar") do
+      system "echo 'I'm going to do: rm -rf *'"
+    end
+  end
+
+The Interpreter#preview_for method provides conditional execution of blocks.
+When running in preview mode, it will display the supplied message and not
+execute the block containing the +system+ command:
+
+  => PREVIEW: Deleting all files in directory /tmp/foo/bar
+
+When running without preview mode, the method will not display the message
+but will call block, generating the following output:
+
+  ** echo 'I'm going to do: rm -rf *'"
+  I'm going to do: rm -rf *
+
+=== Conclusion
+
+Keeping the preview issues in mind and wrapping custom code with conditionals
+will help you write code that can be safely previewed.