aspera-cli 4.26.1 → 4.27.0

data/lib/aspera/cli/plugins/server.rb

@@ -3,6 +3,7 @@
 # cspell:ignore ascmd zmode zuid zgid fasping
 require 'aspera/cli/plugins/basic_auth'
 require 'aspera/cli/sync_actions'
+require 'aspera/transfer/result'
 require 'aspera/transfer/spec'
 require 'aspera/ascmd'
 require 'aspera/ssh'
@@ -21,26 +22,17 @@ module Aspera
         LOCAL_SCHEME = 'local'
         HTTPS_SCHEME = 'https'
         URI_SCHEMES = [SSH_SCHEME, LOCAL_SCHEME, HTTPS_SCHEME].freeze
-        ASCMD_ALIASES = {
-          browse: :ls,
-          delete: :rm,
-          rename: :mv
-        }.freeze
-        TRANSFER_COMMANDS = %i[sync upload download].freeze
 
-        private_constant :SSH_SCHEME, :URI_SCHEMES, :ASCMD_ALIASES, :TRANSFER_COMMANDS
+        private_constant :SSH_SCHEME, :URI_SCHEMES
 
         class LocalExecutor
           def execute(ascmd_path, input:)
             Environment.secure_execute(ascmd_path, mode: :capture, stdin_data: input, binmode: true, exception: false).first
           end
         end
+        application_name 'HSTS Fasp/SSH'
 
         class << self
-          def application_name
-            'HSTS Fasp/SSH'
-          end
-
           # @return [Hash,NilClass]
           def detect(address_or_url)
             urls = if address_or_url.match?(%r{^[a-z]{1,6}://})
@@ -87,10 +79,8 @@ module Aspera
         def initialize(**_)
           super
           @connection_type = :ssh
-          options.declare(:ssh_keys, 'SSH key path list', allowed: Allowed::TYPES_STRING_ARRAY)
-          options.declare(:passphrase, 'SSH private key passphrase')
-          options.declare(:ssh_options, 'SSH options', allowed: Hash, default: {})
-          SyncActions.declare_options(options)
+          @ascmd_executor = nil
+          @server_transfer_spec = nil
           options.parse_options!
           @ssh_opts = options.get_option(:ssh_options).symbolize_keys
         end
@@ -165,81 +155,136 @@ module Aspera
           end
           # if user provided transfer spec has a token, we will use bypass keys
           cred_set = true if transfer.user_transfer_spec['token'].is_a?(String)
-          Aspera.assert(cred_set, type: BadArgument){'Either password, key , or transfer spec token must be provided'}
+          Aspera.assert(cred_set, 'Either password, key , or transfer spec token must be provided', type: BadArgument)
           return server_transfer_spec
         end
 
-        def execute_transfer(command, transfer_spec)
-          case command
-          when :upload, :download
-            transfer_spec['direction'] = Transfer::Spec.transfer_type_to_direction(command)
-            return Main.result_transfer(transfer.start(transfer_spec))
-          when :sync
-            # lets ignore the arguments provided by execute_sync_action, we just give the transfer spec
-            return execute_sync_action{transfer_spec}
+        Sync::Operations::DIRECTIONS.each do |dir|
+          define_method(:"action_sync_#{dir}"){ |**| run_sync_transfer(dir){@server_transfer_spec}}
+        end
+
+        # --- DSL ---
+
+        option :ssh_keys,    description: 'SSH key path list', allowed: Allowed::TYPES_STRING_ARRAY
+        option :passphrase,  description: 'SSH private key passphrase'
+        option :ssh_options, description: 'SSH options', allowed: Hash
+
+        # root_setup runs once before any command argument is consumed, populating
+        # @server_transfer_spec and @ascmd_executor so that condition methods work.
+        root_setup :setup_server
+
+        command :health, description: 'Check transfer health'
+        command(:upload, description: 'Upload files to server', transfer_paths: :send, action: lambda do
+          @server_transfer_spec['direction'] = Transfer::Spec.transfer_type_to_direction(:upload)
+          Runner.result_transfer(transfer.start(@server_transfer_spec))
+        end)
+        command(:download, description: 'Download files from server', transfer_paths: :receive, action: lambda do
+          @server_transfer_spec['direction'] = Transfer::Spec.transfer_type_to_direction(:download)
+          Runner.result_transfer(transfer.start(@server_transfer_spec))
+        end)
+        command :sync, description: 'Synchronize files with server'
+        commands_under(:sync) do
+          Sync::Operations::DIRECTIONS.each do |dir|
+            command(dir, description: "#{dir.capitalize}-sync with server", transfer_paths: :send)
+          end
+          command :admin, description: 'Manage sync database (admin operations)'
+          SyncActions.register_sync_admin_commands(self, %i[sync admin])
+        end
+
+        commands_under(:health) do
+          command :transfer, description: 'Check FASP transfer health'
+        end
+
+        # AsCmd operations (available only when SSH/local - not WSS)
+        ASCMD_ARGS = [{name: :command_arguments, multiple: true, mandatory: false, default: nil}].freeze
+        private_constant :ASCMD_ARGS
+
+        command :ls,     description: 'List files on server',            condition: :ascmd_available?, aliases: [:browse], arguments: ASCMD_ARGS
+        command :rm,     description: 'Delete file(s) on server',        condition: :ascmd_available?, aliases: [:delete], arguments: ASCMD_ARGS
+        command :mv,     description: 'Rename/move file(s) on server',   condition: :ascmd_available?, aliases: [:rename], arguments: ASCMD_ARGS
+        command :cp,     description: 'Copy file(s) on server',          condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :mkdir,  description: 'Create directory on server',       condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :df,     description: 'Show disk usage on server',        condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :du,     description: 'Show file sizes on server',        condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :md5sum, description: 'Compute MD5 checksums on server',  condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :info,   description: 'Show server system information',   condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+
+        # Generate ascmd handlers - convention: action_<op>
+        %i[rm mv cp mkdir].each do |op|
+          define_action_method([op]) do |command_arguments:, **|
+            execute_ascmd(op, command_arguments){Result::Success.new}
           end
         end
 
-        # actions without ascmd
-        BASE_ACTIONS = %i[health].concat(TRANSFER_COMMANDS).freeze
-        # all actions
-        ACTIONS = [BASE_ACTIONS, AsCmd::OPERATIONS, ASCMD_ALIASES.keys].flatten.freeze
+        %i[du md5sum info].each do |op|
+          define_action_method([op]) do |command_arguments:, **|
+            execute_ascmd(op, command_arguments){ |r| Result::SingleObject.new(r.stringify_keys)}
+          end
+        end
+
+        # --- conditions ---
+
+        def ascmd_available?
+          !@ascmd_executor.nil?
+        end
+
+        # --- setup ---
 
-        def execute_action
-          server_transfer_spec = options_to_base_transfer_spec
-          ascmd_executor = case @connection_type
+        # Build the transfer spec and ascmd executor from CLI options.
+        # Stores results in instance variables; returns empty context hash.
+        def setup_server(**)
+          @server_transfer_spec = options_to_base_transfer_spec
+          @ascmd_executor = case @connection_type
           when :local then LocalExecutor.new
-          when :wss then nil
-          when :ssh then Ssh.new(server_transfer_spec['remote_host'], server_transfer_spec['remote_user'], @ssh_opts)
+          when :wss   then nil
+          when :ssh   then Ssh.new(@server_transfer_spec['remote_host'], @server_transfer_spec['remote_user'], @ssh_opts)
           else Aspera.error_unexpected_value(@connection_type){'connection type'}
           end
-          # the set of available commands depends on SSH executor availability (i.e. no WSS)
-          available_commands = ascmd_executor.nil? ? BASE_ACTIONS : ACTIONS
-          # get command and translate aliases
-          command = options.get_next_command(available_commands)
-          command = ASCMD_ALIASES[command] if ASCMD_ALIASES.key?(command)
-          case command
-          when :health
-            nagios = Nagios.new
-            command_nagios = options.get_next_command(%i[transfer])
-            case command_nagios
-            when :transfer
-              probe_ts = server_transfer_spec.merge({
-                'direction'     => 'send',
-                'cookie'        => 'aspera.sync', # hide in console
-                'resume_policy' => 'none',
-                'paths'         => [{'source' => 'faux:///pingfile?1k', 'destination' => '.fasping'}]
-              })
-              statuses = transfer.start(probe_ts)
-              if TransferAgent.session_status(statuses).eql?(:success)
-                nagios.add_ok('transfer', 'ok')
-              else
-                nagios.add_critical('transfer', statuses.reject{ |i| i.eql?(:success)}.first.to_s)
-              end
-            else Aspera.error_unexpected_value(command_nagios)
-            end
-            Main.result_object_list(nagios.status_list)
-          when *TRANSFER_COMMANDS
-            return execute_transfer(command, server_transfer_spec)
-          when *AsCmd::OPERATIONS
-            command_arguments = options.get_next_argument('ascmd command arguments', multiple: true, mandatory: false)
-            ascmd = AsCmd.new(ascmd_executor)
-            begin
-              result = ascmd.execute_single(command, command_arguments)
-              case command
-              when :mkdir, :mv, :cp, :rm
-                return Main.result_success
-              when :ls
-                return Main.result_object_list(result.map(&:stringify_keys), fields: %w[zmode zuid zgid size mtime name])
-              when :df
-                return Main.result_object_list(result.map(&:stringify_keys))
-              when :du, :md5sum, :info
-                return Main.result_single_object(result.stringify_keys)
-              end
-            rescue AsCmd::Error => e
-              raise Cli::BadArgument, e.extended_message
-            end
-          else Aspera.error_unreachable_line
+          {}
+        end
+
+        # --- health ---
+
+        def action_health_transfer
+          nagios = Nagios.new
+          probe_ts = @server_transfer_spec.merge({
+            'direction'     => 'send',
+            'cookie'        => 'aspera.sync', # hide in console
+            'resume_policy' => 'none',
+            'paths'         => [{'source' => 'faux:///pingfile?1k', 'destination' => '.fasping'}]
+          })
+          statuses = transfer.start(probe_ts)
+          if statuses.is_a?(Transfer::Result::Success)
+            nagios.add_ok('transfer', 'ok')
+          else
+            nagios.add_critical('transfer', statuses.is_a?(Transfer::Result::Error) ? statuses.exception.message : statuses.to_s)
+          end
+          Result::ObjectList.new(nagios.status_list)
+        end
+
+        # --- ascmd handlers ---
+
+        def action_ls(command_arguments:, **)
+          execute_ascmd(:ls, command_arguments) do |result|
+            Result::ObjectList.new(result.map(&:stringify_keys), fields: %w[zmode zuid zgid size mtime name])
+          end
+        end
+
+        def action_df(command_arguments:, **)
+          execute_ascmd(:df, command_arguments) do |result|
+            Result::ObjectList.new(result.map(&:stringify_keys))
+          end
+        end
+
+        private
+
+        def execute_ascmd(op, command_arguments)
+          ascmd = AsCmd.new(@ascmd_executor)
+          begin
+            result = ascmd.execute_single(op, command_arguments)
+            yield(result)
+          rescue AsCmd::Error => e
+            raise Cli::BadArgument, e.extended_message
           end
         end
       end