wordpresstrano 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5436061cb8fc9afe6050e4f86f69595e9259c791
+  data.tar.gz: 1513416e7fed88eaa04554fd21f9711dc60d0667
+SHA512:
+  metadata.gz: 3719edf22d551b9ff9d8dac8691b77123d2b3e3ecbf237742ed040d331f8ee81975d3bd3304edfc4122bcab4ec9869deeda8f51a81a1849fd481f1a88a9a5800
+  data.tar.gz: 644b5f81e4007e13770fce41c8cfb18f4b3a9f66320a99d0ff8364e1de837e7ab05928b7b34b075489e12adf303db08f378118b9dcfba91cc4b3171c284d9fd2

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nialto Services
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,5 @@
+# WordPresstrano
+
+This gem is currently in beta.
+
+Documentation coming soon!

data/lib/capistrano/wordpress/helpers/fixnum.rb

@@ -0,0 +1,22 @@
+class Fixnum
+  # Get the ordinal string of the integer value
+  def ordinal
+    abs_number = self.to_i.abs
+    
+    if (11..13).include?(abs_number % 100)
+      "th"
+    else
+      case abs_number % 10
+        when 1; "st"
+        when 2; "nd"
+        when 3; "rd"
+        else    "th"
+      end
+    end
+  end
+  
+  # Get the ordinal string prefixed with the integer value
+  def ordinalize
+    "#{self}#{self.ordinal}"
+  end
+end

data/lib/capistrano/wordpress/helpers/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  # Check to see if we contain all the specified keys
+	def has_keys?(*keys)
+		keys.each do |key|
+			return false unless self.has_key? key
+		end
+		
+		true
+	end
+end

data/lib/capistrano/wordpress/hooks.rb

@@ -0,0 +1,95 @@
+# 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"
+
+# Check if maintenance mode should be enabled before pushing the database
+before "db:push", "db:check_maintenance_enable"
+
+# Create the MySQL database before pushing content to it
+before "db:push", "db:create"
+
+# Backup the database before pushing
+before "db:push", "db:backup"
+
+# Check if maintenance mode should be enabled before restoring the database
+before "db:restore", "db:check_maintenance_enable"
+
+# Create the database before restoring
+before "db:restore", "db:create"
+
+# Deploy shared configuration files before deploying
+before "deploy", "deploy:shared_configs"
+
+# 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"
+
+# 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"
+
+# Link the release into the website root
+after "deploy:finished", "webroot:symlink"
+
+# Touch the release directory after deploying
+# This is required as after the first deployment, we enable
+# maintenance mode for every subsequent deployment. This causes
+# the previous release directory to have a newer timestamp than
+# the new release directory which leads to issues with the rollback
+# feature as the releases directory is sorted by modification time
+# when capistrano looks for the release to rollback to.
+after "deploy:finishing", "deploy:touch_release"
+
+# Set permissions on the resources after deploying them
+after "config:generate", "config:setperms"
+after "htaccess:push", "htaccess:setperms"
+after "robots:generate", "robots:setperms"
+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"
+
+# Check if maintenance mode should be disabled after restoring the database
+after "db:restore", "db:check_maintenance_disable"
+
+# Push the local resources after finishing deploy:updated
+after "deploy:reverted", "db:rollback"
+after "deploy:updated", "htaccess:push"
+after "deploy:updated", "uploads:push"
+after "deploy:updated", "db:push" # We want this to happen last so leave it here :)

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

@@ -0,0 +1,35 @@
+namespace :binaries do
+  desc "Check that all required binaries are installed"
+  task :check do
+    next if true == fetch(:checked_binaries)
+    
+    required_binaries = {
+      local: [:php, :rm, :rsync, :wp],
+      remote: {
+        :all => [:chmod, :find, :rm, :wp],
+        :app => [:ln, :readlink, :rsync],
+        :db => [:du, :grep, :mysqlshow]
+      }
+    }
+  
+    run_locally do
+      required_binaries[:local].each do |binary|
+        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
+        end
+      end
+    end
+    
+    set :checked_binaries, true
+  end
+end

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

@@ -0,0 +1,85 @@
+namespace :config do
+  desc "Generate a wp-config.php file"
+  task :generate do
+    file = "wp-config.php"
+    
+    local_path = File.join(Dir.pwd, file)
+    remote_path = File.join(shared_path, file)
+    
+    template_path = File.join("config", "templates", "#{file}.erb")
+    template_content = File.read(template_path)
+    
+    run_locally do
+      database_config = fetch(:local_database_config)
+      
+      unless database_config.has_keys? :hostname, :username, :database, :password
+        abort "The local database configuration is invalid"
+      end
+      
+      database_hostname = database_config[:hostname]
+      database_username = database_config[:username]
+      database_name = database_config[:database]
+      database_password = database_config[:password]
+      
+      secret_keys = Net::HTTP.get URI("https://api.wordpress.org/secret-key/1.1/salt")
+      
+      if secret_keys.nil? or secret_keys.empty?
+        abort "Unable to fetch secret keys using the WordPress API"
+      end
+      
+      configuration = ERB.new(template_content).result(binding)
+      
+      if test("[ -f #{local_path} ]")
+        execute :rm, "-f", local_path
+      end
+      
+      info "Writing local #{file} file"
+      
+      File.write(local_path, configuration)
+    end
+    
+    database_config = fetch(:database_config)
+    
+    unless database_config.has_keys? :hostname, :username, :database, :password
+      abort "The #{fetch(:stage)} database configuration is invalid"
+    end
+    
+    database_hostname = database_config[:hostname]
+    database_username = database_config[:username]
+    database_name = database_config[:database]
+    database_password = database_config[:password]
+    
+    secret_keys = Net::HTTP.get URI("https://api.wordpress.org/secret-key/1.1/salt")
+    
+    if secret_keys.nil? or secret_keys.empty?
+      abort "Unable to fetch secret keys using the WordPress API"
+    end
+    
+    configuration = ERB.new(template_content).result(binding)
+    
+    on roles(:app) do |server|
+      if test("[ -f #{remote_path} ]")
+        execute :rm, "-f", remote_path
+      end
+      
+      upload! StringIO.new(configuration), remote_path
+    end
+  end
+  
+  desc "Set permissions on the wp-config.php file"
+  task :setperms do
+    on roles(:app) do |server|
+      file = "wp-config.php"
+      
+      remote_path = File.join(shared_path, file)
+      
+      unless test("[ -f #{remote_path} ]")
+        error "A #{file} file does not exist on #{server.user}@#{server.hostname}"
+      end
+      
+      info "Setting permissions for #{file} on #{server.user}@#{server.hostname}"
+      
+      execute :chmod, 644, remote_path
+    end
+  end
+end

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

@@ -0,0 +1,355 @@
+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"
+    
+    local_path = File.join(Dir.pwd, file)
+    remote_path = File.join(fetch(:tmp_dir), file)
+    
+    on roles(:db) do |server|
+      info "Pushing WordPress database to #{server.user}@#{server.hostname}"
+      
+      run_locally do
+        execute :wp, "db", "export", local_path
+      end
+      
+      upload! local_path, remote_path
+      
+      run_locally do
+        execute :rm, "-f", local_path
+      end
+      
+      within release_path do
+        execute :wp, "db", "import", remote_path
+        execute :rm, "-f", remote_path
+        
+        if fetch(:local_site_url) and fetch(:site_url)
+          execute :wp, "search-replace", fetch(:local_site_url), fetch(:site_url)
+        end
+      end
+    end
+  end
+  
+  desc "Create the MySQL database"
+  task :create do
+    database_config = fetch(:database_config)
+    
+    unless database_config.has_keys? :hostname, :username, :database, :password
+      abort "The #{fetch(:stage)} database configuration is invalid"
+    end
+    
+    database_name = database_config[:database]
+    database_hostname = database_config[:hostname]
+    database_username = database_config[:username]
+    database_password = database_config[:password]
+    
+    on roles(:db) 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}"
+          
+          next
+        end
+        
+        info "Creating MySQL database on #{server.user}@#{server.hostname}"
+        
+        execute :wp, "db", "create"
+      end
+    end
+  end
+  
+  desc "Drop the MySQL database"
+  task :drop do
+    database_config = fetch(:database_config)
+    
+    unless database_config.has_keys? :hostname, :username, :database, :password
+      abort "The #{fetch(:stage)} database configuration is invalid"
+    end
+    
+    database_name = database_config[:database]
+    database_hostname = database_config[:hostname]
+    database_username = database_config[:username]
+    database_password = database_config[:password]
+    
+    on roles(:db) 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}"
+          
+          next
+        end
+        
+        info "Deleting MySQL database on #{server.user}@#{server.hostname}"
+        
+        execute :wp, "db", "drop", "--yes"
+      end
+    end
+  end
+  
+  desc "Reset the MySQL database"
+  task :reset do
+    on roles(:db) 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}"
+          
+          next
+        end
+        
+        info "Resetting the WordPress database on #{server.user}@#{server.hostname}"
+        
+        execute :wp, "db", "reset", "--yes"
+      end
+    end
+  end
+  
+  desc "Create a backup of the WordPress database"
+  task :backup do
+    backups_directory = File.join(fetch(:deploy_to), "backups", "database")
+    
+    on roles(:db) do |server|
+      next unless test("[ -d #{current_path} ]")
+      
+      actual_current_path = capture("readlink -f #{current_path}").strip
+      
+      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}"
+      
+      execute :mkdir, "-p", backups_directory
+      
+      if test("[ -f #{remote_path} ]")
+        execute :rm, "-f", remote_path
+      end
+      
+      within release_path do
+        execute :wp, "db", "export", remote_path
+      end
+    end
+  end
+  
+  desc "Restore a backup of the WordPress database"
+  task :restore do
+    backups_directory = File.join(fetch(:deploy_to), "backups", "database")
+    
+    backup_id = fetch(:rollback_timestamp, ENV["id"])
+    
+    unless backup_id
+      run_locally do
+        info "No backup id provided to restore database backup"
+      end
+      
+      next
+    end
+    
+    on roles(:db) 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}"
+        
+        next
+      end
+      
+      info "Restoring WordPress database #{backup_id} on #{server.user}@#{server.hostname}"
+      
+      within release_path do
+        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
+      
+      backups_directory = File.join(fetch(:deploy_to), "backups", "database")
+      
+      unless test("[ -d #{backups_directory} ]")
+        info "No database backups found"
+        
+        next
+      end
+      
+      backup_paths = capture("find #{backups_directory} -name '*.sql' -maxdepth 1")
+      
+      if backup_paths.nil? or backup_paths.empty?
+        info "No database backups found"
+        
+        next
+      end
+      
+      if 1 == backup_paths.lines.count
+        info "Found 1 database backup"
+      else
+        info "Found #{backup_paths.lines.count} database backups"
+      end
+      
+      backup_paths.each_line do |backup_path|
+        backup_path = backup_path.strip
+        
+        backup_basename = File.basename(backup_path).gsub(".sql", "").strip
+        
+        backup_time = Time.parse(backup_basename)
+        backup_time = backup_time.strftime("%A #{backup_time.day.ordinalize} %B %Y at %H:%M:%S")
+        
+        backup_size = capture("du -h #{backup_path} | awk '{ print \$1 }'")
+        
+        info "#{backup_time} - #{backup_size} (ID: #{backup_basename})"
+      end
+    end
+  end
+  
+  # Rollback the WordPress database
+  # This is only useful when called during a deploy:rollback task
+  task :rollback 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
+      
+      actual_current_path = capture("readlink -f #{current_path}").strip
+      actual_release_path = capture("readlink -f #{release_path}").strip
+    end
+    
+    if actual_current_path == actual_release_path
+      run_locally do
+        error "This task is only useful when called during a deploy:rollback task!"
+      end
+      
+      next
+    end
+    
+    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)
+    
+    unless :rollback_from_timestamp
+      run_locally do
+        error "No timestamp set for the release we rolled away from"
+      end
+      
+      next
+    end
+    
+    file = "#{rollback_from_timestamp}.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)
+    
+    on roles(:db) do |server|
+      unless test("[ -f #{source_path} ]")
+        error "The database backup file does not exist on #{server.user}@#{server.hostname}"
+        
+        next
+      end
+      
+      info "Moving database backup #{rollback_from_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
+      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

@@ -0,0 +1,24 @@
+namespace :deploy do
+  task :shared_configs do
+    config_path = File.join(shared_path, "wp-config.php")
+    robots_path = File.join(shared_path, "robots.txt")
+    
+    on roles(:app) do
+      unless test("[ -f #{config_path} ]")
+        invoke "config:generate"
+      end
+      
+      unless test("[ -f #{robots_path} ]")
+        invoke "robots:generate"
+      end
+    end
+  end
+  
+  task :touch_release do
+    on roles(:app) do |server|
+      info "Touching release directory on #{server.user}@#{server.hostname}"
+      
+      execute :touch, release_path
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+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"
+    
+    local_path = File.join(Dir.pwd, file)
+    remote_path = File.join(release_path, file)
+    
+    unless File.file? file
+      run_locally do
+        htaccess = "# BEGIN WordPress\n"
+        htaccess << "<IfModule mod_rewrite.c>\n"
+        htaccess << "RewriteEngine On\n"
+        htaccess << "RewriteBase /\n"
+        htaccess << "RewriteRule ^index\.php$ - [L]\n"
+        htaccess << "RewriteCond %{REQUEST_FILENAME} !-f\n"
+        htaccess << "RewriteCond %{REQUEST_FILENAME} !-d\n"
+        htaccess << "RewriteRule . /index.php [L]\n"
+        htaccess << "</IfModule>\n"
+        htaccess << "# END WordPress\n"
+        
+        File.write(local_path, htaccess)
+      end
+    end
+    
+    on roles(:app) do |server|
+      if test("[ -f #{remote_path} ]")
+        local_sha256sum = Digest::SHA256.hexdigest(File.read(local_path))
+        remote_sha256sum = capture("sha256sum #{remote_path}").split(' ').first
+        
+        if local_sha256sum == remote_sha256sum
+          info "No changes detected in #{file} on #{server.user}@#{server.hostname}"
+          
+          next
+        end
+      end
+      
+      info "Pushing #{file} file to #{server.user}@#{server.hostname}"
+      
+      upload! local_path, remote_path
+    end
+  end
+  
+  desc "Set permissions on the .htaccess file"
+  task :setperms do
+    file = ".htaccess"
+    
+    remote_path = File.join(release_path, file)
+    
+    on roles(:app) do |server|
+      unless test("[ -f #{remote_path} ]")
+        info "No #{file} file found on #{server.user}@#{server.hostname}"
+        
+        next
+      end
+      
+      info "Setting permissions for #{file} on #{server.user}@#{server.hostname}"
+      
+      execute :chmod, 644, remote_path
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+namespace :maintenance do
+  desc "Enable maintenance mode on the WordPress site"
+  task :enable do
+    file = ".maintenance"
+    
+    on roles(:app) do |server|
+      actual_current_path = capture("readlink -f #{current_path}").strip
+      
+      remote_path = File.join(actual_current_path, file)
+      
+      if test("[ -f #{remote_path} ]")
+        info "Maintenance mode is already enabled on #{server.user}@#{server.hostname}"
+        
+        next
+      end
+      
+      maintenance_info = fetch(:maintenance_info, {
+        title: "Maintenance",
+        header: "This site is currently undergoing maintenance.",
+        body: "Please check back in a moment."
+      })
+      
+      file_content = "<?php header('HTTP/1.1 503 Service Unavailable'); ?>\n"
+      file_content << "<?php header('Content-Type: text/html'); ?>\n"
+      file_content << "<!DOCTYPE html>\n"
+      file_content << "<html>\n"
+      file_content << "  <head>\n"
+      file_content << "    <meta charset=\"utf-8\">\n"
+      file_content << "    <meta name=\"viewport\" content=\"initial-scale=1.0\">\n"
+      file_content << "    <title>#{maintenance_info[:title]}</title>\n" if maintenance_info.has_key? :title
+      file_content << "  </head>\n"
+      file_content << "  <body class=\"body\">\n"
+      file_content << "    <h1>#{maintenance_info[:header]}</h1>\n" if maintenance_info.has_key? :header
+      file_content << "    <h3>#{maintenance_info[:subheader]}</h3>\n" if maintenance_info.has_key? :subheader
+      file_content << "    <p>#{maintenance_info[:body]}</p>\n" if maintenance_info.has_key? :body
+      file_content << "  </body>\n"
+      file_content << "</html>\n"
+      file_content << "<?php exit; ?>\n"
+      
+      info "Enabling WordPress maintenance mode on #{server.user}@#{server.hostname}"
+      
+      upload! StringIO.new(file_content), remote_path
+      
+      execute :chmod, 644, remote_path
+    end
+  end
+  
+  desc "Disable maintenance mode on the WordPress site"
+  task :disable do
+    file = ".maintenance"
+    
+    on roles(:app) do |server|
+      actual_current_path = capture("readlink -f #{current_path}").strip
+      
+      remote_path = File.join(actual_current_path, file)
+      
+      unless test("[ -f #{remote_path} ]")
+        info "Maintenance mode is not enabled on #{server.user}@#{server.hostname}"
+        
+        next
+      end
+      
+      info "Disabling WordPress maintenance mode on #{server.user}@#{server.hostname}"
+      
+      execute :rm, "-f", remote_path
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+namespace :robots do
+  desc "Generate a robots.txt file"
+  task :generate do
+    file = "robots.txt"
+    
+    remote_path = File.join(shared_path, file)
+    
+    on roles(:app) do |server|
+      info "Generating a #{file} file on #{server.user}@#{server.hostname}"
+      
+      if :production != fetch(:stage)
+        debug "Disallowing all user agents in #{file} on #{server.user}@#{server.hostname}"
+        
+        upload! StringIO.new("User-agent: *\nDisallow: /"), remote_path
+      else
+        upload! StringIO.new, remote_path
+      end
+    end
+  end
+  
+  desc "Set permissions on the robots.txt file"
+  task :setperms do
+    file = "robots.txt"
+    
+    remote_path = File.join(shared_path, file)
+    
+    on roles(:app) do |server|
+      unless test("[ -f #{remote_path} ]")
+        error "A #{file} file does not exist on #{server.user}@#{server.hostname}"
+      end
+      
+      info "Setting permissions for #{file} on #{server.user}@#{server.hostname}"
+      
+      execute :chmod, 644, remote_path
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+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")
+    
+    local_path = File.join(Dir.pwd, directory)
+    remote_path = File.join(release_path, directory)
+    
+    unless File.directory? local_path
+      error "No local uploads directory exists"
+      
+      next
+    end
+    
+    on roles(:app) do |server|
+      if test("[ -d #{current_path} ]") and (ENV["clone_uploads"].nil? or ENV["clone_uploads"].empty? or [true, "true", "yes", "y"].include? ENV["clone_uploads"].downcase)
+        actual_current_path = capture("readlink -f #{current_path}").strip
+        actual_release_path = capture("readlink -f #{release_path}").strip
+        
+        previous_remote_path = File.join(actual_current_path, directory)
+        
+        if actual_current_path != actual_release_path and test("[ -d #{previous_remote_path} ]")
+          debug "Cloning uploads directory from current release on #{server.user}@#{server.hostname}"
+          
+          execute :cp, "-R", "--preserve=timestamps", previous_remote_path, remote_path
+        end
+      end
+      
+      execute :mkdir, "-p", remote_path
+      
+      info "Pushing #{directory} directory to #{server.user}@#{server.hostname}"
+      
+      # Fix for rsync
+      local_path += "/"
+      
+      run_locally do
+        execute :rsync, "-lrtvzO", "--delete-before", (server.port ? "-e 'ssh -p #{server.port}'" : nil), local_path, "#{server.user}@#{server.hostname}:#{remote_path}"
+      end
+    end
+  end
+  
+  desc "Set permissions on the uploads directory"
+  task :setperms do
+    directory = File.join("wp-content", "uploads")
+    
+    remote_path = File.join(release_path, directory)
+    
+    on roles(:app) do |server|
+      unless test("[ -d #{remote_path} ]")
+        error "No uploads directory exists on #{server.user}@#{server.hostname}"
+        
+        next
+      end
+      
+      info "Setting permissions for the uploads directory on #{server.user}@#{server.hostname}"
+      
+      execute :find, remote_path, "-type d", "-exec", :chmod, 755, "{}", "\\;"
+      execute :find, remote_path, "-type f", "-exec", :chmod, 644, "{}", "\\;"
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+namespace :webroot do
+  desc "Symlink the current release into the website root"
+  task :symlink do
+    remote_path = fetch(:website_root)
+    
+    next unless remote_path
+    
+    on roles(:app) do |server|
+      if test("[ -d #{remote_path} ]")
+        execute :rm, "-rf", remote_path
+      end
+      
+      info "Symlinking the current release into the website root on #{server.user}@#{server.hostname}"
+      
+      execute :ln, "-nfs", release_path, remote_path
+    end
+  end
+  
+  desc "Set permissions on the uploads directory"
+  task :setperms do
+    remote_path = fetch(:website_root)
+    
+    next unless remote_path
+    
+    on roles(:app) do |server|
+      unless test("[ -d #{remote_path} ]")
+        error "No website root directory exists on #{server.user}@#{server.hostname}"
+        
+        next
+      end
+      
+      info "Setting permissions for the website root directory on #{server.user}@#{server.hostname}"
+      
+      execute :find, remote_path, "-type d", "-exec", :chmod, 755, "{}", "\\;"
+      execute :find, remote_path, "-type f", "-exec", :chmod, 644, "{}", "\\;"
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+namespace :wp do
+  namespace :core do
+    # Load the local version (for use with wp:core:deploy)
+    task :load_local_version do
+      run_locally do
+        version_script_path = File.join(Dir.pwd, "wp-includes", "version.php")
+        
+        unless File.file? version_script_path
+          abort "No valid WordPress installation could be found locally"
+        end
+        
+        set :wp_version, capture("php -r \"include '#{version_script_path}'; echo \\$wp_version;\"")
+      end
+    end
+    
+    desc "Download the WordPress core files into the release"
+    task :download do
+      on roles(:app) do |server|
+        version = fetch(:wp_version, ENV["version"])
+        
+        info "Downloading WordPress Core" + (version ? " (Version #{version})" : "")
+        
+        tmp_dir = File.join(fetch(:tmp_dir), SecureRandom.hex(8))
+        
+        execute :mkdir, "-p", tmp_dir
+        
+        within tmp_dir do
+          execute :wp, "core", "download", (version ? "--version=#{version}" : "")
+          
+          excludes = [".", "license.txt", "readme.html", "wp-config-sample.php", "wp-content"]
+          excludes = excludes.map { |e| "! -name '#{e}' " }.join(" ").squeeze(" ").strip
+          
+          paths = capture :find, ".", "-maxdepth 1", excludes
+          paths = paths.split("\n")
+          paths.each do |path|
+            execute :cp, "-R", path, release_path
+          end
+        end
+        
+        execute :rm, "-rf", tmp_dir
+      end
+    end
+    
+    desc "Remove the WordPress core files from the release"
+    task :remove do
+      on roles(:app) do
+        within release_path do
+          paths = []
+          
+          excludes = [".", "wp-config.php", "wp-content"]
+          excludes = excludes.map { |e| "! -name '#{e}' " }.join(" ").squeeze(" ").strip
+          
+          ["index.php", "wp-*", "xmlrpc.php"].each do |glob|
+            find_output = capture :find, ".", "-maxdepth 1", "-name '#{glob}'", excludes
+            
+            paths.concat(find_output.split("\n"))
+          end
+          
+          next if 1 > paths.length
+          
+          info "Removing #{paths.length} WordPress core file(s)"
+          
+          paths.each do |path|
+            execute :rm, "-rf", path
+          end
+        end
+      end
+    end
+  end
+  
+  desc "Execute a WordPress CLI command"
+  task :exec do
+    set :wp_exec_command, ask("The WordPress CLI command to execute", "help")
+    
+    unless fetch(:wp_exec_command)
+      abort "You didn't enter a command to execute"
+    end
+    
+    on roles(:all) do |server|
+      next if ENV["role"] and !server.roles.map { |role| role.to_s }.include? ENV["role"]
+      
+      within release_path do
+        puts capture :wp, fetch(:wp_exec_command)
+      end
+    end
+    
+    set :wp_exec_command, nil
+  end
+end

data/lib/capistrano/wordpress.rb

@@ -0,0 +1,13 @@
+require "net/http"
+require "securerandom"
+require "time"
+
+# Load all helpers and capistrano tasks
+["wordpress/helpers/**/*.rb", "wordpress/tasks/**/*.rake", "wordpress/hooks.rb"].each do |glob|
+  Dir.glob(File.expand_path(File.join('..', glob), __FILE__)).each do |file_path|
+    load file_path
+  end
+end
+
+# Tell capistrano about files we want linked into releases
+set :linked_files, fetch(:linked_files, []).push("robots.txt", "wp-config.php")

data/lib/wordpresstrano.rb

@@ -0,0 +1 @@
+require 'capistrano/wordpress'

data/wordpresstrano.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = 'wordpresstrano'
+  s.version = '0.2.0'
+  s.date = '2015-08-09'
+  s.authors = ['Nialto Services']
+  s.email = 'support@nialtoservices.co.uk'
+  s.summary = 'Deploy WordPress sites to web servers using Capistrano'
+  s.description = 'Deploy your WordPress sites to web servers like cPanel using the Capistrano deployment tool'
+  s.homepage = 'http://rubygems.org/gems/wordpresstrano'
+  s.files = `git ls-files`.split($/)
+  s.require_paths = ['lib']
+  s.license = 'MIT'
+  
+  s.required_ruby_version = '>= 2.0.0'
+  s.add_dependency 'capistrano', '~> 3.0', '>= 3.4.0'
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: wordpresstrano
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Nialto Services
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+description: Deploy your WordPress sites to web servers like cPanel using the Capistrano
+  deployment tool
+email: support@nialtoservices.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/capistrano/wordpress.rb
+- lib/capistrano/wordpress/helpers/fixnum.rb
+- lib/capistrano/wordpress/helpers/hash.rb
+- lib/capistrano/wordpress/hooks.rb
+- lib/capistrano/wordpress/tasks/binaries.rake
+- lib/capistrano/wordpress/tasks/config.rake
+- lib/capistrano/wordpress/tasks/database.rake
+- lib/capistrano/wordpress/tasks/deploy.rake
+- lib/capistrano/wordpress/tasks/htaccess.rake
+- lib/capistrano/wordpress/tasks/maintenance.rake
+- lib/capistrano/wordpress/tasks/robots.rake
+- lib/capistrano/wordpress/tasks/uploads.rake
+- lib/capistrano/wordpress/tasks/webroot.rake
+- lib/capistrano/wordpress/tasks/wordpress.rake
+- lib/wordpresstrano.rb
+- wordpresstrano.gemspec
+homepage: http://rubygems.org/gems/wordpresstrano
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Deploy WordPress sites to web servers using Capistrano
+test_files: []