wordmove 5.2.1 → 6.0.0.alpha.3

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

@@ -0,0 +1,71 @@
+module Wordmove
+  module Actions
+    module Ftp
+      # Downloads the remote DB over FTP protocol
+      class DownloadRemoteDb
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+        include Wordmove::Actions::Ftp::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::FTP]
+        # @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'
+
+          if simulate?(cli_options: context.cli_options)
+            context.logger.info 'A dump of the remote DB would have been saved into ' \
+                                "#{context.db_paths.local.path}, " \
+                                'but you\'re simulating'
+            next context
+          end
+
+          result = Wordmove::Actions::PutFile.execute(
+            photocopier: context.photocopier,
+            logger: context.logger,
+            cli_options: context.cli_options,
+            command_args: [
+              context.db_paths.ftp.local.generated_dump_script_path,
+              context.db_paths.ftp.remote.dump_script_path
+            ]
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          dump_url = [
+            context.db_paths.ftp.remote.dump_script_url,
+            '?shared_key=',
+            context.db_paths.ftp.token
+          ].join
+
+          begin
+            download(url: dump_url, local_path: context.db_paths.local.path)
+          rescue => _e # rubocop:disable Style/RescueStandardError
+            context.fail_and_return!(e.message)
+          end
+
+          unless File.exist? context.db_paths.local.path
+            context.fail_and_return!('Download of remote DB failed')
+          end
+
+          context.logger.success "Remote DB dump downloaded in #{context.db_paths.local.path}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module Wordmove
+  module Actions
+    module Ftp
+      # Syncs a whole directory over FTP protocol from the remote server to local host
+      class GetDirectory
+        extend LightService::Action
+        include Wordmove::Actions::Helpers
+        include WordpressDirectory::RemoteHelperMethods
+        include WordpressDirectory::LocalHelperMethods
+
+        # :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::FTP]
+        # @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'
+
+          # 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) || [
+            send(
+              "remote_#{context.folder_task}_dir",
+              remote_options: context.remote_options
+            ).path,
+            send(
+              "local_#{context.folder_task}_dir",
+              local_options: context.local_options
+            ).path,
+            paths_to_exclude(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 pull #{context.folder_task}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Wordmove
+  module Actions
+    module Ftp
+      module Helpers
+        extend ActiveSupport::Concern
+
+        class_methods do # rubocop:disable Metrics/BlockLength
+          #
+          # (In)Utility method to retrieve ftp options from the superset of remote options
+          #
+          # @param [Hash] remote_options Remote host options fetched from movefile
+          #               (with symbolized keys)
+          #
+          # @return [Hash] Ftp options from the movefile
+          #
+          def ftp_options(remote_options:)
+            remote_options[:ftp]
+          end
+
+          #
+          # Escape a string to be printed into PHP files
+          #
+          # @param [String] string The string to escape
+          #
+          # @return [String] The escaped string
+          #
+          def escape_php(string:)
+            return '' unless string
+
+            # replaces \ with \\
+            # replaces ' with \'
+            string.gsub('\\', '\\\\\\').gsub(/'/, '\\\\\'')
+          end
+
+          #
+          # Generate a token
+          #
+          # @return [String] A random hexadecimal string
+          #
+          def remote_php_scripts_token
+            SecureRandom.hex(40)
+          end
+
+          #
+          # Generate THE PHP dump script, protected by a token to ensure only Wordmove will run it
+          #
+          # @param [Hash] remote_db_options The remote DB configurations fetched from movefile
+          # @param [String] token The token that will be used to protect the execution of the script
+          #
+          # @return [String] The PHP file as string
+          #
+          def generate_dump_script(remote_db_options:, token:)
+            template = ERB.new(
+              File.read(File.join(File.dirname(__FILE__), '../../assets/dump.php.erb'))
+            )
+            template.result(binding)
+          end
+
+          #
+          # Generate THE PHP import script, protected by a token to ensure only Wordmove will run it
+          #
+          # @param [Hash] remote_db_options The remote DB configurations fetched from movefile
+          # @param [String] token The token that will be used to protect the execution of the script
+          #
+          # @return [String] The PHP file as string
+          #
+          def generate_import_script(remote_db_options:, token:)
+            template = ERB.new(
+              File.read(File.join(File.dirname(__FILE__), '../../assets/import.php.erb'))
+            )
+            template.result(binding)
+          end
+
+          #
+          # Download a file from the internet making a simple GET request
+          #
+          # @param [String] url The URL of the resource to download
+          # @param [String] local_path The local path where the resource will be saved
+          #
+          # @return [nil]
+          #
+          def download(url:, local_path:)
+            File.open(local_path, 'w') do |file|
+              file << URI.parse(url).read
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ftp/pull_wordpress.rb

@@ -0,0 +1,56 @@
+module Wordmove
+  module Actions
+    module Ftp
+      # Syncs wordpress folder (usually root folder), exluding +wp-content/+ folder, over FTP
+      # protocol from the remote server to local host
+      class PullWordpress
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+        include WordpressDirectory::RemoteHelperMethods
+
+        expects :remote_options,
+                :local_options,
+                :logger,
+                :photocopier
+
+        # @!method execute
+        # @param remote_options [Hash] Remote host options fetched from
+        #        movefile (with symbolized keys)
+        # @param local_options [Hash] Local host options fetched from
+        #        movefile (with symbolized keys)
+        # @param logger [Wordmove::Logger]
+        # @param photocopier [Photocopier::FTP]
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context|
+          local_path = context.local_options[:wordpress_path]
+
+          remote_path = context.remote_options[:wordpress_path]
+
+          wp_content_relative_path = remote_wp_content_dir(
+            remote_options: context.remote_options
+          ).relative_path
+
+          exclude_wp_content = exclude_dir_contents(
+            path: wp_content_relative_path
+          )
+
+          exclude_paths = paths_to_exclude(
+            remote_options: context.remote_options
+          ).push(exclude_wp_content)
+
+          result = Wordmove::Actions::Ftp::GetDirectory.execute(
+            photocopier: context.photocopier,
+            logger: context.logger,
+            command_args: [remote_path, local_path, exclude_paths],
+            folder_task: :wordpress,
+            local_options: context.local_options,
+            remote_options: context.remote_options,
+            cli_options: context.cli_options
+          )
+          context.fail!(result.message) if result.failure?
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ftp/push_wordpress.rb

@@ -0,0 +1,54 @@
+module Wordmove
+  module Actions
+    module Ftp
+      # Syncs wordpress folder (usually root folder), exluding +wp-content/+ folder, over FTP
+      # protocol from local host to the remote server
+      class PushWordpress
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+        include WordpressDirectory::LocalHelperMethods
+
+        expects :remote_options,
+                :local_options,
+                :logger,
+                :photocopier
+
+        # @!method execute
+        # @param remote_options [Hash] Remote host options fetched from
+        #        movefile (with symbolized keys)
+        # @param local_options [Hash] Local host options fetched from
+        #        movefile (with symbolized keys)
+        # @param logger [Wordmove::Logger]
+        # @param photocopier [Photocopier::FTP]
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context|
+          local_path = context.local_options[:wordpress_path]
+
+          remote_path = context.remote_options[:wordpress_path]
+
+          wp_content_relative_path = local_wp_content_dir(
+            local_options: context.local_options
+          ).relative_path
+
+          exclude_wp_content = exclude_dir_contents(path: wp_content_relative_path)
+
+          exclude_paths = paths_to_exclude(
+            remote_options: context.remote_options
+          ).push(exclude_wp_content)
+
+          result = Wordmove::Actions::Ftp::PutDirectory.execute(
+            photocopier: context.photocopier,
+            logger: context.logger,
+            command_args: [local_path, remote_path, exclude_paths],
+            folder_task: :wordpress,
+            local_options: context.local_options,
+            remote_options: context.remote_options,
+            cli_options: context.cli_options
+          )
+          context.fail!(result.message) if result.failure?
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ftp/put_and_import_dump_remotely.rb

@@ -0,0 +1,83 @@
+module Wordmove
+  module Actions
+    module Ftp
+      # Uploads a DB dump to remote host and import it in the remote database over FTP protocol
+      class PutAndImportDumpRemotely
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+        include Wordmove::Actions::Ftp::Helpers
+        include WordpressDirectory::RemoteHelperMethods
+        include WordpressDirectory::LocalHelperMethods
+
+        expects :remote_options,
+                :cli_options,
+                :logger,
+                :photocopier,
+                :db_paths
+
+        # @!method execute
+        # @param logger [Wordmove::Logger]
+        # @param cli_options [Hash] Command line options (with symbolized keys)
+        # @param remote_options [Hash] Remote host options fetched from
+        #        movefile (with symbolized keys)
+        # @param db_paths [BbPathsConfig] Configuration object for database
+        # @param photocopier [Photocopier::FTP]
+        # @!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 'Upload and import adapted DB'
+
+          result = Wordmove::Actions::PutFile.execute(
+            logger: context.logger,
+            photocopier: context.photocopier,
+            cli_options: context.cli_options,
+            command_args: [
+              context.db_paths.local.adapted_path,
+              context.db_paths.remote.path
+            ]
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          result = Wordmove::Actions::PutFile.execute(
+            logger: context.logger,
+            photocopier: context.photocopier,
+            cli_options: context.cli_options,
+            command_args: [
+              context.db_paths.ftp.local.generated_import_script_path,
+              context.db_paths.ftp.remote.import_script_path
+            ]
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          import_url = [
+            context.db_paths.ftp.remote.import_script_url,
+            '?shared_key=',
+            context.db_paths.ftp.token,
+            '&start=1&foffset=0&totalqueries=0&fn=dump.sql'
+          ].join
+
+          download(url: import_url, local_path: context.db_paths.ftp.local.temp_path)
+
+          if context.cli_options[:debug]
+            context.logger.debug "Operation log located at: #{context.db_paths.ftp.local.temp_path}"
+          else
+            result = Wordmove::Actions::DeleteLocalFile.execute(
+              cli_options: context.cli_options,
+              logger: context.logger,
+              file_path: context.db_paths.ftp.local.temp_path
+            )
+
+            if result.failure?
+              context.logger.warning 'Failed to delete local file ' \
+                                     "#{context.db_paths.ftp.local.temp_path} because: " \
+                                     "#{result.message}" \
+                                     '. Manual intervention required'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/actions/ftp/put_directory.rb

@@ -0,0 +1,67 @@
+module Wordmove
+  module Actions
+    module Ftp
+      # Syncs a whole directory over FTP protocol from local host to remote server
+      class PutDirectory
+        extend LightService::Action
+        include Wordmove::Actions::Helpers
+        include WordpressDirectory::LocalHelperMethods
+        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::FTP]
+        # @param folder_task [Symbol] Symbolazied folder name
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context|
+          context.logger.task "Pushing #{context.folder_task}"
+
+          next context if simulate?(cli_options: context.cli_options)
+
+          command = 'put_directory'
+
+          # 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 `"local_#{context.folder_task}_dir"` could
+          # not be defined.
+          command_args = context.fetch(:command_args) || [
+            send(
+              "local_#{context.folder_task}_dir",
+              local_options: context.local_options
+            ).path,
+            send(
+              "remote_#{context.folder_task}_dir",
+              remote_options: context.remote_options
+            ).path,
+            paths_to_exclude(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/get_file.rb

@@ -0,0 +1,38 @@
+module Wordmove
+  module Actions
+    # Download a single file from 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 GetFile
+      extend LightService::Action
+      include Wordmove::Actions::Helpers
+
+      expects :photocopier,
+              :logger,
+              :cli_options,
+              :command_args
+
+      # @!method execute
+      # @param photocopier [Photocopier::SSH|Photocopier::FTP]
+      # @param logger [Wordmove::Logger]
+      # @param cli_options [Hash] Command line options (with symbolized keys)
+      # @param command_args ((String) remote file path, (String) local file path)
+      # @!scope class
+      # @return [LightService::Context] Action's context
+      executed do |context|
+        command = 'get'
+
+        context.logger.task_step false, "#{command}: #{context.command_args.join(' ')}"
+
+        next context if simulate?(cli_options: context.cli_options)
+
+        result = context.photocopier.send(command, *context.command_args)
+
+        next context if result == true
+
+        context.fail! "Failed to download file: #{context.command_args.first}"
+      end
+    end
+  end
+end

data/lib/wordmove/actions/helpers.rb

@@ -0,0 +1,142 @@
+module Wordmove
+  module Actions
+    # Helpers for +Wordmove::Actions+
+    #
+    # All helpers methos are class methods; this way we force avoiding the use
+    # of persistence. All actions have to be approached more as functional code
+    # than OO code. Thus helpers are condidered as functional code too.
+    module Helpers
+      extend ActiveSupport::Concern
+
+      # rubocop:disable Metrics/BlockLength
+      class_methods do
+        # Determines if we're running a simulated command. Actually this is a
+        # wrapper around command line arguments set by the user.
+        #
+        # @param cli_options [Hash] Command line options hash (deep symbolized).
+        #        Generally you will find this into action's context
+        # @return [Boolean]
+        # @!scope class
+        def simulate?(cli_options:)
+          cli_options.fetch(:simulate, false)
+        end
+
+        # Returns the path to be excluded as per movefile.yml configuration.
+        # `remote_options` is always valid for both push and pull actions,
+        # because path exclusions are configured only on remote environments
+        #
+        # @param remote_options [Hash] The options hash for the selected remote
+        #        remote environment. Generally you will find this into action's context.
+        # @return [Array<String>]
+        # @!scope class
+        def paths_to_exclude(remote_options:)
+          remote_options.fetch(:exclude, [])
+        end
+
+        # Given a path, it will append the `/*` string to it. This is how
+        # folder content - thus not the folder itself - is represented by rsync.
+        # The name of this method is not explicative nor expressive, but we retain
+        # it for backward compatibility.
+        #
+        # @param path [String]
+        # @return [String]
+        # @!scope class
+        def exclude_dir_contents(path:)
+          "#{path}/*"
+        end
+
+        # Construct the mysql dump command as a string
+        #
+        # @param env_db_options [Hash] This hash is defined by the user through movefile.yml
+        # @param save_to_path [String] The path where the db dump will be saved
+        # @return [String] The full composed mysql command
+        # @!scope class
+        def mysql_dump_command(env_db_options:, save_to_path:)
+          command = ['mysqldump']
+
+          if env_db_options[:host].present?
+            command << "--host=#{Shellwords.escape(env_db_options[:host])}"
+          end
+
+          if env_db_options[:port].present?
+            command << "--port=#{Shellwords.escape(env_db_options[:port])}"
+          end
+
+          if env_db_options[:user].present?
+            command << "--user=#{Shellwords.escape(env_db_options[:user])}"
+          end
+
+          if env_db_options[:password].present?
+            command << "--password=#{Shellwords.escape(env_db_options[:password])}"
+          end
+
+          command << "--result-file=\"#{save_to_path}\""
+
+          if env_db_options[:mysqldump_options].present?
+            command << Shellwords.split(env_db_options[:mysqldump_options])
+          end
+
+          command << Shellwords.escape(env_db_options[:name])
+
+          command.join(' ')
+        end
+
+        # Construct the mysql import command as a string
+        #
+        # @param dump_path [String] The path where the dump to import is located
+        # @param env_db_options [Hash] This hash is defined by the user through movefile.yml
+        # @return [String] The full composed mysql command
+        # @!scope class
+        def mysql_import_command(dump_path:, env_db_options:)
+          command = ['mysql']
+          %i[host port user].each do |option|
+            if env_db_options[option].present?
+              command << "--#{option}=#{Shellwords.escape(env_db_options[option])}"
+            end
+          end
+          if env_db_options[:password].present?
+            command << "--password=#{Shellwords.escape(env_db_options[:password])}"
+          end
+          command << "--database=#{Shellwords.escape(env_db_options[:name])}"
+          if env_db_options[:mysql_options].present?
+            command << Shellwords.split(env_db_options[:mysql_options])
+          end
+          command << "--execute=\"SET autocommit=0;SOURCE #{dump_path};COMMIT\""
+          command.join(' ')
+        end
+
+        # Construct the command to compress a file as a string. The command will be wrapped
+        # as argument to the +nice+ command, in order to lower the process priority and do
+        # not lock the system while compressing large files.
+        #
+        # @param file_path [String] The path where the file to be compressed is located
+        # @return [String] the command
+        # @!scope class
+        def compress_command(file_path:)
+          command = ['nice']
+          command << '-n'
+          command << '0'
+          command << 'gzip'
+          command << '-9'
+          command << '-f'
+          command << "\"#{file_path}\""
+          command.join(' ')
+        end
+
+        # Construct the command to deflate a compressed file as a string.
+        #
+        # @param file_path [String] The path where the file to be deflated is located
+        # @return [String] the command
+        # @!scope class
+        def uncompress_command(file_path:)
+          command = ['gzip']
+          command << '-d'
+          command << '-f'
+          command << "\"#{file_path}\""
+          command.join(' ')
+        end
+      end
+      # rubocop:enable Metrics/BlockLength
+    end
+  end
+end