rda-python-miscs 1.0.1__py3-none-any.whl

rda_python_miscs/rdacp.usg

@@ -0,0 +1,62 @@
+
+ Copy directories and files in the current or specified directories to a target
+ directory. The owner of the target directories and files is 'rdadata' with default
+ or specified modes.
+  
+ Usage: rdacp [-D DiretoryMode] [-f] FromDirecctories/Files [-F FileMode]  \
+              [-hf HtarFileName] [-fh FromHostName] [-h] [-r] [-R RecursiveLevel] \
+              [-t ToDirectory/FileName] [-th ToHostName] [-fl FileCountLimit]
+
+      - Option -D, changes mode of target directories. It defaults to "775";
+
+      - Option -f, mandatory option for directories and files to be copied from. 
+        Unix command line wildcards are supported. Use './' or '*' for all
+        directories and files in the current directory to be copied.
+        The directories and files must be readable by user 'rdadata';
+        otherwise 'rdacp' will try to change file mode to make them readable.
+        The file names are htar member files if a htar file name is provided
+        by Option -hf;
+ 
+      - Option -fh, host name for directories and files to be copied from. 
+        It defaults to local host unless htar file name is provded via Option
+        -hf, then it defaults to hpss;
+ 
+      - Option -F, changes mode of target files. It defaults to "664";
+
+      - Option -h, display this help document;
+
+      - Option -hf, provides a HTAR file name to retrieve its one or multiple
+        member files to local for option -fh HPSS, or to htar givens local files
+        onto HPSS for option -th HPSS;
+ 
+      - Option -r, copies directories and files recursively;
+
+      - Option -R, copies directories and files recursively up to the level provided
+        with this Option;
+
+      - Option -t, provides a target Directory/File name. Its value defaults to '.'.
+        Mutilple source files can not be copied if a single target file name is
+        specified.
+ 
+      - Option -th, host name for target directories and files. 
+        It defaults to local host;
+
+      - Option -fl, file count limit in each htar file, default 0 means all files in
+        a single htar file; if > 0, it means to archive multiple htar files, with
+        each holding up to the given file count. The max value is 5000000;
+ 
+  This utility program can be executed anywhere. This help document is displayed if
+  either the source Directory/File Names are missed. 
+ 
+  For examples, to copy every directory/file under the current directory to under
+  ds277.6 on host castle, you can
+     
+     rdacp  -r -t /PathTo/ds277.6/ -th castle -f *
+
+  To copy every directory/file under a given local directory to under ds277.6
+  on host castle, you can
+     
+     rdacp  -r -t /PathTo/ds277.6/ -th castle -f /PathTo/DirectoryName/
+  
+  where if the ending '/' is missed, the DirectoryName itself is copied too.
+ 

rda_python_miscs/rdakill.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+#
+##################################################################################
+#
+#     Title: rdakill
+#    Author: Zaihua Ji, zji@ucar.edu
+#      Date: 10/24/2020
+#            2025-03-10 transferred to package rda_python_miscs from
+#            https://github.com/NCAR/rda-utility-programs.git
+#   Purpose: kill a local or batch process and its child processes for a given
+#            running process ID by 'rdadata'
+#
+#    Github: https://github.com/NCAR/rda-python-miscs.git
+#
+##################################################################################
+#
+import re
+import sys
+import time
+from rda_python_common import PgLOG
+from rda_python_common import PgSIG
+from rda_python_common import PgUtil
+from rda_python_common import PgFile
+from rda_python_common import PgDBI
+
+RDAKILL = {
+   'a' : None,    # application name
+   'h' : None,    # hostname
+   'p' : 0,       # process id to be killed
+   'P' : 0,       # parent pid
+   'r' : 0,       # 1 - reserved for exclusive, working with -s PEND only 
+   'u' : None,    # login user name
+   's' : None,    # batch status to kill
+   'q' : None     # batch partition/queue for SLURM/PBS, rda for default
+}
+
+#
+# main function to run the application
+#
+def main():
+
+   optcnt = 0
+   option = None
+   argv = sys.argv[1:]
+   PgDBI.dssdb_dbname()
+   PgLOG.set_suid(PgLOG.PGLOG['EUID'])
+   PgLOG.set_help_path(__file__)
+   PgLOG.PGLOG['LOGFILE'] = "rdakill.log"   # set different log file
+   PgLOG.cmdlog("rdakill {}".format(' '.join(argv)))
+   
+   for arg in argv:
+      ms = re.match(r'-([ahpPqstu])$', arg)
+      if ms:
+         option = ms.group(1)
+      elif re.match(r'-r$', arg):
+         RDAKILL['r'] = 1
+      elif re.match(r'-\w+$', arg):
+         PgLOG.pglog(arg + ": Unknown Option", PgLOG.LGEREX)
+      elif option:
+         if RDAKILL[option]: PgLOG.pglog("{}: value passed to Option -{} already".format(arg, option), PgLOG.LGEREX)
+         if 'pPt'.find(option) > -1:
+            RDAKILL[option] = int(arg)
+         elif option == 'h':
+            RDAKILL[option] = PgLOG.get_short_host(arg)
+         else:
+            RDAKILL[option] = arg
+         option = None
+         optcnt += 1
+      else:
+         ms = re.match(r'^(\d+)$', arg)
+         if ms and RDAKILL['p']:
+            RDAKILL['p'] = int(ms.group(1))   # pid allow value only without leading option
+            optcnt += 1
+         else:
+            PgLOG.pglog(arg + ": pass in value without Option", PgLOG.LGEREX)
+   
+   if not optcnt: PgLOG.show_usage("rdakill")
+   killloc = 1
+   if RDAKILL['h']:
+      PgFile.local_host_action(RDAKILL['h'], "kill processes", PgLOG.PGLOG['HOSTNAME'], PgLOG.LGEREX)
+      if not PgUtil.pgcmp(RDAKILL['h'], PgLOG.PGLOG['SLMNAME'], 1):
+         if not (RDAKILL['p'] or RDAKILL['s']):
+            PgLOG.pglog("Provide Batch ID or Job Status to kill SLURM jobs", PgLOG.LGEREX)
+         if RDAKILL['p']:
+            rdakill_slurm_batch(RDAKILL['p'])
+         else:
+            rdakill_slurm_status(RDAKILL['s'], RDAKILL['q'], RDAKILL['u'])
+         killloc = 0
+      elif not PgUtil.pgcmp(RDAKILL['h'], PgLOG.PGLOG['PBSNAME'], 1):
+         if not (RDAKILL['p'] or RDAKILL['s']):
+            PgLOG.pglog("Provide Batch ID or Job Status to kill PBS jobs", PgLOG.LGEREX)
+         if RDAKILL['p']:
+            rdakill_pbs_batch(RDAKILL['p'])
+         else:
+            rdakill_pbs_status(RDAKILL['s'], RDAKILL['q'], RDAKILL['u'])
+         killloc = 0
+   if killloc:
+      if not (RDAKILL['p'] or RDAKILL['P'] or RDAKILL['a']):
+         PgLOG.pglog("Specify process ID, parent PID or App Name to kill", PgLOG.LGEREX)
+      rdakill_processes(RDAKILL['p'], RDAKILL['P'], RDAKILL['a'], RDAKILL['u'])
+
+   PgLOG.cmdlog()
+   PgLOG.pgexit(0)
+
+#
+# kill processes for given condition
+#
+def rdakill_processes(pid, ppid, aname = None, uname = None, level = 0):
+
+   kcnt = 0
+   if pid:
+      cmd = "ps -p {} -f".format(pid)
+   elif ppid:
+      cmd = "ps --ppid {} -f".format(ppid)
+   elif uname:
+      cmd = "ps -u {} -f".format(uname)
+   else:
+      cmd = "ps -ef"
+
+   buf = PgLOG.pgsystem(cmd, PgLOG.LGWNEX, 20)
+   if buf:
+      for line in re.split('\n', buf):
+         ms = re.match(r'\s*(\w+)\s+(\d+)\s+(\d+)\s+(.*)$', line)
+         if ms:
+            uid = ms.group(1)
+            cid = int(ms.group(2))
+            pcid = int(ms.group(3))
+            cname = ms.group(4)
+            if pid and pid != cid: continue
+            if ppid and ppid != pcid: continue
+            if uname and not re.match(r'all$', uname, re.I) and uname != uid: continue
+            if aname and cname.find(aname) < 0: continue
+            kcnt += 1
+            rdakill_processes(0, cid, None, None, level+1)
+            kill_local_child(cid, uid, re.sub(r'  +', ' ', line))
+            record_dscheck_interrupt(cid, PgLOG.PGLOG['HOSTNAME'])
+
+   if not (kcnt or level):
+      buf = "No process idendified to kill "
+      if RDAKILL['h']:
+         buf += "on " + RDAKILL['h']
+      else:
+         buf += "locally"
+         if PgLOG.PGLOG['CURBID']: buf += "; add Option '-h SLURM' if SLURM batch ID provided"
+      PgLOG.pglog(buf, PgLOG.LOGWRN)
+
+#
+# a local child process
+def kill_local_child(pid, uid, line):
+
+   if PgSIG.check_process(pid):
+      cmd = PgLOG.get_local_command("kill -9 {}".format(pid), uid)
+      if PgLOG.pgsystem(cmd, PgLOG.LOGWRN, 260):     # 4+256
+         return PgLOG.pglog("Kill: " + line, PgLOG.LOGWRN)
+      elif PgSIG.check_process(pid):
+         return PgLOG.pglog("Error Kill: {}\n{}".format(line, PgLOG.PGLOG['SYSERR']), PgLOG.LOGWRN)
+
+   if not PgSIG.check_process(pid): PgLOG.pglog("Quit: " + line, PgLOG.LOGWRN)
+
+#
+# kill a slurm batch job
+#
+def rdakill_slurm_batch(bid):
+
+   ret = 0
+   stat = PgSIG.check_slurm_status(bid, PgLOG.LOGWRN)
+   if stat:
+      cmd = PgLOG.get_local_command("scancel {}".format(bid), stat['USER'])
+      ret = PgLOG.pgsystem(cmd, PgLOG.LOGWRN, 6)
+      if ret: record_dscheck_interrupt(bid, PgLOG.PGLOG['SLMNAME'])
+   else:
+      PgLOG.pglog("{}: cannot find SLURM batch ID".format(bid), PgLOG.LOGERR)
+
+   if not ret and PgLOG.PGLOG['SYSERR']: PgLOG.pglog(PgLOG.PGLOG['SYSERR'], PgLOG.LGEREX)
+   
+   return ret
+
+#
+# kill SLURM batch jobs for given status
+#
+def rdakill_slurm_status(stat, part, uname):
+   
+   if not part: part = 'rda'
+   bcmd = "sacct -o jobid,user,state -r {} -".format(part)
+   bcmd += ("u " + uname if uname else 'a')
+
+   lines = PgSIG.get_slurm_multiple(bcmd)
+   bcnt = len(lines['JOBID']) if lines else 0
+   pcnt = kcnt = 0
+   for i in range(bcnt):
+      if lines['STATE'][i] == stat:
+         pcnt += 1
+         kcnt += rdakill_slurm_batch(lines['JOBID'][i])
+
+   if pcnt > 0:
+      s = 's' if pcnt > 1 else ''
+      line = "{} of {} SLURM '{}' job{} Killed".format(kcnt, pcnt, stat, s)
+   else:
+      line = "No SLURM '{}' job found to kill".format(stat)
+
+   line += " in Partition '{}'".format(part)
+   if uname: line += " for " + uname
+   PgLOG.pglog(line, PgLOG.LOGWRN)
+
+#
+# kill a pbs batch job
+#
+def rdakill_pbs_batch(bid):
+
+   ret = 0
+   stat = PgSIG.get_pbs_info(bid, 0, PgLOG.LOGWRN)
+   if stat:
+      dcmd = 'qdel'
+      if PgLOG.PGLOG['HOSTTYPE'] == 'ch': dcmd += 'casper'
+      cmd = PgLOG.get_local_command("{} {}".format(dcmd, bid), stat['UserName'])
+      ret = PgLOG.pgsystem(cmd, PgLOG.LOGWRN, 7)
+      if ret: record_dscheck_interrupt(bid, PgLOG.PGLOG['PBSNAME'])
+   else:
+      PgLOG.pglog("{}: cannot find PBS batch ID".format(bid), PgLOG.LOGERR)
+
+   if not ret and PgLOG.PGLOG['SYSERR']: PgLOG.pglog(PgLOG.PGLOG['SYSERR'], PgLOG.LGEREX)
+
+   return ret
+
+#
+# kill PBS batch jobs for given status
+#
+def rdakill_pbs_status(stat, queue, uname):
+
+   if not queue: queue = 'rda'
+   qopts = ''
+   if uname:
+      qopts = "-u " + uname
+   if qopts: qopts += ' '
+   qopts += queue
+   lines = PgSIG.get_pbs_info(qopts, 1)
+   bcnt = len(lines['JobID'])
+   pcnt = kcnt = 0
+   for i in range(bcnt):
+      if stat != lines['State'][i]: continue
+      pcnt += 1
+      kcnt += rdakill_pbs_batch(lines['JobID'][i])
+
+   if pcnt > 0:
+      s = 's' if pcnt > 1 else ''
+      line = "{} of {} PBS '{}' job{} Killed".format(kcnt, pcnt, stat, s)
+   else:
+      line = "No PBS '{}' job found to kill".format(stat)
+
+   line += " in Queue '{}'".format(queue)
+   if uname: line += " for " + uname
+   PgLOG.pglog(line, PgLOG.LOGWRN)
+
+#
+# record a dscheck 
+#
+def record_dscheck_interrupt(pid, host):
+
+   pgrec = PgDBI.pgget("dscheck", "cindex", "pid = {} AND hostname = '{}'".format(pid, host), PgLOG.LOGERR)
+   if pgrec:
+      record = {'chktime' : int(time.time()), 'status' : 'I', 'pid' : 0}   # release lock
+      PgDBI.pgupdt("dscheck", record, "cindex = {}".format(pgrec['cindex']), PgLOG.LGEREX)
+
+#
+# call main() to start program
+#
+if __name__ == "__main__": main()

rda_python_miscs/rdakill.usg

@@ -0,0 +1,36 @@
+
+ Kill one of multiple processes and theirs children for given local process ID or
+ other process information; kill one or multiple SLURM/PBS batch jobs for give batch
+ Job ID or Status. For killing SLURM/PBS batch jobs, you must login to cheyenne/caser
+ login nodes.
+ 
+ Usage: rdakill [-h HostName] [-p ProcessID] [-P ParentProcessID]  \
+                [-s BatchStatus] [-u ProcessOwner] [-a ApplicationName]
+
+      - Option -a, application name of the process;
+
+      - Option -h, hostname the process is on. Omit it for local process,
+        but it is mandatory if the process id is a SLURM/PBS bactch id.
+ 
+      - Option -p, the process id or batch job id to be stopped.
+ 
+      - Option -P, the parent process id;
+ 
+      - Option -q, the SLURM Partition or PBS queue name. It defaults to 'rda';
+
+      - Option -s, the Batch Job Status; this is mantatory if batch id is not provided;
+
+      - Option -u, use login name for the process owner. It defaults to 'all' for
+        all user login names.
+
+  This help document is displayed if rdakill is executed without option.
+  
+  For examples, to kill a process of a dsrqst process with pid 13199 locally,
+     
+     rdakill -p 13199 -a dsrqst
+ 
+  The child processes under the dsrqst process, if any, are also terminated. To kill
+  a PBS bactch process with a bid = 334323,
+     
+     rdakill -h PBS -p 334323
+ 

rda_python_miscs/rdals.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+#
+##################################################################################
+#
+#     Title: rdals
+#    Author: Zaihua Ji, zji@ucar.edu
+#      Date: 10/20/2020
+#            2025-03-10 transferred to package rda_python_miscs from
+#            https://github.com/NCAR/rda-utility-programs.git
+#   Purpose: list files/directories in a local directory and show additional
+#            information recorded in RDADB if any
+#
+#    Github: https://github.com/NCAR/rda-python-miscs.git
+#
+##################################################################################
+#
+import re
+import os
+import sys
+import glob
+from os import path as op
+from rda_python_common import PgLOG
+from rda_python_common import PgDBI
+from rda_python_common import PgUtil
+from rda_python_common import PgSplit
+
+# define some constants for rdals actions
+DIDX = 3   # description column index
+CLMT = 500   # reformat list if count reach this limit
+WIDTHS = [0, 0, 0]   # WIDTHS for formated display
+ALIGNS = [0, 1, 1]   # alignment, 0 - left; 1 - right
+
+RDALS = {
+   'd' : 0,     # 1 to list directory information only
+   'f' : 0,     # 1 to list file information only
+   'N' : 0,     # 1 to list files unformatted
+   'r' : 0,     # 1 if recursive all
+   'R' : 0,     # > 0 to set recursive limit
+   'D' : None,  # specify delimiting symbols, default to '  '
+}
+
+LINFO = {
+   'files' : [],
+   'curdir' : None,
+   'tpath' : None,
+   'dhome' : None,
+   'dsid' : None,
+   'dcnt' : 0,
+   'gcnt' : 0,
+   'fcnt' : 0,
+   'pcnt' : 0,
+   'pgrecs' : []
+}
+
+#
+# main function to run the application
+#
+def main():
+
+   PgDBI.view_dbinfo()
+   PgLOG.set_help_path(__file__)
+   PgLOG.PGLOG['LOGFILE'] = "rdals.log"   # set different log file
+   LINFO['curdir'] = get_real_path(os.getcwd())
+   argv = sys.argv[1:]
+   PgLOG.pglog("rdals {} ({})".format(' '.join(argv), LINFO['curdir']))
+   option = defopt = 'l'
+   for arg in argv:
+      if re.match(r'-(h|-*help|\?)$', arg): PgLOG.show_usage("rdals")
+      ms = re.match(r'-(\w)$', arg)
+      if ms:
+         option = ms.group(1)
+         if option not in RDALS: PgLOG.pglog(arg + ": Unknown Option", PgLOG.LGEREX)
+         if 'dfNr'.find(option) > -1:
+            RDALS[option] = 1
+            option = defopt
+         continue
+      if not option: PgLOG.pglog(arg + ": Value provided without option", PgLOG.LGEREX)
+      if option == 'l':
+         LINFO['files'].append(get_real_path(arg))
+         defopt = None
+      else:
+         if option == 'R':
+            RDALS[option] = int(arg)
+         else:
+            RDALS[option] = arg
+         option = defopt
+   
+   if not LINFO['files']:
+      LINFO['files'] = sorted(glob.glob('*'))   # view all files in current directory
+      if not LINFO['files']:
+         sys.stderr.write(LINFO['curdir'] + ": Empty directory\n")
+         PgLOG.pgexit(1)
+
+   if not (RDALS['d'] or RDALS['f']):
+      RDALS['d'] = RDALS['f'] = 1   # list both directories and files as default
+   if not RDALS['D']: RDALS['D'] = '|' if RDALS['N'] else "  "    # default delimiter for no format display
+   if not RDALS['R'] and RDALS['r']: RDALS['R'] = 1000
+
+   display_top_list(LINFO['files'])   # display or cache file/directory list
+   if LINFO['pcnt'] > 0: display_format_list()   # if some left over
+
+   if (LINFO['dcnt'] + LINFO['gcnt'] + LINFO['fcnt']) > 1:
+      msg = ''
+      if LINFO['dcnt'] > 0:
+         s = 's' if LINFO['dcnt'] > 1 else ''
+         msg += "{} Dataset{}".format(LINFO['dcnt'], s)
+      if LINFO['gcnt'] > 0:
+         s = 's' if LINFO['gcnt'] > 1 else ''
+         if msg: msg += " & "
+         msg += "{} Group{}".format(LINFO['gcnt'], s)
+      if LINFO['fcnt'] > 0:
+         s = 's' if LINFO['fcnt'] > 1 else ''
+         if msg: msg += " & "
+         msg += "{} File{}".format(LINFO['fcnt'], s)
+      print("Total {} displayed".format(msg))
+   elif (LINFO['dcnt'] + LINFO['gcnt'] + LINFO['fcnt']) == 0:
+      sys.stderr.write((LINFO['tpath'] if LINFO['tpath'] else LINFO['curdir']) + ": No RDA data information found\n")
+      PgLOG.pgexit(1)
+   
+   PgLOG.pgexit(0)
+
+#
+# display the top level list
+#
+def display_top_list(files):
+
+   for file in files:
+
+      if not op.exists(file):
+         sys.stderr.write(file + ": NOT exists\n")
+         continue
+
+      isdir = 1 if op.isdir(file) else 0
+      display = 1
+      if isdir and re.search(r'/$', file):
+         display = 0   # do not display the directory info if it is ended by '/'
+         file = re.sub(r'/$', '', file)
+
+      if not re.match(r'^/', file): file = PgLOG.join_paths(LINFO['curdir'], file)
+      LINFO['tpath'] = (op.dirname(file) if display else file) + "/"
+      if display: display_line(file, isdir)
+      if isdir and (RDALS['R'] or not display or not LINFO['dsid']):
+         fs = sorted(glob.glob(file + "/*"))
+         display_list(fs, 1)
+         if LINFO['pcnt'] > CLMT: display_format_list()
+
+#
+# recursively display directory/file info
+#
+def display_list(files, level):
+
+   for file in files:
+      isdir = 1 if op.isdir(file) else 0
+      display_line(file, isdir)
+      if isdir and level < RDALS['R']:
+         fs = sorted(glob.glob(file + "/*"))
+         display_list(fs, level+1)
+         if LINFO['pcnt'] > CLMT: display_format_list()
+
+#
+# find dataset/group info; display or cache file
+#
+def display_line(file, isdir):
+   
+   getwfile = 1
+   if LINFO['dsid'] and LINFO['dhome']:
+      ms = re.match(r'^{}/(.*)$'.format(LINFO['dhome']), file)
+      if ms:
+         wfile = ms.group(1)
+         getwfile = 0
+   if getwfile:
+      LINFO['dsid'] = PgUtil.find_dataset_id(file, logact = PgLOG.LOGWRN)
+      if LINFO['dsid'] == None: return     # skip for missing dsid
+
+      pgrec = PgDBI.pgget("dataset", "title, (dwebcnt + nwebcnt) nc, (dweb_size + nweb_size) ns", "dsid = '{}'".format(LINFO['dsid']), PgLOG.LGEREX)
+      if not pgrec: return None
+
+      LINFO['dhome'] = "{}/{}".format(PgLOG.PGLOG['DSDHOME'], LINFO['dsid'])
+      if LINFO['dhome'] == file:
+         file = re.sub(r'^{}'.format(LINFO['tpath']), '', file, 1)
+         if RDALS['d']:
+            title = pgrec['title'] if pgrec['title'] else ''
+            display_record(["D" + file, pgrec['ns'], str(pgrec['nc']), title])
+         LINFO['dcnt'] += 1
+         return
+
+      ms = re.match(r'^{}/(.*)$'.format(LINFO['dhome']), file)
+      if ms:
+         wfile = ms.group(1)
+      else:
+         return
+
+   if isdir:
+      if RDALS['d']:   # check and display group info for directory
+         pgrec = PgDBI.pgget("dsgroup", "title, (dwebcnt + nwebcnt) nc, (dweb_size + nweb_size) ns",
+                             "dsid = '{}' AND webpath = '{}'".format(LINFO['dsid'], wfile), PgLOG.LGEREX)
+         if pgrec:
+            file = re.sub(r'^{}'.format(LINFO['tpath']), '', file, 1)
+            title = pgrec['title'] if pgrec['title'] else ''
+            display_record(["G" + file, pgrec['ns'], str(pgrec['nc']), title])
+            LINFO['gcnt'] += 1
+
+   elif RDALS['f']:   # check and display file info
+      pgrec = PgSplit.pgget_wfile(LINFO['dsid'], "data_size, data_format, note",
+                          "wfile = '{}'".format(wfile), PgLOG.LGEREX)
+      if pgrec:
+         if pgrec['note']:
+            note = re.sub(r'\n', ' ', pgrec['note'])   # remove '\n' in note
+         else:
+            note = ''
+         file = re.sub(r'^{}'.format(LINFO['tpath']), '', file, 1)
+         display_record(["F" + file, pgrec['data_size'], pgrec['data_format'], note])
+         LINFO['fcnt'] += 1
+
+#
+# display one file info
+#
+def display_record(disp):
+
+   disp[1] = get_float_string(disp[1])
+   if RDALS['N']:
+      print(RDALS['D'].join(disp))
+   else:
+      LINFO['pgrecs'].append(disp)
+      LINFO['pcnt'] += 1
+      for i in range(DIDX):
+         dlen = len(disp[i])
+         if dlen > WIDTHS[i]: WIDTHS[i] = dlen
+
+#
+# display cached list with format
+#
+def display_format_list():
+
+   for j in range(LINFO['pcnt']):
+      disp = LINFO['pgrecs'][j]
+      for i in range(DIDX):
+         if ALIGNS[i] == 1:
+            disp[i] = "{:>{}}".format(disp[i], WIDTHS[i])
+         else:
+            disp[i] = "{:{}}".format(disp[i], WIDTHS[i])
+      print(RDALS['D'].join(disp))
+
+   LINFO['pcnt'] = 0
+
+#
+# change size to floating point value with unit
+#
+def get_float_string(val):
+
+   units = ['B', 'K', 'M', 'G', 'T', 'P']
+
+   idx = 0
+   while val > 1000 and idx < 5:
+      val /= 1000
+      idx += 1
+
+   if idx > 0:
+      return "{:.2f}{}".format(val, units[idx])
+   else:
+      return "{}{}".format(val, units[idx])
+
+#
+# replace /glade to the real path /gpfs
+#
+def get_real_path(path):
+
+   if re.match(r'^/gpfs/u', path):
+      path = re.sub(r'^/gpfs', '/glade', path, 1)
+   elif re.match(r'^/gpfs/csfs1/', path):
+      path = re.sub(r'^/gpfs/csfs1', '/glade/campaign', path, 1)
+
+   return path
+
+#
+# call main() to start program
+#
+if __name__ == "__main__": main()