gHSK.py

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

## \namespace gHSK
##
## \brief GLAST LAT record definitions.
##
## \b Contents:
##
##
## \b Overview:
##
##  This module provides classes that are used as the building blocks for the
##  Housekeeping hierarchy.
##

__facility__ = "Online"
__abstract__ = "GLAST LAT functional block hierarchy"
__author__  = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/09/07 20:10:22 $").split(' ')[1]
__version__ = "$Revision: 1.14 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import os, types
import gSchemaConfig
from gSchemaConfig import hasAttribute, getAttribute
import gDb
import gHdb
import logging                    as     log
from xml.dom                      import Node
from xml.dom.ext.reader           import Sax2
# from gHdb                         import GHdb
from gGroup                       import *


# GHSK class
class GHSK(gDb.Gdb):
  """\brief GLAST HSK node Record

  """

  def __init__(self, client):
    """\brief Initialize valid attributes as Gattrs.

    Assign default values to members
    """
    self.HTEM = gDb.Children(self, HTEM)
    self.HAEM = None
    self.HGEM = None
    self.HEBM = None
    self.HPDU = gDb.Children(self, HPDU)
    self.HCOM = None
    self.HCPU = None
    self.HNUL = HNUL(self)           # NULL node.  Used to reference non-used bytes in hsk

    self.__schemaComments            = []
    self.__schemaName                = ''
    self.__configComments            = []
    self.__configName                = ''
    self.__configVersion             = ''
    self.__includeFiles              = []
    self.__declarations              = None
    self.__configurations            = {}
    self.__opaque                    = {}
    self.__serialnos                 = {}
    gDb.Gdb.__init__(self, client, None, None)

  def downHTEM(self, childId):
    """\brief Navigate to the HTEM indicated by \a childId

    \param  childId The id of the child HTEM

    \return         A HARC object instance
    """
    return self.HTEM.down(childId)

  def downHAEM(self):
    """\brief Navigate to the HAEM node

    \return         The HAEM object instance
    """
    return self.HAEM

  def downHGEM(self):
    """\brief Navigate to the HGEM node

    \return         The HGEM object instance
    """
    return self.HGEM

  def downHEBM(self):
    """\brief Navigate to the HEBM node

    \return         The HEBM object instance
    """
    return self.HEBM

  def downHPDU(self, childId):
    """\brief Navigate to the HPDU node

    \return         The HPDU object instance
    """
    return self.HPDU.down(childId)

  def downHCOM(self):
    """\brief Navigate to the HCOM node

    \return         The HCOM object instance
    """
    return self.HCOM

  def downHCPU(self):
    """\brief Navigate to the HCPU node

    \return         The HCPU object instance
    """
    return self.HCPU

  def downHNUL(self):
    """\brief Navigate to the HNUL node

    \return         The HNUL object instance
    """
    return self.HNUL

  def existsHTEM(self, temID):
    """\brief Check if the HTEM instance with the id
    \a temID exists in the schema.

    \param  temID ACD readout controller id

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.HTEM.exists(temID)

  def existsHAEM(self):
    """\brief Check if the HAEM instance exists in the schema.

    \return       True if it exists, False if it doesn't.
    """
    return self.HAEM != None

  def existsHGEM(self):
    """\brief Check if the HGEM instance exists in the schema.

    \return       True if it exists, False if it doesn't.
    """
    return self.HGEM != None

  def existsHEBM(self):
    """\brief Check if the HEBM instance exists in the schema.

    \return       True if it exists, False if it doesn't.
    """
    return self.HEBM != None

  def existsHPDU(self, hpduID):
    """\brief Check if the HPDU instance exists in the schema.

    \return       True if it exists, False if it doesn't.
    """
    return self.HPDU.exists(hpduID)

  def existsHCOM(self):
    """\brief Check if the HCOM instance exists in the schema.

    \return       True if it exists, False if it doesn't.
    """
    return self.HCOM != None

  def existsHCPU(self):
    """\brief Check if the HCPU instance exists in the schema.

    \return       True if it exists, False if it doesn't.
    """
    return self.HCPU != None

  def readSchema(self, schema):
    self.HTEM = gDb.Children(self, HTEM)
    self.HAEM = None
    self.HGEM = None
    self.HEBM = None
    self.HPDU = gDb.Children(self, HPDU)
    self.HCOM = None
    self.HCPU = None
    from gSchemaConfig import gSCprocessRegistry
    gSCprocessRegistry['GHSK'] = processGHSK
    gSchemaConfig.readSchema(self, schema)

  def readConfig(self, cfgFileName):
    return readHskConfig(self, cfgFileName)

  def applyConfig(self, seq):
    applyHskConfig(self, seq)

  def getConfigurations(self):
    """\brief Get list of configurations.

    Return a list of configuration tuples where
    each tuple contains the configDOM, configName and configRelease.

    \return Configuration tuple list.
    """
    return self.__configurations

  def getDeclarations(self):
    """\brief Get list of declarations.

    Return a list of declarations

    \return Declarations.
    """
    return self.__declarations

  def getRules(self):
    """\brief Retrieves the rule dictionary as defined by the
    current schema/configuration.

    \return Dictionary containing Grule objects (or its descendants).
    """
    return self.__declarations['rules']

  def getOpaque(self, name):
    """\brief Retrieves the named opaque data included in the schema

    \param  name Name of the opaque XML data

    \return      A list of XML DOM objects matching \a name
    """
    if name in self.__opaque:
      return self.__opaque[name]

  def __addHTEM(self, temID):
    return self.HTEM.add(temID)

  def __addHAEM(self):
    self.HAEM = HAEM(self.client(), self)
    return self.HAEM

  def __addHGEM(self):
    self.HGEM = HGEM(self.client(), self)
    return self.HGEM

  def __addHEBM(self):
    self.HEBM = HEBM(self.client(), self)
    return self.HEBM

  def __addHPDU(self, pduID):
    return self.HPDU.add(pduID)

  def __addHCOM(self):
    self.HCOM = HCOM(self.client(), self)
    return self.HCOM

  def __addHCPU(self):
    self.HCPU = HCPU(self.client(), self)
    return self.HCPU

  def __removeHTEM(self, temID):
    self.HTEM.remove(temID)

  def __removeHAEM(self):
    self.HAEM = None

  def __removeHGEM(self):
    self.HGEM = None

  def __removeHEBM(self):
    self.HEBM = None

  def __removeHPDU(self, pduID):
    self.HPDU.remove(pduID)

  def __removeHCOM(self):
    self.HCOM = None

  def __removeHCPU(self):
    self.HCPU = None


class HTEM(gDb.Gdb):
  """\brief GLAST TEM HSK node record

  Valid Attributes:
  - \c tkr_digital_v
  - \c tkr_digital_i  DEPRECATED, no replace
  - \c tkr_analoga_v           
  - \c tkr_analoga_i  DEPRECATED, no replace
  - \c tkr_analogb_v           
  - \c tkr_analogb_i  DEPRECATED, no replace
  - \c tkr_bias_v     DEPRECATED, replaced by:
  - \c tkr_bias_v0             
  - \c tkr_bias_i     DEPRECATED, no replace
  - \c cal_digital_v           
  - \c cal_digital_i  DEPRECATED, replaced by:
  - \c tkr_bias_v1             
  - \c cal_analog_v            
  - \c cal_analog_i   DEPRECATED, replaced by:
  - \c cal_bias_v1             
  - \c cal_bias_v     DEPRECATED, replaced by:
  - \c cal_bias_v0             
  - \c cal_bias_i     DEPRECATED, replaced by:
  - \c tem_28_v0               
  - \c tem_digital_v           
  - \c tem_digital_i  DEPRECATED, replaced by:
  - \c tem_28_v0
  - \c afee_[0-3]_t[0-1]  (AFEE_*_t0 DEPRECATED)
  - \c tkr_c[0-7]_t[0-1]
  - \c tkr_lrs_0_low
  - \c tkr_lrs_0_high
  - \c tkr_lrs_1_low
  - \c tkr_lrs_1_high
  - \c tkr_lrs_mask
  - \c cal_lrs_0
  - \c cal_lrs_0_mask
  - \c cal_lrs_1
  - \c cal_lrs_1_mask
  - \c deadtime
  """
  # Environmental
  __regs = [
    gHdb.GattrHsk('TKR_DIGITAL_V',  0),
    gHdb.GattrHsk('TKR_DIGITAL_I',  1),  # DEPRECATED, no replace
    gHdb.GattrHsk('TKR_ANALOGA_V',  2),
    gHdb.GattrHsk('TKR_ANALOGA_I',  3),  # DEPRECATED, no replace
    gHdb.GattrHsk('TKR_ANALOGB_V',  4),
    gHdb.GattrHsk('TKR_ANALOGB_I',  5),  # DEPRECATED, no replace
    gHdb.GattrHsk('TKR_BIAS_V'   ,  6),  # DEPRECATED, replaced by:
    gHdb.GattrHsk('TKR_BIAS_V0'  ,  6),
    gHdb.GattrHsk('TKR_BIAS_I'   ,  7),  # DEPRECATED, no replace
    # mux boundary
    gHdb.GattrHsk('CAL_DIGITAL_V',  8),
    gHdb.GattrHsk('CAL_DIGITAL_I',  9),  # DEPRECATED, replaced by:
    gHdb.GattrHsk('TKR_BIAS_V1'  ,  9),
    gHdb.GattrHsk('CAL_ANALOG_V' , 10),
    gHdb.GattrHsk('CAL_ANALOG_I' , 11),  # DEPRECATED, replaced by:
    gHdb.GattrHsk('CAL_BIAS_V1',   11), 
    gHdb.GattrHsk('CAL_BIAS_V'   , 12),  # DEPRECATED, replaced by:
    gHdb.GattrHsk('CAL_BIAS_V0'  , 12),
    gHdb.GattrHsk('CAL_BIAS_I'   , 13),  # DEPRECATED, replaced by:
    gHdb.GattrHsk('TEM_28_V0'    , 13),
    gHdb.GattrHsk('TEM_DIGITAL_V', 14),
    gHdb.GattrHsk('TEM_DIGITAL_I', 15),  # DEPRECATED, replaced by:
    gHdb.GattrHsk('TEM_28_V1'    , 15),
  ]
  offset = 16
  for i in range(4):
    __regs.append(gHdb.GattrHsk('AFEE_%d_T0'%i, offset   ))  # DEPRECATED
    __regs.append(gHdb.GattrHsk('AFEE_%d_T1'%i, offset+1 ))
    offset += 2
  for i in range(8):
    __regs.append(gHdb.GattrHsk('TKR_C%d_T0'%i, offset   ))
    __regs.append(gHdb.GattrHsk('TKR_C%d_T1'%i, offset+1 ))
    offset += 2
  # LRS counters
  __regs.append(gHdb.GattrHsk('TKR_LRS_0_LOW',  offset+0 ))
  __regs.append(gHdb.GattrHsk('TKR_LRS_0_HIGH', offset+1 ))
  __regs.append(gHdb.GattrHsk('TKR_LRS_1_LOW',  offset+2 ))
  __regs.append(gHdb.GattrHsk('TKR_LRS_1_HIGH', offset+3 ))
  __regs.append(gHdb.GattrHsk('TKR_LRS_MASK',   offset+4 ))
  __regs.append(gHdb.GattrHsk('CAL_LRS_0',      offset+5 ))
  __regs.append(gHdb.GattrHsk('CAL_LRS_0_MASK', offset+6 ))
  __regs.append(gHdb.GattrHsk('CAL_LRS_1',      offset+7 ))
  __regs.append(gHdb.GattrHsk('CAL_LRS_1_MASK', offset+8 ))
  __regs.append(gHdb.GattrHsk('DEADTIME',       offset+9 ))


  def __init__(self, client, parent, temID):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, temID, self.__regs)


class HAEM(gDb.Gdb):
  """\brief GLAST AEM HSK node Record

  Valid Attributes:
  - \c FreeI
  - \c Temperature
  - \c HVI
  - \c DAQV
  - \c CommonStatus
  - \c CableStatus

  """
  __regs = [
    # DAQ board hsk quantities
    gHdb.GattrHsk('FreeI'        , 0),
    gHdb.GattrHsk('Temperature'  , 1),
    gHdb.GattrHsk('HVI'          , 2),
    gHdb.GattrHsk('DAQV'         , 3),
    gHdb.GattrHsk('CommonStatus' , 4),
    gHdb.GattrHsk('CableStatus'  , 5),
  ]
  def __init__(self, client, parent):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    self.HARC = gDb.Children(self, HARC)
    gDb.Gdb.__init__(self, client, parent, None, self.__regs)

  def downHARC(self, arcID):
    """\brief Navigate to the HARC indicated by \a arcID

    \param  arcID The id of the child HARC

    \return         A HARC object instance
    """
    try:
      return self.HARC[arcID]
    except KeyError:
      return None

  def existsHARC(self, arcID):
    """\brief Check if the HARC instance with the id
    \a arcID exists in the schema.

    \param  arcId ACD readout controller id

    \return       1 if it exists, 0 if it doesn't.
    """
    if arcID in self.HARC:
      return 1
    else:
      return 0

  def __addHARC(self, arcID):
    if arcID in self.HARC:
      raise KeyError('*** HARC: ARC already exists with ID: %d' % arcID)
    else:
      self.HARC[arcID] = HARC(self.client(), self, arcID)
    return self.HARC[arcID]

  def __removeHARC(self, arcID):
    if arcID in self.HARC:
      self.HARC.__delitem__(arcID)


class HARC(gDb.Gdb):
  """\brief GLAST ARC HSK node record

  Valid Attributes:
  - \c Vdd
  - \c Temperature
  - \c HV1
  - \c HV2
  """
  __regs = [
    gHdb.GattrHsk('Vdd'         , 0),
    gHdb.GattrHsk('Temperature' , 1),
    gHdb.GattrHsk('HV1'         , 2),
    gHdb.GattrHsk('HV2'         , 3),
  ]
  def __init__(self, client, parent, arcID):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, arcID, self.__regs)

class HGEM(gDb.Gdb):
  """\brief GLAST GEM HSK node record

  Valid Attributes:
  - \c Events
  - \c Livetime
  - \c Prescaled
  - \c Busy
  - \c Sent
  - \c PPS
  - \c LastPPS
  - \c TriggerTime
  """
  __regs = [
    gHdb.GattrHsk('Events'        , 0),
    gHdb.GattrHsk('Livetime'      , 1),
    gHdb.GattrHsk('Prescaled'     , 2),
    gHdb.GattrHsk('Busy'          , 3),
    gHdb.GattrHsk('Sent'          , 4),
    gHdb.GattrHsk('PPS'           , 5),
    gHdb.GattrHsk('LastPPS'       , 6),
    gHdb.GattrHsk('TriggerTime'   , 7),
  ]
  def __init__(self, client, parent):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, None, self.__regs)

class HEBM(gDb.Gdb):
  """\brief GLAST EBM HSK node record

  Valid Attributes:
  - \c Events
  - \c GEMreceive
  - \c TEM[0-15]receive
  - \c AEMreceive
  - \c SIU0receive
  - \c SIU1receive
  - \c EPU0receive
  - \c EPU1receive
  - \c EPU2receive
  - \c SIU0transmit
  - \c SIU1transmit
  - \c EPU0transmit
  - \c EPU1transmit
  - \c EPU2transmit
  - \c SSRtransmit
  """
  __regs = [
    gHdb.GattrHsk('Events'         ,  0),
    gHdb.GattrHsk('GEMreceive'     ,  1),
    gHdb.GattrHsk('TEM0receive'    ,  2),
    gHdb.GattrHsk('TEM1receive'    ,  3),
    gHdb.GattrHsk('TEM2receive'    ,  4),
    gHdb.GattrHsk('TEM3receive'    ,  5),
    gHdb.GattrHsk('TEM4receive'    ,  6),
    gHdb.GattrHsk('TEM5receive'    ,  7),
    gHdb.GattrHsk('TEM6receive'    ,  8),
    gHdb.GattrHsk('TEM7receive'    ,  9),
    gHdb.GattrHsk('TEM8receive'    , 10),
    gHdb.GattrHsk('TEM9receive'    , 11),
    gHdb.GattrHsk('TEM10receive'   , 12),
    gHdb.GattrHsk('TEM11receive'   , 13),
    gHdb.GattrHsk('TEM12receive'   , 14),
    gHdb.GattrHsk('TEM13receive'   , 15),
    gHdb.GattrHsk('TEM14receive'   , 16),
    gHdb.GattrHsk('TEM15receive'   , 17),
    gHdb.GattrHsk('AEMreceive'     , 18),
    gHdb.GattrHsk('SIU0receive'    , 19),
    gHdb.GattrHsk('SIU1receive'    , 20),
    gHdb.GattrHsk('EPU0receive'    , 21),
    gHdb.GattrHsk('EPU1receive'    , 22),
    gHdb.GattrHsk('EPU2receive'    , 23),
    gHdb.GattrHsk('SIU0transmit'   , 24),
    gHdb.GattrHsk('SIU1transmit'   , 25),
    gHdb.GattrHsk('EPU0transmit'   , 26),
    gHdb.GattrHsk('EPU1transmit'   , 27),
    gHdb.GattrHsk('EPU2transmit'   , 28),
    gHdb.GattrHsk('SSRtransmit'    , 29),
  ]
  def __init__(self, client, parent):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, None, self.__regs)

class HPDU(gDb.Gdb):
  """\brief GLAST PDU HSK node record

  Valid Attributes:
  - \c ACDShellTemp0
  - \c ACDShellTemp1
  - \c ACDconvTemp
  - \c ACDpowerState
  - \c ACDpowerSupply
  - \c GridTemp[0-12]
  - \c RadiatorTemp[0-12]
  - \c RadiatorAfrzTemp0
  - \c RadiatorAfrzTemp1
  - \c CalBaseplateTemp[0-16]
  - \c VHCP_DSHP_M_Temp[0-6]
  - \c VHCP_DSHP_P_Temp[0-6]
  - \c VHCP_XLHP_M_Temp[0-6]
  - \c VHCP_XLHP_P_Temp[0-6]
  - \c VHCPRes_M_Temp[0-6]
  - \c VHCPRes_P_Temp[0-6]
  - \c TEM[0-16]_PCBTemp
  - \c TEM[0-16]_digital33V
  - \c TEM[0-16]_PSTemp
  - \c TEM[0-16]_powerState
  - \c ACDpmtRailTemp[0-4]
  - \c ACDBEAgridTemp[0-1]
  - \c GridRadiatorTemp[0-4]
  - \c EPUdigitalVoltage[0-3]
  - \c EPUTemp[0-3]
  - \c EPUCratePowerStat[0-3]
  - \c EPUConverterStat[0-3]
  """
  __regs = []
  __regs.append(gHdb.GattrHsk('ACDShellTemp0',  0))
  __regs.append(gHdb.GattrHsk('ACDShellTemp1',  1))
  __regs.append(gHdb.GattrHsk('ACDconvTemp',    2))
  __regs.append(gHdb.GattrHsk('ACDpowerState',  3))
  __regs.append(gHdb.GattrHsk('ACDpowerSupply', 4))
  offset = 5
  for i in range(12):
    __regs.append(gHdb.GattrHsk('GridTemp%d'%i,     offset  ))
    __regs.append(gHdb.GattrHsk('RadiatorTemp%d'%i, offset+1))
    offset += 2
  __regs.append(gHdb.GattrHsk('RadiatorAfrzTemp0',  offset+0))
  __regs.append(gHdb.GattrHsk('RadiatorAfrzTemp1',  offset+1))
  offset += 2
  for i in range(16):
    __regs.append(gHdb.GattrHsk('CalBaseplateTemp%d'%i, offset))
    offset += 1

  for i in range(6):
    __regs.append(gHdb.GattrHsk('VHCP_DSHP_M_Temp%d'%i, offset+0))
    __regs.append(gHdb.GattrHsk('VHCP_DSHP_P_Temp%d'%i, offset+1))
    __regs.append(gHdb.GattrHsk('VHCP_XLHP_M_Temp%d'%i, offset+2))
    __regs.append(gHdb.GattrHsk('VHCP_XLHP_P_Temp%d'%i, offset+3))
    __regs.append(gHdb.GattrHsk('VHCPRes_M_Temp%d'%i,   offset+4))
    __regs.append(gHdb.GattrHsk('VHCPRes_P_Temp%d'%i,   offset+5))
    offset += 6

  for i in range(16):
    __regs.append(gHdb.GattrHsk('TEM%d_PCBTemp'%i,    offset+0))
    __regs.append(gHdb.GattrHsk('TEM%d_digital33V'%i, offset+1))
    __regs.append(gHdb.GattrHsk('TEM%d_PSTemp'%i,     offset+2))
    __regs.append(gHdb.GattrHsk('TEM%d_powerState'%i, offset+3))
    offset += 4
  for i in range(4):
    __regs.append(gHdb.GattrHsk('ACDpmtRailTemp%d'%i, offset))
    offset += 1
  __regs.append(gHdb.GattrHsk('ACDBEAgridTemp0',offset+0))
  __regs.append(gHdb.GattrHsk('ACDBEAgridTemp1',offset+1))
  offset += 2
  for i in range(4):
    __regs.append(gHdb.GattrHsk('GridRadiatorTemp%d'%i,offset))
    offset += 1
  for i in range(3):
    __regs.append(gHdb.GattrHsk('EPUdigitalVoltage%d'%i,offset+0))
    __regs.append(gHdb.GattrHsk('EPUTemp%d'%i,          offset+1))
    __regs.append(gHdb.GattrHsk('EPUCratePowerStat%d'%i,offset+2))
    __regs.append(gHdb.GattrHsk('EPUConverterStat%d'%i, offset+3))
    offset += 4
  __regs.append(gHdb.GattrHsk('Spare0',offset  ))
  __regs.append(gHdb.GattrHsk('Spare1',offset+1))
  offset += 2

  def __init__(self, client, parent, pduID):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, pduID, self.__regs)

class HCOM(gDb.Gdb):
  """\brief GLAST Communications statistics HSK node record

  Valid Attributes:
  - \c Traffic_LCB0
  - \c Traffic_LCB0
  - \c Traffic_LCB0
  - \c Traffic_1553
  - \c Traffic_SSR
  """
  __regs = [
    gHdb.GattrHsk('Traffic_LCB0',0),
    gHdb.GattrHsk('Traffic_LCB0',1),
    gHdb.GattrHsk('Traffic_LCB0',2),
    gHdb.GattrHsk('Traffic_1553',3),
    gHdb.GattrHsk('Traffic_SSR' ,4),
  ]
  def __init__(self, client, parent):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, None, self.__regs)

class HCPU(gDb.Gdb):
  """\brief GLAST CPU metrics HSK node record

  Valid Attributes:
  - \c CPU_Idle_[0-3]
  - \c CPU_Temp_[0-3]
  - \c MemUsage_[0-3]
  - \c CacheMisses_[0-3]
  - \c TaskStats_[0-3]
  """
  __regs = []
  offset = 0
  for i in range(3):
    __regs.append(gHdb.GattrHsk('CPU_Idle_%d'%i,    offset+0))
    __regs.append(gHdb.GattrHsk('CPU_Temp_%d'%i,    offset+1))
    __regs.append(gHdb.GattrHsk('MemUsage_%d'%i,    offset+2))
    __regs.append(gHdb.GattrHsk('CacheMisses_%d'%i, offset+3))
    __regs.append(gHdb.GattrHsk('TaskStats_%d'%i,   offset+4))
    offset += 5
  def __init__(self, client, parent):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, None, self.__regs)

class HNUL(gDb.Gdb):
  """\brief GLAST HSK null record

  Valid Attributes:
  - \c EMPTY
  """
  __regs = [
    gHdb.GattrHsk('EMPTY',0),
  ]
  def __init__(self, parent):
    """\brief Initialize valid housekeeping quantities as Gattrs
    """
    gDb.Gdb.__init__(self, None, parent, None, self.__regs)

def processGHSK(isSchema, ghdb, node, declarations):
  fn = "processGHSK"
  for n in gSchemaConfig.getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName   == 'htem':
      processHTEM(isSchema, ghdb, n, declarations)
    elif tagName == 'haem':
      processHAEM(isSchema, ghdb, n, declarations)
    elif tagName == 'hgem':
      processHGEM(isSchema, ghdb, n, declarations)
    elif tagName == 'hebm':
      processHEBM(isSchema, ghdb, n, declarations)
    elif tagName == 'hpdu':
      processHPDU(isSchema, ghdb, n, declarations)
    elif tagName == 'hcom':
      processHCOM(isSchema, ghdb, n, declarations)
    elif tagName == 'hcpu':
      processHCPU(isSchema, ghdb, n, declarations)
    elif tagName == 'opaque':
      gSchemaConfig.addOpaque(ghdb, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in ghdb.regs:
      gSchemaConfig.setRegister(ghdb.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing GHSK...Invalid attribute %s" % (fn, n.tagName))

  return ghdb


def processHTEM(isSchema, ghdb, node, declarations):
  fn = "processHTEM"
  if hasAttribute(node,'ID'):
    htemIdSeq = gSchemaConfig.uncompressSequence(getAttribute(node,'ID'))
  else:
    raise KeyError("%s: Configuration error processing HTEM ...No ID attribute for HTEM." % (fn) )

  for htemId in htemIdSeq:
    if isSchema:
      htem = __privateFn(ghdb, '__addHTEM')(ghdb, htemId)
    elif ghdb.existsHTEM(htemId):
      htem = ghdb.downHTEM(htemId)
    else:
      log.debug("%s: Configuration error processing HTEM ...Not populated" %(fn))
      continue
    for n in gSchemaConfig.getChildNodes(node):
      tagName = n.tagName.lower()
      if tagName == 'opaque':
        gSchemaConfig.addOpaque(htem, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName in htem.regs:
        gSchemaConfig.setRegister(htem.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing HTEM # %d ...Invalid attribute %s" % (fn, htemId, n.tagName))

def processHAEM(isSchema, ghdb, node, declarations):
  fn = "processHAEM"
  if isSchema:
    haem = __privateFn(ghdb, '__addHAEM')(ghdb)
  elif ghdb.existsHAEM():
    haem = ghdb.downHAEM()
  else:
    log.debug("%s: Configuration error processing HAEM ...Not populated" %(fn))
    return
  for n in gSchemaConfig.getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'harc':
      processHARC(isSchema, haem, n, declarations)
    elif tagName == 'opaque':
      gSchemaConfig.addOpaque(haem, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in haem.regs:
      gSchemaConfig.setRegister(haem.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing HAEM ...Invalid attribute %s" %(fn, n.tagName))

def processHARC(isSchema, ghdb, node, declarations):
  fn = "processHARC"
  if hasAttribute(node,'ID'):
    harcIdSeq = gSchemaConfig.uncompressSequence(getAttribute(node,'ID'))
  else:
    raise KeyError("%s: Configuration error processing HARC ...No ID attribute for HARC." % (fn) )

  for harcId in harcIdSeq:
    if isSchema:
      harc = __privateFn(ghdb, '__addHARC')(ghdb, harcId)
    elif ghdb.existsHARC(harcId):
      harc = ghdb.downHARC(harcId)
    else:
      log.debug("%s: Configuration error processing HARC ...Not populated" %(fn))
      continue
    for n in gSchemaConfig.getChildNodes(node):
      tagName = n.tagName.lower()
      if tagName == 'opaque':
        gSchemaConfig.addOpaque(harc, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName in harc.regs:
        gSchemaConfig.setRegister(harc.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing HARC # %d ...Invalid attribute %s" % (fn, harcId, n.tagName))





def processHGEM(isSchema, ghdb, node, declarations):
  fn = "processHGEM"
  if isSchema:
    hgem = __privateFn(ghdb, '__addHGEM')(ghdb)
  elif ghdb.existsHGEM():
    hgem = ghdb.downHGEM()
  else:
    log.debug("%s: Configuration error processing HGEM ...Not populated" %(fn))
    return

  for n in gSchemaConfig.getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      gSchemaConfig.addOpaque(hgem, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in hgem.regs:
      gSchemaConfig.setRegister(hgem.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing HGEM ...Invalid attribute %s" %(fn, n.tagName))


def processHEBM(isSchema, ghdb, node, declarations):
  fn = "processHEBM"
  if isSchema:
    hebm = __privateFn(ghdb, '__addHEBM')(ghdb)
  elif ghdb.existsHEBM():
    hebm = ghdb.downHEBM()
  else:
    log.debug("%s: Configuration error processing HEBM ...Not populated" %(fn))
    return

  for n in gSchemaConfig.getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      gSchemaConfig.addOpaque(hebm, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in hebm.regs:
      gSchemaConfig.setRegister(hebm.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing HEBM ...Invalid attribute %s" %(fn, n.tagName))


def processHPDU(isSchema, ghdb, node, declarations):
  fn = "processHPDU"
  if hasAttribute(node,'ID'):
    hpduIdSeq = gSchemaConfig.uncompressSequence(getAttribute(node,'ID'))
  else:
    raise KeyError("%s: Configuration error processing HPDU ...No ID attribute for HPDU." % (fn) )

  for hpduId in hpduIdSeq:
    if isSchema:
      hpdu = __privateFn(ghdb, '__addHPDU')(ghdb,hpduId)
    elif ghdb.existsHPDU(hpduId):
      hpdu = ghdb.downHPDU(hpduId)
    else:
      log.debug("%s: Configuration error processing HPDU %d ...Not populated" %(fn, hpduId))
      return

    for n in gSchemaConfig.getChildNodes(node):
      tagName = n.tagName.lower()
      if tagName == 'opaque':
        gSchemaConfig.addOpaque(hpdu, n)
      elif isSchema:
        log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
      elif tagName in hpdu.regs:
        gSchemaConfig.setRegister(hpdu.regs[tagName], n, declarations)
      else:
        log.error("%s: Configuration error processing HPDU ...Invalid attribute %s" %(fn, n.tagName))


def processHCOM(isSchema, ghdb, node, declarations):
  fn = "processHCOM"
  if isSchema:
    hcom = __privateFn(ghdb, '__addHCOM')(ghdb)
  elif ghdb.existsHCOM():
    hcom = ghdb.downHCOM()
  else:
    log.debug("%s: Configuration error processing HCOM ...Not populated" %(fn))
    return

  for n in gSchemaConfig.getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      gSchemaConfig.addOpaque(hcom, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in hcom.regs:
      gSchemaConfig.setRegister(hcom.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing HCOM ...Invalid attribute %s" %(fn, n.tagName))


def processHCPU(isSchema, ghdb, node, declarations):
  fn = "processHCPU"
  if isSchema:
    hcpu = __privateFn(ghdb, '__addHCPU')(ghdb)
  elif ghdb.existsHCPU():
    hcpu = ghdb.downHCPU()
  else:
    log.debug("%s: Configuration error processing HCPU ...Not populated" %(fn))
    return

  for n in gSchemaConfig.getChildNodes(node):
    tagName = n.tagName.lower()
    if tagName == 'opaque':
      gSchemaConfig.addOpaque(hcpu, n)
    elif isSchema:
      log.error("%s: Unexpected tag: %s" % (fn, n.tagName))
    elif tagName in hcpu.regs:
      gSchemaConfig.setRegister(hcpu.regs[tagName], n, declarations)
    else:
      log.error("%s: Configuration error processing HCPU ...Invalid attribute %s" %(fn, n.tagName))



def readHskConfig(ghsk, cfgFileName):
  """Read a hsk configuration XML file and add its DOM
  to the dictionary of configurations.

  \param  ghsk        Populated schema
  \param  cfgFileName Name of the configuration file in XML format
  \return             The numeric key value of the dictionary entry.
                      -1 if it fails to read the configuration file.
  """
  fn = "readHskConfig"
  curDir = os.getcwd()
  mainFilePath = os.path.dirname(cfgFileName)
  mainFileName = os.path.basename(cfgFileName)
  if mainFilePath != '': os.chdir(mainFilePath)

  try:
    cfgDoc = Sax2.FromXmlFile(cfgFileName)
  except:
    log.exception("%s: Error reading configuration file" % fn)
    os.chdir(curDir)
    return -1

  cfgNode = cfgDoc.documentElement

  includeFiles = []
  gSchemaConfig.processIncludes(cfgDoc, cfgNode, includeFiles, mainFilePath)
  ghsk._GHSK__includeFiles += includeFiles
  cfgDict = ghsk.getConfigurations()
  configSeq = len(cfgDict)
  configName = ''
  configVersion = ''
  if hasAttribute(cfgNode,'name'):
    configName = str(getAttribute(cfgNode,'name'))
  if hasAttribute(cfgNode,'version'):
    configVersion = str(getAttribute(cfgNode,'version'))

  cfgDict[configSeq] = (cfgNode, configName, configVersion)
  os.chdir(curDir)
  return configSeq

def applyHskConfig(ghsk, seq=None):
  """Applies the configuration that may have existed when the schema is read.
     The configuration portion of the schema is stored as a DOM reference
     in the GHSK node. This function accesses that DOM and sets the attributes
     accordingly

  Input ::

    (1) GHSK root of the object model
    (2) Optional sequence number of the configuration

  Output: None

  Usage::

    applyConfig(ghsk)"""

  fn = "applyHskConfig"
  configs = []
  if seq is None:
    if len(ghsk.getConfigurations()) == 0:
      log.debug("%s: Nothing to do, no configuration exists" % fn)
      return
    else:
      configSeqList = ghsk.getConfigurations().keys()
      configSeqList.sort()
      for seq in configSeqList:
        configs.append(ghsk.getConfigurations()[seq][0])
  elif type(seq) == types.IntType:
    if ghsk.getConfigurations().has_key(seq):
      configs.append(ghsk.getConfigurations()[seq][0])
    else:
      log.error("%s: Configuration with sequence %d could not be found" % (fn, seq))
      return

  for config in configs:
    for n in gSchemaConfig.getChildNodes(config):
      processHskConfigProperties(ghsk, n, ghsk.getDeclarations())
      if n.nodeType == Node.ELEMENT_NODE:
        tagname = n.tagName.lower()
        if tagname == 'ghsk':
          if hasAttribute(config,'name'):
            configName = getAttribute(config,'name')
          else:
            configName = '(no name)'
          log.debug("%s: Applying configuration: %s" % (fn, configName))
          processGHSK(0, ghsk, n, ghsk.getDeclarations())

def processHskConfigProperties(ghsk, node, declarations):
  fn = "processHskConfigProperties"
  if node.nodeType == Node.ELEMENT_NODE:
    cfgTagname = node.tagName.lower()
    if cfgTagname == 'declarations':
      gSchemaConfig.processDeclarations(0, node, declarations)
    elif cfgTagname == 'constraints':
      gSchemaConfig.processConstraints(node, declarations)
    elif cfgTagname == 'rules':
      gSchemaConfig.processRules(node, declarations)
    elif cfgTagname == 'egus':
      gSchemaConfig.processEGUs(node, declarations)
    elif cfgTagname in ('ghsk'):
      pass
    else:
      log.error("%s: Unrecognized configuration tag: %s" % (fn, cfgTagname))




def __privateFn(cls, function):
  # local routine to return an arbitrary class attribute.
  # used to return private methods of classes.
  gname = cls.__class__.__name__
  gdict = cls.__class__.__dict__
  return gdict['_' + gname + function]

---