wordmove 5.2.1 → 6.0.0.alpha.3

data/lib/wordmove/actions/put_file.rb

@@ -0,0 +1,48 @@
+module Wordmove
+  module Actions
+    # Upload a single file to the remote server.
+    #
+    # @note The remote server is already configured inside the Photocopier object
+    # @note This action is *not* meant to be organized, but as a standalone one.
+    class PutFile
+      extend LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :photocopier,
+              :logger,
+              :command_args,
+              :cli_options
+
+      # @!method execute
+      #   @param photocopier [Photocopier]
+      #   @param logger [Wordmove::Logger]
+      #   @param command_args ((String) local file path, (String) remote file path)
+      #   @return [LightService::Context] Action's context
+      executed do |context|
+        command = 'put'
+
+        # First argument could be a file or a content string. Do not log if the latter
+        message = if File.exist?(context.command_args.first)
+                    context.command_args.join(' ')
+                  else
+                    context.command_args.second
+                  end
+
+        context.logger.task_step false, "#{command}: #{message}"
+
+        result = if simulate?(cli_options: context.cli_options)
+                   true
+                 else
+                   context.photocopier.send(command, *context.command_args)
+                 end
+
+        next context if result == true
+        # We can't trust the return from the fotocopier method when using FTP.  Keep on
+        # and have faith.
+        next context if context.photocopier.is_a? Photocopier::FTP
+
+        context.fail! "Failed to upload file: #{context.command_args.first}"
+      end
+    end
+  end
+end

data/lib/wordmove/actions/run_after_pull_hook.rb

@@ -0,0 +1,26 @@
+module Wordmove
+  module Actions
+    # Runs before push hooks by invoking the external service
+    # Wordmove::Hook
+    class RunAfterPullHook
+      extend ::LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :movefile,
+              :cli_options
+
+      # @!method execute
+      #   @param movefile [Wordmove::Movefile]
+      #   @param cli_options [Hash]
+      #   @return [LightService::Context] Action's context
+      executed do |context|
+        Wordmove::Hook.run(
+          :pull,
+          :after,
+          movefile: context.movefile,
+          simulate: simulate?(cli_options: context.cli_options)
+        )
+      end
+    end
+  end
+end

data/lib/wordmove/actions/run_after_push_hook.rb

@@ -0,0 +1,26 @@
+module Wordmove
+  module Actions
+    # Runs after push hooks by invoking the external service
+    # Wordmove::Hook
+    class RunAfterPushHook
+      extend ::LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :movefile,
+              :cli_options
+
+      # @!method execute
+      #   @param movefile [Wordmove::Movefile]
+      #   @param cli_options [Hash]
+      #   @return [LightService::Context] Action's context
+      executed do |context|
+        Wordmove::Hook.run(
+          :push,
+          :after,
+          movefile: context.movefile,
+          simulate: simulate?(cli_options: context.cli_options)
+        )
+      end
+    end
+  end
+end

data/lib/wordmove/actions/run_before_pull_hook.rb

@@ -0,0 +1,26 @@
+module Wordmove
+  module Actions
+    # Runs before pull hooks by invoking the external service
+    # Wordmove::Hook
+    class RunBeforePullHook
+      extend ::LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :movefile,
+              :cli_options
+
+      # @!method execute
+      #   @param movefile [Wordmove::Movefile]
+      #   @param cli_options [Hash]
+      #   @return [LightService::Context] Action's context
+      executed do |context|
+        Wordmove::Hook.run(
+          :pull,
+          :before,
+          movefile: context.movefile,
+          simulate: simulate?(cli_options: context.cli_options)
+        )
+      end
+    end
+  end
+end

data/lib/wordmove/actions/run_before_push_hook.rb

@@ -0,0 +1,26 @@
+module Wordmove
+  module Actions
+    # Runs before push hooks by invoking the external service
+    # Wordmove::Hook
+    class RunBeforePushHook
+      extend ::LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :movefile,
+              :cli_options
+
+      # @!method execute
+      #   @param movefile [Wordmove::Movefile]
+      #   @param cli_options [Hash]
+      #   @return [LightService::Context] Action's context
+      executed do |context|
+        Wordmove::Hook.run(
+          :push,
+          :before,
+          movefile: context.movefile,
+          simulate: simulate?(cli_options: context.cli_options)
+        )
+      end
+    end
+  end
+end

data/lib/wordmove/actions/run_local_command.rb

@@ -0,0 +1,34 @@
+require 'English'
+
+module Wordmove
+  module Actions
+    # Run a command on the local system.
+    # Command won't be run if +--simulate+ flag is present on CLI.
+    # @note This action is *not* meant to be organized, but as a standalone one.
+    class RunLocalCommand
+      extend LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :command,
+              :cli_options,
+              :logger
+
+      # @!method execute
+      #   @param command [String] The command to run
+      #   @param cli_options [Hash]
+      #   @param logger [Wordmove::Logger]
+      #   @return [LightService::Context] Action's context
+      executed do |context|
+        context.logger.task_step true, context.command
+
+        next context if simulate?(cli_options: context.cli_options)
+
+        begin
+          system(context.command, exception: true)
+        rescue RuntimeError, SystemExit => e
+          context.fail!("Local command status reports an error: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/setup_context_for_db.rb

@@ -0,0 +1,78 @@
+module Wordmove
+  module Actions
+    class SetupContextForDb
+      extend ::LightService::Action
+      include Wordmove::Actions::Helpers
+      include Wordmove::Actions::Ftp::Helpers
+      include WordpressDirectory::LocalHelperMethods
+      include WordpressDirectory::RemoteHelperMethods
+
+      expects :cli_options,
+              :local_options,
+              :remote_options,
+              :logger,
+              :movefile,
+              :database_task
+      promises :db_paths
+
+      executed do |context| # rubocop:disable Metrics/BlockLength
+        if context.database_task == false
+          context.db_paths = false
+          next context
+        end
+
+        next context if simulate?(cli_options: context.cli_options)
+
+        content_dir = local_wp_content_dir(local_options: context.local_options)
+
+        token = remote_php_scripts_token
+
+        DbPathsConfig.local.path = content_dir.path('dump.sql')
+        DbPathsConfig.local.gzipped_path = "#{DbPathsConfig.local.path}.gz"
+        DbPathsConfig.remote.path = remote_wp_content_dir(
+          remote_options: context.remote_options
+        ).path('dump.sql')
+        DbPathsConfig.remote.gzipped_path = "#{DbPathsConfig.remote.path}.gz"
+        DbPathsConfig.local.adapted_path = content_dir.path('search_replace_dump.sql')
+        DbPathsConfig.local.gzipped_adapted_path = "#{DbPathsConfig.local.adapted_path}.gz"
+        DbPathsConfig.backup.local.path = content_dir.path("local-backup-#{Time.now.to_i}.sql")
+        DbPathsConfig.backup.local.gzipped_path = "#{DbPathsConfig.backup.local.path}.gz"
+        DbPathsConfig.backup.remote.path =
+          content_dir.path("#{context.movefile.environment}-backup-#{Time.now.to_i}.sql")
+        DbPathsConfig.backup.remote.gzipped_path = "#{DbPathsConfig.backup.remote.path}.gz"
+
+        DbPathsConfig.ftp.remote.dump_script_path = remote_wp_content_dir(
+          remote_options: context.remote_options
+        ).path('dump.php')
+        DbPathsConfig.ftp.remote.dumped_path = remote_wp_content_dir(
+          remote_options: context.remote_options
+        ).path('dump.mysql')
+        DbPathsConfig.ftp.remote.dump_script_url = remote_wp_content_dir(
+          remote_options: context.remote_options
+        ).url('dump.php')
+        DbPathsConfig.ftp.remote.import_script_path = remote_wp_content_dir(
+          remote_options: context.remote_options
+        ).path('import.php')
+        DbPathsConfig.ftp.remote.import_script_url = remote_wp_content_dir(
+          remote_options: context.remote_options
+        ).url('import.php')
+        DbPathsConfig.ftp.local.generated_dump_script_path = generate_dump_script(
+          remote_db_options: context.remote_options[:database],
+          token: token
+        )
+        DbPathsConfig.ftp.local.generated_import_script_path = generate_import_script(
+          remote_db_options: context.remote_options[:database],
+          token: token
+        )
+        DbPathsConfig.ftp.local.temp_path = local_wp_content_dir(
+          local_options: context.local_options
+        ).path('log.html')
+        # I know this is not a path, but it's used to generate
+        # a URL to dump the DB, so it's somewhat in context
+        DbPathsConfig.ftp.token = token
+
+        context.db_paths = DbPathsConfig
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ssh/backup_remote_db.rb

@@ -0,0 +1,51 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Bakups an alrady downloaded remote dump
+      class BackupRemoteDb
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+
+        expects :cli_options,
+                :logger,
+                :db_paths
+
+        # @!method execute
+        # @param cli_options [Hash] Command line options (with symbolized keys)
+        # @param logger [Wordmove::Logger]
+        # @param db_paths [BbPathsConfig] Configuration object for database
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context|
+          next context if context.database_task == false
+
+          context.logger.task 'Backup remote DB'
+
+          if simulate?(cli_options: context.cli_options)
+            context.logger.info 'A backup of the remote DB would have been saved into ' \
+                                "#{context.db_paths.backup.remote.gzipped_path}, " \
+                                'but you\'re simulating'
+            next context
+          end
+
+          # Most of the expectations are needed to be proxied to `DownloadRemoteDb`
+          # Wordmove::Actions::Ssh::DownloadRemoteDb.execute(context)
+          # DownloadRemoteDB will save the file in `db_paths.local.gzipped_path`
+
+          begin
+            FileUtils.mv(
+              context.db_paths.local.gzipped_path,
+              context.db_paths.backup.remote.gzipped_path
+            )
+
+            context.logger.success(
+              "Backup saved at #{context.db_paths.backup.remote.gzipped_path}"
+            )
+          rescue Errno::ENOENT => e
+            context.fail_and_return!("Remote DB backup failed with: #{e.message}. Aborting.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ssh/cleanup_after_adapt.rb

@@ -0,0 +1,56 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Cleanup file created during DB push/pull operations
+      class CleanupAfterAdapt
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+
+        expects :db_paths,
+                :cli_options,
+                :logger
+
+        # @!method execute
+        # @param db_paths [BbPathsConfig] Configuration object for database
+        # @param cli_options [Hash] Command line options (with symbolized keys)
+        # @param logger [Wordmove::Logger]
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context| # rubocop:disable Metrics/BlockLength
+          next context if context.database_task == false
+
+          context.logger.task 'Cleanup'
+
+          if simulate?(cli_options: context.cli_options)
+            context.logger.info 'No cleanup during simulation'
+            next context
+          end
+
+          result = Wordmove::Actions::DeleteLocalFile.execute(
+            logger: context.logger,
+            cli_options: context.cli_options,
+            file_path: context.db_paths.local.path
+          )
+          if result.failure?
+            context.logger.warning 'Failed to delete local file ' \
+                                   "#{context.db_paths.local.path} because: " \
+                                   "#{result.message}" \
+                                   '. Manual intervention required'
+          end
+
+          result = Wordmove::Actions::DeleteLocalFile.execute(
+            cli_options: context.cli_options,
+            logger: context.logger,
+            file_path: context.db_paths.local.gzipped_adapted_path
+          )
+          if result.failure?
+            context.logger.warning 'Failed to delete local file ' \
+                                   "#{context.db_paths.local.gzipped_adapted_path} because: " \
+                                   "#{result.message}" \
+                                   '. Manual intervention required'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ssh/download_remote_db.rb

@@ -0,0 +1,83 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Downloads the remote DB over SSH protocol
+      class DownloadRemoteDb
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+        include WordpressDirectory::LocalHelperMethods
+        include WordpressDirectory::RemoteHelperMethods
+
+        expects :remote_options,
+                :cli_options,
+                :logger,
+                :photocopier,
+                :db_paths
+
+        # @!method execute
+        # @param remote_options [Hash] Remote host options fetched from
+        #        movefile (with symbolized keys)
+        # @param cli_options [Hash] Command line options (with symbolized keys)
+        # @param logger [Wordmove::Logger]
+        # @param photocopier [Photocopier::SSH]
+        # @param db_paths [BbPathsConfig] Configuration object for database
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context| # rubocop:disable Metrics/BlockLength
+          next context if context.database_task == false
+
+          context.logger.task 'Download remote DB'
+
+          next context if simulate?(cli_options: context.cli_options)
+
+          result = Wordmove::Actions::Ssh::RunRemoteCommand.execute(
+            cli_options: context.cli_options,
+            photocopier: context.photocopier,
+            logger: context.logger,
+            command: mysql_dump_command(
+              env_db_options: context.remote_options[:database],
+              save_to_path: context.db_paths.remote.path
+            )
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          result = Wordmove::Actions::Ssh::RunRemoteCommand.execute(
+            cli_options: context.cli_options,
+            photocopier: context.photocopier,
+            logger: context.logger,
+            command: compress_command(file_path: context.db_paths.remote.path)
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          result = Wordmove::Actions::GetFile.execute(
+            photocopier: context.photocopier,
+            logger: context.logger,
+            cli_options: context.cli_options,
+            command_args: [
+              context.db_paths.remote.gzipped_path,
+              context.db_paths.local.gzipped_path
+            ]
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          result = Wordmove::Actions::DeleteRemoteFile.execute(
+            photocopier: context.photocopier,
+            logger: context.logger,
+            cli_options: context.cli_options,
+            remote_file: context.db_paths.remote.gzipped_path
+          )
+          if result.failure?
+            context.logger.warning 'Failed to delete remote file ' \
+                                   "#{context.db_paths.remote.gzipped_path} because: " \
+                                   "#{result.message}" \
+                                   '. Manual intervention required'
+          end
+
+          context.logger.success(
+            "Remote DB dump downloaded in #{context.db_paths.local.gzipped_path}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ssh/get_directory.rb

@@ -0,0 +1,76 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Syncs a whole directory over SSH protocol from the remote server to local host
+      class GetDirectory
+        extend LightService::Action
+        include Wordmove::Actions::Helpers
+        include Wordmove::Actions::Ssh::Helpers
+        include WordpressDirectory::RemoteHelperMethods
+
+        # :folder_task is expected to be one symbol from Wordmove::CLI.wordpress_options array
+        expects :logger,
+                :local_options,
+                :remote_options,
+                :cli_options,
+                :photocopier,
+                :folder_task
+
+        # @!method execute
+        # @param logger [Wordmove::Logger]
+        # @param local_options [Hash] Local host options fetched from
+        #        movefile (with symbolized keys)
+        # @param remote_options [Hash] Remote host options fetched from
+        #        movefile (with symbolized keys)
+        # @param cli_options [Hash] Command line options (with symbolized keys)
+        # @param photocopier [Photocopier::SSH]
+        # @param folder_task [Symbol] Symbolazied folder name
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context|
+          context.logger.task "Pulling #{context.folder_task}"
+
+          next context if simulate?(cli_options: context.cli_options)
+
+          command = 'get_directory'
+          # For this action `local_path` and `remote_path` will always be
+          # `:wordpress_path`; specific folder for `context.folder_task` will be included by
+          # `pull_include_paths`
+          local_path = context.local_options[:wordpress_path]
+          remote_path = context.remote_options[:wordpress_path]
+
+          # This action can generate `command_args` by itself,
+          # but it gives the context the chance to ovveride it.
+          # By the way this variable is not `expects`ed.
+          # Note that we do not use the second argument to `fetch`
+          # to express a default value, because it would be greedly interpreted
+          # but if `command_args` is already defined by context, then it's
+          # possible that `"remote_#{context.folder_task}_dir"` could
+          # not be defined.
+          command_args = context.fetch(:command_args) || [
+            remote_path,
+            local_path,
+            pull_exclude_paths(
+              remote_task_dir: send(
+                "remote_#{context.folder_task}_dir",
+                remote_options: context.remote_options
+              ),
+              paths_to_exclude: paths_to_exclude(remote_options: context.remote_options)
+            ),
+            pull_include_paths(remote_task_dir: send(
+              "remote_#{context.folder_task}_dir",
+              remote_options: context.remote_options
+            ))
+          ]
+
+          context.logger.task_step false, "#{command}: #{command_args.join(' ')}"
+          result = context.photocopier.send(command, *command_args)
+
+          next context if result == true
+
+          context.fail!("Failed to push #{context.folder_task}")
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ssh/helpers.rb

@@ -0,0 +1,128 @@
+require 'pathname'
+
+# rubocop:disable Metrics/BlockLength
+module Wordmove
+  module Actions
+    module Ssh
+      module Helpers
+        extend ActiveSupport::Concern
+
+        class_methods do
+          #
+          # Utility method to retrieve and augment ssh options from the superset of remote options.
+          # This is useful most because it appends +--dy-run+ rsync's flag to ssh options based
+          # on +--simulate+ flag presence
+          #
+          # @param [Hash] remote_options Remote host options fetcehd from movefile
+          # @param [Bool] simulate Tell the moethod if you're in a simulated operation
+          #
+          # @return [Hash] Ssh options
+          #
+          def ssh_options(remote_options:, simulate: false)
+            ssh_options = remote_options[:ssh]
+
+            if simulate == true && ssh_options[:rsync_options]
+              ssh_options[:rsync_options].concat(' --dry-run')
+            elsif simulate == true
+              ssh_options[:rsync_options] = '--dry-run'
+            end
+
+            ssh_options
+          end
+
+          #
+          # Given the directory you're pushing/pulling, generates an array of path to be included
+          # by rsync while pushing. Note that by design include paths are always required but are
+          # only programmatically deduced and never user configured.
+          #
+          # @note The business logic behind how these paths are produced should be deepened
+          #
+          # @param [WordpressDirectory] local_task_dir An object representing a wordpress folder
+          #
+          # @return [Array<String>] The array of path to be included by rsync
+          #
+          def push_include_paths(local_task_dir:)
+            Pathname.new(local_task_dir.relative_path)
+                    .ascend
+                    .each_with_object([]) do |directory, array|
+                      path = directory.to_path
+                      path.prepend('/') unless path.match? %r{^/}
+                      path.concat('/') unless path.match? %r{/$}
+                      array << path
+                    end
+          end
+
+          #
+          # Given the directory you're pushing/pulling and the user configured exclude list,
+          # generates an array of path to be excluded
+          # by rsync while pushing. Note that by design exclude some paths are always required
+          # even when the user does not confiure any exclusion.
+          #
+          # @note The business logic behind how these paths are produced should be deepened
+          #
+          # @param [WordpressDirectory] local_task_dir An object representing a wordpress folder
+          # @param [Array<String>] pats_to_exclude An array of paths
+          #
+          # @return [Array<String>] The array of path to be included by rsync
+          #
+          def push_exclude_paths(local_task_dir:, paths_to_exclude:)
+            Pathname.new(local_task_dir.relative_path)
+                    .dirname
+                    .ascend
+                    .each_with_object([]) do |directory, array|
+                      path = directory.to_path
+                      path.prepend('/') unless path.match? %r{^/}
+                      path.concat('/') unless path.match? %r{/$}
+                      path.concat('*')
+                      array << path
+                    end
+                    .concat(paths_to_exclude)
+                    .concat(['/*'])
+          end
+
+          #
+          # Same as Wordmove::Actions::Ssh::Helpers.push_include_path but for pull actions
+          #
+          # @param [WordpressDirectory] local_task_dir An object representing a wordpress folder
+          #
+          # @return [Array<String>] An array of paths
+          #
+          def pull_include_paths(remote_task_dir:)
+            Pathname.new(remote_task_dir.relative_path)
+                    .ascend
+                    .each_with_object([]) do |directory, array|
+                      path = directory.to_path
+                      path.prepend('/') unless path.match? %r{^/}
+                      path.concat('/') unless path.match? %r{/$}
+                      array << path
+                    end
+          end
+
+          #
+          # Same as Wordmove::Actions::Ssh::Helpers.push_exclude_path but for pull actions
+          #
+          # @param [WordpressDirectory] local_task_dir An object representing a wordpress folder
+          # @param [Array<String>] paths_to_exclude User configured array of paths to exclude
+          #
+          # @return [Array<String>] Array of paths to be excluded
+          #
+          def pull_exclude_paths(remote_task_dir:, paths_to_exclude:)
+            Pathname.new(remote_task_dir.relative_path)
+                    .dirname
+                    .ascend
+                    .each_with_object([]) do |directory, array|
+                      path = directory.to_path
+                      path.prepend('/') unless path.match? %r{^/}
+                      path.concat('/') unless path.match? %r{/$}
+                      path.concat('*')
+                      array << path
+                    end
+                    .concat(paths_to_exclude)
+                    .concat(['/*'])
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength