StringTcpProtocol.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Current Value Table Server"
__author__  = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/09/27 21:43:26 $").split(' ')[1]
__version__ = "$Revision: 1.3 $"
__release__  = "$Name: HEAD $"
__credits__ = "SLAC"

import LICOS.copyright_SLAC

import struct, threading, asyncore
# from binascii import hexlify

# import LICOS.util.gOptions as gOptions


class Int16StringProtocol(asyncore.dispatcher, object):
  """Defines a protocol where the messages passed are of the format
     "XX<string>" where <string> is an arbitrary string and XX the
     length of this string expressed as a ushort.  The max length of
     <string> is 0xffff bytes.  Locks are used to prevent buffer overwrites.
  """
  MAXSTRINGLEN  = 0xffff
  def __init__(self, port=None):
    super(Int16StringProtocol, self).__init__(port)
    
    self.__readBuffer = ''
    self.__writeBuffer = ''
    self.__writeLock = threading.Lock()
  
  def readable(self):
    return True
    
  def writable(self):
    self.__writeLock.acquire()
    retVal = len(self.__writeBuffer) > 0
    self.__writeLock.release()
    return retVal
    
  def handle_read(self):
    """ Read the socket and parse into messages.
    """
    self.__readBuffer += self.recv(8192)
    # print "handle_read", len(self.__readBuffer)
    while len(self.__readBuffer) > 1:
      length = (ord(self.__readBuffer[0])*0x100) + ord(self.__readBuffer[1])
      if len(self.__readBuffer) < length+2:
        break
      dataString = self.__readBuffer[2:length+2]
      self.__readBuffer = self.__readBuffer[length+2:]
      # print "dispatch string", len(dataString)
      self.stringReceived(dataString)
  
  def handle_write(self):
    self.__writeLock.acquire()
    sent = self.send(self.__writeBuffer)
    self.__writeBuffer = self.__writeBuffer[sent:]
    self.__writeLock.release()  
  
  def stringReceived(self, line):
    """!\brief Receive a string from the socket
    
    \param line  The string from the socket
    """
    # print line
    raise NotImplementedError, "stringReceived must be overridden in a derived class"
  
  def sendString(self, data):
    """!\brief Send a string through the socket
    
    \param data  String data to send through the socket.
    
    If len(data) > 0xffff, ValueError is raised.
    """
    if len(data) > self.MAXSTRINGLEN:
      raise ValueError, "sendString: Max string length %x exceeded.  String length attempted = %x", (self.MAXSTRINGLEN, len(data))
    message = struct.pack("!H", len(data)) + data
    self.__writeLock.acquire()
    self.__writeBuffer += message
    self.__writeLock.release()
    



if __name__ == '__main__':
  pass







#eof

---