calas-capitate 0.3.6

data/lib/capitate/cap_ext/connections.rb

@@ -0,0 +1,105 @@
+# Patch to add ability to clear sessions/connections.
+module Capitate
+  module CapExt
+    module Connections
+  
+      # Set the user to something new (but save the old user; reset_user will set it back).
+      # Takes care of invalidating current connections. Will force a re-login.
+      # 
+      # ==== Options
+      # +new_user+:: User to become
+      #
+      # ==== Examples
+      #   set_user("nginx")
+      #   # Do something as user nginx
+      #
+      def set_user(new_user)
+        previous_user = fetch(:user)
+    
+        return if previous_user == new_user
+        set :previous_user, previous_user
+    
+        set :user, new_user
+        clear_sessions
+      end
+  
+      # Reset to the old user.
+      # Takes care of invalidating current connections. Will force a re-login.
+      # 
+      # ==== Examples
+      #   # User is "root"
+      #   set_user("nginx")
+      #   # Do something as user nginx
+      #   reset_user
+      #   # User is now root
+      #
+      def reset_user
+        return unless exists?(:previous_user)
+        set :user, fetch(:previous_user)
+        unset :previous_user
+        clear_sessions
+      end
+  
+      # Perform action as a different user. Yields the previous user to the block.
+      #
+      # ==== Options
+      # +new_user+:: User to become
+      #
+      # ==== Examples
+      #   new_user("nginx") do |old_user|
+      #     # Do something as user nginx
+      #   end
+      #   # Now as user old_user
+      #
+      def with_user(new_user, &block)
+        begin
+          set_user(new_user)
+          yield exists?(:previous_user) ? fetch(:previous_user) : nil
+        ensure
+          reset_user
+        end
+    
+        clear_sessions
+      end
+  
+      # Close all open sessions, and will force user to re-login.
+      def clear_sessions    
+        sessions.each do |key, session|
+          logger.info "Closing: #{key}"
+          session.close
+        end    
+        sessions.clear    
+        reset_password
+      end
+  
+      # Reset the password.
+      # Display the current user that is asking for the password.
+      def reset_password
+        set :password, Proc.new {
+          Capistrano::CLI.password_prompt("Password (for user: #{user}): ")
+        }  
+      end
+    
+    end
+  end
+end
+
+# Debug connections
+class Capistrano::SSH
+  
+  class << self  
+  
+    def connect_with_logging(server, options={}, &block)      
+      @connect_mutex ||= Mutex.new
+      
+      @connect_mutex.synchronize do
+        puts "--- Connecting to #{server} with user: #{server.user || options[:user]}"      
+      end
+
+      connect_without_logging(server, options, &block)      
+    end
+  
+    alias_method_chain :connect, :logging
+  
+  end
+end

data/lib/capitate/cap_ext/docs.rb

@@ -0,0 +1,26 @@
+module Capitate
+  
+  module CapExt
+    
+    module Docs
+      
+      # Get link to github source, so we can refer to recipe code.
+      #
+      # ==== Options
+      # +recipe+:: Recipe path, probably use __FILE__
+      #
+      # ==== Examples
+      #   # In a lib/recipes/foo/foo.rb
+      #   link_to_source(__FILE__) => "http://github.com/gabriel/capitate/tree/master/lib/recipes/foo/foo.rb"
+      #
+      def link_to_source(recipe_path)
+        full_path = File.expand_path(recipe_path)
+        project_path = File.expand_path(File.dirname(__FILE__) + "/../../../")
+        "http://github.com/gabriel/capitate/tree/master#{full_path.sub(project_path, "")}"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/capitate/cap_ext/namespace.rb

@@ -0,0 +1,34 @@
+module Capitate
+  
+  module CapExt
+    
+    module Namespace
+      
+      def self.included(base) #:nodoc:
+        unless base.method_defined?(:task_without_capitate)
+          base.send :alias_method, :task_without_capitate, :task
+          base.send :alias_method, :task, :task_with_capitate
+        end
+      end
+      
+      def task_arg(name, desc, options = {})
+        @next_task_arguments ||= []
+        @next_task_arguments << options.merge({ :name => name, :desc => desc })
+      end
+      
+      def task_with_capitate(name, options={}, &block)
+        task_without_capitate(name, options) do
+          find_task(name).setup_defaults
+          block.call
+        end
+        task_def = find_task(name)        
+        task_def.arguments = @next_task_arguments
+        @next_task_arguments = nil
+        task_def
+      end
+            
+    end
+    
+  end
+  
+end

data/lib/capitate/cap_ext/run_via.rb

@@ -0,0 +1,16 @@
+module Capitate::CapExt::RunVia
+  
+  # Invoke command with current run_method setting.
+  #
+  # Chooses +sudo+ or +run+ based on <tt>:run_method</tt> setting.
+  #
+  # ==== Options
+  # +cmd+:: Command to run
+  # +options+:: Options (see invoke_command options)
+  #
+  def run_via(cmd, options = {}, &block)    
+    options[:via] = fetch(:run_method, :sudo) unless options.has_key?(:via)
+    invoke_command(cmd, options, &block)
+  end
+  
+end

data/lib/capitate/cap_ext/task_definition.rb

@@ -0,0 +1,22 @@
+module Capitate
+  
+  module CapExt
+    
+    module TaskDefinition
+      
+      attr_accessor :arguments
+      
+      def setup_defaults
+        return if arguments.blank?
+        
+        arguments.each do |arg|
+          namespace.fetch_or_default(arg[:name], arg[:default]) if arg.has_key?(:default)
+          namespace.fetch_or_set(arg[:name], arg[:set]) if arg.has_key?(:set)
+        end 
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/capitate/cap_ext/variables.rb

@@ -0,0 +1,132 @@
+module Capitate
+  module CapExt
+    module Variables
+
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :fetch_without_capitate, :fetch
+        base.send :alias_method, :fetch, :fetch_with_capitate
+      end
+    
+      # Fetch.
+      # Displays usage message from recipe docs if variable not found.
+      #
+      # See capistrano fetch for usage info.
+      #
+      def fetch_with_capitate(variable, *args)
+        begin
+          fetch_without_capitate(variable, *args)
+        rescue IndexError
+          message = capitate.usage(variable)
+
+          if message.blank?
+            message = <<-EOS
+
+            Please set :#{variable} variable in your Capfile or deploy.rb
+
+            EOS
+          end
+        
+          raise IndexError, "\n#{message}"
+        end        
+      end
+      
+      # Fetch or set and return default.
+      #
+      # ==== Options
+      # +variable+:: Variable to fetch
+      # +default+:: Default value if not set
+      # +args+:: ?
+      #
+      # ==== Examples
+      #   fetch_or_default(:memcached_port, 11211) => 11211
+      #   # Any calls to fetch(memcached_port) in the future will return this value 11211 (unless overriden)
+      #
+      def fetch_or_default(variable, default, *args)
+        if exists?(variable)
+          fetch(variable, *args)
+        else
+          set variable, default
+          default
+        end        
+      end
+      
+      # Fetch or set and fetch any default variable listed.
+      #
+      # ==== Options
+      # +variable+:: Variable to fetch
+      # +variables+:: List if variables to try in order
+      #
+      # ==== Examples
+      #   fetch_or_set(:sphinx_db_host, :db_host)
+      #
+      def fetch_or_set(variable, *default_variables)
+        return fetch(variable) if exists?(variable)
+        
+        default_variables.each do |default_variable|
+          if exists?(default_variable)
+            value = fetch(default_variable) 
+            set variable, value
+            return value
+          end
+        end
+        nil        
+      end
+      
+      # Fetch roles with name and options.
+      # I don't actually use this.
+      #
+      # ==== Options
+      # +name+:: Role name to look for
+      # +options+:: Options to match on, e.g. :primary => true
+      #
+      # ==== Examples
+      #   fetch_roles(:db) => [ "10.0.6.71", "10.0.6.72" ]
+      #   fetch_roles(:db, :primary => true) => [ "10.0.6.71" ]
+      #
+      def fetch_roles(name, options = {})
+        matched_roles = Set.new
+        
+        roles.each do |role_info|
+          role_name = role_info.first 
+          
+          next unless role_name == name
+            
+          role = role_info.last
+          role.each do |server|
+            
+            abort = false
+            options.each do |k, v|
+              unless server.options[k] == v
+                abort = true
+                break 
+              end
+            end
+            next if abort
+            
+            matched_roles << server
+          end
+        end
+        matched_roles.to_a
+      end
+      
+      # Fetch first role with name and options.
+      #
+      # ==== Options
+      # +name+:: Role name to look for
+      # +options+:: Options to match on, e.g. :primary => true
+      #
+      # ==== Examples
+      #   fetch_roles(:db) => [ "10.0.6.71", "10.0.6.72" ]
+      #   fetch_roles(:db, :primary => true) => [ "10.0.6.71" ]
+      #
+      def fetch_role(name, options = {})
+        matched = fetch_roles(name, options)
+        return matched.first if matched
+        nil
+      end
+      
+    end
+  end
+  
+end
+    

data/lib/capitate/plugins/base.rb

@@ -0,0 +1,140 @@
+require 'erb'
+require 'yaml'
+
+# Capitate base capistrano plugin
+module Capitate::Plugins::Base
+  
+  # Project root. Fetch from :project_root, or fall back to RAILS_ROOT.
+  def root
+    return fetch(:project_root) if exists?(:project_root)
+    RAILS_ROOT
+  end
+    
+  # Path relative to project root.
+  #
+  # To set the project root:
+  #
+  #   set :project_root, "path/to/project" in Capfile.
+  #
+  # ==== Options
+  # +path+:: Relative path
+  # +check_exist+:: Whether to check its existence and throw error if not found
+  #
+  # ==== Examples
+  #   relative_to_root("config/foo.yml") => "path/to/project/config/foo.yml"
+  #
+  def relative_to_root(path = nil, check_exist = false)
+    if path
+      root_path = File.join(root, path)
+    else
+      root_path = root
+    end
+    
+    # Check for file existance
+    if check_exist and !File.exist?(root_path)
+      raise <<-EOS
+        
+        File not found: #{File.expand_path(root_path)}
+        
+        This is loaded for the capitate plugin. View the README in:
+        #{File.expand_path(File.dirname(__FILE__) + "/../doc/README")}
+      EOS
+    end
+    
+    root_path
+  end    
+  
+  # Usage for current task.
+  #
+  # ==== Options
+  # +variable+:: Missing variable setting (to display as not set)
+  #
+  # ==== Examples
+  #   usage(:gem_list) => "Description from task definition."
+  # 
+  def usage(variable = nil)
+    message = ""
+    
+    if variable
+      message += <<-EOS
+    
+      Error: :#{variable} not set.    
+      EOS
+    end
+    
+    if current_task
+      message += <<-EOS
+    
+    Usage: 
+    
+#{indent_doc(current_task.desc)}
+    
+      EOS
+    end
+    message
+  end
+  
+  # Indent string block.
+  #
+  # ==== Options
+  # +s+:: String block
+  # +amount+:: Amount to indent
+  #
+  def indent_doc(s, amount = 4)
+    return nil if s.blank?
+    indentation = (0..amount).collect { |n| " " }.join
+    s.split("\n").collect { |sp| "#{indentation}#{sp}"}.join("\n")
+  end
+  
+  # Unindent.
+  #
+  # Lifted from capistrano bin/capify
+  #
+  # ==== Options
+  # +string+:: String to unindent
+  #
+  def unindent(string)
+    return "" if string.blank?
+    if string =~ /\A(\s*)/
+      amount = $1.length
+      return string.strip.gsub(/^#{$1}/, "")
+    end
+    string
+  end  
+  
+  # Load all tasks into an array.
+  def load_all_tasks
+    tasks = []
+    top.namespaces.each do |namespace|
+      load_tasks(namespace, tasks)
+    end
+    tasks
+  end
+  
+  # Build a task tree, consisting of task nodes.  
+  def task_tree
+    top_node = Capitate::TaskNode.new("top")
+    
+    load_all_tasks.each do |task|
+      Capitate::TaskNode.populate_with_task(top_node, task)
+    end
+    top_node
+  end
+
+protected
+    
+  def load_tasks(namespace, tasks = [])    
+    recipe = namespace.last
+    
+    recipe.namespaces.each do |nested_namespace|
+      load_tasks(nested_namespace, tasks)
+    end
+    
+    recipe.task_list.each do |task|
+      tasks << task
+    end
+  end
+    
+end
+
+Capistrano.plugin :capitate, Capitate::Plugins::Base