590 lines
24 KiB
Python
590 lines
24 KiB
Python
import logging
|
|
from collections import defaultdict
|
|
from decimal import Decimal
|
|
|
|
from twisted.internet import defer
|
|
from twisted.python.failure import Failure
|
|
from twisted.internet.error import ConnectionAborted
|
|
|
|
from lbrynet.core.Error import ConnectionClosedBeforeResponseError
|
|
from lbrynet.core.Error import InvalidResponseError, RequestCanceledError, NoResponseError
|
|
from lbrynet.core.Error import PriceDisagreementError, DownloadCanceledError, InsufficientFundsError
|
|
from lbrynet.core.client.ClientRequest import ClientRequest, ClientBlobRequest
|
|
from lbrynet.core.Offer import Offer
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
def get_points(num_bytes, rate):
|
|
if isinstance(rate, float):
|
|
return 1.0 * num_bytes * rate / 2**20
|
|
elif isinstance(rate, Decimal):
|
|
return 1.0 * num_bytes * float(rate) / 2**20
|
|
else:
|
|
raise Exception("Unknown rate type")
|
|
|
|
|
|
def cache(fn):
|
|
"""Caches the function call for each instance"""
|
|
attr = '__{}_value'.format(fn.__name__)
|
|
|
|
def helper(self):
|
|
if not hasattr(self, attr):
|
|
value = fn(self)
|
|
setattr(self, attr, value)
|
|
return getattr(self, attr)
|
|
return helper
|
|
|
|
|
|
class BlobRequester:
|
|
#implements(IRequestCreator)
|
|
|
|
def __init__(self, blob_manager, peer_finder, payment_rate_manager, wallet, download_manager):
|
|
self.blob_manager = blob_manager
|
|
self.peer_finder = peer_finder
|
|
self.payment_rate_manager = payment_rate_manager
|
|
self.wallet = wallet
|
|
self._download_manager = download_manager
|
|
self._peers = defaultdict(int) # {Peer: score}
|
|
self._available_blobs = defaultdict(list) # {Peer: [blob_hash]}
|
|
self._unavailable_blobs = defaultdict(list) # {Peer: [blob_hash]}}
|
|
self._protocol_prices = {} # {ClientProtocol: price}
|
|
self._protocol_offers = {}
|
|
self._price_disagreements = [] # [Peer]
|
|
self._protocol_tries = {}
|
|
self._maxed_out_peers = []
|
|
self._incompatible_peers = []
|
|
|
|
######## IRequestCreator #########
|
|
def send_next_request(self, peer, protocol):
|
|
"""Makes an availability request, download request and price request"""
|
|
if not self.should_send_next_request(peer):
|
|
return defer.succeed(False)
|
|
return self._send_next_request(peer, protocol)
|
|
|
|
@defer.inlineCallbacks
|
|
def get_new_peers_for_head_blob(self):
|
|
""" look for peers for the head blob """
|
|
head_blob_hash = self._download_manager.get_head_blob_hash()
|
|
peers = yield self._find_peers_for_hash(head_blob_hash)
|
|
defer.returnValue(peers)
|
|
|
|
@defer.inlineCallbacks
|
|
def get_new_peers_for_next_unavailable(self):
|
|
"""
|
|
Look for peers for the next unavailable blob, if we have
|
|
all blobs, return an empty list
|
|
"""
|
|
blob_hash = yield self._get_hash_for_peer_search()
|
|
if blob_hash is None:
|
|
defer.returnValue([])
|
|
peers = yield self._find_peers_for_hash(blob_hash)
|
|
defer.returnValue(peers)
|
|
|
|
######### internal calls #########
|
|
def should_send_next_request(self, peer):
|
|
return (
|
|
self._blobs_to_download() and
|
|
self._should_send_request_to(peer)
|
|
)
|
|
|
|
def _send_next_request(self, peer, protocol):
|
|
log.debug('Sending a blob request for %s and %s', peer, protocol)
|
|
availability = AvailabilityRequest(self, peer, protocol, self.payment_rate_manager)
|
|
head_blob_hash = self._download_manager.get_head_blob_hash()
|
|
download = DownloadRequest(self, peer, protocol, self.payment_rate_manager,
|
|
self.wallet, head_blob_hash)
|
|
price = PriceRequest(self, peer, protocol, self.payment_rate_manager)
|
|
|
|
sent_request = False
|
|
if availability.can_make_request():
|
|
availability.make_request_and_handle_response()
|
|
sent_request = True
|
|
if price.can_make_request():
|
|
# TODO: document why a PriceRequest is only made if an
|
|
# Availability or Download request was made
|
|
price.make_request_and_handle_response()
|
|
sent_request = True
|
|
if download.can_make_request():
|
|
try:
|
|
download.make_request_and_handle_response()
|
|
sent_request = True
|
|
except InsufficientFundsError as err:
|
|
return defer.fail(err)
|
|
|
|
return defer.succeed(sent_request)
|
|
|
|
def _get_hash_for_peer_search(self):
|
|
"""
|
|
Get next unavailable hash for blob,
|
|
returns None if there is nothing left to download
|
|
"""
|
|
r = None
|
|
blobs_to_download = self._blobs_to_download()
|
|
if blobs_to_download:
|
|
blobs_without_sources = self._blobs_without_sources()
|
|
if not blobs_without_sources:
|
|
blob_hash = blobs_to_download[0].blob_hash
|
|
else:
|
|
blob_hash = blobs_without_sources[0].blob_hash
|
|
r = blob_hash
|
|
log.debug("Blob requester peer search response: %s", str(r))
|
|
return defer.succeed(r)
|
|
|
|
def _find_peers_for_hash(self, h):
|
|
d = self.peer_finder.find_peers_for_blob(h, filter_self=True)
|
|
|
|
def choose_best_peers(peers):
|
|
bad_peers = self._get_bad_peers()
|
|
without_bad_peers = [p for p in peers if not p in bad_peers]
|
|
without_maxed_out_peers = [
|
|
p for p in without_bad_peers if p not in self._maxed_out_peers]
|
|
return without_maxed_out_peers
|
|
|
|
d.addCallback(choose_best_peers)
|
|
|
|
def lookup_failed(err):
|
|
log.error("An error occurred looking up peers for a hash: %s", err.getTraceback())
|
|
return []
|
|
|
|
d.addErrback(lookup_failed)
|
|
return d
|
|
|
|
def _should_send_request_to(self, peer):
|
|
if self._peers[peer] < -5.0:
|
|
return False
|
|
if peer in self._price_disagreements:
|
|
return False
|
|
if peer in self._incompatible_peers:
|
|
return False
|
|
return True
|
|
|
|
def _get_bad_peers(self):
|
|
return [p for p in self._peers.keys() if not self._should_send_request_to(p)]
|
|
|
|
def _hash_available(self, blob_hash):
|
|
for peer in self._available_blobs:
|
|
if blob_hash in self._available_blobs[peer]:
|
|
return True
|
|
return False
|
|
|
|
def _hash_available_on(self, blob_hash, peer):
|
|
if blob_hash in self._available_blobs[peer]:
|
|
return True
|
|
return False
|
|
|
|
def _blobs_to_download(self):
|
|
needed_blobs = self._download_manager.needed_blobs()
|
|
return sorted(needed_blobs, key=lambda b: b.is_downloading())
|
|
|
|
def _blobs_without_sources(self):
|
|
return [
|
|
b for b in self._download_manager.needed_blobs()
|
|
if not self._hash_available(b.blob_hash)
|
|
]
|
|
|
|
def _price_settled(self, protocol):
|
|
if protocol in self._protocol_prices:
|
|
return True
|
|
return False
|
|
|
|
def _update_local_score(self, peer, amount):
|
|
self._peers[peer] += amount
|
|
|
|
|
|
class RequestHelper:
|
|
def __init__(self, requestor, peer, protocol, payment_rate_manager):
|
|
self.requestor = requestor
|
|
self.peer = peer
|
|
self.protocol = protocol
|
|
self.payment_rate_manager = payment_rate_manager
|
|
|
|
@property
|
|
def protocol_prices(self):
|
|
return self.requestor._protocol_prices
|
|
|
|
@property
|
|
def protocol_offers(self):
|
|
return self.requestor._protocol_offers
|
|
|
|
@property
|
|
def available_blobs(self):
|
|
return self.requestor._available_blobs[self.peer]
|
|
|
|
@property
|
|
def unavailable_blobs(self):
|
|
return self.requestor._unavailable_blobs[self.peer]
|
|
|
|
@property
|
|
def maxed_out_peers(self):
|
|
return self.requestor._maxed_out_peers
|
|
|
|
def update_local_score(self, score):
|
|
self.requestor._update_local_score(self.peer, score)
|
|
|
|
def _request_failed(self, reason, request_type):
|
|
if reason.check(DownloadCanceledError, RequestCanceledError, ConnectionAborted,
|
|
ConnectionClosedBeforeResponseError, ValueError):
|
|
return
|
|
if reason.check(NoResponseError):
|
|
self.requestor._incompatible_peers.append(self.peer)
|
|
log.warning("A request of type '%s' failed. Reason: %s, Error type: %s",
|
|
request_type, reason.getErrorMessage(), reason.type)
|
|
self.update_local_score(-10.0)
|
|
if isinstance(reason, (InvalidResponseError, NoResponseError)):
|
|
self.peer.update_score(-10.0)
|
|
else:
|
|
self.peer.update_score(-2.0)
|
|
return reason
|
|
|
|
def get_rate(self):
|
|
if self.payment_rate_manager.price_limit_reached(self.peer):
|
|
if self.peer not in self.maxed_out_peers:
|
|
self.maxed_out_peers.append(self.peer)
|
|
return None
|
|
rate = self.protocol_prices.get(self.protocol)
|
|
if rate is None:
|
|
if self.peer in self.payment_rate_manager.strategy.pending_sent_offers:
|
|
pending = self.payment_rate_manager.strategy.pending_sent_offers[self.peer]
|
|
if not pending.is_too_low and not pending.is_accepted:
|
|
return pending.rate
|
|
rate = self.payment_rate_manager.get_rate_blob_data(self.peer, self.available_blobs)
|
|
return rate
|
|
|
|
|
|
def _handle_incoming_blob(response_dict, peer, request):
|
|
if request.response_identifier not in response_dict:
|
|
return InvalidResponseError("response identifier not in response")
|
|
if not isinstance(response_dict[request.response_identifier], dict):
|
|
return InvalidResponseError("response not a dict. got %s" %
|
|
type(response_dict[request.response_identifier]))
|
|
response = response_dict[request.response_identifier]
|
|
if 'error' in response:
|
|
# This means we're not getting our blob for some reason
|
|
if response['error'] == "RATE_UNSET":
|
|
# Stop the download with an error that won't penalize the peer
|
|
request.cancel(PriceDisagreementError())
|
|
else:
|
|
# The peer has done something bad so we should get out of here
|
|
return InvalidResponseError("Got an unknown error from the peer: %s" %
|
|
(response['error'],))
|
|
else:
|
|
if 'blob_hash' not in response:
|
|
return InvalidResponseError("Missing the required field 'blob_hash'")
|
|
if not response['blob_hash'] == request.request_dict['requested_blob']:
|
|
return InvalidResponseError(
|
|
"Incoming blob does not match expected. Incoming: %s. Expected: %s" %
|
|
(response['blob_hash'], request.request_dict['requested_blob'])
|
|
)
|
|
if 'length' not in response:
|
|
return InvalidResponseError("Missing the required field 'length'")
|
|
if not request.blob.set_length(response['length']):
|
|
return InvalidResponseError("Could not set the length of the blob")
|
|
return True
|
|
|
|
|
|
def _handle_download_error(err, peer, blob_to_download):
|
|
if not err.check(DownloadCanceledError, PriceDisagreementError, RequestCanceledError,
|
|
ConnectionClosedBeforeResponseError):
|
|
log.warning("An error occurred while downloading %s from %s. Error: %s",
|
|
blob_to_download.blob_hash, str(peer), err.getTraceback())
|
|
if err.check(PriceDisagreementError):
|
|
# Don't kill the whole connection just because a price couldn't be agreed upon.
|
|
# Other information might be desired by other request creators at a better rate.
|
|
return True
|
|
return err
|
|
|
|
|
|
class AvailabilityRequest(RequestHelper):
|
|
"""Ask a peer what blobs it has available.
|
|
|
|
Results are saved in `_available_blobs` and `_unavailable_blobs`
|
|
on the parent BlobRequester.
|
|
"""
|
|
def can_make_request(self):
|
|
return self.get_top_needed_blobs()
|
|
|
|
def make_request_and_handle_response(self):
|
|
request = self._get_request()
|
|
self._handle_request(request)
|
|
|
|
def _get_request(self):
|
|
to_request = self.get_top_needed_blobs()
|
|
if not to_request:
|
|
raise Exception('Unable to make a request without available blobs')
|
|
return self._make_request(to_request)
|
|
|
|
@cache
|
|
def get_top_needed_blobs(self, limit=20):
|
|
all_needed = [
|
|
b.blob_hash for b in self.requestor._blobs_to_download()
|
|
if not self.is_available(b)
|
|
]
|
|
# sort them so that the peer will be asked first for blobs it
|
|
# hasn't said it doesn't have
|
|
sorted_needed = sorted(
|
|
all_needed,
|
|
key=lambda b: b in self.unavailable_blobs
|
|
)
|
|
return sorted_needed[:limit]
|
|
|
|
def is_available(self, blob):
|
|
return blob.blob_hash in self.available_blobs
|
|
|
|
def _make_request(self, to_request):
|
|
log.debug('Requesting blobs: %s', to_request)
|
|
r_dict = {'requested_blobs': to_request}
|
|
response_identifier = 'available_blobs'
|
|
request = ClientRequest(r_dict, response_identifier)
|
|
return request
|
|
|
|
def _handle_request(self, a_r):
|
|
log.debug('making an availability request')
|
|
d1 = self.protocol.add_request(a_r)
|
|
d1.addCallback(self._handle_availability, a_r)
|
|
d1.addErrback(self._request_failed, "availability request")
|
|
|
|
def _handle_availability(self, response_dict, request):
|
|
assert request.response_identifier == 'available_blobs'
|
|
if 'available_blobs' not in response_dict:
|
|
raise InvalidResponseError("response identifier not in response")
|
|
log.debug("Received a response to the availability request")
|
|
# save available blobs
|
|
blob_hashes = response_dict['available_blobs']
|
|
if not blob_hashes:
|
|
# should not send any more requests as it doesn't have any blob we need
|
|
self.update_local_score(-10.0)
|
|
return True
|
|
for blob_hash in blob_hashes:
|
|
if blob_hash in request.request_dict['requested_blobs']:
|
|
self.process_available_blob_hash(blob_hash, request)
|
|
# everything left in the request is missing
|
|
for blob_hash in request.request_dict['requested_blobs']:
|
|
self.unavailable_blobs.append(blob_hash)
|
|
return True
|
|
|
|
def process_available_blob_hash(self, blob_hash, request):
|
|
log.debug("The server has indicated it has the following blob available: %s", blob_hash)
|
|
self.available_blobs.append(blob_hash)
|
|
self.remove_from_unavailable_blobs(blob_hash)
|
|
request.request_dict['requested_blobs'].remove(blob_hash)
|
|
|
|
def remove_from_unavailable_blobs(self, blob_hash):
|
|
if blob_hash in self.unavailable_blobs:
|
|
self.unavailable_blobs.remove(blob_hash)
|
|
|
|
|
|
class PriceRequest(RequestHelper):
|
|
"""Ask a peer if a certain price is acceptable"""
|
|
def can_make_request(self):
|
|
if len(self.available_blobs) and self.protocol not in self.protocol_prices:
|
|
return self.get_rate() is not None
|
|
return False
|
|
|
|
def make_request_and_handle_response(self):
|
|
request = self._get_price_request()
|
|
self._handle_price_request(request)
|
|
|
|
def _get_price_request(self):
|
|
rate = self.get_rate()
|
|
if rate is None:
|
|
log.debug("No blobs to request from %s", self.peer)
|
|
raise Exception('Cannot make a price request without a payment rate')
|
|
log.debug("Offer rate %s to %s for %i blobs", rate, self.peer, len(self.available_blobs))
|
|
|
|
request_dict = {'blob_data_payment_rate': rate}
|
|
assert self.protocol not in self.protocol_offers
|
|
self.protocol_offers[self.protocol] = rate
|
|
return ClientRequest(request_dict, 'blob_data_payment_rate')
|
|
|
|
def _handle_price_request(self, price_request):
|
|
d = self.protocol.add_request(price_request)
|
|
d.addCallback(self._handle_price_response, price_request)
|
|
d.addErrback(self._request_failed, "price request")
|
|
|
|
def _handle_price_response(self, response_dict, request):
|
|
assert request.response_identifier == 'blob_data_payment_rate'
|
|
if 'blob_data_payment_rate' not in response_dict:
|
|
return InvalidResponseError("response identifier not in response")
|
|
offer_value = self.protocol_offers.pop(self.protocol)
|
|
offer = Offer(offer_value)
|
|
offer.handle(response_dict['blob_data_payment_rate'])
|
|
self.payment_rate_manager.record_offer_reply(self.peer, offer)
|
|
if offer.is_accepted:
|
|
log.info("Offered rate %f/mb accepted by %s", offer.rate, self.peer.host)
|
|
self.protocol_prices[self.protocol] = offer.rate
|
|
return True
|
|
elif offer.is_too_low:
|
|
log.debug("Offered rate %f/mb rejected by %s", offer.rate, self.peer.host)
|
|
return not self.payment_rate_manager.price_limit_reached(self.peer)
|
|
else:
|
|
log.warning("Price disagreement")
|
|
self.requestor._price_disagreements.append(self.peer)
|
|
return False
|
|
|
|
|
|
class DownloadRequest(RequestHelper):
|
|
"""Choose a blob and download it from a peer and also pay the peer for the data."""
|
|
def __init__(self, requester, peer, protocol, payment_rate_manager, wallet, head_blob_hash):
|
|
super().__init__(requester, peer, protocol, payment_rate_manager)
|
|
self.wallet = wallet
|
|
self.head_blob_hash = head_blob_hash
|
|
|
|
def can_make_request(self):
|
|
if self.protocol in self.protocol_prices:
|
|
return self.get_blob_details()
|
|
return False
|
|
|
|
def make_request_and_handle_response(self):
|
|
request = self._get_request()
|
|
self._handle_download_request(request)
|
|
|
|
def _get_request(self):
|
|
blob_details = self.get_blob_details()
|
|
if not blob_details:
|
|
raise Exception('No blobs available to download')
|
|
return self._make_request(blob_details)
|
|
|
|
@cache
|
|
def get_blob_details(self):
|
|
"""Open a blob for writing and return the details.
|
|
|
|
If no blob can be opened, returns None.
|
|
"""
|
|
to_download = self.get_available_blobs()
|
|
return self.find_blob(to_download)
|
|
|
|
def get_available_blobs(self):
|
|
available_blobs = [
|
|
b for b in self.requestor._blobs_to_download()
|
|
if self.requestor._hash_available_on(b.blob_hash, self.peer)
|
|
]
|
|
log.debug('available blobs: %s', available_blobs)
|
|
return available_blobs
|
|
|
|
def find_blob(self, to_download):
|
|
"""Return the first blob in `to_download` that is successfully opened for write."""
|
|
for blob in to_download:
|
|
if blob.get_is_verified():
|
|
log.debug('Skipping blob %s as its already validated', blob)
|
|
continue
|
|
writer, d = blob.open_for_writing(self.peer)
|
|
if d is not None:
|
|
return BlobDownloadDetails(blob, d, writer.write, writer.close, self.peer)
|
|
log.warning('Skipping blob %s as there was an issue opening it for writing', blob)
|
|
return None
|
|
|
|
def _make_request(self, blob_details):
|
|
blob = blob_details.blob
|
|
request = ClientBlobRequest(
|
|
{'requested_blob': blob.blob_hash},
|
|
'incoming_blob',
|
|
blob_details.counting_write_func,
|
|
blob_details.deferred,
|
|
blob_details.cancel_func,
|
|
blob
|
|
)
|
|
log.info("Requesting blob %s from %s", blob.blob_hash, self.peer)
|
|
return request
|
|
|
|
def _handle_download_request(self, client_blob_request):
|
|
reserved_points = self.reserve_funds_or_cancel(client_blob_request)
|
|
self.add_callbacks_to_download_request(client_blob_request, reserved_points)
|
|
self.create_add_blob_request(client_blob_request)
|
|
|
|
def reserve_funds_or_cancel(self, client_blob_request):
|
|
reserved_points = self._reserve_points(client_blob_request.max_pay_units)
|
|
if reserved_points is not None:
|
|
return reserved_points
|
|
client_blob_request.cancel(InsufficientFundsError())
|
|
client_blob_request.finished_deferred.addErrback(lambda _: True)
|
|
raise InsufficientFundsError()
|
|
|
|
def add_callbacks_to_download_request(self, client_blob_request, reserved_points):
|
|
# Note: The following three callbacks will be called when the blob has been
|
|
# fully downloaded or canceled
|
|
client_blob_request.finished_deferred.addCallbacks(
|
|
self._download_succeeded,
|
|
self._download_failed,
|
|
callbackArgs=(client_blob_request.blob,),
|
|
)
|
|
client_blob_request.finished_deferred.addBoth(self._pay_or_cancel_payment,
|
|
reserved_points, client_blob_request.blob)
|
|
client_blob_request.finished_deferred.addErrback(_handle_download_error, self.peer,
|
|
client_blob_request.blob)
|
|
|
|
def _pay_or_cancel_payment(self, arg, reserved_points, blob):
|
|
if self._can_pay_peer(blob, arg):
|
|
self._pay_peer(blob.length, reserved_points)
|
|
else:
|
|
self._cancel_points(reserved_points)
|
|
return arg
|
|
|
|
def _can_pay_peer(self, blob, arg):
|
|
return (
|
|
blob.length != 0 and
|
|
(not isinstance(arg, Failure) or arg.check(DownloadCanceledError))
|
|
)
|
|
|
|
def _pay_peer(self, num_bytes, reserved_points):
|
|
assert num_bytes != 0
|
|
rate = self.get_rate()
|
|
point_amount = get_points(num_bytes, rate)
|
|
self.wallet.send_points(reserved_points, point_amount)
|
|
self.payment_rate_manager.record_points_paid(point_amount)
|
|
|
|
def _cancel_points(self, reserved_points):
|
|
self.wallet.cancel_point_reservation(reserved_points)
|
|
|
|
def create_add_blob_request(self, client_blob_request):
|
|
d = self.protocol.add_blob_request(client_blob_request)
|
|
# Note: The following two callbacks will be called as soon as the peer sends its
|
|
# response, which will be before the blob has finished downloading, but may be
|
|
# after the blob has been canceled. For example,
|
|
# 1) client sends request to Peer A
|
|
# 2) the blob is finished downloading from peer B, and therefore this one is canceled
|
|
# 3) client receives response from Peer A
|
|
# Therefore, these callbacks shouldn't rely on there being a blob about to be
|
|
# downloaded.
|
|
d.addCallback(_handle_incoming_blob, self.peer, client_blob_request)
|
|
d.addErrback(self._request_failed, "download request")
|
|
|
|
def _reserve_points(self, num_bytes):
|
|
# jobevers: there was an assertion here, but I don't think it
|
|
# was a valid assertion to make. It is possible for a rate to
|
|
# not yet been set for this protocol or for it to have been
|
|
# removed so instead I switched it to check if a rate has been set
|
|
# and calculate it if it has not
|
|
rate = self.get_rate()
|
|
points_to_reserve = get_points(num_bytes, rate)
|
|
return self.wallet.reserve_points(self.peer, points_to_reserve)
|
|
|
|
def _download_succeeded(self, arg, blob):
|
|
log.info("Blob %s has been successfully downloaded from %s", blob, self.peer)
|
|
self.update_local_score(5.0)
|
|
self.peer.update_stats('blobs_downloaded', 1)
|
|
self.peer.update_score(5.0)
|
|
should_announce = blob.blob_hash == self.head_blob_hash
|
|
d = self.requestor.blob_manager.blob_completed(blob, should_announce=should_announce)
|
|
d.addCallback(lambda _: arg)
|
|
return d
|
|
|
|
def _download_failed(self, reason):
|
|
if not reason.check(DownloadCanceledError, PriceDisagreementError):
|
|
self.update_local_score(-10.0)
|
|
return reason
|
|
|
|
|
|
class BlobDownloadDetails:
|
|
"""Contains the information needed to make a ClientBlobRequest from an open blob"""
|
|
def __init__(self, blob, deferred, write_func, cancel_func, peer):
|
|
self.blob = blob
|
|
self.deferred = deferred
|
|
self.write_func = write_func
|
|
self.cancel_func = cancel_func
|
|
self.peer = peer
|
|
|
|
def counting_write_func(self, data):
|
|
self.peer.update_stats('blob_bytes_downloaded', len(data))
|
|
return self.write_func(data)
|