net.py

   1 #!/usr/bin/python
   2
   3 import sys
   4 import socket
   5 import logging
   6 import traceback
   7 from threading import Thread
   8 from time import sleep
   9 from protocol import *
  10
  11 logger = logging.getLogger(__name__)
  12
  13 class NetServer(Thread):
  14         def __init__(self, handler=None, handler_connect=None, handler_disconnect=None):
  15                 Thread.__init__(self)
  16                 self.setDaemon(True)
  17                 self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  18                 self.sck.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  19                 self.sck.bind(("", 10001))
  20                 self.sck.listen(1)
  21                 self.sck.setblocking(0)
  22                 self.bRun = False
  23                 self.handler = handler
  24                 self.handler_connect = handler_connect
  25                 self.handler_disconnect = handler_disconnect
  26                 self.start()
  27
  28         def run(self):
  29                 self.bRun = True
  30                 while(self.bRun):
  31                         sleep(0.01)
  32                         try:
  33                                 conn, addr = self.sck.accept()
  34                                 #conn.settimeout(0.01)
  35                         except:
  36                                 continue
  37                         logger.debug("New Connection")
  38                         proto = Protocol(NetWrapper(conn))
  39                         if self.handler_connect:
  40                                 self.handler_connect(proto)
  41                         while True:
  42                                 try:
  43                                         addr, msg = proto.receive()
  44                                 except socket.error, e:
  45                                         if e.errno == 11:
  46                                                 logger.debug("Connection lost")
  47                                         elif e.errno:
  48                                                 logger.debug("Socket Error %d", e.errno)
  49                                                 traceback.print_exc(file=sys.stdout)
  50                                         break
  51                                 except TimeoutException:
  52                                         continue
  53                                 except ByteError:
  54                                         continue
  55                                 except NAKReceived:
  56                                         continue
  57                                 except:
  58                                         traceback.print_exc(file=sys.stdout)
  59                                         break
  60
  61                                 if self.handler:
  62                                         try:
  63                                                 self.handler(addr, msg)
  64                                         except:
  65                                                 traceback.print_exc(file=sys.stdout)
  66                         logger.debug("Connection Ended")
  67                         if self.handler_disconnect:
  68                                 self.handler_disconnect(proto)
  69                         conn.close()
  70
  71         def stop(self):
  72                 self.bRun = False
  73
  74
  75 class NetWrapper:
  76         def __init__(self, sck):
  77                 self.sck = sck
  78
  79         def write(self, s):
  80                 return self.sck.send(s)
  81
  82         def read(self, i):
  83                 return self.sck.recv(i)
  84
  85         def close(self):
  86                 return self.sck.close()
  87
  88 class NetClient(Protocol, Thread):
  89         def __init__(self, kTarget, handler=None):
  90                 Thread.__init__(self)
  91                 self.setDaemon(True)
  92                 self.comm = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  93                 self.comm.connect(kTarget)
  94                 self.comm.setblocking(0)
  95                 self.comm.settimeout(0.01)
  96                 Protocol.__init__(self, NetWrapper(self.comm))
  97                 self.handler = handler
  98                 self.bRun = False
  99
 100         def run(self):
 101                 self.bRun = True
 102                 while(self.bRun):
 103                         sleep(0.01)
 104                         try:
 105                                 addr, msg = self.receive()
 106                                 if self.handler:
 107                                         self.handler(addr, msg)
 108                         except socket.error, e:
 109                                 if hasattr(e, "errno") and e.errno == 9:
 110                                         #print "Connection lost"
 111                                         break
 112                                 elif e.message == "timed out":
 113                                         pass
 114                                 else:
 115                                         traceback.print_exc(file=sys.stdout)
 116                         except TimeoutException:
 117                                 pass
 118                         except:
 119                                 traceback.print_exc(file=sys.stdout)
 120                 self.comm.close()
 121
 122         def receive(self):
 123                 i = 0
 124                 while True:
 125                         i+=1
 126                         try:
 127                                 return Protocol.receive(self)
 128                         except:
 129                                 if i > 300:
 130                                         raise
 131                         sleep(0.01)
 132
 133         def stop(self):
 134                 self.bRun = False
 135
 136
 137 if __name__ == "__main__":
 138         def handler(addr, s):
 139                 print addr, s
 140
 141         if sys.argv[1] == "server":
 142                 pNet = NetServer(handler)
 143                 while(1):
 144                         sleep(1)
 145         elif sys.argv[1] == "client":
 146                 pNet = NetClient(("192.168.36.14", 10001))
 147                 pNet.send(0, "lights")