def setValueOfType(self, entryPath, value):
from main import config_types
typ = self.getType(entryPath)
if not typ or typ in [
config_types.TYPE_STRING,
config_types.TYPE_TEXT,
config_types.TYPE_UNDEFINED,
]:
self.setData(entryPath, strng.text_type(value))
elif typ in [
config_types.TYPE_BOOLEAN,
]:
if strng.is_string(value):
vl = strng.to_text(value).strip().lower() == 'true'
else:
vl = bool(value)
self.setBool(entryPath, vl)
elif typ in [
config_types.TYPE_INTEGER,
config_types.TYPE_POSITIVE_INTEGER,
config_types.TYPE_NON_ZERO_POSITIVE_INTEGER,
config_types.TYPE_PORT_NUMBER,
]:
self.setInt(entryPath, int(value))
elif typ in [
config_types.TYPE_FOLDER_PATH,
config_types.TYPE_FILE_PATH,
config_types.TYPE_COMBO_BOX,
config_types.TYPE_PASSWORD,
]:
self.setString(entryPath, value)
else:
self.setData(entryPath, strng.text_type(value))
return True
def register_key(key_id, key_object_or_string, label='', keys_folder=None):
"""
"""
if key_id in known_keys():
lg.warn('key %s already exists' % key_id)
return None
if not label:
label = 'key%s' % utime.make_timestamp()
if strng.is_string(key_object_or_string):
if _Debug:
lg.out(_DebugLevel, 'my_keys.register_key %s from %d bytes openssh_input_string' % (
key_id, len(key_object_or_string)))
key_object = unserialize_key_to_object(key_object_or_string)
if not key_object:
lg.warn('invalid openssh string, unserialize_key_to_object() failed')
return None
else:
if _Debug:
lg.out(_DebugLevel, 'my_keys.register_key %s from object' % key_id)
key_object = key_object_or_string
known_keys()[key_id] = key_object
if _Debug:
lg.out(_DebugLevel, ' key %s added' % key_id)
if not keys_folder:
keys_folder = settings.KeyStoreDir()
save_key(key_id, keys_folder=keys_folder)
events.send('key-registered', data=dict(key_id=key_id, label=label, key_size=key_object.size(), ))
return key_object
def _on_packet_request_result(self, NewPacketOrPacketID, result):
if _Debug:
lg.args(_DebugLevel, packet=NewPacketOrPacketID, result=result)
packet_id = None
if strng.is_string(NewPacketOrPacketID):
packet_id = NewPacketOrPacketID
else:
packet_id = getattr(NewPacketOrPacketID, 'PacketID', None)
if not packet_id:
raise Exception('packet ID is unknown from %r' % NewPacketOrPacketID)
if packet_id not in self.block_requests:
if _Debug:
lg.args(_DebugLevel, block_requests=self.block_requests)
raise Exception('packet ID not registered')
if result == 'in queue':
if self.block_requests[packet_id] is not None:
raise Exception('packet is still in IO queue, but already unregistered')
lg.warn('packet already in the request queue: %r' % packet_id)
return
if result in ['received', 'exist', ]:
self.block_requests[packet_id] = True
if result == 'exist':
reactor.callLater(0, self.automat, 'data-received', (None, packet_id, )) # @UndefinedVariable
else:
reactor.callLater(0, self.automat, 'data-received', (NewPacketOrPacketID, packet_id, )) # @UndefinedVariable
else:
self.block_requests[packet_id] = False
self.RequestFails.append(packet_id)
reactor.callLater(0, self.automat, 'request-failed', packet_id) # @UndefinedVariable
def on_message_failed(idurl, json_data, recipient_global_id, packet_id, response, info, result_defer=None, error=None):
global _LastUserPingTime
idurl = id_url.to_bin(idurl)
lg.err('message %s failed sending to %s in %s because : %r' % (
packet_id, recipient_global_id, response, error, ))
if idurl in _LastUserPingTime:
_LastUserPingTime[idurl] = 0
if result_defer and not result_defer.called:
err = Exception(response) if response else (error if not strng.is_string(error) else Exception(error))
result_defer.errback(err)
def process(json_request):
lg.out(12, 'filemanager_api.process %s' % json_request)
if not driver.is_on('service_my_data'):
return {'result': {
"success": False,
"error": "network [service_my_data] is not started: %s" % (
driver.services().get('service_my_data', '!!! not found !!!'))}}
mode = ''
result = {}
try:
if strng.is_string(json_request):
import json
json_request = json.loads(json_request)
mode = json_request['params']['mode']
if mode == 'config':
result = _config(json_request['params'])
elif mode == 'stats':
result = _stats(json_request['params'])
elif mode == 'list':
result = _list(json_request['params'])
elif mode == 'listlocal':
result = _list_local(json_request['params'])
elif mode == 'listall':
result = _list_all(json_request['params'])
elif mode == 'upload':
result = _upload(json_request['params'])
elif mode == 'delete':
result = _delete(json_request['params'])
elif mode == 'deleteversion':
result = _delete_version(json_request['params'])
elif mode == 'download':
result = _download(json_request['params'])
elif mode == 'tasks':
result = _list_active_tasks(json_request['params'])
elif mode == 'packets':
result = _list_in_out_packets(json_request['params'])
elif mode == 'connections':
result = _list_active_connections(json_request['params'])
elif mode == 'streams':
result = _list_active_streams(json_request['params'])
elif mode == 'debuginfo':
result = _debuginfo(json_request['params'])
else:
result = {"result": {"success": False,
"error": 'filemanager method %s not found' % mode}}
except Exception as exc:
lg.exc()
descr = str(sys.exc_info()[0].__name__) + ': ' + str(sys.exc_info()[1])
result = {"result": {"success": False,
"error": descr}}
# lg.out(4, ' ERROR unknown mode: %s' % mode)
lg.out(20, ' %s' % pprint.pformat(result))
return result
def is_idurl(value):
"""
Return True if input is `ID_URL_FIELD` field or string in valid format.
"""
if value in [None, 'None', '', b'None', b'', False, ]:
return False
if isinstance(value, ID_URL_FIELD):
return True
if not strng.is_string(value):
return False
v = strng.to_text(value)
if not v.startswith('http') or not v.endswith('.xml') or v.count('://') != 1:
return False
return True
def _on_packet_request_result(self, NewPacketOrPacketID, result):
if self.block_requests is None:
return
if _Debug:
lg.args(_DebugLevel, packet=NewPacketOrPacketID, result=result)
packet_id = None
if strng.is_string(NewPacketOrPacketID):
packet_id = NewPacketOrPacketID
else:
packet_id = getattr(NewPacketOrPacketID, 'PacketID', None)
if not packet_id:
raise Exception('packet ID is unknown from %r' %
NewPacketOrPacketID)
if packet_id not in self.block_requests:
resp = global_id.NormalizeGlobalID(packet_id)
for req_packet_id in self.block_requests:
req = global_id.NormalizeGlobalID(req_packet_id)
if resp['version'] == req['version'] and resp['path'] == req[
'path']:
if resp['key_alias'] == req['key_alias'] and resp[
'user'] == req['user']:
if id_url.is_the_same(resp['idurl'], req['idurl']):
packet_id = req_packet_id
lg.warn(
'found matching packet request %r for rotated idurl %r'
% (
packet_id,
resp['idurl'],
))
break
if packet_id not in self.block_requests:
if _Debug:
lg.args(_DebugLevel, block_requests=self.block_requests)
raise Exception('packet ID not registered')
if result == 'in queue':
if self.block_requests[packet_id] is not None:
raise Exception(
'packet is still in IO queue, but already unregistered')
lg.warn('packet already in the request queue: %r' % packet_id)
return
if result in [
'received',
'exist',
]:
self.block_requests[packet_id] = True
if result == 'exist':
# reactor.callLater(0, self.automat, 'data-received', (None, packet_id, )) # @UndefinedVariable
self.event('data-received', (
None,
packet_id,
))
else:
# reactor.callLater(0, self.automat, 'data-received', (NewPacketOrPacketID, packet_id, )) # @UndefinedVariable
self.event('data-received', (
NewPacketOrPacketID,
packet_id,
))
else:
self.block_requests[packet_id] = False
self.RequestFails.append(packet_id)
# reactor.callLater(0, self.automat, 'request-failed', packet_id) # @UndefinedVariable
self.event('request-failed', packet_id)
def register_key(key_id, key_object_or_string, label='', keys_folder=None):
global _LatestLocalKeyID
key_id = latest_key_id(key_id)
if is_key_registered(key_id):
lg.warn('key %s already registered' % key_id)
return None
if not keys_folder:
keys_folder = settings.KeyStoreDir()
if not label:
label = 'key%s' % utime.make_timestamp()
if strng.is_string(key_object_or_string):
key_object_or_string = strng.to_bin(key_object_or_string)
if _Debug:
lg.out(
_DebugLevel,
'my_keys.register_key %r from %d bytes openssh_input_string' %
(key_id, len(key_object_or_string)))
key_object = unserialize_key_to_object(key_object_or_string)
if not key_object:
lg.warn(
'invalid openssh string, unserialize_key_to_object() failed')
return None
else:
if _Debug:
lg.out(_DebugLevel, 'my_keys.register_key %r from object' % key_id)
key_object = key_object_or_string
known_local_key_id = local_keys_index().get(key_object.toPublicString())
if known_local_key_id is not None:
known_key_id = local_keys().get(known_local_key_id)
if known_key_id is not None:
known_key_id = latest_key_id(known_key_id)
if known_key_id != key_id:
raise Exception(
'must not register same key with local_key_id=%r twice with different key_id: %r ~ %r'
% (
known_local_key_id,
known_key_id,
key_id,
))
new_local_key_id = known_local_key_id
if new_local_key_id is None:
_LatestLocalKeyID += 1
save_latest_local_key_id(keys_folder=keys_folder)
new_local_key_id = _LatestLocalKeyID
key_object.local_key_id = new_local_key_id
known_keys()[key_id] = key_object
if _Debug:
lg.out(_DebugLevel, ' key %r registered' % key_id)
save_key(key_id, keys_folder=keys_folder)
events.send('key-registered',
data=dict(
key_id=key_id,
label=label,
key_size=key_object.size(),
))
listeners.push_snapshot('key',
snap_id=key_id,
data=make_key_info(
key_object=key_object,
key_id=key_id,
event='key-registered',
include_private=False,
include_local_id=True,
include_signature=True,
include_label=True,
))
return key_object