wordmove-ng 6.0.0

data/lib/wordmove/doctor/ssh.rb

@@ -0,0 +1,90 @@
+module Wordmove
+  class Doctor
+    class Ssh
+      attr_reader :logger, :movefile
+
+      def initialize(movefile_name = nil, movefile_dir = '.')
+        @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+        @movefile = Wordmove::Movefile.new(movefile_name, movefile_dir)
+      end
+
+      def check!
+        logger.task "Checking SSH client"
+
+        if system('which ssh', out: File::NULL, err: File::NULL)
+          logger.success "SSH command found"
+        else
+          logger.error "SSH command not found. And belive me: it's really strange it's not there."
+          return
+        end
+
+        ssh_environments.each { |name, ssh_options| check_environment!(name, ssh_options) }
+      end
+
+      private
+
+      # Returns { environment_name => ssh_options } for every remote using SSH.
+      # Any movefile problem is reported by the Movefile doctor, so it is
+      # silently skipped here.
+      def ssh_environments
+        options = movefile.fetch(false)
+        options.each_with_object({}) do |(name, env), memo|
+          next if %i[local global].include?(name)
+          next unless env.is_a?(Hash) && env[:ssh].is_a?(Hash)
+
+          memo[name] = env[:ssh]
+        end
+      rescue MovefileNotFound, Psych::SyntaxError
+        {}
+      end
+
+      def check_environment!(name, ssh_options)
+        logger.task "Checking SSH connection to \"#{name}\""
+        warn_about_gateway_password(name, ssh_options)
+        runner = Wordmove::SshRunner.new(ssh_options)
+        _stdout, stderr, exit_code = runner.run('true')
+
+        if exit_code.zero?
+          logger.success "Non interactive SSH authentication to \"#{name}\" works"
+          check_remote_prerequisites!(name, runner)
+        else
+          logger.error <<-LONG
+  Non interactive SSH authentication to "#{name}" failed (exit code #{exit_code}).
+                Database sync and remote hooks use `ssh` exactly like rsync does, so
+                check your keys, ssh-agent, ~/.ssh/config or the `ssh.password` option.
+                The command used to test was:
+                #{runner.ssh_argv.join(' ')} true
+                #{stderr}
+          LONG
+        end
+      rescue UnmetPeerDependencyError => e
+        logger.error e.message
+      end
+
+      def check_remote_prerequisites!(name, runner)
+        missing = Wordmove::Prerequisites.missing_remotely(runner, Wordmove::Prerequisites::REMOTE_ALL)
+        if missing.empty?
+          logger.success "All required programs are available on \"#{name}\""
+        else
+          logger.error <<-LONG
+  Missing on "#{name}": #{Wordmove::Prerequisites.describe(missing)}.
+                rsync is needed for file sync; gzip, mysql/mariadb, mysqldump/mariadb-dump
+                and wp for database sync (wp runs search-replace on the remote after a push).
+                Programs must be in the PATH of a non interactive login shell.
+          LONG
+        end
+      rescue ShellCommandError => e
+        logger.error e.message
+      end
+
+      def warn_about_gateway_password(name, ssh_options)
+        gateway = ssh_options[:gateway]
+        return unless gateway.is_a?(Hash) && gateway[:password].present?
+
+        logger.warn "\"#{name}\" sets ssh.gateway.password, which cannot be used: the gateway " \
+                    "is reached with `ssh -J`, so it must accept your key or ssh-agent. " \
+                    "The password is ignored."
+      end
+    end
+  end
+end

data/lib/wordmove/doctor/wpcli.rb

@@ -0,0 +1,43 @@
+module Wordmove
+  class Doctor
+    class Wpcli
+      attr_reader :logger
+
+      def initialize
+        @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+      end
+
+      def check!
+        logger.task "Checking local wp-cli installation"
+
+        if in_path?
+          logger.success "wp-cli is correctly installed"
+
+          if up_to_date?
+            logger.success "wp-cli is up to date"
+          else
+            logger.error <<-LONG
+  wp-cli is not up to date.
+                Use `wp cli update` to update to the latest version.
+            LONG
+          end
+        else
+          logger.error <<-LONG
+  wp-cli is not installed (or not in your $PATH).
+              Read http://wp-cli.org/#installing for installation info.
+          LONG
+        end
+      end
+
+      private
+
+      def in_path?
+        system('which wp', out: File::NULL)
+      end
+
+      def up_to_date?
+        `wp cli check-update --format=json --allow-root`.empty?
+      end
+    end
+  end
+end

data/lib/wordmove/doctor.rb

@@ -0,0 +1,67 @@
+module Wordmove
+  class Doctor
+    def self.start
+      banner
+      movefile
+      mysql
+      wpcli
+      rsync
+      ssh
+    end
+
+    def self.movefile
+      movefile_doctor = Wordmove::Doctor::Movefile.new
+      movefile_doctor.validate!
+    end
+
+    def self.mysql
+      mysql_doctor = Wordmove::Doctor::Mysql.new
+      mysql_doctor.check!
+    end
+
+    def self.wpcli
+      wpcli_doctor = Wordmove::Doctor::Wpcli.new
+      wpcli_doctor.check!
+    end
+
+    def self.rsync
+      rsync_doctor = Wordmove::Doctor::Rsync.new
+      rsync_doctor.check!
+    end
+
+    def self.ssh
+      ssh_doctor = Wordmove::Doctor::Ssh.new
+      ssh_doctor.check!
+    end
+
+    # rubocop:disable-next Metrics/MethodLength
+    def self.banner
+      paint = <<-'ASCII'
+        .------------------------.
+        |       PSYCHIATRIC      |
+        |         HELP  5¢       |
+        |________________________|
+        ||     .-"""--.         ||
+        ||    /        \.-.     ||
+        ||   |     ._,     \    ||
+        ||   \_/`-'   '-.,_/    ||
+        ||   (_   (' _)') \     ||
+        ||   /|           |\    ||
+        ||  | \     __   / |    ||
+        ||   \_).,_____,/}/     ||
+      __||____;_--'___'/ (      ||
+     |\ ||   (__,\\    \_/------||
+     ||\||______________________||
+     ||||                        |
+     ||||       THE DOCTOR       |
+     \|||         IS [IN]   _____|
+      \||                  (______)
+       `|___________________//||\\
+                           //=||=\\
+                           `  ``  `
+      ASCII
+
+      puts paint
+    end
+  end
+end

data/lib/wordmove/environments_list.rb

@@ -0,0 +1,68 @@
+module Wordmove
+  class EnvironmentsList
+    attr_reader :movefile, :logger, :remote_vhosts, :local_vhost
+
+    class << self
+      def print(cli_options)
+        new(cli_options).print
+      end
+    end
+
+    def initialize(options)
+      @logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+      @movefile = Wordmove::Movefile.new(options[:config])
+      @remote_vhosts = []
+      @local_vhost = []
+    end
+
+    def print
+      contents = parse_movefile(movefile: movefile)
+      generate_vhost_list(contents: contents)
+      output
+    end
+
+    private
+
+    def select_vhost(contents:)
+      target = contents.select { |_key, env| env[:vhost].present? }
+      target.map { |key, env| { env: key, vhost: env[:vhost] } }
+    end
+
+    def parse_movefile(movefile:)
+      movefile.fetch
+    end
+
+    def output
+      logger.task('Listing Local')
+      logger.plain(output_string(vhost_list: local_vhost))
+
+      logger.task('Listing Remotes')
+      logger.plain(output_string(vhost_list: remote_vhosts))
+    end
+
+    def output_string(vhost_list:)
+      return 'vhost list is empty' if vhost_list.empty?
+
+      vhost_list.each_with_object("") do |entry, retval|
+        retval << "#{entry[:env]}: #{entry[:vhost]}\n"
+      end
+    end
+
+    #
+    # return env, vhost map
+    # Exp. {:env=>:local, :vhost=>"http://vhost.local"},
+    #      {:env=>:production, :vhost=>"http://example.com"}
+    #
+    def generate_vhost_list(contents:)
+      # select object which has 'vhost' only
+      vhosts = select_vhost(contents: contents)
+      vhosts.each do |list|
+        if list[:env] == :local
+          @local_vhost << list
+        else
+          @remote_vhosts << list
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/exceptions.rb

@@ -0,0 +1,10 @@
+module Wordmove
+  class UndefinedEnvironment < StandardError; end
+  class NoAdapterFound < StandardError; end
+  class MovefileNotFound < StandardError; end
+  class ShellCommandError < StandardError; end
+  class ImplementInSubclassError < StandardError; end
+  class UnmetPeerDependencyError < StandardError; end
+  class RemoteHookException < StandardError; end
+  class LocalHookException < StandardError; end
+end

data/lib/wordmove/generators/movefile.rb

@@ -0,0 +1,50 @@
+module Wordmove
+  module Generators
+    class Movefile < Thor::Group
+      include Thor::Actions
+      include MovefileAdapter
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def copy_movefile
+        template "movefile.yml"
+        uncomment_local_database_connection_overrides
+      end
+
+      no_commands do
+        def uncomment_local_database_connection_overrides
+          content = File.read(movefile_path)
+          updated = uncomment_local_port(content)
+          updated = uncomment_local_socket(updated)
+          File.write(movefile_path, updated)
+        end
+
+        def movefile_path
+          File.join(destination_root, "movefile.yml")
+        end
+
+        def uncomment_local_port(content)
+          port = database.respond_to?(:port) ? database.port : nil
+          return content if port.to_s.empty?
+
+          content.sub(
+            /^(\s*)# port: 3306$/,
+            "\\1port: #{port}"
+          )
+        end
+
+        def uncomment_local_socket(content)
+          socket = database.respond_to?(:socket) ? database.socket : nil
+          return content if socket.to_s.empty?
+
+          content.sub(
+            %r{^(\s*)# socket: /path/to/mysql\.sock # optional unix socket path$},
+            "\\1socket: #{socket.inspect} # optional unix socket path"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/generators/movefile.yml

@@ -0,0 +1,104 @@
+global:
+  # Put the target site in `wp maintenance-mode` while its database is replaced.
+  # Can also be forced with the WORDMOVE_MAINTENANCE_MODE=1 environment variable.
+  maintenance_mode: false
+
+local:
+  vhost: <%= vhost %>
+  wordpress_path: "<%= wordpress_path %>" # use an absolute path here
+
+  database:
+    name: <%= database.name %>
+    user: <%= database.user %>
+    password: "<%= database.password %>" # could be blank, so always use quotes around
+    host: <%= database.host %>
+    # port: 3306
+    # socket: /path/to/mysql.sock # optional unix socket path
+
+production:
+  vhost: http://example.com
+  wordpress_path: "/var/www/your_site" # use an absolute path here
+
+  database:
+    name: database_name
+    user: user
+    password: password
+    host: host
+    # port: 3308 # Use just in case you have exotic server config
+    # socket: /path/to/mysql.sock # Useful for local tunnels or unix socket setups
+    # mysqldump_options: '--max_allowed_packet=1G' # Only available if using SSH
+    # mysql_options: '--protocol=TCP' # mysql command is used to import db
+
+  exclude:
+    - '.git/'
+    - '.gitignore'
+    - '.gitmodules'
+    - '.env'
+    - 'node_modules/'
+    - 'bin/'
+    - 'tmp/*'
+    - 'Gemfile*'
+    - 'Movefile'
+    - 'movefile'
+    - 'movefile.yml'
+    - 'movefile.yaml'
+    - 'wp-config.php'
+    - 'wp-content/*.sql.gz'
+    - '*.orig'
+
+  # paths: # you can customize wordpress internal paths
+  #   wp_content: wp-content
+  #   uploads: wp-content/uploads
+  #   plugins: wp-content/plugins
+  #   mu_plugins: wp-content/mu-plugins
+  #   themes: wp-content/themes
+  #   languages: wp-content/languages
+
+  # ssh:
+  #   host: host
+  #   user: user
+  #   password: password # optional; requires `sshpass`. Without it ssh runs in BatchMode with your keys/agent.
+  #   port: 22 # Port is optional
+  #   rsync_options: '--verbose --itemize-changes' # Additional rsync options, optional
+  #   gateway: # Gateway is optional
+  #     host: host
+  #     user: user
+  #     password: password # password is optional, will use public keys if available.
+
+
+  # hooks:
+  #   push:
+  #     before:
+  #       - command: 'echo "do something"'
+  #         where: local
+  #         raise: false # raise is true by default
+  #     after:
+  #       - command: 'echo "do something"'
+  #         where: remote
+  #   pull:
+  #     before:
+  #       - command: 'echo "do something"'
+  #         where: local
+  #         raise: false
+  #     after:
+  #       - command: 'echo "do something"'
+  #         where: remote
+  #
+  # forbid:
+  #   push:
+  #     db: false
+  #     plugins: false
+  #     themes: false
+  #     languages: false
+  #     uploads: false
+  #     mu-plugins: false
+  #   pull:
+  #     db: false
+  #     plugins: false
+  #     themes: false
+  #     languages: false
+  #     uploads: false
+  #     mu-plugins: false
+
+# staging: # multiple environments can be specified
+#   [...]

data/lib/wordmove/generators/movefile_adapter.rb

@@ -0,0 +1,188 @@
+require 'shellwords'
+
+module Wordmove
+  module Generators
+    module MovefileAdapter
+      def vhost
+        VhostReader.config
+      end
+
+      def wordpress_path
+        File.expand_path(Dir.pwd)
+      end
+
+      def database
+        DBConfigReader.config
+      end
+    end
+
+    class DBConfigReader
+      def self.config
+        new.config
+      end
+
+      def config
+        OpenStruct.new(database_config)
+      end
+
+      def database_config
+        if wp_config_exists?
+          WordpressDBConfig.config
+        else
+          DefaultDBConfig.config
+        end
+      end
+
+      def wp_config_exists?
+        File.exist?(WordpressDirectory.default_path_for(:wp_config))
+      end
+    end
+
+    class DefaultDBConfig
+      def self.config
+        {
+          name: "database_name",
+          user: "user",
+          password: "password",
+          host: "127.0.0.1"
+        }
+      end
+    end
+
+    class VhostReader
+      def self.config
+        new.config
+      end
+
+      def config
+        wp_config_vhost || wp_cli_vhost || default_vhost
+      end
+
+      def default_vhost
+        "http://vhost.local"
+      end
+
+      def wordpress_path
+        File.expand_path(Dir.pwd)
+      end
+
+      def wp_config_exists?
+        File.exist?(WordpressDirectory.default_path_for(:wp_config))
+      end
+
+      def wp_config
+        @wp_config ||= File.read(
+          WordpressDirectory.default_path_for(:wp_config)
+        ).encode('utf-8', invalid: :replace)
+      end
+
+      def wp_config_vhost
+        return unless wp_config_exists?
+
+        %w[WP_HOME WP_SITEURL].each do |definition|
+          wp_config.match(wp_definition_regex(definition)) do |match|
+            value = match[:value].to_s.strip
+            return value unless value.empty?
+          end
+        end
+
+        nil
+      end
+
+      def wp_cli_vhost
+        return unless wp_config_exists?
+        return unless wp_in_path?
+
+        read_wp_option('home').presence || read_wp_option('siteurl').presence
+      end
+
+      def wp_in_path?
+        system('which wp > /dev/null 2>&1')
+      end
+
+      def read_wp_option(option)
+        command = [
+          "wp option get #{option}",
+          "--path=#{Shellwords.escape(wordpress_path)}",
+          "--allow-root",
+          "2>/dev/null"
+        ].join(' ')
+
+        `#{command}`.strip
+      end
+
+      def wp_definition_regex(definition)
+        /
+          ^\s*define\(
+          \s*['"]#{Regexp.escape(definition)}['"]
+          \s*,\s*
+          (?<quote>['"])
+          (?<value>(?:\\.|(?!\k<quote>).)*)
+          \k<quote>
+          \s*\)\s*;?
+        /x
+      end
+    end
+
+    class WordpressDBConfig
+      def self.config
+        new.config
+      end
+
+      def wp_config
+        @wp_config ||= File.read(
+          WordpressDirectory.default_path_for(:wp_config)
+        ).encode('utf-8', invalid: :replace)
+      end
+
+      def wp_definitions
+        {
+          name: 'DB_NAME',
+          user: 'DB_USER',
+          password: 'DB_PASSWORD',
+          host: 'DB_HOST'
+        }
+      end
+
+      def wp_definition_regex(definition)
+        /
+          ^\s*define\(
+          \s*['"]#{Regexp.escape(definition)}['"]
+          \s*,\s*
+          (?<quote>['"])
+          (?<value>(?:\\.|(?!\k<quote>).)*)
+          \k<quote>
+          \s*\)\s*;?
+        /x
+      end
+
+      def defaults
+        DefaultDBConfig.config.clone
+      end
+
+      def config
+        config = wp_definitions.each_with_object(defaults) do |(key, definition), result|
+          wp_config.match(wp_definition_regex(definition)) do |match|
+            result[key] = match[:value]
+          end
+        end
+
+        normalize_host_config(config)
+      end
+
+      def normalize_host_config(config)
+        host = config[:host].to_s
+
+        if host.match(%r{\A(?<hostname>[^:]+):(?<socket>/.+)\z})
+          config[:host] = Regexp.last_match[:hostname]
+          config[:socket] = Regexp.last_match[:socket]
+        elsif host.match(/\A(?<hostname>[^:]+):(?<port>\d+)\z/)
+          config[:host] = Regexp.last_match[:hostname]
+          config[:port] = Regexp.last_match[:port]
+        end
+
+        config
+      end
+    end
+  end
+end

data/lib/wordmove/guardian.rb

@@ -0,0 +1,37 @@
+module Wordmove
+  class Guardian
+    attr_reader :movefile, :environment, :action, :logger
+
+    def initialize(options: nil, action: nil)
+      @movefile = Wordmove::Movefile.new(options[:config])
+      @environment = @movefile.environment(options).to_sym
+      @action = action
+      @logger = Logger.new(STDOUT, @movefile.secrets).tap { |l| l.level = Logger::DEBUG }
+    end
+
+    def allows(task)
+      if forbidden?(task)
+        logger.task("#{action.capitalize}ing #{task.capitalize}")
+        logger.warn("You tried to #{action} #{task}, but is forbidden by configuration. Skipping")
+      end
+
+      !forbidden?(task)
+    end
+
+    private
+
+    def forbidden?(task)
+      return false unless forbidden_tasks[task].present?
+
+      forbidden_tasks[task] == true
+    end
+
+    def forbidden_tasks
+      environment_options = movefile.fetch(false)[environment]
+      return {} unless environment_options.key?(:forbid)
+      return {} unless environment_options[:forbid].key?(action)
+
+      environment_options[:forbid][action]
+    end
+  end
+end