VscProxyTools.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__ = "Tools for VSC packet handling"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/19 02:56:08 $"
__version__  = "$Revision: 1.10 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from LICOS.lib.cmdTlmDb.LCATtlmDb           import LICOS_VscTlmPacketFactory

from binascii import hexlify

from VSC import VscHandling
import socket
import threading
import struct
import sys
import time
import logging as log


class PacketDispatcher(object):
  """!\brief PacketDispatcher class

  Class used to define a dispatch system for VSC packets
  """
# Implementation notes:
#
#  Note the use of super() in PacketDispatcher, TelemetryDispatcher
#  and ScienceDispatcher.  This usage allows us to use the mixin
#  class PacketDispatcher to replace the process method of
#  the various packet handlers with something a bit more useful.
#
#  Important:  The order of classes in multiple inheritance situations
#  is critical when using super().  The first call to super() will
#  call the first in the chain.  Thus, the call to super.__init
#  in TelemetryDispatcher calls the __init__ of PacketDispatcher.
#  In that function, the call to super.__init__ will call
#  the __init__ method of the *next* class in the MI chain.
#  A good tutorial on super() is at
#  http://wiki.osafoundation.org/bin/view/Projects/UsingSuper
  def __init__(self):
    super(PacketDispatcher, self).__init__()
    self.__handlerList = []
    self.__lock = threading.Lock()

  def process(self, dat):
    """!\brief process method

    Loops over the registered handlers and calls their process() methods.
    If a packet isn't handled by any of the handlers, the catchall()
    method is called.

    \param dat A VSC packet (any type)
    """
    # print "pktdis.process", dat, dat.apid()
    self.__lock.acquire()
    try:
      caught=False
      # print self.__handlerList
      for handler in self.__handlerList:
        # print handler.catchable(dat)
        if handler.catchable(dat):
          handler.process(dat)
          caught=True
      if not caught:
        self.catchall(dat)
    except Exception, e:
      print e
      self.__lock.release()
      raise
    else:
      self.__lock.release()

  # def catchable(self, dat):
    # print "catchable"
    # self.__lock.acquire()
    # catch = False
    # for handler in self.__handlerList:
      # if handler.catchable(dat):
        # print "setting catch=True for apid %x" % dat.apid()
        # catch = True
        # break
    # self.__lock.release()
    # return catch

  def register(self, handler):
    """!\brief register method

    register a handler with the dispatcher.

    \param handler A VSC Handler object
    """
    self.__lock.acquire()
    if handler not in self.__handlerList:
      self.__handlerList.append(handler)
      self.__ranOnce = False
    self.__lock.release()

  def unregister(self, handler):
    """!\brief unregister method

    remove a handler from the dispatcher's registry.

    \param handler A VSC Handler object
    """
    self.__lock.acquire()
    if handler in self.__handlerList:
      self.__handlerList.remove(handler)
      self.__ranOnce = False
    self.__lock.release()

  def catchall(self, dat):
    """!\brief catchall method

    process all packets that are not processed by one of the registered handlers.

    \param dat A VSC packet (any type)
    """
    log.debug("catchall called for apid %d=0x%03x"%(dat.apid(), dat.apid()))

class TelemetryDispatcher(PacketDispatcher, VscHandling.TelemetryHandler):
  """!\brief TelemetryDispatcher class

  A dispatcher for VSC telemetry data.
  """
  def __init__(self, apidRange=[0x200,0x25f]):
    super(TelemetryDispatcher, self).__init__()
    self.handle(apidRange[0], apidRange[1])

  def process(self, dat):
    # print "TelemetryDispatcher.process()"
    super(TelemetryDispatcher, self).process(dat)

  # def catchable(self, dat):
    # print "catch22"
    # super(TelemetryDispatcher, self).catchable(dat)

class ScienceDispatcher(PacketDispatcher, VscHandling.ScienceHandler):
  """!\brief ScienceDispatcher class

  A dispatcher for VSC science data.
  """
  def __init__(self):
    super(ScienceDispatcher, self).__init__()
    self.handle(0x0,0xffff)

  def process(self, dat):
    super(ScienceDispatcher, self).process(dat)

#  def catchable(self, dat):
#    super(ScienceDispatcher, self).catchable(dat)

class TestTelemetryHandler(VscHandling.TelemetryHandler):
  def __init__(self):
    VscHandling.TelemetryHandler.__init__(self)

    self.handle(0x0,0xffff)

  def process(self, dat):
    packet = LICOS_VscTlmPacketFactory(dat)
    print "packet: %x" % packet.apid, packet.name  #, hexlify(packet.encode_packet())

class SocketTelemetrySender(VscHandling.TelemetryHandler):
  """Send CCSDS packets over a socket to the Current Value Table
  """
  TIMEOUT=10
  CONNECT_MSG  = "ok CCSDS\n"
  def __init__(self, destSocket, apidLow, apidHigh):
    VscHandling.TelemetryHandler.__init__(self)
    self.handle(apidLow, apidHigh)

    self.__sock = destSocket

  def process(self, pkt):
    # print "STS: pkt"
    if self.__sock.isConnected():
      data = encodePacket(pkt)
      sendStr = struct.pack("!H", len(data)) + data

      try:
        self.__sock.send(sendStr)
      except:
        self.__sock.disconnect()
    else:
      log.debug("no connection, dumping packet on floor")


def getip(hostname):
  """!\brief getip method.

  \param hostname Host name

  \return IP address
  """
  (name, alias, ipaddr_list) = socket.gethostbyname_ex(hostname)
  ipdotted = ipaddr_list[0]
  ips = socket.inet_aton(ipdotted)
  (ip,) = struct.unpack('!i', ips)
  return ip

def encodePacket(pkt):
    # may want to move this to an external function.  **REVISIT** --JHP
    # create the packet header
    pkthdr = 0L
    pkthdr = pkthdr << 3
    pkthdr = pkthdr | pkt.version()
    pkthdr = pkthdr << 1
#    pkthdr = pkthdr | pkt.isTelecommand()
    pkthdr = pkthdr << 1
    pkthdr = pkthdr | 0x1                  # secondary header
    pkthdr = pkthdr << 11
    pkthdr = pkthdr | pkt.apid()
    pkthdr = pkthdr << 2
    pkthdr = pkthdr | pkt.seqFlags()
    pkthdr = pkthdr << 14
    pkthdr = pkthdr | pkt.seqNum()
    pkthdr = pkthdr << 16
    pkthdr = pkthdr | pkt.length()
    pkthdr = pkthdr << 32
    pkthdr = pkthdr | pkt.secs()
    pkthdr = pkthdr << 32
    pkthdr = pkthdr | pkt.usecs()

    # marshall the packet header into a binary string
    pktstr = ''
    bitsleft = 112
    while bitsleft > 0:
      pktstr = struct.pack( 'B', pkthdr & 0xFF ) + pktstr
      pkthdr = pkthdr >> 8
      bitsleft = bitsleft - 8

    # append the packet payload data
    pktstr = pktstr + str( pkt.payload() )
    return pktstr

class VscProxyLogger(object):
  def __init__(self, name):
    self.__name = name

  def write(self, buffer):
    if buffer == '\n': return
    t = time.strftime('%Y.%m.%d %H:%M:%S ', time.localtime())
    sys.__stdout__.write(t + self.__name + buffer + '\n')

  def flush(self):
    sys.__stdout__.flush()

---