home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / BitTorrent / RawServer.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  15.4 KB  |  597 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. from bisect import insort
  5. import socket
  6. from cStringIO import StringIO
  7. from traceback import print_exc
  8. from errno import EWOULDBLOCK, ENOBUFS
  9.  
  10. try:
  11.     from select import poll, error, POLLIN, POLLOUT, POLLERR, POLLHUP
  12.     timemult = 1000
  13. except ImportError:
  14.     from selectpoll import poll, error, POLLIN, POLLOUT, POLLERR, POLLHUP
  15.     timemult = 1
  16.  
  17. from threading import Thread, Event
  18. from time import time, sleep
  19. import sys
  20. from random import randrange
  21. all = POLLIN | POLLOUT
  22.  
  23. class SingleSocket:
  24.     
  25.     def __init__(self, raw_server, sock, handler):
  26.         self.raw_server = raw_server
  27.         self.socket = sock
  28.         self.handler = handler
  29.         self.buffer = []
  30.         self.last_hit = time()
  31.         self.fileno = sock.fileno()
  32.         self.connected = False
  33.  
  34.     
  35.     def get_ip(self):
  36.         
  37.         try:
  38.             return self.socket.getpeername()[0]
  39.         except socket.error:
  40.             return 'no connection'
  41.  
  42.  
  43.     
  44.     def close(self):
  45.         sock = self.socket
  46.         self.socket = None
  47.         self.buffer = []
  48.         del self.raw_server.single_sockets[self.fileno]
  49.         self.raw_server.poll.unregister(sock)
  50.         sock.close()
  51.  
  52.     
  53.     def shutdown(self, val):
  54.         self.socket.shutdown(val)
  55.  
  56.     
  57.     def is_flushed(self):
  58.         return len(self.buffer) == 0
  59.  
  60.     
  61.     def write(self, s):
  62.         self.buffer.append(s)
  63.         if len(self.buffer) == 1:
  64.             self.try_write()
  65.         
  66.  
  67.     
  68.     def try_write(self):
  69.         if self.connected:
  70.             
  71.             try:
  72.                 while self.buffer != []:
  73.                     amount = self.socket.send(self.buffer[0])
  74.                     if amount != len(self.buffer[0]):
  75.                         if amount != 0:
  76.                             self.buffer[0] = self.buffer[0][amount:]
  77.                         
  78.                         break
  79.                     
  80.                     del self.buffer[0]
  81.             except socket.error:
  82.                 e = None
  83.                 (code, msg) = e
  84.                 if code != EWOULDBLOCK:
  85.                     self.raw_server.dead_from_write.append(self)
  86.                     return None
  87.                 
  88.             except:
  89.                 code != EWOULDBLOCK
  90.             
  91.  
  92.         None<EXCEPTION MATCH>socket.error
  93.         if self.buffer == []:
  94.             self.raw_server.poll.register(self.socket, POLLIN)
  95.         else:
  96.             self.raw_server.poll.register(self.socket, all)
  97.  
  98.  
  99.  
  100. def default_error_handler(x):
  101.     print x
  102.  
  103.  
  104. class RawServer:
  105.     
  106.     def __init__(self, doneflag, timeout_check_interval, timeout, noisy = True, errorfunc = default_error_handler, maxconnects = 55):
  107.         self.timeout_check_interval = timeout_check_interval
  108.         self.timeout = timeout
  109.         self.poll = poll()
  110.         self.single_sockets = { }
  111.         self.dead_from_write = []
  112.         self.doneflag = doneflag
  113.         self.noisy = noisy
  114.         self.errorfunc = errorfunc
  115.         self.maxconnects = maxconnects
  116.         self.funcs = []
  117.         self.unscheduled_tasks = []
  118.         self.add_task(self.scan_for_timeouts, timeout_check_interval)
  119.  
  120.     
  121.     def add_task(self, func, delay):
  122.         self.unscheduled_tasks.append((func, delay))
  123.  
  124.     
  125.     def scan_for_timeouts(self):
  126.         self.add_task(self.scan_for_timeouts, self.timeout_check_interval)
  127.         t = time() - self.timeout
  128.         tokill = []
  129.         for s in self.single_sockets.values():
  130.             if s.last_hit < t:
  131.                 tokill.append(s)
  132.                 continue
  133.         
  134.         for k in tokill:
  135.             if k.socket is not None:
  136.                 self._close_socket(k)
  137.                 continue
  138.         
  139.  
  140.     
  141.     def bind(self, port, bind = '', reuse = False):
  142.         self.bindaddr = bind
  143.         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  144.         if reuse:
  145.             server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  146.         
  147.         server.setblocking(0)
  148.         
  149.         try:
  150.             server.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, 32)
  151.         except:
  152.             pass
  153.  
  154.         server.bind((bind, port))
  155.         server.listen(5)
  156.         self.poll.register(server, POLLIN)
  157.         self.server = server
  158.  
  159.     
  160.     def start_connection(self, dns, handler = None):
  161.         if handler is None:
  162.             handler = self.handler
  163.         
  164.         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  165.         sock.setblocking(0)
  166.         
  167.         try:
  168.             sock.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, 32)
  169.         except:
  170.             pass
  171.  
  172.         sock.bind((self.bindaddr, 0))
  173.         
  174.         try:
  175.             sock.connect_ex(dns)
  176.         except socket.error:
  177.             raise 
  178.         except Exception:
  179.             e = None
  180.             raise socket.error(str(e))
  181.  
  182.         self.poll.register(sock, POLLIN)
  183.         s = SingleSocket(self, sock, handler)
  184.         self.single_sockets[sock.fileno()] = s
  185.         return s
  186.  
  187.     
  188.     def handle_events(self, events):
  189.         for sock, event in events:
  190.             if sock == self.server.fileno():
  191.                 pass
  192.             None if event & (POLLHUP | POLLERR) != 0 else None<EXCEPTION MATCH>socket.error
  193.             s = self.single_sockets.get(sock)
  194.             if s is None:
  195.                 continue
  196.             
  197.             s.connected = True
  198.             if event & (POLLHUP | POLLERR) != 0:
  199.                 self._close_socket(s)
  200.                 continue
  201.             
  202.             if event & POLLIN != 0:
  203.                 
  204.                 try:
  205.                     s.last_hit = time()
  206.                     data = s.socket.recv(100000)
  207.                     if data == '':
  208.                         self._close_socket(s)
  209.                     else:
  210.                         s.handler.data_came_in(s, data)
  211.                 except socket.error:
  212.                     e = None
  213.                     (code, msg) = e
  214.                     if code != EWOULDBLOCK:
  215.                         self._close_socket(s)
  216.                         continue
  217.                     
  218.                 except:
  219.                     code != EWOULDBLOCK
  220.                 
  221.  
  222.             None<EXCEPTION MATCH>socket.error
  223.             if event & POLLOUT != 0 and s.socket is not None and not s.is_flushed():
  224.                 s.try_write()
  225.                 if s.is_flushed():
  226.                     s.handler.connection_flushed(s)
  227.                 
  228.             s.is_flushed()
  229.         
  230.  
  231.     
  232.     def pop_unscheduled(self):
  233.         
  234.         try:
  235.             while True:
  236.                 (func, delay) = self.unscheduled_tasks.pop()
  237.                 insort(self.funcs, (time() + delay, func))
  238.         except IndexError:
  239.             pass
  240.  
  241.  
  242.     
  243.     def listen_forever(self, handler):
  244.         self.handler = handler
  245.         
  246.         try:
  247.             while not self.doneflag.isSet():
  248.                 
  249.                 try:
  250.                     self.pop_unscheduled()
  251.                     if len(self.funcs) == 0:
  252.                         period = 2 ** 30
  253.                     else:
  254.                         period = self.funcs[0][0] - time()
  255.                     if period < 0:
  256.                         period = 0
  257.                     
  258.                     events = self.poll.poll(period * timemult)
  259.                     if self.doneflag.isSet():
  260.                         return None
  261.                     
  262.                     while len(self.funcs) > 0 and self.funcs[0][0] <= time():
  263.                         (garbage, func) = self.funcs[0]
  264.                         del self.funcs[0]
  265.                         
  266.                         try:
  267.                             func()
  268.                         continue
  269.                         except KeyboardInterrupt:
  270.                             print_exc()
  271.                             return None
  272.                             continue
  273.                             if self.noisy:
  274.                                 data = StringIO()
  275.                                 print_exc(file = data)
  276.                                 self.errorfunc(data.getvalue())
  277.                             
  278.                         
  279.  
  280.                         None<EXCEPTION MATCH>KeyboardInterrupt
  281.                     self._close_dead()
  282.                     self.handle_events(events)
  283.                     if self.doneflag.isSet():
  284.                         return None
  285.                     
  286.                     self._close_dead()
  287.                 continue
  288.                 except error:
  289.                     e = None
  290.                     if self.doneflag.isSet():
  291.                         return None
  292.                     
  293.                     
  294.                     try:
  295.                         (code, msg, desc) = e
  296.                     except:
  297.                         
  298.                         try:
  299.                             (code, msg) = e
  300.                         code = ENOBUFS
  301.  
  302.  
  303.                     if code == ENOBUFS:
  304.                         self.errorfunc('Have to exit due to the TCP stack flaking out')
  305.                         return None
  306.                     
  307.                     code == ENOBUFS
  308.                     except KeyboardInterrupt:
  309.                         print_exc()
  310.                         return None
  311.                         continue
  312.                         data = StringIO()
  313.                         print_exc(file = data)
  314.                         self.errorfunc(data.getvalue())
  315.                         continue
  316.                     
  317.                     None<EXCEPTION MATCH>KeyboardInterrupt
  318.                 for ss in self.single_sockets.values():
  319.                     ss.close()
  320.                 
  321.  
  322.             self.server.close()
  323.             return None
  324.  
  325.  
  326.     
  327.     def _close_dead(self):
  328.         while len(self.dead_from_write) > 0:
  329.             old = self.dead_from_write
  330.             self.dead_from_write = []
  331.             for s in old:
  332.                 if s.socket is not None:
  333.                     self._close_socket(s)
  334.                     continue
  335.             
  336.  
  337.     
  338.     def _close_socket(self, s):
  339.         sock = s.socket.fileno()
  340.         s.socket.close()
  341.         self.poll.unregister(sock)
  342.         del self.single_sockets[sock]
  343.         s.socket = None
  344.         s.handler.connection_lost(s)
  345.  
  346.  
  347.  
  348. class DummyHandler:
  349.     
  350.     def __init__(self):
  351.         self.external_made = []
  352.         self.data_in = []
  353.         self.lost = []
  354.  
  355.     
  356.     def external_connection_made(self, s):
  357.         self.external_made.append(s)
  358.  
  359.     
  360.     def data_came_in(self, s, data):
  361.         self.data_in.append((s, data))
  362.  
  363.     
  364.     def connection_lost(self, s):
  365.         self.lost.append(s)
  366.  
  367.     
  368.     def connection_flushed(self, s):
  369.         pass
  370.  
  371.  
  372.  
  373. def sl(rs, handler, port):
  374.     rs.bind(port)
  375.     Thread(target = rs.listen_forever, args = [
  376.         handler]).start()
  377.  
  378.  
  379. def loop(rs):
  380.     x = []
  381.     
  382.     def r(rs = rs, x = x):
  383.         rs.add_task(x[0], 0.10000000000000001)
  384.  
  385.     x.append(r)
  386.     rs.add_task(r, 0.10000000000000001)
  387.  
  388. beginport = 5000 + randrange(10000)
  389.  
  390. def test_starting_side_close():
  391.     
  392.     try:
  393.         fa = Event()
  394.         fb = Event()
  395.         da = DummyHandler()
  396.         sa = RawServer(fa, 100, 100)
  397.         loop(sa)
  398.         sl(sa, da, beginport)
  399.         db = DummyHandler()
  400.         sb = RawServer(fb, 100, 100)
  401.         loop(sb)
  402.         sl(sb, db, beginport + 1)
  403.         sleep(0.5)
  404.         ca = sa.start_connection(('127.0.0.1', beginport + 1))
  405.         sleep(1)
  406.         cb = db.external_made[0]
  407.         del db.external_made[:]
  408.         ca.write('aaa')
  409.         cb.write('bbb')
  410.         sleep(1)
  411.         del da.data_in[:]
  412.         del db.data_in[:]
  413.         ca.write('ccc')
  414.         cb.write('ddd')
  415.         sleep(1)
  416.         del da.data_in[:]
  417.         del db.data_in[:]
  418.         ca.close()
  419.         sleep(1)
  420.         del db.lost[:]
  421.     finally:
  422.         fa.set()
  423.         fb.set()
  424.  
  425.  
  426.  
  427. def test_receiving_side_close():
  428.     
  429.     try:
  430.         da = DummyHandler()
  431.         fa = Event()
  432.         sa = RawServer(fa, 100, 100)
  433.         loop(sa)
  434.         sl(sa, da, beginport + 2)
  435.         db = DummyHandler()
  436.         fb = Event()
  437.         sb = RawServer(fb, 100, 100)
  438.         loop(sb)
  439.         sl(sb, db, beginport + 3)
  440.         sleep(0.5)
  441.         ca = sa.start_connection(('127.0.0.1', beginport + 3))
  442.         sleep(1)
  443.         cb = db.external_made[0]
  444.         del db.external_made[:]
  445.         ca.write('aaa')
  446.         cb.write('bbb')
  447.         sleep(1)
  448.         del da.data_in[:]
  449.         del db.data_in[:]
  450.         ca.write('ccc')
  451.         cb.write('ddd')
  452.         sleep(1)
  453.         del da.data_in[:]
  454.         del db.data_in[:]
  455.         cb.close()
  456.         sleep(1)
  457.         del da.lost[:]
  458.     finally:
  459.         fa.set()
  460.         fb.set()
  461.  
  462.  
  463.  
  464. def test_connection_refused():
  465.     
  466.     try:
  467.         da = DummyHandler()
  468.         fa = Event()
  469.         sa = RawServer(fa, 100, 100)
  470.         loop(sa)
  471.         sl(sa, da, beginport + 6)
  472.         sleep(0.5)
  473.         ca = sa.start_connection(('127.0.0.1', beginport + 15))
  474.         sleep(1)
  475.         del da.lost[:]
  476.     finally:
  477.         fa.set()
  478.  
  479.  
  480.  
  481. def test_both_close():
  482.     
  483.     try:
  484.         da = DummyHandler()
  485.         fa = Event()
  486.         sa = RawServer(fa, 100, 100)
  487.         loop(sa)
  488.         sl(sa, da, beginport + 4)
  489.         sleep(1)
  490.         db = DummyHandler()
  491.         fb = Event()
  492.         sb = RawServer(fb, 100, 100)
  493.         loop(sb)
  494.         sl(sb, db, beginport + 5)
  495.         sleep(0.5)
  496.         ca = sa.start_connection(('127.0.0.1', beginport + 5))
  497.         sleep(1)
  498.         cb = db.external_made[0]
  499.         del db.external_made[:]
  500.         ca.write('aaa')
  501.         cb.write('bbb')
  502.         sleep(1)
  503.         del da.data_in[:]
  504.         del db.data_in[:]
  505.         ca.write('ccc')
  506.         cb.write('ddd')
  507.         sleep(1)
  508.         del da.data_in[:]
  509.         del db.data_in[:]
  510.         ca.close()
  511.         cb.close()
  512.         sleep(1)
  513.     finally:
  514.         fa.set()
  515.         fb.set()
  516.  
  517.  
  518.  
  519. def test_normal():
  520.     l = []
  521.     f = Event()
  522.     s = RawServer(f, 100, 100)
  523.     loop(s)
  524.     sl(s, DummyHandler(), beginport + 7)
  525.     s.add_task((lambda l = l: l.append('b')), 2)
  526.     s.add_task((lambda l = l: l.append('a')), 1)
  527.     s.add_task((lambda l = l: l.append('d')), 4)
  528.     sleep(1.5)
  529.     s.add_task((lambda l = l: l.append('c')), 1.5)
  530.     sleep(3)
  531.     f.set()
  532.  
  533.  
  534. def test_catch_exception():
  535.     l = []
  536.     f = Event()
  537.     s = RawServer(f, 100, 100, False)
  538.     loop(s)
  539.     sl(s, DummyHandler(), beginport + 9)
  540.     s.add_task((lambda l = l: l.append('b')), 2)
  541.     s.add_task((lambda : 4 / 0), 1)
  542.     sleep(3)
  543.     f.set()
  544.  
  545.  
  546. def test_closes_if_not_hit():
  547.     
  548.     try:
  549.         da = DummyHandler()
  550.         fa = Event()
  551.         sa = RawServer(fa, 2, 2)
  552.         loop(sa)
  553.         sl(sa, da, beginport + 14)
  554.         sleep(1)
  555.         db = DummyHandler()
  556.         fb = Event()
  557.         sb = RawServer(fb, 100, 100)
  558.         loop(sb)
  559.         sl(sb, db, beginport + 13)
  560.         sleep(0.5)
  561.         sa.start_connection(('127.0.0.1', beginport + 13))
  562.         sleep(1)
  563.         del db.external_made[:]
  564.         sleep(3.1000000000000001)
  565.     finally:
  566.         fa.set()
  567.         fb.set()
  568.  
  569.  
  570.  
  571. def test_does_not_close_if_hit():
  572.     
  573.     try:
  574.         fa = Event()
  575.         fb = Event()
  576.         da = DummyHandler()
  577.         sa = RawServer(fa, 2, 2)
  578.         loop(sa)
  579.         sl(sa, da, beginport + 12)
  580.         sleep(1)
  581.         db = DummyHandler()
  582.         sb = RawServer(fb, 100, 100)
  583.         loop(sb)
  584.         sl(sb, db, beginport + 13)
  585.         sleep(0.5)
  586.         sa.start_connection(('127.0.0.1', beginport + 13))
  587.         sleep(1)
  588.         cb = db.external_made[0]
  589.         del db.external_made[:]
  590.         cb.write('bbb')
  591.         sleep(0.5)
  592.     finally:
  593.         fa.set()
  594.         fb.set()
  595.  
  596.  
  597.