capistrano-cul 0.0.17 → 0.0.18

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

@@ -1,5 +1,5 @@
-require 'tempfile'
 require 'json'
+require 'tempfile'
 
 namespace :cul do
   namespace :wp do
@@ -7,44 +7,25 @@ namespace :cul 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_params!([:wp_docroot, :wp_content_path])
+        require_cap_variables!([:wp_docroot])
 
-        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
+        require_src_wp_domain_if_multisite!
+        require_dest_wp_domain_if_multisite!
 
-        # TODO: Would be nice to verify that destination wordpress has already had the setup and deploy tasks run for it
+        set :src_wp_server, ask("source WordPress server (e.g. ldpd-nginx-prod1.cul.columbia.edu)")
         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'
+        puts "Checking #{fetch(:src_wp_server)} for version of WordPress instance at #{fetch(:src_wp_docroot)}..."
 
-        # Check WP version on source WordPress instance
+        # Check WP version on source WordPress instance. We require latest version because we always download the latest version for the new instance.
         failure = false
-        on roles(:web) do
+        on fetch(:remote_user) + '@' + fetch(:src_wp_server) 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')
+            result = capture :wp, (fetch(:multisite, false) ? "--url=#{fetch(:src_multisite_domain)}" : ''), 'core', 'check-update'
+            if result.index('Success')
+              puts "Running latest version of WordPress!"
+            else
               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
@@ -52,161 +33,225 @@ namespace :cul do
         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
+        # Run setup task to destroy current docroot and download new copy of WordPress
+        # Note: The setup task enables maintenance mode during intermediate deployment
+        # step, and then disables maintenance mode before it completes.
         invoke 'cul:wp:setup'
 
-        path_to_list_of_files_to_copy = ''
+        # Enable maintenance mode AGAIN
+        invoke! 'cul:wp:enable_maintenance_mode'
 
-        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)")
+        # Run wp-content copy task to sync certain wp-content files (everything other than plugins, themes, mu-plugins) from src instance to dest instance
+        invoke 'cul:wp:migrate:copy_wp_content'
 
-            puts (
-              "The following files will not be copied:\n" +
-              "-------------------------\n" +
-              "./plugins\n" +
-              "./mu-plugins\n" +
-              "./themes\n" +
-              files_not_copied + "\n" +
-              "-------------------------"
-            )
-          end
+        # Copy database
+        invoke 'cul:wp:migrate:copy_database'
 
-          # For destination wordpress, delete and recreate the wp-content directory
-          execute :rm, '-rf', fetch(:wp_content_path)
-          execute :mkdir, fetch(:wp_content_path)
+        # Run cul:wp:searchreplace one or more times
+        invoke 'cul:wp:migrate:post_database_copy_searchreplace'
 
-          # 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'
-          ]
+        # Download non-repo-managed plugins and themes
+        invoke 'cul:wp:migrate:download_plugins_and_themes'
 
-          # we're only copying files from the given file list
-          rsync_params << "--files-from=#{path_to_list_of_files_to_copy}"
+        # Disable maintenance mode
+        invoke! 'cul:wp:disable_maintenance_mode'
 
-          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:]]/\''
+        puts 'Copy complete!'
+      end
 
-          # 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) + '/'
+      desc "Copies certain wp-content (everything other than plugins, themes, and mu-plugins) from one environment to another (e.g. prod to dev). This task is part of the :copy_from task and isn't meant to be called directly."
+      task :copy_wp_content do
+        # Define src and dest wp content paths, for later use
+        src_wp_content_path = File.join(fetch(:src_wp_docroot), 'wp-content')
+        dest_wp_content_path = File.join(fetch(:wp_docroot), 'wp-content')
 
-          puts 'Copying wp-content. This may take a while for sites with a lot of uploads...'
+        allowed_file_extensions = []
 
-          puts 'rsync args:'
-          puts rsync_params.join(' ')
+        # Get list of allowed file extensions to copy from source WP instance
+        on fetch(:remote_user) + '@' + fetch(:src_wp_server) do
+          within fetch(:src_wp_docroot) do
+            allowed_file_extensions = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:src_multisite_domain)}" : ''), 'eval', '"echo cul_allowed_upload_file_extensions_as_json();"'))
+          end
+        end
 
-          execute :rsync, *rsync_params
+        # Copy certain files from src wp-content to dest wp-content
+        on roles(:web) do
+          within fetch(:wp_docroot) do
 
-          # clean up path_to_list_of_files_to_copy file
-          execute :rm, path_to_list_of_files_to_copy
+            # Note that because we have the '--copy-links' flag below, we're transforming all symlinks into real file copies
+            rsync_base_params = [
+              '--recursive',
+              '--perms',
+              '--times',
+              '--devices',
+              '--specials',
+              '--copy-links',
+              '--prune-empty-dirs',
+              # Always exclude certain file and directory patterns
+              '--exclude=".nfs*"',
+              '--exclude="*.tmp.*"',
+              '--exclude=".git*"',
+              '--exclude=".svn*"',
+              '--exclude=".hg*"'
+            ]
+
+            # First copy all files and folders OTHER THAN
+            # plugins, themes, mu-plugins, uploads, and blogs.dir
+            execute :rsync, (
+              rsync_base_params + [
+                # Apply exclusions, relative to the rsync src directory
+                '--exclude="plugins"',
+                '--exclude="mu-plugins"',
+                '--exclude="themes"',
+                '--exclude="uploads"',
+                '--exclude="blogs.dir"'
+              ] +
+              # Apply user-defined exclusion filters, if present
+              fetch(:wp_content_rsync_exclude_filters, []).map{ |filter_value| "--exclude=\"#{filter_value}\"" } +
+              [
+                # src directory
+                fetch(:remote_user) + '@' + fetch(:src_wp_server) + ':' + src_wp_content_path + '/', # trailing slash so we only copy content within dir, but not dir itself
+                # dest directory
+                dest_wp_content_path
+              ]
+            )
 
-          # Next, create symlinks to repo-managed plugins and themes, which will also recreate plugins, mu-plugins, and themes directories
+            # Then copy all files and folders from uploads AND blogs.dir,
+            # (with cul-allowed-upload-types file extension filter applied)
+            execute :rsync, (
+              rsync_base_params +
+              # Apply user-defined exclusion filters, if present
+              fetch(:wp_content_rsync_exclude_filters, []).map{ |filter_value| "--exclude=\"#{filter_value}\"" } +
+              [
+                # Apply inclusion filters, relative to the rsync src directory
+                '--include="/uploads**/"',
+                '--include="/blogs.dir**/"',
+              ] +
+              # Apply inclusion filters based on file extension
+              allowed_file_extensions.map{ |allowed_file_extension| "--include=\"*.#{allowed_file_extension}\"" } +
+              [
+                # Exclude everything else not included by --include filters
+                '--exclude="*"',
+                # src directory
+                fetch(:remote_user) + '@' + fetch(:src_wp_server) + ':' + src_wp_content_path + '/', # trailing slash so we only copy content within dir, but not dir itself
+                # dest directory
+                dest_wp_content_path
+              ]
+            )
 
-          within fetch(:wp_docroot) do
-            # Regenerate symlinks
-            invoke! 'cul:wp:symlink_custom_plugins_and_themes'
           end
+        end
 
-          # Now it's time to copy the database
+        # Compare copied files and tell use which files were not copied
+        puts 'Comparing file lists between environments...'
 
-          db_export_tempfile_path = ''
+        on roles(:web) do
+          within dest_wp_content_path do
+            files_not_copied = capture(:comm, '-23',
+              "<(ssh #{fetch(:remote_user)}@#{fetch(:src_wp_server)} \"cd #{src_wp_content_path} && find . -type f \\( -path '*/uploads/*' -o -path '*/blogs.dir/*' \\) | sort\")",
+              "<(cd #{dest_wp_content_path} && find . -type f \\( -path '*/uploads/*' -o -path '*/blogs.dir/*' \\) | sort)"
+            )
 
-          within fetch(:src_wp_docroot) do
-            # On source WordPress...
+            # Generate list of files that weren't copied. Display this list to the user.
+            puts (
+              "The following files were not copied because of file and directory filters:\n" +
+              "-------------------------\n" +
+              "./plugins\n" +
+              "./mu-plugins\n" +
+              "./themes\n" +
+              (files_not_copied.length > 0 ? files_not_copied + "\n" : '') +
+              "-------------------------"
+            )
+          end
+        end
+
+      end
 
-            puts 'Exporting database from source site. This may take a while for large sites...'
+      desc "Copies certain wp-content (everything other than plugins, themes, and mu-plugins) from one environment to another (e.g. prod to dev). This task is part of the :copy_from task and isn't meant to be called directly."
+      task :copy_database do
+
+        db_export_tempfile = 'db_export_tempfile.sql'
+        remote_server_db_export_tempfile_path = Dir::Tmpname.make_tmpname '/tmp/', db_export_tempfile
+        local_server_db_export_file_path = File.join(fetch(:wp_docroot), db_export_tempfile)
+
+        # Export database from source WordPress instance
+        on fetch(:remote_user) + '@' + fetch(:src_wp_server) do
+          within fetch(:src_wp_docroot) do
+            puts 'Exporting database from source site. This might 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
+            execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:src_multisite_domain)}" : ''), 'db', 'export', remote_server_db_export_tempfile_path
           end
+        end
 
-          within fetch(:wp_docroot) do
-            # On destination WordPress...
+        begin
+          on roles(:web) do
+            # Import database to destination WordPress instance
+            within fetch(:wp_docroot) do
+              puts 'Importing database. This may take a while for large sites...'
 
-            puts 'Importing database. This may take a while for large sites...'
+              # Copy database export from other server to this server
+              execute :rsync,
+                fetch(:remote_user) + '@' + fetch(:src_wp_server) + ':' + remote_server_db_export_tempfile_path,
+                local_server_db_export_file_path
 
-            # Drop all tables
-            execute :wp, 'db', 'reset', '--yes'
 
-            # Read in db file
-            execute :wp, 'db', 'import', db_export_tempfile_path
+              # Drop all tables
+              execute :wp, 'db', 'reset', '--yes'
 
-            # Delete db file now that we're done with it
-            execute :rm, db_export_tempfile_path
+              # Read in db file
+              execute :wp, 'db', 'import', local_server_db_export_file_path
+            end
+          end
+        ensure
+          # Regardless of whether the db import was successful, make sure to
+          # delete DB temp files on remote server and local server.
+
+          # Delete on remote server
+          on fetch(:remote_user) + '@' + fetch(:src_wp_server) do
+            within fetch(:src_wp_docroot) do
+              execute :rm, remote_server_db_export_tempfile_path
+            end
+          end
 
-            # 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.'
+          # Delete on local server
+          on roles(:web) do
+            within fetch(:wp_docroot) do
+              execute :rm, local_server_db_export_file_path
             end
           end
+        end
+      end
+
+      desc "Runs one or more cul:wp:searchreplace operations after a database copy"
+      task :post_database_copy_searchreplace do
+
+        # 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."
+        if enter_y_to_continue(color_text("Do you want to run cul:wp:searchreplace?"))
+          invoke! 'cul:wp:searchreplace'
+          while enter_y_to_continue(color_text("Do you want to run cul:wp:searchreplace again?"))
+            invoke! 'cul:wp:searchreplace'
+          end
+        end
+
+      end
 
-          # Next, install all plugins and themes from src wordpress, matching all versions and active vs. inactive plugin and theme states
+      desc "Gets a list of all non-mu plugins and themes on SOURCE WP instance and installs them to DESTINATION WP instance, but does not activate them. Activation status is already determined by the copied-over database."
+      task :download_plugins_and_themes do
 
-          data_for_plugins = []
-          data_for_themes = []
+        data_for_plugins = []
+        data_for_themes = []
 
-          # Within src wp instance, get list of all plugins and themes with version
+        # Within src wp instance, get list of all plugins and themes with version
+        on fetch(:remote_user) + '@' + fetch(:src_wp_server) do
           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'))
+            data_for_plugins = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:src_multisite_domain)}" : ''), 'plugin', 'list', '--fields=name,version,status', '--format=json'))
+            data_for_themes = JSON.parse(capture(:wp, (fetch(:multisite, false) ? "--url=#{fetch(:src_multisite_domain)}" : ''), 'theme', 'list', '--fields=name,version,status', '--format=json'))
           end
+        end
 
-          # Within dest wp instance, install specifically versioned plugins and themes
+        # Within dest wp instance, install specifically versioned plugins and themes
+        on roles(:web) do
           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
@@ -220,12 +265,8 @@ namespace :cul do
               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 'active', 'active-network', 'inactive'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:dest_multisite_domain)}" : ''), '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
@@ -238,26 +279,25 @@ namespace :cul do
 
               case status
               when 'active'
-                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:destination_site_multisite_url)}" : ''), 'theme', 'install', name, "--version=#{version}", '--activate'
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:dest_multisite_domain)}" : ''), '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}"
+                execute :wp, (fetch(:multisite, false) ? "--url=#{fetch(:dest_multisite_domain)}" : ''), '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'
+      desc 'Sets correct permissions for files in the WP docroot.'
+      task :set_correct_wp_docroot_permissions do
+        # Make wp-content readable and executable for "other" user so nginx, which runs as "nobody", can read wp-files.
+        # Use -L flag because we want to follow symlinks. The 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.php is not world readable. It's only run by php, not nginx.
+        execute :chmod, 'o-r', File.join(fetch(:wp_docroot), 'wp-config.php')
+      end
 
     end
   end

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

@@ -0,0 +1,73 @@
+namespace :cul do
+  namespace :wp do
+
+    task :setup do
+      desc "Downloads a new copy of wordpress, completely overwriting any existing site files. To install WordPress, follow this setup task with the cul:wp:install task."
+      require_cap_variables!([:wp_docroot])
+
+      unless enter_y_to_continue(color_text("This will delete all content at #{fetch(:wp_docroot)}."))
+        puts 'Operation cancelled because "y" was not entered.'
+        next
+      end
+
+      on roles(:web) do
+        within(deploy_path) do
+
+          # Destroy and recreate the docroot
+          execute :rm, '-rf', fetch(:wp_docroot), '&&', 'mkdir', fetch(:wp_docroot)
+
+          # Create nginx logs directory if it doesn't already exist
+          execute :mkdir, '-p', deploy_path.join('logs')
+
+          # Download and unpack latest version of WP to wp_docroot
+          execute :wp, 'core', ['download', "--version=latest", "--path=#{fetch(:wp_docroot)}"]
+
+          # Create a limited-content wp-config.php file that requires our shared
+          # wp-config-include.php file. We do this so that wordpress still has a
+          # wp-config.php file at the expected location, and that file correctly
+          # sets the ABSPATH constant based on the wp-config.php file location.
+
+          # Our limited-content wp-config file will only contain the following:
+          # ----------------------------------------------------------
+          # require dirname(__DIR__) . '/conf/the-real-conf.php';
+          #
+          #/* That's all, stop editing! Happy blogging. */
+          #
+          #/** WordPress absolute path to the Wordpress directory. */
+          #if ( !defined('ABSPATH') )
+          #        define('ABSPATH', dirname(__FILE__) . '/');
+          #
+          #/** Sets up WordPress vars and included files. */
+          #require_once(ABSPATH . 'wp-settings.php');
+          #?>
+          # ----------------------------------------------------------
+          execute :echo, '-e', '"' +
+            "<?php" +
+              '\\n' +
+              "require dirname(__DIR__) . '/shared/wp-config-include.php';" +
+              '\\n\\n' +
+              "/* That's all, stop editing! Happy blogging. */" +
+              '\\n' +
+              "/** WordPress absolute path to the Wordpress directory. */" +
+              '\\n' +
+              "if ( !defined('ABSPATH') ) { define('ABSPATH', dirname(__FILE__) . '/'); }" +
+              '\\n\\n' +
+              "/** Sets up WordPress vars and included files. */" +
+              '\\n' +
+              "require_once(ABSPATH . 'wp-settings.php');" +
+              '\\n' +
+            "?>" +
+          '"',
+          '>',
+          File.join(fetch(:wp_docroot), 'wp-config.php')
+        end
+      end
+
+      # After setup, do a deployment so we have the latest plugins and themes
+      # available and symlinked in wp-content
+      invoke 'deploy'
+
+    end
+
+  end
+end