capistrano-cul 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a0e53d0b3eedd681257e528aebf115a1970ac10
-  data.tar.gz: 7768d92de643aa8f389f88e9083967d7862cea3c
+  metadata.gz: b8f18b075e8eb0daa92a48fbba497a780a6a8cb2
+  data.tar.gz: 28bffd4b2afec0899e3918e3d09c6ac9aacf4903
 SHA512:
-  metadata.gz: 5e6c6c71b3b07cbc76c8b0c24c27bb3f2fe72a73c39571ccb4243e3f9dbcf4d4db6ab692d8cd716f73e68a62abd399bd6a1b6d5b34476ff1092cdcfee5e62971
-  data.tar.gz: 6db4f2a1ccc30f3f92d55ee7d51d4f940d4ccd15d02bd7aa446b623c953d8ccc308da45a981410e4e2043a594806321fd5b2620c8ce3ba2b1e5320323d86cf2f
+  metadata.gz: 3171e4f2cf8c7e2ff01c1bca1ef4de7c563619f376a203278b51c8f405303620cd7bd86d218583208d53e6c110366973c5885fddee20b3eeaa740ba1752357fc
+  data.tar.gz: 3ee2c4c9ef618595da89a4c67f7d2eb8d158e6c48681dc1195d7c5e6a10e3d3787156e51e601b11346c8b30c7078f5355ded52c8ef2056d0adf2e6fed25ae22e

data/README.md

@@ -93,7 +93,6 @@ Here's a sample configuration:
 
 ```ruby
 set :wp_docroot, "#{fetch(:deploy_to)}/wp-docroot"
-set :wp_content_path, "#{fetch(:deploy_to)}/wp-content"
 set :multisite, false
 set :title, 'Amazing WordPress Site'
 

data/VERSION

@@ -1 +1 @@
-0.0.17
+0.0.18

data/capistrano-cul.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'capistrano', '~> 3.1'
+  spec.add_dependency 'capistrano-git-with-submodules', '~> 2.0'
 
   spec.add_development_dependency "bundler", "~> 1.15"
 end

data/lib/capistrano/cul/wp.rb

@@ -1,3 +1,6 @@
 load File.expand_path('../../tasks/wp.cap', __FILE__)
+load File.expand_path('../../tasks/wp/deploy.cap', __FILE__)
+load File.expand_path('../../tasks/wp/setup.cap', __FILE__)
+load File.expand_path('../../tasks/wp/install.cap', __FILE__)
 load File.expand_path('../../tasks/wp/update.cap', __FILE__)
 load File.expand_path('../../tasks/wp/migrate.cap', __FILE__)

data/lib/capistrano/tasks/cul.cap

@@ -25,4 +25,28 @@ namespace :cul do
       execute :mv, tmp_current_path, current_path.parent
     end
   end
+
+  # Throws an error if any of the given variables are nil or blank, potentially prompting
+  # the user for a value if a variable was configured to be set by the ask() method.
+  def self.require_cap_variables!(variables)
+    variables.each do |variable|
+      value = fetch(variable) # fetch the variable, potentially prompting the use to enter a value on the command line
+      next if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      raise Capistrano::ValidationError, "Missing required variable #{variable}" if value.nil? || value.empty?
+    end
+  end
+
+  def self.enter_y_to_continue(prompt)
+    puts prompt
+    set :confirmation_value, ask('"y" or "yes" to continue (or any other value to cancel)')
+    entered_y = ['y', 'yes'].include?(fetch(:confirmation_value))
+    delete :confirmation_value
+    entered_y
+  end
+
+  def self.color_text(message, color_number=35)
+    text_color = "\e[#{color_number}m"
+    default_color = "\e[0m"
+    text_color + message + default_color
+  end
 end

data/lib/capistrano/tasks/wp/deploy.cap

@@ -0,0 +1,88 @@
+namespace :cul do
+  namespace :wp do
+    namespace :deploy do
+
+      before 'deploy:starting', 'cul:wp:deploy:display_maintenance_mode_warning'
+      before 'deploy:starting', 'cul:wp:deploy:require_deploy_cap_variables'
+      after 'deploy:starting', 'cul:wp:enable_maintenance_mode'
+
+      after :deploy, 'cul:wp:deploy:download_cul_allowed_upload_types_plugin'
+      after :deploy, 'cul:wp:deploy:symlink_custom_plugins_and_themes'
+      after :deploy, 'cul:wp:disable_maintenance_mode'
+
+      desc "Verifies that all deployed-related cap variables have been set in the application's deploy config."
+      task :require_deploy_cap_variables do
+        require_cap_variables!([:branch, :wp_docroot, :multisite])
+      end
+
+      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
+
+      desc "Downloads the cul-allowed-upload-types plugin from its remote web location"
+      task :download_cul_allowed_upload_types_plugin do
+        on roles(:web) do
+          within(current_path) do
+            zip_file_name = "#{fetch(:cul_allowed_upload_types_version)}.zip"
+            execute :curl, '-L', '--silent', '-o', zip_file_name, "https://github.com/cul/#{fetch(:cul_allowed_upload_types_plugin_name)}/archive/#{zip_file_name}"
+            execute :unzip, zip_file_name
+            execute :rm, zip_file_name # clean up zip file
+
+            # rename plugin directory so that it's just called
+            # "#{fetch(:cul_allowed_upload_types_plugin_name)}",
+            # so we can easily reference it later in our symlinking step,
+            # regardless of version number
+            versioned_plugin_directory_name = capture :find, '.', '-mindepth', '1', '-maxdepth', '1', '-name', "#{fetch(:cul_allowed_upload_types_plugin_name)}*"
+            execute :mv, versioned_plugin_directory_name, fetch(:cul_allowed_upload_types_downloaded_plugin_path)
+          end
+        end
+      end
+
+      desc "Downloads the cul-allowed-upload-types plugin from its remote web location"
+      task :symlink_custom_plugins_and_themes do
+        on roles(:web) do
+          wp_content_path = File.join(fetch(:wp_docroot), 'wp-content')
+          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')
+
+          ### Create necessary directories
+          execute :mkdir, '-p', wp_content_plugin_path, wp_content_mu_plugin_path, wp_content_themes_path
+
+          ### Remove old symlinks in each directory
+          [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 symlinks for custom plugins
+          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
+
+          ### Add symlinks for custom mu-plugins
+          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
+
+          ### Add symlinks for custom themes
+          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
+
+          ### Add symlinks for all files and directories directly under the cul-allowed-upload-types plugin directory.
+          # The symlinks will be created directly under the wordpress instance mu-plugins directory.
+          within deploy_path do
+            cul_allowed_upload_types_plugin_top_level_files_and_dirs = capture(:find, fetch(:cul_allowed_upload_types_downloaded_plugin_path), '-mindepth', '1', '-maxdepth', '1').split("\n")
+            cul_allowed_upload_types_plugin_top_level_files_and_dirs.each do |plugin_file_or_directory_path|
+              plugin_file_or_directory_name = File.basename(plugin_file_or_directory_path)
+              next if plugin_file_or_directory_name == '.gitignore' # we don't want to symlink the .gitignore file from the plugin's repo
+              execute :ln, '-sf', plugin_file_or_directory_path, File.join(wp_content_mu_plugin_path, plugin_file_or_directory_name)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/capistrano/tasks/wp/install.cap

@@ -0,0 +1,35 @@
+namespace :cul do
+  namespace :wp do
+
+    desc "Runs a WordPress installation for a newly set up instance and creates a new admin user"
+    task :install do
+      unless enter_y_to_continue(color_text("This will drop any existing database for #{fetch(:stage)}."))
+        puts 'Operation cancelled because "y" was not entered.'
+        next
+      end
+
+      puts "Please provide administrative user credentials for this new WP instance:"
+      ask(:admin_user, "Admin username:")
+      ask(:admin_password, "Admin password:", echo: false)
+      ask(:admin_email, "Admin email:")
+
+      require_cap_variables!([:url, :title, :admin_user, :admin_password, :admin_email])
+
+      on roles(:web) do
+        within fetch(:wp_docroot) do
+
+          # Drop existing database
+          execute :wp, 'db', 'reset', '--yes'
+
+          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
+
+  end
+end

data/lib/capistrano/tasks/wp/migrate-old.cap

@@ -0,0 +1,268 @@
+require 'tempfile'
+require 'json'
+
+namespace :cul do
+  namespace :wp do
+    namespace :migrate do
+
+      desc "Copies the WordPress installation from one environment to another (e.g. prod to dev)"
+      task :copy_from do
+        # Need to store path as local variable so it can be referenced in `on roles(:web) do` portion of script
+        path_to_allowed_upload_types_plugin = cul_allowed_upload_types_plugin_path
+
+        require_cap_variables!([:wp_docroot, :wp_content_path])
+
+        if fetch(:multisite, false)
+          puts "Since this is a multisite, you'll need to specify the source multisite instance domain to continue:"
+          set :source_site_multisite_url, ask('source multisite instance domain (e.g. blogs.cul.columbia.edu)')
+          fetch(:source_site_multisite_url)
+
+          puts "And you'll also need to specify the destination multisite instance domain to continue:"
+          set :destination_site_multisite_url, ask('destination multisite instance domain (e.g. blogs-dev.cul.columbia.edu)')
+          fetch(:destination_site_multisite_url)
+        end
+
+        # TODO: Would be nice to verify that destination wordpress has already had the setup and deploy tasks run for it
+        set :src_wp_docroot, ask("server path to source WordPress installation (to copy from)")
+
+        # Confirm operation because it is destructive
+        puts "\nWARNING: This operation will obliterate all content in environment [#{fetch(:stage)}] and replace it with content from [#{fetch(:src_wp_docroot)}]."
+        puts "Are you sure you want to continue?"
+        set :confirm, ask('"y" or "yes" to continue')
+        unless ['y', 'yes'].include?(fetch(:confirm))
+          puts 'Copy operation has been cancelled because neither "y" nor "yes" were entered.'
+          next
+        end
+
+        # Don't really care about maintenance mode because we're completely destroying the target environment
+        # Enter maintenance mode
+        #invoke 'cul:wp:enable_maintenance_mode'
+
+        # Check WP version on source WordPress instance
+        failure = false
+        on roles(:web) do
+          within fetch(:src_wp_docroot) do
+            # Ensure that source WordPress is running the latest version
+            result = capture :wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'core', 'check-update'
+            unless result.index('Success')
+              puts 'Could not copy from source WordPress because it is not running the latest version of WordPress. Please update source before running a copy operation.'
+              failure = true
+            end
+          end
+        end
+        next if failure # End if the previous checks failed
+
+        on roles(:web) do
+          # Destroy current wp_docroot
+          execute :rm, '-rf', fetch(:wp_docroot)
+          execute :mkdir, fetch(:wp_docroot)
+        end
+
+        # Download new copy of wordpress
+        invoke 'cul:wp:setup'
+
+        path_to_list_of_files_to_copy = ''
+
+        on roles(:web) do
+          # In source site's wp-content directory, generate file list to copy
+          within File.join(fetch(:src_wp_docroot), 'wp-content') do
+            # We're going to be copying wp-content in two parts
+            # 1. Everything else under wp-content EXCEPT uploads, blogs.dir,
+            # plugins, themes, mu-plugins
+            # 2. Everything under uploads AND wpblogs.dir with
+            # cul-allowed-upload-types file extension filter applied
+
+            # Make sure find command handles non-ASCII chars
+            #execute 'LC_ALL=en_US.iso885915'
+
+            # Generate two find commands for the above searches
+            find_non_upload_dirs = '. -type f ' +
+              # EXCLUDE plugins, themes, mu-plugins, uploads, and blogs.dir
+              "-not \\( -path './plugins/*' -o -path './mu-plugins/*' -o -path './themes/*' -o -path './uploads/*' -o -path './blogs.dir/*' \\) " +
+              # EXCLUDE certain unwanted files and paths
+              "-a -not \\( -name '.nfs*' -o -name '*.tmp.*' \\) " +
+              "-a -not \\( -path '*/.git*' -o -path '*/.svn*' -o -path '*/.hg*' \\)"
+
+            find_upload_dirs = '. -type f ' +
+              # INCLUDE ONLY uploads and blogs.dir
+              "\\( -path './uploads/*' -o -path './blogs.dir/*' \\) " +
+              # EXCLUDE certain unwanted files and paths
+              "-a -not \\( -name '.nfs*' -o -name '*.tmp.*' \\) " +
+              "-a -not \\( -path '*/.git*' -o -path '*/.svn*' -o -path '*/.hg*' \\) " +
+              # INCLUDE ONLY certain file extensions
+              "-a \\( " + JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'eval', '"echo cul_allowed_upload_file_extensions_as_json();"')).map{ |allowed_file_extension|
+                "-iname '*.#{allowed_file_extension}'"
+              }.join(' -o ') + " \\) "
+
+            path_to_list_of_files_to_copy = '/tmp/WP' + fetch(:wp_docroot).gsub('/', '-') + '-' + Time.now.to_i.to_s + '-files.txt'
+            execute :find, find_non_upload_dirs, ' > ', path_to_list_of_files_to_copy
+            execute :find, find_upload_dirs, ' >> ', path_to_list_of_files_to_copy
+
+            # Print out which files won't be copied
+            files_not_copied = capture(:comm, '-23', "<(find . -type f \\( -path './uploads/*' -o -path './blogs.dir/*' \\) | sort)", "<(find #{find_upload_dirs} | sort)")
+
+            puts (
+              "The following files will not be copied:\n" +
+              "-------------------------\n" +
+              "./plugins\n" +
+              "./mu-plugins\n" +
+              "./themes\n" +
+              files_not_copied + "\n" +
+              "-------------------------"
+            )
+          end
+
+          # For destination wordpress, delete and recreate the wp-content directory
+          execute :rm, '-rf', fetch(:wp_content_path)
+          execute :mkdir, fetch(:wp_content_path)
+
+          # Copy wp-content files (from path_to_list_of_files_to_copy) from source WP to destination WP
+          # Note that because we have the '--copy-links' flag below, we're transforming all symlinks into real file copies
+          rsync_params = [
+            '--recursive',
+            '--perms',
+            '--times',
+            '--devices',
+            '--specials',
+            '--copy-links',
+            '--prune-empty-dirs'
+          ]
+
+          # we're only copying files from the given file list
+          rsync_params << "--files-from=#{path_to_list_of_files_to_copy}"
+
+          src_wp_content_dir = File.join(fetch(:src_wp_docroot), 'wp-content/')
+          # Run a find operation on the wp-content dir to pre-cache all non-UTF compliant files prior to our rsync operation (to handle files with smart quotes, em dashes, foreign characters, etc.)
+          #execute :find, src_wp_content_dir, '-print0', '|', 'perl', '-n0e', '\'chomp; print $_, "\n" if /[[:^ascii:][:cntrl:]]/\''
+
+          # src directory (--files-from values are relative to this src directory)
+          rsync_params << src_wp_content_dir
+          # dest directory
+          rsync_params << fetch(:wp_content_path) + '/'
+
+          puts 'Copying wp-content. This may take a while for sites with a lot of uploads...'
+
+          puts 'rsync args:'
+          puts rsync_params.join(' ')
+
+          # begin
+            execute :rsync, *rsync_params
+          # rescue
+          #   puts '--- Rsync failed, but will continue with deployment anyway!'
+          # end
+
+          # clean up path_to_list_of_files_to_copy file
+          execute :rm, path_to_list_of_files_to_copy
+
+          # Next, create symlinks to repo-managed plugins and themes, which will also recreate plugins, mu-plugins, and themes directories
+
+          within fetch(:wp_docroot) do
+            # Regenerate symlinks
+            invoke! 'cul:wp:symlink_custom_plugins_and_themes'
+          end
+
+          # Now it's time to copy the database
+
+          db_export_tempfile_path = ''
+
+          within fetch(:src_wp_docroot) do
+            # On source WordPress...
+
+            puts 'Exporting database from source site. This may take a while for large sites...'
+            # Export source WP DB to a temporary file
+            db_export_tempfile_path = Dir::Tmpname.make_tmpname '/tmp/', 'db_export_tempfile.sql'
+            execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'db', 'export', db_export_tempfile_path
+          end
+
+          within fetch(:wp_docroot) do
+            # On destination WordPress...
+
+            puts 'Importing database. This may take a while for large sites...'
+
+            # Drop all tables
+            execute :wp, 'db', 'reset', '--yes'
+
+            # Read in db file
+            execute :wp, 'db', 'import', db_export_tempfile_path
+
+            # Delete db file now that we're done with it
+            execute :rm, db_export_tempfile_path
+
+            # Invoke searchreplace task to update URL
+            puts "\nYou'll probably want to run the cul:wp:searchreplace command now, since it's likely that your WP URL differs between environments."
+            puts "Do you want to run a search and replace operation?"
+            set :confirm_searchreplace, ask('"y" or "yes" to continue')
+            if ['y', 'yes'].include?(fetch(:confirm_searchreplace))
+              invoke 'cul:wp:searchreplace'
+            else
+              puts '- Skipping search and replace because neither "y" nor "yes" were entered.'
+            end
+          end
+
+          # Next, install all plugins and themes from src wordpress, matching all versions and active vs. inactive plugin and theme states
+
+          data_for_plugins = []
+          data_for_themes = []
+
+          # Within src wp instance, get list of all plugins and themes with version
+          within File.join(fetch(:src_wp_docroot)) do
+            data_for_plugins = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'plugin', 'list', '--fields=name,version,status', '--format=json'))
+            data_for_themes = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:source_site_multisite_url)}" : ''), 'theme', 'list', '--fields=name,version,status', '--format=json'))
+          end
+
+          # Within dest wp instance, install specifically versioned plugins and themes
+          within File.join(fetch(:wp_docroot)) do
+            # Get list of repo-managed plugins and themes so that we don't attempt to overwrite these directories
+            repo_managed_plugin_names = fetch(:wp_custom_plugins, {}).keys
+            repo_managed_theme_names = fetch(:wp_custom_themes, {}).keys
+
+            puts "Downloading new copies of non-repo-managed plugins and themes..."
+
+            data_for_plugins.delete_if{|plugin_info| repo_managed_plugin_names.include?(plugin_info['name']) }.each do |plugin_info|
+              name = plugin_info['name']
+              version = plugin_info['version']
+              status = plugin_info['status']
+
+              case status
+              when 'active'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'plugin', 'install', name, "--version=#{version}", '--activate'
+              when 'active-network'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'plugin', 'install', name, "--version=#{version}", '--activate-network'
+              when 'inactive'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'plugin', 'install', name, "--version=#{version}"
+              when 'must-use'
+                puts "--- WARNING: must-use plugin #{name} was not migrated over.  It should be put in your blog's repository and deployed through a regular deployment."
+              end
+            end
+
+            data_for_themes.delete_if{|theme_info| repo_managed_theme_names.include?(theme_info['name']) }.each do |theme_info|
+              name = theme_info['name']
+              version = theme_info['version']
+              status = theme_info['status']
+
+              case status
+              when 'active'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'theme', 'install', name, "--version=#{version}", '--activate'
+              when 'inactive', 'parent'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'theme', 'install', name, "--version=#{version}"
+              end
+            end
+          end
+
+          within fetch(:wp_docroot) do
+            # Make docroot readable and executable for "other" user so nginx, which runs as "nobody", can read
+            # Use -L flag because we want to follow symlinks. The whole deployment relies on symlinks.
+            execute :find, '-L', File.join(fetch(:wp_docroot), 'wp-content'), '-type d -exec chmod o+rx "{}" \;'
+            execute :find, '-L', File.join(fetch(:wp_docroot), 'wp-content'), '-type f -exec chmod o+r "{}" \;'
+            # Make sure that wp-config file is not world readable
+            execute :chmod, 'o-r', shared_path.join('wp-config.php')
+          end
+
+        end
+      end
+
+      #after 'cul:wp:migrate:copy_from', 'cul:wp:disable_maintenance_mode'
+
+    end
+  end
+end