aspera-cli 4.13.0 → 4.15.0

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+# cspell:ignore ascmd zmode zuid zgid fasping
 require 'aspera/cli/basic_auth_plugin'
-require 'aspera/cli/plugins/sync'
-require 'aspera/ascmd'
+require 'aspera/cli/sync_actions'
 require 'aspera/fasp/transfer_spec'
+require 'aspera/ascmd'
 require 'aspera/ssh'
 require 'aspera/nagios'
 require 'tempfile'
@@ -13,19 +14,12 @@ module Aspera
   module Cli
     module Plugins
       # implement basic remote access with FASP/SSH
-      class SyncSpecServer
-        def initialize(transfer_spec)
-          @transfer_spec = transfer_spec
-        end
-
-        def transfer_spec(direction, local_path, remote_path)
-          return @transfer_spec
-        end
-      end
-
       class Server < Aspera::Cli::BasicAuthPlugin
+        include SyncActions
         SSH_SCHEME = 'ssh'
-        URI_SCHEMES = %w[https local].push(SSH_SCHEME).freeze
+        LOCAL_SCHEME = 'local'
+        HTTPS_SCHEME = 'https'
+        URI_SCHEMES = [SSH_SCHEME, LOCAL_SCHEME, HTTPS_SCHEME].freeze
         ASCMD_ALIASES = {
           browse: :ls,
           delete: :rm,
@@ -41,36 +35,88 @@ module Aspera
             cmd = cmd.map{|v|%Q("#{v}")}.join(' ') if cmd.is_a?(Array)
             Log.log.debug{"Executing: #{cmd} with '#{line}'"}
             stdout_str, stderr_str, status = Open3.capture3(cmd, stdin_data: line, binmode: true)
-            Log.log.debug(">> #{status} -> #{stderr_str}")
+            Log.log.debug{"exec status: #{status} -> #{stderr_str}"}
             raise "command #{cmd} failed with code #{status.exitstatus} #{stderr_str}" unless status.success?
             return stdout_str
           end
         end
 
+        class << self
+          def application_name
+            'HSTS Fasp/SSH'
+          end
+
+          def detect(address_or_url)
+            urls = if address_or_url.match?(%r{^[a-z]{1,6}://})
+              [address_or_url]
+            else
+              [
+                "ssh://#{address_or_url}:33001",
+                "ssh://#{address_or_url}:22"
+              ]
+              # wss not practical as it requires a token
+            end
+
+            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}"}
+              next unless server_uri.scheme.eql?(SSH_SCHEME)
+              begin
+                socket = TCPSocket.new(server_uri.hostname, server_uri.port)
+                socket.puts('SSH-2.0-Ascli_0.0')
+                version = socket.gets.chomp
+                if version.match?(/^SSH-2.0-/)
+                  return {version: version.gsub(/^SSH-2.0-/, ''), url: base_url}
+                end
+              rescue StandardError => e
+                Log.log.debug{"detect error: #{e}"}
+              end
+            end
+            return nil
+          end
+
+          def wizard(object:, private_key_path: nil, pub_key_pem: nil)
+            options = object.options
+            return {
+              preset_value: {
+                url:      options.get_option(:url, mandatory: true),
+                username: options.get_option(:username, mandatory: true),
+                password: options.get_option(:password, mandatory: true)
+              },
+              test_args:    'files br /'
+            }
+          end
+        end
+
         def initialize(env)
           super(env)
-          options.add_opt_simple(:ssh_keys, 'SSH key path list (Array or single)')
-          options.add_opt_simple(:ssh_options, 'SSH options (Hash)')
+          options.declare(:ssh_keys, 'SSH key path list (Array or single)')
+          options.declare(:passphrase, 'SSH private key passphrase')
+          options.declare(:ssh_options, 'SSH options', types: Hash, default: {})
+          SyncActions.declare_options(options)
           options.parse_options!
-          @ssh_opts = nil
+          @ssh_opts = options.get_option(:ssh_options).symbolize_keys
         end
 
         # Read command line options
         # @return [Hash] transfer specification
         def options_to_base_transfer_spec
-          url = options.get_option(:url, is_type: :mandatory)
+          url = options.get_option(:url, mandatory: true)
           server_transfer_spec = {}
           server_uri = URI.parse(url)
-          Log.log.debug{"URI : #{server_uri}, 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}."}
             server_uri.scheme = SSH_SCHEME
           end
-          if server_uri.scheme.eql?('local')
+          if server_uri.scheme.eql?(LOCAL_SCHEME)
             # Using local execution (mostly for testing)
+            server_transfer_spec['remote_host'] = 'localhost'
+            # simulate SSH environment, else ascp will fail
+            ENV['SSH_CLIENT'] = 'local 0 0'
             return server_transfer_spec
-          elsif transfer.option_transfer_spec['token'].is_a?(String) && server_uri.scheme.eql?('https')
+          elsif transfer.option_transfer_spec['token'].is_a?(String) && server_uri.scheme.eql?(HTTPS_SCHEME)
             server_transfer_spec['wss_enabled'] = true
             server_transfer_spec['wss_port'] = server_uri.port
             # Using WSS
@@ -88,11 +134,7 @@ module Aspera
             options.set_option(:username, Aspera::Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER)
             Log.log.info{"No username provided: Assuming default transfer user: #{Aspera::Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER}"}
           end
-          server_transfer_spec['remote_user'] = options.get_option(:username, is_type: :mandatory)
-          ssh_args = options.get_option(:ssh_options)
-          ssh_args = {} if ssh_args.nil?
-          raise 'expecting a Hash for ssh_options' unless ssh_args.is_a?(Hash)
-          @ssh_opts = ssh_args.symbolize_keys
+          server_transfer_spec['remote_user'] = options.get_option(:username, mandatory: true)
           if !server_uri.port.nil?
             @ssh_opts[:port] = server_uri.port
             server_transfer_spec['ssh_port'] = server_uri.port
@@ -119,6 +161,11 @@ module Aspera
               cred_set = true
             end
           end
+          ssh_passphrase = options.get_option(:passphrase)
+          if !ssh_passphrase.nil?
+            @ssh_opts[:passphrase] = ssh_passphrase
+            server_transfer_spec['ssh_private_key_passphrase'] = ssh_passphrase
+          end
           # if user provided transfer spec has a token, we will use bypass keys
           cred_set = true if transfer.option_transfer_spec['token'].is_a?(String)
           raise 'Either password, key , or transfer spec token must be provided' if !cred_set
@@ -131,8 +178,8 @@ module Aspera
             Fasp::TransferSpec.action_to_direction(transfer_spec, command)
             return Main.result_transfer(transfer.start(transfer_spec))
           when :sync
-            sync_plugin = Plugins::Sync.new(@agents, sync_spec: SyncSpecServer.new(transfer_spec))
-            return sync_plugin.execute_action
+            # lets ignore the arguments provided by execute_sync_action, we just give the transfer spec
+            return execute_sync_action {transfer_spec}
           end
         end
 
@@ -143,7 +190,7 @@ module Aspera
 
         def execute_action
           server_transfer_spec = options_to_base_transfer_spec
-          ascmd_executor = if !@ssh_opts.nil?
+          ascmd_executor = if !@ssh_opts.empty?
             Ssh.new(server_transfer_spec['remote_host'], server_transfer_spec['remote_user'], @ssh_opts)
           elsif server_transfer_spec.key?('wss_enabled')
             nil
@@ -184,10 +231,10 @@ module Aspera
           when *TRANSFER_COMMANDS
             return execute_transfer(command, server_transfer_spec)
           when *Aspera::AsCmd::OPERATIONS
-            args = options.get_next_argument('ascmd command arguments', expected: :multiple, mandatory: false)
+            command_arguments = options.get_next_argument('ascmd command arguments', expected: :multiple, mandatory: false)
             ascmd = Aspera::AsCmd.new(ascmd_executor)
             begin
-              result = ascmd.send(:execute_single, command, args)
+              result = ascmd.send(:execute_single, command, command_arguments)
               case command
               when :mkdir, :mv, :cp, :rm
                 return Main.result_success
@@ -199,7 +246,7 @@ module Aspera
                 return {type: :single_object, data: result.stringify_keys}
               end
             rescue Aspera::AsCmd::Error => e
-              raise CliBadArgument, e.extended_message
+              raise Cli::BadArgument, e.extended_message
             end
           else raise 'internal error: unexpected action'
           end

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

@@ -7,43 +7,67 @@ module Aspera
     module Plugins
       # Plugin for Aspera Shares v1
       class Shares < Aspera::Cli::BasicAuthPlugin
+        API_BASE = 'node_api'
         class << self
-          def detect(base_url)
-            api = Rest.new({base_url: base_url})
-            # Shares
+          def detect(address_or_url)
+            address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
+            api = Rest.new(base_url: address_or_url, redirect_max: 1)
+            found = false
             begin
               # shall fail: shares requires auth, but we check error message
               # TODO: use ping instead ?
-              api.read('node_api/app')
+              api.read("#{API_BASE}/app")
             rescue RestCallError => e
               if e.response.code.to_s.eql?('401') && e.response.body.eql?('{"error":{"user_message":"API user authentication failed"}}')
-                return {version: 'unknown'}
+                found = true
               end
             end
-            nil
+            return nil unless found
+            version = 'unknown'
+            test_page = api.call({ operation: 'GET', subpath: 'login' })
+            if (m = test_page[:http].body.match(/\(v(1\..*)\)/))
+              version = m[1]
+            end
+            return {
+              version: version,
+              url:     address_or_url
+            }
+          end
+
+          def wizard(object:, private_key_path: nil, pub_key_pem: nil)
+            options = object.options
+            return {
+              preset_value: {
+                url:      options.get_option(:url, mandatory: true),
+                username: options.get_option(:username, mandatory: true),
+                password: options.get_option(:password, mandatory: true)
+              },
+              test_args:    'files br /'
+            }
           end
         end
 
         def initialize(env)
           super(env)
-          options.add_opt_list(:type, %i[any local ldap saml], 'Type of user/group for operations')
-          options.set_option(:type, :any)
+          options.declare(:type, 'Type of user/group for operations', values: %i[any local ldap saml], default: :any)
           options.parse_options!
         end
 
         SAML_IMPORT_MANDATORY = %w[id name_id].freeze
         SAML_IMPORT_ALLOWED = %w[email given_name surname].concat(SAML_IMPORT_MANDATORY).freeze
 
-        ACTIONS = %i[health repository admin].freeze
+        ACTIONS = %i[health files admin].freeze
+        # common to users and groups
+        USR_GRP_SETTINGS = %i[transfer_settings app_authorizations share_permissions].freeze
 
         def execute_action
-          command = options.get_next_command(ACTIONS)
+          command = options.get_next_command(ACTIONS, aliases: {repository: :files})
           case command
           when :health
             nagios = Nagios.new
             begin
               Rest
-                .new(base_url: options.get_option(:url, is_type: :mandatory) + '/node_api')
+                .new(base_url: "#{options.get_option(:url, mandatory: true)}/#{API_BASE}")
                 .call(
                   operation: 'GET',
                   subpath: 'ping',
@@ -54,25 +78,28 @@ module Aspera
               nagios.add_critical('node api', e.to_s)
             end
             return nagios.result
-          when :repository
-            api_shares_node = basic_auth_api('node_api')
+          when :repository, :files
+            api_shares_node = basic_auth_api(API_BASE)
             repo_command = options.get_next_command(Node::COMMANDS_SHARES)
-            return Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_shares_node)).execute_action(repo_command)
+            return Node.new(@agents, api: api_shares_node).execute_action(repo_command)
           when :admin
             api_shares_admin = basic_auth_api('api/v1')
-            admin_command = options.get_next_command(%i[user group share node])
+            admin_command = options.get_next_command(%i[user group share node].freeze)
             case admin_command
             when :node
               return entity_action(api_shares_admin, 'data/nodes')
             when :user, :group
               entity_type = admin_command
-              entities_location = options.get_option(:type, is_type: :mandatory)
+              entities_location = options.get_option(:type, mandatory: true)
               entities_path = "data/#{entities_location}_#{entity_type}s"
               entity_action = nil
               case entities_location
               when :any
                 entities_path = "data/#{entity_type}s"
-                entity_action = %i[list show delete share_permissions app_authorizations].freeze
+                entity_action = %i[list show delete]
+                entity_action.concat(USR_GRP_SETTINGS)
+                entity_action.push(:users) if entity_type.eql?(:group)
+                entity_action.freeze
               when :local
                 entity_action = %i[list show create modify delete].freeze
               when :ldap
@@ -80,31 +107,15 @@ module Aspera
               when :saml
                 entity_action = %i[import].freeze
               end
-              entity_command = options.get_next_command(entity_action)
-              entity_path = "#{entities_path}/#{instance_identifier}" if %i[app_authorizations share_permissions].include?(entity_command)
-              case entity_command
-              when :list, :show, :create, :delete, :modify
+              entity_verb = options.get_next_command(entity_action)
+              # entity_path = "#{entities_path}/#{instance_identifier}" if %i[app_authorizations share_permissions].include?(entity_verb)
+              case entity_verb
+              when *Plugin::ALL_OPS
                 display_fields = entity_type.eql?(:user) ? %w[id username first_name last_name email] : nil
                 display_fields.push(:directory_user) if entity_type.eql?(:user) && entities_location.eql?(:any)
-                return entity_command(entity_command, api_shares_admin, entities_path, display_fields: display_fields)
-              when :app_authorizations
-                case options.get_next_command(%i[modify show])
-                when :show
-                  return {type: :single_object, data: api_shares_admin.read("#{entity_path}/app_authorizations")[:data]}
-                when :modify
-                  parameters = options.get_option(:value, is_type: :mandatory)
-                  return {type: :single_object, data: api_shares_admin.update("#{entity_path}/app_authorizations", parameters)[:data]}
-                end
-              when :share_permissions
-                case options.get_next_command(%i[list show])
-                when :list
-                  return {type: :object_list, data: api_shares_admin.read("#{entity_path}/share_permissions")[:data]}
-                when :show
-                  return {type: :single_object, data: api_shares_admin.read("#{entity_path}/share_permissions/#{instance_identifier}")[:data]}
-                end
+                return entity_command(entity_verb, api_shares_admin, entities_path, display_fields: display_fields)
               when :import
-                parameters = options.get_option(:value, is_type: :mandatory)
-                return do_bulk_operation(parameters, 'created') do |entity_parameters|
+                return do_bulk_operation(command: entity_verb, descr: 'user information') do |entity_parameters|
                   entity_parameters = entity_parameters.transform_keys{|k|k.gsub(/\s+/, '_').downcase}
                   raise 'expecting Hash' unless entity_parameters.is_a?(Hash)
                   SAML_IMPORT_MANDATORY.each{|p|raise "missing mandatory field: #{p}" if entity_parameters[p].nil?}
@@ -114,11 +125,13 @@ module Aspera
                   api_shares_admin.create("#{entities_path}/import", entity_parameters)[:data]
                 end
               when :add
-                parameters = options.get_option(:value)
-                return do_bulk_operation(parameters, 'created') do |entity_name|
-                  raise "expecting string (name), have #{entity_name.class}" unless entity_name.is_a?(String)
+                return do_bulk_operation(command: entity_verb, descr: "#{entity_type} name", values: String) do |entity_name|
                   api_shares_admin.create(entities_path, {entity_type=>entity_name})[:data]
                 end
+              when *USR_GRP_SETTINGS
+                group_id = instance_identifier
+                entities_path = "#{entities_path}/#{group_id}/#{entity_verb}"
+                return entity_action(api_shares_admin, entities_path, is_singleton: !entity_verb.eql?(:share_permissions))
               end
             when :share
               share_command = options.get_next_command(%i[user_permissions group_permissions].concat(Plugin::ALL_OPS))

data/lib/aspera/cli/sync_actions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'aspera/sync'
+
+module Aspera
+  module Cli
+    # Module for sync actions
+    module SyncActions
+      SIMPLE_ARGUMENTS_SYNC = {
+        direction:  Aspera::Sync::DIRECTIONS,
+        local_dir:  String,
+        remote_dir: String
+      }.stringify_keys.freeze
+
+      class << self
+        def declare_options(options)
+          options.declare(:sync_info, 'Information for sync instance and sessions', types: Hash)
+        end
+      end
+
+      def execute_sync_action(&block)
+        # options = Aspera::Cli::Manager.new
+        raise 'Internal Error: No block given' unless block
+        command = options.get_next_command(%i[start admin])
+        # try to get 3 arguments as simple arguments
+        case command
+        when :start
+          simple_session_args = {}
+          SIMPLE_ARGUMENTS_SYNC.each do |arg, check|
+            value = options.get_next_argument(
+              arg,
+              type: check.is_a?(Class) ? check : nil,
+              expected: check.is_a?(Class) ? :single : check,
+              mandatory: false)
+            break if value.nil?
+            simple_session_args[arg] = value.to_s
+          end
+          async_params = nil
+          if simple_session_args.empty?
+            async_params = options.get_option(:sync_info, mandatory: true)
+          else
+            raise Cli::BadArgument,
+              "Provide zero or 3 arguments: #{SIMPLE_ARGUMENTS_SYNC.keys.join(',')}" unless simple_session_args.keys.sort == SIMPLE_ARGUMENTS_SYNC.keys.sort
+            async_params = options.get_option(
+              :sync_info,
+              mandatory: false,
+              default: {'sessions' => [{'name' => File.basename(simple_session_args['local_dir'])}]})
+            raise "sync_info shall be a Hash with key 'sessions' with Array of Hash: #{async_params}" unless async_params.is_a?(Hash) &&
+              async_params['sessions']&.is_a?(Array) &&
+              async_params['sessions'].first.is_a?(Hash)
+            async_params['sessions'].first.merge!(simple_session_args)
+          end
+          Log.log.debug{Log.dump('async_params', async_params)}
+          Aspera::Sync.start(async_params, &block)
+          return Main.result_success
+        when :admin
+          command2 = options.get_next_command([:status])
+          case command2
+          when :status
+            sync_session_name = options.get_next_argument('name of sync session', mandatory: false, type: String)
+            async_params = options.get_option(:sync_info, mandatory: true)
+            return {type: :single_object, data: Aspera::Sync.admin_status(async_params, sync_session_name)}
+          end # command2
+        end # command
+      end # execute_action
+    end # SyncActions
+  end # Cli
+end # Aspera