def _get_price_request(self, peer, protocol):
self._protocol_prices[
protocol] = self.payment_rate_manager.get_rate_live_blob_info(peer)
request_dict = {
'blob_info_payment_rate': self._protocol_prices[protocol]
}
request = ClientRequest(request_dict, 'blob_info_payment_rate')
return request
def _get_price_request(self, peer, protocol):
request = None
if not protocol in self._protocol_prices:
self._protocol_prices[
protocol] = self.payment_rate_manager.get_rate_blob_data(peer)
request_dict = {
'blob_data_payment_rate': self._protocol_prices[protocol]
}
request = ClientRequest(request_dict, 'blob_data_payment_rate')
return request
def send_next_request(self, peer, protocol):
if self.sent_request is True:
return defer.succeed(False)
response_identifier = 'moc_request'
r_dict = {'moc_request': 0}
request = ClientRequest(r_dict, response_identifier)
d = protocol.add_request(request) # ClientRequest here
d.addErrback(self.request_err, peer)
d.addCallback(self.request_success)
self.sent_request = True
return defer.succeed(True)
def send_next_request(self, peer, protocol):
if not protocol in self._protocols:
r = ClientRequest({'public_key': self.wallet.encoded_public_key},
'public_key')
d = protocol.add_request(r)
d.addCallback(self._handle_exchange_response, peer, r, protocol)
d.addErrback(self._request_failed, peer)
self._protocols.append(protocol)
return defer.succeed(True)
else:
return defer.succeed(False)
def send_next_request(self, peer, protocol):
if not protocol in self._protocols:
r = ClientRequest({'lbrycrd_address': True}, 'lbrycrd_address')
d = protocol.add_request(r)
d.addCallback(self._handle_address_response, peer, r, protocol)
d.addErrback(self._request_failed, peer)
self._protocols.append(protocol)
return defer.succeed(True)
else:
return defer.succeed(False)
def _get_price_request(self):
rate = self.get_and_save_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}
return ClientRequest(request_dict, 'blob_data_payment_rate')
def _get_info_price_request(self, peer, protocol):
request = None
if not protocol in self._info_protocol_prices:
self._info_protocol_prices[
protocol] = self.payment_rate_manager.get_rate_valuable_blob_info(
peer)
request_dict = {
'blob_length_payment_rate':
self._info_protocol_prices[protocol]
}
request = ClientRequest(request_dict, 'blob_length_payment_rate')
return request
def _get_availability_request(self, peer):
all_needed = [
b.blob_hash for b in self._blobs_to_download()
if not b.blob_hash in self._available_blobs[peer]
]
# sort them so that the peer will be asked first for blobs it hasn't said it doesn't have
to_request = sorted(
all_needed, key=lambda b: b in self._unavailable_blobs[peer])[:20]
if to_request:
r_dict = {'requested_blobs': to_request}
response_identifier = 'available_blobs'
request = ClientRequest(r_dict, response_identifier)
return request
return None
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