wp.cap in capistrano-cul-0.0.18

- old
+ new

@@ -1,253 +1,64 @@
-CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME = 'cul-allowed-upload-types'
-CUL_ALLOWED_UPLOAD_TYPES_REPO_URL = "https://github.com/cul/#{CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME}"
+set :cul_allowed_upload_types_version, 'v0.5.0' # can be overridden by an app's deploy.rb file
+set :cul_allowed_upload_types_plugin_name, 'cul-allowed-upload-types'
+set :cul_allowed_upload_types_downloaded_plugin_path, ->{current_path.join(fetch(:cul_allowed_upload_types_plugin_name))} # can be overridden by an app's deploy.rb file
 
-# Set cul_allowed_uplaod_types_version here so it can be overridden by env config
-set :cul_allowed_uplaod_types_version, 'v0.5.0'
-
 namespace :cul do
   namespace :wp do
-    before 'deploy:starting', 'cul:wp:display_maintenance_mode_warning'
-    after 'deploy:starting', 'cul:wp:enable_maintenance_mode'
-    after 'deploy:starting', 'cul:wp:update_cul_allowed_upload_types_plugin'
-    after :deploy, 'cul:wp:symlink_custom_plugins_and_themes'
-    after :deploy, 'cul:wp:disable_maintenance_mode'
 
-    desc "Displays a message to the deploying user about how to disable maintenance mode"
-    task :display_maintenance_mode_warning do
-      puts color_text("WARNING: Starting a deployment will set WordPress to maintenance mode.  If you cancel deployment mid-way through, you'll need to manually disable maintenance mode by running: cap [env] cul:wp:disable_maintenance_mode")
-    end
+    set :maintenance_file_path, ->{
+      require_cap_variables!([:wp_docroot])
+      File.join(fetch(:wp_docroot), '.maintenance')
+    }
 
     desc "Enables maintenance mode for the WordPress site in the deploy environment"
     task :enable_maintenance_mode do
-      path_to_maintenance_file = maintenance_file_path # save path to local variable because we can't call method inside `on roles(:web)`
       on roles(:web) do
         within fetch(:wp_docroot) do
           # Set maintenance $upgrading value to current time.
           # Note that WordPress will ignore maintenance mode file
           # after 10 minutes have passed after the maintenance time
           # we set in the file.
-          execute :echo, "'<?php $upgrading = #{Time.now.to_i};'", '>', path_to_maintenance_file
+          execute :echo, "'<?php $upgrading = #{Time.now.to_i};'", '>', fetch(:maintenance_file_path)
         end
       end
       puts color_text("Maintenance mode enabled!")
     end
 
     desc "Disable maintenance mode for the WordPress site in the deploy environment"
     task :disable_maintenance_mode do
-      path_to_maintenance_file = maintenance_file_path # save path to local variable because we can't call method inside `on roles(:web)`
       on roles(:web) do
         within fetch(:wp_docroot) do
-          if test("[ -f #{path_to_maintenance_file} ]")
-            execute :rm, path_to_maintenance_file
+          if test("[ -f #{fetch(:maintenance_file_path)} ]")
+            execute :rm, fetch(:maintenance_file_path)
           else
             puts "No maintenance file found, so there's nothing to delete."
           end
         end
       end
       puts color_text("Maintenance mode disabled!")
     end
 
-    desc "Creates symlinks for custom plugins and themes as part of a WordPress deployment. Generally run as an `after :deploy` hook."
-    task :symlink_custom_plugins_and_themes do
-      symlink_custom_plugins_and_themes
-    end
+    desc "Runs a search and replace operation on the tables in a WordPress installation"
+    task :searchreplace do
 
-    # Runs normal deploy task, downloads new copy of WP, sets up docroot, runs
-    # deploy command, sets up symlinks. Does not run WP install and does not
-    # create any wp users.
-    desc "Sets up a WordPress docroot and runs deployment; does not install wordpress and does not create any users"
-    task :setup do
-      puts "Deploying repo branch: #{fetch(:branch)}"
+      set :search_string, ask("search string")
+      set :replacement_string, ask("replacement string")
 
-      set :wp_version, ask('WordPress version to download:', 'latest')
-      # Printing out wp_version here because the `set` command above only runs
-      # the first time its associated symbol is referenced, and we want to
-      # capture version before running any other commands.
-      puts "Setting up wp_version: #{fetch(:wp_version)}"
-
-      require_cap_params!([:branch, :wp_version, :wp_docroot, :wp_content_path])
-
-      on roles(:web) do
-        wp_docroot_wp_config_file_path = File.join(fetch(:wp_docroot), 'wp-config.php')
-        wp_docroot_robots_txt_file_path = File.join(fetch(:wp_docroot), 'robots.txt')
-        wp_docroot_wp_content_path = File.join(fetch(:wp_docroot), 'wp-content')
-
-        shared_wp_config_file_path = shared_path.join('wp-config.php')
-        shared_robots_txt_file_path = shared_path.join('robots.txt')
-
-        wp_content_path = fetch(:wp_content_path)
-
-        # Create nginx logs directory if it doesn't already exist
-        execute :mkdir, '-p', deploy_path.join('logs')
-
-        # Make full path to wp_docroot directory if not exist
-        execute :mkdir, '-p', fetch(:wp_docroot)
-
-        # Make full path to wp_content_path if not exist
-        execute :mkdir, '-p', wp_content_path
-
-        invoke 'deploy' # Deploy before doing setup
-
-        # If wp_docroot/wp-includes does not exist, do wordpress download
-        unless test("[ -d #{File.join(fetch(:wp_docroot), 'wp-includes')} ]")
-          # Download and unpack new WP instance to wp_docroot
-          execute :wp, 'core', ['download', "--version=#{fetch(:wp_version)}", "--path=#{fetch(:wp_docroot)}"]
-        end
-
-        # Check for wp-config.php file in shared. Create if it doesn't exist.
-        unless test("[ -f #{shared_wp_config_file_path} ]")
-          # If no wp-config.php file is found in the 'shared' directory, copy WordPress built-in wp-config-sample.php to there
-          execute :cp, File.join(fetch(:wp_docroot), 'wp-config-sample.php'), shared_wp_config_file_path
-        end
-
-        # Delete original wp-sample-config.php
-        execute :rm, '-f', File.join(fetch(:wp_docroot), 'wp-config-sample.php')
-        # Create symlink for wp_document_root wp-config.php to 'shared' version.
-        execute :ln, '-sf', shared_wp_config_file_path, wp_docroot_wp_config_file_path
-
-        # Check for robots.txt file in shared. Create if it doesn't exist.
-        unless test("[ -f #{shared_robots_txt_file_path} ]")
-          execute "echo -e \"User-agent: *\nDisallow: /\" > #{shared_robots_txt_file_path}"
-        end
-        # Create symlink for wp_document_root robots.txt to 'shared' version.
-        execute :ln, '-sf', shared_robots_txt_file_path, wp_docroot_robots_txt_file_path
-
-        # Check for actual wp-content directory at wp_content_path. Create if it doesn't exist.
-        unless test("[ -d #{wp_content_path} ]")
-          # If no wp-config.php file is found in the 'shared' directory, copy WordPress built-in wp-config-sample.php to there
-          execute :cp, '-r', wp_docroot_wp_content_path, wp_content_path
-        end
-        # Delete original wp-content directory
-        execute :rm, '-rf', wp_docroot_wp_content_path
-        # Create symlink for wp_document_root wp-content to wp_content_path
-        execute :ln, '-sf', wp_content_path, wp_docroot_wp_content_path
+      unless enter_y_to_continue(color_text("This will replace all occurrences of \"#{fetch(:search_string)}\" with \"#{fetch(:replacement_string)}\"."))
+        puts 'Search and replace cancelled because "y" was not entered.'
+        next
       end
-      symlink_custom_plugins_and_themes
-    end
 
-    desc "Runs a WordPress installation for a newly set up instance and creates a new admin user"
-    task :install do
-      puts "Please provide administrative credentials:"
-      ask(:admin_user, "Admin username:")
-      ask(:admin_password, "Admin password:", echo: false)
-      ask(:admin_email, "Admin email:")
-
-      require_cap_params!([:url, :title, :admin_user, :admin_password, :admin_email])
-
       on roles(:web) do
         within fetch(:wp_docroot) do
-          execute :wp, 'core', fetch(:multisite) ? 'multisite-install' : 'install',
-            "--url='#{fetch(:url)}'",
-            "--title='#{fetch(:title)}'",
-            "--admin_user='#{fetch(:admin_user)}'",
-            "--admin_password='#{fetch(:admin_password)}'",
-            "--admin_email='#{fetch(:admin_email)}'"
-        end
-      end
-    end
-
-    def self.require_cap_params!(vars)
-      validate vars do |key, value|
-        if value.nil? || value.empty?
-          raise Capistrano::ValidationError, "Missing required parameter #{key}"
-        end
-      end
-    end
-
-    def self.symlink_custom_plugins_and_themes
-      on roles(:web) do
-        wp_content_path = fetch(:wp_content_path)
-        wp_content_plugin_path = File.join(wp_content_path, 'plugins')
-        wp_content_mu_plugin_path = File.join(wp_content_path, 'mu-plugins')
-        wp_content_themes_path = File.join(wp_content_path, 'themes')
-
-        if test("[ -d #{wp_content_path} ]")
-
-          ### Create necessary directories
-          execute :mkdir, '-p', wp_content_plugin_path
-          execute :mkdir, '-p', wp_content_mu_plugin_path
-          execute :mkdir, '-p', wp_content_themes_path
-
-          ### Remove old symlinks
-          [wp_content_plugin_path, wp_content_mu_plugin_path, wp_content_themes_path].each do |dir|
-            execute :find, dir, '-maxdepth 1', '-type l', '-exec rm {} \;'
-          end
-
-          ### Add latest symlinks
-          fetch(:wp_custom_plugins, {}).each do |plugin, repo_relative_path|
-            execute :ln, '-sf', File.join(current_path, repo_relative_path), File.join(wp_content_plugin_path, plugin)
-          end
-
-          fetch(:wp_custom_mu_plugins, {}).each do |mu_plugin, repo_relative_path|
-            execute :ln, '-sf', File.join(current_path, repo_relative_path), File.join(wp_content_mu_plugin_path, mu_plugin)
-          end
-
-          fetch(:wp_custom_themes, {}).each do |theme, repo_relative_path|
-            execute :ln, '-sf', File.join(current_path, repo_relative_path), File.join(wp_content_themes_path, theme)
-          end
-
-          ### Also symlink to cul-allowed-upload-types plugin files
-          within deploy_path do
-            cul_allowed_upload_types_plugin_top_level_files_and_dirs = capture(:find, CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME, '-mindepth', '2', '-maxdepth', '2').split("\n")
-            # Symlink all plugin files and directories
-            cul_allowed_upload_types_plugin_top_level_files_and_dirs.each do |plugin_file_or_directory_path|
-              #puts 'Run: ' + [:ln, '-sf', File.join(deploy_path, plugin_file_or_directory_path), File.join(wp_content_mu_plugin_path, File.basename(plugin_file_or_directory_path))].join(' ')
-              execute :ln, '-sf', File.join(deploy_path, plugin_file_or_directory_path), File.join(wp_content_mu_plugin_path, File.basename(plugin_file_or_directory_path))
-            end
-          end
-
-        end
-      end
-    end
-
-    desc "Downloads the latest version of the cul-allowed-upload-types plugin"
-    task :update_cul_allowed_upload_types_plugin do
-      # Download plugin to deploy_path
-      on roles(:web) do
-        within deploy_path do
-          # Clear out old plugin directory if it exists
-          execute :rm, '-rf', CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME
-          # Re-create plugin directory and temp dir inside of it
-          allowed_upload_types_tempdir = File.join(CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME, 'tmp')
-          execute :mkdir, '-p', allowed_upload_types_tempdir
-
-          # Download and unzip plugin
-          allowed_upload_types_temp_zipfile = File.join(allowed_upload_types_tempdir, 'plugin.zip')
-          zip_file_name = "#{fetch(:cul_allowed_uplaod_types_version)}.zip"
-          execute :curl, '-L', '--silent', '-o', allowed_upload_types_temp_zipfile, "#{CUL_ALLOWED_UPLOAD_TYPES_REPO_URL}/archive/#{zip_file_name}"
-          execute :unzip, allowed_upload_types_temp_zipfile, '-d', CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME
-
-          # Delete temp dir after unzip
-          execute :rm, '-rf', allowed_upload_types_tempdir
-
-          # Remove .gitignore file from plugin directory so we don't symlink to it later
-          execute :find, CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME, '-name', '.gitignore', '-delete'
-        end
-      end
-    end
-
-    desc "Runs a search and replace operation on the tables in a WordPress installation"
-    task :searchreplace do
-      on roles(:web) do
-        within fetch(:wp_docroot) do
-          set :search_string, ask("search string")
-          set :replacement_string, ask("replacement string")
-          puts "Are you sure you want to replace all occurrences of \"#{fetch(:search_string)}\" with \"#{fetch(:replacement_string)}\"?"
-          set :confirm, ask('"y" or "yes" to continue')
-
-          unless ['y', 'yes'].include?(fetch(:confirm))
-            puts 'Search and replace operation has been cancelled because neither "y" nor "yes" were entered.'
-            next
-          end
-
           puts 'Running search and replace. This may take a while for large databases...'
           start_time = Time.now
 
           if fetch(:multisite, false)
-            puts "Since this is a multisite, you'll need to specify the source multisite instance domain to continue:"
-            set :multisite_url, ask('source multisite instance domain (e.g. blogs.cul.columbia.edu)')
+            puts "Since this is a multisite, you'll need to specify the original multisite instance domain to continue:"
+            set :multisite_url, ask('original multisite instance domain (e.g. blogs.cul.columbia.edu)')
 
             execute :wp, "--url=#{fetch(:multisite_url)}", 'search-replace', "'#{fetch(:search_string)}'", "'#{fetch(:replacement_string)}'", '--all-tables', '--skip-columns=guid'
           else
             execute :wp, 'search-replace', "'#{fetch(:search_string)}'", "'#{fetch(:replacement_string)}'", '--skip-columns=guid'
           end
@@ -255,21 +66,23 @@
           puts "Search and replace complete (took #{(Time.now - start_time).to_s} seconds)"
         end
       end
     end
 
-    def self.cul_allowed_upload_types_plugin_path
-      File.join('mu-plugins', CUL_ALLOWED_UPLOAD_TYPES_PLUGIN_NAME)
+    def self.require_dest_wp_domain_if_multisite!
+      if(fetch(:multisite))
+        puts "Since this is a multisite, you'll need to specify the DESTINATION instance domain to continue:"
+        set :dest_multisite_domain, ask('destination multisite instance domain (e.g. blogs-dev.cul.columbia.edu)')
+        require_cap_variables!([:dest_multisite_domain])
+      end
     end
 
-    def self.maintenance_file_path
-      File.join(fetch(:wp_docroot), '.maintenance')
-    end
-
-    def self.color_text(message, color_number=35)
-      text_color = "\e[#{color_number}m"
-      default_color = "\e[0m"
-      text_color + message + default_color
+    def self.require_src_wp_domain_if_multisite!
+      if(fetch(:multisite))
+        puts "Since this is a multisite, you'll need to specify the SOURCE instance domain to continue:"
+        set :src_multisite_domain, ask('source multisite instance domain (e.g. blogs.cul.columbia.edu)')
+        require_cap_variables!([:src_multisite_domain])
+      end
     end
 
   end
 end