aspera-cli 4.27.2 → 4.27.4

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

@@ -8,6 +8,8 @@ require 'aspera/api/ats'
 require 'aspera/api/aoc'
 require 'aspera/api/alee'
 require 'aspera/assert'
+require 'aspera/rainbow'
+using Rainbow
 
 module Aspera
   module Cli
@@ -33,26 +35,26 @@ module Aspera
           super(**base_args)
           @ats_api_open = Api::Ats.new
           @ats_api_auth = api
-          options.parse_options!
         end
 
         # --- DSL ---
 
-        command :cluster,    description: 'Display general ATS cluster information (public API, no auth)'
+        command :cluster,    description: 'Show general ATS cluster information (public API, no auth)'
         command :access_key, description: 'Manage ATS access keys'
         command :api_key,    description: 'Manage credential to access ATS API', condition: :api_key_available?
-        command :aws_trust_policy, description: 'Show AWS trust policy', action: lambda { Result::SingleObject.new(ats_api.read('aws/trustpolicy', {region: options.get_option(:region, mandatory: true)})) }
+        command :aws_trust_policy, description: 'Show AWS trust policy', action: ->(**) { Result::SingleObject.new(ats_api.read('aws/trustpolicy', {region: options.get_option(:region, mandatory: true)})) }
 
-        commands_under(:cluster) do
-          command :clouds, description: 'List cloud providers', action: lambda { Result::ObjectList.new(@ats_api_open.cloud_names.map { |k, v| CLOUD_TABLE.zip([k, v]).to_h }) }
-          command :list,   description: 'List ATS servers',     action: lambda { Result::ObjectList.new(@ats_api_open.all_servers, fields: %w[id cloud region]) }
-          command :show,   description: 'Show a specific server'
+        commands_under :cluster do
+          command :clouds, description: 'List cloud providers', action: ->(**) { Result::ObjectList.new(@ats_api_open.cloud_names.map { |k, v| CLOUD_TABLE.zip([k, v]).to_h }) }
+          command :list,   description: 'List ATS servers',     action: ->(**) { Result::ObjectList.new(@ats_api_open.all_servers, fields: %w[id cloud region]) }
+          command :show,   description: 'Show a specific server (or use options cloud and region)',
+            arguments: [{name: :server_id, mandatory: false, default: nil}]
         end
 
-        commands_under(:access_key) do
+        commands_under :access_key do
           command :create,      description: 'Create an access key',
-            arguments: [{name: :params, type: Hash, mandatory: false, default: {}}]
-          command(:list,        description: 'List access keys', action: lambda do
+            arguments: [{name: :access_key, type: Hash, mandatory: false, default: {}}]
+          command(:list,        description: 'List access keys', action: lambda do |**|
             res = ats_api.read('access_keys', query_read_delete(default: {'offset' => 0, 'max_results' => 1000}))
             Result::ObjectList.new(res['data'], fields: ['name', 'id', 'created.at', 'modified.at'])
           end)
@@ -60,41 +62,52 @@ module Aspera
             arguments: [{name: :access_key_id, type: :identifier}],
             action: ->(access_key_id:, **) { Result::SingleObject.new(ats_api.read("access_keys/#{access_key_id}")) }
           command :modify,      description: 'Modify an access key',
-            arguments: [{name: :access_key_id, type: :identifier}, {name: :params, type: Hash}]
-          command :delete,      description: 'Delete an access key',
-            arguments: [{name: :access_key_id, type: :identifier}]
+            arguments: [{name: :access_key_id, type: :identifier}, {name: :access_key, type: Hash}]
+          command(
+            :delete, description: 'Delete an access key',
+            arguments: [{name: :access_key_id, type: :identifier}],
+            action: lambda do |access_key_id:, **|
+              ats_api.delete("access_keys/#{access_key_id}")
+              Result::Status.new("deleted #{access_key_id}")
+            end
+          )
           command :node,        description: 'Execute node commands via ATS access key',
             arguments: [{name: :access_key_id, type: :identifier}],
-            setup: :setup_ak_node
+            mount: {plugin: Node, at: %i[access_keys do], instance: :ak_node_plugin}
           command :cluster,     description: 'Show cluster info for an access key',
             arguments: [{name: :access_key_id, type: :identifier}]
-          command :entitlement, description: 'Show ATS entitlement for an access key',
-            arguments: [{name: :access_key_id, type: :identifier}]
-        end
-
-        commands_under %i[access_key node] do
-          command :permission, description: 'Manage permissions'
-          command :sync,       description: 'Synchronize folders'
-          Node::COMMANDS_GEN4_SPEC.each do |cmd, spec|
-            command cmd, **spec
-          end
+          command(
+            :entitlement, description: 'Show ATS entitlement for an access key',
+            arguments: [{name: :access_key_id, type: :identifier}],
+            action: lambda do |access_key_id:, **|
+              ak = ats_api.read("access_keys/#{access_key_id}")
+              api_bss = Api::Alee.new(ak['license']['entitlement_id'], ak['license']['customer_id'])
+              return Result::SingleObject.new(api_bss.read('entitlement'))
+            end
+          )
         end
 
-        commands_under(:api_key) do
-          command(:instances, description: 'List ATS instances in IBM Cloud', action: lambda do
+        commands_under :api_key do
+          command(:instances, description: 'List ATS instances in IBM Cloud', action: lambda do |**|
             instances = ats_api_v2_auth_ibm.read('instances')
             Log.log.warn { "more instances remaining: #{instances['remaining']}" } unless instances['remaining'].to_i.eql?(0)
             Result::ValueList.new(instances['data'], name: 'instance')
           end)
           command :create, description: 'Create an ATS API key',
-            arguments: [{name: :params, type: Hash, mandatory: false, default: {}}],
-            action: ->(params:, **) { Result::SingleObject.new(build_ats_ibm_api_with_instance.create('api_keys', params)) }
-          command :list,   description: 'List ATS API keys', action: lambda { Result::ValueList.new(build_ats_ibm_api_with_instance.read('api_keys', {'offset' => 0, 'max_results' => 1000})['data'], name: 'ats_id') }
+            arguments: [{name: :api_key, type: Hash, mandatory: false, default: {}}],
+            action: ->(api_key:, **) { Result::SingleObject.new(build_ats_ibm_api_with_instance.create('api_keys', api_key)) }
+          command :list,   description: 'List ATS API keys', action: ->(**) { Result::ValueList.new(build_ats_ibm_api_with_instance.read('api_keys', {'offset' => 0, 'max_results' => 1000})['data'], name: 'ats_id') }
           command :show,   description: 'Show an ATS API key',
             arguments: [{name: :api_key_id, type: :identifier}],
             action: ->(api_key_id:, **) { Result::SingleObject.new(build_ats_ibm_api_with_instance.read("api_keys/#{api_key_id}")) }
-          command :delete, description: 'Delete an ATS API key',
-            arguments: [{name: :api_key_id, type: :identifier}]
+          command(
+            :delete, description: 'Delete an ATS API key',
+            arguments: [{name: :api_key_id, type: :identifier}],
+            action: lambda do |api_key_id:, **|
+              build_ats_ibm_api_with_instance.delete("api_keys/#{api_key_id}")
+              Result::Status.new("deleted #{api_key_id}")
+            end
+          )
         end
 
         # --- conditions ---
@@ -116,7 +129,7 @@ module Aspera
         # require api key only if needed
         def ats_api
           return @ats_api_auth unless @ats_api_auth.nil?
-          @ats_api_auth = Rest.new(
+          @ats_api_auth = Rest::Client.new(
             base_url: "#{Api::Ats::SERVICE_BASE_URL}/pub/v1",
             auth:     {
               type:     :basic,
@@ -127,7 +140,7 @@ module Aspera
         end
 
         def ats_api_v2_auth_ibm(rest_add_headers = {})
-          return Rest.new(
+          return Rest::Client.new(
             base_url: "#{Api::Ats::SERVICE_BASE_URL}/v2",
             headers:  rest_add_headers,
             auth:     {
@@ -144,25 +157,26 @@ module Aspera
           )
         end
 
-        def action_cluster_show
+        def action_cluster_show(server_id: nil, **)
           if options.get_option(:cloud) || options.get_option(:region)
             server_data = server_by_cloud_region
           else
-            server_id = options.instance_identifier
+            Aspera.assert(server_id, type: Cli::MissingArgument) { 'server_id (or options cloud and region)' }
             server_data = @ats_api_open.all_servers.find { |i| i['id'].eql?(server_id) }
             raise BadIdentifier.new('server', server_id) if server_data.nil?
           end
           Result::SingleObject.new(server_data)
         end
 
-        def action_access_key_create(params: {}, **)
+        def action_access_key_create(access_key: {}, **)
+          params = access_key
           server_data = nil
           # if transfer_server_id not provided, get it from command line options
           if !params.key?('transfer_server_id')
             server_data = server_by_cloud_region
             params['transfer_server_id'] = server_data['id']
           end
-          Log.log.debug { "using params: #{params}".bg_red.gray }
+          Log.log.debug { "using params: #{params}".bg(:red).white }
           if params.key?('storage')
             case params['storage']['type']
             # here we need somehow to map storage type to field to get for auth end point
@@ -189,27 +203,17 @@ module Aspera
           # TODO : action : modify, with "PUT"
         end
 
-        def action_access_key_modify(params:, access_key_id:, **)
+        def action_access_key_modify(access_key:, access_key_id:, **)
+          params = access_key
           params['id'] = access_key_id
           ats_api.update("access_keys/#{access_key_id}", params)
           return Result::Status.new('modified')
         end
 
-        def action_access_key_delete(access_key_id:, **)
-          ats_api.delete("access_keys/#{access_key_id}")
-          Result::Status.new("deleted #{access_key_id}")
-        end
-
-        def action_access_key_entitlement(access_key_id:, **)
-          ak = ats_api.read("access_keys/#{access_key_id}")
-          api_bss = Api::Alee.new(ak['license']['entitlement_id'], ak['license']['customer_id'])
-          return Result::SingleObject.new(api_bss.read('entitlement'))
-        end
-
-        # Build the Node plugin for an ATS access key.
+        # access_key > node - mount target: Node plugin for an ATS access key.
         # access_key_id: is already in ctx via arguments: on the :node command.
-        # @return [Hash] context hash containing :ak_node_plugin and :ak_root_file_id
-        def setup_ak_node(access_key_id:, **)
+        # @return [Array(Node, Hash)] Node plugin and seed ctx for `access_keys do`
+        def ak_node_plugin(access_key_id:, **)
           ak_data = ats_api.read("access_keys/#{access_key_id}")
           server_data = @ats_api_open.all_servers.find { |i| i['id'].start_with?(ak_data['transfer_server_id']) }
           Aspera.assert(!server_data.nil?, type: Cli::Error) { 'no such server found' }
@@ -222,37 +226,12 @@ module Aspera
               password: context.secret_finder.lookup(url: node_url, username: access_key_id)
             }
           )
-          {
-            ak_node_plugin:  Node.new(context: context, api: api_node),
-            ak_root_file_id: ak_data['root_file_id']
-          }
-        end
-
-        # One handler per COMMANDS_GEN4 - delegates to the Node plugin's DSL registry.
-        # Pre-resolved arguments (e.g. path:) are forwarded via **ctx to avoid double token consumption.
-        Node::COMMANDS_GEN4.each do |cmd|
-          define_action_method([:access_key, :node, cmd]) do |ak_node_plugin:, ak_root_file_id:, **ctx|
-            # For permission: the handler consumes the path first then re-dispatches to sub-commands.
-            # Calling dispatch_from_registry with skip_setup would bypass path consumption and fail.
-            next ak_node_plugin.send(:"action_access_keys_do_#{cmd}", do_root_file_id: ak_root_file_id, **ctx) if cmd.eql?(:permission)
-            ak_node_plugin.dispatch_from_registry([:access_keys, :do, cmd], {do_root_file_id: ak_root_file_id, **ctx}, skip_setup: true)
-          end
-        end
-
-        def action_api_key_instances
-          instances = ats_api_v2_auth_ibm.read('instances')
-          Log.log.warn { "more instances remaining: #{instances['remaining']}" } unless instances['remaining'].to_i.eql?(0)
-          Result::ValueList.new(instances['data'], name: 'instance')
-        end
-
-        def action_api_key_delete(api_key_id:, **)
-          build_ats_ibm_api_with_instance.delete("api_keys/#{api_key_id}")
-          Result::Status.new("deleted #{api_key_id}")
+          [Node.new(context: context, api: api_node), {do_root_file_id: ak_data['root_file_id']}]
         end
 
         def action_access_key_cluster(access_key_id:, **)
           ats_url = ats_api.base_url
-          api_ak_auth = Rest.new(
+          api_ak_auth = Rest::Client.new(
             base_url: ats_url,
             auth:     {
               type:     :basic,
@@ -270,7 +249,7 @@ module Aspera
         def build_ats_ibm_api_with_instance
           instance = options.get_option(:instance)
           if instance.nil?
-            instance = ats_api_v2_auth_ibm.read('instances')['data'].first
+            instance = ats_api_v2_auth_ibm.read('instances')['data']&.first
             formatter.display_status("using first instance: #{instance}")
           end
           ats_api_v2_auth_ibm({'X-ATS-Service-Instance-Id' => instance})