aspera-cli 4.26.2 → 4.27.1

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}://})
@@ -55,7 +47,7 @@ module Aspera
             error = nil
             urls.each do |base_url|
               server_uri = URI.parse(base_url)
-              Log.log.debug{"URI=#{server_uri}, host=#{server_uri.hostname}, port=#{server_uri.port}, scheme=#{server_uri.scheme}"}
+              Log.log.debug { "URI=#{server_uri}, host=#{server_uri.hostname}, port=#{server_uri.port}, scheme=#{server_uri.scheme}" }
               next unless server_uri.scheme.eql?(SSH_SCHEME)
               socket = TCPSocket.new(server_uri.hostname, server_uri.port)
               socket.puts('SSH-2.0-Ascli_0.0')
@@ -63,7 +55,7 @@ module Aspera
               return {version: version.gsub(/^SSH-2.0-/, ''), url: base_url} if version.match?(/^SSH-2.0-/)
             rescue StandardError => e
               error = e
-              Log.log.debug{"detect error: #{e}"}
+              Log.log.debug { "detect error: #{e}" }
             end
             raise error if error
             return
@@ -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
@@ -101,10 +91,10 @@ module Aspera
           url = options.get_option(:url, mandatory: true)
           server_transfer_spec = {}
           server_uri = URI.parse(url)
-          Log.log.debug{"URI=#{server_uri}, host=#{server_uri.hostname}, port=#{server_uri.port}, scheme=#{server_uri.scheme}"}
+          Log.log.debug { "URI=#{server_uri}, host=#{server_uri.hostname}, port=#{server_uri.port}, scheme=#{server_uri.scheme}" }
           server_transfer_spec['remote_host'] = server_uri.hostname
           unless URI_SCHEMES.include?(server_uri.scheme)
-            Log.log.warn{"Scheme [#{server_uri.scheme}] not supported in #{url}, use one of: #{URI_SCHEMES.join(', ')}. Defaulting to #{SSH_SCHEME}."}
+            Log.log.warn { "Scheme [#{server_uri.scheme}] not supported in #{url}, use one of: #{URI_SCHEMES.join(', ')}. Defaulting to #{SSH_SCHEME}." }
             server_uri.scheme = SSH_SCHEME
           end
           if server_uri.scheme.eql?(LOCAL_SCHEME)
@@ -125,13 +115,13 @@ module Aspera
             Log.log.warn('URL scheme is https but no token was provided in transfer spec.')
             Log.log.warn("If you want to access the server, not using WSS for session, then use a URL with scheme \"#{SSH_SCHEME}\" and proper SSH port")
             assumed_url = "#{SSH_SCHEME}://#{server_transfer_spec['remote_host']}:#{Transfer::Spec::SSH_PORT}"
-            Log.log.warn{"Assuming proper URL is: #{assumed_url}"}
+            Log.log.warn { "Assuming proper URL is: #{assumed_url}" }
             server_uri = URI.parse(assumed_url)
           end
           # Scheme is SSH
           if options.get_option(:username).nil?
             options.set_option(:username, Transfer::Spec::ACCESS_KEY_TRANSFER_USER)
-            Log.log.info{"No username provided: Assuming default transfer user: #{Transfer::Spec::ACCESS_KEY_TRANSFER_USER}"}
+            Log.log.info { "No username provided: Assuming default transfer user: #{Transfer::Spec::ACCESS_KEY_TRANSFER_USER}" }
           end
           server_transfer_spec['remote_user'] = options.get_option(:username, mandatory: true)
           if !server_uri.port.nil?
@@ -147,14 +137,14 @@ module Aspera
           end
           ssh_key_list = options.get_option(:ssh_keys)
           if !ssh_key_list.nil?
-            Aspera.assert_array_all(ssh_key_list, String){'ssh_keys'}
-            ssh_key_list.map!{ |p| File.expand_path(p)}
-            Log.log.debug{"SSH keys=#{ssh_key_list}"}
+            Aspera.assert_array_all(ssh_key_list, String) { 'ssh_keys' }
+            ssh_key_list.map! { |p| File.expand_path(p) }
+            Log.dump(:ssh_keys, ssh_key_list)
             if !ssh_key_list.empty?
               @ssh_opts[:keys] = ssh_key_list
               # PEM as per RFC 7468
               server_transfer_spec['ssh_private_key'] = File.read(ssh_key_list.first).strip
-              Log.log.warn{'Using only first SSH key for transfers'} unless ssh_key_list.length.eql?(1)
+              Log.log.warn { 'Using only first SSH key for transfers' } unless ssh_key_list.length.eql?(1)
               cred_set = true
             end
           end
@@ -169,77 +159,137 @@ module Aspera
           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 Runner.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}") { |path:, sync_info: {}, **| run_sync_transfer(dir, path: path, sync_info: sync_info) { @server_transfer_spec } }
+        end
+
+        # --- DSL ---
+
+        option :ssh_keys,    description: 'SSH key path list', allowed: Type::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, arguments: SyncActions::PATH_AND_INFO_ARGS
           end
+          command :admin, description: 'Manage sync database (admin operations)'
+          SyncActions.register_sync_admin_commands(self, :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',            condition: :ascmd_available?, aliases: [:browse], arguments: ASCMD_ARGS
+        command :rm,     description: 'Delete files',          condition: :ascmd_available?, aliases: [:delete], arguments: ASCMD_ARGS
+        command :mv,     description: 'Rename/move files',     condition: :ascmd_available?, aliases: [:rename], arguments: ASCMD_ARGS
+        command :cp,     description: 'Copy files',            condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :mkdir,  description: 'Create directory',      condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :df,     description: 'Show disk usage',       condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :du,     description: 'Show file sizes',       condition: :ascmd_available?,                     arguments: ASCMD_ARGS
+        command :md5sum, description: 'Compute MD5 checksums', 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
+
+        %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
 
-        # actions without ascmd
-        BASE_ACTIONS = %i[health].concat(TRANSFER_COMMANDS).freeze
-        # all actions
-        ACTIONS = [BASE_ACTIONS, AsCmd::OPERATIONS, ASCMD_ALIASES.keys].flatten.freeze
+        # --- 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)
-          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
-            Result::ObjectList.new(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 Result::Success.new
-              when :ls
-                return Result::ObjectList.new(result.map(&:stringify_keys), fields: %w[zmode zuid zgid size mtime name])
-              when :df
-                return Result::ObjectList.new(result.map(&:stringify_keys))
-              when :du, :md5sum, :info
-                return Result::SingleObject.new(result.stringify_keys)
-              end
-            rescue AsCmd::Error => e
-              raise Cli::BadArgument, e.extended_message
-            end
-          else Aspera.error_unreachable_line
+          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
+          {}
+        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