gSocket.py

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


__facility__ = "Online"
__abstract__ = "Socket class"
__author__   = "Amedeo Perazzo <perazzo@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2005/10/28 22:02:14 $").split(' ')[1]
__version__  = "$Revision: 2.13 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import socket
import threading
import logging as log

class Socket(object):
  __TIMEOUT = 5

  def __init__(self, portnumber):
    self.__port = portnumber
    self.__sock = None
    self.__host = None
    self.__lock = threading.Lock()

  def connect(self, host):
    if host is None:
      raise RuntimeError, 'gSocket: host server name not specified'
    try:
      self.__sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      self.__sock.settimeout(Socket.__TIMEOUT)  # TMOs are not handled correctly
      self.__sock.connect((host, self.__port))
      self.__host = host
    except socket.error, msg:
      self.disconnect()
      raise RuntimeError, \
            'gSocket: unable to connect to %s on port %d: %s' \
            %(host, self.__port, str(msg))
    ss = 2*1024*1024
    self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, ss)

  def disconnect(self):
    if self.isConnected():
      self.__sock.close()
      self.__sock = None

  def isConnected(self):
    return (self.__sock is not None)

  def socket(self):
    return self.__sock

  def setSocket(self, sock):
    self.__sock = sock

  def port(self):
    return self.__port

  def setPort(self, port):
    self.__port = port

  def lock(self):
    self.__lock.acquire()

  def release(self):
    self.__lock.release()

  def gettimeout(self):
    return self.__sock.gettimeout()

  def settimeout(self, seconds):
    self.__sock.settimeout(seconds)

  def send(self, packet):
    return self.__sock.send(packet)

  def recv(self, size):
    return self.__sock.recv(size)

  def sendall(self, packet):
    return self.__sock.sendall(packet)

  def recvall(self, size):
    # The following is not supported on Windows, at least.
    # return self.__sock.recv(size, socket.MSG_WAITALL)

    data = ''
    remaining = size
    sock = self.__sock
    count = 0
    while remaining > 0:
      try:
        received = sock.recv(remaining)
        reclen = len(received)
        # When a recv returns 0 bytes, other side has closed
        if reclen == 0: return received
        remaining -= reclen
        data += received
      except socket.error, e:
        if str(e) != "timed out": raise # Throw away "timed out" exceptions
        log.warn("Exception seen in recvall: %s" % str(e))
        if count > 5:
          raise
        count += 1
    return data

  def purge(self):
    """\brief Purge all stale data out of the socket.
    """
    max  = 64*1024
    sock = self.__sock
    tmo  = sock.gettimeout()
    size = 0
    sock.settimeout(0.1)
    try:
      # While loop will break on exception
      while True:
        received = sock.recv(max)
        # When a recv returns 0 bytes, other side has closed
        reclen = len(received)
        if reclen == 0:
          break
        size += reclen
    except socket.error, e:
      if str(e) != "timed out":  raise # Throw away "timed out" exceptions
    sock.settimeout(tmo)
    return size

---