aspera-cli 4.6.0 → 4.7.0

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/ascmd'
-require 'aspera/fasp/default'
+require 'aspera/fasp/transfer_spec'
 require 'aspera/ssh'
 require 'aspera/nagios'
 require 'tempfile'
@@ -11,23 +12,23 @@ module Aspera
       # implement basic remote access with FASP/SSH
       class Server < BasicAuthPlugin
         class LocalExecutor
-          def execute(cmd,input=nil)
-            `#{cmd}`
+          def execute(cmd,_input=nil)
+            %x(#{cmd})
           end
         end
 
         def initialize(env)
           super(env)
-          self.options.add_opt_simple(:ssh_keys,'ssh key path list (Array or single)')
-          self.options.add_opt_simple(:ssh_options,'ssh options (Hash)')
-          self.options.add_opt_simple(:cmd_prefix,'prefix to add for as cmd execution, e.g. sudo or /opt/aspera/bin ')
-          self.options.set_option(:ssh_keys,[])
-          self.options.set_option(:ssh_options,{})
-          self.options.parse_options!
+          options.add_opt_simple(:ssh_keys,'ssh key path list (Array or single)')
+          options.add_opt_simple(:ssh_options,'ssh options (Hash)')
+          options.add_opt_simple(:cmd_prefix,'prefix to add for as cmd execution, e.g. sudo or /opt/aspera/bin ')
+          options.set_option(:ssh_keys,[])
+          options.set_option(:ssh_options,{})
+          options.parse_options!
         end
 
         def key_symb_to_str_single(source)
-          return source.inject({}){|memo,(k,v)| memo[k.to_s] = v; memo}
+          return source.each_with_object({}){|(k,v),memo| memo[k.to_s] = v; }
         end
 
         def key_symb_to_str_list(source)
@@ -35,64 +36,76 @@ module Aspera
         end
 
         def asctl_parse(text)
+          # normal separator
           r=/:\s*/
-          return text.split("\n").map do |line|
-            # console
+          result=[]
+          text.split("\n").each do |line|
+            # console: missing space
             line.gsub!(/(SessionDataCollector)/,'\1 ')
             # orchestrator
             line.gsub!(/ with pid:.*/,'')
             line.gsub!(/ is /,': ')
-            x=line.split(r)
-            next unless x.length.eql?(2)
-            y={'process'=>x.first,'state'=>x.last}
+            items=line.split(r)
+            next unless items.length.eql?(2)
+            state={'process'=>items.first,'state'=>items.last}
             # console
-            y['state'].gsub!(/\.+$/,'')
+            state['state'].gsub!(/\.+$/,'')
             # console
-            y['process'].gsub!(/^.+::/,'')
+            state['process'].gsub!(/^.+::/,'')
             # faspex
-            y['process'].gsub!(/^Faspex /,'')
+            state['process'].gsub!(/^Faspex /,'')
             # faspex
-            y['process'].gsub!(/ Background/,'')
-            y['process'].gsub!(/serving orchestrator on port /,'')
+            state['process'].gsub!(/ Background/,'')
+            state['process'].gsub!(/serving orchestrator on port /,'')
             # console
-            r=/\s+/ if y['process'].eql?('Console')
+            r=/\s+/ if state['process'].eql?('Console')
             # orchestrator
-            y['process'].gsub!(/^  -> /,'')
-            y['process'].gsub!(/ Process/,'')
-            y
-          end.select{|i|!i.nil?}
+            state['process'].gsub!(/^  -> /,'')
+            state['process'].gsub!(/ Process/,'')
+            result.push(state)
+          end
+          return result
         end
 
         ACTIONS=[:health,:nodeadmin,:userdata,:configurator,:ctl,:download,:upload,:browse,:delete,:rename].concat(Aspera::AsCmd::OPERATIONS)
 
         def execute_action
-          server_uri=URI.parse(self.options.get_option(:url,:mandatory))
+          server_uri=URI.parse(options.get_option(:url,:mandatory))
           Log.log.debug("URI : #{server_uri}, port=#{server_uri.port}, scheme:#{server_uri.scheme}")
           server_transfer_spec={'remote_host'=>server_uri.hostname}
           shell_executor=nil
           case server_uri.scheme
-          when 'ssh'
-            if self.options.get_option(:username,:optional).nil?
-              self.options.set_option(:username,Aspera::Fasp::Default::ACCESS_KEY_TRANSFER_USER)
-              Log.log.info("Using default transfer user: #{Aspera::Fasp::Default::ACCESS_KEY_TRANSFER_USER}")
+          when 'local'
+            shell_executor=LocalExecutor.new
+          when 'https'
+            raise 'ERROR: transfer spec with token required' unless transfer.option_transfer_spec['token'].is_a?(String)
+            server_transfer_spec.merge!({
+              'wss_enabled'=>true,
+              'wss_port'   =>server_uri.port
+            })
+          else # when 'ssh'
+            Log.log.error("Scheme #{server_uri.scheme} not supported. Assuming SSH.") if !server_uri.scheme.eql?('ssh')
+            if options.get_option(:username,:optional).nil?
+              options.set_option(:username,Aspera::Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER)
+              Log.log.info("Using default transfer user: #{Aspera::Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER}")
             end
-            server_transfer_spec['remote_user']=self.options.get_option(:username,:mandatory)
-            ssh_options=self.options.get_option(:ssh_options,:optional)
+            server_transfer_spec['remote_user']=options.get_option(:username,:mandatory)
+            ssh_options=options.get_option(:ssh_options,:optional)
             raise 'expecting a Hash for ssh_options' unless ssh_options.is_a?(Hash)
             if !server_uri.port.nil?
               ssh_options[:port]=server_uri.port
               server_transfer_spec['ssh_port']=server_uri.port
             end
             cred_set=false
-            password=self.options.get_option(:password,:optional)
+            password=options.get_option(:password,:optional)
             if !password.nil?
               ssh_options[:password]=password
               server_transfer_spec['remote_password']=password
               cred_set=true
             end
-            ssh_keys=self.options.get_option(:ssh_keys,:optional)
+            ssh_keys=options.get_option(:ssh_keys,:optional)
             if !ssh_keys.nil?
-              raise 'expecting single value or array for ssh_keys' unless ssh_keys.is_a?(Array) or ssh_keys.is_a?(String)
+              raise 'expecting single value or array for ssh_keys' unless ssh_keys.is_a?(Array) || ssh_keys.is_a?(String)
               ssh_keys=[ssh_keys] if ssh_keys.is_a?(String)
               ssh_keys.map!{|p|File.expand_path(p)}
               Log.log.debug("ssh keys=#{ssh_keys}")
@@ -106,30 +119,20 @@ module Aspera
               end
             end
             # if user provided transfer spec has a token, we will use by pass keys
-            cred_set=true if self.transfer.option_transfer_spec['token'].is_a?(String)
+            cred_set=true if transfer.option_transfer_spec['token'].is_a?(String)
             raise 'either password, key , or transfer spec token must be provided' if !cred_set
             shell_executor=Ssh.new(server_transfer_spec['remote_host'],server_transfer_spec['remote_user'],ssh_options)
-          when 'https'
-            raise "ERROR: transfer spec with token required" unless self.transfer.option_transfer_spec['token'].is_a?(String)
-            server_transfer_spec.merge!({
-              'wss_enabled'=>true,
-              'wss_port'   =>server_uri.port
-            })
-          when 'local'
-            shell_executor=LocalExecutor.new
-          else
-            raise CliError,'Only ssh scheme is supported in url' if !server_uri.scheme.eql?('ssh')
           end
 
           # get command and set aliases
-          command=self.options.get_next_command(ACTIONS)
+          command=options.get_next_command(ACTIONS)
           command=:ls if command.eql?(:browse)
           command=:rm if command.eql?(:delete)
           command=:mv if command.eql?(:rename)
           case command
           when :health
             nagios=Nagios.new
-            command_nagios=self.options.get_next_command([ :app_services, :transfer, :asctlstatus ])
+            command_nagios=options.get_next_command([:app_services, :transfer, :asctlstatus])
             case command_nagios
             when :app_services
               # will not work with aspshell, requires Linux/bash
@@ -143,7 +146,7 @@ module Aspera
             when :transfer
               file = Tempfile.new('transfer_test')
               filepath=file.path
-              file.write("This is a test file for transfer test")
+              file.write('This is a test file for transfer test')
               file.close
               probe_ts=server_transfer_spec.merge({
                 'direction'     => 'send',
@@ -151,18 +154,18 @@ module Aspera
                 'resume_policy' => 'none',
                 'paths'         => [{'source'=>filepath,'destination'=>'.fasping'}]
               })
-              statuses=self.transfer.start(probe_ts,{:src=>:direct})
+              statuses=transfer.start(probe_ts,{src: :direct})
               file.unlink
               if TransferAgent.session_status(statuses).eql?(:success)
                 nagios.add_ok('transfer','ok')
               else
-                nagios.add_critical('transfer',statuses.select{|i|!i.eql?(:success)}.first.to_s)
+                nagios.add_critical('transfer',statuses.reject{|i|i.eql?(:success)}.first.to_s)
               end
             when :asctlstatus
               realcmd='asctl'
-              prefix=self.options.get_option(:cmd_prefix,:optional)
+              prefix=options.get_option(:cmd_prefix,:optional)
               realcmd="#{prefix}#{realcmd} all:status" unless prefix.nil?
-              result=shell_executor.execute(realcmd.split(' '))
+              result=shell_executor.execute(realcmd.split)
               data=asctl_parse(result)
               data.each do |i|
                 if i['state'].eql?('running')
@@ -171,31 +174,32 @@ module Aspera
                   nagios.add_critical(i['process'],i['state'])
                 end
               end
-            else raise "ERROR"
+            else raise 'ERROR'
             end
             return nagios.result
           when :nodeadmin,:userdata,:configurator,:ctl
             realcmd='as'+command.to_s
-            prefix=self.options.get_option(:cmd_prefix,:optional)
+            prefix=options.get_option(:cmd_prefix,:optional)
             if !prefix.nil?
               realcmd="#{prefix}#{realcmd}"
             end
-            args = self.options.get_next_argument("#{realcmd} arguments",:multiple)
+            args = options.get_next_argument("#{realcmd} arguments",:multiple)
             result=shell_executor.execute(args.unshift(realcmd))
             case command
             when :ctl
-              return {:type=>:object_list,:data=>asctl_parse(result)}#
+              return {type: :object_list,data: asctl_parse(result)}
             when :configurator
               lines=result.split("\n")
-              Log.log.debug(`type asconfigurator`)
+              # not windows
+              Log.log.debug(%x(type asconfigurator))
               result=lines
               if lines.first.eql?('success')
                 lines.shift
                 result={}
                 lines.each do |line|
-                  Log.log.debug("#{line}")
-                  data=line.split(',').map{|i|i.gsub(/^"/,'').gsub(/"$/,'')}.map{|i|case i;when'AS_NULL';nil;when'true';true;when'false';false;else i;end}
-                  Log.log.debug("#{data}")
+                  Log.log.debug(line.to_s)
+                  data=line.split(',').map{|i|i.gsub(/^"/,'').gsub(/"$/,'')}.map{|i|case i;when 'AS_NULL' then nil;when 'true' then true;when 'false' then false;else i;end}
+                  Log.log.debug(data.to_s)
                   section=data.shift
                   datapart=result[section]||={}
                   if section.eql?('user')
@@ -206,34 +210,34 @@ module Aspera
                   datapart['default']=data.pop
                   datapart['value']=data.pop
                 end
-                return {:type=>:single_object,:data=>result,:fields=>['section','name','value','default'],:option_expand_last=>true}
+                return {type: :single_object,data: result,fields: ['section','name','value','default'],option_expand_last: true}
               end
             end
             return Main.result_status(result)
           when :upload
-            return Main.result_transfer(self.transfer.start(server_transfer_spec.merge('direction'=>'send'),{:src=>:direct}))
+            return Main.result_transfer(transfer.start(server_transfer_spec.merge('direction'=>Fasp::TransferSpec::DIRECTION_SEND),{src: :direct}))
           when :download
-            return Main.result_transfer(self.transfer.start(server_transfer_spec.merge('direction'=>'receive'),{:src=>:direct}))
+            return Main.result_transfer(transfer.start(server_transfer_spec.merge('direction'=>Fasp::TransferSpec::DIRECTION_RECEIVE),{src: :direct}))
           when *Aspera::AsCmd::OPERATIONS
-            args=self.options.get_next_argument('ascmd command arguments',:multiple,:optional)
+            args=options.get_next_argument('ascmd command arguments',:multiple,:optional)
             ascmd=Aspera::AsCmd.new(shell_executor)
             begin
               result=ascmd.send(:execute_single,command,args)
               case command
-              when :mkdir;  return Main.result_success
-              when :mv;     return Main.result_success
-              when :cp;     return Main.result_success
-              when :rm;     return Main.result_success
-              when :ls;     return {:type=>:object_list,:data=>key_symb_to_str_list(result),:fields=>['zmode','zuid','zgid','size','mtime','name']}
-              when :info;   return {:type=>:single_object,:data=>key_symb_to_str_single(result)}
-              when :df;     return {:type=>:object_list,:data=>key_symb_to_str_list(result)}
-              when :du;     return {:type=>:single_object,:data=>key_symb_to_str_single(result)}
-              when :md5sum; return {:type=>:single_object,:data=>key_symb_to_str_single(result)}
+              when :mkdir then  return Main.result_success
+              when :mv then     return Main.result_success
+              when :cp then     return Main.result_success
+              when :rm then     return Main.result_success
+              when :ls then     return {type: :object_list,data: key_symb_to_str_list(result),fields: ['zmode','zuid','zgid','size','mtime','name']}
+              when :info then   return {type: :single_object,data: key_symb_to_str_single(result)}
+              when :df then     return {type: :object_list,data: key_symb_to_str_list(result)}
+              when :du then     return {type: :single_object,data: key_symb_to_str_single(result)}
+              when :md5sum then return {type: :single_object,data: key_symb_to_str_single(result)}
               end
             rescue Aspera::AsCmd::Error => e
               raise CliBadArgument,e.extended_message
             end
-          else raise "internal error: unexpected action"
+          else raise 'internal error: unexpected action'
           end
         end # execute_action
       end # Server

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/cli/plugins/node'
 
 module Aspera
@@ -6,70 +7,68 @@ module Aspera
       class Shares < BasicAuthPlugin
         class << self
           def detect(base_url)
-            api=Rest.new({:base_url=>base_url})
+            api=Rest.new({base_url: base_url})
             # Shares
             begin
               # shall fail: shares requires auth, but we check error message
               api.read('node_api/app')
             rescue RestCallError => e
-              if e.response.code.to_s.eql?('401') and e.response.body.eql?('{"error":{"user_message":"API user authentication failed"}}')
-                return {:version=>'unknown'}
+              if e.response.code.to_s.eql?('401') && e.response.body.eql?('{"error":{"user_message":"API user authentication failed"}}')
+                return {version: 'unknown'}
               end
-            rescue
             end
             nil
           end
         end
 
-        def initialize(env)
-          super(env)
-          #self.options.parse_options!
-        end
+        #        def initialize(env)
+        #          super(env)
+        #        end
 
-        ACTIONS=[ :repository,:admin ]
+        ACTIONS=[:repository,:admin]
 
         def execute_action
-          command=self.options.get_next_command(ACTIONS)
+          command=options.get_next_command(ACTIONS)
           case command
           when :repository
             api_shares_node=basic_auth_api('node_api')
-            command=self.options.get_next_command(Node::COMMON_ACTIONS)
+            command=options.get_next_command(Node::COMMON_ACTIONS)
             case command
-            when *Node::COMMON_ACTIONS; Node.new(@agents.merge(skip_basic_auth_options: true,node_api: api_shares_node)).execute_action(command)
+            when *Node::COMMON_ACTIONS then Node.new(@agents.merge(skip_basic_auth_options: true,node_api: api_shares_node)).execute_action(command)
             else raise "INTERNAL ERROR, unknown command: [#{command}]"
             end
           when :admin
             api_shares_admin=basic_auth_api('api/v1')
-            command=self.options.get_next_command([:user,:share])
+            command=options.get_next_command([:user,:share])
             case command
             when :user
-              command=self.options.get_next_command([:list,:id])
+              command=options.get_next_command([:list,:id])
               case command
               when :list
-                return {:type=>:object_list,:data=>api_shares_admin.read('data/users')[:data],:fields=>['username','email','directory_user','urn']}
+                return {type: :object_list,data: api_shares_admin.read('data/users')[:data],fields: ['username','email','directory_user','urn']}
               when :id
-                res_id=self.options.get_next_argument('user id')
-                command=self.options.get_next_command([:app_authorizations,:authorize_share])
+                res_id=options.get_next_argument('user id')
+                command=options.get_next_command([:app_authorizations,:authorize_share])
                 case command
                 when :app_authorizations
-                  return {:type=>:single_object,:data=>api_shares_admin.read("data/users/#{res_id}/app_authorizations")[:data]}
+                  return {type: :single_object,data: api_shares_admin.read("data/users/#{res_id}/app_authorizations")[:data]}
                 when :share
-                  share_name=self.options.get_next_argument('share name')
+                  share_name=options.get_next_argument('share name')
                   all_shares=api_shares_admin.read('data/shares')[:data]
                   share_id=all_shares.select{|s| s['name'].eql?(share_name)}.first['id']
-                  return {:type=>:single_object,:data=>api_shares_admin.create("data/shares/#{share_id}/user_permissions")[:data]}
+                  return {type: :single_object,data: api_shares_admin.create("data/shares/#{share_id}/user_permissions")[:data]}
                 end
               end
             when :share
-              command=self.options.get_next_command([:list,:name])
+              command=options.get_next_command([:list,:name])
               all_shares=api_shares_admin.read('data/shares')[:data]
               case command
               when :list
-                return {:type=>:object_list,:data=>all_shares,:fields=>['id','name','status','status_message']}
+                return {type: :object_list,data: all_shares,fields: ['id','name','status','status_message']}
               when :name
-                share_name=self.options.get_next_argument('share name')
+                share_name=options.get_next_argument('share name')
                 share_id=all_shares.select{|s| s['name'].eql?(share_name)}.first['id']
-                raise "TODO"
+                raise "NOT IMPLEMENTED: #{share_name} #{share_id}"
               end
             end
           end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+require 'English'
 require 'aspera/cli/plugin'
 require 'aspera/sync'
 require 'aspera/log'
@@ -10,53 +12,49 @@ module Aspera
       class Sync < Plugin
         def initialize(env)
           super(env)
-          self.options.add_opt_simple(:parameters,"extended value for session set definition")
-          self.options.add_opt_simple(:session_name,"name of session to use for admin commands, by default first one")
-          self.options.parse_options!
+          options.add_opt_simple(:parameters,'extended value for session set definition')
+          options.add_opt_simple(:session_name,'name of session to use for admin commands, by default first one')
+          options.parse_options!
         end
 
-        ACTIONS=[ :start, :admin ]
+        ACTIONS=[:start, :admin]
 
         def execute_action
-          command=self.options.get_next_command(ACTIONS)
+          command=options.get_next_command(ACTIONS)
           case command
           when :start
-            env_args=Aspera::Sync.new(self.options.get_option(:parameters,:mandatory)).compute_args
+            env_args=Aspera::Sync.new(options.get_option(:parameters,:mandatory)).compute_args
             async_bin='async'
             Log.log.debug("execute: #{env_args[:env].map{|k,v| "#{k}=\"#{v}\""}.join(' ')} \"#{async_bin}\" \"#{env_args[:args].join('" "')}\"")
             res=system(env_args[:env],[async_bin,async_bin],*env_args[:args])
             Log.log.debug("result=#{res}")
             case res
-            when true; return Main.result_success
-            when false; raise "failed: #{$?}"
-            when nil; return Main.result_status("not started: #{$?}")
-            else raise "internal error: unspecified case"
+            when true then return Main.result_success
+            when false then raise "failed: #{$CHILD_STATUS}"
+            when nil then return Main.result_status("not started: #{$CHILD_STATUS}")
+            else raise 'internal error: unspecified case'
             end
           when :admin
-            p=self.options.get_option(:parameters,:mandatory)
-            n=self.options.get_option(:session_name,:optional)
+            p=options.get_option(:parameters,:mandatory)
+            n=options.get_option(:session_name,:optional)
             cmdline=['asyncadmin','--quiet']
-            if n.nil?
-              session=p['sessions'].first
-            else
-              session=p['sessions'].select{|s|s['name'].eql?(n)}.first
-            end
+            session=n.nil? ? p['sessions'].first : p['sessions'].select{|s|s['name'].eql?(n)}.first
             cmdline.push('--name='+session['name'])
             if session.has_key?('local_db_dir')
               cmdline.push('--local-db-dir='+session['local_db_dir'])
             else
               cmdline.push('--local-dir='+session['local_dir'])
             end
-            command2=self.options.get_next_command([:status])
+            command2=options.get_next_command([:status])
             case command2
             when :status
               stdout, stderr, status = Open3.capture3(*cmdline)
               Log.log.debug("status=#{status}, stderr=#{stderr}")
-              items=stdout.split("\n").inject({}){|m,l|i=l.split(/:  */);m[i.first.lstrip]=i.last.lstrip;m}
-              return {:type=>:single_object,:data=>items}
-            else raise "error"
+              items=stdout.split("\n").each_with_object({}){|l,m|i=l.split(/:  */);m[i.first.lstrip]=i.last.lstrip;}
+              return {type: :single_object,data: items}
+            else raise 'error'
             end # command
-          else raise "error"
+          else raise 'error'
           end # command
         end # execute_action
       end # Sync