wordmove 5.2.0 → 6.0.0.alpha.2

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

@@ -0,0 +1,56 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Syncs wordpress folder (usually root folder), exluding +wp-content/+ folder, over SSH
+      # 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::SSH]
+        # @!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::Ssh::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/ssh/push_wordpress.rb

@@ -0,0 +1,54 @@
+module Wordmove
+  module Actions
+    module Ssh
+      # Syncs wordpress folder (usually root folder), exluding +wp-content/+ folder, over SSH
+      # 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::SSH]
+        # @!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::Ssh::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/ssh/put_and_import_dump_remotely.rb

@@ -0,0 +1,77 @@
+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
+          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.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
+          )
+          if result.failure?
+            context.logger.warning 'Failed to delete remote file ' \
+                                   "#{context.db_paths.remote.path} because: " \
+                                   "#{result.message}" \
+                                   '. Manual intervention required'
+          end
+        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/assets/wordmove_schema_remote.yml

@@ -162,7 +162,7 @@ mapping:
             type: bool
           uploads:
             type: bool
-          mu-plugins:
+          mu_plugins:
             type: bool
       push:
         type: map
@@ -177,5 +177,5 @@ mapping:
             type: bool
           uploads:
             type: bool
-          mu-plugins:
+          mu_plugins:
             type: bool

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