def addUser(self, description):
uid = 1
while self.userExists(uid):
uid += 1
if 'type' in list(description.keys()):
del description['type']
logger.log(logging.DEBUG, "add user \"%s\": %s" % (uid, description))
user = UserDescription(uid, description)
self.users[uid] = user
for path in [self.userMessageBox(uid), self.userReceiptBox(uid)]:
try:
os.mkdir(path)
except:
logging.exception("Cannot create directory " + path)
sys.exit(1)
path = ""
try:
path = os.path.join(MBOXES_PATH, str(uid), DESC_FILENAME)
logger.log(logging.DEBUG, "add user description " + path)
self.saveOnFile(path, json.dumps(description))
except:
logging.exception("Cannot create description file " + path)
sys.exit(1)
return user
def processCreate(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
if 'uuid' not in list(data.keys()):
logger.log(
logging.ERROR,
"No \"uuid\" field in \"create\" message: " + json.dumps(data))
client.sendResult({"error": "wrong message format"})
return
if not set(data.keys()).issuperset(set({'secdata', 'signature'})):
logger.log(logging.ERROR,
"Badly formatted \"send\" message: " + json.dumps(data))
client.sendResult({"error": "wrong message format"})
uuid = data['uuid']
if not isinstance(uuid, int):
logger.log(
logging.ERROR,
"No valid \"uuid\" field in \"create\" message: " +
json.dumps(data))
client.sendResult({"error": "wrong message format"})
return
if self.registry.userExists(uuid):
logger.log(logging.ERROR,
"User already exists: " + json.dumps(data))
client.sendResult({"error": "uuid already exists"})
return
me = self.registry.addUser(data)
client.sendResult({"result": me.id})
def print_patterns(self):
if not self._size_to_patterns:
logger.warning('No patterns were found')
return
if os.path.exists(self.OUTPUT_DIR):
shutil.rmtree(self.OUTPUT_DIR)
with multiprocessing.pool.ThreadPool(processes=multiprocessing.cpu_count()) as thread_pool:
for size, patterns in self._size_to_patterns.items():
if not patterns:
continue
logger.log(logger.WARNING, f'Exporting patterns of size {size}', show_pid=True)
same_size_dir = os.path.join(self.OUTPUT_DIR, str(size))
os.makedirs(same_size_dir, exist_ok=True)
fn = functools.partial(self._print_pattern, same_size_dir)
thread_pool.map(fn, patterns)
self._generate_contents(
same_size_dir,
f'Size {size} contents',
[{'name': f'Pattern #{p.id}', 'url': f'{p.id}/details.html'}
for p in sorted(patterns, key=lambda p: p.id)],
styles='../../styles.css', has_upper_contents=True)
self._generate_contents(
self.OUTPUT_DIR,
'Contents',
[{'name': f'Size {size}', 'url': f'{size}/contents.html'}
for size in sorted(self._size_to_patterns.keys())])
logger.warning('Done patterns output')
def _get_most_freq_group_and_freq_for_fragments(self, ext_fragments: set,
is_giant):
start = time.time()
groups: Set[FrozenSet[Fragment]] = Fragment.create_groups(
ext_fragments)
logger.log(logger.INFO,
f'Groups for {len(ext_fragments)} fragments created',
start_time=start,
show_pid=True)
freq_group: Set[Fragment] = set()
freq = self.MIN_FREQUENCY - 1
for curr_group in groups:
overlapped_fragments: list = self.get_graph_overlapped_fragments(
curr_group)
curr_freq = len(curr_group) - len(overlapped_fragments)
if curr_freq > freq:
curr_group = set(curr_group)
if is_giant and self._is_giant_extension(curr_group):
for fragment in overlapped_fragments:
curr_group.remove(fragment)
freq_group = curr_group
freq = curr_freq
return freq_group, freq
def get_hash(self):
logger.log(logger.DEBUG, f'Getting vector hash, data size = {len(self.data)}')
result = 0
for key in sorted(self.data.keys()):
result = normalize(result * 31 + self.data[key])
logger.log(logger.DEBUG, f'Hash calculated, value = {result}')
return result
def _remove_duplicates(group):
if len(group) < Pattern.MIN_FREQUENCY:
return group
lst = list(group) # todo escape convertions
vb_utils.filter_list(lst, condition=lambda i, j: lst[i].is_equal(lst[j]))
logger.log(logger.INFO, f'Remove duplicates: affected {len(group) - len(lst)} items', show_pid=True)
return set(lst)
def uncapsulate_secure_message(self, message):
logger.log(logging.DEBUG, "SECURE MESSAGE RECEIVED: %r" % message)
# Check all payload fields
if not set({'payload', 'cipher_spec', 'mac'}).issubset(
set(message.keys())):
logger.log(
logging.DEBUG, "ERROR: INCOMPLETE FIELDS IN SECURE "
"MESSAGE: %r" % message)
return {'type': 'error', 'error': 'Invalid secure message format'}
assert message['cipher_spec'] == self.cipher_spec
payload = json.loads(
base64.b64decode(message['payload'].encode()).decode())
# Derive AES key and decipher payload
self.number_of_hash_derivations = payload['secdata']['index']
self.peer_pub_value = deserialize_key(payload['secdata']['dhpubvalue'])
self.peer_salt = base64.b64decode(payload['secdata']['salt'].encode())
aes_key = derive_key_from_ecdh(
self.priv_value,
self.peer_pub_value,
self.peer_salt,
self.salt,
self.cipher_suite['aes']['key_size'],
self.cipher_suite['sha']['size'],
self.number_of_hash_derivations,
)
# Verify MAC to make sure of message integrity
if not verify_mac(aes_key, message['payload'].encode() + self.prev_mac,
base64.b64decode(message['mac'].encode()),
self.cipher_suite['sha']['size']):
return {'type': 'error', 'error': "Invalid MAC; dropping message"}
self.prev_mac = message['mac'].encode()
# Decipher payload
aes_cipher, aes_iv = generate_aes_cipher(
aes_key, self.cipher_suite['aes']['mode'],
base64.b64decode(payload['secdata']['iv'].encode()))
return_payload = payload['message']
# Decipher message, if present
if 'message' in payload:
decryptor = aes_cipher.decryptor()
return_payload = decryptor.update(
base64.b64decode(
payload['message'].encode())) + decryptor.finalize()
return_payload = json.loads(return_payload.decode())
return return_payload
def handle(self):
data, sock = self.request
if data == b'MAX-REMOTE':
logger.log(type='udp', action='handshake',
content=self.client_address)
else:
logger.log(type='udp', action='data',
content=repr(data))
sock.sendto(config.server_name, self.client_address)
def close(self):
"""Shuts down and closes this client's socket.
Will log error if called on a client with closed socket.
Never fails.
"""
logger.log(logging.INFO, "Client.close(%s)" % self)
try:
self.socket.close()
except:
logging.exception("Client.close(%s)" % self)
def log_servo_error(servo, state, errno, only_log_error_servo=True):
if only_log_error_servo and errno == 0:
return
logger.info('伺服: {}, 状态: {}'.format(servo, state))
if errno != 0:
error = ServoError(errno)
logger.info('报警代码: <span style="color: red">{}</span>'.format(hex(error.errno)))
logger.info('报警说明: <span style="color: red">{}</span>'.format(error.description))
logger.info('报警处理: ')
for i, h in enumerate(error.handle):
logger.info('------>{}. <span style="color: red">{}</span>'.format(i + 1, h))
logger.log('-' * 50)
def extend(self, iteration=1):
logger.warning(
f'Extending pattern with fragments cnt = {len(self.fragments)}')
start_time = time.time()
label_to_fragment_to_ext_list: Dict[str,
Dict[Fragment,
Set[Tuple[Fragment]]]] = {}
for fragment in self.fragments:
label_to_ext_list: Dict[
str, Set[Tuple]] = fragment.get_label_to_ext_list()
for label, exts in label_to_ext_list.items():
d = label_to_fragment_to_ext_list.setdefault(label, {})
d[fragment] = exts
label_to_fragment_to_ext_list = {
k: v
for k, v in label_to_fragment_to_ext_list.items()
if len(v) >= self.MIN_FREQUENCY
}
logger.warning(
f'Dict label_to_fragment_to_ext_list with '
f'{len(label_to_fragment_to_ext_list.items())} items was constructed',
start_time=start_time)
freq_group, freq = self._get_most_freq_group_and_freq(
label_to_fragment_to_ext_list)
if freq >= Pattern.MIN_FREQUENCY:
extended_pattern = Pattern(freq_group, freq)
new_nodes = []
for ix in range(len(self.repr.nodes),
len(extended_pattern.repr.nodes)):
new_nodes.append(extended_pattern.repr.nodes[ix])
old_nodes_s = '\n' + '\n'.join(
[f'\t{node}' for node in self.repr.nodes]) + '\n'
new_nodes_s = '\n' + '\n'.join([f'\t{node}'
for node in new_nodes]) + '\n'
logger.info(f'Pattern with old nodes: {old_nodes_s}'
f'was extended with new nodes: {new_nodes_s}'
f'new size={extended_pattern.size}, '
f'fragments cnt={len(extended_pattern.fragments)}, '
f'iteration = {iteration}')
return extended_pattern.extend(iteration=iteration + 1)
else:
logger.log(logger.WARNING, f'Done extend() for a pattern')
return self
def processAll(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
user = -1
if 'id' in list(data.keys()):
user = int(data['id'])
if user < 0:
logger.log(
logging.ERROR, "No valid \"id\" field in \"all\" message: " +
json.dumps(data))
client.sendResult({"error": "wrong message format"})
return
if not self.registry.userExists(user):
logger.log(
logging.ERROR,
"Unknown source id for \"all\" message: " + json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
if self.registry.getUser(client.secure.uuid).id != user:
logger.log(
logging.ERROR,
"Source id different from client id for \"all\" message: " +
json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
client.sendResult({
"result": [
self.registry.userAllMessages(user),
self.registry.userSentMessages(user)
]
})
def processResource(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
if not set({'ids'}).issubset(set(data.keys())):
logger.log(
logging.ERROR,
"Badly formated \"status\" message: " + json.dumps(data))
client.sendResult({"error": "wrong message format"})
result = []
for user in data['ids']:
result += [self.get_user_resources(user)]
client.sendResult({"result": result})
def processReceipt(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
if not set({'id', 'msg', 'receipt'}).issubset(set(data.keys())):
logger.log(
logging.ERROR,
"Badly formated \"receipt\" message: " + json.dumps(data))
client.sendResult({"error": "wrong request format"})
fromId = int(data["id"])
msg = str(data['msg'])
receipt = str(data['receipt'])
if self.registry.getUser(client.secure.uuid).id != fromId:
logger.log(
logging.ERROR,
"Source id different from client id for \"receipt\" request: "
+ json.dumps(data))
return
if not self.registry.messageWasRed(str(fromId), msg):
logger.log(
logging.ERROR,
"Unknown, or not yet red, message for \"receipt\" request " +
json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
self.registry.storeReceipt(fromId, msg, receipt)
def processList(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
user = 0 # 0 means all users
userStr = "all users"
if 'id' in list(data.keys()):
user = int(data['id'])
userStr = "user%d" % user
logger.log(logging.DEBUG, "List %s" % userStr)
userList = self.registry.listUsers(user)
client.sendResult({"result": userList})
def ssh_public(self, task):
'''
统一任务分配
:param task: 任务指令
:return:
'''
while True:
if task == 'cmd':
command = input("请输入执行命令(q:返回)：\n>>> ").strip()
# 输入命令为空，一直输入
while not command:
command = input(">>> ").strip()
if command == "q": break
elif task == 'trans':
local = input("请输入上传文件的路径(q:返回)：\n>>> ").strip()
# 输入命令为空，一直输入
while not local:
local = input(">>> ").strip()
if local == 'q': break
# 当输入文件不存在，继续输入
while not os.path.exists(local):
print("输入文件不存在。")
local = input("请输入上传文件的路径：\n>>> ").strip()
print("\033[32m远程路径格式：（路径+文件名）\033[0m默认上传到用户宿主目录……")
remote = input("文件到远程的路径(q:返回)\n>>> ").strip()
if remote == 'q': break
t_objs = []
for i in range(len(self.host_list)):
host = self.host_list[i]
ip, port, user, passwd = host['ip'], host['port'], host[
'user'], host['password']
if task == 'cmd':
log(ip, "执行命令：%s" % command) # 写入日志
t = threading.Thread(target=ssh_conn,
args=(ip, port, user, passwd,
command))
elif task == 'trans':
log(ip, "上传文件：%s到%s" % (local, remote)) # 写入日志
t = threading.Thread(target=ssh_trans,
args=(ip, port, user, passwd, local,
remote))
t.start()
t_objs.append(t)
print("\033[5;32;1m任务执行中，请等待……\033[0m")
for t in t_objs:
t.join() # t.wait() 等待
def parseReqs(self, data):
"""Parse a chunk of data from this client.
Return any complete requests in a list.
Leave incomplete requests in the buffer.
This is called whenever data is available from client socket."""
if len(self.bufin) + len(data) > MAX_BUFSIZE:
logger.log(
logging.ERROR,
"Client (%s) buffer exceeds MAX BUFSIZE. %d > %d" %
(self, len(self.bufin) + len(data), MAX_BUFSIZE))
self.bufin = ""
self.bufin += data
reqs = self.bufin.split(TERMINATOR)
self.bufin = reqs[-1]
return reqs[:-1]
def readMsgFile(self, uid, msg):
path = self.userMessageBox(uid)
if msg.startswith('_'):
path = os.path.join(path, msg)
else:
try:
f = os.path.join(path, msg)
path = os.path.join(path, "_" + msg)
logger.log(logging.DEBUG,
"Marking message " + msg + " as read")
os.rename(f, path)
except:
logging.exception("Cannot rename message file to " + path)
path = os.path.join(self.userMessageBox(str(uid)), msg)
return self.readFromFile(path)
def login():
'''
用户登录
:return: 用户登录状态
'''
print("\033[32m*\033[0m" * 30)
print("\033[32m*\t\t简易主机管理系统\033[0m")
print("\033[32m*\033[0m" * 30)
username = input("请输入用户名：\n>>> ").strip()
password = input("请输入密码：\n>>> ").strip()
if username == "admin" and password == "admin":
print("\033[32;1m你已成功登录主机管理系统……\033[0m")
log("Manage_platform", "登录成功")
return True
else:
print("用户名或密码错误……")
return False
def list_all_messages(self):
payload = {'type': 'all'}
if self.debug:
while True:
try:
payload['id'] = int(input(colored("User ID: ", 'blue')))
break
except ValueError:
print(colored("ERROR: Invalid User ID", 'red'))
else:
payload['id'] = self.user_id
print(
colored(
str.format('\nGetting all messages for user {:d} ...\n',
payload['id']), 'yellow'))
data = self.send_payload(
self.secure.encapsulate_secure_message(payload))
data = self.secure.uncapsulate_secure_message(data)
if 'error' in data:
print(colored("ERROR: " + data['error'], 'red'))
else:
if 'result' not in data or len(data['result']) != 2:
print(colored("An error has occurred, aborting.", 'red'))
logger.log(
logging.DEBUG, "ERROR: INCOMPLETE FIELDS IN "
"ALL MESSAGE: %r" % data)
return
if data['result'][0]:
print(colored("All received messages: ", 'green'))
for message in data['result'][0]:
print(colored("\t" + message, 'green'))
else:
print(colored("No received messages", 'green'))
if data['result'][1]:
print(colored("\n\nAll sent messages: ", 'green'))
for message in data['result'][1]:
print(colored("\t" + message, 'green'))
else:
print(colored("No sent messages", 'green'))
def storeReceipt(self, uid, msg, receipt):
pattern = re.compile("_?([0-9]+)_([0-9])")
m = pattern.match(msg)
if not m:
logger.log(
logging.ERROR, "Internal error, wrong message file name (" +
msg + ") format!")
sys.exit(2)
path = self.userReceiptBox(
os.path.join(m.group(1),
"_%s_%s_%d" % (uid, m.group(2), time.time() * 1000)))
try:
self.saveOnFile(path, receipt)
except:
logging.exception("Cannot create receipt file " + path)
def userMessages(self, path, pattern):
logger.log(logging.DEBUG,
"Look for files at " + path + " with pattern " + pattern)
messageList = []
if not os.path.exists(path):
return []
try:
for filename in os.listdir(path):
logger.log(logging.DEBUG, "\tFound file " + filename)
if re.match(pattern, filename):
messageList.append(filename)
except:
logging.exception("Error while listing messages in directory " +
path)
return messageList
def listUsers(self, uid):
if uid == 0:
logger.log(logging.DEBUG, "Looking for all connected users")
else:
logger.log(logging.DEBUG, "Looking for \"%d\"" % uid)
if uid != 0:
user = self.getUser(uid)
if user is not None:
return [user]
return None
userList = []
for k in list(self.users.keys()):
userList.append(self.users[k])
return userList
def processRecv(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
if not set({'id', 'msg'}).issubset(set(data.keys())):
logger.log(logging.ERROR,
"Badly formated \"recv\" message: " + json.dumps(data))
client.sendResult({"error": "wrong message format"})
fromId = int(data['id'])
msg = str(data['msg'])
if not self.registry.userExists(fromId):
logger.log(
logging.ERROR,
"Unknown source id for \"recv\" message: " + json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
if self.registry.getUser(client.secure.uuid).id != fromId:
logger.log(
logging.ERROR,
"Source id different from client id for \"recv\" message: " +
json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
if not self.registry.messageExists(fromId, msg):
logger.log(
logging.ERROR,
"Unknown source msg for \"recv\" message: " + json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
# Read message
response = self.registry.recvMessage(fromId, msg)
sender_id = int(response[0])
client.sendResult({
"result": response,
"resources": {
'result': [self.get_user_resources(sender_id)]
}
})
def uncapsulate_init_message(self, payload):
logger.log(logging.DEBUG, "INIT MESSAGE RECEIVED: %r" % payload)
# Check all payload fields
if not set({'payload', 'cipher_spec', 'signature', 'certificate'
}).issubset(set(payload.keys())):
logger.log(
logging.DEBUG, "ERROR: INCOMPLETE FIELDS IN INIT "
"MESSAGE: %r" % payload)
return {'type': 'error', 'error': 'Invalid secure message format'}
sent_payload = json.loads(
base64.b64decode(payload['payload'].encode()).decode())
self.uuid = sent_payload['uuid']
self.cipher_spec = payload['cipher_spec'] \
if payload['cipher_spec'] is not None \
else json.loads(base64.b64decode(self.registry.getUser(
self.uuid).description['secdata'].encode()).decode())['cipher_spec']
self.cipher_suite = get_cipher_suite(self.cipher_spec)
# Verify signature and certificate validity to authenticate client
peer_certificate = deserialize_certificate(payload['certificate'])
if not self.certs.validate_cert(peer_certificate):
logger.log(logging.DEBUG, "Invalid certificate; "
"dropping message")
self.uuid = None
self.cipher_spec = None
self.cipher_suite = None
return {'type': 'error', 'error': 'Invalid server certificate'}
try:
rsa_verify(peer_certificate.get_pubkey().to_cryptography_key(),
base64.b64decode(payload['signature'].encode()),
payload['payload'].encode(),
self.cipher_suite['rsa']['sign']['cc']['sha'],
self.cipher_suite['rsa']['sign']['cc']['padding'])
except InvalidSignature:
logger.log(logging.DEBUG, "Invalid signature; " "dropping message")
self.uuid = None
self.cipher_spec = None
self.cipher_suite = None
return {'type': 'error', 'error': 'Invalid message signature'}
self.peer_pub_value = deserialize_key(
sent_payload['secdata']['dhpubvalue'])
self.peer_salt = base64.b64decode(
sent_payload['secdata']['salt'].encode())
self.number_of_hash_derivations = sent_payload['secdata']['index']
self.nonce = base64.b64decode(sent_payload['nonce'].encode())
return {'type': 'init', 'uuid': self.uuid}
def get_servo_debug_msg(self, only_log_error_servo=True):
if self.ui.main_ui.window.log_window.isHidden():
self.ui.main_ui.window.log_window.show()
self.ui.main_ui.logAction.setText('Close-Log')
try:
if self.xarm and self.xarm.connected:
ret = self.xarm.get_servo_debug_msg()
if ret[0] in [0, x2_config.UX2_ERR_CODE, x2_config.UX2_WAR_CODE]:
logger.log('=' * 50)
for i in range(1, 8):
servo = '机械臂第{}轴'.format(i)
log_servo_error(servo, ret[i * 2 - 1], ret[i * 2], only_log_error_servo=only_log_error_servo)
log_servo_error('机械爪', ret[15], ret[16], only_log_error_servo=only_log_error_servo)
logger.log('=' * 50)
elif ret[0] == 3:
logger.debug('cmd: get_servo_debug_msg, ret: 通信错误')
else:
logger.debug('cmd: get_servo_debug_msg, ret: xArm is not connected')
except Exception as e:
print(e)
def _get_freq_group(fr):
max_freq = 0
freq_group = None
label_to_ext_list = fr.get_label_to_ext_list()
for label, ext_list in label_to_ext_list.items():
ext_fragments = set()
for ext in ext_list:
ext_fr = Fragment.create_extended(fr, ext)
ext_fragments.add(ext_fr)
groups = Fragment.create_groups(ext_fragments)
for num, group in enumerate(groups):
freq = len(group)
if freq > max_freq:
max_freq = freq
freq_group = group
logger.log(logger.DEBUG, f'Elements in group #{num + 1} -> {len(group)}')
return freq_group
def _group_same_hash_fragments(cls, fragments: set):
groups: Set[FrozenSet[Fragment]] = set()
while len(fragments) > 0:
fragment = next(iter(fragments))
fragments.remove(fragment)
group: Set[Fragment] = set()
group.add(fragment)
for fr in copy.copy(fragments):
if fragment.vector.data == fr.vector.data:
group.add(fr)
fragments.remove(fr)
# TODO: in the source there are also genesis fragments' groups checks, why?
if len(group) >= Pattern.MIN_FREQUENCY:
group: Set[Fragment] = cls._remove_duplicates(group)
if len(group) >= Pattern.MIN_FREQUENCY:
logger.log(logger.INFO, f'A new group has been created, len = {len(group)}', show_pid=True)
groups.add(frozenset(group))
return groups
def processSend(self, data, client):
logger.log(logging.DEBUG, "%s" % json.dumps(data))
if not set(data.keys()).issuperset(set({'src', 'dst', 'msg', 'copy'})):
logger.log(logging.ERROR,
"Badly formatted \"send\" message: " + json.dumps(data))
client.sendResult({"error": "wrong message format"})
srcId = int(data['src'])
dstId = int(data['dst'])
msg = str(data['msg'])
copy = str(data['copy'])
if not self.registry.userExists(srcId):
logger.log(
logging.ERROR,
"Unknown source id for \"send\" message: " + json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
if self.registry.getUser(client.secure.uuid).id != srcId:
logger.log(
logging.ERROR,
"Source id different from client id for \"send\" message: " +
json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
if not self.registry.userExists(dstId):
logger.log(
logging.ERROR,
"Unknown destination id for \"send\" message: " +
json.dumps(data))
client.sendResult({"error": "wrong parameters"})
return
# Save message and copy
response = self.registry.sendMessage(srcId, dstId, msg, copy)
client.sendResult({"result": response})
def handleRequest(self, s, request, client):
"""Handle a request from a client socket.
"""
try:
logging.info("HANDLING message from %s: %r" %
(client, repr(request)))
try:
req = request
except:
logging.exception("Invalid message from client")
return
if not isinstance(req, dict):
logger.log(logging.ERROR, "Invalid message format from client")
return
if 'type' not in req:
logger.log(logging.ERROR, "Message has no TYPE field")
return
if req['type'] in self.messageTypes:
self.messageTypes[req['type']](req, client)
else:
logger.log(
logging.ERROR, "Invalid message type: " +
str(req['type']) + " Should be one of: " +
str(list(self.messageTypes.keys())))
client.sendResult({"error": "unknown request"})
except Exception as e:
logging.exception("Could not handle request")
def recvMessage(self, uid, msg):
uid = str(uid)
msg = str(msg)
result = []
pattern = "_?([0-9]+)_[0-9]+"
matches = re.match(pattern, msg)
if not matches:
logger.log(logging.ERROR,
"Internal error, wrong message file name format!")
sys.exit(2)
result.extend(matches.group(1))
try:
result.append(self.readMsgFile(uid, msg))
except:
logging.exception("Cannot read message " + msg + " from user " +
uid)
return result
