PC Welt 2006 November (DVD)/PCWELT_11_2006.ISO/casper/filesystem.squashfs/usr/lib/python2.4/site-packages/BitTorrent/Downloader.pyc

Python Compiled Bytecode | 2006-08-31 | 18.1 KB | 776 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 2.4)

from CurrentRateMeasure import Measure
from random import shuffle
from time import time
from bitfield import Bitfield

class SingleDownload:

    def __init__(self, downloader, connection):
        self.downloader = downloader
        self.connection = connection
        self.choked = True
        self.interested = False
        self.active_requests = []
        self.measure = Measure(downloader.max_rate_period)
        self.have = Bitfield(downloader.numpieces)
        self.last = 0
        self.example_interest = None


    def disconnected(self):
        self.downloader.downloads.remove(self)
        for i in xrange(len(self.have)):
            if self.have[i]:
                self.downloader.picker.lost_have(i)
                continue

        self._letgo()


    def _letgo(self):
        if not self.active_requests:
            return None

        if self.downloader.storage.is_endgame():
            self.active_requests = []
            return None

        lost = []
        for index, begin, length in self.active_requests:
            self.downloader.storage.request_lost(index, begin, length)
            if index not in lost:
                lost.append(index)
                continue

        self.active_requests = []
        ds = _[1]
        shuffle(ds)
        for d in ds:
            d._request_more(lost)

        for d in self.downloader.downloads:
            if d.choked and not (d.interested):
                for l in lost:
                    if d.have[l] and self.downloader.storage.do_I_have_requests(l):
                        d.interested = True
                        d.connection.send_interested()
                        break
                        continue
                    []

            []



    def got_choke(self):
        if not self.choked:
            self.choked = True
            self._letgo()



    def got_unchoke(self):
        if self.choked:
            self.choked = False
            if self.interested:
                self._request_more()




    def is_choked(self):
        return self.choked


    def is_interested(self):
        return self.interested


    def got_piece(self, index, begin, piece):

        try:
            self.active_requests.remove((index, begin, len(piece)))
        except ValueError:
            return False

        if self.downloader.storage.is_endgame():
            self.downloader.all_requests.remove((index, begin, len(piece)))

        self.last = time()
        self.measure.update_rate(len(piece))
        self.downloader.measurefunc(len(piece))
        self.downloader.downmeasure.update_rate(len(piece))
        if self.downloader.storage.do_I_have(index):
            self.downloader.picker.complete(index)

        if self.downloader.storage.is_endgame():
            for d in self.downloader.downloads:
                if d is not self and d.interested:
                    if d.choked:
                        d.fix_download_endgame()
                    else:

                        try:
                            d.active_requests.remove((index, begin, len(piece)))
                        except ValueError:
                            continue

                        d.connection.send_cancel(index, begin, len(piece))
                        d.fix_download_endgame()
                d.choked


        self._request_more()
        return self.downloader.storage.do_I_have(index)


    def _want(self, index):
        if self.have[index]:
            pass
        return self.downloader.storage.do_I_have_requests(index)


    def _request_more(self, indices = None):
        if not not (self.choked):
            raise AssertionError
        if len(self.active_requests) == self.downloader.backlog:
            return None

        if self.downloader.storage.is_endgame():
            self.fix_download_endgame()
            return None

        lost_interests = []
        while len(self.active_requests) < self.downloader.backlog:
            if indices is None:
                interest = self.downloader.picker.next(self._want, self.have.numfalse == 0)
            else:
                interest = None
                for i in indices:
                    if self.have[i] and self.downloader.storage.do_I_have_requests(i):
                        interest = i
                        break
                        continue

            if interest is None:
                break

            if not self.interested:
                self.interested = True
                self.connection.send_interested()

            self.example_interest = interest
            (begin, length) = self.downloader.storage.new_request(interest)
            self.downloader.picker.requested(interest, self.have.numfalse == 0)
            self.active_requests.append((interest, begin, length))
            self.connection.send_request(interest, begin, length)
            if not self.downloader.storage.do_I_have_requests(interest):
                lost_interests.append(interest)
                continue
        if not (self.active_requests) and self.interested:
            self.interested = False
            self.connection.send_not_interested()

        if lost_interests:
            for d in self.downloader.downloads:
                if d.active_requests or not (d.interested):
                    continue

                if d.example_interest is not None and self.downloader.storage.do_I_have_requests(d.example_interest):
                    continue

                for lost in lost_interests:
                    if d.have[lost]:
                        break
                        continue

                interest = self.downloader.picker.next(d._want, d.have.numfalse == 0)
                if interest is None:
                    d.interested = False
                    d.connection.send_not_interested()
                    continue
                d.example_interest = interest


        if self.downloader.storage.is_endgame():
            self.downloader.all_requests = []
            for d in self.downloader.downloads:
                self.downloader.all_requests.extend(d.active_requests)

            for d in self.downloader.downloads:
                d.fix_download_endgame()




    def fix_download_endgame(self):
        want = _[1]
        if not (self.interested) and want:
            self.interested = True
            self.connection.send_interested()

        if self.choked:
            return None

        shuffle(want)
        del want[self.downloader.backlog - len(self.active_requests):]
        self.active_requests.extend(want)
        for piece, begin, length in want:
            self.connection.send_request(piece, begin, length)



    def got_have(self, index):
        if self.have[index]:
            return None

        self.have[index] = True
        self.downloader.picker.got_have(index)
        if self.downloader.picker.am_I_complete() and self.have.numfalse == 0:
            self.connection.close()
            return None

        if self.downloader.storage.is_endgame():
            self.fix_download_endgame()
        elif self.downloader.storage.do_I_have_requests(index):
            if not self.choked:
                self._request_more([
                    index])
            elif not self.interested:
                self.interested = True
                self.connection.send_interested()




    def got_have_bitfield(self, have):
        self.have = have
        for i in xrange(len(self.have)):
            if self.have[i]:
                self.downloader.picker.got_have(i)
                continue

        if self.downloader.picker.am_I_complete() and self.have.numfalse == 0:
            self.connection.close()
            return None

        if self.downloader.storage.is_endgame():
            for piece, begin, length in self.downloader.all_requests:
                if self.have[piece]:
                    self.interested = True
                    self.connection.send_interested()
                    return None
                    continue


        for i in xrange(len(self.have)):
            if self.have[i] and self.downloader.storage.do_I_have_requests(i):
                self.interested = True
                self.connection.send_interested()
                return None
                continue



    def get_rate(self):
        return self.measure.get_rate()


    def is_snubbed(self):
        return time() - self.last > self.downloader.snub_time



class Downloader:

    def __init__(self, storage, picker, backlog, max_rate_period, numpieces, downmeasure, snub_time, measurefunc = (lambda x: pass)):
        self.storage = storage
        self.picker = picker
        self.backlog = backlog
        self.max_rate_period = max_rate_period
        self.downmeasure = downmeasure
        self.numpieces = numpieces
        self.snub_time = snub_time
        self.measurefunc = measurefunc
        self.downloads = []


    def make_download(self, connection):
        self.downloads.append(SingleDownload(self, connection))
        return self.downloads[-1]



class DummyPicker:

    def __init__(self, num, r):
        self.stuff = range(num)
        self.r = r


    def next(self, wantfunc, seed):
        for i in self.stuff:
            if wantfunc(i):
                return i
                continue



    def lost_have(self, pos):
        self.r.append('lost have')


    def got_have(self, pos):
        self.r.append('got have')


    def requested(self, pos, seed):
        self.r.append('requested')


    def complete(self, pos):
        self.stuff.remove(pos)
        self.r.append('complete')


    def am_I_complete(self):
        return False


    def bump(self, i):
        pass



class DummyStorage:

    def __init__(self, remaining, have_endgame = False, numpieces = 1):
        self.remaining = remaining
        self.active = [ [] for i in xrange(numpieces) ]
        self.endgame = False
        self.have_endgame = have_endgame


    def do_I_have_requests(self, index):
        return self.remaining[index] != []


    def request_lost(self, index, begin, length):
        x = (begin, length)
        self.active[index].remove(x)
        self.remaining[index].append(x)
        self.remaining[index].sort()


    def piece_came_in(self, index, begin, piece):
        self.active[index].remove((begin, len(piece)))
        return True


    def do_I_have(self, index):
        if self.remaining[index] == []:
            pass
        return self.active[index] == []


    def new_request(self, index):
        x = self.remaining[index].pop()
        for i in self.remaining:
            if i:
                break
                continue
        else:
            self.endgame = True
        self.active[index].append(x)
        self.active[index].sort()
        return x


    def is_endgame(self):
        if self.have_endgame:
            pass
        return self.endgame



class DummyConnection:

    def __init__(self, events):
        self.events = events


    def send_interested(self):
        self.events.append('interested')


    def send_not_interested(self):
        self.events.append('not interested')


    def send_request(self, index, begin, length):
        self.events.append(('request', index, begin, length))


    def send_cancel(self, index, begin, length):
        self.events.append(('cancel', index, begin, length))



def test_stops_at_backlog():
    ds = DummyStorage([
        [
            (0, 2),
            (2, 2),
            (4, 2),
            (6, 2)]])
    events = []
    d = Downloader(ds, DummyPicker(len(ds.remaining), events), 2, 15, 1, Measure(15), 10)
    sd = d.make_download(DummyConnection(events))
    if not events == []:
        raise AssertionError
    if not ds.remaining == [
        [
            (0, 2),
            (2, 2),
            (4, 2),
            (6, 2)]]:
        raise AssertionError
    if not ds.active == [
        []]:
        raise AssertionError
    sd.got_have_bitfield(Bitfield(1, chr(128)))
    if not events == [
        'got have',
        'interested']:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        [
            (0, 2),
            (2, 2),
            (4, 2),
            (6, 2)]]:
        raise AssertionError
    if not ds.active == [
        []]:
        raise AssertionError
    sd.got_unchoke()
    if not events == [
        'requested',
        ('request', 0, 6, 2),
        'requested',
        ('request', 0, 4, 2)]:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        [
            (0, 2),
            (2, 2)]]:
        raise AssertionError
    if not ds.active == [
        [
            (4, 2),
            (6, 2)]]:
        raise AssertionError
    sd.got_piece(0, 4, 'ab')
    if not events == [
        'requested',
        ('request', 0, 2, 2)]:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        [
            (0, 2)]]:
        raise AssertionError
    if not ds.active == [
        [
            (2, 2),
            (6, 2)]]:
        raise AssertionError


def test_got_have_single():
    ds = DummyStorage([
        [
            (0, 2)]])
    events = []
    d = Downloader(ds, DummyPicker(len(ds.remaining), events), 2, 15, 1, Measure(15), 10)
    sd = d.make_download(DummyConnection(events))
    if not events == []:
        raise AssertionError
    if not ds.remaining == [
        [
            (0, 2)]]:
        raise AssertionError
    if not ds.active == [
        []]:
        raise AssertionError
    sd.got_unchoke()
    if not events == []:
        raise AssertionError
    if not ds.remaining == [
        [
            (0, 2)]]:
        raise AssertionError
    if not ds.active == [
        []]:
        raise AssertionError
    sd.got_have(0)
    if not events == [
        'got have',
        'interested',
        'requested',
        ('request', 0, 0, 2)]:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        []]:
        raise AssertionError
    if not ds.active == [
        [
            (0, 2)]]:
        raise AssertionError
    sd.disconnected()
    if not events == [
        'lost have']:
        raise AssertionError


def test_choke_clears_active():
    ds = DummyStorage([
        [
            (0, 2)]])
    events = []
    d = Downloader(ds, DummyPicker(len(ds.remaining), events), 2, 15, 1, Measure(15), 10)
    sd1 = d.make_download(DummyConnection(events))
    sd2 = d.make_download(DummyConnection(events))
    if not events == []:
        raise AssertionError
    if not ds.remaining == [
        [
            (0, 2)]]:
        raise AssertionError
    if not ds.active == [
        []]:
        raise AssertionError
    sd1.got_unchoke()
    sd1.got_have(0)
    if not events == [
        'got have',
        'interested',
        'requested',
        ('request', 0, 0, 2)]:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        []]:
        raise AssertionError
    if not ds.active == [
        [
            (0, 2)]]:
        raise AssertionError
    sd2.got_unchoke()
    sd2.got_have(0)
    if not events == [
        'got have']:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        []]:
        raise AssertionError
    if not ds.active == [
        [
            (0, 2)]]:
        raise AssertionError
    sd1.got_choke()
    if not events == [
        'interested',
        'requested',
        ('request', 0, 0, 2),
        'not interested']:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        []]:
        raise AssertionError
    if not ds.active == [
        [
            (0, 2)]]:
        raise AssertionError
    sd2.got_piece(0, 0, 'ab')
    if not events == [
        'complete',
        'not interested']:
        raise AssertionError
    del events[:]
    if not ds.remaining == [
        []]:
        raise AssertionError
    if not ds.active == [
        []]:
        raise AssertionError


def test_endgame():
    ds = DummyStorage([
        [
            (0, 2)],
        [
            (0, 2)],
        [
            (0, 2)]], True, 3)
    events = []
    d = Downloader(ds, DummyPicker(len(ds.remaining), events), 10, 15, 3, Measure(15), 10)
    ev1 = []
    ev2 = []
    ev3 = []
    ev4 = []
    sd1 = d.make_download(DummyConnection(ev1))
    sd2 = d.make_download(DummyConnection(ev2))
    sd3 = d.make_download(DummyConnection(ev3))
    sd1.got_unchoke()
    sd1.got_have(0)
    if not ev1 == [
        'interested',
        ('request', 0, 0, 2)]:
        raise AssertionError
    del ev1[:]
    sd2.got_unchoke()
    sd2.got_have(0)
    sd2.got_have(1)
    if not ev2 == [
        'interested',
        ('request', 1, 0, 2)]:
        raise AssertionError
    del ev2[:]
    sd3.got_unchoke()
    sd3.got_have(0)
    sd3.got_have(1)
    sd3.got_have(2)
    if not ev3 == [
        'interested',
        ('request', 2, 0, 2),
        ('request', 0, 0, 2),
        ('request', 1, 0, 2)] and ev3 == [
        'interested',
        ('request', 2, 0, 2),
        ('request', 1, 0, 2),
        ('request', 0, 0, 2)]:
        raise AssertionError
    del ev3[:]
    if not ev2 == [
        ('request', 0, 0, 2)]:
        raise AssertionError
    del ev2[:]
    sd2.got_piece(0, 0, 'ab')
    if not ev1 == [
        ('cancel', 0, 0, 2),
        'not interested']:
        raise AssertionError
    del ev1[:]
    if not ev2 == []:
        raise AssertionError
    if not ev3 == [
        ('cancel', 0, 0, 2)]:
        raise AssertionError
    del ev3[:]
    sd3.got_choke()
    if not ev1 == []:
        raise AssertionError
    if not ev2 == []:
        raise AssertionError
    if not ev3 == []:
        raise AssertionError
    sd3.got_unchoke()
    if not ev3 == [
        ('request', 2, 0, 2),
        ('request', 1, 0, 2)] and ev3 == [
        ('request', 1, 0, 2),
        ('request', 2, 0, 2)]:
        raise AssertionError
    del ev3[:]
    if not ev1 == []:
        raise AssertionError
    if not ev2 == []:
        raise AssertionError
    sd4 = d.make_download(DummyConnection(ev4))
    sd4.got_have_bitfield([
        True,
        True,
        True])
    if not ev4 == [
        'interested']:
        raise AssertionError
    del ev4[:]
    sd4.got_unchoke()
    if not ev4 == [
        ('request', 2, 0, 2),
        ('request', 1, 0, 2)] and ev4 == [
        ('request', 1, 0, 2),
        ('request', 2, 0, 2)]:
        raise AssertionError
    if not ev1 == []:
        raise AssertionError
    if not ev2 == []:
        raise AssertionError
    if not ev3 == []:
        raise AssertionError


def test_stops_at_backlog_endgame():
    ds = DummyStorage([
        [
            (2, 2),
            (0, 2)],
        [
            (2, 2),
            (0, 2)],
        [
            (0, 2)]], True, 3)
    events = []
    d = Downloader(ds, DummyPicker(len(ds.remaining), events), 3, 15, 3, Measure(15), 10)
    ev1 = []
    ev2 = []
    ev3 = []
    sd1 = d.make_download(DummyConnection(ev1))
    sd2 = d.make_download(DummyConnection(ev2))
    sd3 = d.make_download(DummyConnection(ev3))
    sd1.got_unchoke()
    sd1.got_have(0)
    if not ev1 == [
        'interested',
        ('request', 0, 0, 2),
        ('request', 0, 2, 2)]:
        raise AssertionError
    del ev1[:]
    sd2.got_unchoke()
    sd2.got_have(0)
    if not ev2 == []:
        raise AssertionError
    sd2.got_have(1)
    if not ev2 == [
        'interested',
        ('request', 1, 0, 2),
        ('request', 1, 2, 2)]:
        raise AssertionError
    del ev2[:]
    sd3.got_unchoke()
    sd3.got_have(2)
    if not ev2 == [
        ('request', 0, 0, 2)] and ev2 == [
        ('request', 0, 2, 2)]:
        raise AssertionError
    n = ev2[0][2]
    del ev2[:]
    sd1.got_piece(0, n, 'ab')
    if not ev1 == []:
        raise AssertionError
    if not ev2 == [
        ('cancel', 0, n, 2),
        ('request', 0, 2 - n, 2)]:
        raise AssertionError