aspera-cli 4.5.0 → 4.8.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/nagios'
 
@@ -5,53 +7,57 @@ module Aspera
   module Cli
     module Plugins
       class Console < BasicAuthPlugin
+        DEFAULT_FILTER_AGE_SECONDS = 3 * 3600
+        private_constant :DEFAULT_FILTER_AGE_SECONDS
         def initialize(env)
           super(env)
-          self.options.add_opt_date(:filter_from,"only after date")
-          self.options.add_opt_date(:filter_to,"only before date")
-          self.options.set_option(:filter_from,Manager.time_to_string(Time.now - 3*3600))
-          self.options.set_option(:filter_to,Manager.time_to_string(Time.now))
-          self.options.parse_options!
+          options.add_opt_date(:filter_from,'only after date')
+          options.add_opt_date(:filter_to,'only before date')
+          time_now = Time.now
+          options.set_option(:filter_from,Manager.time_to_string(time_now - DEFAULT_FILTER_AGE_SECONDS))
+          options.set_option(:filter_to,Manager.time_to_string(time_now))
+          options.parse_options!
         end
 
-        ACTIONS=[:transfer,:health]
+        ACTIONS = %i[transfer health].freeze
 
         def execute_action
-          api_console=basic_auth_api('api')
-          command=self.options.get_next_command(ACTIONS)
+          api_console = basic_auth_api('api')
+          command = options.get_next_command(ACTIONS)
           case command
           when :health
-            nagios=Nagios.new
+            nagios = Nagios.new
             begin
               api_console.read('ssh_keys')
               nagios.add_ok('console api','accessible')
-            rescue => e
+            rescue StandardError => e
               nagios.add_critical('console api',e.to_s)
             end
             return nagios.result
           when :transfer
-            command=self.options.get_next_command([ :current, :smart ])
+            command = options.get_next_command(%i[current smart])
             case command
             when :smart
-              command=self.options.get_next_command([:list,:submit])
+              command = options.get_next_command(%i[list submit])
               case command
               when :list
-                return {:type=>:object_list,:data=>api_console.read('smart_transfers')[:data]}
+                return {type: :object_list,data: api_console.read('smart_transfers')[:data]}
               when :submit
-                smart_id = self.options.get_next_argument("smart_id")
-                params = self.options.get_next_argument("transfer parameters")
-                return {:type=>:object_list,:data=>api_console.create('smart_transfers/'+smart_id,params)[:data]}
+                smart_id = options.get_next_argument('smart_id')
+                params = options.get_next_argument('transfer parameters')
+                return {type: :object_list,data: api_console.create('smart_transfers/' + smart_id,params)[:data]}
               end
             when :current
-              command=self.options.get_next_command([ :list ])
+              command = options.get_next_command([:list])
               case command
               when :list
-                return {:type=>:object_list,
-                  :data=>api_console.read('transfers',{
-                  'from'=>self.options.get_option(:filter_from,:mandatory),
-                  'to'=>self.options.get_option(:filter_to,:mandatory)
+                return {
+                  type:   :object_list,
+                  data:   api_console.read('transfers',{
+                    'from' => options.get_option(:filter_from,is_type: :mandatory),
+                    'to'   => options.get_option(:filter_to,is_type: :mandatory)
                   })[:data],
-                  :fields=>['id','contact','name','status']}
+                  fields: %w[id contact name status]}
               end
             end
           end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/cli/plugin'
 require 'aspera/cli/plugins/node'
 require 'aspera/cos_node'
@@ -8,55 +10,44 @@ module Aspera
       class Cos < Plugin
         def initialize(env)
           super(env)
-          @service_creds=nil
-          self.options.add_opt_simple(:bucket,'IBM Cloud Object storage bucket')
-          self.options.add_opt_simple(:endpoint,'storage endpoint url')
-          self.options.add_opt_simple(:apikey,'storage API key')
-          self.options.add_opt_simple(:crn,'ressource instance id')
-          #self.options.add_opt_simple(:oauth,'Oauth url')
-          self.options.add_opt_simple(:service_credentials,'IBM Cloud service credentials (Hash)')
-          self.options.add_opt_simple(:region,'IBM Cloud Object storage region')
+          @service_creds = nil
+          options.add_opt_simple(:bucket,'Bucket name')
+          options.add_opt_simple(:endpoint,'Storage endpoint url')
+          options.add_opt_simple(:apikey,'Storage API key')
+          options.add_opt_simple(:crn,'Ressource instance id')
+          options.add_opt_simple(:service_credentials,'IBM Cloud service credentials (Hash)')
+          options.add_opt_simple(:region,'Storage region')
+          options.add_opt_simple(:identity,"Authentication url (#{CosNode::IBM_CLOUD_TOKEN_URL})")
+          options.set_option(:identity,CosNode::IBM_CLOUD_TOKEN_URL)
+          options.parse_options!
         end
 
-        ACTIONS=[:node]
+        ACTIONS = %i[node].freeze
 
         def execute_action
-          command=self.options.get_next_command(ACTIONS)
+          command = options.get_next_command(ACTIONS)
           case command
           when :node
-            bucket_name=self.options.get_option(:bucket,:mandatory)
+            bucket_name = options.get_option(:bucket,is_type: :mandatory)
             # get service credentials, Hash, e.g. @json:@file:...
-            service_credentials=self.options.get_option(:service_credentials,:optional)
-            storage_endpoint=self.options.get_option(:endpoint,:optional)
-            raise "one of: endpoint or service_credentials is required" if service_credentials.nil? and storage_endpoint.nil?
-            raise "endpoint and service_credentials are mutually exclusive" unless service_credentials.nil? or storage_endpoint.nil?
+            service_credentials = options.get_option(:service_credentials)
+            storage_endpoint = options.get_option(:endpoint)
+            raise CliBadArgument,'one of: endpoint or service_credentials is required' if service_credentials.nil? && storage_endpoint.nil?
+            raise CliBadArgument,'endpoint and service_credentials are mutually exclusive' unless service_credentials.nil? || storage_endpoint.nil?
             if service_credentials.nil?
-              service_api_key = self.options.get_option(:apikey,:mandatory)
-              instance_id = self.options.get_option(:crn,:mandatory)
+              service_api_key = options.get_option(:apikey,is_type: :mandatory)
+              instance_id = options.get_option(:crn,is_type: :mandatory)
             else
-              # check necessary contents
-              raise CliBadArgument,'service_credentials must be a Hash' unless service_credentials.is_a?(Hash)
-              ['apikey','resource_instance_id','endpoints'].each do |field|
-                raise CliBadArgument,"service_credentials must have a field: #{field}" unless service_credentials.has_key?(field)
-              end
-              Aspera::Log.dump('service_credentials',service_credentials)
-              # get options
-              bucket_region=self.options.get_option(:region,:mandatory)
-              # get API key from service credentials
-              service_api_key=service_credentials['apikey']
-              instance_id=service_credentials['resource_instance_id']
-              # read endpoints from service provided in service credentials
-              endpoints=Aspera::Rest.new({:base_url=>service_credentials['endpoints']}).read('')[:data]
-              Aspera::Log.dump('endpoints',endpoints)
-              storage_endpoint=endpoints.dig('service-endpoints','regional',bucket_region,'public',bucket_region)
-              raise "no such region: #{bucket_region}" if storage_endpoint.nil?
-              storage_endpoint='https://'+storage_endpoint
+              params=CosNode.parameters_from_svc_creds(service_credentials,options.get_option(:region,is_type: :mandatory))
+              storage_endpoint = params[:storage_endpoint]
+              service_api_key = params[:service_api_key]
+              instance_id = params[:instance_id]
             end
-            api_node=CosNode.new(bucket_name,storage_endpoint,instance_id,service_api_key)
+            api_node = CosNode.new(bucket_name,storage_endpoint,instance_id,service_api_key,options.get_option(:identity,is_type: :mandatory))
             #command=self.options.get_next_command(Node::ACTIONS)
             #command=self.options.get_next_command(Node::COMMON_ACTIONS)
-            command=self.options.get_next_command([:upload,:download,:info,:access_key,:api_details])
-            node_plugin=Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_node, add_request_param: api_node.add_ts))
+            command = options.get_next_command(%i[upload download info access_key api_details transfer])
+            node_plugin = Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_node, add_request_param: api_node.add_ts))
             return node_plugin.execute_action(command)
           end
         end