VscArchivers.py

Go to the documentation of this file.

#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Writes CCSDS packets to file"
__author__   = "<perazzo@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__version__  = "$Revision: 1.16 $"
__credits__  = "SLAC"

import logging as log
import threading
import time
import os
from binascii import hexlify

import Queue

class VscArchiver(object):
  MinInterval = 10
  PrimaryHeaderSize = 6
  CCSDSLengthCorrection = PrimaryHeaderSize + 1
  def __init__(self, apIdGrp, path, granularity):
    self.__apIdGrp  = apIdGrp
    self.__path     = path

    if (granularity < VscArchiver.MinInterval):
      log.warning('File creation interval increased: minimum is %d secs'
                  ' requested was %d secs',
                  VscArchiver.MinInterval, granularity)
      self.__granularity = VscArchiver.MinInterval
    else:
      self.__granularity = granularity

    self.__shutdown = False
    self.__queue = Queue.Queue()
    self.__archivtask = threading.Thread(name="archive", target=self.__archive)
    self.__archivtask.start()

    self.__expired = threading.Event()
    self.__timertask = threading.Thread(name="timer", target=self.__timer)
    self.__timertask.start()

  def send(self, packet):
    data = packet.header()
    datacopy = data[:1] + data[1:packet.length()+self.CCSDSLengthCorrection]
    packet.unswap(datacopy)
    self.__queue.put(datacopy, block=True)

  def send_nothrow(self, packet):
    # Passthrough function to mimic TelemetrySender's new send_nothrow function
    self.send(packet)

  def abort(self):
    self.__shutdown = True
    # Set the event flag to true in order to shutdown the timer task
    self.__expired.set()
    self.__timertask.join()
    # Queue zero length data in order to shutdown the archiver task
    self.__queue.put('', block=True)
    self.__archivtask.join()

  def __timer(self):
    timeout = self.__granularity
    while True:
      self.__expired.wait(timeout)
      if self.__expired.isSet():
        break
      # Queue zero length data in order to trigger the closing of the file
      self.__queue.put('', block=False)
    
  def __archive(self):
    self.__newfile()
    while True:
      data = self.__queue.get(block=True)
      datalen = len(data)
      if datalen > 0:
        self.__file.write(data)
      else:
        if self.__shutdown:
          break
        else:
          self.__close()
          self.__newfile()
    self.__close()

  def __newfile(self):
    now = time.time()
    t = time.gmtime(now)
    name = 'GLAST_%04d%03d_%02d%02d%02d_%s' \
           %(t.tm_year, t.tm_yday, t.tm_hour, t.tm_min, t.tm_sec,
             self.__apIdGrp)
    self.__file = file(os.path.join(self.__path, name), 'w+b', 0)

  def __close(self):
    name = self.__file.name
    self.__file.close()
    os.rename(name, '%s.pkt' %(name))
      

---