aspera-cli 4.5.0 → 4.8.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/cli/plugins/node'
 require 'aspera/ats_api'
 
@@ -10,202 +12,207 @@ module Aspera
       class Ats < Plugin
         def initialize(env)
           super(env)
-          self.options.add_opt_simple(:ibm_api_key,"IBM API key, see https://cloud.ibm.com/iam/apikeys")
-          self.options.add_opt_simple(:instance,"ATS instance in ibm cloud")
-          self.options.add_opt_simple(:ats_key,"ATS key identifier (ats_xxx)")
-          self.options.add_opt_simple(:ats_secret,"ATS key secret")
-          self.options.add_opt_simple(:params,"Parameters access key creation (@json:)")
-          self.options.add_opt_simple(:cloud,"Cloud provider")
-          self.options.add_opt_simple(:region,"Cloud region")
-          self.options.parse_options!
+          options.add_opt_simple(:ibm_api_key,'IBM API key, see https://cloud.ibm.com/iam/apikeys')
+          options.add_opt_simple(:instance,'ATS instance in ibm cloud')
+          options.add_opt_simple(:ats_key,'ATS key identifier (ats_xxx)')
+          options.add_opt_simple(:ats_secret,'ATS key secret')
+          options.add_opt_simple(:params,'Parameters access key creation (@json:)')
+          options.add_opt_simple(:cloud,'Cloud provider')
+          options.add_opt_simple(:region,'Cloud region')
+          options.parse_options!
         end
 
-        #
         def server_by_cloud_region
           # todo: provide list ?
-          cloud=self.options.get_option(:cloud,:mandatory).upcase
-          region=self.options.get_option(:region,:mandatory)
+          cloud = options.get_option(:cloud,is_type: :mandatory).upcase
+          region = options.get_option(:region,is_type: :mandatory)
           return @ats_api_pub.read("servers/#{cloud}/#{region}")[:data]
         end
 
         # require api key only if needed
         def ats_api_pub_v1
           return @ats_api_pub_v1_cache unless @ats_api_pub_v1_cache.nil?
-          @ats_api_pub_v1_cache=Rest.new({
-            :base_url => AtsApi.base_url+'/pub/v1',
-            :auth     => {
-            :type     => :basic,
-            :username => self.options.get_option(:ats_key,:mandatory),
-            :password => self.options.get_option(:ats_secret,:mandatory)}
+          @ats_api_pub_v1_cache = Rest.new({
+            base_url: AtsApi.base_url + '/pub/v1',
+            auth:     {
+              type:     :basic,
+              username: options.get_option(:ats_key,is_type: :mandatory),
+              password: options.get_option(:ats_secret,is_type: :mandatory)}
           })
         end
 
         def execute_action_access_key
-          commands=[:create,:list,:show,:modify,:delete,:node,:cluster,:entitlement]
-          command=self.options.get_next_command(commands)
+          commands = %i[create list show modify delete node cluster entitlement]
+          command = options.get_next_command(commands)
           # those dont require access key id
-          access_key_id=self.instance_identifier() unless [:create,:list].include?(command)
+          access_key_id = instance_identifier unless %i[create list].include?(command)
           case command
           when :create
-            params=self.options.get_option(:params,:optional) || {}
-            server_data=nil
+            params = options.get_option(:params) || {}
+            server_data = nil
             # if transfer_server_id not provided, get it from command line options
             if !params.has_key?('transfer_server_id')
-              server_data=server_by_cloud_region
-              params['transfer_server_id']=server_data['id']
+              server_data = server_by_cloud_region
+              params['transfer_server_id'] = server_data['id']
             end
             Log.log.debug("using params: #{params}".bg_red.gray)
             if params.has_key?('storage')
               case params['storage']['type']
               # here we need somehow to map storage type to field to get for auth end point
               when 'ibm-s3'
-                server_data2=nil
+                server_data2 = nil
                 if server_data.nil?
-                  server_data2=@ats_api_pub.all_servers.select{|s|s['id'].eql?(params['transfer_server_id'])}.first
+                  server_data2 = @ats_api_pub.all_servers.find{|s|s['id'].eql?(params['transfer_server_id'])}
                   raise "no such transfer server id: #{params['transfer_server_id']}" if server_data2.nil?
                 else
-                  server_data2=@ats_api_pub.all_servers.select{|s|s['cloud'].eql?(server_data['cloud']) and s['region'].eql?(server_data['region']) and s.has_key?('s3_authentication_endpoint')}.first
+                  server_data2 = @ats_api_pub.all_servers.find do |s|
+                    s['cloud'].eql?(server_data['cloud']) &&
+                    s['region'].eql?(server_data['region']) &&
+                    s.has_key?('s3_authentication_endpoint')
+                  end
                   raise "no such transfer server id: #{params['transfer_server_id']}" if server_data2.nil?
                   # specific one do not have s3 end point in id
-                  params['transfer_server_id']=server_data2['id']
+                  params['transfer_server_id'] = server_data2['id']
                 end
                 if !params['storage'].has_key?('authentication_endpoint')
                   params['storage']['endpoint'] = server_data2['s3_authentication_endpoint']
                 end
               end
             end
-            res=ats_api_pub_v1.create('access_keys',params)
-            return {:type=>:single_object, :data=>res[:data]}
+            res = ats_api_pub_v1.create('access_keys',params)
+            return {type: :single_object, data: res[:data]}
             # TODO : action : modify, with "PUT"
           when :list
-            params=self.options.get_option(:params,:optional) || {'offset'=>0,'max_results'=>1000}
-            res=ats_api_pub_v1.read("access_keys",params)
-            return {:type=>:object_list, :data=>res[:data]['data'], :fields => ['name','id','created.at','modified.at']}
+            params = options.get_option(:params) || {'offset' => 0,'max_results' => 1000}
+            res = ats_api_pub_v1.read('access_keys',params)
+            return {type: :object_list, data: res[:data]['data'], fields: ['name','id','created.at','modified.at']}
           when :show
-            res=ats_api_pub_v1.read("access_keys/#{access_key_id}")
-            return {:type=>:single_object, :data=>res[:data]}
+            res = ats_api_pub_v1.read("access_keys/#{access_key_id}")
+            return {type: :single_object, data: res[:data]}
           when :modify
-            params=self.options.get_option(:value,:mandatory)
-            params["id"]=access_key_id
-            res=ats_api_pub_v1.update("access_keys/#{access_key_id}",params)
+            params = options.get_option(:value,is_type: :mandatory)
+            params['id'] = access_key_id
+            ats_api_pub_v1.update("access_keys/#{access_key_id}",params)
             return Main.result_status('modified')
           when :entitlement
-            ak=ats_api_pub_v1.read("access_keys/#{access_key_id}")[:data]
-            api_bss=AoC.metering_api(ak['license']['entitlement_id'],ak['license']['customer_id'])
-            return {:type=>:single_object, :data=>api_bss.read('entitlement')[:data]}
+            ak = ats_api_pub_v1.read("access_keys/#{access_key_id}")[:data]
+            api_bss = AoC.metering_api(ak['license']['entitlement_id'],ak['license']['customer_id'])
+            return {type: :single_object, data: api_bss.read('entitlement')[:data]}
           when :delete
-            res=ats_api_pub_v1.delete("access_keys/#{access_key_id}")
+            ats_api_pub_v1.delete("access_keys/#{access_key_id}")
             return Main.result_status("deleted #{access_key_id}")
           when :node
-            ak_data=ats_api_pub_v1.read("access_keys/#{access_key_id}")[:data]
-            server_data=@ats_api_pub.all_servers.select {|i| i['id'].start_with?(ak_data['transfer_server_id'])}.first
-            raise CliError,"no such server found" if server_data.nil?
-            base_url=server_data['transfer_setup_url']
-            api_node=Rest.new({
-              :base_url => base_url,
-              :auth     => {
-              :type     => :basic,
-              :username => access_key_id,
-              :password => @agents[:config].get_secret(url: base_url,username: access_key_id)
+            ak_data = ats_api_pub_v1.read("access_keys/#{access_key_id}")[:data]
+            server_data = @ats_api_pub.all_servers.find {|i| i['id'].start_with?(ak_data['transfer_server_id'])}
+            raise CliError,'no such server found' if server_data.nil?
+            base_url = server_data['transfer_setup_url']
+            api_node = Rest.new({
+              base_url: base_url,
+              auth:     {
+                type:     :basic,
+                username: access_key_id,
+                password: @agents[:config].get_secret(url: base_url,username: access_key_id)
               }})
-            command=self.options.get_next_command(Node::COMMON_ACTIONS)
+            command = options.get_next_command(Node::COMMON_ACTIONS)
             return Node.new(@agents.merge(skip_basic_auth_options: true, node_api: api_node)).execute_action(command)
           when :cluster
-            base_url=ats_api_pub_v1.params[:base_url]
-            rest_params={
-              :base_url => base_url,
-              :auth     => {
-              :type     => :basic,
-              :username => access_key_id,
-              :password => @agents[:config].get_secret(url: base_url, username: access_key_id)
+            base_url = ats_api_pub_v1.params[:base_url]
+            rest_params = {
+              base_url: base_url,
+              auth:     {
+                type:     :basic,
+                username: access_key_id,
+                password: @agents[:config].get_secret(url: base_url, username: access_key_id)
               }}
-            api_ak_auth=Rest.new(rest_params)
-            return {:type=>:single_object, :data=>api_ak_auth.read("servers")[:data]}
-          else raise "INTERNAL ERROR"
+            api_ak_auth = Rest.new(rest_params)
+            return {type: :single_object, data: api_ak_auth.read('servers')[:data]}
+          else raise 'INTERNAL ERROR'
           end
         end
 
         def execute_action_cluster_pub
-          command=self.options.get_next_command([ :clouds, :list, :show])
+          command = options.get_next_command(%i[clouds list show])
           case command
           when :clouds
-            return {:type=>:single_object, :data=>@ats_api_pub.cloud_names, :columns=>['id','name']}
+            return {type: :single_object, data: @ats_api_pub.cloud_names, columns: %w[id name]}
           when :list
-            return {:type=>:object_list, :data=>@ats_api_pub.all_servers, :fields=>['id','cloud','region']}
+            return {type: :object_list, data: @ats_api_pub.all_servers, fields: %w[id cloud region]}
           when :show
-            if self.options.get_option(:cloud,:optional) or self.options.get_option(:region,:optional)
-              server_data=server_by_cloud_region
+            if options.get_option(:cloud) || options.get_option(:region,is_type: :optional)
+              server_data = server_by_cloud_region
             else
-              server_id=instance_identifier()
-              server_data=@ats_api_pub.all_servers.select {|i| i['id'].eql?(server_id)}.first
-              raise "no such server id" if server_data.nil?
+              server_id = instance_identifier
+              server_data = @ats_api_pub.all_servers.find {|i| i['id'].eql?(server_id)}
+              raise 'no such server id' if server_data.nil?
             end
-            return {:type=>:single_object, :data=>server_data}
+            return {type: :single_object, data: server_data}
           end
         end
 
         def ats_api_v2_auth_ibm(rest_add_headers={})
           return Rest.new({
-            :base_url => AtsApi.base_url+'/v2',
-            :headers  => rest_add_headers,
-            :auth     => {
-            :type       => :oauth2,
-            :base_url   => 'https://iam.bluemix.net/identity',
-            #does not work:  :base_url   => 'https://iam.cloud.ibm.com/identity',
-            :grant      => :ibm_apikey,
-            :api_key    => self.options.get_option(:ibm_api_key,:mandatory)
-            }
-          })
+            base_url: AtsApi.base_url + '/v2',
+            headers:  rest_add_headers,
+            auth:     {
+              type:     :oauth2,
+              base_url: 'https://iam.bluemix.net/identity',
+              #does not work:  base_url:    'https://iam.cloud.ibm.com/identity',
+              crtype:   :generic,
+              generic:  {
+                grant_type:    'urn:ibm:params:oauth:grant-type:apikey',
+                response_type: 'cloud_iam',
+                apikey:        options.get_option(:ibm_api_key,is_type: :mandatory)
+              }}})
         end
 
         def execute_action_api_key
-          command=self.options.get_next_command([:instances, :create, :list, :show, :delete])
-          if [:show,:delete].include?(command)
-            concerned_id=self.instance_identifier()
+          command = options.get_next_command(%i[instances create list show delete])
+          if %i[show delete].include?(command)
+            concerned_id = instance_identifier
           end
-          rest_add_header={}
+          rest_add_header = {}
           if !command.eql?(:instances)
-            instance=self.options.get_option(:instance,:optional)
+            instance = options.get_option(:instance)
             #Log.log.error("1>>#{instance}".red)
             if instance.nil?
               # Take the first Aspera on Cloud transfer service instance ID if not provided by user
-              instance=ats_api_v2_auth_ibm.read('instances')[:data]['data'].first
+              instance = ats_api_v2_auth_ibm.read('instances')[:data]['data'].first
               self.format.display_status("using first instance: #{instance}")
             end
             #Log.log.error("2>>#{instance}".red)
-            rest_add_header={'X-ATS-Service-Instance-Id'=>instance}
+            rest_add_header = {'X-ATS-Service-Instance-Id' => instance}
           end
-          ats_ibm_api=ats_api_v2_auth_ibm(rest_add_header)
+          ats_ibm_api = ats_api_v2_auth_ibm(rest_add_header)
           case command
           when :instances
-            instances=ats_ibm_api.read('instances')[:data]
+            instances = ats_ibm_api.read('instances')[:data]
             Log.log.warn("more instances remaining: #{instances['remaining']}") unless instances['remaining'].to_i.eql?(0)
-            return {:type=>:value_list, :data=>instances['data'], :name=>'instance'}
+            return {type: :value_list, data: instances['data'], name: 'instance'}
           when :create
-            create_value=self.options.get_option(:value,:optional)||{}
-            created_key=ats_ibm_api.create('api_keys',create_value)[:data]
-            return {:type=>:single_object, :data=>created_key}
+            create_value = options.get_option(:value) || {}
+            created_key = ats_ibm_api.create('api_keys',create_value)[:data]
+            return {type: :single_object, data: created_key}
           when :list # list known api keys in ATS (this require an api_key ...)
-            res=ats_ibm_api.read('api_keys',{'offset'=>0,'max_results'=>1000})
-            return {:type=>:value_list, :data=>res[:data]['data'], :name => 'ats_id'}
+            res = ats_ibm_api.read('api_keys',{'offset' => 0,'max_results' => 1000})
+            return {type: :value_list, data: res[:data]['data'], name: 'ats_id'}
           when :show # show one of api_key in ATS
-            res=ats_ibm_api.read("api_keys/#{concerned_id}")
-            return {:type=>:single_object, :data=>res[:data]}
-          when :delete #
-            res=ats_ibm_api.delete("api_keys/#{concerned_id}")
+            res = ats_ibm_api.read("api_keys/#{concerned_id}")
+            return {type: :single_object, data: res[:data]}
+          when :delete
+            ats_ibm_api.delete("api_keys/#{concerned_id}")
             return Main.result_status("deleted #{concerned_id}")
-          else raise "INTERNAL ERROR"
+          else raise 'INTERNAL ERROR'
           end
         end
 
-        ACTIONS=[ :cluster, :access_key ,:api_key, :aws_trust_policy]
+        ACTIONS = %i[cluster access_key api_key aws_trust_policy].freeze
 
         # called for legacy and AoC
         def execute_action_gen(ats_api_arg)
-          actions=ACTIONS
+          actions = ACTIONS.dup
           actions.delete(:api_key) unless ats_api_arg.nil?
-          command=self.options.get_next_command(actions)
-          @ats_api_pub_v1_cache=ats_api_arg
+          command = options.get_next_command(actions)
+          @ats_api_pub_v1_cache = ats_api_arg
           # keep as member variable as we may want to use the api in AoC name space
           @ats_api_pub = AtsApi.new
           case command
@@ -216,9 +223,9 @@ module Aspera
           when :api_key # manage credential to access ATS API
             return execute_action_api_key
           when :aws_trust_policy
-            res=ats_api_pub_v1.read('aws/trustpolicy',{:region=>self.options.get_option(:region,:mandatory)})[:data]
-            return {:type=>:single_object, :data=>res}
-          else raise "ERROR"
+            res = ats_api_pub_v1.read('aws/trustpolicy',{region: options.get_option(:region,is_type: :mandatory)})[:data]
+            return {type: :single_object, data: res}
+          else raise 'ERROR'
           end
         end
 

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

@@ -1,21 +1,20 @@
+# frozen_string_literal: true
+
 require 'aspera/rest'
 
 module Aspera
   module Cli
     module Plugins
       class Bss < BasicAuthPlugin
+        ACTIONS = %i[subscription].freeze
 
-        ACTIONS=[ :subscription ]
-
-        FIELDS={
-          'bssSubscriptions' => %w{id name termVolumeGb termMonths trial startDate endDate plan renewalType chargeAgreementNumber customerName}
-        }
+        FIELDS = {
+          'bssSubscriptions' => %w[id name termVolumeGb termMonths trial startDate endDate plan renewalType chargeAgreementNumber customerName]
+        }.freeze
 
         def initialize(env)
           super(env)
-          if env.has_key?(:bss_api)
-            @api_bss=env[:bss_api]
-          end
+          @api_bss = env[:bss_api] if env.has_key?(:bss_api)
         end
 
         def all_fields(name)
@@ -24,44 +23,46 @@ module Aspera
 
         def execute_action
           if @api_bss.nil?
-            key = self.options.get_option(:password,:mandatory)
-            @api_bss=Rest.new(
-            base_url: 'https://dashboard.bss.asperasoft.com/platform',
-            headers: {cookie: "_dashboard_key=#{key}"})
+            key = options.get_option(:password,is_type: :mandatory)
+            @api_bss = Rest.new(
+              base_url: 'https://dashboard.bss.asperasoft.com/platform',
+              headers: {cookie: "_dashboard_key=#{key}"})
           end
-          command=self.options.get_next_command(ACTIONS)
+          command = options.get_next_command(ACTIONS)
           case command
           when :subscription
-            command=self.options.get_next_command([:find,:show, :instances])
-            object='bssSubscriptions'
+            command = options.get_next_command(%i[find show instances])
+            object = 'bssSubscriptions'
             case command
             when :find
-              query = self.options.get_option(:query,:mandatory) # AOC_ORGANIZATION_QUERY AOC_USER_EMAIL
-              value = self.options.get_option(:value,:mandatory)
-              request={
-                'variables'=>{'filter'=>{'key'=>query,'value'=>value}},
-                'query'=>"query($filter: BssSubscriptionFilter!) {#{object}(filter: $filter) { #{all_fields('bssSubscriptions')} } }"
+              query = options.get_option(:query,is_type: :mandatory) # AOC_ORGANIZATION_QUERY AOC_USER_EMAIL
+              value = options.get_option(:value,is_type: :mandatory)
+              request = {
+                'variables' => {'filter' => {'key' => query,'value' => value}},
+                'query'     => "query($filter: BssSubscriptionFilter!) {#{object}(filter: $filter) { #{all_fields('bssSubscriptions')} } }"
               }
-              result=@api_bss.create('graphql',request)[:data]
+              result = @api_bss.create('graphql',request)[:data]
               # give fields to keep order
-              return {:type=>:object_list, :data=>result['data'][object],:fields=> FIELDS['bssSubscriptions']}
+              return {type: :object_list, data: result['data'][object],fields: FIELDS['bssSubscriptions']}
             when :show
-              id = self.instance_identifier()
-              request={
-                'variables'=>{'id'=>id},
-                'query'=>"query($id: ID!) {#{object}(id: $id) { #{all_fields('bssSubscriptions')} roleAssignments(uniqueSubjectId: true) { id subjectId } instances { id state planId serviceId ssmSubscriptionId entitlement { id } aocOrganization { id subdomainName name status tier urlId trialExpiresAt users(organizationAdmin: true) { id name email atsAdmin subscriptionAdmin } } } } }"
+              id = instance_identifier
+              request = {
+                'variables' => {'id' => id},
+                'query'     => "query($id: ID!) {#{object}(id: $id) { #{all_fields('bssSubscriptions')} roleAssignments(uniqueSubjectId: true) { id subjectId } "\
+                  'instances { id state planId serviceId ssmSubscriptionId entitlement { id } aocOrganization { id subdomainName name status tier urlId trialExpiresAt '\
+                  'users(organizationAdmin: true) { id name email atsAdmin subscriptionAdmin } } } } }'
               }
-              result=@api_bss.create('graphql',request)[:data]['data'][object].first
+              result = @api_bss.create('graphql',request)[:data]['data'][object].first
               result.delete('instances')
-              return {:type=>:single_object, :data=>result}
+              return {type: :single_object, data: result}
             when :instances
-              id = self.instance_identifier()
-              request={
-                'variables'=>{'id'=>id},
-                'query'=>"query($id: ID!) {#{object}(id: $id) { aocOrganization { id subdomainName name status tier urlId trialExpiresAt } } } }"
+              id = instance_identifier
+              request = {
+                'variables' => {'id' => id},
+                'query'     => "query($id: ID!) {#{object}(id: $id) { aocOrganization { id subdomainName name status tier urlId trialExpiresAt } } } }"
               }
-              result=@api_bss.create('graphql',request)[:data]['data'][object].first
-              return {:type=>:object_list, :data=>result['instances']}
+              result = @api_bss.create('graphql',request)[:data]['data'][object].first
+              return {type: :object_list, data: result['instances']}
             end
           end
         end