server/my_threading.py

   1
   2 __all__ = ['Thread', 'schedule', 'sleep']
   3
   4 import time
   5
   6 try:
   7     import stackless
   8     import stackless_socket
   9     import socket
  10     stackless_socket.install()
  11
  12     Thread = stackless.tasklet
  13     schedule = stackless.schedule
  14
  15     from heapq import heappush
  16
  17     sleepingTasklets = []
  18
  19     class Lock(object):
  20         __enter__ = lambda *args: None
  21         __exit__ = lambda *args: None
  22
  23     class Event(object):
  24         val = False
  25         channel = stackless.channel()
  26
  27         def set(self):
  28             val = True
  29             self.channel.send(None)
  30         def clear(self):
  31             val = False
  32         def wait(self):
  33             self.val or self.channel.receive()
  34
  35     def sleep(seconds):
  36         channel = stackless.channel()
  37         endTime = time.time() + seconds
  38         heappush(sleepingTasklets, (endTime, channel))
  39         # Block until we get sent an awakening notification.
  40         channel.receive()
  41
  42     class ThreadingMixIn:
  43         def handle_request(self):
  44             try:
  45                 request, client_address = self.get_request()
  46             except socket.error:
  47                 return
  48             stackless.tasklet(self.handle_request_tasklet)(request, client_address)
  49             stackless.schedule()
  50
  51         def handle_request_tasklet(self, request, client_address):
  52             if self.verify_request(request, client_address):
  53                 try:
  54                     self.process_request(request, client_address)
  55                 except:
  56                     self.handle_error(request, client_address)
  57                     self.close_request(request)
  58
  59     def ManageSleepingTasklets():
  60         while True:
  61             while len(sleepingTasklets):
  62                 endTime = sleepingTasklets[0][0]
  63                 if endTime > time.time():
  64                     break
  65                 channel = sleepingTasklets[0][1]
  66                 sleepingTasklets.pop(0)
  67                 # It does not matter what we send as it is not used.
  68                 channel.send(None)
  69             stackless.schedule()
  70
  71     stackless.tasklet(ManageSleepingTasklets)()
  72
  73 except ImportError:
  74     from threading import Thread as PyThread
  75     from threading import Lock, Event
  76     from SocketServer import ThreadingMixIn
  77
  78     class Thread(PyThread):
  79         def __init__(self, func):
  80             super(Thread, self).__init__(target=func)
  81
  82         def __call__(self):
  83             super(Thread, self).start()
  84
  85     def schedule():
  86         pass
  87
  88     sleep = time.sleep
  89
  90