FMX.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2006
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "FMX interface library"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2006/03/31 00:00:00"
__updated__  = "$Date: 2006/04/13 02:20:15 $"
__version__  = "$Revision: 1.4 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import logging as log
import os
import re
import subprocess

# This is a simple python wrapper to the perl interface around FMX
#
# It shall only support certain subsets of FMX, namely those dealing with
#   the LAT filesystems
#
# add, upload, commit, corrupt, delete
#
#
# Main functions:
#  fmx_upload( filetype, ... )
#    polymorphic upload method.  Due to some features of FMX, the arguments
#    for different filetypes 
#
#
#
#


# Notes for Jim to put into confluence at some point
# Important FMX trickery for setup:
#   FMX_C_FDB:  environment var defining where physical files live.
#               --> Also contains softlink: fmx.host --> fmx database instance
#               /nfs/slac/g/glast/fmx000  -->  lat-hobbit1  (060405)
#               /afs/slac/g/glast/fmx     -->  glastlnx06
#
#   mysql --host <> -P 8206 --pass 
#
#


## FMX database location environment variable
FMX_DB_ENV = "FMX_C_FDB"

## FMX file types
FMX_TYPES = ['cdm', 'fof', 'hsk', 'latc', 'lci', 'pbc', 'rel', 'sbm', 'sbs', 'vxw']

## FMX devices
FMX_DEVICES = ['ee0', 'ee1', 'mm0', 'mm1', 'ram', 'rom', 'mem']

## FMX allowed architectures
FMX_ARCHS = ['rad-750', 'mv2304', 'mcp750', 'linux-gcc', 'sun-gcc']

## FMX allowed node names  ** Note:  Distinct from FSW_UNIT_NAMES in LATconstants.  There are *two* SIUs in this scheme.
FMX_NODES = ['siu0', 'siu1', 'epu0', 'epu1', 'epu2']

## FMX base location, fully justified
FMX_BASE  = os.path.expandvars("$%s" % FMX_DB_ENV)

## FMX logical name for the LAT
FMX_LAT_NAME = 'mordor'

## FMX path parsing regexp
FMX_PATH_REGEXP = ' *(?P<filetype>.*)/(?P<package>.*)/(?P<version>.*)/(?P<constituent>.*)'

## FMX upload success regexp
FMX_UPGOOD_REGEXP = 'FMX: Upload physical=(?P<physical>.*) file=(?P<path>.*)$'

class FMX_command(subprocess.Popen):
  """ Subclass subprocess.Popen to change the defaults for use with FMX
  """
  def __init__(self, args):
    subprocess.Popen.__init__(self, args,
                              shell     = True,
                              stdin     = subprocess.PIPE,
                              stdout    = subprocess.PIPE,
                              stderr    = subprocess.PIPE,
                              close_fds = True)
    self.args = args
#    print "\nDEBUG: %s\n" % args[0]
  

def fmx_delete( filetype, **argv ):
  """!\brief Interface to fmx delete <blatz>

  \param filetype   Type of package you are working with
  
  filetype is broken into three main types:
    CODE:     cdm, rel, sbm, vxw   --  Code (compiled) modules
    CONFIG:   hsk, latc, lci       --  Configuration files
    FOF:      fof, sbs             --  files of Files
  
  Required arguments, all keyword required:
    node    = Destination of file (siu0, epu2, etc.)
    device  = Storage location of file (ee0, ee1, ram, etc)
  Partially optional arguments, all keyword required:
    package      = source package.         Required for CODE filetypes
    constituent  = package constituent.    Required for CODE filetypes 
    version      = package version.        Required for CODE filetypes
    relname      = relative upload path.   Required for CONFIG and FOF filetypes
    instrument   = Instrument name.        Optional.  If not set, instrument name for LAT is used.  (mordor)

  """
  CMD_BASE = "fmx delete %s"

  def _handleDelete( fmx ):
    """ Private function to handle common semantics of deleting a file
        from the LAT (or anywhere else...)

        Returns True or False, depending on the errors encountered inside fmx
    """
    if fmx.returncode == 0:    # commit passed
      return True
    else:
      lines = fmx.stdout.readlines()
      # first error line can be a sort-of success
      notExtantString = "FMX: Cannot delete a non-existent file"
      l = lines[0].strip()
      if l == notExtantString:   # deleting a nonexistant file should succeed.
        return True
      else:
        msg = "%s : original cmd = %s" % (l.strip(), cmd)
        log.error(msg)

      # and continue printing errors
      for l in lines[1:]: # and if no stdout??? **revisit
        msg = "%s" % (l.strip())
        log.error(msg)
      return False

  defaultInstrument( argv )
  node        = checkNode(str(argv['node']))
  device      = checkDevice(str(argv['device']))
  if device is None:
    raise RuntimeError ("Supplied FMX device %s is not in list of allowed devices" % argv['device'] )
  else:
    argv['device'] = device
  if node is None:
    raise RuntimeError ("Supplied FMX node %s is not in list of allowed nodes" % argv['node'] )
  else:
    argv['node'] = node
    
  # cdm, rel, sbm, vxw  are homomorphic
  # hsk, latc, lci are homomorphic
  # fof, sbs are homomorphic
  # pbc is not implemented in FMX
  if filetype in ['cdm', 'rel', 'sbm', 'vxw']:
    cmd = __fmx_code_command( CMD_BASE, filetype, argv['package'], argv['version'],  argv['constituent'],  argv['instrument'],  argv['node'],  argv['device'] )
  elif filetype in ['hsk', 'latc', 'lci']:
    cmd = __fmx_config_command( CMD_BASE, filetype, argv['relname'], argv['instrument'],  argv['node'],  argv['device'] )
  elif filetype in ['fof', 'sbs']:
    cmd = __fmx_config_command( CMD_BASE, filetype, argv['relname'], argv['instrument'],  argv['node'],  argv['device'] )
  else:
    raise RuntimeError( "Filetype %s is not supported by fmx_commit" % filetype)
  
  fmx = FMX_command( [cmd] )
  fmx.wait()
  return _handleDelete( fmx )

def fmx_commit( filetype, **argv ):
  """!\brief Interface to fmx commit <blatz>

  \param filetype   Type of package you are working with
  
  filetype is broken into three main types:
    CODE:     cdm, rel, sbm, vxw   --  Code (compiled) modules
    CONFIG:   hsk, latc, lci       --  Configuration files
    FOF:      fof, sbs             --  files of Files
  
  Required arguments, all keyword required:
    node    = Destination of file (siu0, epu2, etc.)
    device  = Storage location of file (ee0, ee1, ram, etc)
  Partially optional arguments, all keyword required:
    package      = source package.         Required for CODE filetypes
    constituent  = package constituent.    Required for CODE filetypes 
    version      = package version.        Required for CODE filetypes
    relname      = relative upload path.   Required for CONFIG and FOF filetypes
    instrument   = Instrument name.        Optional.  If not set, instrument name for LAT is used.  (mordor)

  """
  CMD_BASE = "fmx commit %s"

  def _fmx_commit_code( filetype , **argv ):
    """ Private commit function for uploading single code type modules.

    return True or False
    """
    cmd = __fmx_code_command( CMD_BASE, filetype, argv['package'], argv['version'],  argv['constituent'],  argv['instrument'],  argv['node'],  argv['device'] )
    fmx = FMX_command( [cmd] )
    fmx.wait()

    if fmx.returncode == 0:    # commit passed
      return True
    else:
      lines = fmx.stdout.readlines()
      for l in lines: # and if no stdout??? **revisit
        msg = "%s : original cmd = %s" % (l.strip(), cmd)
        log.error(msg)
      return False

    pass

  def _fmx_commit_fof( filetype , **argv ):
    """ Private commit function for uploading single code type modules.

    return True or False
    """

    cmd = __fmx_fof_command( CMD_BASE, filetype, argv['relname'], argv['instrument'],  argv['node'],  argv['device'] )
    fmx = FMX_command( [cmd] )
    fmx.wait()

    if fmx.returncode == 0:    # commit passed
      return True
    else:
      lines = fmx.stdout.readlines()
      for l in lines: # and if no stdout??? **revisit
        msg = "%s : original cmd = %s" % (l.strip(), cmd)
        log.error(msg)
      return False


  def _fmx_commit_config( filetype , **argv ):
    """ Private commit function for uploading single code type modules.

    return True or False
    """

    cmd = __fmx_config_command( CMD_BASE, filetype, argv['relname'], argv['instrument'],  argv['node'],  argv['device'] )
    fmx = FMX_command( [cmd] )
    fmx.wait()

    if fmx.returncode == 0:    # commit passed
      return True
    else:
      lines = fmx.stdout.readlines()
      for l in lines: # and if no stdout??? **revisit
        msg = "%s : original cmd = %s" % (l.strip(), cmd)
        log.error(msg)
      return False

  defaultInstrument( argv )
  node        = checkNode(str(argv['node']))
  device      = checkDevice(str(argv['device']))
  if device is None:
    raise RuntimeError ("Supplied FMX device %s is not in list of allowed devices" % argv['device'] )
  else:
    argv['device'] = device
  if node is None:
    raise RuntimeError ("Supplied FMX node %s is not in list of allowed nodes" % argv['node'] )
  else:
    argv['node'] = node
    
  # cdm, rel, sbm, vxw  are homomorphic
  # hsk, latc, lci are homomorphic
  # fof, sbs are homomorphic
  # pbc is not implemented in FMX
  if filetype in ['cdm', 'rel', 'sbm', 'vxw']:
    return _fmx_commit_code( filetype, **argv )
  elif filetype in ['hsk', 'latc', 'lci']:
    return _fmx_commit_config( filetype, **argv )
  elif filetype in ['fof', 'sbs']:
    return _fmx_commit_fof( filetype, **argv )
  else:
    raise RuntimeError( "Filetype %s is not supported by fmx_commit" % filetype)
  

  pass


def fmx_upload( filetype, **argv ):
  """ upload a file to the system

  \param filetype   Type of file to upload.

  filetype is broken into three main types:
    CODE:     cdm, rel, sbm, vxw   --  Code (compiled) modules
    CONFIG:   hsk, latc, lci       --  Configuration files
    FOF:      fof, sbs             --  files of Files
  
  Required arguments, all keyword required:
    node    = Destination of file (siu0, epu2, etc.)
    device  = Storage location of file (ee0, ee1, ram, etc)
  Partially optional arguments, all keyword required:
    package      = source package.         Required for CODE filetypes
    constituent  = package constituent.    Required for CODE filetypes 
    version      = package version.        Required for CODE filetypes
    relname      = relative upload path.   Required for CONFIG and FOF filetypes
    instrument   = Instrument name.        Optional.  If not set, instrument name for LAT is used.  (mordor)
    
  """
  CMD_BASE = "fmx upload %s"
  upload_allowed_args = [ 'package', 'version', 'constituent', 'node',
                          'device', 'relname', 'instrument' ]
  
  def _fmx_upload_code( filetype, **argv ):
    """ Private upload function for uploading single code type modules.

    return Either: (physical ID, path to disk file)
    return Or:     (None, None) and an error message is logged
    """

    cmd = __fmx_code_command( CMD_BASE, filetype, argv['package'], argv['version'],  argv['constituent'],  argv['instrument'],  argv['node'],  argv['device'] )
    fmx = FMX_command( [cmd] )
    fmx.wait()


    if fmx.returncode == 0:    # Safe to upload, return the physical ID and path
      return physPath(fmx.stdout.readline())
    else:                      # Not safe to upload.  Raise something???  ***REVISIT
      msg = "FMX upload failed: %s" % cmd
      log.error(msg)
      lines = fmx.stdout.readlines()
      for l in lines: # and if no stdout??? **revisit
        msg = "%s " % (l.strip())
        log.error(msg)

      return (None, None)

  def _fmx_upload_fof( filetype, **argv ):
    """ Private function for uploading Files of Files.

    \return Either: (physical ID, path to disk file)
    \return Or:     [list of upload requirements]
    """

    cmd = __fmx_fof_command( CMD_BASE, filetype, argv['relname'], argv['instrument'],  argv['node'],  argv['device'] )
    # special code for resolving a FOF/SBS object on upload:
    if 'create' in argv and argv['create']:
      cmd += ' --create'
    fmx = FMX_command( [cmd] )
    fmx.wait()

    if fmx.returncode == 0:    # Safe to upload, return the physical ID and path
      return physPath(fmx.stdout.readline())
    else:                      # Not safe to upload.  return prereqs
      notAvString = "FMX: Files not available on"
      prereqs = []
      lines = fmx.stdout.readlines()

      l = lines[0].strip()   # fmx fof error returns summary line, followed by list of files
      if len(l) < len(notAvString) or l[0:len(notAvString)] != notAvString:
        log.error("Fmx upload of %s failed: Original command: %s" % ( filetype, fmx.args) )
        raise RuntimeError("Error, unexpected return string from FMX: %s" % l)
      
      for l in lines[1:]: # and if no stdout??? **revisit
        if filetype == 'fof':
          prereqs.append(l.strip().split('/',1))  # split into filetype, relpath
        else:  # sbs
          prereqs.append(fmxPathSplit(l.strip()))  # split into filetype, relpath
          

      return prereqs

  def _fmx_upload_config( filetype, **argv ):
    """ Private function for uploading configuration files (lhk, lci, latc)

    \return Either: (physical ID, path to disk file)
    \return Or:     ???
    """

    cmd = __fmx_config_command( CMD_BASE, filetype, argv['relname'], argv['instrument'],  argv['node'],  argv['device'] )
    fmx = FMX_command( [cmd] )
    fmx.wait()

    if fmx.returncode == 0:    # Safe to upload, return the physical ID and path
      return physPath(fmx.stdout.readline())
    else:                      # Not safe to upload.  return (none, none)
      lines = fmx.stdout.readlines()
      for l in lines:
        msg = "%s : original cmd = %s" % (l.strip(), cmd)
        log.error(msg)

      return (None, None)
      

  # LAT instrument is default  **REVISIT**
  defaultInstrument( argv )
  
  node        = checkNode(str(argv['node']))
  device      = checkDevice(str(argv['device']))
  if device is None:
    raise RuntimeError ("Supplied FMX device %s is not in list of allowed devices" % argv['device'] )
  else:
    argv['device'] = device
  if node is None:
    raise RuntimeError ("Supplied FMX node %s is not in list of allowed nodes" % argv['node'] )
  else:
    argv['node'] = node
    
  
  # cdm, rel, sbm, vxw  are homomorphic
  # hsk, latc, lci are homomorphic
  # fof, sbs are homomorphic
  # pbc is not implemented in FMX
  if filetype in ['cdm', 'rel', 'sbm', 'vxw']:
    return _fmx_upload_code( filetype, **argv )
  elif filetype in ['hsk', 'latc', 'lci']:
    return _fmx_upload_config( filetype, **argv )
  elif filetype in ['fof', 'sbs']:
    return _fmx_upload_fof( filetype, **argv )
  else:
    raise RuntimeError( "Filetype %s is not supported by fmx_upload" % filetype)


def __fmx_code_command( command, filetype, package, version, constituent, instrument, node, device ):
  ## Private call constructing commands for code use

  # Need strings.  Coerce everything just in case
  package     = str(package).upper()
  version     = str(version).upper()
  constituent = str(constituent)
  instrument  = str(instrument)
  node        = str(node)
  device      = str(device)

  cmd  = "".join( [command % filetype,
                   " %s %s " % (package, constituent),
                   " --version=%s" % version,
                   " --instrument=%s" % instrument,
                   " --device=/%s" % device,
                   " --node=%s" % node,] )
  return cmd

def __fmx_fof_command( command, filetype, relname, instrument, node, device ):
  ## Private call for constructing fof type commands

  relname     = str(relname)
  instrument  = str(instrument)
  node        = str(node)
  device      = str(device)

  cmd = "".join( [ command % filetype,
                   " %s" % relname,
                   " --instrument=%s" % instrument,
                   " --device=/%s" % device,
                   " --node=%s" % node,] )
  return cmd
                   
def __fmx_config_command( command, filetype, relname, instrument, node, device ):
  ## Private call for constructing config type commands

  relname     = str(relname)
  instrument  = str(instrument)
  node        = str(node)
  device      = str(device)

  cmd = "".join( [ command % filetype,
                   " %s" % relname,
                   " --instrument=%s" % instrument,
                   " --device=/%s" % device,
                   " --node=%s" % node,] )
  return cmd
                   
  

## helper functions

def defaultInstrument( argv ):
  # Dumb function, if instrument isn't set, set it to standard name.  else, make sure it is lowercase
  if 'instrument' not in argv:
    argv['instrument'] = FMX_LAT_NAME
  else:
    argv['instrument'] = str(argv['instrument']).lower()

  

def physPath( line ):
  m = re.match(FMX_UPGOOD_REGEXP, line)
  if m:
    physical, filepath = m.groups()
    physical = int(physical, 16)
  else:
    physical, filepath = None, ""
  return physical, filepath.strip()
  
  
def fmxPathSplit( fmxPath ):
  # split the FMX path into filetype, package, version, constituent
  # and return a list in the above order
  m = re.match(FMX_PATH_REGEXP, fmxPath)
  return m.groups()

def checkDevice( device ):
  # Check if the device is in the allowed list of devices
  # Returns the device passed, or None
  if device in FMX_DEVICES:
    return device
  return None

def checkNode( node ):
  # Check if the unit is in the allowed list of units
  # Returns the unit passed, or None
  if node in FMX_NODES:
    return node
  return None





if __name__ == "__main__":
  import unittest
  import time

  class FmxInterfaceTestCase(unittest.TestCase):
    sbsp = []
    latc = [      ]
    
    def __init__(self, arg):
      unittest.TestCase.__init__(self, arg)

    def checkPathSplit(self):
      """ Check if fmxPathSplit function works correctly"""
      filetype, package, version, constituent = fmxPathSplit('cdm/CGB_DB/V0-0-2/cal_db_gains')

      self.failUnlessEqual(filetype, 'cdm')
      self.failUnlessEqual(package, 'CGB_DB')
      self.failUnlessEqual(version, 'V0-0-2')
      self.failUnlessEqual(constituent, 'cal_db_gains')

    def checkUploadCode(self):
      """ Check if code files upload correctly"""
      filetype, package, version, constituent = 'cdm','CGB_DB','V0-0-2','cal_db_gains'

      result = fmx_upload( filetype = filetype, package = package,
                           version = version, constituent = constituent, 
                           instrument = 'mordor', node ="siu0", device = 'ee0' )

      self.failUnless( result[0] )
      self.failUnless( result[1] )

    def checkCommitCode(self):
      """ Check if code files commit correctly"""
      filetype, package, version, constituent = 'cdm','CGB_DB','V0-0-2','cal_db_gains'

      result = fmx_commit( filetype = filetype, package = package,
                           version = version, constituent = constituent, 
                           instrument = 'mordor', node ="siu0", device = 'ee0' )
      self.failUnless( result )

    def checkDeleteCode(self):
      """ Check if code files delete correctly"""
      filetype, package, version, constituent = 'cdm','CGB_DB','V0-0-2','cal_db_gains'

      result = fmx_delete( filetype = filetype, package = package,
                           version = version, constituent = constituent, 
                           instrument = 'mordor', node ="siu0", device = 'ee0' )
      self.failUnless( result )

    def checkUploadConfig(self):
      """ Check if configuration files db upload correctly"""

      result = fmx_upload( filetype = 'latc', relname='panetta/test1/latc.a',
                           instrument = 'mordor', node ="siu0", device = 'ee0' )

      self.failUnless( result[0] )
      self.failUnless( result[1] )

    def checkCommitConfig(self):
      """ Check if configuration db files commit correctly"""

      result = fmx_commit( filetype = 'latc', relname='panetta/test1/latc.a',
                           instrument = 'mordor', node ="siu0", device = 'ee0' )

      self.failUnless( result )

    def checkDeleteConfig(self):
      """ Check if configuration db files delete correctly"""

      result = fmx_delete( filetype = 'latc', relname='panetta/test1/latc.a',
                           instrument = 'mordor', node ="siu0", device = 'ee0' )

      self.failUnless( result )
    

    def checkUploadBadVersion(self):
      """ Check if uploading a file with a bad version *fails*"""
      # note bad version string...
      log.disable(log.ERROR)
      filetype, package, version, constituent = 'cdm','CGB_DB','V99999','cal_db_gains'

      result = fmx_upload( filetype = filetype, package = package,
                           version = version, constituent = constituent, 
                           instrument = 'mordor', node ="siu0", device = 'ee0' )

      # result should now be (None, None), and an error message is printed
      self.failIf( result[0] )
      self.failIf( result[1] )
      # turn logging back on
      log.disable(log.NOTSET)

    def checkNoInstrument(self):
      """ Check if uploading without specifying instrument works"""
      # same as checkUploadConfig but instrument isn't set.
      #   only one test needed as code is common

      # Note:  assumes checkDeleteConfig has been run
      result = fmx_upload( filetype = 'latc', relname='panetta/test1/latc.a',
                           node ="siu0", device = 'ee0' )

      self.failUnless( result[0] )
      self.failUnless( result[1] )      

    def checkUploadSBSunresolved(self):
      """ Check returning of unresolved files from an unresolved SBS"""
      
      result = fmx_upload( filetype = 'sbs', relname = 'FTS/V0-1-4/B0-6-5/siu.fmx.template',
                           device = 'mm0', node = 'siu0' )

      self.failUnless( len(result) )

    def checkUploadedAlready(self):
      """ Check if attempting to upload an already uploaded file fails"""
      # File has been uploaded already
      log.disable(log.ERROR)
      result = fmx_upload( filetype = 'hsk', relname = 'LHK/V6-4-8/LHKCFLIM/LHKCFLIM',
                           device = 'ee0', node = 'siu0' )
      # result should be (None, None) and an error message should be printed
      self.failIf( result[0] )
      self.failIf( result[1] )
      log.disable(log.NOTSET)

    def checkResolveSBS(self):
      """ Check logic for resolving an SBS"""
      # test of actually doing a resolve on an SBS script.
      # 0) Set up variables to clean up afterwards
      dev = 'ee0'
      node = 'siu0'

      # 1) Attempt an upload of SBS.  Note requirements for upload
      prereqs = fmx_upload( filetype = 'sbs', relname = 'FTS/V0-1-4/B0-6-5/siu.fmx.template',
                            device = 'mm0', node = 'siu0' )
      self.failUnless( len(prereqs) )

      # 2) Loop over the prereqs, uploading and committing
      for f in prereqs:
        self.sbsp.append(f)  # for cleanup later
        ft, pac, ver, con = f
        result = fmx_upload( ft, package=pac, version=ver, constituent=con,
                             device=dev, node=node )
        self.failUnless( result[0] )
        self.failUnless( result[1] )
        if result is not (None, None):
          passed = fmx_commit( ft, package=pac, version=ver, constituent=con,
                               device=dev, node=node )
          self.failUnless( passed )

      final = fmx_upload( filetype = 'sbs', relname = 'FTS/V0-1-4/B0-6-5/siu.fmx.template',
                          device = 'mm0', node = 'siu0', create = True )
      self.failUnless( final[0] )
      self.failUnless( final[1] )
      self.failIf( len(final) > 2 )

      passed = fmx_commit( filetype = 'sbs', relname = 'FTS/V0-1-4/B0-6-5/siu.fmx.template',
                           device = 'mm0', node = 'siu0' )

      self.failUnless( passed )

    def checkUnResolveSBS(self):
      """ Check logic for removing an SBS from the system"""
      # Must be run *after* checkResolveSBS
      dev = 'ee0'
      node = 'siu0'

      # empirical knowledge:  One must delete the sbs *before* one deletes the components
      final = fmx_delete( filetype = 'sbs', relname = 'FTS/V0-1-4/B0-6-5/siu.fmx.template',
                           device = 'mm0', node = 'siu0' )
      self.failUnless( final )
      
      for f in self.sbsp:
        ft, pac, ver, con = f
        result = fmx_delete( ft, package=pac, version=ver, constituent=con,
                             device=dev, node=node )
        self.failUnless( result )

    def deleteList(self):
      """ Only used in testing.  DO NOT USE"""
      pkgs = [ ('rel','LTC','V3-0-4','ltc'),
               ('rel','LATC','V7-5-4','latc'),
               ('rel','LATC','V7-5-4','latc_cmn'),
               ('rel','LCI','V3-1-1','lci'),
               ('rel','LPA','V3-0-0','lpa_siu'),
               ('rel','LIM','V1-10-0','lim'),
               ('cdm','LIM_DB','V0-4-0','lim_data'),
            ]
      dev = 'ee0'
      node = 'siu0'
      for f in pkgs:
        ft, pac, ver, con = f
        result = fmx_delete( ft, package=pac, version=ver, constituent=con,
                             device=dev, node=node )
        self.failUnless( result )

      latc = [('latc','panetta/test1/latc_DFT.lcb'),
              ('latc','panetta/test1/latc_AEM.lcb'),
              ('latc','panetta/test1/latc_AFE.lcb'),
              ('latc','panetta/test1/latc_ARC.lcb'),
              ('latc','panetta/test1/latc_CCC.lcb'),
              ('latc','panetta/test1/latc_CFE.lcb'),
              ('latc','panetta/test1/latc_GEM.lcb'),
              ('latc','panetta/test1/latc_TCC.lcb'),
              ('latc','panetta/test1/latc_TDC.lcb'),
              ('latc','panetta/test1/latc_TEM.lcb'),
              ('latc','panetta/test1/latc_TFE.lcb'),]
        

    def checkUploadLATC(self):
      """ Test resolving and uploading a LATC fof."""
      dev = 'ee0'
      node= 'siu0'

      # 1) Attempt an upload of SBS.  Note requirements for upload
      prereqs = fmx_upload( filetype = 'fof', relname = 'panetta/test1/latc.lcm',
                            device = 'ee0', node = 'siu0' )
      self.failUnless( len(prereqs) )

      for f in prereqs:
        self.latc.append(f)
        ft, rp = f
        result = fmx_upload( ft, relname=rp,
                             device=dev, node=node )
        self.failUnless( result[0] )
        self.failUnless( result[1] )
        if result is not (None, None):
          passed = fmx_commit( ft, relname=rp,
                               device=dev, node=node )
          self.failUnless( passed )

      final = fmx_upload( filetype = 'fof', relname = 'panetta/test1/latc.lcm',
                          device = 'ee0', node = 'siu0', create = True )
      self.failUnless( final[0] )
      self.failUnless( final[1] )
      self.failIf( len(final) > 2 )

      passed = fmx_commit( filetype = 'fof', relname = 'panetta/test1/latc.lcm',
                           device = 'ee0', node = 'siu0' )

      self.failUnless( passed )
      

    def checkUnloadLATC(self):
      """ Test removal of a LATC FOF from the system (with its files)"""
      #import time
      #print "sleeping..."
      #time.sleep(60)
      dev = 'ee0'
      node= 'siu0'
      final = fmx_delete( filetype = 'fof', relname = 'panetta/test1/latc.lcm',
                           device = 'ee0', node = 'siu0' )
      self.failUnless( final )
      
      for f in self.latc:
        ft, rp = f
        result = fmx_delete( ft, relname=rp,
                             device=dev, node=node )
        self.failUnless( result )
      
      

  def suite():
    loader = unittest.TestLoader()
    testSuite = loader.loadTestsFromNames(
      ['checkPathSplit',
       'checkNoInstrument',
       'checkUploadCode',
       'checkCommitCode',
       'checkDeleteCode',
       'checkDeleteCode',     # twice to check for success when deleting nonexistent file
       'checkUploadConfig',
       'checkCommitConfig',
       'checkDeleteConfig',
       'checkUploadBadVersion',
       'checkUploadSBSunresolved',
       'checkResolveSBS',
       'checkUnResolveSBS',
       'checkUploadedAlready',
       'checkUploadLATC',
       'checkUnloadLATC',
       #'deleteList',          # only used during script debugging.  DO NOT USE for normal unit test
       ],
      FmxInterfaceTestCase )
    return testSuite
      

  def test():

    # Initialize logging
    log.basicConfig()
    #log.disable(log.ERROR)

    runner =  unittest.TextTestRunner(verbosity=2)
    runner.run(suite())

    # Shut down the logger
    log.shutdown()

  # Now run the tests
  test()


#EOF

---