aspera-cli 4.5.0 → 4.8.0

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

@@ -1,6 +1,8 @@
+# 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 +13,24 @@ 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)
+            Log.log.debug("Executing: #{cmd}")
+            %x(#{cmd.join(' ')})
           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,135 +38,163 @@ module Aspera
         end
 
         def asctl_parse(text)
-          r=/:\s*/
-          return text.split("\n").map do |line|
-            # console
+          # 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 /,': ')
-            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
+
+        def asconfigurator_parse(result)
+          lines = result.split("\n")
+          # not windows
+          Log.log.debug(%x(type asconfigurator))
+          status=lines.shift
+          case status
+          when 'success'
+            result = []
+            lines.each do |line|
+              Log.log.debug(line.to_s)
+              # normalize values
+              data = line.
+                gsub(/^"/,'').
+                gsub(/,""$/,',"AS_EMPTY"').
+                gsub(/"$/,'').
+                split('","').
+                map{|i|case i;when 'AS_NULL' then nil;when 'AS_EMPTY' then '';when 'true' then true;when 'false' then false;else i;end}
+              data.insert(1,'') if data.length.eql?(4)
+              titles=%w[level section parameter value default]
+              result.push(titles.each_with_object({}){|t,o|o[t]=data.shift})
+            end
+            return result
+          when 'failure'
+            raise lines.join("\n")
+          else raise "Unexpected: #{status}"
+          end
         end
 
-        ACTIONS=[:health,:nodeadmin,:userdata,:configurator,:ctl,:download,:upload,:browse,:delete,:rename].concat(Aspera::AsCmd::OPERATIONS)
+        ACTIONS = %i[health nodeadmin userdata configurator ctl download upload browse delete rename].concat(Aspera::AsCmd::OPERATIONS).freeze
 
         def execute_action
-          server_uri=URI.parse(self.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 '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['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).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,is_type: :mandatory)
+            ssh_options = options.get_option(:ssh_options)
             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
+              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)
+            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=self.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) or ssh_keys.is_a?(String)
-              ssh_keys=[ssh_keys] if 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}")
               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 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')
+            shell_executor = Ssh.new(server_transfer_spec['remote_host'],server_transfer_spec['remote_user'],ssh_options)
           end
 
           # get command and set aliases
-          command=self.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=self.options.get_next_command([ :app_services, :transfer, :asctlstatus ])
+            nagios = Nagios.new
+            command_nagios = options.get_next_command(%i[app_services transfer asctlstatus])
             case command_nagios
             when :app_services
               # will not work with aspshell, requires Linux/bash
-              procs=shell_executor.execute('ps -A -o comm').split("\n")
+              procs = shell_executor.execute('ps -A -o comm').split("\n")
               Log.log.debug("found: #{procs}")
-              ['asperanoded','asperaredisd'].each do |name|
+              %w[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
-              file.write("This is a test file for transfer test")
+              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=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)
-              realcmd="#{prefix}#{realcmd} all:status" unless prefix.nil?
-              result=shell_executor.execute(realcmd.split(' '))
-              data=asctl_parse(result)
+              realcmd = 'asctl'
+              prefix = options.get_option(:cmd_prefix)
+              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'])
@@ -171,69 +202,43 @@ 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)
-            if !prefix.nil?
-              realcmd="#{prefix}#{realcmd}"
-            end
-            args = self.options.get_next_argument("#{realcmd} arguments",:multiple)
-            result=shell_executor.execute(args.unshift(realcmd))
+            realcmd = "as#{command}"
+            prefix = options.get_option(:cmd_prefix)
+            realcmd = "#{prefix}#{realcmd}" unless prefix.nil?
+            args = options.get_next_argument("#{realcmd} arguments",expected: :multiple)
+            args.unshift('-x') if command.eql?(:configurator)
+            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`)
-              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}")
-                  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
+              result=asconfigurator_parse(result)
+              return {type: :object_list,data: result} # ,option_expand_last: true
             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)
-            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;  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,: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: 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,5 @@
+# frozen_string_literal: true
+
 require 'aspera/cli/plugins/node'
 
 module Aspera
@@ -6,70 +8,81 @@ 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 = %i[health repository admin].freeze
 
         def execute_action
-          command=self.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=self.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; 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])
+            api_shares_admin = basic_auth_api('api/v1')
+            command = options.get_next_command(%i[user share])
             case command
             when :user
-              command=self.options.get_next_command([:list,:id])
+              command = options.get_next_command(%i[list app_authorizations share_permissions])
+              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=self.options.get_next_argument('user id')
-                command=self.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=self.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]}
-                end
+                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]}
               end
             when :share
-              command=self.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=self.options.get_next_argument('share name')
-                share_id=all_shares.select{|s| s['name'].eql?(share_name)}.first['id']
-                raise "TODO"
+                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,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'English'
 require 'aspera/cli/plugin'
 require 'aspera/sync'
 require 'aspera/log'
@@ -10,53 +13,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 = %i[start admin].freeze
 
         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
-            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; 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)
-            cmdline=['asyncadmin','--quiet']
-            if n.nil?
-              session=p['sessions'].first
-            else
-              session=p['sessions'].select{|s|s['name'].eql?(n)}.first
-            end
-            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=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