fileTools.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
# package fileTools.py
#
# This package creates an interface to the LAT filesystem from LICOS.
#
# Error tolerant APIs are provided to do the following
#    Upload a file
#    Download a file
#    Delete a file
#    List a directory
#    Create a directory
#    Delete a directory ( opt: also all files in it)


__facility__ = "Online"
__abstract__ = "File tools for ScriptEngine classes"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/11/1 00:08:27"
__updated__  = "$Date: 2006/04/27 02:06:03 $"
__version__  = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from LICOS.lib.cmdTlmDb.LCATcmdDb      import LCATcmdDb
from LICOS.lib.cmdTlmDb.LCATtlmDb      import LCATtlmDb
from LICOS.lib.cmdTlmDb.TelemetryEvent import TelemetryEvent
from LICOS.lib.LATfunctions            import utcfromtimestamp

import array
import logging as log
import os
import struct
import tempfile
import time


# enums from FILE traveler document
FSW_DEVICE_BOOT  = 0  # Boot device
FSW_DEVICE_RAM   = 1  # RAM disk
FSW_DEVICE_EE0   = 2  # SIB EEPROM partition 0
FSW_DEVICE_EE1   = 3  # SIB EEPROM partition 1
FSW_DEVICE_TMP   = 4  # Host temp file system
FSW_DEVICE_USR0  = 5  # User-defined device 0
FSW_DEVICE_USR1  = 6  # User-defined device 1
FSW_DEVICE_NAMES = ["boot", "ram", "ee0", "ee1", "tmp", "usr0", "usr1"  ]

FSW_UNIT_SIU     = 0
FSW_UNIT_EPU0    = 1
FSW_UNIT_EPU1    = 2
FSW_UNIT_EPU2    = 3
FSW_UNIT_EPU3    = 4
FSW_UNIT_NAMES = [ 'SIU ', 'EPU0', 'EPU1', 'EPU2', 'EPU3' ]

# As per verbal agreement with Tony Waite (051108) INT can have
#   directories 8-15 for it's own use.  Note:  Any directory > 15
#   needs to be created
INT_DIR_LATC     = 10
INT_DIR_LCI      = 11

FILETOOL_STANDARD_TIMEOUT = 60    # seconds

# Define our tempfile paths for consistency
if os.name == 'posix':
  FILETOOL_TMP_PATH = "/tmp"
else:   # gotta be windows...
  FILETOOL_TMP_PATH = os.path.normpath(os.path.join('C:/', 'TEMP'))

# executables to add FMX headers and compression to binary uploads
if os.name == 'posix':
  FILETOOL_HDR_ALLOW = True
  FSW_ADD_HEADER_CMD = 'file_hdr_prefix'     # flight/SVC/symlnk/linux-gcc/exe/zcompress
  FSW_COMPRESS_CMD   = 'zcompress'           # flight/SVC/symlnk/linux-gcc/exe/file_hdr_prefix
else:
  FILETOOL_HDR_ALLOW = False                 # do NOT allow addition of fsw headers from Windows
  FSW_ADD_HEADER_CMD = None
  FSW_COMPRESS_CMD   = None

# hook for keeping track of an arbitrary file number (last part of a FswFileID)
FILETOOL_ARBITRARY_FILENUMBER  = 0
# hook for keeping track of an arbitrary FMX key  (not to be used with real FMX)
FILETOOL_ARBITRARY_FMXID       = 0x20000000L


def arbitraryFileID(seed=None):
  """!\brief Retrieve a semi-arbitrary FSW file Number to be used as input for FswFileID()

  \return  an integer
  """
  global FILETOOL_ARBITRARY_FILENUMBER
  if seed is not None:
    FILETOOL_ARBITRARY_FILENUMBER = seed
  # there is a max filenumber
  if FILETOOL_ARBITRARY_FILENUMBER > FswFileID.MASK_FILENUM:
    FILETOOL_ARBITRARY_FILENUMBER = 0
  id = FILETOOL_ARBITRARY_FILENUMBER
  FILETOOL_ARBITRARY_FILENUMBER += 1
  return id

def arbitraryFmxID(seed=None):
  """!\brief Retrieve a semi-arbitrary FMX id to be used in creating an FMX header on the fly

  \return  an integer
  """
  global FILETOOL_ARBITRARY_FMXID
  if seed is not None:
    FILETOOL_ARBITRARY_FMXID = seed
  id = FILETOOL_ARBITRARY_FMXID
  FILETOOL_ARBITRARY_FMXID += 1
  return id

class FswFile(object):
  """!\brief Functional interface to a generic file in FSW
  """
  def __init__(self, fid, bin, uploaded=False):
    """!\brief Constructor

    \param  fid       FswFileID for this file
    \param  bin       Raw binary representation of file
    \param  uploaded  True if file has been uploaded
    """
    self.__fid      = fid
    self.__bin      = bin
    self.__uploaded = False

  def fileID(self):
    """!\brief retrieve file ID

    \return a FswFileID object
    """
    return self.__fid

  def binary(self):
    """!\brief retrieve file data

    \return a raw binary string
    """
    return self.__bin

  def uploaded(self):
    """!\brief retrieve file upload status

    \return True if uploaded
    """
    return self.__uploaded

  def setUploaded(self, bool):
    """!\brief Set file upload status

    \param  bool True if file is uploaded
    """
    self.__uploaded = bool

  def write(self, stream):
    """!\brief write file to stream  (file descriptor)

    \param  stream  Any writable file descriptor
    """
    stream.write(self.__bin)
    stream.flush()    # because of buffering, string may not show up until flush() or close()

class FswFileFromData(FswFile):
  """!\brief A memory resident FSW file interface
  """
  def __init__(self, fileID, fileDat, uploaded=False):
    """!\brief Constructor

    \param fileID    FswFileID for this file
    \param fileDat   The file's raw data
    \param uploaded  True if file has been uploaded
    """
    try:
      FswFile.__init__(self, fileID, fileDat, uploaded)
    except:
      raise

class FswFileFromDisk(FswFile):
  """!\brief A disk resident FSW file interface
  """
  def __init__(self, fileID, fileName, uploaded=False):
    """!\brief Constructor

    \param fileID    FswFileID for this file
    \param fileName  A fully qualified file name to open
    \param uploaded  True if file has been uploaded
    """
    self.name = fileName
    try:
      self.file = open(fileName, 'rb')
      bin = self.file.read()


      FswFile.__init__(self, fileID, bin, uploaded)
    except Exception, e:
      raise

class FswFileID(object):
  """!\brief Define a Flight Software File ID

  Defines the FSW file id, as specified in the FILE FSW traveler document
  """
  MASK_DEVICE    = 0x7
  MASK_DIRECTORY = 0x7F
  MASK_FILENUM   = 0x3FFFFF
  SHFT_DEVICE    = 29
  SHFT_DIRECTORY = 22
  SHFT_FILENUM   =  0
  def __init__(self, *argv, **argd):
    """!\brief Polymorphic constructor

    Takes 1 or 3 arguments {fileID} or {device,directory,fileNumber}
    Arguments can be either named or not.  A mix of both named and unnamed
    args is verboten.

    \param fileID    A LAT file ID (32 bit packed)

    \param device      Device to store file to [0..7]
    \param directory   Directory to store file to [0..0x7F]
    \param fileNumber  File Number [0..0x3FFFFF]
    """
    if len(argv) == 1:
      self.__fid = argv[0]
    elif len(argv) == 3:
      self.__fid = self.__computeFileID(argv[0], argv[1], argv[2])
    elif len(argd) == 1:
      self.__fid = argd['fileID']
    elif len(argd) == 3:
      self.__fid = self.__computeFileID( argd['device'], argd['directory'], argd['fileNumber'] )
    else:
      raise SyntaxError( "Incorrect arguments for FswFileID constructor: argv=%s, argd=%d" % (str(argv), str(argd)) )

  def __computeFileID(self, device, directory, filNum):
    """!\brief Compute the 32 bit FSW destination from component parts
    """
    if device & self.MASK_DEVICE != device:
      raise "Selected device number 0x%x is greater than the maximum of 0x7" % device
    if directory & self.MASK_DIRECTORY != directory:
      raise "Selected directory number 0x%x is greater than the maximum of 0x7F" % directory
    if filNum & self.MASK_FILENUM != filNum:
      raise "Selected file number 0x%x is greater than the maximum of 0x3fffff" % filNum

    dest = (device    << self.SHFT_DEVICE) + \
           (directory << self.SHFT_DIRECTORY) + \
           (filNum    << self.SHFT_FILENUM)
    return dest

  def id(self):
    """!\brief retrieve file ID

    \return 32 bit file ID
    """
    return self.__fid

  def device(self):
    """!\brief retrieve device

    \return 3 bit device
    """
    return (self.__fid >> self.SHFT_DEVICE ) & self.MASK_DEVICE

  def directory(self):
    """!\brief retrieve file ID

    \return 7 bit directory
    """
    return (self.__fid >> self.SHFT_DIRECTORY ) & self.MASK_DIRECTORY

  def fileNumber(self):
    """!\brief retrieve file ID

    \return 22 bit file Number
    """
    return (self.__fid >> self.SHFT_FILENUM ) & self.MASK_FILENUM

  def __str__(self):
    return '/%s/d%03d/f%07d' % \
           ( FSW_DEVICE_NAMES[self.device()], self.directory(), self.fileNumber())


class FswDirectoryItem(object):
  """!\brief Representation of an item in an FSW directory

  REVISIT:  Make the members private and member functions?
  """
  __isdirTxt = [ '-', 'd' ]
  __roTxt    = [ 'w', '-' ]
  def __init__(self, fileID, ro, size, isdir, time, unit, blocks):
    """!\ Constructor

    \param fileID  A FswFileID object
    \param ro      file is ReadOnly flag (True/False)
    \param size    File size in bytes
    \param isdir   file is a directory flag  (True/False)
    \param time    File modification time in LAT epoch
    \param unit    File unit (i.e. FSW_UNIT_SIU)
    \param blocks  REVISIT::  file blocks, maybe unused?
    """
    self.id     = fileID
    self.ro     = ro
    self.size   = size
    self.isdir  = isdir
    self.time   = time
    self.unit   = unit
    self.blocks = blocks

  def dump(self, stream):
    """!\brief dump a directoryItem to a file descriptor.

    \param stream  Any file descriptor  (ie. sys.stdout)
    """
    msg = ""
    msg += self.__isdirTxt[self.isdir]
    msg += 'r'                            # always readable
    msg += self.__roTxt[self.ro]
    msg += ' %4s' % FSW_UNIT_NAMES[self.unit]
    msg += ' %10d' % self.size
    msg += ' %s' % utcfromtimestamp(int(self.time), 0).ctime()
    strid = str(self.id)
    if self.isdir: strid = strid[:-8]
    msg += ' %s' % strid
    print >> stream, msg


class FswDirectory(object):
  """!\brief Representation of a FSW directory

  """
  def __init__(self, dirID):
    """!\ Constructor

    \param dirID  A FswFileID object
    """
    self.__id = dirID
    self.__files = []

  def addItem(self, f):
    """!\brief Add a file to this representation

    \param f  An FswDirectoryItem
    """
    if f not in self.__files:
      self.__files.append(f)

  def files(self):
    """!\brief return a list of all files in this directory rep
    """
    return self.__files

  def id(self):
    """!\brief retrieve file ID

    \return a FswFileID object
    """
    return self.__id

  def setId(self, id):
    """!\brief set the ID for this directory

    \param id   A FswFileID object
    """
    self.__id = id

  def dump(self, stream):
    """!\brief dump a directory to a file descriptor

    \param stream  Any file descriptor  (ie. sys.stdout)
    """
    msg = '/%s/d%03d' % ( FSW_DEVICE_NAMES[self.id().device()], self.id().directory())
    print >> stream, msg
    for item in self.__files:
      item.dump(stream)

def addFmxHeader(inFile, doCompress=False, preCompressed=False, name=None,
                 type=None, key=None, timestamp=None):
  """!\brief Add an fmx header to a file.  compressing on the fly if requested

  \param  inFile         An FswFile object
  \param  doCompress     True/False  to compress on fly/not
  \param  preCompressed  True/False  if already compressed
  \param  name
  \param  type
  \param  key
  \param  timestamp

  \return An FswFile object with proper headers for upload
  """
  if not FILETOOL_HDR_ALLOW:
    raise RuntimeError('Adding an FMX header is not possible on non-unix systems')

  hdrCmd  = FSW_ADD_HEADER_CMD
  if hasattr(inFile, 'name'):  # passing a disk resident file
    rawFile = inFile
  else:
    rawFile  = tempfile.NamedTemporaryFile(mode='w+b')
    inFile.write(rawFile.file)
  hdrFile  = tempfile.NamedTemporaryFile(mode='w+b')


  if doCompress:
    # compress in tmpspace
    cmpFile  = tempfile.NamedTemporaryFile(mode='w+b')

    cmd  = FSW_COMPRESS_CMD
    cmd += ' %s' % rawFile.name
    cmd += ' %s' % cmpFile.name
    rc = os.system(cmd)
    rawFile = cmpFile
  if doCompress or preCompressed:
    hdrCmd += ' -c'

  # Various options for the header adding command
  if name is not None:
    hdrCmd += ' -n=%s' % name
  if type is not None:
    hdrCmd += ' -t=%s' % str(type)
  if key is not None:
    hdrCmd += ' -k=%s' % str(key)
  if timestamp is not None:
    hdrCmd += ' -s=%s' % str(timestamp)

  hdrCmd += ' %s' % rawFile.name
  hdrCmd += ' %s' % hdrFile.name
  rc = os.system(hdrCmd)

  retFile = FswFileFromDisk(inFile.fileID(), hdrFile.name)

  return retFile







def downloadFile(app, unit, fileID):
  """!\brief Download a file from the LAT

  \param app         A testAppBase object  (your user application...)
  \param unit        LAT unit id to upload to
  \param fileID      An FswFileID object
  \return An FswFile object containing the data uploaded
  """
  class FileDump(object):
    def __init__(self, app):
      self.__app = app
      self.__fragments = {}
      self.__dumpSizes = {}
      self.__expectedID = None
      self.__dumpCTDBtelem = TelemetryEvent(app.getDiagHandler(),
                                            [app.lcatTlm.getApidFromName('LLFSDUMPCTDB')],
                                            self.dumpCTDB)
    def dumpCTDB(self, telemetry):
      # File chunks may be sent down out of order.
      # Cache each dump payload in a dictionary keyed on the file offset.
      pkt = self.__app.lcatTlm.decodeTelemetry(telemetry)
      offset = pkt.get_payload("LFSFDMPOFFSET")
      dumpSize = pkt.get_payload("LFSFDMPSIZE")
      # Check if this is part of the expected file
      dumpDev  = pkt.get_payload("LFSDMPDEV")
      dumpDir  = pkt.get_payload("LFSDMPDIR")
      dumpFile = pkt.get_payload("LFSDMPFILE")
      if dumpDev  != self.__expectedID.device() or \
         dumpDir  != self.__expectedID.directory() or \
         dumpFile != self.__expectedID.dumpFile():
        msg = "CTDB dump resulted in unexpected file: %s, expected %s" % \
              ( str(FswFileID(dumpDev, dumpDir, dumpFile)), self.__expectedID )
        raise RuntimeError(msg)


      dataMnems = ['LFSFDMPDATA%d' % i for i in xrange(390)]
      self.__fragments[offset] = ''.join(map(chr, map(pkt.get_payload, dataMnems)))
      self.__dumpSizes[offset] = dumpSize

    def dump(self, unit, fileID):
      self.__expectedID = fileID
      self.__dumpCTDBtelem.enable()
      LFS = self.__app.lcat.LFS
      LFS.LFSFILEDUMPC( LFSFILEID=fileID.id(), LFSUNIT=unit, LFSPAD16=0 )
      self.__app.waitForConfirmation(timeout = FILETOOL_STANDARD_TIMEOUT)
      offsets = self.__fragments.keys()
      offsets.sort()
      binary = ""
      for o in offsets:
        binary += self.__fragments[o][:self.__dumpSizes[o]]

      self.__dumpCTDBtelem.disable()

      return FswFileFromData(fileID, binary, uploaded=True)

  fd = FileDump(app)

  fswFile = fd.dump(unit, fileID)

  return fswFile

def downloadFileToSSR(app, unit, fileID):
  """!\brief Download a file from the LAT

  \param app         A testAppBase object  (your user application...)
  \param unit        LAT unit id to upload to
  \param fileID      An FswFileID object
  \return status
  """
  LFS.LFSFILEDUMPS( LFSFILEID=fileID.id(), LFSunit=unit, LFSPAD16=0 )
  status = __checkLastCommandStatus(app)
  return status


def uploadFileFromDisk(app, fileName, unit, fileID):
  """!\brief Upload a disk resident file with an FMX header

  \param app         A testAppBase object  (your user application...)
  \param fileName    Fully qualified file name
  \param unit        LAT unit id to upload to
  \param fileID      An FswFileID object
  \return An FswFile object containing the data uploaded
  """
  uplFile = None
  try:
    uplFile = FswFileFromDisk(fileID, fileName)
  except:
    raise
  else:
    uploadFile(app, uplFile, unit)
  return uplFile

def uploadFileFromData(app, fileData, unit, fileID):
  """!\brief Upload a memory resident file with an FMX header (Typically received from MOOT)

  \param app         A testAppBase object  (your user application...)
  \param fileData    Binary representation of an FMX file
  \param unit        LAT unit id to upload to
  \param fileID      An FswFileID object
  \return An FswFile object containing the data uploaded
  """
  uplFile = None
  try:
    uplFile = FswFileFromData(fileID, fileData)
  except:
    raise
  else:
    uploadFile(app, uplFile, unit)
  return uplFile

def cancelUpload(app, unit):
  """!\brief cancel any in process uploads

  \param app         A testAppBase object  (your user application...)
  \param fswFile     FswFile object
  \param unit        LAT unit id to upload to
  \return status
  """
  app.lcat.FILE.LFILUPLCANCEL(LFILEUNIT=unit)
  status = __checkLastCommandStatus(app)
  return status

def uploadFile(app, fswFile, unit):
  """!\brief Upload a memory resident fsw file object

  \param app         A testAppBase object  (your user application...)
  \param fswFile     FswFile object
  \param unit        LAT unit id to upload to
  """


  # TODO:  JHP-  Check for uploaded?
  # if fswFile.uploaded():
  #   log.info("Fmx File 0x%x:%d has already been uploaded" % ( fswFile.fileId(), fswFile.fileId() )
  #   return True

  fileID = fswFile.fileID()
  uplStr = fswFile.binary()

  # cancel any pending transfers
  status = cancelUpload(app, unit)
  if not status:
    raise RuntimeError("Recieved bad status from cancelUpload.  Check previous warning.")

  # start file transfer command
  # fiddly code: 1: FSW uploads packets in multiples of 48 bytes.
  #              2: filuplstart must tell system *exactly* how much data to expect
  #              3: Round up to next 48 byte boundary
  dumpSize = len(fswFile.binary())
  d,m = divmod(dumpSize, 48)
  if m != 0:
    d += 1
  app.lcat.FILE.LFILUPLSTART(LFILESIZE=d*48)
  status = __checkLastCommandStatus(app)
  if not status:
    raise RuntimeError("Recieved bad status from upload start.  Check previous warning.")

  # loop over 48 byte chunks
  nDataBytes = 48
  chunk = 0
  offset = 0
  lastpacket = dumpSize // nDataBytes - 1
  while True:
    offset = chunk*nDataBytes
    if offset >= dumpSize:
      break
    if lastpacket > 0:
      if chunk == 0:
        seqFlags = 0x1 # first packet
      elif chunk == lastpacket:
        seqFlags = 0x2 # last packet
      else:
        seqFlags = 0x0 # middle packet
    else:
      seqFlags = 0x3     # not a sequence
    app.lcat.FILE.getCmdObj('LFILUPLDATA').seqFlags = seqFlags
    __uploadChunk(app, uplStr[offset:offset+nDataBytes], offset, nDataBytes)
    chunk += 1

  app.lcat.FILE.LFILUPLCOMMIT(LFILEUNIT=unit,
                              LFILEFLAGS=0,
                              LFILEID=fileID.id())
  status = __checkLastCommandStatus(app)
  if not status:
    raise RuntimeError("Received bad status from File Upload Commit.  Check previous warning")


  # don't forget to tell the file that it has been uploaded
  fswFile.setUploaded(True)
  return status


def __uploadChunk(app, uplChunk, offset, nDataBytes):
  lChunk = len(uplChunk)
  if lChunk > nDataBytes:
    raise ValueError, "Length of a chunk can't be greater than %d bytes" % nDataBytes
  # Pad to nDataBytes bytes
  uplChunk = uplChunk + ( chr(0) * (nDataBytes-lChunk) )
  app.lcat.FILE.LFILUPLDATA(offset, *array.array('B',uplChunk).tolist())

  # from binascii import hexlify
  # print "chunk", offset, hexlify(uplChunk)
  # We do not get command confirmation for LFILUPLDATA telecommands

def dumpDirectory(app, unit, directoryID, root=False):
  """!\brief Download a directory listing from the LAT

  \param app         A testAppBase object  (your user application...)
  \param unit        LAT unit id to upload to
  \param fileID      An FswFileID object with the correct directory set.
  \return An FswFile object containing the data uploaded
  """
  class DirDump(object):
    def __init__(self, app, root):
      self.__app  = app
      self.__root = root
      self.__rep = None
      self.__dumpSizes = {}
      if self.__root:
        wantedPacket = "LLFSROOTLIST"
      else:
        wantedPacket = "LLFSDIRLIST"


      self.__dumpDirTelem = TelemetryEvent(app.getDiagHandler(),
                                           [app.lcatTlm.getApidFromName(wantedPacket)],
                                           self.getPackets)
    def getPackets(self, telemetry):
      try:
        pkt = self.__app.lcatTlm.decodeTelemetry(telemetry)
        if self.__root:
          prefix = 'LFSRDMPF'
        else:
          prefix = 'LFSDDMP'

        device    = pkt.get_payload( prefix + "DEV" )
        directory = pkt.get_payload( prefix + "DIR" )
        fileNum   = pkt.get_payload( prefix + "FILE" )
        # Deal with LCAT inconsistencies
        if self.__root:
          prefix = prefix[:-1]

        ro        = pkt.get_payload( prefix + "ROFLG")
        size      = pkt.get_payload( prefix + "SIZE")
        isdir     = pkt.get_payload( prefix + "DIRFLG")
        t         = pkt.get_payload( prefix + "TIME")
        u         = pkt.get_payload( prefix + "UNIT")
        blocks    = 0  # pkt.get_payload( prefix + "BLOCKS")  # bad?  why?
        # print "cracked packet"
        self.__rep.addItem( FswDirectoryItem(FswFileID(device, directory, fileNum),
                                             ro, size, isdir, t, u, blocks) )
        # print "returning from getPa"
      except Exception, e:
        print e
        raise

    def dump(self, unit, dirID):
      self.__rep = FswDirectory( dirID=dirID )
      self.__dumpDirTelem.enable()
      self.__app.lcat.LFS.LFSDIRDUMP(LFSFILEID=dirID.id(),
                                     LFSUNIT=unit,
                                     LFSPAD16=0)
      self.__app.waitForConfirmation(timeout = FILETOOL_STANDARD_TIMEOUT)
      self.__dumpDirTelem.disable()

      return self.__rep

  dd = DirDump(app, root)
  dirRep = dd.dump(unit, directoryID)
  return dirRep

def createDirectory(app, unit, directoryID):
  """!\brief create a directory on a LAT file system

  \param app         A testAppBase object  (your user application...)
  \param unit        LAT unit id
  \param fileID      An FswFileID object with the correct directory set.
  \return status     True if it worked, False if not.
  """
  app.lcat.LFS.LFSDIRCREATE(LFSUNIT=unit,
                            LFSFILEID=directoryID.id(),
                            LFSPAD16=0)
  status = app.waitForConfirmation(timeout = FILETOOL_STANDARD_TIMEOUT)
  return status

def deleteDirectory(app, unit, directoryID, force=False):
  """!\brief Delete a directory on a LAT filesystem

  \param app          A testAppBase object  (your user application...)
  \param unit         LAT unit id to upload to
  \param directoryID  An FswFileID object with the correct directory set.
  \return status      True if success, False if failure
  """
  status = True
  if force:
    # Remove all files in this directory
    dirRep = dumpDirectory(app, unit, directoryID)
    for f in dirRep.files():
      status = deleteFile(app, unit, f.id)
      if not status:
        break
  if status:
    # log.debug("deleting directory %s" % directoryID)
    app.lcat.LFS.LFSDIRDELETE(LFSUNIT=unit,
                              LFSFILEID=directoryID.id(),
                              LFSPAD16=0)
    status = __checkLastCommandStatus(app)
  return status

def deleteFile(app, unit, fileID):
  """!\brief Delete a file on a LAT filesystem

  \param app         A testAppBase object  (your user application...)
  \param unit        LAT unit id to upload to
  \param fileID      An FswFileID object
  \return status     True if success, False if failure
  """
  app.lcat.LFS.LFSFILEDELETE(LFSUNIT=unit,
                             LFSFILEID=fileID.id(),
                             LFSPAD16=0)
  status = __checkLastCommandStatus(app)
  return status

def copyFile(app, unit, source, dest):
  """!\brief  Copy a file on any LAT unit

  \param app         A testAppBase object  (your user application...)
  \param unit        LAT unit id to upload to
  \param source      An FswFileID object corresponding to the source file
  \param dest        An FswFileID object corresponding to the destination file
  \return status     True if success, False if failure
  """
  status = True
  app.lcat.LFS.LFSFILECOPY(LFSUNIT=unit,
                           LFSSRCFILEID=source.id(),
                           LFSDESTFILEID=dest.id(),
                           LFSPAD16=0)
  status = __checkLastCommandStatus(app)

  return status

def __checkLastCommandStatus(app):
  # boilerplate code that waits for completion on a command
  #   and checks the completion status.  If bad, log a warning
  status = True
  status = app.waitForConfirmation(timeout = FILETOOL_STANDARD_TIMEOUT)
  statusMsg = app.getConfirmationMsg()
  if not app.lcatTlm.msgIsSuccess(statusMsg):
    log.warning(app.lcatTlm.msgByValue(statusMsg))
    status=False
  return status

---