capistrano 2.1.0 → 3.0.0

data/lib/capistrano/application.rb

@@ -0,0 +1,60 @@
+module Capistrano
+  class Application < Rake::Application
+
+    def initialize
+      super
+      @name = "cap"
+      @rakefiles = %w{capfile Capfile capfile.rb Capfile.rb} << capfile
+    end
+
+    def run
+      Rake.application = self
+      super
+    end
+
+    def sort_options(options)
+      options.push(version,dry_run)
+      super
+    end
+
+    def load_rakefile
+      @name = 'cap'
+      super
+    end
+
+    def top_level_tasks
+      if tasks_without_stage_dependency.include?(@top_level_tasks.first)
+        @top_level_tasks
+      else
+        @top_level_tasks.unshift(ensure_stage)
+      end
+    end
+
+    private
+
+    # allows the `cap install` task to load without a capfile
+    def capfile
+      File.expand_path(File.join(File.dirname(__FILE__),'..','Capfile'))
+    end
+
+    def version
+      ['--version', '-V',
+       "Display the program version.",
+       lambda { |value|
+         puts "Capistrano Version: #{Capistrano::VERSION} (Rake Version: #{RAKEVERSION})"
+         exit
+       }
+      ]
+    end
+
+    def dry_run
+      ['--dry-run', '-n',
+       "Do a dry run without executing actions",
+       lambda { |value|
+         Configuration.env.set(:sshkit_backend, SSHKit::Backend::Printer)
+       }
+      ]
+    end
+  end
+
+end

data/lib/capistrano/configuration/question.rb

@@ -0,0 +1,42 @@
+module Capistrano
+  class Configuration
+    class Question
+
+      def initialize(env, key, default)
+        @env, @key, @default = env, key, default
+      end
+
+      def call
+        ask_question
+        save_response
+      end
+
+      private
+      attr_reader :env, :key, :default
+
+      def ask_question
+        $stdout.puts question
+      end
+
+      def save_response
+        env.set(key, value)
+      end
+
+      def value
+        if response.empty?
+          default
+        else
+          response
+        end
+      end
+
+      def response
+        @response ||= $stdin.gets.chomp
+      end
+
+      def question
+        I18n.t(:question, key: key, default_value: default, scope: :capistrano)
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/server.rb

@@ -0,0 +1,133 @@
+require 'set'
+module Capistrano
+  class Configuration
+    class Server < SSHKit::Host
+      extend Forwardable
+      def_delegators :properties, :roles, :fetch, :set
+
+      def add_roles(roles)
+        Array(roles).each { |role| add_role(role) }
+      end
+      alias roles= add_roles
+
+      def add_role(role)
+        roles.add role.to_sym
+      end
+
+      def has_role?(role)
+        roles.include? role.to_sym
+      end
+
+      def matches?(host)
+        hostname == Server.new(host).hostname
+      end
+
+      def select?(options)
+        selector = Selector.new(options)
+        selector.call(self)
+      end
+
+      def primary
+        self if fetch(:primary)
+      end
+
+      def with(properties)
+        properties.each { |key, value| add_property(key, value) }
+        self
+      end
+
+      def properties
+        @properties ||= Properties.new
+      end
+
+      def netssh_options_with_options
+        @netssh_options ||= netssh_options_without_options.merge( fetch(:ssh_options) || {} )
+      end
+      alias_method :netssh_options_without_options, :netssh_options
+      alias_method :netssh_options, :netssh_options_with_options
+
+      def roles_array
+        roles.to_a
+      end
+
+      private
+
+      def add_property(key, value)
+        if respond_to?("#{key}=")
+          send("#{key}=", value)
+        else
+          set(key, value)
+        end
+      end
+
+      class Properties
+
+        def initialize
+          @properties = {}
+        end
+
+        def set(key, value)
+          @properties[key] = value
+        end
+
+        def fetch(key)
+          @properties[key]
+        end
+
+        def respond_to?(method)
+          @properties.has_key?(method)
+        end
+
+        def roles
+          @roles ||= Set.new
+        end
+
+        def method_missing(key, value=nil)
+          if value
+            set(lvalue(key), value)
+          else
+            fetch(key)
+          end
+        end
+
+        private
+
+        def lvalue(key)
+          key.to_s.chomp('=').to_sym
+        end
+
+      end
+
+      class Selector
+        def initialize(options)
+          @options = options
+        end
+
+        def callable
+          if key.respond_to?(:call)
+            key
+          else
+            ->(server) { server.fetch(key) }
+          end
+        end
+
+        def call(server)
+          callable.call(server)
+        end
+
+        private
+        attr_reader :options
+
+        def key
+          options[:filter] || options[:select] || all
+        end
+
+        def all
+          ->(server) { :all }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/capistrano/configuration/servers/role_filter.rb

@@ -0,0 +1,86 @@
+module Capistrano
+  class Configuration
+    class Servers
+      class RoleFilter
+
+        def initialize(required, available)
+          @required, @available = required, available
+        end
+
+        def self.for(required, available)
+          new(required, available).roles
+        end
+
+        def roles
+          if required.include?(:all)
+            available
+          else
+            required.select { |name| available.include? name }
+          end
+        end
+
+        private
+
+        def required
+          Array(@required).flat_map(&:to_sym)
+        end
+
+        def available
+          if role_filter.any?
+            role_filter
+          else
+            @available
+          end
+        end
+
+        def role_filter
+          env_filter | configuration_filter
+        end
+
+        def configuration_filter
+          ConfigurationFilter.new.roles
+        end
+
+        def env_filter
+          EnvFilter.new.roles
+        end
+
+        class ConfigurationFilter
+
+          def roles
+            if filter
+              Array(filter.fetch(:roles, [])).map(&:to_sym)
+            else
+              []
+            end
+          end
+
+          def config
+            Configuration.env
+          end
+
+          def filter
+            config.fetch(:filter) || config.fetch(:select)
+          end
+        end
+
+
+        class EnvFilter
+
+          def roles
+            if filter
+              filter.split(',').map(&:to_sym)
+            else
+              []
+            end
+          end
+
+          def filter
+            ENV['ROLES']
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/capistrano/configuration/servers.rb

@@ -1,75 +1,70 @@
+require 'set'
+require_relative 'servers/role_filter'
 module Capistrano
   class Configuration
-    module Servers
-      # Identifies all servers that the given task should be executed on.
-      # The options hash accepts the same arguments as #find_servers, and any
-      # preexisting options there will take precedence over the options in
-      # the task.
-      def find_servers_for_task(task, options={})
-        find_servers(task.options.merge(options))
+    class Servers
+      include Enumerable
+
+      def add_host(host, properties={})
+        servers.add server(host).with(properties)
+      end
+
+      def add_role(role, hosts, options={})
+        Array(hosts).each { |host| add_host(host, options.merge(roles: role)) }
+      end
+
+      def roles_for(names)
+        options = extract_options(names)
+        fetch_roles(names, options)
+      end
+
+      def fetch_primary(role)
+        hosts = fetch(role)
+        hosts.find(&:primary) || hosts.first
+      end
+
+      def each
+        servers.each { |server| yield server }
       end
 
-      # Attempts to find all defined servers that match the given criteria.
-      # The options hash may include a :hosts option (which should specify
-      # an array of host names or ServerDefinition instances), a :roles
-      # option (specifying an array of roles), an :only option (specifying
-      # a hash of key/value pairs that any matching server must match), and
-      # an :exception option (like :only, but the inverse).
-      #
-      # Additionally, if the HOSTS environment variable is set, it will take
-      # precedence over any other options. Similarly, the ROLES environment
-      # variable will take precedence over other options. If both HOSTS and
-      # ROLES are given, HOSTS wins.
-      #
-      # Usage:
-      #
-      #   # return all known servers
-      #   servers = find_servers
-      #
-      #   # find all servers in the app role that are not exempted from
-      #   # deployment
-      #   servers = find_servers :roles => :app,
-      #                :except => { :no_release => true }
-      #
-      #   # returns the given hosts, translated to ServerDefinition objects
-      #   servers = find_servers :hosts => "jamis@example.host.com"
-      def find_servers(options={})
-        hosts  = server_list_from(ENV['HOSTS'] || options[:hosts])
-        roles  = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
-        only   = options[:only] || {}
-        except = options[:except] || {}
+      private
 
-        if hosts.any?
-          hosts.uniq
+      def server(host)
+        if host.is_a? Server
+          host
         else
-          servers = roles.inject([]) { |list, role| list.concat(self.roles[role]) }
-          servers = servers.select { |server| only.all? { |key,value| server.options[key] == value } }
-          servers = servers.reject { |server| except.any? { |key,value| server.options[key] == value } }
-          servers.uniq
+          servers.find { |server| server.matches?(host) } || Server.new(host)
         end
       end
 
-    protected
+      def fetch(role)
+        servers.find_all { |server| server.has_role? role}
+      end
 
-      def server_list_from(hosts)
-        hosts = hosts.split(/,/) if String === hosts
-        hosts = build_list(hosts)
-        hosts.map { |s| String === s ? ServerDefinition.new(s.strip) : s }
+      def fetch_roles(required, options)
+        filter_roles = RoleFilter.for(required, available_roles)
+        select(servers_with_roles(filter_roles), options)
       end
 
-      def role_list_from(roles)
-        roles = roles.split(/,/) if String === roles
-        roles = build_list(roles)
-        roles.map do |role|
-          role = String === role ? role.strip.to_sym : role
-          raise ArgumentError, "unknown role `#{role}'" unless self.roles.key?(role)
-          role
-        end
+      def servers_with_roles(roles)
+        roles.flat_map { |role| fetch role }.uniq
+      end
+
+      def select(servers, options)
+        servers.select { |server| server.select?(options) }
+      end
+
+      def available_roles
+        servers.flat_map { |server| server.roles_array }.uniq
+      end
+
+      def servers
+        @servers ||= Set.new
       end
 
-      def build_list(list)
-        Array(list).map { |item| item.respond_to?(:call) ? item.call : item }.flatten
+      def extract_options(array)
+        array.last.is_a?(::Hash) ? array.pop : {}
       end
     end
   end
-end
+end

data/lib/capistrano/configuration.rb

@@ -1,41 +1,95 @@
-require 'capistrano/logger'
-
-require 'capistrano/configuration/callbacks'
-require 'capistrano/configuration/connections'
-require 'capistrano/configuration/execution'
-require 'capistrano/configuration/loading'
-require 'capistrano/configuration/namespaces'
-require 'capistrano/configuration/roles'
-require 'capistrano/configuration/servers'
-require 'capistrano/configuration/variables'
-
-require 'capistrano/configuration/actions/file_transfer'
-require 'capistrano/configuration/actions/inspect'
-require 'capistrano/configuration/actions/invocation'
+require_relative 'configuration/question'
+require_relative 'configuration/servers'
+require_relative 'configuration/server'
 
 module Capistrano
-  # Represents a specific Capistrano configuration. A Configuration instance
-  # may be used to load multiple recipe files, define and describe tasks,
-  # define roles, and set configuration variables.
   class Configuration
-    # The logger instance defined for this configuration.
-    attr_accessor :logger
 
-    def initialize #:nodoc:
-      @logger = Logger.new
+    class << self
+      def env
+        @env ||= new
+      end
+    end
+
+    def ask(key, default=nil)
+      question = Question.new(self, key, default)
+      set(key, question)
     end
 
-    # make the DSL easier to read when using lazy evaluation via lambdas
-    alias defer lambda
+    def set(key, value)
+      config[key] = value
+    end
+
+    def delete(key)
+      config.delete(key)
+    end
 
-    # The includes must come at the bottom, since they may redefine methods
-    # defined in the base class.
-    include Connections, Execution, Loading, Namespaces, Roles, Servers, Variables
+    def fetch(key, default=nil, &block)
+      value = fetch_for(key, default, &block)
+      if value.respond_to?(:call)
+        set(key, value.call)
+      else
+        value
+      end
+    end
 
-    # Mix in the actions
-    include Actions::FileTransfer, Actions::Inspect, Actions::Invocation
+    def role(name, hosts, options={})
+      servers.add_role(name, hosts, options)
+    end
+
+    def server(name, properties={})
+      servers.add_host(name, properties)
+    end
+
+    def roles_for(names)
+      servers.roles_for(names)
+    end
+
+    def primary(role)
+      servers.fetch_primary(role)
+    end
+
+    def backend
+      @backend ||= SSHKit
+    end
+
+    attr_writer :backend
+
+    def configure_backend
+      backend.configure do |sshkit|
+        sshkit.format           = fetch(:format)
+        sshkit.output_verbosity = fetch(:log_level)
+        sshkit.default_env      = fetch(:default_env)
+        sshkit.backend          = fetch(:sshkit_backend, SSHKit::Backend::Netssh)
+        sshkit.backend.configure do |backend|
+          backend.pty                = fetch(:pty)
+          backend.connection_timeout = fetch(:connection_timeout)
+          backend.ssh_options        = fetch(:ssh_options) if fetch(:ssh_options)
+        end
+      end
+    end
+
+    def timestamp
+      @timestamp ||= Time.now.utc
+    end
+
+    private
+
+    def servers
+      @servers ||= Servers.new
+    end
+
+    def config
+      @config ||= Hash.new
+    end
+
+    def fetch_for(key, default, &block)
+      if block_given?
+        config.fetch(key, &block)
+      else
+        config.fetch(key, default)
+      end
+    end
 
-    # Must mix last, because it hooks into previously defined methods
-    include Callbacks
   end
 end

data/lib/capistrano/console.rb

@@ -0,0 +1 @@
+load File.expand_path("../tasks/console.rake", __FILE__)

data/lib/capistrano/defaults.rb

@@ -0,0 +1,13 @@
+set :scm, :git
+set :branch, :master
+set :deploy_to, "/var/www/#{fetch(:application)}"
+set :tmp_dir, "/tmp"
+
+set :default_env, {}
+set :keep_releases, 5
+
+set :format, :pretty
+set :log_level, :debug
+
+set :pty, true
+

data/lib/capistrano/deploy.rb

@@ -0,0 +1,3 @@
+load File.expand_path("../tasks/framework.rake", __FILE__)
+load File.expand_path("../tasks/deploy.rake", __FILE__)
+require 'capistrano/install'

data/lib/capistrano/dotfile.rb

@@ -0,0 +1,3 @@
+dotfile = Pathname.new(File.join(Dir.home, '.capfile'))
+load dotfile if dotfile.file?
+

data/lib/capistrano/dsl/env.rb

@@ -0,0 +1,64 @@
+module Capistrano
+  module DSL
+    module Env
+
+      def configure_backend
+        env.configure_backend
+      end
+
+      def fetch(key, default=nil, &block)
+        env.fetch(key, default, &block)
+      end
+
+      def any?(key)
+        value = fetch(key)
+        if value && value.respond_to?(:any?)
+          value.any?
+        else
+          !fetch(key).nil?
+        end
+      end
+
+      def set(key, value)
+        env.set(key, value)
+      end
+
+      def delete(key)
+        env.delete(key)
+      end
+
+      def ask(key, value)
+        env.ask(key, value)
+      end
+
+      def role(name, servers, options={})
+        env.role(name, servers, options)
+      end
+
+      def server(name, properties={})
+        env.server(name, properties)
+      end
+
+      def roles(*names)
+        env.roles_for(names)
+      end
+
+      def primary(role)
+        env.primary(role)
+      end
+
+      def env
+        Configuration.env
+      end
+
+      def release_timestamp
+        env.timestamp.strftime("%Y%m%d%H%M%S")
+      end
+
+      def asset_timestamp
+        env.timestamp.strftime("%Y%m%d%H%M.%S")
+      end
+
+    end
+  end
+end