capistrano 2.15.11 → 3.0.0.pre

data/lib/capistrano/configuration/servers.rb

@@ -1,115 +1,63 @@
+require 'set'
 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))
-      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),
-      # an :except option (like :only, but the inverse), and a
-      # :skip_hostfilter option to ignore the HOSTFILTER environment variable
-      # described below.
-      #
-      # 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.
-      #
-      # Yet additionally, if the HOSTFILTER environment variable is set, it
-      # will limit the result to hosts found in that (comma-separated) list.
-      #
-      # If the HOSTROLEFILTER environment variable is set, it will limit the
-      # result to hosts found in that (comma-separated) list of roles
-      #
-      # 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={})
-        return [] if options.key?(:hosts) && (options[:hosts].nil? || [] == options[:hosts])
-        return [] if options.key?(:roles) && (options[:roles].nil? || [] == options[:roles])
-
-        hosts  = server_list_from(ENV['HOSTS'] || options[:hosts])
+    class Servers
+      include Enumerable
 
-        if hosts.any?
-          if options[:skip_hostfilter]
-            hosts.uniq
-          else
-            filter_server_list(hosts.uniq)
+      def add_host(host, properties = {})
+        find_or_create_server(host).tap do |host|
+          Array(properties.delete(:roles) || properties.delete("roles")).each do |role|
+            host.add_role(role)
           end
-        else
-          roles = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
-          roles = roles & Array(options[:roles]) if preserve_roles && !options[:roles].nil?
+          properties.each do |key, value|
+            unless host.properties.respond_to?(key)
+              host.properties.send(:"#{key}=", value)
+            end
+          end
+          servers.add host
+        end
+      end
+
+      def add_role(role, hosts)
+        Array(hosts).each do |host|
+          server = find_or_create_server(host)
+          server.add_role(role)
+          servers.add server
+        end
+      end
 
-          only   = options[:only] || {}
-          except = options[:except] || {}
+      def fetch_roles(names)
+        roles_for(names)
+      end
 
-          # If we don't have a def for a role it means its bogus, skip it so higher level can handle
-          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 } }
+      def fetch_primary(role)
+        fetch(role).select { |h| h.properties.primary }.first || fetch(role).first
+      end
 
-          if options[:skip_hostfilter]
-            servers.uniq
-          else
-            filter_server_list(servers.uniq)
-          end
-        end
+      def each
+        servers.each { |server| yield server }
       end
 
-    protected
+      private
 
-      def filter_server_list(servers)
-        return servers unless ENV['HOSTFILTER'] or ENV['HOSTROLEFILTER']
-        if ENV['HOSTFILTER']
-          filters = ENV['HOSTFILTER'].split(/,/)
-          servers.select { |server| filters.include?(server.host) }
-        elsif ENV['HOSTROLEFILTER']
-          filters = ENV['HOSTROLEFILTER'].split(/,/).map do |role|
-            local_roles = roles[role.to_sym]
-            if local_roles.is_a? Array
-              roles[role.to_sym]
-            else
-              roles[role.to_sym].servers
-            end
-          end.flatten
-          servers.select { |server| filters.include?(server) }
-        end
+      def find_or_create_server(host)
+        servers.find { |server| server.matches?(host) } || Server.new(host)
       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(name)
+        servers.find_all { |server| server.has_role? name }
       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
-          role
+      def roles_for(names)
+        if Array(names).map(&:to_sym).include?(:all)
+          servers
+        else
+          Array(names).flat_map { |name| fetch name }.uniq
         end
       end
 
-      def build_list(list)
-        Array(list).map { |item| item.respond_to?(:call) ? item.call : item }.flatten
+      def servers
+        @servers ||= Set.new
       end
     end
   end

data/lib/capistrano/configuration.rb

@@ -1,57 +1,94 @@
-require 'capistrano/logger'
-
-require 'capistrano/configuration/alias_task'
-require 'capistrano/configuration/callbacks'
-require 'capistrano/configuration/connections'
-require 'capistrano/configuration/execution'
-require 'capistrano/configuration/loading'
-require 'capistrano/configuration/log_formatters'
-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 :debug, :logger, :dry_run, :preserve_roles
 
-    def initialize(options={}) #:nodoc:
-      @debug = false
-      @dry_run = false
-      @preserve_roles = false
-      @logger = Logger.new(options)
+    class << self
+      def env
+        @env ||= new
+      end
     end
 
-    # make the DSL easier to read when using lazy evaluation via lambdas
-    alias defer lambda
+    def ask(key, default=nil)
+      question = Question.new(self, key, default)
+      set(key, question)
+    end
+
+    def set(key, value)
+      config[key] = value
+    end
+
+    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
+
+    def role(name, hosts)
+      servers.add_role(name, hosts)
+    end
+
+    def server(name, properties = {})
+      servers.add_host(name, properties)
+    end
+
+    def roles_for(names, options = {})
+      servers.fetch_roles(names).tap do |list|
+        if filter = options.delete(:filter) || options.delete(:select)
+          if filter.respond_to?(:call)
+            list.select!(&filter)
+          else
+            list.select! { |s| s.properties.send(filter) }
+          end
+          if list.empty?
+            raise "Your filter #{filter} would remove all matching servers!"
+          end
+        end
+      end
+    end
+
+    def primary(role)
+      servers.fetch_primary(role)
+    end
+
+    def configure_backend
+      SSHKit.configure do |sshkit|
+        sshkit.format           = fetch(:format)
+        sshkit.output_verbosity = fetch(:log_level)
+        sshkit.default_env      = fetch(:default_env)
+        sshkit.backend.configure do |backend|
+          backend.pty                = fetch(:pty)
+          backend.connection_timeout = fetch(:connection_timeout)
+        end
+      end
+    end
 
-    # The includes must come at the bottom, since they may redefine methods
-    # defined in the base class.
-    include AliasTask, Connections, Execution, Loading, LogFormatters, Namespaces, Roles, Servers, Variables
+    def timestamp
+      @timestamp ||= Time.now.utc
+    end
 
-    # Mix in the actions
-    include Actions::FileTransfer, Actions::Inspect, Actions::Invocation
+    private
 
-    # Must mix last, because it hooks into previously defined methods
-    include Callbacks
+    def servers
+      @servers ||= Servers.new
+    end
 
-    (self.instance_methods & Kernel.methods).select do |name|
-      # Select the instance methods owned by the Configuration class.
-      self.instance_method(name).owner.to_s.start_with?("Capistrano::Configuration")
-    end.select do |name|
-      # Of those, select methods that are being shadowed by the Kernel module in the Namespace class.
-      Namespaces::Namespace.method_defined?(name) && Namespaces::Namespace.instance_method(name).owner == Kernel
-    end.each do |name|
-      # Undefine the shadowed methods, since we want Namespace objects to defer handling to the Configuration object.
-      Namespaces::Namespace.send(:undef_method, name)
+    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
+
   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,11 @@
+set :scm, :git
+set :branch, :master
+set :deploy_to, "/var/www/#{fetch(:application)}"
+
+set :default_environment, {}
+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,57 @@
+module Capistrano
+  module DSL
+    module Env
+
+      def configure_backend
+        env.configure_backend
+      end
+
+      def fetch(key, default=nil)
+        env.fetch(key, default)
+      end
+
+      def any?(key)
+        value = fetch(key)
+        if value.respond_to?(:any)
+          value.any?
+        else
+          !fetch(key).nil?
+        end
+      end
+
+      def set(key, value)
+        env.set(key, value)
+      end
+
+      def ask(key, value)
+        env.ask(key, value)
+      end
+
+      def role(name, servers)
+        env.role(name, servers)
+      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
+

data/lib/capistrano/dsl/paths.rb

@@ -0,0 +1,74 @@
+require 'pathname'
+module Capistrano
+  module DSL
+    module Paths
+
+      def deploy_to
+        fetch(:deploy_to)
+      end
+
+      def deploy_path
+        Pathname.new(deploy_to)
+      end
+
+      def current_path
+        deploy_path.join('current')
+      end
+
+      def releases_path
+        deploy_path.join('releases')
+      end
+
+      def release_path
+        releases_path.join(release_timestamp)
+      end
+
+      def repo_path
+        deploy_path.join('repo')
+      end
+
+      def shared_path
+        deploy_path.join('shared')
+      end
+
+      def revision_log
+        deploy_path.join('revisions.log')
+      end
+
+      def release_timestamp
+        fetch(:rollback_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
+
+      def linked_dirs(parent)
+        paths = fetch(:linked_dirs)
+        join_paths(parent, paths)
+      end
+
+      def linked_files(parent)
+        paths = fetch(:linked_files)
+        join_paths(parent, paths)
+      end
+
+      def linked_file_dirs(parent)
+        map_dirnames(linked_files(parent))
+      end
+
+      def linked_dir_parents(parent)
+        map_dirnames(linked_dirs(parent))
+      end
+
+      def join_paths(parent, paths)
+        paths.map { |path| parent.join(path) }
+      end
+
+      def map_dirnames(paths)
+        paths.map { |path| path.dirname }
+      end
+    end
+  end
+end

data/lib/capistrano/dsl/stages.rb

@@ -0,0 +1,15 @@
+module Capistrano
+  module DSL
+    module Stages
+
+      def stages
+        Dir['config/deploy/*.rb'].map { |f| File.basename(f, '.rb') }
+      end
+
+      def stage_set?
+        !!fetch(:stage, false)
+      end
+
+    end
+  end
+end

data/lib/capistrano/dsl/task_enhancements.rb

@@ -0,0 +1,15 @@
+module Capistrano
+  module TaskEnhancements
+    def before(task, prerequisite, *args, &block)
+      prerequisite = Rake::Task.define_task(prerequisite, *args, &block) if block_given?
+      Rake::Task[task].enhance [prerequisite]
+    end
+
+    def after(task, post_task, *args, &block)
+      post_task = Rake::Task.define_task(post_task, *args, &block) if block_given?
+      Rake::Task[task].enhance do
+        invoke(post_task)
+      end
+    end
+  end
+end

data/lib/capistrano/dsl.rb

@@ -0,0 +1,38 @@
+require 'capistrano/dsl/task_enhancements'
+require 'capistrano/dsl/paths'
+require 'capistrano/dsl/stages'
+require 'capistrano/dsl/env'
+
+module Capistrano
+  module DSL
+    include TaskEnhancements
+    include Env
+    include Paths
+    include Stages
+
+    def invoke(task, *args)
+      Rake::Task[task].invoke(*args)
+    end
+
+    def t(key, options={})
+      I18n.t(key, options.merge(scope: :capistrano))
+    end
+
+    def scm
+      fetch(:scm)
+    end
+
+    def revision_log_message
+      fetch(:revision_log_message,
+            t(:revision_log_message, branch: fetch(:branch), user: local_user, release: release_timestamp))
+    end
+
+    def rollback_log_message
+      t(:rollback_log_message, user: local_user, release: release_timestamp)
+    end
+
+    def local_user
+      `whoami`
+    end
+  end
+end

data/lib/capistrano/git.rb

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

data/lib/capistrano/i18n.rb

@@ -0,0 +1,33 @@
+require 'i18n'
+
+en = {
+  starting:                    'Starting',
+  capified:                    'Capified',
+  starting:                    'Starting',
+  start:                       'Start',
+  update:                      'Update',
+  finalize:                    'Finalise',
+  restart:                     'Restart',
+  finishing:                   'Finishing',
+  finished:                    'Finished',
+  stage_not_set:               'Stage not set, please call something such as `cap production deploy`, where production is a stage you have defined.',
+  written_file:                'create %{file}',
+  question:                    'Please enter %{key}: |%{default_value}|',
+  keeping_releases:            'Keeping %{keep_releases} of %{releases} deployed releases',
+  linked_file_does_not_exist:  'linked file %{file} does not exist on %{host}',
+  mirror_exists:               "The repository mirror is at %{at}",
+  revision_log_message:        'Branch %{branch} deployed as release %{release} by %{user}',
+  rollback_log_message:        '%{user} rolled back to release %{release}',
+  console: {
+    welcome:  'capistrano console - enter command to execute on %{stage}',
+    bye:      'bye'
+  },
+  error: {
+    user: {
+      does_not_exist:  'User %{user} does not exists',
+      cannot_switch:   'Cannot switch to user %{user}'
+    }
+  }
+}
+
+I18n.backend.store_translations(:en, { capistrano: en })

data/lib/capistrano/install.rb

@@ -0,0 +1 @@
+load File.expand_path(File.join(File.dirname(__FILE__),'tasks/install.rake'))

data/lib/capistrano/setup.rb

@@ -0,0 +1,17 @@
+include Capistrano::DSL
+
+load 'capistrano/defaults.rb'
+
+stages.each do |stage|
+  Rake::Task.define_task(stage) do
+    load "config/deploy.rb"
+    load "config/deploy/#{stage}.rb"
+    load "capistrano/#{fetch(:scm)}.rb"
+    set(:stage, stage.to_sym)
+    I18n.locale = fetch(:locale, :en)
+    configure_backend
+  end
+end
+
+
+require 'capistrano/dotfile'

data/lib/capistrano/tasks/bundler.rake

@@ -0,0 +1,13 @@
+namespace :deploy do
+
+  desc 'Bundle'
+  task :bundle do
+    on roles :web do
+      within release_path do
+        execute :bundle, "--gemfile #{release_path}/Gemfile --deployment --binstubs #{shared_path}/bin --path #{shared_path}/bundle --without development test cucumber"
+      end
+    end
+  end
+
+  before :finalize, :bundle
+end

data/lib/capistrano/tasks/console.rake

@@ -0,0 +1,21 @@
+desc 'Execute remote commands'
+task :console do
+  stage = fetch(:stage)
+  puts I18n.t('console.welcome', scope: :capistrano, stage: stage)
+  loop do
+    print "#{stage}> "
+    command = $stdin.gets.chomp
+    if %w{quit exit q}.include? command
+      puts t('console.bye')
+      break
+    else
+      begin
+        on roles :all do
+          execute command
+        end
+      rescue => e
+        puts e
+      end
+    end
+  end
+end