wordpresstrano 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a39a6ee135372c5de3d06d78771e8165e92948f
-  data.tar.gz: 03465170ef4519a96e2a4e74b1a39dcc89546128
+  metadata.gz: 61fd148512fb3279807ba2e5afaffd510de22b2e
+  data.tar.gz: 1dd7e3d9601695732cae56e36beccfafae86f046
 SHA512:
-  metadata.gz: f6f2916a978dd401a9dfc46fe7afe3783b8d45396851678fd41d9538f2c8fc51788fb4eedb77fa04e6beff70ca4aea22ad1d3d531279579e8ad3eda415524fad
-  data.tar.gz: 78528b29a4c75b9fcd73f19b76dec33636f300267e023966c013ff9a234cadf307e5dc8f62d282b616480817c224899df75496a78a7d7d378a994332b57ef824
+  metadata.gz: 2e35f1b198560f0a973dd770e8af7c02fa80e96c2310d9879e15fbff30d7ed580d3af4c0bd3a667c9dc038d9e8a6dacb4c7a352929bce5862c904be36fb0edee
+  data.tar.gz: 6d8e28ae42045e052d675072c69116593798fa54213837888f57d5663ef87ad16c14fc52030c39b07d62352777b418bc299b9ec1a28d70cc30dc514bd843ef27

data/lib/capistrano/wordpress/hooks.rb

@@ -1,38 +1,23 @@
-# Check binaries before performing tasks
-before "db:backup", "binaries:check"
-before "db:create", "binaries:check"
-before "db:list_backups", "binaries:check"
-before "db:pull", "binaries:check"
-before "db:push", "binaries:check"
-before "db:reset", "binaries:check"
-before "db:restore", "binaries:check"
-before "deploy", "binaries:check"
-before "htaccess:pull", "binaries:check"
-before "htaccess:push", "binaries:check"
-before "uploads:pull", "binaries:check"
-before "uploads:push", "binaries:check"
-before "uploads:setperms", "binaries:check"
-before "wp:core:download", "binaries:check"
-before "wp:core:remove", "binaries:check"
-
-# Check directories before performing tasks
-before "config:generate", "deploy:check:directories"
-before "db:backup", "deploy:check:directories"
-before "db:create", "deploy:check:directories"
-before "db:list_backups", "deploy:check:directories"
-before "db:pull", "deploy:check:directories"
-before "db:push", "deploy:check:directories"
-before "db:reset", "deploy:check:directories"
-before "db:restore", "deploy:check:directories"
-before "deploy:shared_configs", "deploy:check:directories"
-before "htaccess:pull", "deploy:check:directories"
-before "htaccess:push", "deploy:check:directories"
-before "robots:generate", "deploy:check:directories"
-before "uploads:pull", "deploy:check:directories"
-before "uploads:push", "deploy:check:directories"
+# Perform a safety check before running tasks
+before "config:generate", "deploy:safety_check"
+before "db:backup", "deploy:safety_check"
+before "db:create", "deploy:safety_check"
+before "db:list_backups", "deploy:safety_check"
+before "db:push", "deploy:safety_check"
+before "db:reset", "deploy:safety_check"
+before "db:restore", "deploy:safety_check"
+before "deploy", "deploy:safety_check"
+before "deploy:all", "deploy:safety_check"
+before "deploy:configs", "deploy:safety_check"
+before "htaccess:push", "deploy:safety_check"
+before "robots:generate", "deploy:safety_check"
+before "uploads:push", "deploy:safety_check"
+before "uploads:setperms", "deploy:safety_check"
+before "wp:core:download", "deploy:safety_check"
+before "wp:core:remove", "deploy:safety_check"
 
 # Check if maintenance mode should be enabled before pushing the database
-before "db:push", "db:check_maintenance_enable"
+before "db:push", "maintenance:enable_if_previous_deployment"
 
 # Create the MySQL database before pushing content to it
 before "db:push", "db:create"
@@ -41,31 +26,33 @@ before "db:push", "db:create"
 before "db:push", "db:backup"
 
 # Check if maintenance mode should be enabled before restoring the database
-before "db:restore", "db:check_maintenance_enable"
+before "db:restore", "maintenance:enable_if_previous_deployment"
 
 # Create the database before restoring
 before "db:restore", "db:create"
 
-# Deploy shared configuration files before deploying
-before "deploy", "deploy:shared_configs"
+# Check if there is a previous deployment before performing
+# a partial deployment.
+before "deploy", "deploy:check_for_previous_deployment"
+
+# Set the timestamp to be used by the db:backup task
+before "deploy:all", "db:match_backup_timestamp_with_release"
+before "deploy:rollback", "db:match_backup_timestamp_with_release"
 
 # Move the database backup from the release we rolled away from
 # into the release's root before it's archived
 before "deploy:cleanup_rollback", "db:cleanup_rollback_database"
 
+# Remove the existing WordPress core before downloading a new one
+before "wp:core:download", "wp:core:remove"
+
 # Load the local WordPress version so that when downloading the
 # WordPress core on a remote server, the version matches the local installation.
 before "deploy:updated", "wp:core:load_local_version"
 
-# Remove the existing WordPress core before downloading a new one
-before "wp:core:download", "wp:core:remove"
-
 # Download the WordPress core files before finishing deploy:updated
 before "deploy:updated", "wp:core:download"
 
-# Check if we can deploy without pushing htaccess/uploads/database
-before "deploy", "deploy:check_for_previous_deployment"
-
 # Link the release into the website root
 after "deploy:finished", "webroot:symlink"
 
@@ -86,10 +73,10 @@ after "uploads:push", "uploads:setperms"
 after "deploy:finished", "webroot:setperms"
 
 # Check if maintenance mode should be disabled after pushing the database
-after "db:push", "db:check_maintenance_disable"
+after "db:push", "maintenance:disable_if_previous_deployment"
 
 # Check if maintenance mode should be disabled after restoring the database
-after "db:restore", "db:check_maintenance_disable"
+after "db:restore", "maintenance:disable_if_previous_deployment"
 
 # Rollback the database after rolling back the files
 after "deploy:reverted", "db:rollback"

data/lib/capistrano/wordpress/tasks/binaries.rake

@@ -1,31 +1,25 @@
 namespace :binaries do
   desc "Check that all required binaries are installed"
   task :check do
-    next if true == fetch(:checked_binaries)
+    next if fetch(:checked_binaries, false)
     
     required_binaries = {
       local: [:mysql, :mysqldump, :mysqlshow, :php, :rm, :rsync, :wp],
-      remote: {
-        :all => [:chmod, :find, :mysql, :mysqldump, :mysqlshow, :rm, :wp],
-        :app => [:ln, :readlink, :rsync],
-        :db => [:du, :grep]
-      }
+      remote: [:chmod, :du, :find, :grep, :ln, :mysql, :mysqldump, :mysqlshow, :readlink, :rm, :rsync, :wp]
     }
-  
-    run_locally do
-      required_binaries[:local].each do |binary|
+    
+    required_binaries[:local].each do |binary|
+      run_locally do
         unless test :which, binary
           abort "The binary '#{binary}' is missing from the local system"
         end
       end
     end
   
-    required_binaries[:remote].each do |role, binaries|
-      on roles(role) do |server|
-        binaries.each do |binary|
-          unless test :which, binary
-            abort "The binary '#{binary}' is missing from #{server.user}@#{server.hostname}"
-          end
+    required_binaries[:remote].each do |binary|
+      on roles(:app) do |server|
+        unless test :which, binary
+          abort "The binary '#{binary}' is missing from #{server.user}@#{server.hostname}"
         end
       end
     end

data/lib/capistrano/wordpress/tasks/database.rake

@@ -1,65 +1,4 @@
 namespace :db do
-  desc "Pull down the WordPress database"
-  task :pull do
-    file = "#{SecureRandom.hex(8)}.sql"
-    
-    local_path = File.join(Dir.pwd, file)
-    remote_path = File.join(fetch(:tmp_dir), file)
-    
-    next if 0 == roles(:db).count
-    
-    if 1 < roles(:db).count
-      run_locally do
-        info "Found #{roles(:db).count} database servers"
-        
-        roles(:db).each_with_index do |server, index|
-          info "#{index + 1}) #{server.user}@#{server.hostname} (Port #{server.port or 22})"
-        end
-        
-        set :database_pull_server, ask("the number of the server to pull the database from", "1")
-      end
-    else
-      set :database_pull_server, "1"
-    end
-    
-    database_pull_server = fetch(:database_pull_server).to_i
-    
-    if 1 > database_pull_server or roles(:db).count < database_pull_server
-      run_locally do
-        error "Unable to locate a server with an id '#{database_pull_server}'"
-      end
-      
-      next
-    end
-    
-    database_pull_server = roles(:db)[database_pull_server - 1]
-    
-    on roles(:db) do |server|
-      next unless server.matches? database_pull_server
-      
-      info "Pulling WordPress database from #{server.user}@#{server.hostname}"
-      
-      within release_path do
-        execute :wp, "db", "export", remote_path
-      end
-      
-      download! remote_path, local_path
-      
-      execute :rm, "-f", remote_path
-      
-      run_locally do
-        execute :wp, "db", "import", local_path
-        execute :rm, "-f", local_path
-        
-        if fetch(:local_site_url) and fetch(:site_url)
-          execute :wp, "search-replace", fetch(:site_url), fetch(:local_site_url)
-        end
-      end
-    end
-    
-    set :database_pull_server, nil
-  end
-  
   desc "Push up the WordPress database"
   task :push do
     file = "#{SecureRandom.hex(8)}.sql"
@@ -67,11 +6,11 @@ namespace :db do
     local_path = File.join(Dir.pwd, file)
     remote_path = File.join(fetch(:tmp_dir), file)
     
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       info "Pushing WordPress database to #{server.user}@#{server.hostname}"
       
       run_locally do
-        execute :wp, "db", "export", local_path
+        execute :wp, :db, :export, local_path
       end
       
       upload! local_path, remote_path
@@ -81,7 +20,7 @@ namespace :db do
       end
       
       within release_path do
-        execute :wp, "db", "import", remote_path
+        execute :wp, :db, :import, remote_path
         execute :rm, "-f", remote_path
         
         if fetch(:local_site_url) and fetch(:site_url)
@@ -104,17 +43,17 @@ namespace :db do
     database_username = database_config[:username]
     database_password = database_config[:password]
     
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       within release_path do
         if test("[ \"#{database_name}\" == $(mysqlshow --user=\"#{database_username}\" --password=\"#{database_password}\" #{database_name} | grep -v Wildcard | grep -o #{database_name}) ]")
-          info "The MySQL database already exists on #{server.user}@#{server.hostname}"
+          error "The MySQL database already exists on #{server.user}@#{server.hostname}"
           
           next
         end
         
         info "Creating MySQL database on #{server.user}@#{server.hostname}"
         
-        execute :wp, "db", "create"
+        execute :wp, :db, :create
       end
     end
   end
@@ -132,34 +71,34 @@ namespace :db do
     database_username = database_config[:username]
     database_password = database_config[:password]
     
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       within release_path do
         unless test("[ \"#{database_name}\" == $(mysqlshow --user=\"#{database_username}\" --password=\"#{database_password}\" #{database_name} | grep -v Wildcard | grep -o #{database_name}) ]")
-          info "The MySQL database does not exist on #{server.user}@#{server.hostname}"
+          error "The MySQL database does not exist on #{server.user}@#{server.hostname}"
           
           next
         end
         
         info "Deleting MySQL database on #{server.user}@#{server.hostname}"
         
-        execute :wp, "db", "drop", "--yes"
+        execute :wp, :db, :drop, "--yes"
       end
     end
   end
   
   desc "Reset the MySQL database"
   task :reset do
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       within release_path do
-        unless test :wp, "core", "is-installed"
-          info "The WordPress database does not appear to be installed on #{server.user}@#{server.hostname}"
+        unless test :wp, :core, "is-installed"
+          error "The WordPress database does not appear to be installed on #{server.user}@#{server.hostname}"
           
           next
         end
         
         info "Resetting the WordPress database on #{server.user}@#{server.hostname}"
         
-        execute :wp, "db", "reset", "--yes"
+        execute :wp, :db, :reset, "--yes"
       end
     end
   end
@@ -168,14 +107,13 @@ namespace :db do
   task :backup do
     backups_directory = File.join(fetch(:deploy_to), "backups", "database")
     
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       next unless test("[ -d #{current_path} ]")
       
-      actual_current_path = capture("readlink -f #{current_path}").strip
+      timestamp = fetch(:db_backup_timestamp, Time.now.strftime("%Y%m%d%H%M%S"))
+      
+      file = "#{timestamp}.sql"
       
-      file = File.basename(actual_current_path)
-      file = "#{file}.sql"
-    
       remote_path = File.join(backups_directory, file)
       
       info "Backing up WordPress database on #{server.user}@#{server.hostname}"
@@ -187,7 +125,7 @@ namespace :db do
       end
       
       within release_path do
-        execute :wp, "db", "export", remote_path
+        execute :wp, :db, :export, remote_path
       end
     end
   end
@@ -196,44 +134,42 @@ namespace :db do
   task :restore do
     backups_directory = File.join(fetch(:deploy_to), "backups", "database")
     
-    backup_id = fetch(:rollback_timestamp, ENV["id"])
+    backup_id = fetch(:db_restore_timestamp, ENV['id'])
     
     unless backup_id
       run_locally do
-        info "No backup id provided to restore database backup"
+        error "You must provide the ID of the backup to restore!"
       end
       
       next
     end
     
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       file = "#{backup_id}.sql"
     
       remote_path = File.join(backups_directory, file)
       
       unless test("[ -f #{remote_path} ]")
-        info "Could not find database backup #{backup_id} on #{server.user}@#{server.hostname}"
+        info "No database backup found for the id '#{backup_id}' on #{server.user}@#{server.hostname}"
         
         next
       end
       
-      info "Restoring WordPress database #{backup_id} on #{server.user}@#{server.hostname}"
+      info "Rolling back the database to '#{backup_id}' on #{server.user}@#{server.hostname}"
       
       within release_path do
-        execute :wp, "db", "import", remote_path
+        execute :wp, :db, :import, remote_path
       end
     end
   end
   
   desc "List all WordPress database backups"
   task :list_backups do
-    on roles(:db) do |server|
-      next unless server.matches? roles(:db).first # Hack to make sure we run only once
-      
+    on roles(:app) do |server|
       backups_directory = File.join(fetch(:deploy_to), "backups", "database")
       
       unless test("[ -d #{backups_directory} ]")
-        info "No database backups found"
+        error "No database backups found on #{server.user}@#{server.hostname}"
         
         next
       end
@@ -241,16 +177,12 @@ namespace :db do
       backup_paths = capture("find #{backups_directory} -name '*.sql' -maxdepth 1")
       
       if backup_paths.nil? or backup_paths.empty?
-        info "No database backups found"
+        error "No database backups found on #{server.user}@#{server.hostname}"
         
         next
       end
       
-      if 1 == backup_paths.lines.count
-        info "Found 1 database backup"
-      else
-        info "Found #{backup_paths.lines.count} database backups"
-      end
+      info "Found #{backup_paths.lines.count} database backup(s) on #{server.user}@#{server.hostname}"
       
       backup_paths.each_line do |backup_path|
         backup_path = backup_path.strip
@@ -273,9 +205,7 @@ namespace :db do
     actual_current_path = nil
     actual_release_path = nil
     
-    on roles(:db) do |server|
-      next unless server.matches? roles(:db).first # Hack to make sure we run only once
-      
+    on roles(:app) do |server|
       actual_current_path = capture("readlink -f #{current_path}").strip
       actual_release_path = capture("readlink -f #{release_path}").strip
     end
@@ -288,68 +218,46 @@ namespace :db do
       next
     end
     
+    set :db_restore_timestamp, File.basename(actual_release_path)
+    
     invoke 'db:backup'
     invoke 'db:restore'
-    
-    set :rollback_from_timestamp, File.basename(actual_current_path)
   end
   
   # Move the database backup from the release we rolled away from
   # into the release's root before it's archived
   task :cleanup_rollback_database do
-    rollback_from_timestamp = fetch(:rollback_from_timestamp)
+    db_backup_timestamp = fetch(:db_backup_timestamp)
     
-    unless :rollback_from_timestamp
-      run_locally do
-        error "No timestamp set for the release we rolled away from"
-      end
-      
-      next
-    end
+    next unless db_backup_timestamp
     
-    file = "#{rollback_from_timestamp}.sql"
+    file = "database.sql"
     
     backups_directory = File.join(fetch(:deploy_to), "backups", "database")
     
     source_path = File.join(backups_directory, file)
-    destination_path = File.join(releases_path, rollback_from_timestamp, file)
+    destination_path = File.join(releases_path, db_backup_timestamp, file)
     
-    on roles(:db) do |server|
+    on roles(:app) do |server|
       unless test("[ -f #{source_path} ]")
-        error "The database backup file does not exist on #{server.user}@#{server.hostname}"
+        error "The database backup (#{db_backup_timestamp}) does not exist on #{server.user}@#{server.hostname}"
         
         next
       end
       
-      info "Moving database backup #{rollback_from_timestamp} into release on #{server.user}@#{server.hostname}"
+      info "Moving database backup #{db_backup_timestamp} into release on #{server.user}@#{server.hostname}"
       
       execute :mv, source_path, destination_path
     end
   end
   
-  # Enable maintenance mode if WordPress is already installed (used by db:push)
-  task :check_maintenance_enable do
-    maintenance_path = File.join(current_path, ".maintenance")
-    
-    on roles(:db) do
-      next unless test("[ -d #{current_path} ]")
-      next if test("[ -f #{maintenance_path} ]")
-      next if true == fetch(:db_enabled_maintenance_mode)
-      
-      within current_path do
-        if test :wp, "core", "is-installed"
-          set :db_enabled_maintenance_mode, true
-          
-          invoke 'maintenance:enable'
-        end
+  # Set the timestamp for the backup task to match
+  # the timestamp of the current release.
+  task :match_backup_timestamp_with_release do
+    on roles(:app) do
+      if test("[ -d #{current_path} ]")
+        set :db_backup_timestamp, File.basename(capture("readlink -f #{current_path}").strip)
       end
     end
   end
-  
-  # Disable maintenance mode if it was enabled by check_maintenance_enable
-  task :check_maintenance_disable do
-    next unless true == fetch(:db_enabled_maintenance_mode)
-    
-    invoke 'maintenance:disable'
-  end
 end

data/lib/capistrano/wordpress/tasks/deploy.rake

@@ -1,8 +1,11 @@
 namespace :deploy do
+  desc "Deploy all resources to the remote servers"
   task :all do
     Rake::Task["deploy"].prerequisites.delete("deploy:check_for_previous_deployment")
     Rake::Task["deploy:updated"].prerequisites.delete("htaccess:clone_from_previous_release")
     
+    before "deploy", "deploy:configs"
+    
     after "deploy:updated", "htaccess:push"
     after "deploy:updated", "uploads:push"
     after "deploy:updated", "db:push"
@@ -10,23 +13,8 @@ namespace :deploy do
     invoke "deploy"
   end
   
-  task :check_for_previous_deployment do
-    previous_deployment = true
-    
-    on roles(:all) do |server|
-      unless test("[ -d #{current_path} ]")
-        error "Unable to locate a current release on #{server.user}@#{server.hostname}"
-        
-        previous_deployment = false
-      end
-    end
-    
-    unless previous_deployment
-      raise "One or more servers don't have a current release on them. You should run 'deploy:all' first."
-    end
-  end
-  
-  task :shared_configs do
+  desc "Deploy the wp-config.php and robots.txt configuration files"
+  task :configs do
     config_path = File.join(shared_path, "wp-config.php")
     robots_path = File.join(shared_path, "robots.txt")
     
@@ -41,11 +29,47 @@ namespace :deploy do
     end
   end
   
+  desc "Perform a safety check"
+  task :safety_check do
+    unless fetch(:website_root)
+      raise "You must set the :website_root variable in your deployment configuration!"
+    end
+    
+    if 1 < roles(:app).count
+      raise "You can't deploy to more than one server!"
+    end
+    
+    invoke "binaries:check"
+    invoke "deploy:check:directories"
+  end
+  
+  desc "Touch the most recent release directory on the remote servers"
   task :touch_release do
     on roles(:app) do |server|
-      info "Touching release directory on #{server.user}@#{server.hostname}"
-      
-      execute :touch, release_path
+      if test("[ -d #{release_path} ]")
+        info "Touching release directory on #{server.user}@#{server.hostname}"
+        
+        execute :touch, release_path
+      else
+        error "No release directory found on #{server.user}@#{server.hostname}"
+      end
+    end
+  end
+  
+  # Check if a previous deployment exists on the remote servers.
+  # If one or more servers don't have a release on them, we should
+  # raise an error.
+  task :check_for_previous_deployment do
+    on roles(:app) do |server|
+      unless test("[ -d #{current_path} ]")
+        error "No releases found on #{server.user}@#{server.hostname}"
+        
+        set :all_servers_have_deployments, false
+      end
+    end
+    
+    unless fetch(:all_servers_have_deployments, true)
+      raise "You need to run the 'deploy:all' task first!"
     end
   end
 end

data/lib/capistrano/wordpress/tasks/htaccess.rake

@@ -1,74 +1,4 @@
 namespace :htaccess do
-  desc "Pull down the .htaccess file"
-  task :pull do
-    file = ".htaccess"
-    
-    remote_file = File.join(release_path, file)
-    
-    next if 0 == roles(:app).count
-    
-    if 1 < roles(:app).count
-      run_locally do
-        info "Found #{roles(:app).count} application servers"
-        
-        roles(:app).each_with_index do |server, index|
-          info "#{index + 1}) #{server.user}@#{server.hostname} (Port #{server.port or 22})"
-        end
-        
-        set :htaccess_pull_server, ask("the number of the server to pull the #{file} file from", "1")
-      end
-    else
-      set :htaccess_pull_server, "1"
-    end
-    
-    htaccess_pull_server = fetch(:htaccess_pull_server).to_i
-    
-    if 1 > htaccess_pull_server or roles(:app).count < htaccess_pull_server
-      run_locally do
-        error "Unable to locate a server with an id '#{htaccess_pull_server}'"
-      end
-      
-      next
-    end
-    
-    htaccess_pull_server = roles(:app)[htaccess_pull_server - 1]
-    
-    on roles(:app) do |server|
-      next unless server.matches? htaccess_pull_server
-      
-      unless test("[ -f #{remote_file} ]")
-        error "There isn't a #{file} file on #{server.user}@#{server.hostname}"
-        
-        next
-      end
-      
-      if File.file? file
-        local_sha256sum = Digest::SHA256.hexdigest(File.read(file))
-        remote_sha256sum = capture("sha256sum #{remote_file}").split(' ').first
-        
-        if local_sha256sum == remote_sha256sum
-          info "No changes detected in #{file} file on #{server.user}@#{server.hostname}"
-          
-          next
-        end
-        
-        unless fetch(:confirm_pull_htaccess)
-          set :confirm_pull_htaccess, ask("confirmation for local #{file} file overwrite", "Y/n")
-        end
-        
-        next unless [true, "y", "yes"].include? fetch(:confirm_pull_htaccess).downcase
-      end
-      
-      info "Pulling #{file} file from #{server.user}@#{server.hostname}"
-      
-      download! remote_file, file
-      
-      break
-    end
-    
-    set :htaccess_pull_server, nil
-  end
-  
   desc "Push up the .htaccess file"
   task :push do
     file = ".htaccess"

data/lib/capistrano/wordpress/tasks/maintenance.rake

@@ -65,4 +65,29 @@ namespace :maintenance do
       execute :rm, "-f", remote_path
     end
   end
+  
+  # Enable maintenance mode if there is already a WordPress deployment.
+  task :enable_if_previous_deployment do
+    maintenance_path = File.join(current_path, ".maintenance")
+    
+    on roles(:app) do
+      next unless test("[ -d #{current_path} ]")
+      next if test("[ -f #{maintenance_path} ]")
+      
+      within current_path do
+        if test :wp, :core, "is-installed"
+          set :previous_deployment_maintenance_enabled, true
+          
+          invoke 'maintenance:enable'
+        end
+      end
+    end
+  end
+  
+  # Disable maintenance mode if it was enabled by the :enable_if_previous_deployment task.
+  task :disable_if_previous_deployment do
+    next unless true == fetch(:previous_deployment_maintenance_enabled)
+    
+    invoke 'maintenance:disable'
+  end
 end

data/lib/capistrano/wordpress/tasks/uploads.rake

@@ -1,65 +1,4 @@
 namespace :uploads do
-  desc "Pull down the uploads directory"
-  task :pull do
-    directory = File.join("wp-content", "uploads")
-    
-    local_path = File.join(Dir.pwd, directory)
-    remote_path = File.join(release_path, directory)
-    
-    next if 0 == roles(:app).count
-    
-    if 1 < roles(:app).count
-      run_locally do
-        info "Found #{roles(:app).count} application servers"
-        
-        roles(:app).each_with_index do |server, index|
-          info "#{index + 1}) #{server.user}@#{server.hostname} (Port #{server.port or 22})"
-        end
-        
-        set :uploads_pull_server, ask("the number of the server to pull the #{directory} directory from", "1")
-      end
-    else
-      set :uploads_pull_server, "1"
-    end
-    
-    uploads_pull_server = fetch(:uploads_pull_server).to_i
-    
-    if 1 > uploads_pull_server or roles(:app).count < uploads_pull_server
-      run_locally do
-        error "Unable to locate a server with an id '#{uploads_pull_server}'"
-      end
-      
-      next
-    end
-    
-    uploads_pull_server = roles(:app)[uploads_pull_server - 1]
-    
-    on roles(:app) do |server|
-      next unless server.matches? uploads_pull_server
-      
-      unless test("[ -d #{remote_path} ]")
-        error "There isn't a #{directory} directory on #{server.user}@#{server.hostname}"
-        
-        next
-      end
-      
-      run_locally do
-        execute :mkdir, "-p", local_path
-      end
-      
-      info "Pulling #{directory} directory from #{server.user}@#{server.hostname}"
-      
-      # Fix for rsync
-      remote_path += "/"
-      
-      run_locally do
-        execute :rsync, "-lrtvzO", "--delete-before", (server.port ? "-e 'ssh -p #{server.port}'" : nil), "#{server.user}@#{server.hostname}:#{remote_path}", local_path
-      end
-    end
-    
-    set :uploads_pull_server, nil
-  end
-  
   desc "Push up the uploads directory"
   task :push do
     directory = File.join("wp-content", "uploads")

data/wordpresstrano.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'wordpresstrano'
-  s.version = '0.2.2'
+  s.version = '0.2.3'
   s.date = '2015-08-09'
   s.authors = ['Nialto Services']
   s.email = 'support@nialtoservices.co.uk'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wordpresstrano
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Nialto Services