def doSendRequestService(self, *args, **kwargs):
"""
Action method.
"""
self.target_idurl.refresh()
packet_id = packetid.UniqueID()
if _Debug:
lg.args(_DebugLevel,
idurl=self.target_idurl,
service=self.target_service,
packet_id=packet_id)
service_request_payload = self.request_service_params
if callable(service_request_payload):
service_request_payload = service_request_payload(
self.target_idurl)
out_packet = p2p_service.SendRequestService(
remote_idurl=self.target_idurl,
service_name=self.target_service,
json_payload=service_request_payload,
timeout=self.request_service_timeout,
callbacks={
commands.Ack(): self._node_acked,
commands.Fail(): self._node_failed,
None: self._node_timed_out,
},
packet_id=packet_id,
)
self.requested_packet_id = out_packet.PacketID
def doRequestService(self, *args, **kwargs):
"""
Action method.
"""
service_info = {
'needed_bytes': self.needed_bytes,
'customer_id': global_id.UrlToGlobalID(self.customer_idurl),
}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
)
if self.key_id:
service_info['key_id'] = self.key_id
self._last_known_ecc_map = kwargs.get('ecc_map')
if self._last_known_ecc_map is not None:
service_info['ecc_map'] = self._last_known_ecc_map
self._last_known_family_position = kwargs.get('family_position')
if self._last_known_family_position is not None:
service_info['position'] = self._last_known_family_position
self._last_known_family_snapshot = kwargs.get('family_snapshot')
if self._last_known_family_snapshot is not None:
service_info['family_snapshot'] = self._last_known_family_snapshot
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_acked,
commands.Fail(): self._supplier_failed,
},
)
self.request_packet_id = request.PacketID
def doRequestService(self, arg):
"""
Action method.
"""
service_info = {
'needed_bytes': self.needed_bytes,
'customer_id': global_id.UrlToGlobalID(self.customer_idurl),
}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
)
if self.key_id:
service_info['key_id'] = self.key_id
if self.customer_idurl == my_id.getLocalIDURL():
service_info['ecc_map'] = eccmap.Current().name
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_acked,
commands.Fail(): self._supplier_failed,
},
)
self.request_packet_id = request.PacketID
def _do_request_service_keys_registry(key_id, idurl, include_private, include_signature, timeout, result):
p2p_service.SendRequestService(idurl, 'service_keys_registry', callbacks={
commands.Ack(): lambda response, info:
_on_service_keys_registry_response(response, info, key_id, idurl, include_private, include_signature, result, timeout),
commands.Fail(): lambda response, info:
result.errback(Exception('"service_keys_registry" not started on remote node')),
None: lambda pkt_out: result.errback(Exception('timeout')),
})
return result
def doSendRequestService(self, *args, **kwargs):
"""
Action method.
"""
# service_info = 'service_broadcasting ' + self.request_service_params
out_packet = p2p_service.SendRequestService(
self.target_idurl, 'service_broadcasting', json_payload=self.request_service_params, callbacks={
commands.Ack(): self._node_acked,
commands.Fail(): self._node_failed,
}
)
self.requested_packet_id = out_packet.PacketID
def doSendRequestService(self, arg):
"""
Action method.
"""
service_info = 'service_accountant ' + self.request_service_params
out_packet = p2p_service.SendRequestService(
self.target_idurl, service_info, callbacks={
commands.Ack(): self._node_acked,
commands.Fail(): self._node_failed,
}
)
self.requested_packet_id = out_packet.PacketID
def doSendRequestService(self, *args, **kwargs):
"""
Action method.
"""
# service_info = self.target_service
# if self.request_service_params is not None:
# service_info += ' {}'.format(self.request_service_params)
out_packet = p2p_service.SendRequestService(
self.target_idurl, self.target_service, json_payload=self.request_service_params, callbacks={
commands.Ack(): self._node_acked,
commands.Fail(): self._node_failed,
}
)
self.requested_packet_id = out_packet.PacketID
def _do_request_supplier_service(self, ecc_map, family_position,
family_snapshot):
if _Debug:
lg.args(_DebugLevel,
supplier_idurl=self.supplier_idurl,
ecc_map=ecc_map,
family_position=family_position,
family_snapshot=family_snapshot)
if not self.supplier_idurl:
lg.warn(
'supplier idurl is empty, SKIP sending supplier_service request'
)
return
service_info = {
'needed_bytes': self.needed_bytes,
'customer_id': global_id.UrlToGlobalID(self.customer_idurl),
}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
include_signature=True,
generate_signature=True,
)
else:
lg.warn('my own customer key is not registered: %r' %
my_customer_key_id)
if self.key_id:
service_info['key_id'] = self.key_id
self._last_known_ecc_map = ecc_map
if self._last_known_ecc_map is not None:
service_info['ecc_map'] = self._last_known_ecc_map
self._last_known_family_position = family_position
if self._last_known_family_position is not None:
service_info['position'] = self._last_known_family_position
self._last_known_family_snapshot = family_snapshot
if self._last_known_family_snapshot is not None:
service_info['family_snapshot'] = id_url.to_bin_list(
self._last_known_family_snapshot)
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_service_acked,
commands.Fail(): self._supplier_service_failed,
},
)
self.request_packet_id = request.PacketID
def request_service_keys_registry(key_id, idurl):
result = Deferred()
p2p_service.SendRequestService(
idurl,
'service_keys_registry',
callbacks={
commands.Ack():
lambda response, indo: on_service_keys_registry_response(
response, indo, key_id, idurl, result),
commands.Fail():
lambda response, indo: result.errback(
Exception('"service_keys_registry" not started on remote node')
)
})
return result
def doRequestQueueService(self, *args, **kwargs):
"""
Action method.
"""
if not self.queue_subscribe:
reactor.callLater(0, self.automat,
'queue-skip') # @UndefinedVariable
return
service_info = {
'items': [
{
'scope': 'consumer',
'action': 'start',
'consumer_id': strng.to_text(my_id.getGlobalID()),
},
{
'scope': 'consumer',
'action': 'add_callback',
'consumer_id': strng.to_text(my_id.getGlobalID()),
'method': strng.to_text(my_id.getLocalID()),
},
{
'scope':
'consumer',
'action':
'subscribe',
'consumer_id':
strng.to_text(my_id.getGlobalID()),
'queue_id':
global_id.MakeGlobalQueueID(
queue_alias='supplier-file-modified',
owner_id=my_id.getGlobalID(),
supplier_id=global_id.MakeGlobalID(
idurl=self.supplier_idurl),
),
},
],
}
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_p2p_notifications',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_queue_acked,
commands.Fail(): self._supplier_queue_failed,
},
)
self.request_queue_packet_id = request.PacketID
def doRequestQueueService(self, arg):
"""
Action method.
"""
if not self.queue_subscribe:
self.automat('fail')
return
service_info = {
'items': [
{
'scope': 'consumer',
'action': 'start',
'consumer_id': my_id.getGlobalID(),
},
{
'scope': 'consumer',
'action': 'add_callback',
'consumer_id': my_id.getGlobalID(),
'method': my_id.getLocalID(),
},
{
'scope':
'consumer',
'action':
'subscribe',
'consumer_id':
my_id.getGlobalID(),
'queue_id':
global_id.MakeGlobalQueueID(
queue_alias='supplier-file-modified',
owner_id=my_id.getGlobalID(),
supplier_id=global_id.MakeGlobalID(
idurl=self.supplier_idurl),
),
},
],
}
p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_p2p_notifications',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_acked,
commands.Fail(): self._supplier_failed,
},
)
def doSendRequestService(self, *args, **kwargs):
"""
Action method.
"""
service_request_payload = self.request_service_params
if callable(service_request_payload):
service_request_payload = service_request_payload(
self.target_idurl)
out_packet = p2p_service.SendRequestService(
remote_idurl=self.target_idurl,
service_name=self.target_service,
json_payload=service_request_payload,
callbacks={
commands.Ack(): self._node_acked,
commands.Fail(): self._node_failed,
None: self._node_timed_out,
})
self.requested_packet_id = out_packet.PacketID
def doRequestService(self, arg):
"""
Action method.
"""
bytes_needed = diskspace.GetBytesFromString(settings.getNeededString(),
0)
num_suppliers = settings.getSuppliersNumberDesired()
if num_suppliers > 0:
bytes_per_supplier = int(
math.ceil(2.0 * bytes_needed / float(num_suppliers)))
else:
bytes_per_supplier = int(
math.ceil(2.0 * settings.MinimumNeededBytes() /
float(settings.DefaultDesiredSuppliers())))
service_info = 'service_supplier %d' % bytes_per_supplier
request = p2p_service.SendRequestService(self.idurl,
service_info,
callbacks={
commands.Ack():
self._supplier_acked,
commands.Fail():
self._supplier_failed,
})
self.request_packet_id = request.PacketID
def doRequestService(self, arg):
"""
Action method.
"""
service_info = {
'needed_bytes': self.needed_bytes,
}
try:
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=customer_state.customer_key_id(),
include_private=False,
)
except:
pass
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_acked,
commands.Fail(): self._supplier_failed,
},
)
self.request_packet_id = request.PacketID
