HskCli.py

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


__facility__ = "Online"
__abstract__ = "Housekeeping handler client"
__author__   = "Jim Panetta SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2005/01/26 23:35:26 $").split(' ')[1]
__created__  = "2004/08/27"
__version__  = "$Revision: 1.3 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import logging as log
import select
import struct
import threading
import time

import LATTE.client.gCommand      as gCommand
import LATTE.client.gSocket       as gSocket
import LATTE.client.gException    as gException


CMD_RX_PORT    = 8000
CMD_TX_PORT    = 8001
TELEM_PORT     = 8002

CMD_RX_SIZE    = 62
CMD_TX_SIZE    = 62
TELEM_SIZE     = 842
HSK_SIZE       = 116


class HskCli(object):
  """\brief Housekeeping client input/output class

  This class instantiates and controls the sockets for the housekeeping process.
  """
  def __init__(self, handler=None):
    self.__cmdRx = HskCmdRxSocket(handler)
    self.__cmdTx = HskCmdTxSocket(handler)
    self.__telem = HskTelemSocket(handler)
    self.readCmdRx = self.__cmdRx.read
    self.readCmdTx = self.__cmdTx.read
    self.readTelem = self.__telem.read

  def connect(self, server):
    """\brief connect method

    \param server  the hostname where the housekeeping server process runs
    connect the housekeeping system to the housekeeping server
    """
    self.__cmdRx.connect(server)
    self.__cmdTx.connect(server)
    self.__telem.connect(server)
    self.readCmdRx = self.__cmdRx.read
    self.readCmdTx = self.__cmdTx.read
    self.readTelem = self.__telem.read

  def disconnect(self):
    """\brief disconnect method

    disconnect the housekeeping system from housekeeping server
    """
    self.__cmdRx.disconnect()
    self.__cmdTx.disconnect()
    self.__telem.disconnect()

  def handler(self, newhandler):
    self.__cmdRx.handler(newhandler)
    self.__cmdTx.handler(newhandler)
    self.__telem.handler(newhandler)

class ccsdsSocket(gSocket.Socket):
  UNPACK_ERROR   = -1001

  def __init__(self, handler=None, debug=0, port=0):
    gSocket.Socket.__init__(self, port)
    self.__handler = handler

    self.__timeout         = 30
    self.__timeoutEnabled  = False
    self.read              = None

  def connect(self, host):
    gSocket.Socket.connect(self, host)
    self.read = self.readCCSDS

  def disconnect(self):
    gSocket.Socket.disconnect(self)
    self.read = None

  def handler(self, newhandler):
    self.__handler = newhandler

  def readCCSDS(self):
    """\brief CCSDS read routine.

    This routine does the minimal work of reading the raw CCSDS
    data from a socket.

    \return socket buffer read
    """
    self.lock()
    try:
      # read CCSDS primary header...
      dat = self.recvall(6)
      h = struct.unpack('!HHH',dat)
      # CCSDS packet length encoding:
      #   h[2] = 2ndary hdr (8) + payload (102) - 1
      #   total bytes left = h[2] + 1
      numLeft = h[2] + 1
      dat += self.recvall(numLeft)
      self.release()
    except:
      self.release()
      if self.__handler is not None:
        self.__handler.timedout()
      status = gException.LATInterfaceStatus.status('OCS_TMO')
      raise gException.LATInterfaceException(status)

    if len(dat) == 0:
      if self.__handler is not None:
        self.__handler.disconnected()
      status = gException.LATInterfaceStatus.status('OCS_NOSRV')
      raise gException.LATInterfaceException(status)

    return (0, dat)

  def setTimeoutEnabled(self, flag):
    """\brief Enable or disable event timeout

    \param flag 1 = Enable event timeout
                0 = Disable event timeout (default)
    """
    self.__timeoutEnabled = flag;

  def isTimeoutEnabled(self):
    """\brief Checks the event timeout state

    \return 1 = If event timeout is enabled
            0 = If event timeout is disabled
    """
    return self.__timeoutEnabled

  def setTimeout(self, timeout):
    """\brief Set the timeout value.

    \param timeout Event timeout value as a floating point number in seconds.
                   Default is 1 second.
    """
    self.__timeout = timeout

  def getTimeout(self):
    """\brief Query the current timeout value.

    \return Current event timeout value as a floating point number in seconds
    """
    return self.__timeout

class HskCmdRxSocket(ccsdsSocket):
  def __init__(self, handler=None, debug=0, port=CMD_RX_PORT):
    ccsdsSocket.__init__(self, handler, debug, port)

class HskCmdTxSocket(ccsdsSocket):
  def __init__(self, handler=None, debug=0, port=CMD_TX_PORT):
    ccsdsSocket.__init__(self, handler, debug, port)

class HskTelemSocket(ccsdsSocket):
  def __init__(self, handler=None, debug=0, port=TELEM_PORT):
    ccsdsSocket.__init__(self, handler, debug, port)


class ConnectState:
  Disconnected = 0
  Waiting      = 1
  Connected    = 2

class HskHandler(object):
  """\brief HskHandler class

  Defines connection protocol to hsk server.
  This class needs to define two calls:  disconnected and timeout.

  Inherit from this to create GUI versions of HskSvr
  """
  def __init__(self, server, host):
    self.__server = server
    self.__host   = host
    server.handler(self)
    self.__connection_state = ConnectState.Disconnected    # disconnected at startup
    self.connect()

  def connect(self):
    """\brief connect

    Connect to the command/hsk server
    """
    self.__connection_state = ConnectState.Waiting
    self.__tries = 0
    self.__connect()

  def disconnected(self):
    """\brief disconnected

    """
    self.__disconnect()

  def timedout(self):
    """\brief timedout
    """
    self.__disconnect()

  def __disconnect(self):
    # disconnect from the server
    self.__server.disconnect()
    # deal with the outcome of disconnecting
    self.__connection_notthere()

  def __connect(self):
    # spawn the connecting thread in the background
    connecthdlr = threading.Thread(None, self.__connection_handler, 'ConnectHandler',())
    connecthdlr.setDaemon(True)
    connecthdlr.start()

  def __connection_handler(self):
    while (True):
      try:
        self.__server.connect(self.__host)
        log.info("HSK server is now connected")
        self.__connection_state = ConnectState.Connected
        self.__tries = 0
        break
      except RuntimeError, msg:
        if self.__tries == 0:
          log.error(msg)
        self.__tries += 1
        state = self.__connection_state
        if state == ConnectState.Disconnected: break
        time.sleep(3)

  def __connection_notthere(self):
    # Do this once...
    if self.__connection_state == ConnectState.Connected:
      log.error("HSK server disconnected, trying to reconnect")
      self.__connection_state = ConnectState.Waiting
      self.__connect()

---