wordmove 5.2.2 → 6.0.0.alpha.1

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

@@ -0,0 +1,70 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Uploads a DB dump to remote host and import it in the remote database over SSH protocol
+      class PutAndImportDumpRemotely
+        extend ::LightService::Action
+        include Wordmove::Actions::Helpers
+        include WordpressDirectory::RemoteHelperMethods
+        include WordpressDirectory::LocalHelperMethods
+
+        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
+          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.gzipped_adapted_path,
+              context.db_paths.remote.gzipped_path
+            ]
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          result = Wordmove::Actions::Ssh::RunRemoteCommand.execute(
+            cli_options: context.cli_options,
+            logger: context.logger,
+            photocopier: context.photocopier,
+            command: uncompress_command(file_path: context.db_paths.remote.gzipped_path)
+          )
+          context.fail_and_return!(result.message) if result.failure?
+
+          result = Wordmove::Actions::Ssh::RunRemoteCommand.execute(
+            cli_options: context.cli_options,
+            logger: context.logger,
+            photocopier: context.photocopier,
+            command: mysql_import_command(
+              dump_path: context.db_paths.remote.path,
+              env_db_options: context.remote_options[:database]
+            )
+          )
+          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.path
+          )
+          context.fail!(result.message) if result.failure?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Syncs a whole directory over SSH protocol from local host to remote server
+      class PutDirectory
+        extend LightService::Action
+        include Wordmove::Actions::Helpers
+        include Wordmove::Actions::Ssh::Helpers
+        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::SSH]
+        # @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'
+          # For this action `local_path` and `remote_path` will always be
+          # `:wordpress_path`; specific folder for `context.folder_task` will be included by
+          # `push_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 `"local_#{context.folder_task}_dir"` could
+          # not be defined.
+          command_args = context.fetch(:command_args) || [
+            local_path,
+            remote_path,
+            push_exclude_paths(
+              local_task_dir: send(
+                "local_#{context.folder_task}_dir",
+                local_options: context.local_options
+              ),
+              paths_to_exclude: paths_to_exclude(remote_options: context.remote_options)
+            ),
+            push_include_paths(local_task_dir: send(
+              "local_#{context.folder_task}_dir",
+              local_options: context.local_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/run_remote_command.rb

@@ -0,0 +1,39 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Run a command on a remote host using Photocopier
+      #
+      # @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 RunRemoteCommand
+        extend LightService::Action
+        include Wordmove::Actions::Helpers
+
+        expects :photocopier,
+                :logger,
+                :cli_options,
+                :command
+
+        # @!method execute
+        # @param photocopier [Photocopier]
+        # @param logger [Wordmove::Logger]
+        # @param cli_options [Hash] The hash of command line options
+        # @param command [String] the command to run
+        # @!scope class
+        # @return [LightService::Context] Action's context
+        executed do |context|
+          context.logger.task_step false, context.command
+
+          next context if simulate?(cli_options: context.cli_options)
+
+          _stdout, stderr, exit_code = context.photocopier.exec!(context.command)
+
+          next context if exit_code.zero?
+
+          context.fail! "Error code #{exit_code} returned by command "\
+                        "#{context.command}: #{stderr}"
+        end
+      end
+    end
+  end
+end

data/lib/wordmove/assets/dump.php.erb

@@ -1,6 +1,6 @@
 <?php
 
-$shared_key = '<%= password %>';
+$shared_key = '<%= token %>';
 if ($_GET['shared_key'] != $shared_key) {
   die();
 }
@@ -214,14 +214,14 @@ class MySQLDump
 
 }
 
-$db_host = '<%= escape_php db[:host] %>';
-$db_port = '<%= db[:port] %>';
+$db_host = '<%= escape_php(string: remote_db_options[:host]) %>';
+$db_port = '<%= remote_db_options[:port] %>';
 if (!$db_port) {
   $db_port = ini_get("mysqli.default_port");
 }
-$db_user = '<%= escape_php db[:user] %>';
-$db_password = '<%= escape_php db[:password] %>';
-$db_name = '<%= escape_php db[:name] %>';
+$db_user = '<%= escape_php(string: remote_db_options[:user]) %>';
+$db_password = '<%= escape_php(string: remote_db_options[:password]) %>';
+$db_name = '<%= escape_php(string: remote_db_options[:name]) %>';
 
 $connection = new mysqli($db_host, $db_user, $db_password, $db_name, $db_port);
 $dump = new MySQLDump($connection);

data/lib/wordmove/assets/import.php.erb

@@ -1,6 +1,6 @@
 <?php
 
-$shared_key = '<%= password %>';
+$shared_key = '<%= token %>';
 if ($_GET['shared_key'] != $shared_key) {
   die();
 }
@@ -43,20 +43,20 @@ error_reporting(E_ALL);
 
 // Database configuration
 
-$db_port = '<%= escape_php db[:port] %>';
+$db_port = '<%= escape_php(string: remote_db_options[:port]) %>';
 if (!$db_port) {
   $db_port = ini_get("mysqli.default_port");
 }
-$db_server = '<%= escape_php db[:host] %>';
-$db_username = '<%= escape_php db[:user] %>';
-$db_password = '<%= escape_php db[:password] %>';
-$db_name = '<%= escape_php db[:name] %>';
+$db_server = '<%= escape_php(string: remote_db_options[:host]) %>';
+$db_username = '<%= escape_php(string: remote_db_options[:user]) %>';
+$db_password = '<%= escape_php(string: remote_db_options[:password]) %>';
+$db_name = '<%= escape_php(string: remote_db_options[:name]) %>';
 
 // Connection charset should be the same as the dump file charset (utf8, latin1, cp1251, koi8r etc.)
 // See http://dev.mysql.com/doc/refman/5.0/en/charset-charsets.html for the full list
 // Change this if you have problems with non-latin letters
 
-$db_connection_charset = '<%= db[:charset] || 'utf8' %>';
+$db_connection_charset = '<%= remote_db_options[:charset] || 'utf8' %>';
 
 // OPTIONAL SETTINGS
 

data/lib/wordmove/assets/wordmove_schema_global.yml

@@ -1,4 +1,6 @@
 type: map
 mapping:
   sql_adapter:
+    type: str
     required: true
+    pattern: /\Awpcli\Z/

data/lib/wordmove/cli.rb

@@ -1,122 +1,183 @@
 module Wordmove
-  class CLI < Thor
-    map %w[--version -v] => :__print_version
+  module CLI
+    module PullPushShared
+      extend ActiveSupport::Concern
+      WORDPRESS_OPTIONS = %i[wordpress uploads themes plugins mu_plugins languages db].freeze
+
+      included do # rubocop:disable Metrics/BlockLength
+        option :wordpress, type: :boolean, aliases: %w[w]
+        option :uploads, type: :boolean, aliases: %w[u]
+        option :themes, type: :boolean, aliases: %w[t]
+        option :plugins, type: :boolean, aliases: %w[p]
+        option :mu_plugins, type: :boolean, aliases: %w[m]
+        option :languages, type: :boolean, aliases: %w[l]
+        option :db, type: :boolean, aliases: %w[d]
+        option :simulate, type: :boolean
+        option :environment, aliases: %w[e]
+        option :config, aliases: %w[c]
+        option :no_adapt, type: :boolean
+        option :all, type: :boolean
+        # option :verbose, type: :boolean, aliases: %w[v]
+        option :debug, type: :boolean
+
+        private
+
+        def ensure_wordpress_options_presence!(cli_options)
+          return if (
+            cli_options.deep_symbolize_keys.keys &
+              (Wordmove::CLI::PullPushShared::WORDPRESS_OPTIONS + [:all])
+          ).present?
+
+          puts 'No options given. See wordmove --help'
+          exit 1
+        end
 
-    desc "--version, -v", "Print the version"
-    def __print_version
-      puts Wordmove::VERSION
-    end
+        def initial_context(cli_options)
+          cli_options.deep_symbolize_keys!
+          movefile = Wordmove::Movefile.new(cli_options)
 
-    desc "init", "Generates a brand new movefile.yml"
-    def init
-      Wordmove::Generators::Movefile.start
-    end
+          [cli_options, movefile]
+        end
 
-    desc "doctor", "Do some local configuration and environment checks"
-    def doctor
-      Wordmove::Doctor.start
-    end
+        def movefile_from(**cli_options)
+          ensure_wordpress_options_presence!(cli_options)
+          Wordmove::Movefile.new(cli_options)
+        rescue MovefileNotFound => e
+          Logger.new($stdout).error(e.message)
+          exit 1
+        end
+
+        def call_organizer_with(klass:, movefile:, **cli_options)
+          result = klass.call(cli_options: cli_options, movefile: movefile)
 
-    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)
+          exit 0 if result.success?
+
+          Logger.new($stdout).error(result.message)
+          exit 1
         end
       end
+    end
 
-      def wordpress_options
-        %w[wordpress uploads themes plugins mu_plugins languages db]
-      end
+    module Commands
+      extend Dry::CLI::Registry
 
-      def ensure_wordpress_options_presence!(options)
-        return if (options.keys & (wordpress_options + ["all"])).present?
+      class Version < Dry::CLI::Command
+        desc 'Print the version'
 
-        puts "No options given. See wordmove --help"
-        exit 1
+        def call(*)
+          puts Wordmove::VERSION
+        end
       end
 
-      def logger
-        Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }
+      class Init < Dry::CLI::Command
+        desc 'Generates a brand new movefile.yml'
+
+        def call(*)
+          Wordmove::Generators::Movefile.generate
+        end
       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
+      class Doctor < Dry::CLI::Command
+        desc 'Do some local configuration and environment checks'
 
-    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
+        def call(*)
+          Wordmove::Doctor.start
+        end
       end
 
-      Wordmove::Hook.run(:pull, :before, options)
+      class List < Dry::CLI::Command
+        desc 'List all environments and vhosts'
 
-      guardian = Wordmove::Guardian.new(options: options, action: :pull)
+        option :config, aliases: %w[c]
 
-      handle_options(options) do |task|
-        deployer.send("pull_#{task}") if guardian.allows(task.to_sym)
+        def call(**cli_options)
+          Wordmove::EnvironmentsList.print(cli_options)
+        rescue Wordmove::MovefileNotFound => e
+          Logger.new($stdout).error(e.message)
+          exit 1
+        rescue Psych::SyntaxError => e
+          Logger.new($stdout)
+                .error("Your movefile is not parsable due to a syntax error: #{e.message}")
+          exit 1
+        end
       end
 
-      Wordmove::Hook.run(:pull, :after, options)
-    end
+      class Pull < Dry::CLI::Command
+        desc 'Pulls WP data from remote host to the local machine'
 
-    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
+        include Wordmove::CLI::PullPushShared
+
+        def call(**cli_options)
+          call_pull_organizer_with(**cli_options)
+        end
+
+        private
+
+        def call_pull_organizer_with(**cli_options)
+          movefile = movefile_from(**cli_options)
+
+          if movefile.options.dig(movefile.environment, :ssh)
+            call_organizer_with(
+              klass: Wordmove::Organizers::Ssh::Pull,
+              movefile: movefile,
+              **cli_options
+            )
+          elsif movefile.options.dig(movefile.environment, :ftp)
+            call_organizer_with(
+              klass: Wordmove::Organizers::Ftp::Pull,
+              movefile: movefile,
+              **cli_options
+            )
+          else
+            raise NoAdapterFound, 'No valid adapter found.'
+          end
+        rescue NoAdapterFound => e
+          Logger.new($stdout).error(e.message)
+          exit 1
+        end
       end
 
-      Wordmove::Hook.run(:push, :before, options)
+      class Push < Dry::CLI::Command
+        desc 'Pulls WP data from remote host to the local machine'
 
-      guardian = Wordmove::Guardian.new(options: options, action: :push)
+        include Wordmove::CLI::PullPushShared
 
-      handle_options(options) do |task|
-        deployer.send("push_#{task}") if guardian.allows(task.to_sym)
+        def call(**cli_options)
+          call_push_organizer_with(**cli_options)
+        end
+
+        private
+
+        def call_push_organizer_with(**cli_options)
+          movefile = movefile_from(**cli_options)
+
+          if movefile.options.dig(movefile.environment, :ssh)
+            call_organizer_with(
+              klass: Wordmove::Organizers::Ssh::Push,
+              movefile: movefile,
+              **cli_options
+            )
+          elsif movefile.options.dig(movefile.environment, :ftp)
+            call_organizer_with(
+              klass: Wordmove::Organizers::Ftp::Push,
+              movefile: movefile,
+              **cli_options
+            )
+          else
+            raise NoAdapterFound, 'No valid adapter found.'
+          end
+        rescue NoAdapterFound => e
+          Logger.new($stdout).error(e.message)
+          exit 1
+        end
       end
 
-      Wordmove::Hook.run(:push, :after, options)
+      register 'version', Version, aliases: %w[v -v --version]
+      register 'init', Init
+      register 'doctor', Doctor
+      register 'list', List
+      register 'pull', Pull
+      register 'push', Push
     end
   end
 end

data/lib/wordmove/db_paths_config.rb

@@ -0,0 +1,44 @@
+class DbPathsConfig
+  extend Dry::Configurable
+
+  setting :local, reader: true do
+    setting :path
+    setting :gzipped_path
+    setting :adapted_path
+    setting :gzipped_adapted_path
+  end
+
+  setting :remote, reader: true do
+    setting :path
+    setting :gzipped_path
+  end
+
+  setting :backup, reader: true do
+    setting :local do
+      setting :path
+      setting :gzipped_path
+    end
+
+    setting :remote do
+      setting :path
+      setting :gzipped_path
+    end
+  end
+
+  # FTP settings are intentionally taken apart
+  setting :ftp, reader: true do
+    setting :remote, reader: true do
+      setting :dump_script_path
+      setting :dump_script_url
+      setting :dumped_path
+      setting :import_script_path
+      setting :import_script_url
+    end
+    setting :local, reader: true do
+      setting :generated_dump_script_path
+      setting :generated_import_script_path
+      setting :temp_path
+    end
+    setting :token
+  end
+end

data/lib/wordmove/doctor/movefile.rb

@@ -4,17 +4,17 @@ module Wordmove
       MANDATORY_SECTIONS = %i[global local].freeze
       attr_reader :movefile, :contents, :root_keys
 
-      def initialize(name = nil, dir = '.')
-        @movefile = Wordmove::Movefile.new(name, dir)
+      def initialize(cli_options = {}, dir = '.')
+        @movefile = Wordmove::Movefile.new(cli_options, dir)
 
         begin
-          @contents = movefile.fetch
+          @contents = movefile.options
           @root_keys = contents.keys
         rescue Psych::SyntaxError
-          movefile.logger.error "Your movefile is not parsable due to a syntax error"\
+          movefile.logger.error 'Your movefile is not parsable due to a syntax error'\
                                 "so we can't continue to validate it."
-          movefile.logger.debug "You could try to use https://yamlvalidator.com/ to"\
-                                "get a clue about the problem."
+          movefile.logger.debug 'You could try to use https://yamlvalidator.com/ to'\
+                                'get a clue about the problem.'
         end
       end
 
@@ -40,7 +40,7 @@ module Wordmove
         errors = validator.validate(contents[key].deep_stringify_keys)
 
         if errors&.empty?
-          movefile.logger.success "Formal validation passed"
+          movefile.logger.success 'Formal validation passed'
 
           return true
         end
@@ -69,7 +69,7 @@ module Wordmove
       def validate_protocol_presence(keys)
         return true if keys.include?(:ssh) || keys.include?(:ftp)
 
-        movefile.logger.error "This remote has not ssh nor ftp protocol defined"
+        movefile.logger.error 'This remote has not ssh nor ftp protocol defined'
 
         false
       end