def contacts(include_all=False, include_enabled=True):
"""
Return a union of suppliers and customers ID's.
"""
result = set()
if include_all or (include_enabled and driver.is_enabled('service_customer')) or driver.is_on('service_customer'):
result.update(set(suppliers()))
if include_all or (include_enabled and driver.is_enabled('service_supplier')) or driver.is_on('service_supplier'):
result.update(set(customers()))
if include_all or (include_enabled and driver.is_enabled('service_private_messages')) or driver.is_on('service_private_messages'):
result.update(set(correspondents_ids()))
return list(result)
def _on_my_suppliers_yet_not_hired(self, evt):
from logs import lg
from services import driver
if driver.is_enabled('service_list_files'):
if driver.is_started('service_list_files'):
lg.info('my suppliers failed to hire, stopping service_list_files()')
driver.stop_single('service_list_files')
def _on_inbox_packet_received(self, newpacket, info, status,
error_message):
if newpacket.Command == commands.Identity() and \
newpacket.CreatorID == self.router_idurl and \
newpacket.RemoteID == my_id.getLocalID():
self.automat('router-id-received', (newpacket, info))
self.latest_packet_received = time.time()
return True
if newpacket.CreatorID == self.router_idurl:
self.latest_packet_received = time.time()
if newpacket.Command in [
commands.Relay(),
commands.RelayIn(),
commands.RelayAck(),
commands.RelayFail(),
]:
if driver.is_enabled('service_proxy_server'):
# TODO:
# in case this node already running proxy router service this will not work
# actually you can not use proxy transport for receiving and running proxy router at same time
# need to change one of the services to solve that dependency and prevent this
return False
self.automat('inbox-packet',
(newpacket, info, status, error_message))
return True
return False
def _on_my_identity_rotate_complete(self, evt):
from logs import lg
from services import driver
if driver.is_enabled('service_gateway'):
lg.warn(
'my identity sources were rotated, need to restart service_gateway()'
)
# if driver.is_enabled('service_identity_propagate'):
# from p2p import propagate
# from contacts import contactsdb
# selected_contacts = set(filter(None, contactsdb.contacts_remote(include_all=True)))
# if propagate.startup_list():
# selected_contacts.update(propagate.startup_list())
# propagate.startup_list().clear()
# propagate.propagate(
# selected_contacts=selected_contacts,
# wide=True,
# refresh_cache=True,
# ).addBoth(lambda err: driver.restart('service_gateway'))
# else:
driver.restart('service_gateway')
else:
lg.warn(
'my identity sources were rotated, but service_gateway() is disabled'
)
return None
def _on_my_suppliers_all_hired(self, evt):
from logs import lg
from services import driver
if driver.is_enabled('service_data_motion'):
if not driver.is_started('service_data_motion'):
lg.info('all my suppliers are hired, starting service_data_motion()')
driver.start_single('service_data_motion')
def _on_my_suppliers_all_hired(self, evt):
from logs import lg
from services import driver
if driver.is_enabled('service_list_files'):
if not driver.is_started('service_list_files'):
lg.info('all my suppliers are hired, starting service_list_files()')
driver.start_single('service_list_files')
from customer import list_files_orator
list_files_orator.A('need-files')
def contacts(include_all=False, include_enabled=True):
"""
Return a union of suppliers and customers ID's.
"""
result = set()
if include_all or (include_enabled and driver.is_enabled('service_customer')) or driver.is_on('service_customer'):
result.update(set(all_suppliers()))
if include_all or (include_enabled and driver.is_enabled('service_supplier')) or driver.is_on('service_supplier'):
result.update(set(customers() + known_customers()))
if include_all or (include_enabled and driver.is_enabled('service_private_messages')) or driver.is_on('service_private_messages'):
result.update(set(correspondents_ids()))
if include_all or include_enabled:
if driver.is_enabled('service_message_broker') or driver.is_on('service_message_broker'):
from stream import message_peddler
result.update(set(message_peddler.list_customers()))
result.update(set(message_peddler.list_consumers_producers(include_consumers=True, include_producers=True)))
result.update(set(message_peddler.list_known_brokers()))
return list(result)
def _on_my_storage_ready(self, evt):
from logs import lg
from services import driver
if self.starting_deferred:
if not self.starting_deferred.called:
self.starting_deferred.callback(True)
self.starting_deferred = None
if driver.is_enabled('service_my_data'):
if not driver.is_started('service_my_data'):
lg.info('my storage is ready, starting service_my_data()')
driver.start_single('service_my_data')
def health_check(self):
from services import driver
all_deps_are_ok = True
for dep_name in self.dependent_on():
if not driver.is_enabled(dep_name):
all_deps_are_ok = False
break
if not driver.is_on(dep_name):
all_deps_are_ok = False
break
if not all_deps_are_ok:
return False
return self.state == 'ON'
def _on_my_storage_not_ready_yet(self, evt):
from logs import lg
from services import driver
if self.starting_deferred:
if not self.starting_deferred.called:
self.starting_deferred.errback(
Exception('my storage is not ready yet'))
self.starting_deferred = None
if driver.is_enabled('service_my_data'):
if not driver.is_started('service_my_data'):
lg.info(
'my storage is not ready yet, stopping service_my_data()')
driver.stop_single('service_my_data')
def _on_my_identity_rotate_complete(self, evt):
from logs import lg
from services import driver
if driver.is_enabled('service_gateway'):
lg.info(
'my identity sources were rotated, need to restart service_gateway()'
)
driver.restart('service_gateway')
else:
lg.warn(
'my identity sources were rotated, but service_gateway() is disabled'
)
return None
def _on_my_storage_ready(self, evt):
from logs import lg
from main import listeners
from services import driver
from storage import backup_fs
if self.starting_deferred:
if not self.starting_deferred.called:
self.starting_deferred.callback(True)
self.starting_deferred = None
if listeners.is_populate_requered('private_file'):
listeners.populate_later().remove('private_file')
backup_fs.populate_private_files()
if driver.is_enabled('service_my_data'):
if not driver.is_started('service_my_data'):
lg.info('my storage is ready, starting service_my_data()')
driver.start_single('service_my_data')
def verify_packet_ownership(newpacket, raise_exception=False):
"""
At that point packet creator is already verified via signature,
but creator could be not authorized to store data on that node.
So based on owner ID decision must be made what to do with the packet.
Returns IDURL of the user who should receive and Ack() or None if not authorized.
"""
# SECURITY
owner_idurl = newpacket.OwnerID
creator_idurl = newpacket.CreatorID
owner_id = owner_idurl.to_id()
creator_id = creator_idurl.to_id()
packet_key_alias, packet_owner_id, _ = packetid.SplitKeyOwnerData(
newpacket.PacketID)
packet_key_id = my_keys.latest_key_id(
my_keys.make_key_id(packet_key_alias,
creator_idurl,
creator_glob_id=packet_owner_id))
if _Debug:
lg.args(_DebugLevel,
owner_id=owner_id,
creator_id=creator_id,
packet_id=newpacket.PacketID,
key_id_registered=my_keys.is_key_registered(packet_key_id))
if newpacket.Command == commands.Data():
if owner_idurl.to_bin() == creator_idurl.to_bin():
if contactsdb.is_customer(creator_idurl):
if _Debug:
lg.dbg(
_DebugLevel,
'OK, scenario 1: customer is sending own data to own supplier'
)
return owner_idurl
lg.err(
'FAIL, scenario 6: user is not my customer but trying to store data'
)
if raise_exception:
raise Exception(
'non-authorized user is trying to store data on the supplier'
)
return None
if contactsdb.is_customer(creator_idurl):
if _Debug:
lg.dbg(
_DebugLevel,
'OK, scenario 2: customer wants to store data for someone else on own supplier'
)
# TODO: check that, why do we need that?
return creator_idurl
if packet_owner_id == owner_id:
if contactsdb.is_customer(owner_idurl):
if my_keys.is_key_registered(packet_key_id):
if _Debug:
lg.dbg(
_DebugLevel,
'OK, scenario 3: another authorized user is sending data to customer to be stored on the supplier'
)
return creator_idurl
lg.err('non-authorized user is trying to store data on the supplier')
return None
if newpacket.Command in [
commands.DeleteFile(),
commands.DeleteBackup(),
]:
if owner_idurl == creator_idurl:
if contactsdb.is_customer(creator_idurl):
if _Debug:
lg.dbg(
_DebugLevel,
'OK, scenario 4: customer wants to remove already stored data on own supplier'
)
return owner_idurl
lg.err(
'FAIL, scenario 7: non-authorized user is trying to erase data owned by customer from the supplier'
)
if raise_exception:
raise Exception(
'non-authorized user is trying to erase data owned by customer from the supplier'
)
return None
if contactsdb.is_customer(creator_idurl):
# TODO: check that, why do we need that?
if _Debug:
lg.dbg(
_DebugLevel,
'OK, scenario 8: customer wants to erase existing data that belongs to someone else but stored on the supplier'
)
return creator_idurl
if packet_owner_id == owner_id:
if contactsdb.is_customer(owner_idurl):
if my_keys.is_key_registered(packet_key_id):
if _Debug:
lg.dbg(
_DebugLevel,
'OK, scenario 5: another authorized user wants to remove already stored data from the supplier'
)
return creator_idurl
lg.err('non-authorized user is trying to erase data on the supplier')
return None
if driver.is_enabled('service_proxy_server'):
if _Debug:
lg.dbg(
_DebugLevel,
'IGNORE, scenario 9: received Data() not authorized, but proxy router service was enabled'
)
return None
# TODO:
# scenario 9: make possible to set "active" flag True/False for any key
# this way customer can make virtual location available for other user but in read-only mode
raise Exception('scenario not implemented yet, received %r' % newpacket)
def connected(wait_timeout=5):
ret = Deferred()
if driver.is_enabled('service_proxy_transport'):
p2p_connector_lookup = automat.find('p2p_connector')
if p2p_connector_lookup:
p2p_connector_machine = automat.by_index(p2p_connector_lookup[0])
if p2p_connector_machine and p2p_connector_machine.state == 'CONNECTED':
proxy_receiver_lookup = automat.find('proxy_receiver')
if proxy_receiver_lookup:
proxy_receiver_machine = automat.by_index(
proxy_receiver_lookup[0])
if proxy_receiver_machine and proxy_receiver_machine.state == 'LISTEN':
# service_proxy_transport() is enabled, proxy_receiver() is listening: all good
wait_timeout_defer = Deferred()
wait_timeout_defer.addBoth(lambda _: ret.callback({
'service_network':
'started',
'service_gateway':
'started',
'service_p2p_hookups':
'started',
'service_proxy_transport':
'started',
'proxy_receiver_state':
proxy_receiver_machine.state,
}))
if not wait_timeout:
wait_timeout = 0.01
wait_timeout_defer.addTimeout(wait_timeout,
clock=reactor)
return ret
else:
d = driver.is_healthy('service_proxy_transport')
d.addCallback(on_service_proxy_transport_check_healthy,
wait_timeout=wait_timeout)
d.addErrback(lg.errback,
debug=_Debug,
debug_level=_DebugLevel,
method='network_service.connected',
ignore=True)
lg.warn(
'disconnected, reason is proxy_receiver() not started yet'
)
ret.callback(
dict(
error='disconnected',
reason='proxy_receiver_not_started',
))
return ret
if not my_id.isLocalIdentityReady():
lg.warn('local identity is not valid or not exist')
ret.callback(
dict(
error='local identity is not valid or not exist',
reason='identity_not_exist',
))
return ret
if not driver.is_enabled('service_network'):
lg.warn('service_network() is disabled')
ret.callback(
dict(
error='service_network() is disabled',
reason='service_network_disabled',
))
return ret
if not driver.is_enabled('service_gateway'):
lg.warn('service_gateway() is disabled')
ret.callback(
dict(
error='service_gateway() is disabled',
reason='service_gateway_disabled',
))
return ret
if not driver.is_enabled('service_p2p_hookups'):
lg.warn('service_p2p_hookups() is disabled')
ret.callback(
dict(
error='service_p2p_hookups() is disabled',
reason='service_p2p_hookups_disabled',
))
return ret
do_service_test('service_network', ret, wait_timeout)
return ret
def do_service_proxy_transport_test(result_defer):
if _Debug:
lg.dbg(_DebugLevel, 'checking proxy_transport')
if not driver.is_enabled('service_proxy_transport'):
result_defer.callback({
'service_network': 'started',
'service_gateway': 'started',
'service_p2p_hookups': 'started',
'service_proxy_transport': 'disabled',
})
return None
try:
proxy_receiver_lookup = automat.find('proxy_receiver')
if not proxy_receiver_lookup:
lg.warn('disconnected, reason is "proxy_receiver_not_found"')
result_defer.callback(
dict(
error='disconnected',
reason='proxy_receiver_not_found',
))
return None
proxy_receiver_machine = automat.by_index(proxy_receiver_lookup[0])
if not proxy_receiver_machine:
lg.warn('disconnected, reason is "proxy_receiver_not_exist"')
result_defer.callback(
dict(
error='disconnected',
reason='proxy_receiver_not_exist',
))
return None
if proxy_receiver_machine.state != 'LISTEN':
lg.warn(
'disconnected, reason is "proxy_receiver_disconnected", sending "start" event to proxy_receiver()'
)
proxy_receiver_machine.automat('start')
result_defer.callback(
dict(
error='disconnected',
reason='proxy_receiver_disconnected',
))
return None
result_defer.callback({
'service_network':
'started',
'service_gateway':
'started',
'service_p2p_hookups':
'started',
'service_proxy_transport':
'started',
'proxy_receiver_state':
proxy_receiver_machine.state,
})
except:
lg.exc()
result_defer.callback(
dict(
error='disconnected',
reason='proxy_receiver_error',
))
return None