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.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  10.7 KB  |  412 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (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.     if not u.is_choked():
  184.         raise AssertionError
  185.     if not not u.is_interested():
  186.         raise AssertionError
  187.     u.got_interested()
  188.     if not u.is_interested():
  189.         raise AssertionError
  190.     u.got_request(0, 0, 3)
  191.     dco.flushed = True
  192.     u.flushed()
  193.     if not events == [
  194.         'do I have',
  195.         'get have list',
  196.         ('bitfield', [
  197.             False,
  198.             True]),
  199.         'interested']:
  200.         raise AssertionError
  201.  
  202.  
  203. def test_bad_piece():
  204.     events = []
  205.     dco = DummyConnection(events)
  206.     dch = DummyChoker(events)
  207.     ds = DummyStorage(events)
  208.     u = Upload(dco, dch, ds, 100, 20, 5)
  209.     if not u.is_choked():
  210.         raise AssertionError
  211.     if not not u.is_interested():
  212.         raise AssertionError
  213.     u.got_interested()
  214.     if not u.is_interested():
  215.         raise AssertionError
  216.     u.unchoke()
  217.     if not not u.is_choked():
  218.         raise AssertionError
  219.     u.got_request(0, 0, 4)
  220.     dco.flushed = True
  221.     u.flushed()
  222.     if not events == [
  223.         'do I have',
  224.         'get have list',
  225.         ('bitfield', [
  226.             False,
  227.             True]),
  228.         'interested',
  229.         'unchoke',
  230.         ('get piece', 0, 0, 4),
  231.         'closed']:
  232.         raise AssertionError
  233.  
  234.  
  235. def test_still_rejected_after_unchoke():
  236.     events = []
  237.     dco = DummyConnection(events)
  238.     dch = DummyChoker(events)
  239.     ds = DummyStorage(events)
  240.     u = Upload(dco, dch, ds, 100, 20, 5)
  241.     if not u.is_choked():
  242.         raise AssertionError
  243.     if not not u.is_interested():
  244.         raise AssertionError
  245.     u.got_interested()
  246.     if not u.is_interested():
  247.         raise AssertionError
  248.     u.unchoke()
  249.     if not not u.is_choked():
  250.         raise AssertionError
  251.     u.got_request(0, 0, 3)
  252.     u.choke()
  253.     u.unchoke()
  254.     dco.flushed = True
  255.     u.flushed()
  256.     if not events == [
  257.         'do I have',
  258.         'get have list',
  259.         ('bitfield', [
  260.             False,
  261.             True]),
  262.         'interested',
  263.         'unchoke',
  264.         'choke',
  265.         'unchoke']:
  266.         raise AssertionError
  267.  
  268.  
  269. def test_sends_when_flushed():
  270.     events = []
  271.     dco = DummyConnection(events)
  272.     dch = DummyChoker(events)
  273.     ds = DummyStorage(events)
  274.     u = Upload(dco, dch, ds, 100, 20, 5)
  275.     u.unchoke()
  276.     u.got_interested()
  277.     u.got_request(0, 1, 3)
  278.     dco.flushed = True
  279.     u.flushed()
  280.     u.flushed()
  281.     if not events == [
  282.         'do I have',
  283.         'get have list',
  284.         ('bitfield', [
  285.             False,
  286.             True]),
  287.         'unchoke',
  288.         'interested',
  289.         ('get piece', 0, 1, 3),
  290.         ('piece', 0, 1, 'aaa')]:
  291.         raise AssertionError
  292.  
  293.  
  294. def test_sends_immediately():
  295.     events = []
  296.     dco = DummyConnection(events)
  297.     dch = DummyChoker(events)
  298.     ds = DummyStorage(events)
  299.     u = Upload(dco, dch, ds, 100, 20, 5)
  300.     u.unchoke()
  301.     u.got_interested()
  302.     dco.flushed = True
  303.     u.got_request(0, 1, 3)
  304.     if not events == [
  305.         'do I have',
  306.         'get have list',
  307.         ('bitfield', [
  308.             False,
  309.             True]),
  310.         'unchoke',
  311.         'interested',
  312.         ('get piece', 0, 1, 3),
  313.         ('piece', 0, 1, 'aaa')]:
  314.         raise AssertionError
  315.  
  316.  
  317. def test_cancel():
  318.     events = []
  319.     dco = DummyConnection(events)
  320.     dch = DummyChoker(events)
  321.     ds = DummyStorage(events)
  322.     u = Upload(dco, dch, ds, 100, 20, 5)
  323.     u.unchoke()
  324.     u.got_interested()
  325.     u.got_request(0, 1, 3)
  326.     u.got_cancel(0, 1, 3)
  327.     u.got_cancel(0, 1, 2)
  328.     u.flushed()
  329.     dco.flushed = True
  330.     if not events == [
  331.         'do I have',
  332.         'get have list',
  333.         ('bitfield', [
  334.             False,
  335.             True]),
  336.         'unchoke',
  337.         'interested']:
  338.         raise AssertionError
  339.  
  340.  
  341. def test_clears_on_not_interested():
  342.     events = []
  343.     dco = DummyConnection(events)
  344.     dch = DummyChoker(events)
  345.     ds = DummyStorage(events)
  346.     u = Upload(dco, dch, ds, 100, 20, 5)
  347.     u.unchoke()
  348.     u.got_interested()
  349.     u.got_request(0, 1, 3)
  350.     u.got_not_interested()
  351.     dco.flushed = True
  352.     u.flushed()
  353.     if not events == [
  354.         'do I have',
  355.         'get have list',
  356.         ('bitfield', [
  357.             False,
  358.             True]),
  359.         'unchoke',
  360.         'interested',
  361.         'not interested']:
  362.         raise AssertionError
  363.  
  364.  
  365. def test_close_when_sends_on_not_interested():
  366.     events = []
  367.     dco = DummyConnection(events)
  368.     dch = DummyChoker(events)
  369.     ds = DummyStorage(events)
  370.     u = Upload(dco, dch, ds, 100, 20, 5)
  371.     u.got_request(0, 1, 3)
  372.     if not events == [
  373.         'do I have',
  374.         'get have list',
  375.         ('bitfield', [
  376.             False,
  377.             True]),
  378.         'closed']:
  379.         raise AssertionError
  380.  
  381.  
  382. def test_close_over_max_length():
  383.     events = []
  384.     dco = DummyConnection(events)
  385.     dch = DummyChoker(events)
  386.     ds = DummyStorage(events)
  387.     u = Upload(dco, dch, ds, 100, 20, 5)
  388.     u.got_interested()
  389.     u.got_request(0, 1, 101)
  390.     if not events == [
  391.         'do I have',
  392.         'get have list',
  393.         ('bitfield', [
  394.             False,
  395.             True]),
  396.         'interested',
  397.         'closed']:
  398.         raise AssertionError
  399.  
  400.  
  401. def test_no_bitfield_on_start_empty():
  402.     events = []
  403.     dco = DummyConnection(events)
  404.     dch = DummyChoker(events)
  405.     ds = DummyStorage(events)
  406.     
  407.     ds.do_I_have_anything = lambda : False
  408.     u = Upload(dco, dch, ds, 100, 20, 5)
  409.     if not events == []:
  410.         raise AssertionError
  411.  
  412.