wordmove-ng 6.0.0

data/lib/wordmove/cli.rb

@@ -0,0 +1,134 @@
+module Wordmove
+  class CLI < Thor
+    map %w[--version -v] => :__print_version
+
+    desc "--version, -v", "Print the version"
+    def __print_version
+      puts Wordmove::VERSION
+    end
+
+    desc "init", "Generates a brand new movefile.yml"
+    def init
+      Wordmove::Generators::Movefile.start
+    end
+
+    desc "doctor", "Do some local configuration and environment checks"
+    def doctor
+      Wordmove::Doctor.start
+    rescue Wordmove::MovefileNotFound => e
+      logger.error(e.message)
+      exit 1
+    rescue Psych::SyntaxError => e
+      logger.error("Your movefile is not parsable due to a syntax error: #{e.message}")
+      exit 1
+    end
+
+    shared_options = {
+      wordpress: { aliases: "-w", type: :boolean },
+      uploads: { aliases: "-u", type: :boolean },
+      themes: { aliases: "-t", type: :boolean },
+      plugins: { aliases: "-p", type: :boolean },
+      mu_plugins: { aliases: "-m", type: :boolean },
+      languages: { aliases: "-l", type: :boolean },
+      db: { aliases: "-d", type: :boolean },
+      verbose: { aliases: "-v", type: :boolean },
+      simulate: { aliases: "-s", type: :boolean },
+      environment: { aliases: "-e" },
+      config: { aliases: "-c" },
+      debug: { type: :boolean },
+      no_adapt: { type: :boolean },
+      all: { type: :boolean }
+    }
+
+    no_tasks do
+      def handle_options(options)
+        wordpress_options.each do |task|
+          yield task if options[task] || (options["all"] && options[task] != false)
+        end
+      end
+
+      def wordpress_options
+        %w[wordpress uploads themes plugins mu_plugins languages db]
+      end
+
+      def ensure_wordpress_options_presence!(options)
+        return if (options.keys & (wordpress_options + ["all"])).present?
+
+        puts "No options given. See wordmove --help"
+        exit 1
+      end
+
+      def logger
+        Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      end
+    end
+
+    desc "list", "List all environments and vhosts"
+    shared_options.each do |option, args|
+      method_option option, args
+    end
+    def list
+      Wordmove::EnvironmentsList.print(options)
+    rescue Wordmove::MovefileNotFound => e
+      logger.error(e.message)
+      exit 1
+    rescue Psych::SyntaxError => e
+      logger.error("Your movefile is not parsable due to a syntax error: #{e.message}")
+      exit 1
+    end
+
+    desc "pull", "Pulls WP data from remote host to the local machine"
+    shared_options.each do |option, args|
+      method_option option, args
+    end
+    def pull
+      ensure_wordpress_options_presence!(options)
+      begin
+        deployer = Wordmove::Deployer::Base.deployer_for(options.deep_symbolize_keys)
+      rescue MovefileNotFound => e
+        logger.error(e.message)
+        exit 1
+      rescue Psych::SyntaxError => e
+        logger.error("Your movefile is not parsable due to a syntax error: #{e.message}")
+        exit 1
+      end
+
+      Wordmove::Hook.run(:pull, :before, options)
+
+      guardian = Wordmove::Guardian.new(options: options, action: :pull)
+
+      handle_options(options) do |task|
+        deployer.send("pull_#{task}") if guardian.allows(task.to_sym)
+      end
+
+      Wordmove::Hook.run(:pull, :after, options)
+    end
+
+    desc "push", "Pushes WP data from local machine to remote host"
+    shared_options.each do |option, args|
+      method_option option, args
+    end
+    def push
+      ensure_wordpress_options_presence!(options)
+      begin
+        deployer = Wordmove::Deployer::Base.deployer_for(options.deep_symbolize_keys)
+      rescue MovefileNotFound => e
+        logger.error(e.message)
+        exit 1
+      rescue Psych::SyntaxError => e
+        logger.error("Your movefile is not parsable due to a syntax error: #{e.message}")
+        exit 1
+      end
+
+      Wordmove::Hook.run(:push, :before, options)
+
+      guardian = Wordmove::Guardian.new(options: options, action: :push)
+
+      handle_options(options) do |task|
+        deployer.send("push_#{task}") if guardian.allows(task.to_sym)
+      end
+
+      Wordmove::Hook.run(:push, :after, options)
+    end
+  end
+end

data/lib/wordmove/deployer/base.rb

@@ -0,0 +1,356 @@
+require 'tempfile'
+require 'fileutils'
+
+module Wordmove
+  module Deployer
+    class Base
+      attr_reader :options, :logger, :environment
+
+      SANDBOX_MAGIC_COMMENT = '/*!999999- enable the sandbox mode */'.freeze
+
+      class << self
+        def deployer_for(cli_options)
+          movefile = Wordmove::Movefile.new(cli_options[:config])
+          movefile.load_dotenv(cli_options)
+
+          options = movefile.fetch.merge! cli_options
+          environment = movefile.environment(cli_options)
+
+          # localとenvironmentのdatabaseにoriginを追加
+          options[:local][:database][:origin] = 'local'
+          options[environment][:database][:origin] = 'remote'
+
+          if options[environment][:ftp]
+            raise NoAdapterFound,
+                  "FTP support was removed in wordmove-ng 6.0, but the \"#{environment}\" " \
+                  "environment is configured with an `ftp` block. Switch it to `ssh`, or " \
+                  "keep using the legacy `wordmove` 5.x gem for FTP-only hosts."
+          end
+
+          warn_about_removed_sql_adapter(options, movefile)
+
+          return SSH.new(environment, options) if options[environment][:ssh]
+
+          raise NoAdapterFound, "No valid adapter found."
+        end
+
+        # `global.sql_adapter` no longer selects anything: URL/path adaptation is
+        # always done with wp-cli on the target. Warn once so people notice.
+        def warn_about_removed_sql_adapter(options, movefile)
+          adapter = options.dig(:global, :sql_adapter)
+          return if adapter.nil? || adapter.to_s == 'wpcli'
+
+          logger(movefile.secrets).warn(
+            "`global.sql_adapter: #{adapter}` is ignored since wordmove-ng 6.0; database " \
+            "adaptation always uses wp-cli on the target. Remove the key from your movefile."
+          )
+        end
+
+        def current_dir
+          '.'
+        end
+
+        def logger(secrets)
+          Logger.new(STDOUT, secrets).tap { |l| l.level = Logger::DEBUG }
+        end
+      end
+
+      def initialize(environment, options = {})
+        @environment = environment.to_sym
+        @options = options
+
+        movefile_secrets = Wordmove::Movefile.new(options[:config]).secrets
+        @logger = self.class.logger(movefile_secrets)
+      end
+
+      def push_db
+        logger.task "Pushing Database"
+      end
+
+      def pull_db
+        logger.task "Pulling Database"
+      end
+
+      def exclude_dir_contents(path)
+        "#{path}/*"
+      end
+
+      def push_wordpress
+        logger.task "Pushing wordpress core"
+
+        local_path = local_options[:wordpress_path]
+        remote_path = remote_options[:wordpress_path]
+        exclude_wp_content = exclude_dir_contents(local_wp_content_dir.relative_path)
+        exclude_paths = paths_to_exclude.push(exclude_wp_content)
+
+        remote_put_directory(local_path, remote_path, exclude_paths)
+      end
+
+      def pull_wordpress
+        logger.task "Pulling wordpress core"
+
+        local_path = local_options[:wordpress_path]
+        remote_path = remote_options[:wordpress_path]
+        exclude_wp_content = exclude_dir_contents(remote_wp_content_dir.relative_path)
+        exclude_paths = paths_to_exclude.push(exclude_wp_content)
+
+        remote_get_directory(remote_path, local_path, exclude_paths)
+      end
+
+      protected
+
+      def paths_to_exclude
+        remote_options[:exclude] || []
+      end
+
+      def run(command)
+        logger.task_step true, command
+        return true if simulate?
+
+        system(command)
+        raise ShellCommandError, "Return code reports an error" unless $CHILD_STATUS.success?
+      end
+
+      def simulate?
+        options[:simulate]
+      end
+
+      [
+        WordpressDirectory::Path::WP_CONTENT,
+        WordpressDirectory::Path::PLUGINS,
+        WordpressDirectory::Path::MU_PLUGINS,
+        WordpressDirectory::Path::THEMES,
+        WordpressDirectory::Path::UPLOADS,
+        WordpressDirectory::Path::LANGUAGES
+      ].each do |type|
+        %i[remote local].each do |location|
+          define_method "#{location}_#{type}_dir" do
+            options = send("#{location}_options")
+            WordpressDirectory.new(type, options)
+          end
+        end
+      end
+
+      def mysql_dump_command(options, save_to_path)
+        command = [mysql_dump_binary]
+        command << "--host=#{Shellwords.escape(options[:host])}" if options[:host].present?
+        command << "--port=#{Shellwords.escape(options[:port])}" if options[:port].present?
+        if (socket = mysql_socket_option(options, :mysqldump_options))
+          command << "--socket=#{Shellwords.escape(socket)}"
+        end
+        command << "--user=#{Shellwords.escape(options[:user])}" if options[:user].present?
+        if options[:password].present?
+          command << "--password=#{Shellwords.escape(options[:password])}"
+        end
+        command << "--result-file=#{Shellwords.escape(save_to_path)}"
+        if options[:mysqldump_options].present?
+          command << Shellwords.split(options[:mysqldump_options])
+        end
+        command << Shellwords.escape(options[:name])
+        command.join(" ")
+      end
+
+      def mysql_import_command(dump_path, options)
+        mysql_command = mysql_client_command(options, import: true)
+        escaped_dump_path = Shellwords.escape(dump_path)
+
+        init_commands = [
+          "SET autocommit=0",
+          "SET FOREIGN_KEY_CHECKS=0"
+        ].join('; ')
+
+        [
+          "first_line=$(head -n 1 #{escaped_dump_path} 2>/dev/null || true)",
+          'tmp_dump="$(mktemp)"',
+          %(if [ "$first_line" = '#{SANDBOX_MAGIC_COMMENT}' ]; then),
+          "tail -n +2 #{escaped_dump_path} > \"$tmp_dump\"",
+          'else',
+          "cat #{escaped_dump_path} > \"$tmp_dump\"",
+          'fi',
+          'printf "\\\\nCOMMIT;\\\\n" >> "$tmp_dump"',
+          "#{mysql_command} --init-command=\"#{init_commands}\" < \"$tmp_dump\"",
+          'import_status=$?',
+          'rm -f "$tmp_dump"',
+          'exit $import_status'
+        ].join("\n")
+      end
+
+      def compress_command(path)
+        "gzip -9 -f #{Shellwords.escape(path)}"
+      end
+
+      def uncompress_command(path)
+        "gzip -d -f #{Shellwords.escape(path)}"
+      end
+
+      def local_delete(path)
+        logger.task_step true, "delete: '#{path}'"
+        File.delete(path) unless simulate?
+      end
+
+      def save_local_db(local_dump_path)
+        # dump local mysql into file
+        run mysql_dump_command(local_options[:database], local_dump_path)
+      end
+
+      def remote_options
+        options[environment].clone
+      end
+
+      def local_options
+        options[:local].clone
+      end
+
+      def mysql_client_binary
+        '$(command -v mariadb >/dev/null 2>&1 && echo mariadb || echo mysql)'
+      end
+
+      def mysql_dump_binary
+        '$(command -v mariadb-dump >/dev/null 2>&1 && echo mariadb-dump || echo mysqldump)'
+      end
+
+      def mysql_client_command(options, import: false)
+        mysql_options = options[:mysql_options]
+        command = [mysql_client_binary]
+        command << "--host=#{Shellwords.escape(options[:host])}" if options[:host].present?
+        command << "--port=#{Shellwords.escape(options[:port])}" if options[:port].present?
+        if (socket = mysql_socket_option(options, :mysql_options))
+          command << "--socket=#{Shellwords.escape(socket)}"
+        end
+        command << "--user=#{Shellwords.escape(options[:user])}" if options[:user].present?
+        if options[:password].present?
+          command << "--password=#{Shellwords.escape(options[:password])}"
+        end
+        command << "--database=#{Shellwords.escape(options[:name])}"
+        command << "--force" if import
+        if !mysql_options.to_s.match?(/--(?:skip-)?binary-mode\b/) && import
+          command << "--binary-mode"
+        end
+        command << Shellwords.split(mysql_options) if mysql_options.present?
+        command.join(" ")
+      end
+
+      def normalize_collations!(dump_path)
+        return if simulate?
+
+        mappings = collation_fallbacks
+        charset_map = charset_fallbacks
+        return if mappings.empty? && charset_map.empty?
+
+        collation_matcher = Regexp.union(mappings.keys) unless mappings.empty?
+        temp_dump = Tempfile.new(['wordmove-collation', '.sql'])
+        begin
+          File.open(dump_path, 'rb') do |input|
+            File.open(temp_dump.path, 'wb') do |output|
+              input.each_line do |line|
+                unless collation_matcher && line.match?(collation_matcher)
+                  output.write(line)
+                  next
+                end
+
+                # Ensure we do not explode on invalid byte sequences coming from dumps
+                safe_line = begin
+                  line.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: '')
+                rescue StandardError
+                  line.dup.force_encoding(Encoding::UTF_8)
+                end
+
+                replaced_collation = false
+                mappings.each do |pattern, replacement|
+                  next unless safe_line.match?(pattern)
+
+                  if replacement.is_a?(Hash)
+                    safe_line = safe_line.gsub(pattern, replacement[:collation])
+                    replaced_collation = true
+                    if replacement[:charset]
+                      safe_line = safe_line.gsub(/utf8mb3\b/, replacement[:charset])
+                    end
+                  else
+                    safe_line = safe_line.gsub(pattern, replacement)
+                    replaced_collation = true
+                  end
+                end
+
+                # If we replaced collations but still see utf8mb3, upgrade charset to avoid mismatches
+                if replaced_collation
+                  charset_map.each do |pattern, replacement|
+                    safe_line = safe_line.gsub(pattern, replacement)
+                  end
+                end
+                output.write(safe_line)
+              end
+            end
+          end
+
+          FileUtils.mv(temp_dump.path, dump_path)
+        ensure
+          temp_dump.close!
+        end
+      end
+
+      def collation_fallbacks
+        raw_mappings = options.dig(:global, :collation_fallbacks) || default_collation_fallbacks
+        return {} unless raw_mappings
+
+        raw_mappings.each_with_object({}) do |(pattern, replacement), memo|
+          normalized_pattern = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern.to_s))
+          memo[normalized_pattern] = normalize_replacement(replacement)
+        end
+      end
+
+      def default_collation_fallbacks
+        {
+          /utf8mb3_uca\d+_ai_ci/ => { collation: 'utf8mb4_unicode_ci', charset: 'utf8mb4' },
+          /utf8mb3_uca\d+_as_cs/ => { collation: 'utf8mb4_unicode_ci', charset: 'utf8mb4' },
+          /utf8mb3_unicode_520_ci/ => { collation: 'utf8mb4_unicode_ci', charset: 'utf8mb4' }
+        }
+      end
+
+      def charset_fallbacks
+        raw_mappings = options.dig(:global, :charset_fallbacks) || default_charset_fallbacks
+        return {} unless raw_mappings
+
+        raw_mappings.each_with_object({}) do |(pattern, replacement), memo|
+          normalized_pattern = pattern.is_a?(Regexp) ? pattern : Regexp.new(Regexp.escape(pattern.to_s))
+          memo[normalized_pattern] = replacement
+        end
+      end
+
+      def default_charset_fallbacks
+        {
+          /utf8mb3\b/ => 'utf8mb4'
+        }
+      end
+
+      def normalize_replacement(replacement)
+        return replacement if replacement.is_a?(Hash)
+
+        { collation: replacement, charset: nil }
+      end
+
+      def mysql_socket_option(options, legacy_options_key)
+        return if mysql_option_includes_socket?(options[legacy_options_key])
+
+        options[:socket].presence
+      end
+
+      def mysql_option_includes_socket?(option_string)
+        mysql_socket_from_options(option_string).present?
+      end
+
+      def mysql_socket_from_options(option_string)
+        return if option_string.blank?
+
+        args = Shellwords.split(option_string)
+        socket_index = args.index('--socket')
+        return args[socket_index + 1] if socket_index && args[socket_index + 1]
+
+        args.each do |arg|
+          return Regexp.last_match(1) if arg.match(/\A--socket=(.+)\z/)
+        end
+
+        nil
+      end
+    end
+  end
+end