wordmove-ng 6.0.0

data/lib/wordmove/hook.rb

@@ -0,0 +1,128 @@
+require 'shellwords'
+
+module Wordmove
+  class Hook
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      end
+    end
+
+    # rubocop:disable-next Metrics/MethodLength
+    def self.run(action, step, cli_options)
+      movefile = Wordmove::Movefile.new(cli_options[:config])
+      options = movefile.fetch(false)
+      environment = movefile.environment(cli_options)
+      self.logger = Logger.new(STDOUT, movefile.secrets).tap { |l| l.level = Logger::DEBUG }
+
+      hooks = Wordmove::Hook::Config.new(
+        options[environment][:hooks],
+        action,
+        step
+      )
+
+      return if hooks.empty?
+
+      logger.task "Running #{action}/#{step} hooks"
+
+      hooks.all_commands.each do |command|
+        case command[:where]
+        when 'local'
+          Wordmove::Hook::Local.run(command, options[:local], cli_options[:simulate])
+        when 'remote'
+          Wordmove::Hook::Remote.run(command, options[environment], cli_options[:simulate])
+        else
+          next
+        end
+      end
+    end
+
+    Config = Struct.new(:options, :action, :step) do
+      def empty?
+        all_commands.empty?
+      end
+
+      def all_commands
+        return [] if empty_step?
+
+        options[action][step] || []
+      end
+
+      def local_commands
+        return [] if empty_step?
+
+        options[action][step]
+          .select { |hook| hook[:where] == 'local' } || []
+      end
+
+      def remote_commands
+        return [] if empty_step?
+
+        options[action][step]
+          .select { |hook| hook[:where] == 'remote' } || []
+      end
+
+      private
+
+      def empty_step?
+        return true unless options
+        return true if options[action].nil?
+        return true if options[action][step].nil?
+        return true if options[action][step].empty?
+
+        false
+      end
+    end
+
+    class Local
+      def self.logger
+        Wordmove::Hook.logger
+      end
+
+      def self.run(command_hash, options, simulate = false)
+        wordpress_path = Shellwords.escape(options[:wordpress_path].to_s)
+        logger.task_step true, "Exec command: #{command_hash[:command]}"
+
+        return true if simulate
+
+        stdout_return = `cd #{wordpress_path} && #{command_hash[:command]} 2>&1`
+        logger.task_step true, "Output: #{stdout_return}"
+
+        if $CHILD_STATUS.exitstatus.zero?
+          logger.success ""
+        else
+          logger.error "Error code: #{$CHILD_STATUS.exitstatus}"
+          raise Wordmove::LocalHookException unless command_hash[:raise].eql? false
+        end
+      end
+    end
+
+    class Remote
+      def self.logger
+        Wordmove::Hook.logger
+      end
+
+      def self.run(command_hash, options, simulate = false)
+        wordpress_path = Shellwords.escape(options[:wordpress_path].to_s)
+        logger.task_step false, "Exec command: #{command_hash[:command]}"
+
+        return true if simulate
+
+        runner = Wordmove::SshRunner.new(options[:ssh])
+        stdout, stderr, exit_code =
+          runner.run("cd #{wordpress_path} && #{command_hash[:command]}")
+
+        if exit_code.zero?
+          logger.task_step false, "Output: #{stdout}"
+          logger.success ""
+        else
+          logger.task_step false, "Output: #{stderr}"
+          logger.error "Error code #{exit_code}"
+          raise Wordmove::RemoteHookException unless command_hash[:raise].eql? false
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/logger.rb

@@ -0,0 +1,165 @@
+require 'shellwords'
+
+module Wordmove
+  class Logger < ::Logger
+    MAX_LINE = 70
+
+    def initialize(device, strings_to_hide = [])
+      super(device, formatter: proc { |_severity, _datetime, _progname, message|
+        formatted_message = if strings_to_hide.empty?
+                              message
+                            else
+                              message.gsub(
+                                Regexp.new(
+                                  strings_to_hide.map { |string| Regexp.escape(string) }.join('|')
+                                ),
+                                '[secret]'
+                              )
+                            end
+
+        "\n#{formatted_message}\n"
+      })
+    end
+
+    def task(title)
+      prefix = "▬" * 2
+      title = " #{title} "
+      padding = "▬" * padding_length(title)
+      add(INFO, prefix + title.light_white + padding)
+    end
+
+    def task_step(local_step, title)
+      if local_step
+        add(INFO, "    local".cyan + " | ".black + format_task_step(title))
+      else
+        add(INFO, "   remote".yellow + " | ".black + format_task_step(title))
+      end
+    end
+
+    def error(message)
+      add(ERROR, "    ❌  error".red + " | ".black + message.to_s)
+    end
+
+    def success(message)
+      add(INFO, "    ✅  success".green + " | ".black + message.to_s)
+    end
+
+    def debug(message)
+      add(DEBUG, "    🛠  debug".magenta + " | ".black + message.to_s)
+    end
+
+    def warn(message)
+      add(WARN, "    ⚠️  warning".yellow + " | ".black + message.to_s)
+    end
+
+    def info(message)
+      add(INFO, "    ℹ️  info".yellow + " | ".black + message.to_s)
+    end
+
+    def plain(message)
+      add(INFO, message.to_s)
+    end
+
+    private
+
+    def padding_length(line)
+      result = MAX_LINE - line.length
+      result.positive? ? result : 0
+    end
+
+    def format_task_step(title)
+      message = title.to_s
+      return message if passthrough_task_step?(message)
+
+      lines = message.lines(chomp: true).reject(&:empty?)
+      return summarized_single_line_command(message) if lines.size <= 1
+      return mysql_import_summary(message) if mysql_import_script?(message)
+
+      "run shell script"
+    end
+
+    def passthrough_task_step?(message)
+      prefixes = [
+        "Exec command:",
+        "Output:",
+        "download ",
+        "delete:",
+        "get:",
+        "put:",
+        "get_directory:",
+        "put_directory:"
+      ]
+
+      return true if prefixes.any? { |prefix| message.start_with?(prefix) }
+      return false if message.include?("\n")
+
+      summarized_single_line_command(message) == message
+    end
+
+    def mysql_import_script?(message)
+      message.include?('tmp_dump="$(mktemp)"') &&
+        message.include?('COMMIT;') &&
+        message.include?('--init-command=')
+    end
+
+    def mysql_import_summary(message)
+      dump_path = message[%r{head -n 1 (.+?) 2>/dev/null \|\| true}, 1]
+      database = message[/--database=([^\s]+)/, 1]
+
+      summary = +"import SQL dump"
+      summary << " #{dump_path}" if dump_path
+      summary << " into database #{database}" if database
+      summary << " (strip sandbox header, append COMMIT)"
+      summary
+    end
+
+    def summarized_single_line_command(message)
+      mysql_dump_summary(message) ||
+        gzip_summary(message) ||
+        wp_search_replace_summary(message) ||
+        message
+    end
+
+    def mysql_dump_summary(message)
+      return unless message.include?('--result-file=')
+      return unless message.include?('mariadb-dump') || message.include?('mysqldump')
+
+      args = Shellwords.split(message)
+      dump_path = args.find { |arg| arg.start_with?('--result-file=') }&.split('=', 2)&.last
+      database = args.last
+      return unless dump_path && database
+
+      "dump database #{database} to #{dump_path}"
+    end
+
+    def gzip_summary(message)
+      return unless message.start_with?('gzip ')
+
+      args = Shellwords.split(message)
+      return unless args.length == 4 && args[2] == '-f'
+
+      case args[1]
+      when '-9' then "compress #{args[3]}"
+      when '-d' then "decompress #{args[3]}"
+      end
+    end
+
+    def wp_search_replace_summary(message)
+      return unless message.start_with?('wp search-replace ')
+
+      args = Shellwords.split(message)
+      return if args.length < 4
+
+      path = args.find { |arg| arg.start_with?('--path=') }&.split('=', 2)&.last
+      positional = args.drop(2).reject { |arg| arg.start_with?('--') }
+      return if positional.length < 2
+
+      search = positional[0]
+      replace = positional[1]
+
+      summary = "wp search-replace #{search} -> #{replace}"
+      summary << " in #{path}" if path
+      summary
+    end
+  end
+end

data/lib/wordmove/movefile.rb

@@ -0,0 +1,129 @@
+module Wordmove
+  class Movefile
+    attr_reader :logger, :name, :start_dir
+
+    def initialize(name = nil, start_dir = current_dir)
+      @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      @name = name
+      @start_dir = start_dir
+    end
+
+    def fetch(verbose = true)
+      entries = if name.nil?
+                  Dir["#{File.join(start_dir, '{M,m}ovefile')}{,.yml,.yaml}"]
+                else
+                  Dir["#{File.join(start_dir, name)}{,.yml,.yaml}"]
+                end
+
+      if entries.empty?
+        if last_dir?(start_dir)
+          raise MovefileNotFound, "Could not find a valid Movefile. Searched " \
+                                  "for filename \"#{name}\" in folder \"#{start_dir}\""
+        end
+
+        @start_dir = upper_dir(start_dir)
+        return fetch(verbose)
+      end
+
+      found = entries.first
+      logger.task("Using Movefile: #{found}") if verbose == true
+      safe_load_yaml(ERB.new(File.read(found)).result).deep_symbolize_keys!
+    end
+
+    def load_dotenv(cli_options = {})
+      env = environment(cli_options)
+      env_files = Dir[File.join(start_dir, ".env{.#{env},}")]
+
+      found_env = env_files.first
+
+      return false unless found_env.present?
+
+      logger.info("Using .env file: #{found_env}")
+      Dotenv.load(found_env)
+    end
+
+    def environment(cli_options = {})
+      options = fetch(false)
+      available_enviroments = extract_available_envs(options)
+      options.merge!(cli_options).deep_symbolize_keys!
+
+      if options[:environment] != 'local'
+        if available_enviroments.size > 1 && options[:environment].nil?
+          raise(
+            UndefinedEnvironment,
+            "You need to specify an environment with --environment parameter"
+          )
+        end
+
+        if options[:environment].present? && !available_enviroments.include?(options[:environment].to_sym)
+          raise UndefinedEnvironment, "No environment found for \"#{options[:environment]}\". " \
+                                      "Available Environments: #{available_enviroments.join(' ')}"
+        end
+      end
+
+      (options[:environment] || available_enviroments.first).to_sym
+    end
+
+    # The four values wp search-replace rewrites when syncing +environment+.
+    # If one of them is a proper prefix of another, the replacement of the
+    # shorter one also rewrites every occurrence of the longer one, e.g.
+    # replacing "https://site.test" turns "https://site.test.backup" into
+    # "https://example.com.backup". Returns [[short, long], ...] pairs.
+    def prefix_collisions(environment)
+      options = fetch(false)
+      terms = %i[vhost wordpress_path].flat_map do |key|
+        [options.dig(:local, key), options.dig(environment.to_sym, key)]
+      end
+      terms = terms.compact.map(&:to_s).reject(&:empty?).uniq
+
+      terms.product(terms).select do |short, long|
+        short != long && long.start_with?(short)
+      end
+    end
+
+    def secrets
+      options = fetch(false)
+
+      secrets = []
+      options.each_key do |env|
+        secrets << options.dig(env, :database, :password)
+        secrets << options.dig(env, :database, :host)
+        secrets << options.dig(env, :vhost)
+        secrets << options.dig(env, :ssh, :password)
+        secrets << options.dig(env, :ssh, :host)
+        secrets << options.dig(env, :wordpress_path)
+      end
+
+      secrets.compact.delete_if(&:empty?)
+    end
+
+    private
+
+    def extract_available_envs(options)
+      options.keys.map(&:to_sym) - %i[local global]
+    end
+
+    def last_dir?(directory)
+      directory == "/" || File.exist?(File.join(directory, 'wp-config.php'))
+    end
+
+    def upper_dir(directory)
+      File.expand_path(File.join(directory, '..'))
+    end
+
+    def current_dir
+      '.'
+    end
+
+    def safe_load_yaml(content)
+      YAML.safe_load(
+        content,
+        permitted_classes: [],
+        permitted_symbols: [],
+        aliases: true
+      )
+    rescue ArgumentError
+      YAML.safe_load(content, [], [], true)
+    end
+  end
+end

data/lib/wordmove/prerequisites.rb

@@ -0,0 +1,57 @@
+require 'open3'
+require 'shellwords'
+
+module Wordmove
+  # Checks that the external binaries a database sync relies on exist, either
+  # on this machine or on a remote host reached through an SshRunner.
+  #
+  # A requirement is a binary name, or an array of alternatives of which at
+  # least one must exist (e.g. mysql or mariadb).
+  module Prerequisites
+    # Needed where the dump is produced.
+    DB_SOURCE = ['gzip', %w[mysqldump mariadb-dump]].freeze
+    # Needed where the dump is imported and adapted.
+    DB_TARGET = ['gzip', %w[mysql mariadb], 'wp'].freeze
+    # Everything a remote may be asked for, used by the doctor.
+    REMOTE_ALL = ['rsync', 'gzip', %w[mysql mariadb], %w[mysqldump mariadb-dump], 'wp'].freeze
+
+    class << self
+      # POSIX sh snippet printing, one per line, the requirements that are not
+      # satisfied. Alternatives are printed joined with "|".
+      def probe_command(requirements)
+        requirements.map do |requirement|
+          names = Array(requirement)
+          test = names.map { |n| "command -v #{Shellwords.escape(n)} >/dev/null 2>&1" }.join(' || ')
+          "#{test} || echo #{Shellwords.escape(names.join('|'))}"
+        end.join('; ')
+      end
+
+      def missing_locally(requirements)
+        stdout, _stderr, _status = Open3.capture3('sh', '-c', probe_command(requirements))
+        parse(stdout)
+      end
+
+      # Returns the missing requirements, or raises ShellCommandError when the
+      # probe itself could not run (e.g. authentication failed).
+      def missing_remotely(runner, requirements)
+        stdout, stderr, exit_code = runner.run(probe_command(requirements))
+        unless exit_code.zero?
+          raise ShellCommandError,
+                "Could not check the remote prerequisites (exit code #{exit_code}): #{stderr}"
+        end
+
+        parse(stdout)
+      end
+
+      def describe(missing)
+        missing.map { |names| names.join(' or ') }.join(', ')
+      end
+
+      private
+
+      def parse(stdout)
+        stdout.lines.map(&:strip).reject(&:empty?).map { |line| line.split('|') }
+      end
+    end
+  end
+end

data/lib/wordmove/sql_adapter/wpcli.rb

@@ -0,0 +1,72 @@
+require 'shellwords'
+
+module Wordmove
+  module SqlAdapter
+    class Wpcli
+      attr_accessor :sql_content
+      attr_reader :from, :to, :local_path, :remote
+
+      # When +remote+ is true the command is meant to be executed on the remote
+      # host: +local_path+ is then the remote wordpress_path and is used as-is,
+      # and no local wp-cli availability or configuration probing is done.
+      def initialize(source_config, dest_config, config_key, local_path, remote: false)
+        @from = source_config[config_key]
+        @to = dest_config[config_key]
+        @local_path = local_path
+        @remote = remote
+      end
+
+      # `wp maintenance-mode activate|deactivate` for the install at +path+.
+      def self.maintenance_mode_command(action, path)
+        unless %i[activate deactivate].include?(action)
+          raise ArgumentError, "unknown maintenance mode action #{action.inspect}"
+        end
+
+        "wp maintenance-mode #{action} --path=#{Shellwords.escape(path)} --allow-root"
+      end
+
+      def command
+        unless remote || wp_in_path?
+          raise UnmetPeerDependencyError, "WP-CLI is not installed or not in your $PATH"
+        end
+
+        opts = [
+          "--path=#{Shellwords.escape(cli_config_path)}",
+          Shellwords.escape(from.to_s),
+          Shellwords.escape(to.to_s),
+          "--quiet",
+          "--skip-columns=guid",
+          "--all-tables",
+          "--allow-root"
+        ]
+
+        "wp search-replace #{opts.join(' ')}"
+      end
+
+      private
+
+      def wp_in_path?
+        system('which wp > /dev/null 2>&1')
+      end
+
+      def cli_config_path
+        return local_path if remote
+
+        load_from_yml || load_from_cli || local_path
+      end
+
+      def load_from_yml
+        cli_config_path = File.join(local_path, "wp-cli.yml")
+        return unless File.exist?(cli_config_path)
+
+        YAML.load_file(cli_config_path).with_indifferent_access["path"]
+      end
+
+      def load_from_cli
+        raw = `wp cli param-dump --allow-root --with-values`
+        cli_config = JSON.parse(raw, symbolize_names: true)
+        cli_config.dig(:path, :current)
+      end
+    end
+  end
+end

data/lib/wordmove/ssh_runner.rb

@@ -0,0 +1,110 @@
+require 'open3'
+require 'shellwords'
+
+module Wordmove
+  # Runs remote commands and file transfers through the system `ssh` and `scp`
+  # binaries, so that authentication behaves exactly like the rsync transfers:
+  # ssh-agent, ~/.ssh/config, ProxyJump and modern signature algorithms all work
+  # without any Ruby-side SSH implementation.
+  #
+  # When no password is configured the connection runs in BatchMode, so a failed
+  # key authentication is reported as an error instead of an interactive prompt.
+  class SshRunner
+    attr_reader :options
+
+    def initialize(ssh_options)
+      @options = (ssh_options || {}).dup
+    end
+
+    # Runs +command+ on the remote host with a POSIX sh, regardless of the
+    # remote user's login shell, and returns [stdout, stderr, exit_code].
+    def run(command)
+      execute(ssh_argv + [self.class.shell_wrap(command)])
+    end
+
+    # Every command wordmove generates assumes POSIX sh syntax ($(...), &&,
+    # multi-line scripts), which a fish or csh login shell would mangle.
+    def self.shell_wrap(command)
+      # Block form on purpose: in a replacement string \' means "post-match".
+      quoted = command.gsub("'") { %q('\'') }
+      "sh -c '#{quoted}'"
+    end
+
+    def get(remote_path, local_path)
+      execute(scp_argv + [remote_file(remote_path), local_path])
+    end
+
+    def put(local_path, remote_path)
+      execute(scp_argv + [local_path, remote_file(remote_path)])
+    end
+
+    def delete(remote_path)
+      run("rm -rf #{Shellwords.escape(remote_path)}")
+    end
+
+    def ssh_argv
+      wrap_password(['ssh'] + common_arguments + port_arguments('-p') + [target])
+    end
+
+    def scp_argv
+      wrap_password(['scp', '-q'] + common_arguments + port_arguments('-P'))
+    end
+
+    def password?
+      options[:password].present?
+    end
+
+    private
+
+    def execute(argv)
+      stdout, stderr, status = Open3.capture3(*argv)
+      [stdout, stderr, status.exitstatus]
+    rescue Errno::ENOENT
+      binary = argv.first
+      raise UnmetPeerDependencyError,
+            "`#{binary}` is not installed or not in your $PATH; it is required for SSH " \
+            "database operations and remote hooks"
+    end
+
+    def target
+      user = options[:user]
+      user.present? ? "#{user}@#{options[:host]}" : options[:host].to_s
+    end
+
+    def remote_file(path)
+      # scp hands the remote path to the remote shell, so it needs shell escaping.
+      "#{target}:#{Shellwords.escape(path)}"
+    end
+
+    def common_arguments
+      arguments = []
+      arguments.push("-o", "BatchMode=yes") unless password?
+      arguments.push('-J', jump_host) if gateway?
+      arguments
+    end
+
+    def port_arguments(flag)
+      return [] unless options[:port].present?
+
+      [flag, options[:port].to_s]
+    end
+
+    def wrap_password(argv)
+      return argv unless password?
+
+      ['sshpass', '-p', options[:password].to_s] + argv
+    end
+
+    def gateway?
+      options[:gateway].is_a?(Hash) && options[:gateway][:host].present?
+    end
+
+    def jump_host
+      gateway = options[:gateway]
+      spec = gateway[:host].to_s
+      spec = "#{gateway[:user]}@#{spec}" if gateway[:user].present?
+      spec = "#{spec}:#{gateway[:port]}" if gateway[:port].present?
+      spec
+    end
+  end
+end

data/lib/wordmove/version.rb

@@ -0,0 +1,3 @@
+module Wordmove
+  VERSION = "6.0.0".freeze
+end

data/lib/wordmove/wordpress_directory/path.rb

@@ -0,0 +1,11 @@
+class WordpressDirectory
+  module Path
+    WP_CONTENT = :wp_content
+    WP_CONFIG  = :wp_config
+    PLUGINS    = :plugins
+    MU_PLUGINS = :mu_plugins
+    THEMES     = :themes
+    UPLOADS    = :uploads
+    LANGUAGES  = :languages
+  end
+end