dkdeploy-core 8.0.0

data/lib/dkdeploy/tasks/deploy.rake

@@ -0,0 +1,77 @@
+require 'dkdeploy/dsl'
+
+include Capistrano::DSL
+include Dkdeploy::DSL
+include Dkdeploy::RollbackManager
+
+namespace :deploy do
+  desc 'Generate the new release path name'
+  task :new_release_path do
+    jenkins_suffix = ''
+    # Add jenkins build name and number to release path
+    if ENV['BUILD_TAG']
+      jenkins_suffix = "-#{ENV['JOB_NAME']}-#{ENV['BUILD_NUMBER']}"
+    end
+    set_release_path releases_path.join(Time.now.utc.strftime('%Y-%m-%d-%H-%M-%S') + jenkins_suffix)
+  end
+
+  desc 'Handle deployment errors'
+  task :failed do
+    # Rollback tasks. Reverse sorting for rollback
+    tasks_for_rollback = rollback_tasks.reverse
+
+    run_locally do
+      error I18n.t('error_during_deployment', scope: :dkdeploy)
+    end
+
+    # Check if symlink is created at host
+    on release_roles(:all) do |host|
+      if test "[ `readlink #{current_path}` == #{release_path} ]"
+        invoke_for_server host, 'deploy:revert_release'
+        invoke_for_server host, 'deploy:symlink:release'
+      end
+    end
+    # Backup and remove last release
+    invoke 'deploy:cleanup_rollback'
+
+    run_locally do
+      error I18n.t('rollback_tasks', tasks_for_rollback: tasks_for_rollback.join(', '), scope: :dkdeploy) unless tasks_for_rollback.empty?
+    end
+
+    # Call rollback task after reset release
+    tasks_for_rollback.each do |task_name|
+      next unless Rake::Task.task_defined? task_name
+
+      # call rollback task
+      Rake::Task[task_name].reenable
+      invoke task_name
+    end
+
+    run_locally do
+      error I18n.t('rollback_finished', scope: :dkdeploy)
+    end
+  end
+
+  desc 'Remove and archive rolled-back release'
+  task :cleanup_rollback do
+    # Only keep x rolled-back releases as archive
+    on release_roles(:all) do
+      begin
+        rollback_archives = capture(:ls, '-x', deploy_path.join('rolled-back-release-*.tar.gz')).split
+      rescue
+        rollback_archives = []
+      end
+
+      next if rollback_archives.count <= fetch(:keep_rollback_archives)
+      info I18n.t('keep_rollback_archives',
+                  scope: :dkdeploy,
+                  host: host.to_s,
+                  keep_rollback_archives: fetch(:keep_rollback_archives),
+                  rollback_archives: rollback_archives.count)
+
+      list_of_deleteable_directories = rollback_archives - rollback_archives.last(fetch(:keep_rollback_archives))
+      string_of_deleteable_directories = list_of_deleteable_directories.map { |rollback_archive| current_path.join(rollback_archive) }.join(' ')
+      execute :rm, '-rf', string_of_deleteable_directories
+    end
+  end
+end

data/lib/dkdeploy/tasks/enhanced_symlinks.rake

@@ -0,0 +1,74 @@
+include Capistrano::DSL
+
+namespace :deploy do
+  namespace :enhanced_symlinks do
+    namespace :check do
+      desc "Check directories to be linked exist in shared using the given hash 'enhanced_linked_dirs'"
+      task :linked_dirs do
+        next unless any? :enhanced_linked_dirs
+        fetch(:enhanced_linked_dirs).each do |source, _|
+          on release_roles :all do
+            execute :mkdir, '-pv', shared_path.join(source)
+          end
+        end
+      end
+
+      desc "Check directories of files to be linked exist in shared using the given hash 'enhanced_linked_files'"
+      task :make_linked_dirs do
+        next unless any? :enhanced_linked_files
+        fetch(:enhanced_linked_files).each do |_, target|
+          on release_roles :all do
+            execute :mkdir, '-pv', shared_path.join(target).dirname
+          end
+        end
+      end
+
+      desc "Check files to be linked exist in shared using the given hash 'enhanced_linked_files'"
+      task :linked_files do
+        next unless any? :enhanced_linked_files
+        fetch(:enhanced_linked_files).each do |source, _|
+          on release_roles :all do |host|
+            unless test "[ -f #{shared_path.join source} ]"
+              error t(:linked_file_does_not_exist, file: source, host: host)
+              exit 1
+            end
+          end
+        end
+      end
+    end
+
+    namespace :symlink do
+      desc "Symlink linked directories using the given hash 'enhanced_linked_dirs'"
+      task :linked_dirs do
+        next unless any? :enhanced_linked_dirs
+        fetch(:enhanced_linked_dirs).each do |source, target|
+          target = release_path.join(target)
+          source = shared_path.join(source)
+          on release_roles :all do
+            execute :mkdir, '-pv', target.dirname
+            unless test "[ -L #{target} ]"
+              execute :rm, '-rf', target if test "[ -d #{target} ]"
+              execute :ln, '-s', source, target
+            end
+          end
+        end
+      end
+
+      desc "Symlink linked files using the given hash 'enhanced_linked_files'"
+      task :linked_files do
+        next unless any? :enhanced_linked_files
+        fetch(:enhanced_linked_files).each do |source, target|
+          target = release_path.join(target)
+          source = shared_path.join(source)
+          on release_roles :all do
+            execute :mkdir, '-pv', target.dirname
+            unless test "[ -L #{target} ]"
+              execute :rm, target if test "[ -f #{target} ]"
+              execute :ln, '-s', source, target
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dkdeploy/tasks/fail.rake

@@ -0,0 +1,8 @@
+include Capistrano::DSL
+
+namespace :deploy do
+  desc 'Deployment task which fails every time'
+  task :fail do
+    raise I18n.t('failing_on_purpose', scope: :dkdeploy)
+  end
+end

data/lib/dkdeploy/tasks/file_access.rake

@@ -0,0 +1,89 @@
+require 'capistrano/i18n'
+require 'dkdeploy/i18n'
+require 'dkdeploy/helpers/file_system'
+
+include Capistrano::DSL
+include SSHKit::DSL
+include Dkdeploy::Helpers::FileSystem
+
+namespace :file_access do
+  desc 'Set standard defined owner and group on the shared and release path'
+  task set_owner_group: [:set_owner_group_of_shared_path, :set_owner_group_of_release_path]
+
+  desc 'Set standard defined owner and group on the shared path'
+  task :set_owner_group_of_shared_path do
+    on release_roles :app do
+      paths = merge_paths_with_resolved_symlinks self, shared_path
+      execute :chown, "#{fetch(:default_file_access_owner_of_shared_path)}:#{fetch(:default_file_access_group_of_shared_path)}", paths
+    end
+  end
+
+  desc 'Set recursively standard defined owner and group on the release path'
+  task :set_owner_group_of_release_path do
+    on release_roles :app do
+      paths = merge_paths_with_resolved_symlinks self, release_path
+      execute :chown, '-R', "#{fetch(:default_file_access_owner_of_release_path)}:#{fetch(:default_file_access_group_of_release_path)}", paths
+    end
+  end
+
+  desc 'Set standard defined file permissions on the shared and release path'
+  task set_permissions: [:set_permissions_of_shared_path, :set_permissions_of_release_path]
+
+  desc 'Set standard defined file permissions on the shared path'
+  task :set_permissions_of_shared_path do
+    on release_roles :app do
+      paths = merge_paths_with_resolved_symlinks self, shared_path
+      execute :chmod, fetch(:default_file_access_mode_of_shared_path), paths
+    end
+  end
+
+  desc 'Set recursively standard defined file permissions on the release path'
+  task :set_permissions_of_release_path do
+    on release_roles :app do
+      paths = merge_paths_with_resolved_symlinks self, release_path
+      execute :chmod, '-R', fetch(:default_file_access_mode_of_release_path), paths
+    end
+  end
+
+  desc 'Set custom defined owner, group and mode on paths'
+  task :set_custom_access do
+    fetch(:custom_file_access, {}).each do |role, paths_hash|
+      on release_roles role do |host|
+        release_or_shared_paths = paths_hash.select { |k, _| [:release_path, :shared_path].include? k } # allow only :release_path and :shared_path entries
+        release_or_shared_paths.each do |release_or_shared_path, paths|
+          paths.each do |path, access_properties|
+            path = map_path_in_release_or_shared_path(release_or_shared_path, path.to_s) # build absolute path
+            apply_file_access_permissions(self, host, path, access_properties)
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Set custom defined owner, group and mode on paths positively selected by a list of paths'
+  task :set_selected_custom_access, :selected_custom_file_access do |_, args|
+    list_of_selected_paths = ask_array_variable(args, :selected_custom_file_access, 'questions.selected_custom_file_access.paths')
+    if list_of_selected_paths.empty?
+      run_locally do
+        error I18n.t('resource.empty_selected_custom_file_access', scope: :dkdeploy)
+        exit 1
+      end
+    end
+
+    fetch(:custom_file_access, {}).each do |role, paths_hash|
+      on release_roles role do |host|
+        release_or_shared_paths = paths_hash.select { |k, _| [:release_path, :shared_path].include? k } # allow only :release_path and :shared_path entries
+        release_or_shared_paths.each do |release_or_shared_path, paths|
+          paths.each do |path, access_properties|
+            unless list_of_selected_paths.include?(path)
+              info I18n.t('resource.skipping_selected_custom_file_access', path: path, scope: :dkdeploy)
+              next
+            end
+            path = map_path_in_release_or_shared_path(release_or_shared_path, path.to_s) # build absolute path
+            apply_file_access_permissions(self, host, path, access_properties, true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dkdeploy/tasks/maintenance.rake

@@ -0,0 +1,73 @@
+require 'json'
+require 'i18n'
+require 'dkdeploy/i18n'
+require 'sshkit/dsl'
+require 'capistrano/dsl'
+
+include Capistrano::DSL
+include SSHKit::DSL
+include Dkdeploy::RollbackManager
+
+namespace :maintenance do
+  # Remote maintenance config file path
+  #
+  # @return [String]
+  def maintenance_config_file_path
+    File.join shared_path, 'config/maintenance.json'
+  end
+
+  desc 'Enables the maintenance mode. In a regular case it should be disabled after deployment.'
+  task :enable do
+    # Define rollback behaviour
+    add_rollback_task 'maintenance:disable'
+
+    on release_roles :app, :web do
+      # create remote maintenance config file (and directory if not exists)
+      execute :mkdir, '-p', File.dirname(maintenance_config_file_path)
+      content_json = JSON.pretty_generate enabled_permanent: false
+      # scp-net::upload! expects StringIO object
+      content = StringIO.new content_json
+      upload! content, maintenance_config_file_path
+      info I18n.t('tasks.maintenance.enabled', mode: 'regular', scope: :dkdeploy)
+    end
+  end
+
+  desc "Enables the maintenance permanent mode. The 'maintenance:disable' will require 'maintenance:disable_permanent'."
+  task :enable_permanent do
+    invoke 'maintenance:enable'
+    on release_roles :app, :web do
+      content_json = JSON.pretty_generate enabled_permanent: true
+      # scp-net::upload! expects StringIO object
+      content = StringIO.new content_json
+      upload! content, maintenance_config_file_path
+      info I18n.t('tasks.maintenance.enabled', mode: 'permanent', scope: :dkdeploy)
+    end
+  end
+
+  desc "Disables the maintenance mode, if the 'maintenance:enabled_permanent' has not been enabled."
+  task :disable do
+    on release_roles :app, :web do
+      # noinspection RubyArgCount
+      if test %([ -f "#{maintenance_config_file_path}" ])
+        if test "[ -s #{maintenance_config_file_path} ]"
+          config_file_content = download! maintenance_config_file_path
+          config_file_content = JSON.parse config_file_content
+          if config_file_content.fetch 'enabled_permanent'
+            warn I18n.t('tasks.maintenance.can_not_disable_by_reason_of_permanent', scope: :dkdeploy)
+            next
+          end
+        end
+        execute :rm, '-f', maintenance_config_file_path
+      end
+      info I18n.t('tasks.maintenance.disabled', mode: 'regular', scope: :dkdeploy)
+    end
+  end
+
+  desc "Disables the maintenance permanent mode. The 'maintenance:disable' will work in a regular way again."
+  task :disable_permanent do
+    on release_roles :app, :web do
+      execute :rm, '-f', maintenance_config_file_path
+      info I18n.t('tasks.maintenance.disabled', mode: 'permanent', scope: :dkdeploy)
+    end
+  end
+end

data/lib/dkdeploy/tasks/project_version.rake

@@ -0,0 +1,32 @@
+require 'capistrano/i18n'
+require 'dkdeploy/i18n'
+require 'dkdeploy/constants'
+
+include Capistrano::DSL
+include SSHKit::DSL
+
+namespace :project_version do
+  desc 'Update Version file on server'
+  task :update, :version_file_path do |_, args|
+    version_file_path = ask_variable(args, :version_file_path, 'questions.version_file_path')
+    remote_version_file = File.join release_path, version_file_path, 'Version'
+    local_version_file = 'Version'
+
+    unless File.exist? local_version_file # check if the local version file exists
+      run_locally do
+        error I18n.t('file.not_exists', file: local_version_file, scope: :dkdeploy)
+        exit 1
+      end
+    end
+
+    on release_roles :app do
+      info I18n.t('tasks.project_version.update.update', scope: :dkdeploy)
+      # remove the to be replaced remote version file
+      if test " [ -f #{remote_version_file} ] "
+        execute :rm, '-f', remote_version_file
+      end
+      # upload the current version file
+      upload! local_version_file, remote_version_file
+    end
+  end
+end

data/lib/dkdeploy/tasks/utils.rake

@@ -0,0 +1,141 @@
+require 'capistrano/i18n'
+require 'dkdeploy/i18n'
+
+include Capistrano::DSL
+include SSHKit::DSL
+
+namespace :utils do
+  desc 'Get current webroot path in releases'
+  task :get_current_path do
+    on primary :app do
+      info capture :readlink, '-f', current_path
+    end
+  end
+
+  desc 'Upload a file to current stage.'
+  task :upload_file, :file_name do |_, args|
+    file_name = ask_variable(args, :file_name, 'questions.file_name')
+    run_locally do
+      if file_name.empty?
+        error I18n.t('configuration.argument_missing', name: 'file_name', scope: :dkdeploy)
+        exit 1
+      end
+      # noinspection RubyArgCount
+      unless test "[ -f #{file_name} ]"
+        error I18n.t('file.not_exists', file: file_name, scope: :dkdeploy)
+        exit 1
+      end
+    end
+    regular_expression = "^#{fetch(:copy_source)}"
+    server_filename = File.join current_path, file_name.sub(Regexp.new(regular_expression), '')
+    on roles :app, :web do
+      directory_name = File.dirname server_filename
+      # noinspection RubyArgCount
+      unless test "[ -d #{directory_name} ]"
+        info I18n.t('directory.create', directory: directory_name, scope: :dkdeploy)
+        execute :mkdir, '-p', directory_name
+      end
+      info I18n.t('file.upload', file: file_name, target: server_filename, scope: :dkdeploy)
+      upload! file_name, server_filename
+    end
+  end
+
+  desc 'Download a file to current stage.'
+  task :download_file, :download_filename do |_, args|
+    filename = ask_variable(args, :download_filename, 'questions.file_name')
+    if filename.empty?
+      run_locally do
+        error I18n.t('configuration.argument_missing', name: 'download_filename', scope: :dkdeploy)
+        exit 1
+      end
+    end
+    remote_filename = File.join current_path, filename
+    on roles :app, :web do |server|
+      # noinspection RubyArgCount
+      unless test "[ -f #{remote_filename} ]"
+        error I18n.t('file.not_exists', file: remote_filename, scope: :dkdeploy)
+        next
+      end
+      local_filename = File.join local_dump_path, "#{File.basename(filename, '.*')}.#{server.hostname}#{File.extname(filename)}"
+      info I18n.t('file.download', file: remote_filename, target: local_filename, scope: :dkdeploy)
+      download! remote_filename, local_filename
+    end
+  end
+
+  desc 'Watch file on server'
+  task :watch_file, :file_name do |_, args|
+    file_name = args[:file_name] || fetch(:watch_file_name)
+    on roles :all do |host|
+      unless file_name
+        error I18n.t('configuration.argument_or_configuration_missing', name: 'file_name', variable: 'watch_file_name', scope: :dkdeploy)
+        exit 1
+      end
+      # noinspection RubyArgCount
+      if test " [ -f #{file_name} ] "
+        execute :tail, '-f', file_name
+      else
+        warn I18n.t('file.not_exists_on_host', file: file_name, host: host.hostname, scope: :dkdeploy)
+      end
+    end
+  end
+
+  desc 'Copy data to server with rsync'
+  task :rsync do
+    # Define local variables
+    rsync_roles = fetch :rsync_roles, :app
+    rsync_exclude = fetch :rsync_exclude, []
+    rsync_path = fetch :rsync_path, fetch(:copy_source)
+    # Append '/' to source directory
+    rsync_path = File.join(rsync_path, '')
+
+    rsync_command = %w(--verbose --recursive --perms --times --perms --perms --compress --force --cvs-exclude)
+
+    # Build exclude parameter
+    rsync_exclude.each do |exclude|
+      rsync_command << '--exclude "' + exclude + '"'
+    end
+    # Add local source directory
+    rsync_command << rsync_path
+
+    capistrano_ssh_option = fetch(:ssh_options, {})
+
+    run_locally do
+      # Fetch hosts for rsync command
+      hosts = roles rsync_roles
+      if hosts.empty?
+        error I18n.t('tasks.utils.rsync.no_host', scope: :dkdeploy)
+        exit 1
+      end
+
+      hosts.each do |host|
+        info I18n.t('tasks.utils.rsync.use_host', host: host.hostname, scope: :dkdeploy)
+        ssh_option = 'ssh'
+        ssh_option += ' -p ' + host.port.to_s unless host.port.nil?
+        if capistrano_ssh_option.key? :keys
+          capistrano_ssh_option[:keys].each do |file|
+            ssh_option += " -i '#{file}'"
+          end
+        end
+
+        user = host.user || capistrano_ssh_option[:user]
+
+        ssh_host = ''
+        ssh_host += user + '@' unless user.empty?
+        ssh_host += host.hostname
+
+        execute :rsync, rsync_command + ['--rsh="' + ssh_option + '"', ssh_host + ':' + release_path.to_s]
+      end
+    end
+  end
+
+  desc 'Create custom directories in shared path'
+  task :create_custom_directories, :directories do |_, args|
+    directories = ask_array_variable(args, :directories, 'questions.dir_names')
+
+    on release_roles :app do
+      directories.each do |directory|
+        execute :mkdir, '-p', File.join(shared_path, directory)
+      end
+    end
+  end
+end