def isConnectionAlive(self, *args, **kwargs):
# miss = 0
if driver.is_on('service_udp_datagrams'):
from lib import udp
if time.time() - udp.get_last_datagram_time() < 60:
if settings.enableUDP() and settings.enableUDPreceiving():
return True
# else:
# miss += 1
if driver.is_on('service_gateway'):
from transport import gateway
if time.time() - gateway.last_inbox_time() < 60:
return True
transport_states = [
t.state for t in list(gateway.transports().values())
]
if 'LISTENING' in transport_states:
return True
if 'STARTING' in transport_states:
return True
# else:
# miss += 1
# if miss >= 2:
# return True
# return False ... still testing that approach
return True
def isConnectionAlive(self, arg):
# miss = 0
if driver.is_on('service_udp_datagrams'):
from lib import udp
if time.time() - udp.get_last_datagram_time() < 60:
if settings.enableUDP() and settings.enableUDPreceiving():
return True
# else:
# miss += 1
if driver.is_on('service_gateway'):
from transport import gateway
if time.time() - gateway.last_inbox_time() < 60:
return True
transport_states = map(lambda t: t.state,
gateway.transports().values())
if 'LISTENING' in transport_states:
return True
if 'STARTING' in transport_states:
return True
# else:
# miss += 1
# if miss >= 2:
# return True
return True # testing
return False
def doSetUp(self, *args, **kwargs):
if _Debug:
lg.out(_DebugLevel, 'network_connector.doSetUp')
if driver.is_on('service_udp_datagrams'):
from lib import udp
udp_port = settings.getUDPPort()
if not udp.proto(udp_port):
try:
udp.listen(udp_port)
except:
lg.exc()
if driver.is_on('service_service_entangled_dht'):
from dht import dht_service
dht_service.reconnect()
if driver.is_on('service_ip_port_responder'):
from stun import stun_server
udp_port = int(settings.getUDPPort())
stun_server.A('start', udp_port)
if driver.is_on('service_my_ip_port'):
from stun import stun_client
if not stun_client.A() or stun_client.A().state in ['STOPPED', ]:
stun_client.A().dropMyExternalAddress()
stun_client.A('start')
if driver.is_on('service_private_messages'):
from chat import nickname_holder
nickname_holder.A('set')
self.automat('network-up')
def doSetUp(self, arg):
if _Debug:
lg.out(_DebugLevel, 'network_connector.doSetUp')
# if driver.is_on('service_identity_server'):
# if settings.enableIdServer():
# from userid import id_server
# id_server.A('start', (settings.getIdServerWebPort(),
# settings.getIdServerTCPPort()))
if driver.is_on('service_service_entangled_dht'):
from dht import dht_service
dht_service.reconnect()
if driver.is_on('service_ip_port_responder'):
from stun import stun_server
udp_port = int(settings.getUDPPort())
stun_server.A('start', udp_port)
if driver.is_on('service_my_ip_port'):
from stun import stun_client
stun_client.A().dropMyExternalAddress()
stun_client.A('start')
if driver.is_on('service_private_messages'):
from chat import nickname_holder
nickname_holder.A('set', None)
# if driver.is_on('service_gateway'):
# from transport import gateway
# gateway.start()
self.automat('network-up')
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 doSetDown(self, arg):
"""
"""
if _Debug:
lg.out(_DebugLevel, 'network_connector.doSetDown')
if driver.is_on('service_service_entangled_dht'):
from dht import dht_service
dht_service.disconnect()
if driver.is_on('service_ip_port_responder'):
from stun import stun_server
stun_server.A('stop')
if driver.is_on('service_gateway'):
from transport import gateway
gateway.stop()
self.automat('network-down')
def doSetUp(self, arg):
if _Debug:
lg.out(_DebugLevel, 'network_connector.doSetUp')
# Second attempt
# l = []
# for service_name in driver.affecting('service_network'):
# d = driver.start_single(service_name)
# l.append(d)
#
# def _ok(x):
# lg.info('network child services is UP')
# self.automat('network-up')
# return None
#
# def _fail(err):
# lg.err(err)
# self.automat('network-up')
# return None
#
# dl = DeferredList(l, fireOnOneErrback=True, consumeErrors=True)
# dl.addCallback(_ok)
# d.addErrback(_fail)
# First Solution
if driver.is_on('service_service_entangled_dht'):
from dht import dht_service
dht_service.reconnect()
if driver.is_on('service_ip_port_responder'):
from stun import stun_server
udp_port = int(settings.getUDPPort())
stun_server.A('start', udp_port)
if driver.is_on('service_my_ip_port'):
from stun import stun_client
stun_client.A().dropMyExternalAddress()
stun_client.A('start')
if driver.is_on('service_private_messages'):
from chat import nickname_holder
nickname_holder.A('set')
if driver.is_on('service_udp_datagrams'):
from lib import udp
udp_port = settings.getUDPPort()
if not udp.proto(udp_port):
try:
udp.listen(udp_port)
except:
lg.exc()
self.automat('network-up')
def start(self):
from logs import lg
from transport import callback
from main import events
from contacts import contactsdb
from storage import accounting
from services import driver
from supplier import customer_space
callback.append_inbox_callback(self._on_inbox_packet_received)
events.add_subscriber(customer_space.on_identity_url_changed, 'identity-url-changed')
events.add_subscriber(customer_space.on_customer_accepted, 'existing-customer-accepted')
events.add_subscriber(customer_space.on_customer_accepted, 'new-customer-accepted')
events.add_subscriber(customer_space.on_customer_terminated, 'existing-customer-denied')
events.add_subscriber(customer_space.on_customer_terminated, 'existing-customer-terminated')
space_dict, _ = accounting.read_customers_quotas()
for customer_idurl in contactsdb.customers():
known_customer_meta_info = contactsdb.get_customer_meta_info(customer_idurl)
events.send('existing-customer-accepted', data=dict(
idurl=customer_idurl,
allocated_bytes=space_dict.get(customer_idurl.to_bin()),
ecc_map=known_customer_meta_info.get('ecc_map'),
position=known_customer_meta_info.get('position'),
))
if driver.is_on('service_entangled_dht'):
self._do_connect_suppliers_dht_layer()
else:
lg.warn('service service_entangled_dht is OFF')
events.add_subscriber(self._on_dht_layer_connected, event_id='dht-layer-connected')
return True
def isAllTransportsReady(self, arg):
"""
Condition method.
"""
if not driver.is_on('service_gateway'):
return False
LISTENING_count = 0
OFFLINE_count = 0
from transport import gateway
transports = gateway.transports().values()
for t in transports:
if t.state != 'OFFLINE' and t.state != 'LISTENING':
return False
if t.state == 'OFFLINE':
OFFLINE_count += 1
if t.state == 'LISTENING':
LISTENING_count += 1
if _Debug:
lg.out(
_DebugLevel,
'network_connector.isAllTransportsReady returning True : all transports READY : HELLO WORLD!!! '
)
lg.out(
_DebugLevel,
' OFFLINE transports:%d, LISTENING transports: %d' %
(OFFLINE_count, LISTENING_count))
return True
def state_changed(self, oldstate, newstate, event, arg):
global_state.set_global_state('NETWORK ' + newstate)
if driver.is_on('service_p2p_hookups'):
from p2p import p2p_connector
from system import tray_icon
p2p_connector.A('network_connector.state', newstate)
tray_icon.state_changed(self.state, p2p_connector.A().state)
def doRestartCustomersRejector(self, arg):
"""
Action method.
"""
if driver.is_on('service_customer_patrol'):
from supplier import customers_rejector
customers_rejector.A('restart')
def doRestartBackupMonitor(self, arg):
"""
Action method.
"""
if driver.is_on('service_backup_monitor'):
from storage import backup_monitor
backup_monitor.A('restart')
def on_tray_icon_command(cmd):
from main import shutdowner
from services import driver
from p2p import network_connector
lg.out(2, 'on_tray_icon_command %s' % cmd)
if cmd == 'exit':
# SendCommandToGUI('exit')
shutdowner.A('stop', 'exit')
elif cmd == 'restart':
# SendCommandToGUI('exit')
appList = bpio.find_process(['bpgui.', ])
if len(appList) > 0:
shutdowner.A('stop', 'restartnshow') # ('restart', 'show'))
else:
shutdowner.A('stop', 'restart') # ('restart', ''))
elif cmd == 'reconnect':
if driver.is_on('service_network'):
network_connector.A('reconnect')
elif cmd == 'show':
show()
elif cmd == 'hide':
pass
# SendCommandToGUI('exit')
elif cmd == 'toolbar':
pass
# SendCommandToGUI('toolbar')
else:
lg.warn('wrong command: ' + str(cmd))
def start(self):
from twisted.internet.defer import Deferred
from logs import lg
from main.config import conf
from main import events
from raid import eccmap
from services import driver
from customer import fire_hire
self.starting_deferred = Deferred()
self.starting_deferred.addErrback(
lambda err: lg.warn('service %r was not started: %r' %
(self.service_name, err.getErrorMessage()
if err else 'unknown reason')))
self.all_suppliers_hired_event_sent = False
if driver.is_on('service_entangled_dht'):
self._do_join_suppliers_dht_layer()
eccmap.Update()
fire_hire.A('init')
fire_hire.A().addStateChangedCallback(self._on_fire_hire_ready, None,
'READY')
conf().addConfigNotifier('services/customer/suppliers-number',
self._on_suppliers_number_modified)
conf().addConfigNotifier('services/customer/needed-space',
self._on_needed_space_modified)
events.add_subscriber(self._on_supplier_modified, 'supplier-modified')
events.add_subscriber(self._on_dht_layer_connected,
event_id='dht-layer-connected')
if fire_hire.IsAllHired():
self.starting_deferred.callback(True)
self.starting_deferred = None
lg.info('all my suppliers are already hired')
return True
fire_hire.A('restart')
return self.starting_deferred
def doInit(self, *args, **kwargs):
"""
Action method.
"""
self._do_block_rebuilding()
self.known_suppliers = [
_f
for _f in contactsdb.suppliers(customer_idurl=self.customer_idurl)
if _f
]
if not self.EccMap:
if self.customer_idurl == my_id.getIDURL():
self.EccMap = eccmap.Current()
lg.info('ECC map %r set from local for my own suppliers' %
self.EccMap)
if not self.EccMap:
known_eccmap_dict = {}
for supplier_idurl in self.known_suppliers:
known_ecc_map = contactsdb.get_supplier_meta_info(
supplier_idurl=supplier_idurl,
customer_idurl=self.customer_idurl,
).get('ecc_map', None)
if known_ecc_map:
if known_ecc_map not in known_eccmap_dict:
known_eccmap_dict[known_ecc_map] = 0
known_eccmap_dict[known_ecc_map] += 1
if known_eccmap_dict:
all_known_eccmaps = list(known_eccmap_dict.items())
all_known_eccmaps.sort(key=lambda i: i[1], reverse=True)
self.EccMap = eccmap.eccmap(all_known_eccmaps[0][0])
lg.info('ECC map %r recognized from suppliers meta info' %
self.EccMap)
else:
known_ecc_map = None
if driver.is_on('service_shared_data'):
from access import shared_access_coordinator
active_share = shared_access_coordinator.get_active_share(
self.key_id)
if active_share:
known_ecc_map = active_share.known_ecc_map
if known_ecc_map:
self.EccMap = eccmap.eccmap(known_ecc_map)
lg.info('ECC map %r recognized from active share %r' % (
self.EccMap,
active_share,
))
else:
num_suppliers = len(self.known_suppliers)
if num_suppliers not in eccmap.GetPossibleSuppliersCount():
num_suppliers = settings.DefaultDesiredSuppliers()
self.EccMap = eccmap.eccmap(
eccmap.GetEccMapName(num_suppliers))
lg.warn(
'no meta info found, guessed ECC map %r from %d known suppliers'
% (self.EccMap, len(self.known_suppliers)))
self.max_errors = eccmap.GetCorrectableErrors(
self.EccMap.NumSuppliers())
if data_receiver.A():
data_receiver.A().addStateChangedCallback(
self._on_data_receiver_state_changed)
def _on_my_identity_url_changed(self, evt):
from services import driver
if driver.is_on('service_entangled_dht'):
from dht import dht_service
from userid import my_id
if my_id.getIDURL():
dht_service.set_node_data('idurl', my_id.getIDURL().to_text())
def _on_request_service_received(self, newpacket, info):
from twisted.internet.defer import Deferred
from logs import lg
from lib import serialization
from services import driver
from p2p import p2p_service
from transport import packet_out
if len(newpacket.Payload) > 1024 * 10:
lg.warn('too long payload')
p2p_service.SendFail(newpacket, 'too long payload')
return False
try:
json_payload = serialization.BytesToDict(newpacket.Payload,
keys_to_text=True,
values_to_text=True)
json_payload['name']
json_payload['payload']
except:
lg.warn('json payload invalid')
p2p_service.SendFail(newpacket, 'json payload invalid')
return False
service_name = str(json_payload['name'])
lg.out(
self.debug_level,
"service_p2p_hookups.RequestService {%s} from %s" % (
service_name,
newpacket.OwnerID,
))
if not driver.is_exist(service_name):
lg.warn("got wrong payload in %s" % service_name)
p2p_service.SendFail(newpacket,
'service %s not exist' % service_name)
return False
if not driver.is_on(service_name):
p2p_service.SendFail(newpacket, 'service %s is off' % service_name)
return False
try:
result = driver.request(service_name, json_payload['payload'],
newpacket, info)
except:
lg.exc()
p2p_service.SendFail(newpacket,
'request processing failed with exception')
return False
if not result:
lg.out(
self.debug_level,
"service_p2p_hookups._send_request_service SKIP request %s" %
service_name)
return False
if isinstance(result, Deferred):
lg.out(
self.debug_level,
"service_p2p_hookups._send_request_service fired delayed execution"
)
elif isinstance(result, packet_out.PacketOut):
lg.out(
self.debug_level,
"service_p2p_hookups._send_request_service outbox packet sent")
return True
def doVerifyTransports(self, *args, **kwargs):
"""
Action method.
"""
if not driver.is_on('service_gateway'):
self.automat('gateway-is-not-started')
return
from transport import gateway
def _transports_verified(all_results):
if _Debug:
lg.out(
_DebugLevel,
'network_connector._transports_verified : %s' %
str(all_results))
order, all_results = all_results
not_valid_count = 0
restarts_count = 0
if len(order) == 0:
self.automat('network-transports-verified')
return
for proto in order:
if not all_results[proto]:
not_valid_count += 1
for priority in range(len(order)):
proto = order[priority]
if not all_results[proto]:
if _Debug:
lg.out(
_DebugLevel,
' [%s] at position %d needs restart' %
(proto, priority))
gateway.transport(proto).automat('restart')
restarts_count += 1
if not_valid_count > 1: # this one failed, 2 other failed as well
self.automat('network-transports-verified')
return
continue
if not_valid_count > 0:
if _Debug:
lg.out(
_DebugLevel,
' skip %d transport [%s]' % (priority, proto))
if restarts_count == 0:
if _Debug:
lg.out(
_DebugLevel,
' but no restarts and %d:[%s] is valid' %
(priority, proto))
self.automat('network-transports-verified')
return
if _Debug:
lg.out(
_DebugLevel,
' [%s] at position %d is fine, skip other transports'
% (proto, priority))
self.automat('network-transports-verified')
return
gateway.verify().addCallback(_transports_verified)
def isAllReady(self, *args, **kwargs):
"""
Condition method.
"""
if not driver.is_on('service_gateway'):
if _Debug:
lg.out(_DebugLevel, 'network_connector.isAllReady returning False : service_gateway is OFF')
return False
LISTENING_count = 0
OFFLINE_count = 0
from transport import gateway
transports = list(gateway.transports().values())
for t in transports:
if t.state != 'OFFLINE' and t.state != 'LISTENING':
if _Debug:
lg.out(_DebugLevel, 'network_connector.isAllReady returning False : transport %s is not READY yet' % t)
return False
if t.state == 'OFFLINE':
OFFLINE_count += 1
if t.state == 'LISTENING':
LISTENING_count += 1
if _Debug:
lg.out(_DebugLevel, 'network_connector.isAllReady returning True : all transports READY')
lg.out(_DebugLevel, ' OFFLINE transports:%d, LISTENING transports: %d' % (OFFLINE_count, LISTENING_count))
return True
def start(self):
from twisted.internet import reactor # @UnresolvedImport
from twisted.internet.defer import Deferred
from logs import lg
from transport.proxy import proxy_interface
from transport import network_transport
from transport import gateway
from services import driver
from main import events
from main.config import conf
if len(self._available_transports()) == 0:
lg.warn('no transports available')
return False
events.add_subscriber(self._on_dht_layer_connected,
'dht-layer-connected')
self._check_reset_original_identity()
self.starting_deferred = Deferred()
self.transport = network_transport.NetworkTransport(
'proxy', proxy_interface.GateInterface())
conf().addConfigNotifier('services/proxy-transport/enabled',
self._on_enabled_disabled)
conf().addConfigNotifier('services/proxy-transport/sending-enabled',
self._on_sending_enabled_disabled)
conf().addConfigNotifier('services/proxy-transport/receiving-enabled',
self._on_receiving_enabled_disabled)
if driver.is_on('service_entangled_dht'):
self._do_join_proxy_routers_dht_layer()
else:
self.transport.automat(
'init', (gateway.listener(), self._on_transport_state_changed))
reactor.callLater(0, self.transport.automat,
'start') # @UndefinedVariable
return self.starting_deferred
def doRestartFireHire(self, *args, **kwargs):
"""
Action method.
"""
if driver.is_on('service_employer'):
from customer import fire_hire
fire_hire.A('restart')
def isAllListening(self, *args, **kwargs):
"""
Condition method.
"""
if not driver.is_on('service_gateway'):
if _Debug:
lg.out(
_DebugLevel,
'network_connector.isAllListening returning False : service_gateway is OFF'
)
return False
from transport import gateway
transports = list(gateway.transports().values())
for t in transports:
if t.state != 'LISTENING':
if _Debug:
lg.out(
_DebugLevel,
'network_connector.isAllListening returning False : transport %s is not LISTENING'
% t)
return False
if _Debug:
lg.out(_DebugLevel,
'network_connector.isAllListening returning True')
return True
def backup_outgoing_message(private_message_object, message_id):
"""
"""
if not driver.is_on('service_backups'):
lg.warn('service_backups is not started')
return False
serialized_message = private_message_object.serialize()
local_msg_folder = os.path.join(settings.ChatChannelsDir(),
private_message_object.recipient, 'out')
if not bpio._dir_exist(local_msg_folder):
bpio._dirs_make(local_msg_folder)
local_msg_filename = os.path.join(local_msg_folder, message_id)
if not bpio.WriteBinaryFile(local_msg_filename, serialized_message):
lg.warn('failed writing outgoing message locally')
return False
remote_path_for_message = os.path.join('.messages', 'out',
private_message_object.recipient,
message_id)
global_message_path = global_id.MakeGlobalID(customer=messages_key_id(),
path=remote_path_for_message)
res = api.file_create(global_message_path)
if res['status'] != 'OK':
lg.warn('failed to create path "%s" in the catalog: %s' %
(global_message_path, res['errors']))
return False
res = api.file_upload_start(local_msg_filename,
global_message_path,
wait_result=False)
if res['status'] != 'OK':
lg.warn('failed to upload message "%s": %s' %
(global_message_path, res['errors']))
return False
return True
def process(newpacket, info):
from p2p import p2p_service
from userid import my_id
if not driver.is_on('service_p2p_hookups'):
if _Debug:
lg.out(
_DebugLevel,
'packet_in.process SKIP incoming packet, service_p2p_hookups is not started'
)
return None
if _Debug:
lg.out(
_DebugLevel,
'packet_in.process [%s/%s/%s]:%s(%s) from %s://%s is "%s"' % (
nameurl.GetName(newpacket.OwnerID),
nameurl.GetName(newpacket.CreatorID),
nameurl.GetName(newpacket.RemoteID),
newpacket.Command,
newpacket.PacketID,
info.proto,
info.host,
info.status,
))
if info.status != 'finished':
if _Debug:
lg.out(_DebugLevel,
' skip, packet status is : [%s]' % info.status)
return None
if newpacket.Command == commands.Identity():
if newpacket.RemoteID != my_id.getLocalIDURL():
if _Debug:
lg.out(_DebugLevel,
' incoming Identity is routed to another user')
if not p2p_service.Identity(newpacket, send_ack=False):
lg.warn('non-valid identity received')
return None
# remote peer sending a valid identity to another peer routed via my machine
# need to handle that packet - it should be processed by proxy_server
return handle(newpacket, info)
# contact sending us current identity we might not have
# so we handle it before check that packet is valid
# because we might not have his identity on hands and so can not verify the packet
# so we check that his Identity is valid and save it into cache
# than we check the packet to be valid too.
if not p2p_service.Identity(newpacket):
lg.warn('non-valid identity received')
return None
if not identitycache.HasKey(newpacket.CreatorID):
if _Debug:
lg.out(
_DebugLevel,
' will cache remote identity %s before processing incoming packet %s'
% (newpacket.CreatorID, newpacket))
d = identitycache.immediatelyCaching(newpacket.CreatorID)
d.addCallback(lambda _: handle(newpacket, info))
d.addErrback(lambda err: lg.err('failed caching remote %s identity: %s'
% (newpacket.CreatorID, str(err))))
return d
return handle(newpacket, info)
def doRestartCustomersRejector(self, *args, **kwargs):
"""
Action method.
"""
if driver.is_on('service_customer_patrol'):
# TODO: move this into a callback inside service_customer_patrol
from supplier import customers_rejector
customers_rejector.A('restart')
def _list_active_connections(params):
result = []
if not driver.is_on('service_gateway'):
return {'result': result, }
from transport import gateway
result = []
wanted_protos = params.get('protos', [])
if not wanted_protos:
wanted_protos = gateway.list_active_transports()
for proto in wanted_protos:
for connection in gateway.list_active_sessions(proto):
item = {
'status': 'unknown',
'state': 'unknown',
'proto': proto,
'host': 'unknown',
'idurl': 'unknown',
'bytes_sent': 0,
'bytes_received': 0,
}
if proto == 'tcp':
if hasattr(connection, 'stream'):
try:
host = '%s:%s' % (connection.peer_address[0], connection.peer_address[1])
except:
host = 'unknown'
item.update({
'status': 'active',
'state': connection.state,
'host': host,
'idurl': connection.peer_idurl or '',
'bytes_sent': connection.total_bytes_sent,
'bytes_received': connection.total_bytes_received,
})
else:
try:
host = '%s:%s' % (connection.connection_address[0], connection.connection_address[1])
except:
host = 'unknown'
item.update({
'status': 'connecting',
'host': host,
})
elif proto == 'udp':
try:
host = '%s:%s' % (connection.peer_address[0], connection.peer_address[1])
except:
host = 'unknown'
item.update({
'status': 'active',
'state': connection.state,
'host': host,
'idurl': connection.peer_idurl or '',
'bytes_sent': connection.bytes_sent,
'bytes_received': connection.bytes_received,
})
result.append(item)
return {'result': result, }
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 doPropagateMyIdentity(self, *args, **kwargs):
# TODO: need to run this actions one by one, not in parallel - use Defered chain
if driver.is_on('service_entangled_dht'):
from dht import dht_service
dht_service.set_node_data('idurl', my_id.getLocalID())
propagate.update()
d = propagate.start(wide=True)
d.addCallback(lambda contacts_list: self.automat(
'my-id-propagated', contacts_list))
def DeleteFile(request):
"""
Delete one ore multiple files (that belongs to another user) or folders on my machine.
"""
if _Debug:
lg.out(
_DebugLevel, 'p2p_service.DeleteFile [%s] by %s | %s' %
(request.PacketID, request.OwnerID, request.CreatorID))
if not driver.is_on('service_supplier'):
return SendFail(request, 'supplier service is off')
if request.Payload == '':
ids = [request.PacketID]
else:
ids = request.Payload.split('\n')
filescount = 0
dirscount = 0
for pcktID in ids:
glob_path = global_id.ParseGlobalID(pcktID)
if not glob_path['path']:
# backward compatible check
glob_path = global_id.ParseGlobalID(my_id.getGlobalID() + ':' +
request.PacketID)
if not glob_path['path']:
lg.warn("got incorrect PacketID")
SendFail(request, 'incorrect PacketID')
return
# TODO: add validation of customerGlobID
# TODO: process requests from another customer
filename = makeFilename(request.OwnerID, glob_path['path'])
if filename == "":
filename = constructFilename(request.OwnerID, glob_path['path'])
if not os.path.exists(filename):
lg.warn(
"had unknown customer: %s or pathID is not correct or not exist: %s"
% (nameurl.GetName(request.OwnerID), glob_path['path']))
return SendFail(request, 'not a customer, or file not found')
if os.path.isfile(filename):
try:
os.remove(filename)
filescount += 1
except:
lg.exc()
elif os.path.isdir(filename):
try:
bpio._dir_remove(filename)
dirscount += 1
except:
lg.exc()
else:
lg.warn("path not found %s" % filename)
if _Debug:
lg.out(
_DebugLevel,
"p2p_service.DeleteFile from [%s] with %d IDs, %d files and %d folders were removed"
% (nameurl.GetName(
request.OwnerID), len(ids), filescount, dirscount))
SendAck(request)
def _on_tray_icon_command(self, cmd):
if _Debug:
lg.out(_DebugLevel,
"initializer._on_tray_icon_command : [%s]" % cmd)
try:
from main import shutdowner
if cmd == 'exit':
shutdowner.A('stop', 'exit')
elif cmd == 'restart':
shutdowner.A('stop', 'restart')
elif cmd == 'reconnect':
from p2p import network_connector
if driver.is_on('service_network'):
network_connector.A('reconnect')
elif cmd == 'show':
# TODO: raise up electron window ?
pass
elif cmd == 'sync':
try:
from updates import git_proc
from system import tray_icon
def _sync_callback(result):
if result == 'error':
tray_icon.draw_icon('error')
reactor.callLater(
5,
tray_icon.restore_icon) # @UndefinedVariable
return
elif result == 'source-code-fetched':
tray_icon.draw_icon('updated')
reactor.callLater(
5,
tray_icon.restore_icon) # @UndefinedVariable
return
tray_icon.restore_icon()
tray_icon.draw_icon('sync')
git_proc.sync(_sync_callback, update_method='reset')
except:
lg.exc()
elif cmd == 'hide':
pass
elif cmd == 'toolbar':
pass
else:
lg.warn('wrong command: ' + str(cmd))
except:
lg.exc()
