calas-capitate 0.3.6

data/lib/capitate/plugins/build.rb

@@ -0,0 +1,71 @@
+module Capitate::Plugins::Build
+  
+  # Configure, make, make install.
+  #
+  # ==== Options
+  # +name+:: Name for app
+  # +options+:: Options (See Make install options)
+  #
+  # ==== Make install options
+  # +build_dest+:: Place to build from, ex. /usr/src, defaults to /tmp/name
+  # +url+:: URL to download package from
+  # +configure_options+:: Options for ./configure
+  # +symlink+:: After install, list of source, dest pairs to symlink 
+  #    [ { "/usr/local/sphinx-0.9.8-rc1" => "/usr/local/sphinx" }, ... ]
+  #    ln -s /usr/local/sphinx-0.9.8-rc1 /usr/local/sphinx
+  # +unpack_dir+:: Directory that is unpacked from tgz (if not matching the file name)
+  # +to_log+:: If specified, will redirect output to this path
+  #
+  # ==== Examples (in capistrano task)
+  #   build.make_install("nginx", { :url => "http://sysoev.ru/nginx/nginx-0.5.35.tar.gz", ... })
+  #
+  def make_install(name, options)
+    install(name, options) do |dir|
+      configure_options = options[:configure_options] || ""
+      
+      # Whether to capture build output
+      unless options.has_key?(:to_log)
+        to_log = ">> debug.log 2>&1"
+      else
+        to_log = ""
+        to_log = ">> #{options[:to_log]}" unless options[:to_log].blank?
+      end
+      
+      script.run_all <<-CMDS
+        sh -c "cd #{dir} && ./configure #{configure_options} #{to_log}"
+        sh -c "cd #{dir} && make #{to_log}"
+        sh -c "cd #{dir} && make install #{to_log}"
+      CMDS
+      
+      utils.ln(options[:symlink]) unless options[:symlink].blank?
+    end
+  end
+  
+  # Download, unpack and yield (unpacked source director).
+  # 
+  # ==== Options
+  # +name+:: Name for app
+  # +options+:: Options (see Install options)
+  #
+  # ==== Install options
+  # +build_dest+:: Place to build from, ex. /usr/src, defaults to /tmp/name
+  # +url+:: URL to download package from
+  # 
+  # ==== Examples (in capistrano task)
+  #   script.make("rubygems", { :url => :url => "http://rubyforge.org/frs/download.php/29548/rubygems-1.0.1.tgz" }) do |dir|
+  #     sudo "echo 'Running setup...' && cd #{dir} && ruby #{dir}/setup.rb"
+  #   end
+  #
+  def install(name, options, &block)
+    build_dest = options[:build_dest]
+    build_dest ||= "/tmp/#{name}"
+    url = options[:url]    
+    
+    script.unpack(url, build_dest, options) do |dir|
+      yield(dir) if block_given?
+    end      
+  end
+        
+end
+
+Capistrano.plugin :build, Capitate::Plugins::Build

data/lib/capitate/plugins/gem.rb

@@ -0,0 +1,24 @@
+module Capitate::Plugins::Gem
+  
+  # Install a gem.
+  #
+  # ==== Options
+  # +gems+:: List of gem names, or a single gem
+  #
+  # ==== Examples (in capistrano task)
+  #   gems.install("raspell") 
+  #   gems.install([ "raspell", "foo" ])
+  #
+  def install(gems)
+    # If a single object, wrap in array
+    gems = [ gems ] unless gems.is_a?(Array)
+    
+    # Install one at a time because we may need to pass install args (e.g. mysql)
+    gems.each do |gem|
+      run_via "gem install --no-rdoc --no-ri --no-verbose #{gem}"
+    end
+  end
+  
+end
+
+Capistrano.plugin :gems, Capitate::Plugins::Gem

data/lib/capitate/plugins/prompt.rb

@@ -0,0 +1,109 @@
+require 'md5'
+
+module Capitate::Plugins::Prompt
+
+  # Prompt.
+  #
+  # ==== Options
+  # :label<String>:: Label
+  # :options<Hash>:: An options hash (see below)
+  #
+  def ask(label, options = {}, &block)
+    Capistrano::CLI.ui.ask(label, &block)
+  end
+  
+  # Prompt for password.
+  #
+  # ==== Options (options)
+  # :label<String>:: Label
+  # :options<Hash>:: An options hash (see below)
+  #
+  # ==== Password options
+  # :verify<bool>:: If true, prompt twice and verify
+  # :lazy<bool>:: If true, returns a Proc. _Defaults to true_
+  # :check_hash<String>:: If present, checks that md5 is same as password md5
+  # :max_attempts<Integer>:: Number of attempts to retry. _Defaults to 3_
+  #
+  def password(label, options = {})
+    
+    verify = options[:verify]
+    lazy = options[:lazy].nil? ? true : options[:lazy]
+    check_hash = options[:check_hash]
+    max_attempts = options[:max_attempts] || 3
+    
+    # Lazy
+    password_prompt = Proc.new { 
+      
+      attempts = 0
+      password = nil
+      success = true
+
+      loop do
+        password = Capistrano::CLI.password_prompt(label)
+        attempts += 1
+    
+        if verify
+          password_verify = Capistrano::CLI.password_prompt("[VERIFY] #{label}")
+          if password != password_verify
+            logger.important "Passwords do not match" 
+            success = false
+          end
+        end
+      
+        if check_hash
+          if MD5.md5(password).hexdigest != check_hash
+            logger.important "Invalid password, try again." 
+            success = false            
+          end         
+        end
+        
+        break if success
+        break if attempts >= max_attempts
+        
+        # Reset success
+        success = true
+      end
+      
+      raise "Invalid password, too many tries" unless success
+    
+      password
+    }
+    
+    return password_prompt if lazy
+    password_prompt.call
+  end  
+  
+  # Preview variables, and re-set them if asked to.
+  # Uses highline menus. Is not very intelligent.
+  #
+  # ==== Options
+  # :variables<Array>:: List of variables to show and verify
+  # :header<String>:: Menu header
+  # :prompt<String>:: Menu prompt
+  #
+  def preview_variables(variables, header = "Verify your settings", prompt = "Choose: ")
+    hl = Capistrano::CLI.ui
+    
+    confirmed = false
+    while not confirmed do 
+      hl.choose do |menu|
+        menu.header = header
+        menu.prompt = prompt
+        
+        menu.choice("<Continue>") do
+          confirmed = true
+        end
+        
+        variables.each do |variable|
+          menu.choice("#{variable}: #{fetch(variable)}") do
+            new_setting = ask("Set #{variable}: ") { |q| q.default = fetch(variable) }
+            set variable, new_setting
+          end
+        end        
+      end
+    end
+  end
+  
+end
+
+Capistrano.plugin :prompt, Capitate::Plugins::Prompt

data/lib/capitate/plugins/rake.rb

@@ -0,0 +1,25 @@
+module Capitate::Plugins::Rake
+
+  # Execute rake tasks.
+  #
+  # ==== Options
+  # +tasks+:: List of task names, or a single task
+  #
+  # ==== Examples (in capistrano task)
+  #   rake.run("db:migrate")
+  #   rake.run([ "db:create", "db:migrate" ])
+  #   rake.run("db:bootstrap AUTO_ACCEPT=true")
+  #
+  def run(tasks)
+    # If a single object, wrap in array
+    tasks = [ tasks ] unless tasks.is_a?(Array)
+
+    # Install one at a time because we may need to pass install args (e.g. AUTO_ACCEPT=true)
+    tasks.each do |task|
+      run_via "/usr/bin/env rake RAILS_ENV=#{rails_env} #{task}"
+    end
+  end
+
+end
+
+Capistrano.plugin :rake, Capitate::Plugins::Rake

data/lib/capitate/plugins/script.rb

@@ -0,0 +1,96 @@
+module Capitate::Plugins::Script
+  
+  # Run (sh) script. If script has .erb extension it will evaluate it.
+  #
+  # ==== Options
+  # +script+:: Name of sh file (relative to templates dir)
+  # +override_binding++:: Binding to override, otherwise defaults to current (task) context
+  #
+  # ==== Examples
+  #   script.sh("ruby/openssl_fix.sh")
+  #
+  def sh(script, override_binding = nil)
+        
+    if File.extname(script) == ".erb"
+      name = script[0...script.length-4]
+      dest = "/tmp/cap/#{name}"
+      run_via "mkdir -p #{File.dirname(dest)}"
+      put template.load(script, override_binding || binding), dest
+    else
+      name = script
+      dest = "/tmp/cap/#{name}"
+      run_via "mkdir -p #{File.dirname(dest)}"
+      put template.load(script), dest
+    end
+    
+    # If want verbose, -v
+    run_all <<-CMDS
+      sh -v #{dest}
+      rm -rf #{File.dirname(dest)}
+    CMDS
+  end
+  
+  # Download and unpack URL.
+  # Yields path to unpacked source.
+  #
+  # ==== Options
+  # +url+:: URL to download
+  # +dest+:: Destination directory
+  # +options+:: Options (see Unpack options)
+  #
+  # ==== Unpack options
+  # +clean+:: If true will remove the unpacked directory. _Defaults to true_
+  # +unpack_dir+:: Directory that is unpacked from tgz (if not matching the file name)
+  #
+  # ==== Examples
+  #   script.unpack("http://rubyforge.org/frs/download.php/29548/rubygems-1.0.1.tgz", "/tmp/rubygems") do
+  #     sudo "ruby setup.rb"
+  #   end
+  #
+  def unpack(url, dest, options, &block)        
+    file = url.split("/").last
+    
+    # TODO: Support other types
+    if file !~ /\.tar\.gz\Z|\.tgz\Z/
+      raise "Can't unpack this file: #{file}; only support tar.gz and tgz formats"
+    end
+    
+    options[:clean] = true if options[:clean].nil?
+    unpack_dir = options[:unpack_dir]
+    clean = options[:clean]
+    
+    unpack_dir ||= file.gsub(/\.tar\.gz|\.tgz/, "")
+    
+    http_get_method = fetch(:http_get_method, "wget -nv")
+        
+    run_all <<-CMDS
+      sh -c "mkdir -p #{dest} && cd #{dest} && #{http_get_method} #{url}"
+      sh -c "cd #{dest} && tar zxf #{file}"
+    CMDS
+    
+    if block_given?
+      yield("#{dest}/#{unpack_dir}")
+      run_via "rm -f #{dest}/#{file}"
+      run_via "rm -rf #{dest}" if clean
+    end
+  end
+  
+  # Run all commands (separated by newlines).
+  # 
+  # Uses run_via to execute, so will use <tt>run</tt> or <tt>sudo</tt>
+  # depending on the current <tt>:run_method</tt>
+  #
+  # ==== Options
+  # +cmds+:: Commands (separated by newlines)
+  # +options+:: See Capistrano invoke_command options
+  #
+  def run_all(cmds, options = {}, &block)    
+    cmds.split("\n").each do |cmd|
+      cmd = cmd.gsub(/^\s+/, "")        
+      run_via(cmd, options, &block)
+    end    
+  end  
+  
+end
+
+Capistrano.plugin :script, Capitate::Plugins::Script

data/lib/capitate/plugins/templates.rb

@@ -0,0 +1,113 @@
+module Capitate::Plugins::Templates
+  
+  # Load template. If the extension is .erb will be evaluated with binding.
+  #
+  # You can add to the list of places we search for templates by setting:
+  #
+  #    set :templates_dirs, [ "path/to/templates1", "/path/to/templates2" ]
+  #
+  # It looks for the template from:
+  # * the <tt>:templates_dirs</tt> setting (if set)
+  # * the current directory
+  # * the <tt>:project_root</tt> setting (if set)
+  # * the gem templates path  
+  # 
+  # ==== Options
+  # +path+:: If starts with '/', absolute path, otherwise relative path to templates dir
+  # +override_binding+:: Binding to override, otherwise uses current (task) binding
+  #
+  # ==== Examples
+  #   template.load("memcached/memcached.monitrc.erb") => "This is the text of eval'ed template found at ..."
+  #
+  #   put template.load("memcached/memcached.monitrc.erb"), "/tmp/memcached.monitrc" # Uploads eval'ed template to remote /tmp/ directory
+  #
+  def load(path, override_binding = nil)
+    template_dirs_found = template_dirs.select { |dir| File.exist?("#{dir}/#{path}") }
+    
+    # Not found anywhere, throw error
+    if template_dirs_found.empty?
+      raise "\n\nTemplate not found: #{path}\n\n"
+    end
+    
+    # Use first
+    template_path = template_dirs_found.first + "/#{path}"
+    
+    logger.info "reading #{template_path}"
+    template_data = IO.read(template_path)
+    
+    if File.extname(template_path) == ".erb"    
+      template = ERB.new(template_data)
+      logger.info "evaluating #{template_path}"
+      template_data = template.result(override_binding || binding)
+    end
+    template_data
+  end
+    
+  # Write template at (relative path) with binding to LOCAL destination path.
+  #
+  # ==== Options
+  # +template_path+:: Path to template relative to templates path
+  # +dest_path+:: Local destination path to write to
+  # +overwrite_binding+:: Binding  
+  # +overwrite+:: Force overwrite
+  # +verbose+:: Verbose output
+  #
+  # ==== Examples
+  #   template.write("config/templates/sphinx.conf.erb", "config/sphinx.conf")
+  #  
+  def write(template_path, dest_path, override_binding = nil, overwrite = false, verbose = true)    
+    # This is gnarly!
+    relative_dest_path = Pathname.new(File.expand_path(dest_path)).relative_path_from(Pathname.new(File.expand_path(".")))  
+    
+    if !overwrite && File.exist?(dest_path) 
+      puts "%10s %-40s (skipped)" % [ "create", relative_dest_path ] if verbose
+      return
+    end
+    
+    puts "%10s %-40s" % [ "create", relative_dest_path ] if verbose
+    template_data = load(template_path, override_binding)
+    File.open(dest_path, "w") { |file| file.puts(load(template_path, override_binding)) }
+  end
+    
+    
+protected
+
+  # Load all possible places for templates.
+  #
+  # Returns:
+  # * the <tt>:templates_dirs</tt> setting (if set)
+  # * the current directory
+  # * the <tt>:project_root</tt> setting (if set)
+  # * the gem templates path
+  #
+  def template_dirs
+    @template_dirs ||= begin
+      template_dirs = []      
+      template_dirs += fetch(:templates_dirs) if exists?(:templates_dirs)      
+      template_dirs << "."
+      template_dirs << project_root if exists?(:project_root)
+      template_dirs << gem_templates_root
+      template_dirs
+    end
+  end
+
+  # Get the absolute base templates path.
+  def gem_templates_root
+    File.expand_path(File.dirname(__FILE__) + "/../../templates")
+  end
+  
+  # Get full template path from relative path.
+  #
+  # ==== Options 
+  # +template_path+:: Relative path
+  #
+  # ==== Examples
+  #    gem_template_path("monit/monit.cnf") => /usr/lib/..../capitate/lib/templates/monit/monit.cnf
+  #
+  def gem_template_path(template_path)
+    File.join(gem_templates_root, template_path)
+  end
+  
+end
+
+Capistrano.plugin :template, Capitate::Plugins::Templates

data/lib/capitate/plugins/utils.rb

@@ -0,0 +1,151 @@
+module Capitate::Plugins::Utils
+  
+  # Symlink source to dest
+  #
+  # ==== Options
+  # +args+:: Arguments. If argument is hash, then key is symlinked to value.
+  #
+  # ==== Examples
+  #   utils.ln("src/foo" => "dest/foo") # Run: ln -nfs src/foo dest/foo
+  #   utils.ln("src/foo" => "dest/foo", "src/bar" => "dest/bar") # Links both
+  #
+  def ln(*args)    
+    args.each do |arg|
+      if arg.is_a?(Hash)
+        arg.each do |src, dest|
+          run_via "ln -nfs #{src} #{dest}"    
+        end    
+      end
+    end
+  end
+  
+  # Delete file.
+  #
+  # ==== Options
+  # +path+:: Path to delete
+  #
+  def rm(path)
+    run_via "rm #{path}"
+  end
+
+  # Delete file (recursive/force)
+  #
+  # ==== Options
+  # +path+:: Path to delete
+  #  
+  def rm_rf(path)
+    run_via "rm -rf #{path}"
+  end
+  
+  # Load template and install it.
+  # Removes temporary files during transfer and ensures desination directory is created before install.
+  #
+  # See template plugin for where template paths are loaded from.
+  #
+  # ==== Options
+  # +template_path+:: Path to template
+  # +destination+:: Remote path to evaluated template
+  # +options+:: Options (see Install template options)
+  #
+  # ==== Install template options
+  # +user+:: User to install (-o). Defaults to *root*.
+  # +mode+:: Mode to install file (-m)
+  #
+  # ==== Example
+  #   utils.install_template("monit/memcached.monitrc.erb", "/etc/monit/memcached.monitrc", :user => "root", :mode => "600")
+  #
+  def install_template(template_path, destination, options = {})
+    # Truncate extension
+    tmp_file_path = template_path.gsub("/", "_").gsub(/.erb$/, "")    
+    tmp_path = "/tmp/#{tmp_file_path}"
+    
+    options[:user] ||= "root"
+    
+    install_options = []
+    install_options << "-o #{options[:user]}"
+    install_options << "-m #{options[:mode]}" if options.has_key?(:mode)
+    
+    put template.load(template_path), tmp_path    
+    # TOOD: Ensure directory exists? mkdir -p #{File.dirname(destination)}
+    run_via "install #{install_options.join(" ")} #{tmp_path} #{destination} && rm -f #{tmp_path}"
+  end
+  
+  # Grep file for regex. Returns true if found, false otherwise.
+  #
+  # ==== Options
+  # +grep+:: Regular expression
+  # +path+:: Path to file
+  #
+  # ==== Example
+  #   utils.egrep("^mail.\\*", "/etc/syslog.conf") => true
+  # 
+  def egrep(grep, path)
+    found = true
+    run_via %{egrep '#{grep}' #{path} || echo $?} do |channel, stream, data|    
+      if data =~ /^(\d+)/
+        if $1.to_i > 0
+          logger.trace "Not found"
+          found = false 
+        end
+      end
+    end
+    found
+  end
+  
+  # Check if file exists.
+  #
+  # ==== Options
+  # +path+:: Path to file
+  #
+  def exist?(path)
+    found = true
+    run_via "head -1 #{path} >/dev/null 2>&1 || echo $?" do |channel, stream, data|
+      if data =~ /^(\d+)/
+        if $1.to_i > 0
+          logger.trace "Not found"
+          found = false 
+        end
+      end
+    end
+    found
+  end
+  
+  # Get the hostname of the remote server
+  #
+  # ==== Example
+  #   utils.hostname => "localhost.localdomain"
+  #
+  def hostname
+    hostname = nil
+    run "hostname" do |channel, stream, data|
+      hostname = data.chomp
+    end
+    hostname
+  end
+  
+  # Append data to a file.
+  # Optionally check that it exists before adding.
+  #
+  # ==== Options
+  # +path+:: Path to file to append to
+  # +data+:: String data to append
+  # +check+:: If not nil, will check to see if egrep matches this regex and will not re-append
+  # +left_strip+:: If true (default), remove whitespace before lines
+  # +should_exist+:: If true (default), raise error if file does not exist
+  #
+  def append_to(path, data, check = nil, left_strip = true, should_exist = true)
+    # If checking and found expression then abort append
+    return if check and egrep(check, path)
+
+    # If should exist and doesn't then abort append
+    raise "Can't append to file. File should exist: #{path}" if should_exist and !exist?(path)
+
+    data.split("\n").each do |line|
+      line = line.gsub(/^\s+/, "") if left_strip
+      run_via "echo '#{line}' >> #{path}"
+    end
+  end
+  
+end
+
+Capistrano.plugin :utils, Capitate::Plugins::Utils