aspera-cli 4.5.0 → 4.8.0

data/lib/aspera/cos_node.rb

@@ -1,56 +1,90 @@
+# frozen_string_literal: true
+
 require 'aspera/log'
 require 'aspera/rest'
 require 'xmlsimple'
 
 module Aspera
   class CosNode < Rest
+    class << self
+      def parameters_from_svc_creds(service_credentials,bucket_region)
+        # check necessary contents
+        raise 'service_credentials must be a Hash' unless service_credentials.is_a?(Hash)
+        %w[apikey resource_instance_id endpoints].each do |field|
+          raise "service_credentials must have a field: #{field}" unless service_credentials.has_key?(field)
+        end
+        Aspera::Log.dump('service_credentials',service_credentials)
+        # 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?
+        return {
+          instance_id:      service_credentials['resource_instance_id'],
+          service_api_key:  service_credentials['apikey'],
+          storage_endpoint: "https://#{storage_endpoint}"
+        }
+      end
+    end
+    IBM_CLOUD_TOKEN_URL = 'https://iam.cloud.ibm.com/identity'
+    TOKEN_FIELD = 'delegated_refresh_token'
     attr_reader :add_ts
-    IBM_CLOUD_TOKEN_URL='https://iam.cloud.ibm.com/identity'
-    TOKEN_FIELD='delegated_refresh_token'
     def initialize(bucket_name,storage_endpoint,instance_id,api_key,auth_url=IBM_CLOUD_TOKEN_URL)
-      @auth_url=auth_url
-      @api_key=api_key
-      s3_api=Aspera::Rest.new({
-        :base_url       => storage_endpoint,
-        :not_auth_codes => ['401','403'], # error codes when not authorized
-        :headers        => {'ibm-service-instance-id' => instance_id},
-        :auth           => {
-        :type      => :oauth2,
-        :base_url  => @auth_url,
-        :grant     => :ibm_apikey,
-        :api_key   => @api_key
-        }})
+      @auth_url = auth_url
+      @api_key = api_key
+      s3_api = Aspera::Rest.new({
+        base_url:       storage_endpoint,
+        not_auth_codes: %w[401 403], # error codes when not authorized
+        headers:        {'ibm-service-instance-id' => instance_id},
+        auth:           {
+          type:     :oauth2,
+          base_url: @auth_url,
+          crtype:   :generic,
+          generic:  {
+            grant_type:    'urn:ibm:params:oauth:grant-type:apikey',
+            response_type: 'cloud_iam',
+            apikey:        @api_key
+          }}})
       # read FASP connection information for bucket
-      xml_result_text=s3_api.call({:operation=>'GET',:subpath=>bucket_name,:headers=>{'Accept'=>'application/xml'},:url_params=>{'faspConnectionInfo'=>nil}})[:http].body
-      ats_info=XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
+      xml_result_text = s3_api.call(
+        operation: 'GET',
+        subpath: bucket_name,
+        headers: {'Accept' => 'application/xml'},
+        url_params: {'faspConnectionInfo' => nil}
+      )[:http].body
+      ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
       Aspera::Log.dump('ats_info',ats_info)
       super({
-        :base_url => ats_info['ATSEndpoint'],
-        :auth     => {
-        :type     => :basic,
-        :username => ats_info['AccessKey']['Id'],
-        :password => ats_info['AccessKey']['Secret']}})
+        base_url: ats_info['ATSEndpoint'],
+        auth:     {
+          type:     :basic,
+          username: ats_info['AccessKey']['Id'],
+          password: ats_info['AccessKey']['Secret']}})
       # prepare transfer spec addition
-      @add_ts={'tags'=>{'aspera'=>{'node'=>{'storage_credentials'=>{
+      @add_ts = {'tags' => {'aspera' => {'node' => {'storage_credentials' => {
         'type'  => 'token',
-        'token' => {TOKEN_FIELD=>nil}
-        }}}}}
+        'token' => {TOKEN_FIELD => nil}
+      }}}}}
       generate_token
     end
 
     # potentially call this if delegated token is expired
     def generate_token
       # OAuth API to get delegated token
-      delegated_oauth=Oauth.new({
-        :type       => :oauth2,
-        :base_url   => @auth_url,
-        :grant      => :delegated_refresh,
-        :api_key    => @api_key,
-        :token_field=> TOKEN_FIELD
-      })
-      # get delagated token to be placed in rest call header and in transfer tags
-      @add_ts['tags']['aspera']['node']['storage_credentials']['token'][TOKEN_FIELD]=delegated_oauth.get_authorization().gsub(/^Bearer /,'')
-      @params[:headers]={'X-Aspera-Storage-Credentials'=>JSON.generate(@add_ts['tags']['aspera']['node']['storage_credentials'])}
+      delegated_oauth = Oauth.new({
+        type:        :oauth2,
+        base_url:    @auth_url,
+        token_field: TOKEN_FIELD,
+        crtype:      :generic,
+        generic:     {
+          grant_type:          'urn:ibm:params:oauth:grant-type:apikey',
+          response_type:       'delegated_refresh_token',
+          apikey:              @api_key,
+          receiver_client_ids: 'aspera_ats'
+        }})
+      # get delegated token to be placed in rest call header and in transfer tags
+      @add_ts['tags']['aspera']['node']['storage_credentials']['token'][TOKEN_FIELD] = delegated_oauth.get_authorization.gsub(/^Bearer /,'')
+      @params[:headers] = {'X-Aspera-Storage-Credentials' => JSON.generate(@add_ts['tags']['aspera']['node']['storage_credentials'])}
     end
   end
 end

data/lib/aspera/data_repository.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/log'
 require 'singleton'
 
@@ -6,8 +8,8 @@ module Aspera
   class DataRepository
     include Singleton
     # get binary value from data repository
-    def get_bin(id)
-      File.read(File.join(File.expand_path(File.dirname(__FILE__)),'data',id.to_s),mode: 'rb')
+    def data(id)
+      File.read(File.join(__dir__,'data',id.to_s),mode: 'rb')
     end
   end
 end

data/lib/aspera/environment.rb

@@ -1,65 +1,80 @@
+# frozen_string_literal: true
+
 require 'aspera/log'
 require 'rbconfig'
 
 module Aspera
-  # detect OS, architecture, and OS specific stuff
+  # detect OS, architecture, and specific stuff
   class Environment
     OS_WINDOWS = :windows
     OS_X = :osx
     OS_LINUX = :linux
     OS_AIX = :aix
-    OS_LIST=[OS_WINDOWS,OS_X,OS_LINUX,OS_AIX]
+    OS_LIST = [OS_WINDOWS,OS_X,OS_LINUX,OS_AIX].freeze
+    CPU_X86_64 = :x86_64
+    CPU_PPC64 = :ppc64
+    CPU_PPC64LE = :ppc64le
+    CPU_S390 = :s390
+    CPU_LIST = [CPU_X86_64,CPU_PPC64,CPU_PPC64LE,CPU_S390].freeze
 
-    def self.os
-      case RbConfig::CONFIG['host_os']
-      when /mswin/,/msys/,/mingw/,/cygwin/,/bccwin/,/wince/,/emc/
-        return OS_WINDOWS
-      when /darwin/,/mac os/
-        return OS_X
-      when /linux/
-        return OS_LINUX
-      when /aix/
-        return OS_AIX
-      else
-        raise "Unknown OS: #{RbConfig::CONFIG['host_os']}"
+    class << self
+      def ruby_version
+        return RbConfig::CONFIG['RUBY_PROGRAM_VERSION']
       end
-    end
-    CPU_X86_64=:x86_64
-    CPU_PPC64=:ppc64
-    CPU_PPC64LE=:ppc64le
-    CPU_S390=:s390
-    CPU_LIST=[CPU_X86_64,CPU_PPC64,CPU_PPC64LE,CPU_S390]
 
-    def self.cpu
-      case RbConfig::CONFIG['host_cpu']
-      when /x86_64/,/x64/
-        return CPU_X86_64
-      when /powerpc/
-        return CPU_PPC64LE if os.eql?(OS_LINUX)
-        return CPU_PPC64
-      when /s390/
-        return CPU_S390
-      else # other
-        raise "Unknown CPU: #{RbConfig::CONFIG['host_cpu']}"
+      def os
+        case RbConfig::CONFIG['host_os']
+        when /mswin/,/msys/,/mingw/,/cygwin/,/bccwin/,/wince/,/emc/
+          return OS_WINDOWS
+        when /darwin/,/mac os/
+          return OS_X
+        when /linux/
+          return OS_LINUX
+        when /aix/
+          return OS_AIX
+        else
+          raise "Unknown OS: #{RbConfig::CONFIG['host_os']}"
+        end
       end
-    end
 
-    def self.architecture
-      return "#{os}-#{cpu}"
-    end
+      def cpu
+        case RbConfig::CONFIG['host_cpu']
+        when /x86_64/,/x64/
+          return CPU_X86_64
+        when /powerpc/,/ppc64/
+          return CPU_PPC64LE if os.eql?(OS_LINUX)
+          return CPU_PPC64
+        when /s390/
+          return CPU_S390
+        else # other
+          raise "Unknown CPU: #{RbConfig::CONFIG['host_cpu']}"
+        end
+      end
 
-    def self.exe_extension
-      return '.exe' if os.eql?(OS_WINDOWS)
-      return ''
-    end
+      def architecture
+        return "#{os}-#{cpu}"
+      end
 
-    # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
-    def self.fix_home
-      if os.eql?(OS_WINDOWS)
-        if ENV.has_key?('USERPROFILE') and Dir.exist?(ENV['USERPROFILE'])
-          ENV['HOME']=ENV['USERPROFILE']
-          Log.log.debug("Windows: set home to USERPROFILE: #{ENV['HOME']}")
-        end
+      def exe_extension
+        return '.exe' if os.eql?(OS_WINDOWS)
+        return ''
+      end
+
+      # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
+      # so, tell Ruby the right way
+      def fix_home
+        return unless os.eql?(OS_WINDOWS) && ENV.has_key?('USERPROFILE') && Dir.exist?(ENV['USERPROFILE'])
+        ENV['HOME'] = ENV['USERPROFILE']
+        Log.log.debug("Windows: set home to USERPROFILE: #{ENV['HOME']}")
+      end
+
+      def empty_binding
+        return Kernel.binding
+      end
+
+      # secure execution of Ruby code
+      def secure_eval(code)
+        Kernel.send('lave'.reverse,code,empty_binding, __FILE__, __LINE__)
       end
     end
   end

data/lib/aspera/fasp/agent_base.rb

@@ -1,69 +1,75 @@
+# frozen_string_literal: true
+
 module Aspera
   module Fasp
     # Base class for FASP transfer agents
     # sub classes shall implement start_transfer and shutdown
     class AgentBase
+      # fields description for JSON generation
+      INTEGER_FIELDS = %w[Bytescont FaspFileArgIndex StartByte Rate MinRate Port Priority RateCap MinRateCap TCPPort CreatePolicy TimePolicy
+                          DatagramSize XoptFlags VLinkVersion PeerVLinkVersion DSPipelineDepth PeerDSPipelineDepth ReadBlockSize WriteBlockSize
+                          ClusterNumNodes ClusterNodeId Size Written Loss FileBytes PreTransferBytes TransferBytes PMTU Elapsedusec ArgScansAttempted
+                          ArgScansCompleted PathScansAttempted FileScansCompleted TransfersAttempted TransfersPassed Delay].freeze
+      BOOLEAN_FIELDS = %w[Encryption Remote RateLock MinRateLock PolicyLock FilesEncrypt FilesDecrypt VLinkLocalEnabled VLinkRemoteEnabled
+                          MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
+      EXPECTED_METHODS = %i[text struct enhanced].freeze
+      private_constant :INTEGER_FIELDS,:BOOLEAN_FIELDS,:EXPECTED_METHODS
 
       private
 
-      # fields description for JSON generation
-      IntegerFields=['Bytescont','FaspFileArgIndex','StartByte','Rate','MinRate','Port','Priority','RateCap','MinRateCap','TCPPort','CreatePolicy','TimePolicy','DatagramSize','XoptFlags','VLinkVersion','PeerVLinkVersion','DSPipelineDepth','PeerDSPipelineDepth','ReadBlockSize','WriteBlockSize','ClusterNumNodes','ClusterNodeId','Size','Written','Loss','FileBytes','PreTransferBytes','TransferBytes','PMTU','Elapsedusec','ArgScansAttempted','ArgScansCompleted','PathScansAttempted','FileScansCompleted','TransfersAttempted','TransfersPassed','Delay']
-      BooleanFields=['Encryption','Remote','RateLock','MinRateLock','PolicyLock','FilesEncrypt','FilesDecrypt','VLinkLocalEnabled','VLinkRemoteEnabled','MoveRange','Keepalive','TestLogin','UseProxy','Precalc','RTTAutocorrect']
-      ExpectedMethod=[:text,:struct,:enhanced]
-
       # translates legacy event into enhanced (JSON) event
       def enhanced_event_format(event)
-        return event.keys.inject({}) do |h,e|
+        return event.keys.each_with_object({}) do |e,h|
           # capital_to_snake_case
-          new_name=e.
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          gsub(/([a-z\d])(usec)$/,'\1_\2').
-          downcase
-          value=event[e]
-          value=value.to_i if IntegerFields.include?(e)
-          value=value.eql?('Yes') ? true : false if BooleanFields.include?(e)
-          h[new_name]=value
-          h
+          new_name = e.
+              gsub(/([a-z\d])([A-Z])/,'\1_\2').
+              gsub(/([a-z\d])(usec)$/,'\1_\2').
+              gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+              downcase
+          value = event[e]
+          value = value.to_i if INTEGER_FIELDS.include?(e)
+          value = value.eql?('Yes') if BOOLEAN_FIELDS.include?(e)
+          h[new_name] = value
         end
       end
 
       def initialize
-        @listeners=[]
+        @listeners = []
       end
 
       def notify_listeners(current_event_text,current_event_data)
-        Log.log.debug("send event to listeners")
-        enhanced_event=nil
+        Log.log.debug('send event to listeners')
+        enhanced_event = nil
         @listeners.each do |listener|
-          listener.send(:event_text,current_event_text) if listener.respond_to?(:event_text)
-          listener.send(:event_struct,current_event_data) if listener.respond_to?(:event_struct)
+          listener.event_text(current_event_text) if listener.respond_to?(:event_text)
+          listener.event_struct(current_event_data) if listener.respond_to?(:event_struct)
           if listener.respond_to?(:event_enhanced)
-            enhanced_event=enhanced_event_format(current_event_data) if enhanced_event.nil?
-            listener.send(:event_enhanced,enhanced_event)
+            enhanced_event = enhanced_event_format(current_event_data) if enhanced_event.nil?
+            listener.event_enhanced(enhanced_event)
           end
         end
       end # notify_listeners
 
       def notify_begin(id,size)
-        notify_listeners('emulated',{LISTENER_SESSION_ID_B=>id,'Type'=>'NOTIFICATION','PreTransferBytes'=>size})
+        notify_listeners('emulated',{LISTENER_SESSION_ID_B => id,'Type' => 'NOTIFICATION','PreTransferBytes' => size})
       end
 
       def notify_progress(id,size)
-        notify_listeners('emulated',{LISTENER_SESSION_ID_B=>id,'Type'=>'STATS','Bytescont'=>size})
+        notify_listeners('emulated',{LISTENER_SESSION_ID_B => id,'Type' => 'STATS','Bytescont' => size})
       end
 
       def notify_end(id)
-        notify_listeners('emulated',{LISTENER_SESSION_ID_B=>id,'Type'=>'DONE'})
+        notify_listeners('emulated',{LISTENER_SESSION_ID_B => id,'Type' => 'DONE'})
       end
 
       public
-      LISTENER_SESSION_ID_B='ListenerSessionId'
-      LISTENER_SESSION_ID_S='listener_session_id'
+
+      LISTENER_SESSION_ID_B = 'ListenerSessionId'
+      LISTENER_SESSION_ID_S = 'listener_session_id'
 
       # listener receives events
       def add_listener(listener)
-        raise "expect one of #{ExpectedMethod}" if ExpectedMethod.inject(0){|m,e|m+=listener.respond_to?("event_#{e}")?1:0;m}.eql?(0)
+        raise "expect one of #{EXPECTED_METHODS}" if EXPECTED_METHODS.inject(0){|m,e|m += listener.respond_to?("event_#{e}") ? 1 : 0;m}.eql?(0)
         @listeners.push(listener)
         self
       end
@@ -72,14 +78,13 @@ module Aspera
       # it must be a list of :success or exception
       def self.validate_status_list(statuses)
         raise "internal error: bad statuses type: #{statuses.class}" unless statuses.is_a?(Array)
-        raise "internal error: bad statuses content: #{statuses}" unless statuses.select{|i|!i.eql?(:success) and !i.is_a?(StandardError)}.empty?
+        raise "internal error: bad statuses content: #{statuses}" unless statuses.select{|i|!i.eql?(:success) && !i.is_a?(StandardError)}.empty?
       end
 
       # the following methods must be implemented by subclass:
       # start_transfer(transfer_spec,options) : start and wait for completion
       # wait_for_transfers_completion : wait for termination of all transfers, @return list of : :success or error message
       # optional: shutdown
-
     end
   end
 end

data/lib/aspera/fasp/agent_connect.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/fasp/agent_base'
 require 'aspera/rest'
 require 'aspera/open_application'
@@ -7,26 +9,26 @@ require 'tty-spinner'
 module Aspera
   module Fasp
     class AgentConnect < AgentBase
-      MAX_CONNECT_START_RETRY=3
-      SLEEP_SEC_BETWEEN_RETRY=2
+      MAX_CONNECT_START_RETRY = 3
+      SLEEP_SEC_BETWEEN_RETRY = 2
       private_constant :MAX_CONNECT_START_RETRY,:SLEEP_SEC_BETWEEN_RETRY
-      def initialize(options)
+      def initialize(_options)
         super()
-        @connect_settings={
+        @connect_settings = {
           'app_id' => SecureRandom.uuid
         }
         raise 'Using connect requires a graphical environment' if !OpenApplication.default_gui_mode.eql?(:graphical)
-        trynumber=0
+        trynumber = 0
         begin
-          connect_url=Installation.instance.connect_uri
+          connect_url = Installation.instance.connect_uri
           Log.log.debug("found: #{connect_url}")
-          @connect_api=Rest.new({base_url: "#{connect_url}/v5/connect",headers: {'Origin'=>Rest.user_agent}}) # could use v6 also now
-          cinfo=@connect_api.read('info/version')[:data]
+          @connect_api = Rest.new({base_url: "#{connect_url}/v5/connect",headers: {'Origin' => Rest.user_agent}}) # could use v6 also now
+          cinfo = @connect_api.read('info/version')[:data]
           Log.dump(:connect_version,cinfo)
-        rescue => e # Errno::ECONNREFUSED
+        rescue StandardError => e # Errno::ECONNREFUSED
           raise StandardError,"Unable to start connect after #{trynumber} try" if trynumber >= MAX_CONNECT_START_RETRY
           Log.log.warn("connect is not started. Retry ##{trynumber}, err=#{e}")
-          trynumber+=1
+          trynumber += 1
           if !OpenApplication.uri_graphical('fasp://initialize')
             OpenApplication.uri_graphical('https://downloads.asperasoft.com/connect2/')
             raise StandardError,'Connect is not installed'
@@ -36,41 +38,46 @@ module Aspera
         end
       end
 
-      def start_transfer(transfer_spec,options=nil)
+      def start_transfer(transfer_spec,_options=nil)
         if transfer_spec['direction'] == 'send'
           Log.log.warn("Connect requires upload selection using GUI, ignoring #{transfer_spec['paths']}".red)
           transfer_spec.delete('paths')
-          resdata=@connect_api.create('windows/select-open-file-dialog/',{'aspera_connect_settings'=>@connect_settings,'title'=>'Select Files','suggestedName'=>'','allowMultipleSelection'=>true,'allowedFileTypes'=>''})[:data]
-          transfer_spec['paths']=resdata['dataTransfer']['files'].map { |i| {'source'=>i['name']}}
+          resdata = @connect_api.create('windows/select-open-file-dialog/',{
+            'aspera_connect_settings' => @connect_settings,
+            'title'                   => 'Select Files',
+            'suggestedName'           => '',
+            'allowMultipleSelection'  => true,
+            'allowedFileTypes'        => ''})[:data]
+          transfer_spec['paths'] = resdata['dataTransfer']['files'].map { |i| {'source' => i['name']}}
         end
-        @request_id=SecureRandom.uuid
+        @request_id = SecureRandom.uuid
         # if there is a token, we ask connect client to use well known ssh private keys
         # instead of asking password
-        transfer_spec['authentication']='token' if transfer_spec.has_key?('token')
-        connect_transfer_args={
-          'aspera_connect_settings'=>@connect_settings.merge({
-          'request_id'               =>@request_id,
-          'allow_dialogs'            =>true,
+        transfer_spec['authentication'] = 'token' if transfer_spec.has_key?('token')
+        connect_transfer_args = {
+          'aspera_connect_settings' => @connect_settings.merge({
+            'request_id'    => @request_id,
+            'allow_dialogs' => true
           }),
-          'transfer_specs'         =>[{
-          'transfer_spec'            =>transfer_spec,
+          'transfer_specs'          => [{
+            'transfer_spec' => transfer_spec
           }]}
         # asynchronous anyway
-        res=@connect_api.create('transfers/start',connect_transfer_args)[:data]
-        @xfer_id=res['transfer_specs'].first['transfer_spec']['tags']['aspera']['xfer_id']
+        res = @connect_api.create('transfers/start',connect_transfer_args)[:data]
+        @xfer_id = res['transfer_specs'].first['transfer_spec']['tags']['aspera']['xfer_id']
       end
 
       def wait_for_transfers_completion
-        connect_activity_args={'aspera_connect_settings'=>@connect_settings}
-        started=false
-        spinner=nil
+        connect_activity_args = {'aspera_connect_settings' => @connect_settings}
+        started = false
+        spinner = nil
         begin
           loop do
-            tr_info=@connect_api.create("transfers/info/#{@xfer_id}",connect_activity_args)[:data]
+            tr_info = @connect_api.create("transfers/info/#{@xfer_id}",connect_activity_args)[:data]
             if tr_info['transfer_info'].is_a?(Hash)
-              trdata=tr_info['transfer_info']
+              trdata = tr_info['transfer_info']
               if trdata.nil?
-                Log.log.warn("no session in Connect")
+                Log.log.warn('no session in Connect')
                 break
               end
               # TODO: get session id
@@ -87,23 +94,23 @@ module Aspera
                 spinner.spin
               when 'running'
                 #puts "running: sessions:#{trdata['sessions'].length}, #{trdata['sessions'].map{|i| i['bytes_transferred']}.join(',')}"
-                if !started and trdata['bytes_expected'] != 0
-                  spinner.success unless spinner.nil?
+                if !started && (trdata['bytes_expected'] != 0)
+                  spinner&.success
                   notify_begin(@connect_settings['app_id'],trdata['bytes_expected'])
-                  started=true
+                  started = true
                 else
                   notify_progress(@connect_settings['app_id'],trdata['bytes_written'])
                 end
               when 'failed'
-                spinner.error unless spinner.nil?
-                raise Fasp::Error.new(trdata['error_desc'])
+                spinner&.error
+                raise Fasp::Error, trdata['error_desc']
               else
-                raise Fasp::Error.new("unknown status: #{trdata['status']}: #{trdata['error_desc']}")
+                raise Fasp::Error, "unknown status: #{trdata['status']}: #{trdata['error_desc']}"
               end
             end
-            sleep 1
+            sleep(1)
           end
-        rescue => e
+        rescue StandardError => e
           return [e]
         end
         return [:success]