aspera-cli 4.26.2 → 4.27.0

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

@@ -9,7 +9,7 @@ module Aspera
       class Oauth < BasicAuth
         class << self
           # Get command line `options` specified by `AUTH_OPTIONS`
-          # @param options [Cli::Manager] Object to get command line options.
+          # @param options [Cli::Parser] Object to get command line options.
           # @return [Hash{Symbol => Object}] Options
           # @raise [Cli::Error] if a required option is missing
           def kwargs_from_options(options)
@@ -28,15 +28,12 @@ module Aspera
         AUTH_TYPES = %i[web jwt boot].freeze
         # Options used for authentication (url, auth, client_id, etc...)
         AUTH_OPTIONS = %i[url auth client_id client_secret redirect_uri private_key passphrase username password].freeze
-        def initialize(**_)
-          super
-          options.declare(:auth, 'OAuth type of authentication', allowed: AUTH_TYPES, default: :jwt)
-          options.declare(:client_id, 'OAuth client identifier')
-          options.declare(:client_secret, 'OAuth client secret')
-          options.declare(:redirect_uri, 'OAuth (Web) redirect URI for web authentication')
-          options.declare(:private_key, 'OAuth (JWT) RSA private key PEM value (prefix file path with @file:)')
-          options.declare(:passphrase, 'OAuth (JWT) RSA private key passphrase')
-        end
+        option :auth,          description: 'OAuth type of authentication', allowed: AUTH_TYPES, default: :jwt
+        option :client_id,     description: 'OAuth client identifier'
+        option :client_secret, description: 'OAuth client secret'
+        option :redirect_uri,  description: 'OAuth (Web) redirect URI for web authentication'
+        option :private_key,   description: 'OAuth (JWT) RSA private key PEM value (prefix file path with @file:)'
+        option :passphrase,    description: 'OAuth (JWT) RSA private key passphrase'
       end
     end
   end

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

@@ -15,6 +15,7 @@ module Aspera
         STANDARD_PATH = '/aspera/orchestrator'
         TEST_ENDPOINT = 'api/remote_node_ping'
         private_constant :STANDARD_PATH, :TEST_ENDPOINT
+
         class << self
           # @return [Hash,NilClass]
           def detect(address_or_url)
@@ -23,7 +24,7 @@ module Aspera
             urls.push("#{address_or_url}#{STANDARD_PATH}") unless address_or_url.end_with?(STANDARD_PATH)
             error = nil
             urls.each do |base_url|
-              next unless base_url.match?('https?://')
+              next unless base_url.match?(%r{^https?://})
               api = Rest.new(base_url: base_url)
               data, http = api.read(TEST_ENDPOINT, query: {format: :json}, ret: :both)
               next unless data['remote_orchestrator_info']
@@ -55,13 +56,14 @@ module Aspera
           }
         end
 
+        option :result,      description: "Specify result value as: 'work_step:parameter'"
+        option :synchronous, description: 'Wait for completion', allowed: Allowed::TYPES_BOOLEAN, default: false
+        option :ret_style,   description: 'How return type is requested in api', allowed: %i[header arg ext], default: :arg
+        option :auth_style,  description: 'Authentication type', allowed: %i[arg_pass head_basic apikey], default: :head_basic
+
         def initialize(**_)
           super
           @api_orch = nil
-          options.declare(:result, "Specify result value as: 'work_step:parameter'")
-          options.declare(:synchronous, 'Wait for completion', allowed: Allowed::TYPES_BOOLEAN, default: false)
-          options.declare(:ret_style, 'How return type is requested in api', allowed: %i[header arg ext], default: :arg)
-          options.declare(:auth_style, 'Authentication type', allowed: %i[arg_pass head_basic apikey], default: :head_basic)
           options.parse_options!
         end
 
@@ -97,9 +99,77 @@ module Aspera
           return result
         end
 
-        ACTIONS = %i[health info workflows workorders workstep plugins processes monitors].freeze
+        private :call_ao
+
+        # --- DSL ---
+
+        command :health,     description: 'Check Orchestrator API health',               setup: :setup_api
+        command :info,       description: 'Ping the remote Orchestrator instance',       setup: :setup_api, action: ->{Result::SingleObject.new(call_ao('remote_node_ping', format: 'xml', xml_arrays: false))}
+        command :processes,  description: 'Show Orchestrator background process status', setup: :setup_api, action: ->{Result::ObjectList.new(call_ao('processes_status', format: 'xml')['process'])}
+        command :monitors,   description: 'Show Orchestrator monitor snapshot',          setup: :setup_api, action: ->{Result::SingleObject.new(call_ao('monitor_snapshot')['monitor'])}
+        command :plugins,    description: 'Show Orchestrator plugin versions',           setup: :setup_api, action: ->{Result::ObjectList.new(call_ao('plugin_version')['Plugin'])}
+        command :workflows,  description: 'Manage workflows',   setup: :setup_api
+        command :workorders, description: 'Manage work orders', setup: :setup_api
+        command :workstep,   description: 'Manage work steps',  setup: :setup_api
+
+        commands_under(:workflows) do
+          command(:list, description: 'List all workflows', action: lambda do
+            Result::ObjectList.new(
+              call_ao('workflows_list')['workflows']['workflow'],
+              fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification]
+            )
+          end)
+          command :status,     description: 'Check running status of workflow(s)',
+            arguments: [{name: :wf_id, type: :identifier}],
+            action: ->(wf_id:, **){Result::ObjectList.new(call_ao(wf_id.eql?(SpecialValues::ALL) ? 'workflows_status' : "workflows_status/#{wf_id}")['workflows']['workflow'])}
+          command :inputs,     description: 'Fetch input specification for a workflow',
+            arguments: [{name: :wf_id, type: :identifier}],
+            action: ->(wf_id:, **){Result::SingleObject.new(call_ao("workflow_inputs_spec/#{wf_id}")['workflow_inputs_spec'])}
+          command :details,    description: 'Check detailed running status of a workflow',
+            arguments: [{name: :wf_id, type: :identifier}],
+            action: ->(wf_id:, **){Result::ObjectList.new(call_ao("workflow_details/#{wf_id}")['workflows']['workflow']['statuses'])}
+          command :start,      description: 'Initiate a work order (sync or async)',
+            arguments: [{name: :wf_id, type: :identifier}, {name: :external_parameters, type: Hash, mandatory: false, default: {}}]
+          command :export,     description: 'Export a workflow',
+            arguments: [{name: :wf_id, type: :identifier}],
+            action: ->(wf_id:, **){Result::Text.new(call_ao("export_workflow/#{wf_id}", format: nil, http: true).body)}
+          command :workorders, description: 'Fetch all work orders from a workflow',
+            arguments: [{name: :wf_id, type: :identifier}],
+            action: ->(wf_id:, **){Result::ObjectList.new(call_ao("work_orders_list/#{wf_id}")['work_orders'])}
+          command :outputs,    description: 'Fetch output specification for a workflow',
+            arguments: [{name: :wf_id, type: :identifier}],
+            action: ->(wf_id:, **){Result::ObjectList.new(call_ao("workflow_outputs_spec/#{wf_id}")['workflow_outputs_spec']['output'])}
+        end
+
+        commands_under(:workorders) do
+          command :status, description: 'Check the status of a work order',
+            arguments: [{name: :wo_id, type: :identifier}],
+            action: ->(wo_id:, **){Result::SingleObject.new(call_ao("work_order_status/#{wo_id}")['work_order'])}
+          command :cancel, description: 'Cancel a work order',
+            arguments: [{name: :wo_id, type: :identifier}],
+            action: ->(wo_id:, **){Result::SingleObject.new(call_ao("work_order_cancel/#{wo_id}")['work_order'])}
+          command :reset,  description: 'Reset a work order',
+            arguments: [{name: :wo_id, type: :identifier}],
+            action: ->(wo_id:, **){Result::SingleObject.new(call_ao("work_order_reset/#{wo_id}")['work_order'])}
+          command :output, description: 'Fetch output of a work order',
+            arguments: [{name: :wo_id, type: :identifier}],
+            action: ->(wo_id:, **){Result::ObjectList.new(call_ao("work_order_output/#{wo_id}", format: 'xml')['variable'])}
+        end
+
+        commands_under(:workstep) do
+          command :status, description: 'Check the status of a work step',
+            arguments: [{name: :ws_id, type: :identifier}],
+            action: ->(ws_id:, **){Result::SingleObject.new(call_ao("work_step_status/#{ws_id}"))}
+          command :cancel, description: 'Cancel a work step',
+            arguments: [{name: :ws_id, type: :identifier}],
+            action: ->(ws_id:, **){Result::SingleObject.new(call_ao("work_step_cancel/#{ws_id}"))}
+        end
+
+        # --- setup ---
 
-        def execute_action
+        # Build the Orchestrator REST API from CLI options.
+        # @return [Hash] ctx with no extra keys (stores api in @api_orch instance var)
+        def setup_api(**)
           auth_params =
             case options.get_option(:auth_style, mandatory: true)
             when :arg_pass
@@ -119,140 +189,47 @@ module Aspera
             when :apikey
               Aspera.error_not_implemented
             end
-
           @api_orch = Rest.new(
             base_url: options.get_option(:url, mandatory: true),
             auth: auth_params
           )
+          {}
+        end
 
-          command1 = options.get_next_command(ACTIONS)
-          case command1
-          when :health
-            nagios = Nagios.new
-            begin
-              info = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)
-              nagios.add_ok('api', 'accessible')
-              nagios.check_product_version('api', 'orchestrator', info['orchestrator-version'])
-            rescue StandardError => e
-              nagios.add_critical('node api', e.to_s)
-            end
-            Result::ObjectList.new(nagios.status_list)
-          # 14. Ping the remote Instance
-          when :info
-            result = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)
-            return Result::SingleObject.new(result)
-          # 12. Orchestrator Background Process status
-          when :processes
-            # TODO: Bug ? API has only XML format
-            result = call_ao('processes_status', format: 'xml')
-            return Result::ObjectList.new(result['process'])
-          # 13. Orchestrator Monitor
-          when :monitors
-            result = call_ao('monitor_snapshot')
-            return Result::SingleObject.new(result['monitor'])
-          when :plugins
-            # TODO: Bug ? only json format on url
-            result = call_ao('plugin_version')
-            return Result::ObjectList.new(result['Plugin'])
-          when :workflows
-            command = options.get_next_command(%i[list status inputs details start export workorders outputs])
-            case command
-            # 1. List all available workflows on the system
-            when :list
-              result = call_ao('workflows_list')
-              return Result::ObjectList.new(result['workflows']['workflow'], fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification])
-            # 2.1 Initiate a workorder - Asynchronous
-            # 2.2 Initiate a workorder - Synchronous
-            when :start
-              call_params = {format: :json}
-              wf_id = options.instance_identifier
-              # get external parameters if any
-              options.get_next_argument('external_parameters', mandatory: false, validation: Hash, default: {}).each do |name, value|
-                call_params["external_parameters[#{name}]"] = value
-              end
-              # synchronous call ?
-              call_params['synchronous'] = true if options.get_option(:synchronous, mandatory: true)
-              # expected result for synchro call ?
-              result_location = options.get_option(:result)
-              unless result_location.nil?
-                fields = result_location.split(':')
-                raise Cli::BadArgument, "Expects: work_step:result_name : #{result_location}" if fields.length != 2
-                call_params['explicit_output_step'] = fields[0]
-                call_params['explicit_output_variable'] = fields[1]
-                # implicitly, call is synchronous
-                call_params['synchronous'] = true
-              end
-              result_data = call_ao("initiate/#{wf_id}", args: call_params)
-              # Return appropriate result type based on call mode
-              return call_params['synchronous'] ? Result::Text.new(result_data) : Result::SingleObject.new(result_data)
-            # 3. Fetch input specification for a workflow
-            when :inputs
-              result = call_ao("workflow_inputs_spec/#{options.instance_identifier}")
-              return Result::SingleObject.new(result['workflow_inputs_spec'])
-            # 4. Check the running status for all workflows
-            # 5. Check the running status for a particular workflow
-            when :status
-              wf_id = options.instance_identifier
-              result = call_ao(wf_id.eql?(SpecialValues::ALL) ? 'workflows_status' : "workflows_status/#{wf_id}")
-              return Result::ObjectList.new(result['workflows']['workflow'])
-            # 6. Check the detailed running status for a particular workflow
-            when :details
-              result = call_ao("workflow_details/#{options.instance_identifier}")
-              return Result::ObjectList.new(result['workflows']['workflow']['statuses'])
-            # 15. Fetch output specification for a particular work flow
-            when :outputs
-              result = call_ao("workflow_outputs_spec/#{options.instance_identifier}")
-              return Result::ObjectList.new(result['workflow_outputs_spec']['output'])
-            # 19.Fetch all workorders from a workflow
-            when :workorders
-              result = call_ao("work_orders_list/#{options.instance_identifier}")
-              return Result::ObjectList.new(result['work_orders'])
-            when :export
-              result = call_ao("export_workflow/#{options.instance_identifier}", format: nil, http: true)
-              return Result::Text.new(result.body)
-            end
-          when :workorders
-            command = options.get_next_command(%i[status cancel reset output])
-            case command
-            # 7. Check the status for a particular work order
-            when :status
-              wo_id = options.instance_identifier
-              result = call_ao("work_order_status/#{wo_id}")
-              return Result::SingleObject.new(result['work_order'])
-            # 9. Cancel a Work Order
-            when :cancel
-              wo_id = options.instance_identifier
-              result = call_ao("work_order_cancel/#{wo_id}")
-              return Result::SingleObject.new(result['work_order'])
-            # 11. Reset a Work order
-            when :reset
-              wo_id = options.instance_identifier
-              result = call_ao("work_order_reset/#{wo_id}")
-              return Result::SingleObject.new(result['work_order'])
-            # 16. Fetch output of a work order
-            when :output
-              wo_id = options.instance_identifier
-              result = call_ao("work_order_output/#{wo_id}", format: 'xml')
-              return Result::ObjectList.new(result['variable'])
-            end
-          when :workstep
-            command = options.get_next_command(%i[status cancel])
-            case command
-            # 8. Check the status of a Step
-            when :status
-              ws_id = options.instance_identifier
-              result = call_ao("work_step_status/#{ws_id}")
-              return Result::SingleObject.new(result)
-            # 10. Cancel a Work Step
-            when :cancel
-              ws_id = options.instance_identifier
-              result = call_ao("work_step_cancel/#{ws_id}")
-              return Result::SingleObject.new(result)
-            end
-          else Aspera.error_unexpected_value(command)
+        def action_health
+          nagios = Nagios.new
+          begin
+            info = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)
+            nagios.add_ok('api', 'accessible')
+            nagios.check_product_version('api', 'orchestrator', info['orchestrator-version'])
+          rescue StandardError => e
+            nagios.add_critical('node api', e.to_s)
           end
+          Result::ObjectList.new(nagios.status_list)
+        end
+
+        # 2.1/2.2 Initiate a workorder (async / synchronous)
+        def action_workflows_start(wf_id:, external_parameters:, **)
+          call_params = {format: :json}
+          # get external parameters if any
+          external_parameters.each do |name, value|
+            call_params["external_parameters[#{name}]"] = value
+          end
+          # synchronous call ?
+          call_params['synchronous'] = true if options.get_option(:synchronous, mandatory: true)
+          # expected result for synchro call ?
+          result_location = options.get_option(:result)
+          unless result_location.nil?
+            fields = result_location.split(':')
+            Aspera.assert(fields.length == 2, type: Cli::BadArgument){"Expects: work_step:result_name : #{result_location}"}
+            call_params['explicit_output_step'] = fields[0]
+            call_params['explicit_output_variable'] = fields[1]
+            # implicitly, call is synchronous
+            call_params['synchronous'] = true
+          end
+          result_data = call_ao("initiate/#{wf_id}", args: call_params)
+          call_params['synchronous'] ? Result::Text.new(result_data) : Result::SingleObject.new(result_data)
         end
-        private :call_ao
       end
     end
   end