aspera-cli 4.7.0 → 4.9.0

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/ascmd'
 require 'aspera/fasp/transfer_spec'
@@ -13,226 +14,125 @@ module Aspera
       class Server < BasicAuthPlugin
         class LocalExecutor
           def execute(cmd,_input=nil)
-            %x(#{cmd})
+            Log.log.debug("Executing: #{cmd}")
+            %x(#{cmd.join(' ')})
           end
         end
 
         def initialize(env)
           super(env)
-          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.add_opt_simple(:ssh_keys,'SSH key path list (Array or single)')
+          options.add_opt_simple(:ssh_options,'SSH options (Hash)')
           options.set_option(:ssh_keys,[])
           options.set_option(:ssh_options,{})
           options.parse_options!
         end
 
-        def key_symb_to_str_single(source)
-          return source.each_with_object({}){|(k,v),memo| memo[k.to_s] = v; }
-        end
-
         def key_symb_to_str_list(source)
-          return source.map{|o| key_symb_to_str_single(o)}
+          return source.map(&:stringify_keys)
         end
 
-        def asctl_parse(text)
-          # normal separator
-          r=/:\s*/
-          result=[]
-          text.split("\n").each do |line|
-            # console: missing space
-            line.gsub!(/(SessionDataCollector)/,'\1 ')
-            # orchestrator
-            line.gsub!(/ with pid:.*/,'')
-            line.gsub!(/ is /,': ')
-            items=line.split(r)
-            next unless items.length.eql?(2)
-            state={'process'=>items.first,'state'=>items.last}
-            # console
-            state['state'].gsub!(/\.+$/,'')
-            # console
-            state['process'].gsub!(/^.+::/,'')
-            # faspex
-            state['process'].gsub!(/^Faspex /,'')
-            # faspex
-            state['process'].gsub!(/ Background/,'')
-            state['process'].gsub!(/serving orchestrator on port /,'')
-            # console
-            r=/\s+/ if state['process'].eql?('Console')
-            # orchestrator
-            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)
+        ACTIONS = %i[health download upload browse delete rename].concat(Aspera::AsCmd::OPERATIONS).freeze
 
         def execute_action
-          server_uri=URI.parse(options.get_option(:url,:mandatory))
+          server_uri = URI.parse(options.get_option(:url,is_type: :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
+          server_transfer_spec = {'remote_host' => server_uri.hostname}
+          shell_executor = nil
           case server_uri.scheme
           when 'local'
-            shell_executor=LocalExecutor.new
+            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
-            })
+            server_transfer_spec['wss_enabled'] = true
+            server_transfer_spec['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?
+            if options.get_option(:username).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']=options.get_option(:username,:mandatory)
-            ssh_options=options.get_option(:ssh_options,:optional)
+            server_transfer_spec['remote_user'] = options.get_option(:username,is_type: :mandatory)
+            ssh_options = options.get_option(:ssh_options)
             raise 'expecting a Hash for ssh_options' unless ssh_options.is_a?(Hash)
+            ssh_options = ssh_options.symbolize_keys
             if !server_uri.port.nil?
-              ssh_options[:port]=server_uri.port
-              server_transfer_spec['ssh_port']=server_uri.port
+              ssh_options[:port] = server_uri.port
+              server_transfer_spec['ssh_port'] = server_uri.port
             end
-            cred_set=false
-            password=options.get_option(:password,:optional)
+            cred_set = false
+            password = options.get_option(:password)
             if !password.nil?
-              ssh_options[:password]=password
-              server_transfer_spec['remote_password']=password
-              cred_set=true
+              ssh_options[:password] = password
+              server_transfer_spec['remote_password'] = password
+              cred_set = true
             end
-            ssh_keys=options.get_option(:ssh_keys,:optional)
+            ssh_keys = options.get_option(:ssh_keys)
             if !ssh_keys.nil?
               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 = [ssh_keys] if ssh_keys.is_a?(String)
               ssh_keys.map!{|p|File.expand_path(p)}
               Log.log.debug("ssh keys=#{ssh_keys}")
               if !ssh_keys.empty?
-                ssh_options[:keys]=ssh_keys
-                server_transfer_spec['EX_ssh_key_paths']=ssh_keys
+                ssh_options[:keys] = ssh_keys
+                server_transfer_spec['EX_ssh_key_paths'] = ssh_keys
                 ssh_keys.each do |k|
                   Log.log.warn("no such key file: #{k}") unless File.exist?(k)
                 end
-                cred_set=true
+                cred_set = true
               end
             end
             # if user provided transfer spec has a token, we will use by pass keys
-            cred_set=true if 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)
+            shell_executor = Ssh.new(server_transfer_spec['remote_host'],server_transfer_spec['remote_user'],ssh_options)
           end
 
           # get command and set aliases
-          command=options.get_next_command(ACTIONS)
-          command=:ls if command.eql?(:browse)
-          command=:rm if command.eql?(:delete)
-          command=:mv if command.eql?(:rename)
+          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=options.get_next_command([:app_services, :transfer, :asctlstatus])
+            nagios = Nagios.new
+            command_nagios = options.get_next_command(%i[transfer])
             case command_nagios
-            when :app_services
-              # will not work with aspshell, requires Linux/bash
-              procs=shell_executor.execute('ps -A -o comm').split("\n")
-              Log.log.debug("found: #{procs}")
-              ['asperanoded','asperaredisd'].each do |name|
-                nagios.add_critical('general',"missing process #{name}") unless procs.include?(name)
-              end
-              nagios.add_ok('daemons','ok') if nagios.data.empty?
-              return nagios.result
             when :transfer
               file = Tempfile.new('transfer_test')
-              filepath=file.path
+              filepath = file.path
               file.write('This is a test file for transfer test')
               file.close
-              probe_ts=server_transfer_spec.merge({
+              probe_ts = server_transfer_spec.merge({
                 'direction'     => 'send',
                 'cookie'        => 'aspera.sync', # hide in console
                 'resume_policy' => 'none',
-                'paths'         => [{'source'=>filepath,'destination'=>'.fasping'}]
+                'paths'         => [{'source' => filepath,'destination' => '.fasping'}]
               })
-              statuses=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.reject{|i|i.eql?(:success)}.first.to_s)
               end
-            when :asctlstatus
-              realcmd='asctl'
-              prefix=options.get_option(:cmd_prefix,:optional)
-              realcmd="#{prefix}#{realcmd} all:status" unless prefix.nil?
-              result=shell_executor.execute(realcmd.split)
-              data=asctl_parse(result)
-              data.each do |i|
-                if i['state'].eql?('running')
-                  nagios.add_ok(i['process'],i['state'])
-                else
-                  nagios.add_critical(i['process'],i['state'])
-                end
-              end
             else raise 'ERROR'
             end
             return nagios.result
-          when :nodeadmin,:userdata,:configurator,:ctl
-            realcmd='as'+command.to_s
-            prefix=options.get_option(:cmd_prefix,:optional)
-            if !prefix.nil?
-              realcmd="#{prefix}#{realcmd}"
-            end
-            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)}
-            when :configurator
-              lines=result.split("\n")
-              # 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.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')
-                    name=data.shift
-                    datapart=datapart[name]||={}
-                  end
-                  datapart=datapart[data.shift]={}
-                  datapart['default']=data.pop
-                  datapart['value']=data.pop
-                end
-                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(transfer.start(server_transfer_spec.merge('direction'=>Fasp::TransferSpec::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(transfer.start(server_transfer_spec.merge('direction'=>Fasp::TransferSpec::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=options.get_next_argument('ascmd command arguments',:multiple,:optional)
-            ascmd=Aspera::AsCmd.new(shell_executor)
+            args = options.get_next_argument('ascmd command arguments',expected: :multiple,mandatory: false)
+            ascmd = Aspera::AsCmd.new(shell_executor)
             begin
-              result=ascmd.send(:execute_single,command,args)
+              result = ascmd.send(:execute_single,command,args)
               case command
-              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)}
+              when :mkdir,:mv,:cp,:rm then return Main.result_success
+              when :ls                then return {type: :object_list,data: key_symb_to_str_list(result),fields: %w[zmode zuid zgid size mtime name]}
+              when :df                then return {type: :object_list,data: key_symb_to_str_list(result)}
+              when :du,:md5sum,:info  then return {type: :single_object,data: result.stringify_keys}
               end
             rescue Aspera::AsCmd::Error => e
               raise CliBadArgument,e.extended_message

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/cli/plugins/node'
 
 module Aspera
@@ -7,7 +8,7 @@ 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
@@ -25,50 +26,83 @@ module Aspera
         #          super(env)
         #        end
 
-        ACTIONS=[:repository,:admin]
+        SAML_IMPORT_MANDATORY=%w[id name_id].freeze
+        SAML_IMPORT_ALLOWED=[SAML_IMPORT_MANDATORY,%w[email given_name surname]].flatten.freeze
+
+        ACTIONS = %i[health repository admin].freeze
 
         def execute_action
-          command=options.get_next_command(ACTIONS)
+          command = options.get_next_command(ACTIONS)
           case command
+          when :health
+            nagios = Nagios.new
+            begin
+              Rest.
+                new(base_url: options.get_option(:url,is_type: :mandatory)+'/node_api').
+                call(
+                  operation: 'GET',
+                  subpath: 'ping',
+                  headers: {'content-type': 'application/json'},
+                  return_error: true)
+              nagios.add_ok('shares api','accessible')
+            rescue StandardError => e
+              nagios.add_critical('node api',e.to_s)
+            end
+            return nagios.result
           when :repository
-            api_shares_node=basic_auth_api('node_api')
-            command=options.get_next_command(Node::COMMON_ACTIONS)
+            api_shares_node = basic_auth_api('node_api')
+            command = options.get_next_command(Node::COMMON_ACTIONS)
             case 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=options.get_next_command([:user,:share])
+            api_shares_admin = basic_auth_api('api/v1')
+            command = options.get_next_command(%i[user share])
             case command
             when :user
-              command=options.get_next_command([:list,:id])
+              command = options.get_next_command(%i[list app_authorizations share_permissions saml_import ldap_import])
+              user_id = instance_identifier if %i[app_authorizations share_permissions].include?(command)
               case command
               when :list
-                return {type: :object_list,data: api_shares_admin.read('data/users')[:data],fields: ['username','email','directory_user','urn']}
-              when :id
-                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]}
-                when :share
-                  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: :object_list,data: api_shares_admin.read('data/users')[:data],fields: %w[id username email directory_user urn]}
+              when :app_authorizations
+                return {type: :single_object,data: api_shares_admin.read("data/users/#{user_id}/app_authorizations")[:data]}
+              when :share_permissions
+                #share_name = options.get_next_argument('share name')
+                #all_shares = api_shares_admin.read('data/shares')[:data]
+                #share_id = all_shares.find{|s| s['name'].eql?(share_name)}['id']
+                return {type: :object_list,data: api_shares_admin.read("data/users/#{user_id}/share_permissions")[:data]}
+              when :saml_import
+                parameters = options.get_option(:value)
+                return do_bulk_operation(parameters,'created') do |user_params|
+                  user_params=user_params.transform_keys{|k|k.gsub(/\s+/,'_').downcase}
+                  raise 'expecting Hash' unless user_params.is_a?(Hash)
+                  SAML_IMPORT_MANDATORY.each{|p|raise "missing mandatory field: #{p}" if user_params[p].nil?}
+                  user_params.keys.each do |p|
+                    raise "unsupported field: #{p}, use: #{SAML_IMPORT_ALLOWED.join(',')}" unless SAML_IMPORT_ALLOWED.include?(p)
+                  end
+                  api_shares_admin.create('data/saml_users/import',user_params)[:data]
+                end
+              when :ldap_import
+                parameters = options.get_option(:value)
+                return do_bulk_operation(parameters,'created') do |user_name|
+                  raise 'expecting string (user name), have #{user_params.class}' unless user_params.is_a?(String)
+                  api_shares_admin.create('data/ldap_users',{'user'=>user_name})[:data]
                 end
               end
             when :share
-              command=options.get_next_command([:list,:name])
-              all_shares=api_shares_admin.read('data/shares')[:data]
+              command = options.get_next_command(%i[list user_permissions])
+              share_id = instance_identifier if %i[user_permissions].include?(command)
+              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']}
-              when :name
-                share_name=options.get_next_argument('share name')
-                share_id=all_shares.select{|s| s['name'].eql?(share_name)}.first['id']
-                raise "NOT IMPLEMENTED: #{share_name} #{share_id}"
+                return {type: :object_list,data: all_shares,fields: %w[id name status status_message]}
+              when :user_permissions
+                #share_name = options.get_next_argument('share name')
+                #share_id = all_shares.find{|s| s['name'].eql?(share_name)}['id']
+                #raise "NOT IMPLEMENTED: #{share_name} #{share_id}"
+                return {type: :object_list,data: api_shares_admin.read("data/shares/#{share_id}/user_permissions")[:data]}
               end
             end
           end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'English'
 require 'aspera/cli/plugin'
 require 'aspera/sync'
@@ -17,16 +18,16 @@ module Aspera
           options.parse_options!
         end
 
-        ACTIONS=[:start, :admin]
+        ACTIONS = %i[start admin].freeze
 
         def execute_action
-          command=options.get_next_command(ACTIONS)
+          command = options.get_next_command(ACTIONS)
           case command
           when :start
-            env_args=Aspera::Sync.new(options.get_option(:parameters,:mandatory)).compute_args
-            async_bin='async'
+            env_args = Aspera::Sync.new(options.get_option(:parameters,is_type: :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])
+            res = system(env_args[:env],[async_bin,async_bin],*env_args[:args])
             Log.log.debug("result=#{res}")
             case res
             when true then return Main.result_success
@@ -35,22 +36,22 @@ module Aspera
             else raise 'internal error: unspecified case'
             end
           when :admin
-            p=options.get_option(:parameters,:mandatory)
-            n=options.get_option(:session_name,:optional)
-            cmdline=['asyncadmin','--quiet']
-            session=n.nil? ? p['sessions'].first : p['sessions'].select{|s|s['name'].eql?(n)}.first
-            cmdline.push('--name='+session['name'])
+            p = options.get_option(:parameters,is_type: :mandatory)
+            n = options.get_option(:session_name)
+            cmdline = ['asyncadmin','--quiet']
+            session = n.nil? ? p['sessions'].first : p['sessions'].find{|s|s['name'].eql?(n)}
+            cmdline.push('--name=' + session['name'])
             if session.has_key?('local_db_dir')
-              cmdline.push('--local-db-dir='+session['local_db_dir'])
+              cmdline.push('--local-db-dir=' + session['local_db_dir'])
             else
-              cmdline.push('--local-dir='+session['local_dir'])
+              cmdline.push('--local-dir=' + session['local_dir'])
             end
-            command2=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").each_with_object({}){|l,m|i=l.split(/:  */);m[i.first.lstrip]=i.last.lstrip;}
+              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