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 / Uploader.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  9.2 KB  |  300 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. from CurrentRateMeasure import Measure
  5.  
  6. class Upload:
  7.     
  8.     def __init__(self, connection, choker, storage, max_slice_length, max_rate_period, fudge):
  9.         self.connection = connection
  10.         self.choker = choker
  11.         self.storage = storage
  12.         self.max_slice_length = max_slice_length
  13.         self.max_rate_period = max_rate_period
  14.         self.choked = True
  15.         self.interested = False
  16.         self.buffer = []
  17.         self.measure = Measure(max_rate_period, fudge)
  18.         if storage.do_I_have_anything():
  19.             connection.send_bitfield(storage.get_have_list())
  20.         
  21.  
  22.     
  23.     def got_not_interested(self):
  24.         if self.interested:
  25.             self.interested = False
  26.             del self.buffer[:]
  27.             self.choker.not_interested(self.connection)
  28.         
  29.  
  30.     
  31.     def got_interested(self):
  32.         if not self.interested:
  33.             self.interested = True
  34.             self.choker.interested(self.connection)
  35.         
  36.  
  37.     
  38.     def flushed(self):
  39.         while len(self.buffer) > 0 and self.connection.is_flushed():
  40.             (index, begin, length) = self.buffer[0]
  41.             del self.buffer[0]
  42.             piece = self.storage.get_piece(index, begin, length)
  43.             if piece is None:
  44.                 self.connection.close()
  45.                 return None
  46.             
  47.             self.measure.update_rate(len(piece))
  48.             self.connection.send_piece(index, begin, piece)
  49.  
  50.     
  51.     def got_request(self, index, begin, length):
  52.         if not (self.interested) or length > self.max_slice_length:
  53.             self.connection.close()
  54.             return None
  55.         
  56.         if not self.choked:
  57.             self.buffer.append((index, begin, length))
  58.             self.flushed()
  59.         
  60.  
  61.     
  62.     def got_cancel(self, index, begin, length):
  63.         
  64.         try:
  65.             self.buffer.remove((index, begin, length))
  66.         except ValueError:
  67.             pass
  68.  
  69.  
  70.     
  71.     def choke(self):
  72.         if not self.choked:
  73.             self.choked = True
  74.             del self.buffer[:]
  75.             self.connection.send_choke()
  76.         
  77.  
  78.     
  79.     def unchoke(self):
  80.         if self.choked:
  81.             self.choked = False
  82.             self.connection.send_unchoke()
  83.         
  84.  
  85.     
  86.     def is_choked(self):
  87.         return self.choked
  88.  
  89.     
  90.     def is_interested(self):
  91.         return self.interested
  92.  
  93.     
  94.     def has_queries(self):
  95.         return len(self.buffer) > 0
  96.  
  97.     
  98.     def get_rate(self):
  99.         return self.measure.get_rate()
  100.  
  101.  
  102.  
  103. class DummyConnection:
  104.     
  105.     def __init__(self, events):
  106.         self.events = events
  107.         self.flushed = False
  108.  
  109.     
  110.     def send_bitfield(self, bitfield):
  111.         self.events.append(('bitfield', bitfield))
  112.  
  113.     
  114.     def is_flushed(self):
  115.         return self.flushed
  116.  
  117.     
  118.     def close(self):
  119.         self.events.append('closed')
  120.  
  121.     
  122.     def send_piece(self, index, begin, piece):
  123.         self.events.append(('piece', index, begin, piece))
  124.  
  125.     
  126.     def send_choke(self):
  127.         self.events.append('choke')
  128.  
  129.     
  130.     def send_unchoke(self):
  131.         self.events.append('unchoke')
  132.  
  133.  
  134.  
  135. class DummyChoker:
  136.     
  137.     def __init__(self, events):
  138.         self.events = events
  139.  
  140.     
  141.     def interested(self, connection):
  142.         self.events.append('interested')
  143.  
  144.     
  145.     def not_interested(self, connection):
  146.         self.events.append('not interested')
  147.  
  148.  
  149.  
  150. class DummyStorage:
  151.     
  152.     def __init__(self, events):
  153.         self.events = events
  154.  
  155.     
  156.     def do_I_have_anything(self):
  157.         self.events.append('do I have')
  158.         return True
  159.  
  160.     
  161.     def get_have_list(self):
  162.         self.events.append('get have list')
  163.         return [
  164.             False,
  165.             True]
  166.  
  167.     
  168.     def get_piece(self, index, begin, length):
  169.         self.events.append(('get piece', index, begin, length))
  170.         if length == 4:
  171.             return None
  172.         
  173.         return 'a' * length
  174.  
  175.  
  176.  
  177. def test_skip_over_choke():
  178.     events = []
  179.     dco = DummyConnection(events)
  180.     dch = DummyChoker(events)
  181.     ds = DummyStorage(events)
  182.     u = Upload(dco, dch, ds, 100, 20, 5)
  183.     u.got_interested()
  184.     u.got_request(0, 0, 3)
  185.     dco.flushed = True
  186.     u.flushed()
  187.  
  188.  
  189. def test_bad_piece():
  190.     events = []
  191.     dco = DummyConnection(events)
  192.     dch = DummyChoker(events)
  193.     ds = DummyStorage(events)
  194.     u = Upload(dco, dch, ds, 100, 20, 5)
  195.     u.got_interested()
  196.     u.unchoke()
  197.     u.got_request(0, 0, 4)
  198.     dco.flushed = True
  199.     u.flushed()
  200.  
  201.  
  202. def test_still_rejected_after_unchoke():
  203.     events = []
  204.     dco = DummyConnection(events)
  205.     dch = DummyChoker(events)
  206.     ds = DummyStorage(events)
  207.     u = Upload(dco, dch, ds, 100, 20, 5)
  208.     u.got_interested()
  209.     u.unchoke()
  210.     u.got_request(0, 0, 3)
  211.     u.choke()
  212.     u.unchoke()
  213.     dco.flushed = True
  214.     u.flushed()
  215.  
  216.  
  217. def test_sends_when_flushed():
  218.     events = []
  219.     dco = DummyConnection(events)
  220.     dch = DummyChoker(events)
  221.     ds = DummyStorage(events)
  222.     u = Upload(dco, dch, ds, 100, 20, 5)
  223.     u.unchoke()
  224.     u.got_interested()
  225.     u.got_request(0, 1, 3)
  226.     dco.flushed = True
  227.     u.flushed()
  228.     u.flushed()
  229.  
  230.  
  231. def test_sends_immediately():
  232.     events = []
  233.     dco = DummyConnection(events)
  234.     dch = DummyChoker(events)
  235.     ds = DummyStorage(events)
  236.     u = Upload(dco, dch, ds, 100, 20, 5)
  237.     u.unchoke()
  238.     u.got_interested()
  239.     dco.flushed = True
  240.     u.got_request(0, 1, 3)
  241.  
  242.  
  243. def test_cancel():
  244.     events = []
  245.     dco = DummyConnection(events)
  246.     dch = DummyChoker(events)
  247.     ds = DummyStorage(events)
  248.     u = Upload(dco, dch, ds, 100, 20, 5)
  249.     u.unchoke()
  250.     u.got_interested()
  251.     u.got_request(0, 1, 3)
  252.     u.got_cancel(0, 1, 3)
  253.     u.got_cancel(0, 1, 2)
  254.     u.flushed()
  255.     dco.flushed = True
  256.  
  257.  
  258. def test_clears_on_not_interested():
  259.     events = []
  260.     dco = DummyConnection(events)
  261.     dch = DummyChoker(events)
  262.     ds = DummyStorage(events)
  263.     u = Upload(dco, dch, ds, 100, 20, 5)
  264.     u.unchoke()
  265.     u.got_interested()
  266.     u.got_request(0, 1, 3)
  267.     u.got_not_interested()
  268.     dco.flushed = True
  269.     u.flushed()
  270.  
  271.  
  272. def test_close_when_sends_on_not_interested():
  273.     events = []
  274.     dco = DummyConnection(events)
  275.     dch = DummyChoker(events)
  276.     ds = DummyStorage(events)
  277.     u = Upload(dco, dch, ds, 100, 20, 5)
  278.     u.got_request(0, 1, 3)
  279.  
  280.  
  281. def test_close_over_max_length():
  282.     events = []
  283.     dco = DummyConnection(events)
  284.     dch = DummyChoker(events)
  285.     ds = DummyStorage(events)
  286.     u = Upload(dco, dch, ds, 100, 20, 5)
  287.     u.got_interested()
  288.     u.got_request(0, 1, 101)
  289.  
  290.  
  291. def test_no_bitfield_on_start_empty():
  292.     events = []
  293.     dco = DummyConnection(events)
  294.     dch = DummyChoker(events)
  295.     ds = DummyStorage(events)
  296.     
  297.     ds.do_I_have_anything = lambda : False
  298.     u = Upload(dco, dch, ds, 100, 20, 5)
  299.  
  300.