DiagnosticProxy.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Diagnostic Proxy class"
__author__   = "S. Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/09/06"
__updated__  = "$Date: 2006/04/25 17:22:01 $"
__version__  = "$Revision: 1.24 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import os
import time
import sys
from ConfigParser import ConfigParser

import VSC
import CCSDS

from LICOS.util.gOptions             import Options
from LICOS.tools.proxy.VscProxyPorts import VscProxyPorts
from LICOS.tools.proxy.VscProxyTools import getip, VscProxyLogger

class VscTelemetryRouter(VSC.VscRouting.TelemetryRouter):
  def __init__(self, streamList):
    VSC.VscRouting.TelemetryRouter.__init__(self)
    self.__packet = CCSDS.Ccsds.Telemetry(0, 0, 0)
    self.__streamList = streamList
    if len(self.__streamList) == 0:
      raise "cannot have empty stream list"
    self.__counter = 0

  def allocate(self):
    return self.__packet

  def catchall(self, ccsds):
    self.__counter += 1
    for stream in self.__streamList:
      stream.send_nothrow(ccsds)

  def packets(self):
    return self.__counter

class DiagnosticProxy(VSC.VscProxy.Proxy):
  def __init__(self, ip_vsc, config, noarchiver):
    ports = VscProxyPorts(config.getint('vsc', 'proxyPortBase'))
    VSC.VscProxy.Proxy.__init__(self, ip_vsc, ports.vsc())

    # create the pass through handlers to ScriptEngine
    self.__vscSender = VSC.VscNetwork.TelemetrySender()
    self.__latSender = VSC.VscNetwork.TelemetrySender()
    # connect plumbing for ScriptEngine pass through
    print "Creating ScriptEngine passthrough on port %d" % ports.diagnostic()
    self.__connector = VSC.VscProxy.RequestRouter(ports.diagnostic())
    self.__connector.handle(self.__vscSender, VSC.VscProxy.VscDiagnostic)
    self.__connector.handle(self.__latSender, VSC.VscProxy.LatDiagnostic)
    self.__connector.start()

    # create the pass through handlers to ScriptEngine
    self.__vscMonSender = VSC.VscNetwork.TelemetrySender()
    self.__latMonSender = VSC.VscNetwork.TelemetrySender()
    # connect plumbing for diagnostic monitor pass through
    print "Creating monitor passthrough on port %d" % ports.diagMon()
    self.__monConnector = VSC.VscProxy.RequestRouter(ports.diagMon())
    self.__monConnector.handle(self.__vscMonSender, VSC.VscProxy.VscDiagnostic)
    self.__monConnector.handle(self.__latMonSender, VSC.VscProxy.LatDiagnostic)
    self.__monConnector.start()

    vscStreams = [self.__vscSender, self.__vscMonSender]
    latStreams = [self.__latSender, self.__latMonSender]

    if noarchiver is False:
      # Import here if archiving is enabled otherwise Windows will complain -ST
      from LICOS.tools.proxy.VscArchivers  import VscArchiver
      archive_path = config.get('paths', 'archive_path')
      granularity  = config.getint('ccsds_archivers', 'granularity')
      self.__archiver = VscArchiver(apIdGrp = "DIA",
                                    path = archive_path,
                                    granularity = granularity)
      vscStreams.append(self.__archiver)
      latStreams.append(self.__archiver)

    self.vscRouter = VscTelemetryRouter(vscStreams)
    self.latRouter = VscTelemetryRouter(latStreams)
    self.vscDiagnostic(self.vscRouter)
    self.latDiagnostic(self.latRouter)


if __name__ == '__main__':
  options = Options(['vscip', 'config'], [], ['logtime', 'noarchiver'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(str(msg))
    sys.exit()

  if options.logtime is not None:
    sys.stdout = VscProxyLogger('diagnostic proxy: ')
    sys.stderr = sys.stdout

  vscip = getip(options.vscip)
  config = ConfigParser()
  config.read(options.config)
  dumpInterval = config.getint('vsc', 'dumpInterval')
  noarchiver = (options.noarchiver is not None)
  proxy = DiagnosticProxy(vscip, config, noarchiver)

  while True:
    time.sleep(dumpInterval)
    print 'received %d VSC packets' %proxy.vscRouter.packets()
    print 'received %d LAT packets' %proxy.latRouter.packets()
    sys.stdout.flush()

---