rda-python-miscs 3.0.1__py3-none-any.whl → 3.0.3__py3-none-any.whl

rda_python_miscs/{rdacp.py → gdexcp.py}

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 ##################################################################################
-#     Title: rdacp
+#     Title: gdexcp
 #    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: copy files locally and remotely by 'rdadata'
+#   Purpose: copy files locally and remotely by 'gdexdata'
 #    Github: https://github.com/NCAR/rda-python-miscs.git
 ##################################################################################
 import re
@@ -14,16 +14,16 @@ import sys
 from os import path as op
 from rda_python_common.pg_file import PgFile
 
-class RdaCp(PgFile):
-   """Copy files and directories locally or between remote hosts via 'rdadata'.
+class GdexCp(PgFile):
+   """Copy files and directories locally or between remote hosts via 'gdexdata'.
 
    Supports local-to-local, local-to-remote, remote-to-local, and Object Store /
-   Globus transfers.  Target files are owned by 'rdadata' and created with
+   Globus transfers.  Target files are owned by 'gdexdata' and created with
    configurable permission modes.  Recursive copying is controlled by -r / -R.
    """
 
    def __init__(self):
-      """Initialize RdaCp with default copy options and runtime state."""
+      """Initialize GdexCp with default copy options and runtime state."""
       super().__init__()
       self.RDACP = {
          'fh': None,   # from host name, default to localhost
@@ -33,15 +33,21 @@ class RdaCp(PgFile):
          'fp': None,   # from Globus endpoint
          'tp': None,   # to Globus endpoint
          'f': [],      # from file names
+         'i': None,    # input file holding a list of from file names, one per line
          't': None,    # to file name
          'r': 0,       # 1 if recursive all
          'R': 0,       # > 0 to set recursive limit
+         'o': 0,       # 1 to force a downloaded file owned by COMMONUSER; needs -fp
+         'O': 0,       # 1 to override an existing target file of the same size
+         'm': 1,       # number of multiple processes to copy files in parallel
+         'd': 0,       # 1 to add a dscheck record for delayed PBS batch process
          'F': 0o664,   # to file mode, default to 664
          'D': 0o775,   # to directory mode, default to 775
       }
       self.CINFO = {
          'tcnt': 0,
          'htcnt': 0,
+         'pcnt': 0,      # count of dispatched child processes for option -m
          'cpflag': 0,    # 1 file only, 2 directory only, 3 both
          'cpstr': ['', 'Files', 'Directories', 'Files/Directories'],
          'fpath': None,
@@ -64,8 +70,8 @@ class RdaCp(PgFile):
       argv = sys.argv[1:]
       self.set_suid(self.PGLOG['EUID'])
       self.set_help_path(__file__)
-      self.PGLOG['LOGFILE'] = "rdacp.log"   # set different log file
-      self.cmdlog("rdacp {} ({})".format(' '.join(argv), self.CINFO['curdir']))
+      self.PGLOG['LOGFILE'] = "gdexcp.log"   # set different log file
+      self.cmdlog("gdexcp {} ({})".format(' '.join(argv), self.CINFO['curdir']))
       defopt = option = 'f'
       for arg in argv:
          if re.match(r'-(h|-help)$', arg, re.I):
@@ -75,8 +81,8 @@ class RdaCp(PgFile):
          if ms:
             option = ms.group(1)
             if option not in self.RDACP: self.pglog(arg + ": Unknown Option", self.LGEREX)
-            if option == 'r':
-               self.RDACP['r'] = 1
+            if option in ('r', 'o', 'd', 'O'):
+               self.RDACP[option] = 1
                option = None
             continue
          if not option: self.pglog(arg + ": Value provided without option", self.LGEREX)
@@ -84,7 +90,7 @@ class RdaCp(PgFile):
             self.RDACP['f'].append(arg)
             defopt = None
          else:
-            if option == 'R':
+            if option in ('R', 'm'):
                self.RDACP[option] = int(arg)
             elif option in 'FD':
                self.RDACP[option] = self.base2int(arg, 8)
@@ -95,8 +101,29 @@ class RdaCp(PgFile):
                elif option == 'fh':
                   self.CINFO['fhost'] = arg + '-'
             option = defopt
-      if dohelp or not self.RDACP['f']: self.show_usage("rdacp")
-   
+      if self.RDACP['i']: self.add_input_files(self.RDACP['i'])
+      if dohelp or not self.RDACP['f']: self.show_usage("gdexcp")
+
+   # read source paths from an input file and append them to the -f list
+   def add_input_files(self, infile):
+      """Append source paths read from an input file to the -f source list.
+
+      Each non-empty line in the input file is treated as one source path;
+      leading/trailing whitespace is stripped and lines starting with '#' are
+      ignored as comments.
+
+      Args:
+         infile (str): Path to the input file holding one source path per line.
+      """
+      finfo = self.check_local_file(infile, 0, self.LGWNEX)
+      if not finfo: self.pglog("{}: Input file of -i not found".format(infile), self.LGEREX)
+      fd = open(infile, 'r')
+      for line in fd:
+         line = line.strip()
+         if not line or line[0] == '#': continue
+         self.RDACP['f'].append(line)
+      fd.close()
+
    # function to start actions
    def start_actions(self):
       """Validate copy targets, configure host/bucket/endpoint context, and dispatch copies.
@@ -106,7 +133,7 @@ class RdaCp(PgFile):
       when specified, then calls copy_top_list.  Logs a summary count on completion.
       """
       self.dssdb_dbname()
-      self.validate_decs_group('rdacp', self.PGLOG['CURUID'], 1)
+      self.validate_decs_group('gdexcp', self.PGLOG['CURUID'], 1)
       if not self.RDACP['R'] and self.RDACP['r']: self.RDACP['R'] = 1000
       if not self.RDACP['t']:
          self.CINFO['tpath'] = self.RDACP['t'] = "."
@@ -132,7 +159,23 @@ class RdaCp(PgFile):
          self.PGLOG['BACKUPEP'] = self.RDACP['fp']
       elif self.RDACP['tp']:
          self.PGLOG['BACKUPEP'] = self.RDACP['tp']
+      if self.RDACP['o']:
+         if not self.RDACP['fp']:
+            self.pglog("-o: works only when source Globus endpoint -fp is provided", self.LGEREX)
+         if self.RDACP['th'] or self.RDACP['tp'] or self.RDACP['tb']:
+            self.pglog("-o: works only for downloading to local files (no -th/-tp/-tb)", self.LGEREX)
+      if self.RDACP['m'] < 1: self.RDACP['m'] = 1
+      if self.RDACP['m'] > 16:
+         self.pglog("-m {}: process count too large, capped at 16".format(self.RDACP['m']), self.LOGWRN)
+         self.RDACP['m'] = 16
+      if self.RDACP['d']:
+         self.add_delayed_check()
+         self.cmdlog()
+         return
+      if self.RDACP['m'] > 1:
+         self.start_none_daemon('gdexcp', '', self.PGLOG['CURUID'], self.RDACP['m'], 120)
       self.copy_top_list(self.RDACP['f'])
+      if self.RDACP['m'] > 1: self.check_child(None, 0, self.LOGWRN, 1)
       hinfo = ''
       if self.RDACP['fh']: hinfo += " From " + self.RDACP['fh']
       if self.RDACP['th']: hinfo += " To " + self.RDACP['th']
@@ -175,7 +218,7 @@ class RdaCp(PgFile):
          if not re.match(r'^/', file): file = self.join_paths(self.CINFO['curdir'], file)
          self.CINFO['fpath'] = (file if dosub else op.dirname(file)) + "/"
          if info['isfile']:
-            self.CINFO['tcnt'] += self.copy_file(file, info['isfile'])
+            self.CINFO['tcnt'] += self.dispatch_copy(file, info)
          elif dosub or self.RDACP['R']:
             flist = self.gdex_glob(file, self.RDACP['fh'], 0, self.LGWNEX)
             if flist: self.copy_list(flist, 1, file)
@@ -197,7 +240,7 @@ class RdaCp(PgFile):
       fcnt = 0
       for file in tlist:
          if tlist[file]['isfile']:
-            fcnt += self.copy_file(file, tlist[file]['isfile'])
+            fcnt += self.dispatch_copy(file, tlist[file])
             self.CINFO['cpflag'] |= (1 if tlist[file]['isfile'] else 2)
          elif level < self.RDACP['R']:
             flist = self.gdex_glob(file, self.RDACP['fh'], 0, self.LGWNEX)
@@ -206,20 +249,50 @@ class RdaCp(PgFile):
          self.pglog("{}{}: {} {} copied from directory".format(self.CINFO['fhost'], cdir, fcnt, self.CINFO['cpstr'][self.CINFO['cpflag']]), self.LOGWRN)
       self.CINFO['tcnt'] += fcnt
    
+   # copy one file, forking a child process when running with option -m
+   def dispatch_copy(self, fromfile, finfo):
+      """Copy one file, dispatching the copy to a child process when -m > 1.
+
+      With a single process (-m 1) the file is copied in line.  With multiple
+      processes the copy is forked to a child via the PgSIG process pool (up to
+      RDACP['m'] children run concurrently); the parent records one dispatched
+      file and continues traversing, while each child performs the copy, logs
+      its own result, and exits.
+
+      Args:
+         fromfile (str): Absolute source file path.
+         finfo (dict): Source file-info dict (with 'isfile' and 'data_size').
+
+      Returns:
+         int: 1 if the file was copied (single process) or dispatched to a
+            child process (-m > 1), 0 otherwise.
+      """
+      if self.RDACP['m'] < 2: return self.copy_file(fromfile, finfo)
+      stat = self.start_child("gdexcp_{}".format(self.CINFO['pcnt']), self.LOGWRN, 1)
+      if stat <= 0: self.pglog("{}: cannot start child process to copy".format(fromfile), self.LGEREX)
+      if self.PGSIG['PPID'] > 1:   # in child process
+         self.copy_file(fromfile, finfo)
+         sys.exit(0)
+      self.CINFO['pcnt'] += 1   # in parent process; child already dropped its DB link
+      return 1
+
    # copy one file
-   def copy_file(self, fromfile, isfile):
+   def copy_file(self, fromfile, finfo):
       """Resolve the destination path for one source file and perform the copy.
 
       When a target directory is set (tpath), strips the source base path prefix
       and joins the remainder to tpath.  Otherwise copies directly to the -t value.
+      Skips the copy when the target already exists with the same size as the
+      source, unless -O is given to override an existing same-size target.
 
       Args:
          fromfile (str): Absolute source file path.
-         isfile (int): Non-zero when the source is a regular file (vs. a symlink type).
+         finfo (dict): Source file-info dict (with 'isfile' and 'data_size').
 
       Returns:
          int: 1 if the file was copied successfully, 0 otherwise.
       """
+      isfile = finfo['isfile']
       if self.CINFO['tpath']:
          fname = re.sub(r'^{}'.format(self.CINFO['fpath']), '', fromfile)
          if isfile:
@@ -228,14 +301,84 @@ class RdaCp(PgFile):
             tofile = self.CINFO['tpath'] + '/'
       else:
          tofile = self.RDACP['t']
-      return (1 if self.copy_gdex_file(tofile, fromfile, self.RDACP['th'], self.RDACP['fh'], self.LGWNEX) else 0)
+      if isfile and not self.RDACP['O']:
+         tinfo = self.check_gdex_file(tofile, self.RDACP['th'], 0, self.LGWNEX)
+         if tinfo and tinfo['data_size'] == finfo['data_size']:
+            self.pglog("{}{}: Target exists with same size, skip copying".format(self.CINFO['thost'], tofile), self.LOGWRN)
+            return 0
+      if self.RDACP['o']: return self.force_owner_copy(tofile, fromfile)
+      logact = self.LGWNEX | (self.OVRIDE if self.RDACP['O'] else 0)
+      return (1 if self.copy_gdex_file(tofile, fromfile, self.RDACP['th'], self.RDACP['fh'], logact) else 0)
+
+   # copy one file from a Globus endpoint and force COMMONUSER ownership
+   def force_owner_copy(self, tofile, fromfile):
+      """Download a Globus file via a tmp file so the final copy is owned by COMMONUSER.
+
+      A Globus endpoint dumps the local file owned by the endpoint's mapped user
+      rather than COMMONUSER ('gdexdata').  This downloads to a tmp file under
+      PGLOG['TMPPATH'], makes it group readable/writable as its owner via the
+      pgstart_<user> setuid wrapper, then copies it locally so the final file is
+      owned by COMMONUSER, and removes the tmp file.
+
+      Args:
+         tofile (str): Final local destination path.
+         fromfile (str): Source file path on the Globus endpoint.
+
+      Returns:
+         int: 1 if the file was copied successfully, 0 otherwise.
+      """
+      tmpfile = self.join_paths(self.PGLOG['TMPPATH'], "{}.{}".format(op.basename(fromfile), os.getpid()))
+      if not self.copy_gdex_file(tmpfile, fromfile, self.RDACP['th'], self.RDACP['fh'], self.LGWNEX): return 0
+      finfo = self.check_local_file(tmpfile, 2, self.LGWNEX)
+      owner = finfo['logname'] if finfo else None
+      if owner and owner != self.PGLOG['COMMONUSER']:
+         self.pgsystem(self.get_local_command("chmod g+rw " + tmpfile, owner), self.LGWNEX)
+      ret = self.copy_gdex_file(tofile, tmpfile, self.RDACP['th'], None, self.LGWNEX)
+      self.delete_local_file(tmpfile, self.LGWNEX)
+      return (1 if ret else 0)
+
+   # add a dscheck record so this gdexcp command runs later as a PBS batch job
+   def add_delayed_check(self):
+      """Queue this gdexcp invocation as a delayed PBS batch job via a dscheck record.
+
+      Records the current command (with the -d flag stripped so the batch run
+      performs the actual copy) into the RDADB dscheck table for the dscheck
+      daemon to later submit to PBS through bashqsub/tcshqsub.  The qsub resource
+      option always sets a 24 hour walltime; when -m > 1 it also reserves a single
+      node with (number of processes) cpus and 1gb of memory per cpu.
+      """
+      argv = [arg for arg in sys.argv[1:] if arg != '-d']
+      argstr = self.argv_to_string(argv, 1)
+      argextra = None
+      if len(argstr) > 100:
+         argextra = argstr[100:]
+         argstr = argstr[0:100]
+      record = {
+         'command': 'gdexcp',
+         'argv': argstr,
+         'specialist': self.PGLOG['CURUID'],
+         'workdir': self.CINFO['curdir'],
+         'oindex': 0,
+         'otype': '',
+         'action': None,
+         'dsid': None,
+         'mcount': 1,
+      }
+      (record['date'], record['time']) = self.get_date_time()
+      if argextra: record['argextra'] = argextra
+      qoptions = "-l walltime=24:00:00"
+      if self.RDACP['m'] > 1:
+         qoptions += ",select=1:ncpus={0}:mem={0}gb".format(self.RDACP['m'])
+      record['qoptions'] = qoptions
+      cidx = self.pgadd("dscheck", record, self.LGWNEX|self.AUTOID)
+      self.pglog("Chk{}: gdexcp {} added for delayed batch process".format(cidx, argstr), self.LOGWRN)
 
 # main function to execute this script
 def main():
-   """Entry point: instantiate RdaCp, parse arguments, run, and exit."""
+   """Entry point: instantiate GdexCp, parse arguments, run, and exit."""
    from rda_python_setuid.setup_guide import show_setup_guide
-   object = RdaCp()
-   show_setup_guide(object, 'rda_python_miscs', ['rdacp', 'rdakill', 'rdamod'])
+   object = GdexCp()
+   show_setup_guide(object, 'rda_python_miscs', ['gdexcp', 'gdexkill', 'gdexmod'])
    object.read_parameters()
    object.start_actions()
    object.pgexit(0)

rda_python_miscs/gdexcp.usg

@@ -0,0 +1,145 @@
+
+ Name: gdexcp - copy files and directories as user 'gdexdata'
+
+ Copy files and directories to a target location.  The source and the target may
+ each reside on the local host, a remote host, an Object Store bucket, or a Globus
+ endpoint.  Target files are owned by 'gdexdata' and created with configurable
+ permission modes.
+
+ Usage: gdexcp [-f] FromDirectories/Files [-t ToDirectory/FileName]   \
+              [-i InputFile] [-m ProcessCount] [-d] [-r] [-R RecursiveLevel] \
+              [-fh FromHostName] [-th ToHostName]                     \
+              [-fb FromBucket] [-tb ToBucket]                         \
+              [-fp FromGlobusEndpoint] [-tp ToGlobusEndpoint]         \
+              [-F FileMode] [-D DirectoryMode] [-o] [-O] [-h]
+
+   gdexcp can be run from any directory.  Usage is displayed when no source paths
+   are given.
+
+
+ SOURCE AND TARGET
+
+   -f  FromDirectories/Files
+          Source directories and/or files to copy.  This is the default option,
+          so paths may be given without the -f flag.  Shell wildcards are
+          supported; use './' or '*' to copy everything in the current directory.
+          A trailing '/' on a source directory path copies the contents of that
+          directory (as a file list) rather than the directory entry itself.
+          Source paths must be readable by user 'gdexdata'; gdexcp attempts to
+          fix the mode when they are not.
+
+   -i  InputFile
+          A file holding a list of source paths to copy, one path per line.
+          Blank lines and lines starting with '#' are ignored.  The paths read
+          are appended to the -f source list.
+
+   -t  ToDirectory/FileName
+          Target directory or file name.  Defaults to '.' (the current
+          directory).  A trailing '/' forces the target to be treated as a
+          directory.  Multiple source files cannot be copied to a single target
+          file name.
+
+
+ SOURCE/TARGET LOCATIONS (default to the local host)
+
+   -fh FromHostName     host name where the source files reside.
+   -th ToHostName       host name where the target files are written.
+   -fb FromBucket       Object Store bucket name for the source files.
+   -tb ToBucket         Object Store bucket name for the target files.
+   -fp FromGlobusEndpoint   Globus endpoint for the source files.
+   -tp ToGlobusEndpoint     Globus endpoint for the target files.
+
+
+ COPY BEHAVIOR
+
+   -r     Copy directories and files recursively, with no depth limit.
+
+   -R  RecursiveLevel
+          Copy recursively up to the given depth.  -R 1 copies only the
+          immediate contents of each source directory.
+
+   -m  ProcessCount
+          Number of processes used to copy files in parallel.  Defaults to 1.
+          When greater than 1, the source files are distributed across that many
+          concurrent child processes.  Capped at 16; a larger value is reduced to
+          16 with a warning.
+
+   -d     Add a dscheck record so this gdexcp command runs later as a delayed PBS
+          batch job (submitted by the dscheck daemon via bashqsub / tcshqsub).
+          The qsub resource always sets a 24 hour walltime; when -m is greater
+          than 1 it also reserves a single node with (ProcessCount) cpus and 1gb
+          of memory per cpu.
+
+   -o     Force a downloaded file to be owned by 'gdexdata'.  A Globus endpoint
+          writes the local file owned by the endpoint's mapped user; with -o the
+          file is downloaded to a tmp file, then copied locally so the final file
+          is owned by 'gdexdata'.  Only valid together with -fp and for
+          downloading to local files (not with -th/-tp/-tb).
+
+   -O     Override an existing target.  By default a source file is skipped when
+          the target already exists with the same size; give -O to copy it anyway
+          and overwrite the existing target.
+
+
+ TARGET PERMISSIONS (octal notation)
+
+   -F  FileMode          permission mode for target files.       Defaults to 664.
+   -D  DirectoryMode     permission mode for target directories. Defaults to 775.
+
+
+ MISCELLANEOUS
+
+   -h     Display this help document.
+
+
+ NOTES
+
+   - A trailing '/' on a source directory path copies the contents of that
+     directory rather than the directory entry itself.
+   - By default an unchanged target (same size) is skipped; use -O to overwrite.
+   - If a Globus endpoint (-fp/-tp) is locally accessible, a direct local copy
+     (omitting -fp/-tp and giving the local path) is faster, avoiding the Globus
+     transfer overhead.
+   - A delayed batch job (-d) is given a 24 hour walltime.  Do not submit a single
+     batch job to copy too many files at once; if the copy cannot finish within 24
+     hours the job is killed.  Split a very large copy into multiple -d jobs (and/or
+     raise -m) so each one completes well within the walltime.
+
+
+ EXAMPLES
+
+   1. Copy all files and subdirectories under the current directory to a remote
+      host:
+
+         gdexcp -r -f * -t /PathTo/d277006/ -th castle
+
+   2. Copy the contents of a local directory to a remote location (trailing '/'
+      on the source omits the directory entry itself):
+
+         gdexcp -r -f /PathTo/DirectoryName/ -t /PathTo/d277006/ -th castle
+
+      Without the trailing '/', DirectoryName itself is also copied:
+
+         gdexcp -r -f /PathTo/DirectoryName -t /PathTo/d277006/ -th castle
+
+   3. Copy a single file to an Object Store bucket:
+
+         gdexcp -f /PathTo/myfile.nc -tb my-bucket -t myfile.nc
+
+   4. Copy files from a remote host to the local current directory:
+
+         gdexcp -fh castle -f /PathTo/d277006/myfile.nc
+
+   5. Download a file from a source Globus endpoint and force the local file to
+      be owned by 'gdexdata' (-o requires -fp):
+
+         gdexcp -fp gdex-quasar -f /d277006/myfile.nc -t /PathTo/myfile.nc -o
+
+   6. Copy the source paths listed in an input file using 4 parallel processes:
+
+         gdexcp -i filelist.txt -t /PathTo/d277006/ -m 4
+
+   7. Queue a delayed PBS batch job to copy a directory in parallel; the dscheck
+      daemon submits it later, reserving one node with 4 cpus and 4gb of memory:
+
+         gdexcp -r -f /PathTo/DirectoryName/ -t /PathTo/d277006/ -m 4 -d

rda_python_miscs/{rdakill.py → gdexkill.py}

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
 ##################################################################################
-#     Title: rdakill
+#     Title: gdexkill
 #    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'
+#            running process ID by 'gdexdata'
 #    Github: https://github.com/NCAR/rda-python-miscs.git
 ##################################################################################
 import re
@@ -14,7 +14,7 @@ import sys
 import time
 from rda_python_common.pg_file import PgFile
 
-class RdaKill(PgFile):
+class GdexKill(PgFile):
    """Kill local processes or PBS batch jobs by process ID, parent PID, or status.
 
    For local processes, sends SIGKILL (-9) to the matched process and all its
@@ -24,7 +24,7 @@ class RdaKill(PgFile):
    """
 
    def __init__(self):
-      """Initialize RdaKill with default kill options."""
+      """Initialize GdexKill with default kill options."""
       super().__init__()
       self.RDAKILL = {
          'a': None,    # application name
@@ -52,8 +52,8 @@ class RdaKill(PgFile):
       self.dssdb_dbname()
       self.set_suid(self.PGLOG['EUID'])
       self.set_help_path(__file__)
-      self.PGLOG['LOGFILE'] = "rdakill.log"   # set different log file
-      self.cmdlog("rdakill {}".format(' '.join(argv)))
+      self.PGLOG['LOGFILE'] = "gdexkill.log"   # set different log file
+      self.cmdlog("gdexkill {}".format(' '.join(argv)))
       for arg in argv:
          ms = re.match(r'-([ahpPqsu])$', arg)
          if ms:
@@ -79,7 +79,7 @@ class RdaKill(PgFile):
                optcnt += 1
             else:
                self.pglog(arg + ": pass in value without Option", self.LGEREX)
-      if not optcnt: self.show_usage("rdakill")
+      if not optcnt: self.show_usage("gdexkill")
    
    # function to start actions
    def start_actions(self):
@@ -257,10 +257,10 @@ class RdaKill(PgFile):
 
 # main function to execute this script
 def main():
-   """Entry point: instantiate RdaKill, parse arguments, run, and exit."""
+   """Entry point: instantiate GdexKill, parse arguments, run, and exit."""
    from rda_python_setuid.setup_guide import show_setup_guide
-   object = RdaKill()
-   show_setup_guide(object, 'rda_python_miscs', ['rdacp', 'rdakill', 'rdamod'])
+   object = GdexKill()
+   show_setup_guide(object, 'rda_python_miscs', ['gdexcp', 'gdexkill', 'gdexmod'])
    object.read_parameters()
    object.start_actions()
    object.pgexit(0)

rda_python_miscs/{rdakill.usg → gdexkill.usg}

@@ -3,7 +3,7 @@
  other filter criteria; or cancel one or more PBS batch jobs by job ID or by
  job status.  For PBS operations the -h option must specify the PBS node name.
 
- Usage: rdakill [-h HostName] [-p ProcessID] [-P ParentProcessID]  \
+ Usage: gdexkill [-h HostName] [-p ProcessID] [-P ParentProcessID]  \
                 [-s BatchStatus] [-q BatchQueue] [-r]               \
                 [-u ProcessOwner] [-a ApplicationName]
 
@@ -36,31 +36,31 @@
           Without this option all users are included;
 
   For local processes, all child processes are also terminated recursively.
-  Usage is displayed if rdakill is run without any options or arguments.
+  Usage is displayed if gdexkill is run without any options or arguments.
 
   Examples:
 
     1. Kill a local process by PID:
 
-          rdakill -p 13199
-          rdakill 13199
+          gdexkill -p 13199
+          gdexkill 13199
 
     2. Kill a local process by PID and verify it matches a specific application:
 
-          rdakill -p 13199 -a dsrqst
+          gdexkill -p 13199 -a dsrqst
 
     3. Kill all local processes (and their children) owned by a user:
 
-          rdakill -u zji -a dsrqst
+          gdexkill -u zji -a dsrqst
 
     4. Kill a PBS batch job by job ID:
 
-          rdakill -h casper-pbs -p 334323
+          gdexkill -h casper-pbs -p 334323
 
     5. Kill all running PBS batch jobs for a user in the default queue:
 
-          rdakill -h casper-pbs -s RUN -u zji
+          gdexkill -h casper-pbs -s RUN -u zji
 
     6. Kill all pending PBS batch jobs in a specific queue:
 
-          rdakill -h casper-pbs -s PEND -q gdex
+          gdexkill -h casper-pbs -s PEND -q gdex

rda_python_miscs/{rdamod.py → gdexmod.py}

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
 ##################################################################################
-#     Title: rdamod
+#     Title: gdexmod
 #    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: change file/directory modes in given one or multiple local directories
-#            owned by 'rdadata'
+#            owned by 'gdexdata'
 #    Github: https://github.com/NCAR/rda-python-miscs.git
 ##################################################################################
 import re
@@ -15,17 +15,17 @@ import sys
 from os import path as op
 from rda_python_common.pg_file import PgFile
 
-class RdaMod(PgFile):
-   """Change file and directory permission modes for paths owned by 'rdadata'.
+class GdexMod(PgFile):
+   """Change file and directory permission modes for paths owned by 'gdexdata'.
 
-   Only items owned by 'rdadata' are changed; items with a different owner are
+   Only items owned by 'gdexdata' are changed; items with a different owner are
    logged as errors.  Items already at the target mode are silently skipped.
    A leading letter ('D' or 'F') is logged with each changed path to indicate
    its type.
    """
 
    def __init__(self):
-      """Initialize RdaMod with default mode-change options and runtime state."""
+      """Initialize GdexMod with default mode-change options and runtime state."""
       super().__init__()
       self.RDAMOD = {
          'd': 0,     # 1 to change directory mode
@@ -55,9 +55,9 @@ class RdaMod(PgFile):
       """
       self.set_suid(self.PGLOG['EUID'])
       self.set_help_path(__file__)
-      self.PGLOG['LOGFILE'] = "rdamod.log"   # set different log file
+      self.PGLOG['LOGFILE'] = "gdexmod.log"   # set different log file
       argv = sys.argv[1:]
-      self.cmdlog("rdamod {} ({})".format(' '.join(argv), self.MINFO['curdir']))
+      self.cmdlog("gdexmod {} ({})".format(' '.join(argv), self.MINFO['curdir']))
       option = defopt = 'l'
       for arg in argv:
          ms = re.match(r'-(\w)$', arg)
@@ -80,7 +80,7 @@ class RdaMod(PgFile):
             else:
                self.RDAMOD[option] = arg
             option = defopt
-      if self.RDAMOD['h'] or not self.MINFO['files']: self.show_usage("rdamod")
+      if self.RDAMOD['h'] or not self.MINFO['files']: self.show_usage("gdexmod")
 
    # function to start actions
    def start_actions(self):
@@ -89,7 +89,7 @@ class RdaMod(PgFile):
       if not (self.RDAMOD['d'] or self.RDAMOD['f']):
          self.RDAMOD['d'] = self.RDAMOD['f'] = 1   # both directories and files as default
       if not self.RDAMOD['R'] and self.RDAMOD['r']: self.RDAMOD['R'] = 1000
-      self.validate_decs_group('rdamod', self.PGLOG['CURUID'], 1)   
+      self.validate_decs_group('gdexmod', self.PGLOG['CURUID'], 1)
       self.change_top_list(self.MINFO['files'])
       if (self.MINFO['dcnt'] + self.MINFO['fcnt']) > 1:
          msg = ''
@@ -159,7 +159,7 @@ class RdaMod(PgFile):
       """Change the permission mode of one file or directory.
 
       Skips the item if the -f/-d flag for its type is not set, if it is not
-      owned by 'rdadata', or if its current mode already matches the target.
+      owned by 'gdexdata', or if its current mode already matches the target.
       Logs the old-to-new mode transition on success or an error on owner mismatch.
       Updates MINFO['fcnt'] for files and MINFO['dcnt'] for directories on success.
 
@@ -180,8 +180,8 @@ class RdaMod(PgFile):
          if not self.RDAMOD['d']: return 0
          fname = "D" + fname
          mode = self.RDAMOD['D']
-      if info['logname'] != "rdadata":
-         return self.pglog("{}: owner {} not rdadata".format(fname, info['logname']), self.LOGERR)
+      if info['logname'] != "gdexdata":
+         return self.pglog("{}: owner {} not gdexdata".format(fname, info['logname']), self.LOGERR)
       if info['mode'] == mode: return 0   # no need change mode
       if self.set_local_mode(file, info['isfile'], mode, info['mode'], info['logname'], self.LOGWRN):
          if info['isfile']:
@@ -193,10 +193,10 @@ class RdaMod(PgFile):
 
 # main function to execute this script
 def main():
-   """Entry point: instantiate RdaMod, parse arguments, run, and exit."""
+   """Entry point: instantiate GdexMod, parse arguments, run, and exit."""
    from rda_python_setuid.setup_guide import show_setup_guide
-   object = RdaMod()
-   show_setup_guide(object, 'rda_python_miscs', ['rdacp', 'rdakill', 'rdamod'])
+   object = GdexMod()
+   show_setup_guide(object, 'rda_python_miscs', ['gdexcp', 'gdexkill', 'gdexmod'])
    object.read_parameters()
    object.start_actions()
    object.pgexit(0)