def find_links_with_content(self, data): """Find sc-links with specified content @param data: Content data for search @return: Returns list of sc-addrs of founded sc-links. If there are any error, then return None """ # send request params = struct.pack('=I%ds' % len(data), len(data), data) data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_FIND_LINKS, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK or resSize < 4: return None res = [] data = self.receiveData(resSize) resCount = struct.unpack('=I', data[:4])[0] for i in range(resCount): addr = ScAddr(0, 0) data = data[4:] addr.seg, addr.offset = struct.unpack('=HH', data[:4]) res.append(addr) return res
def find_links_with_content(self, data): """Find sc-links with specified content @param data: Content data for search @return: Returns list of sc-addrs of founded sc-links. If there are any error, then return None """ # send request params = struct.pack('=I%ds' % len(data), len(data), data) data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_FIND_LINKS, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK or resSize < 4: return None res = [] data = self.receiveData(resSize) resCount = struct.unpack('=I', data[:4])[0] for i in xrange(resCount): addr = ScAddr(0, 0) data = data[4:] addr.seg, addr.offset = struct.unpack('=HH', data) res.append(addr) return res
def post(self): result = '[]' with SctpClientInstance() as sctp_client: cmd_addr = ScAddr.parse_from_string(self.get_argument(u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(self.get_argument(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return logic.serialize_error(404, "Invalid argument: %s" % arg) first = False idx += 1 keys = Keynodes(sctp_client) result = logic.do_command(sctp_client, keys, cmd_addr, arguments, self) self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def get_arc(self, arc): """Returns sc-addr of arc element begin @param arc sc-addr of arc to get beign @return If there are no any errors, then returns sc-addr of arc begin; otherwise returns None """ # send request params = struct.pack("=HH", arc.seg, arc.offset) data = struct.pack("=BBII", SctpCommandType.SCTP_CMD_GET_ARC, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack("=BIBI", data) if resCode != SctpResultCode.SCTP_RESULT_OK: return None addr = ScAddr(0, 0) data = self.receiveData(4) addr.seg, addr.offset = struct.unpack("=HH", data) addr2 = ScAddr(0, 0) data = self.receiveData(4) addr2.seg, addr2.offset = struct.unpack("=HH", data) return (addr, addr2)
def post(self): result = '[]' with SctpClientInstance() as sctp_client: cmd_addr = ScAddr.parse_from_string(self.get_argument( u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string( self.get_argument(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return logic.serialize_error( 404, "Invalid argument: %s" % arg) first = False idx += 1 keys = Keynodes(sctp_client) result = logic.do_command(sctp_client, keys, cmd_addr, arguments, self) self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def find_element_by_system_identifier(self, idtf_data): """Find sc-element by it system identifier @param idtf_data: Identifier data for search @return: Returns sc-addrs of founded sc-element. If there are any error or sc-element wasn't found, then return None """ # send request params = struct.pack('=I%ds' % len(idtf_data), len(idtf_data), idtf_data) data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_FIND_ELEMENT_BY_SYSITDF, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK or resSize < 4: return None addr = ScAddr(0, 0) data = self.receiveData(4) addr.seg, addr.offset = struct.unpack('=HH', data) return addr
def create_node(self, el_type): """Create new sc-node in memory with specified type @param el_type: Type of node that would be created @return: If sc-node was created, then returns it sc-addr; otherwise return None """ # send request params = struct.pack('=H', el_type) data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_CREATE_NODE, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK: return None addr = ScAddr(0, 0) data = self.receiveData(4) addr.seg, addr.offset = struct.unpack('=HH', data) return addr
def create_arc(self, arc_type, begin_addr, end_addr): """Create new arc in sc-memory with specified type and begin, end elements @param arc_type: Type of sc-arc @param begin_addr: sc-addr of begin arc element @param end_addr: sc-addr of end arc element @return: If sc-arc was created, then returns it sc-addr; otherwise return None """ # send request params = struct.pack('=HHHHH', arc_type, begin_addr.seg, begin_addr.offset, end_addr.seg, end_addr.offset) data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_CREATE_ARC, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK: return None addr = ScAddr(0, 0) data = self.receiveData(4) addr.seg, addr.offset = struct.unpack('=HH', data) return addr
def info_tooltip(request): result = '[]' if request.is_ajax(): sctp_client = new_sctp_client() # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = request.POST.get(arg_str, None) if arg is not None: arguments.append(arg) first = False idx += 1 keys = Keynodes(sctp_client) sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) res = {} for addr in arguments: tooltip = find_tooltip(ScAddr.parse_from_string(addr), sctp_client, keys, sc_session.get_used_language()) res[addr] = tooltip result = json.dumps(res) return HttpResponse(result, 'application/json')
def post(self): # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = self.get_argument(arg_str, None) if arg is not None: arguments.append(arg) first = False idx += 1 with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) res = {} for addr in arguments: tooltip = logic.find_tooltip(ScAddr.parse_from_string(addr), sctp_client, keys, sc_session.get_used_language()) res[addr] = tooltip self.set_header("Content-Type", "application/json") self.finish(json.dumps(res))
def post(self): lang_addr = ScAddr.parse_from_string(self.get_argument(u'lang_addr', None)) with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) sc_session.set_current_lang_mode(lang_addr) self.finish()
def get(self): result = None # get arguments substr = self.get_argument('substr', None) # connect to redis an try to find identifiers r = redis.StrictRedis(host = tornado.options.options.redis_host, port = tornado.options.options.redis_port, db = tornado.options.options.redis_db_idtf) result = {} sys = [] main = [] common = [] max_n = tornado.options.options.idtf_serach_limit # first of all need to find system identifiers cursor = 0 while True: reply = r.scan(cursor, u"idtf:*%s*" % substr, 200) if not reply or len(reply) == 0: break cursor = int(reply[0]) if cursor == 0: break for idtf in reply[1]: if len(sys) == max_n and len(main) == max_n and len(common) == max_n: break rep = r.get(idtf) utf = idtf.decode('utf-8') addr = ScAddr.parse_binary(rep) if utf.startswith(u"idtf:sys:") and len(sys) < max_n: sys.append([addr.to_id(), utf[9:]]) elif utf.startswith(u"idtf:main:") and len(main) < max_n: main.append([addr.to_id(), utf[10:]]) elif utf.startswith(u"idtf:common:") and len(common) < max_n: common.append([addr.to_id(), utf[12:]]) sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[KeynodeSysIdentifiers.nrel_system_identifier] keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf] result[keynode_nrel_system_identifier.to_id()] = sys result[keynode_nrel_main_idtf.to_id()] = main result[keynode_nrel_idtf.to_id()] = common sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def create_link(self): """Create new sc-link in memory @return: If sc-link was created, then returns it sc-addr; otherwise return None """ # send request data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_CREATE_LINK, 0, 0, 0) alldata = data self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK: return None addr = ScAddr(0, 0) data = self.receiveData(4) addr.seg, addr.offset = struct.unpack('=HH', data) return addr
def post(self): lang_addr = ScAddr.parse_from_string(self.get_argument(u'lang_addr', None)) sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) sc_session.set_current_lang_mode(lang_addr) sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish()
def get_arc(self, arc): """Returns sc-addr of arc element begin @param arc sc-addr of arc to get beign @return If there are no any errors, then returns sc-addr of arc begin; otherwise returns None """ # send request params = struct.pack('=HH', arc.seg, arc.offset) data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_GET_ARC, 0, 0, len(params)) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK: return None addr = ScAddr(0, 0) data = self.receiveData(4) addr.seg, addr.offset = struct.unpack('=HH', data) addr2 = ScAddr(0, 0) data = self.receiveData(4) addr2.seg, addr2.offset = struct.unpack('=HH', data) return (addr, addr2)
def idtf_find(request): result = None if request.is_ajax(): # get arguments substr = request.GET.get('substr', None) # connect to redis an try to find identifiers r = redis.StrictRedis(host = settings.REDIS_HOST, port = settings.REDIS_PORT, db = settings.REDIS_DB) result = {} sys = [] main = [] common = [] # first of all need to find system identifiers cursor = 0 while True: reply = r.scan(cursor, u"idtf:*%s*" % substr, 200) if not reply or len(reply) == 0: break cursor = int(reply[0]) if cursor == 0: break for idtf in reply[1]: if len(sys) == settings.IDTF_SEARCH_LIMIT and len(main) == settings.IDTF_SEARCH_LIMIT and len(common) == settings.IDTF_SEARCH_LIMIT: break rep = r.get(idtf) utf = idtf.decode('utf-8') addr = ScAddr.parse_binary(rep) if utf.startswith(u"idtf:sys:") and len(sys) < settings.IDTF_SEARCH_LIMIT: sys.append([addr.to_id(), utf[9:]]) elif utf.startswith(u"idtf:main:") and len(main) < settings.IDTF_SEARCH_LIMIT: main.append([addr.to_id(), utf[10:]]) elif utf.startswith(u"idtf:common:") and len(common) < settings.IDTF_SEARCH_LIMIT: common.append([addr.to_id(), utf[12:]]) sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[KeynodeSysIdentifiers.nrel_system_identifier] keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf] result[keynode_nrel_system_identifier.to_id()] = sys result[keynode_nrel_main_idtf.to_id()] = main result[keynode_nrel_idtf.to_id()] = common result = json.dumps(result) return HttpResponse(result, 'application/json')
def set_language(request): if (request.is_ajax()): lang_addr = ScAddr.parse_from_string(request.POST.get(u'lang_addr', None)) sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) sc_session.set_current_lang_mode(lang_addr) result = json.dumps('') return HttpResponse(result, 'application/json')
def link_content(request): result = '{}' if True: # request.is_ajax(): sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(request.GET.get('addr', None)) if addr is None: return serialize_error(404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return serialize_error(404, 'Content not found') mimetype_str = u'text/plain' # determine format and mimetype format = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_format ) if format is not None: # fetermine mimetype mimetype = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, format[0][2], ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_mimetype ) if mimetype is not None: mime_value = sctp_client.get_link_content(mimetype[0][2]) if mime_value is not None: mimetype_str = mime_value return HttpResponse(result, mimetype_str + '; charset=UTF-8')
def get(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(self.get_argument('addr', None)) if addr is None: return serialize_error(self, 404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return serialize_error(self, 404, 'Content not found') self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client)) self.finish(result)
def get(self): with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(self.get_argument('addr', None)) if addr is None: return logic.serialize_error(self, 404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return logic.serialize_error(self, 404, 'Content not found') self.set_header("Content-Type", logic.get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client)) self.finish(result)
def link_content(request): result = '{}' sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_nrel_mimetype = keys[KeynodeSysIdentifiers.nrel_mimetype] # parse arguments addr = ScAddr.parse_from_string(request.GET.get('addr', None)) if addr is None: return serialize_error(404, 'Invalid arguments') result = sctp_client.get_link_content(addr) if result is None: return serialize_error(404, 'Content not found') return HttpResponse(result, get_link_mime(addr, keynode_nrel_format, keynode_nrel_mimetype, sctp_client) + '; charset=UTF-8')
def link_format(request): result = '{}' if request.is_ajax(): sctp_client = new_sctp_client() # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = ScAddr.parse_from_string(request.POST.get(arg_str, None)) if arg is not None: arguments.append(arg) first = False idx += 1 keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_format_txt = keys[KeynodeSysIdentifiers.format_txt] result = {} for arg in arguments: # try to resolve format format = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, arg, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_format ) if format is not None: result[arg.to_id()] = format[0][2].to_id() else: result[arg.to_id()] = keynode_format_txt.to_id() result = json.dumps(result) return HttpResponse(result, 'application/json')
def post(self): sctp_client = new_sctp_client() # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg_str = u'%d_' % idx arg = ScAddr.parse_from_string(self.get_argument(arg_str, None)) if arg is not None: arguments.append(arg) first = False idx += 1 keys = Keynodes(sctp_client) keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_format_txt = keys[KeynodeSysIdentifiers.format_txt] result = {} for arg in arguments: # try to resolve format format = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, arg, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_format ) if format is not None: result[arg.to_id()] = format[0][2].to_id() else: result[arg.to_id()] = keynode_format_txt.to_id() sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): result = None # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = self.get_argument(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: self.clear() self.set_status(404) self.finish('Can\'t parse sc-addr from argument: %s' % addr_str) found = False idtf_value = logic.get_identifier_translated( addr, used_lang, keys, sctp_client) if idtf_value: result[addr_str] = idtf_value self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): result = None # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = self.get_argument(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(self, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: self.clear() self.set_status(404) self.finish('Can\'t parse sc-addr from argument: %s' % addr_str) found = False idtf_value = logic.get_identifier_translated(addr, used_lang, keys, sctp_client) if idtf_value: result[addr_str] = idtf_value sctp_client.shutdown() self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def idtf_resolve(request): result = None if request.is_ajax(): # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = request.POST.get(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: print 'Can\'t parse sc-addr from argument: %s' % addr_str return serialize_error(404, 'Can\'t parse sc-addr from argument: %s' % addr_str) found = False idtf_value = get_identifier_translated(addr, used_lang, keys, sctp_client) if idtf_value: result[addr_str] = idtf_value result = json.dumps(result) return HttpResponse(result, 'application/json')
def send(self, message): cmd = json.loads(message) cmdCode = cmd['cmdCode'] def response_message(resCode, res): if res is not None: r = res if isinstance(res, ScAddr): r = res.to_id() self.on_message(json.dumps({'resCode': resCode, 'result': r})) else: self.on_message(json.dumps({'resCode': resCode})) def res_code(res): if res is not None: return sctp.types.SctpResultCode.SCTP_RESULT_OK return sctp.types.SctpResultCode.SCTP_RESULT_FAIL if cmdCode == sctp.types.SctpCommandType.SCTP_CMD_CHECK_ELEMENT: response_message(res_code(sctp.types.ScAddr.parse_from_string(cmd['args'][0])), None) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_FIND_ELEMENT_BY_SYSITDF: res = self.sctp_client.find_element_by_system_identifier(str(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_GET_ELEMENT_TYPE: res = self.sctp_client.get_element_type(sctp.types.ScAddr.parse_from_string(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_GET_ARC: res = self.sctp_client.get_arc(sctp.types.ScAddr.parse_from_string(cmd['args'][0])) response_message(res_code(res), [res[0].to_id(), res[1].to_id()]) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_GET_LINK_CONTENT: res = self.sctp_client.get_link_content(sctp.types.ScAddr.parse_from_string(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_ITERATE_ELEMENTS: resCode = sctp.types.SctpResultCode.SCTP_RESULT_FAIL res = None itType = cmd['args'][0] args = cmd['args'][1:] if itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_3A_A_F: res = self.sctp_client.iterate_elements(itType, args[0], args[1], sctp.types.ScAddr.parse_from_string(args[2])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_3F_A_A: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], args[2]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_3F_A_F: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], sctp.types.ScAddr.parse_from_string(args[2])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_A: res = self.sctp_client.iterate_elements(itType, args[0], args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], args[4]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F: res = self.sctp_client.iterate_elements(itType, args[0], args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], sctp.types.ScAddr.parse_from_string(args[4])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_F_A_A_A_A: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], args[2], args[3], args[4]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_A: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], args[4]) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], sctp.types.ScAddr.parse_from_string(args[2]), args[3], sctp.types.ScAddr.parse_from_string(args[4])) elif itType == sctp.types.SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F: res = self.sctp_client.iterate_elements(itType, sctp.types.ScAddr.parse_from_string(args[0]), args[1], args[2], args[3], sctp.types.ScAddr.parse_from_string(args[4])) sres = [] if res is not None: resCode = sctp.types.SctpResultCode.SCTP_RESULT_OK # convert sc-addrs to string id's for r in res: new_data = [] for v in r: if isinstance(v, sctp.types.ScAddr): new_data.append(v.to_id()) else: new_data.append(v) sres.append(new_data) response_message(resCode, sres) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_EVENT_CREATE: eventType = cmd['args'][0] addr = sctp.types.ScAddr.parse_from_string(cmd['args'][1]) eventId = self.sctp_client.event_create(eventType, addr, self.events_callback) if eventId == None: response_message(sctp.types.SctpResultCode.SCTP_RESULT_FAIL, None) else: response_message(sctp.types.SctpResultCode.SCTP_RESULT_OK, eventId) self.registered_events.append(eventId) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_EVENT_DESTROY: eventId = cmd['args'][0] res = sctp.types.SctpResultCode.SCTP_RESULT_FAIL if self.sctp_client.event_destroy(eventId): res = sctp.types.SctpResultCode.SCTP_RESULT_OK self.registered_events.remove(eventId) response_message(res, None) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_EVENT_EMIT: self.events_lock.acquire() events = self.recieved_events self.recieved_events = [] self.events_lock.release() result = [] for evt in events: if evt[0] in self.registered_events: result.append(evt) response_message(sctp.types.SctpResultCode.SCTP_RESULT_OK, result) # @todo authorised users only elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_CREATE_NODE: res = self.sctp_client.create_node(int(cmd['args'][0])) response_message(res_code(res), res) elif cmdCode == sctp.types.SctpCommandType.SCTP_CMD_CREATE_ARC: args = cmd['args'] res = self.sctp_client.create_arc(int(args[0]), ScAddr.parse_from_string(args[1]), ScAddr.parse_from_string(args[2])) response_message(res_code(res), res)
def get_identifier(request): result = None if request.is_ajax(): lang_code = ScAddr.parse_from_string(request.GET.get(u'language', None)) if lang_code is None: print 'Invalid sc-addr of language' return HttpResponse(None) # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = request.GET.get(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_ui_nrel_idtf_language_relation = keys[KeynodeSysIdentifiers.ui_nrel_idtf_language_relation] # first of all we need to resolve language relation lang_relation_keynode = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, lang_code, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_idtf_language_relation ) if lang_relation_keynode is None: print 'Can\'t resolve keynode for language "%s"' % str(lang_code) return HttpResponse(None) lang_relation_keynode = lang_relation_keynode[0][2] result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: print 'Can\'t parse sc-addr from argument: %s' % addr_str return serialize_error(404, 'Can\'t parse sc-addr from argument: %s' % addr_str) identifier = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, lang_relation_keynode ) idtf_value = None if identifier is not None: idtf_addr = identifier[0][2] # get identifier value idtf_value = sctp_client.get_link_content(idtf_addr) idtf_value = idtf_value.decode('utf-8') result[addr_str] = idtf_value result = json.dumps(result) return HttpResponse(result, 'application/json')
def get(self): result = None # get arguments substr = self.get_argument('substr', None) # connect to redis an try to find identifiers r = redis.StrictRedis(host=tornado.options.options.redis_host, port=tornado.options.options.redis_port, db=tornado.options.options.redis_db_idtf) result = {} sys = [] main = [] common = [] max_n = tornado.options.options.idtf_serach_limit def appendSorted(array, data): if len(array) > 0: idx = 0 inserted = False for idx in xrange(len(array)): if len(array[idx][1]) > len(data[1]): array.insert(idx, data) inserted = True break idx = idx + 1 if not inserted and len(array) < max_n: array.append(data) if (len(array) > max_n): array.pop() else: array.append(data) # first of all need to find system identifiers cursor = 0 while True: reply = r.scan(cursor, u"idtf:*%s*" % substr, 1000) if not reply or len(reply) == 0: break cursor = int(reply[0]) for idtf in reply[1]: if len(sys) == max_n and len(main) == max_n and len( common) == max_n: break rep = r.get(idtf) utf = idtf.decode('utf-8') addr = ScAddr.parse_binary(rep) if utf.startswith(u"idtf:sys:") and len(sys) < max_n: appendSorted(sys, [addr.to_int(), utf[9:]]) elif utf.startswith(u"idtf:main:") and len(main) < max_n: appendSorted(main, [addr.to_int(), utf[10:]]) elif utf.startswith(u"idtf:common:") and len(common) < max_n: appendSorted(common, [addr.to_int(), utf[12:]]) if cursor == 0: break with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[ KeynodeSysIdentifiers.nrel_system_identifier] keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf] result['sys'] = sys result['main'] = main result['common'] = common self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def post(self): with SctpClientInstance() as sctp_client: question_addr = ScAddr.parse_from_string( self.get_argument(u'question', None)) format_addr = ScAddr.parse_from_string( self.get_argument(u'format', None)) keys = Keynodes(sctp_client) keynode_nrel_answer = keys[ KeynodeSysIdentifiers.question_nrel_answer] keynode_nrel_translation = keys[ KeynodeSysIdentifiers.nrel_translation] keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # try to find answer for the question wait_time = 0 wait_dt = 0.1 answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error(self, 404, 'Timeout waiting for answer') answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) if answer is None: return logic.serialize_error(self, 404, 'Answer not found') answer_addr = answer[0][2] # try to find translation to specified format result_link_addr = logic.find_translation_with_format( answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) # if link addr not found, then run translation of answer to specified format if result_link_addr is None: trans_cmd_addr = sctp_client.create_node( ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, trans_cmd_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, answer_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, format_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_output_format], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # add into translation command set arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_translate_from_sc], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # initialize command arc_addr = sctp_client.create_arc( ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_initiated], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # now we need to wait translation result wait_time = 0 translation = logic.find_translation_with_format( answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error( self, 404, 'Timeout waiting for answer translation') translation = logic.find_translation_with_format( answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) if translation is not None: result_link_addr = translation # if result exists, then we need to return it content if result_link_addr is not None: result = json.dumps({"link": result_link_addr.to_int()}) self.set_header("Content-Type", "application/json") self.finish(result)
def iterate_elements(self, iterator_type, *args): """Iterate element by specified template and return results """ params = None params_count = None if iterator_type == SctpIteratorType.SCTP_ITERATOR_3A_A_F: params_count = 3 params = struct.pack('=BHHHH', iterator_type, args[0], args[1], args[2].seg, args[2].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_3F_A_A: params_count = 3 params = struct.pack('=BHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_3F_A_F: params_count = 3 params = struct.pack('=BHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2].seg, args[2].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_A: params_count = 5 params = struct.pack('=BHHHHHH', iterator_type, args[0], args[1], args[2].seg, args[2].offset, args[3], args[4]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F: params_count = 5 params = struct.pack('=BHHHHHHH', iterator_type, args[0], args[1], args[2].seg, args[2].offset, args[3], args[4].seg, args[4].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_F_A_A_A_A: params_count = 5 params = struct.pack('=BHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2], args[3], args[4]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_A: params_count = 5 params = struct.pack('=BHHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2].seg, args[2].offset, args[3], args[4]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F: params_count = 5 params = struct.pack('=BHHHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2].seg, args[2].offset, args[3], args[4].seg, args[4].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F: params_count = 5 params = struct.pack('=BHHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2], args[3], args[4].seg, args[4].offset) params_len = len(params) # send request data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_ITERATE_ELEMENTS, 0, 0, params_len) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK or resSize == 0: return None res_count_data = self.receiveData(4) res_count = struct.unpack('=I', res_count_data)[0] if res_count == 0: return None results = [] for idx in range(res_count): result_item = [] for j in range(params_count): addr_data = self.receiveData(4) addr = ScAddr(0, 0) addr.seg, addr.offset = struct.unpack('=HH', addr_data) result_item.append(addr) results.append(result_item) return results
def idtf_resolve(request): result = None if request.is_ajax(): # get arguments idx = 1 arguments = [] arg = '' while arg is not None: arg = request.POST.get(u'%d_' % idx, None) if arg is not None: arguments.append(arg) idx += 1 sctp_client = new_sctp_client() keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[KeynodeSysIdentifiers.nrel_system_identifier] sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) used_lang = sc_session.get_used_language() result = {} # get requested identifiers for arguments for addr_str in arguments: addr = ScAddr.parse_from_string(addr_str) if addr is None: print 'Can\'t parse sc-addr from argument: %s' % addr_str return serialize_error(404, 'Can\'t parse sc-addr from argument: %s' % addr_str) found = False identifier = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_main_idtf ) idtf_value = None if identifier is not None: for res in identifier: idtf_addr = res[2] # check if founded main identifier is for used language langs = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_3F_A_F, used_lang, ScElementType.sc_type_arc_pos_const_perm, idtf_addr ) if langs is not None: # get identifier value idtf_value = sctp_client.get_link_content(idtf_addr) idtf_value = idtf_value.decode('utf-8') found = True result[addr_str] = idtf_value # if identifier not found, then get system identifier if not found: identifier = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_system_identifier ) if identifier is not None: idtf_value = sctp_client.get_link_content(identifier[0][2]) idtf_value = idtf_value.decode('utf-8') result[addr_str] = idtf_value result = json.dumps(result) return HttpResponse(result, 'application/json')
def get(self): result = None # get arguments substr = self.get_argument('substr', None) # connect to redis an try to find identifiers r = redis.StrictRedis(host = tornado.options.options.redis_host, port = tornado.options.options.redis_port, db = tornado.options.options.redis_db_idtf) result = {} sys = [] main = [] common = [] max_n = tornado.options.options.idtf_serach_limit def appendSorted(array, data): if len(array) > 0: idx = 0 inserted = False for idx in xrange(len(array)): if len(array[idx][1]) > len(data[1]): array.insert(idx, data) inserted = True break; idx = idx + 1 if not inserted and len(array) < max_n: array.append(data) if (len(array) > max_n): array.pop() else: array.append(data) # first of all need to find system identifiers cursor = 0 while True: reply = r.scan(cursor, u"idtf:*%s*" % substr, 1000) if not reply or len(reply) == 0: break cursor = int(reply[0]) for idtf in reply[1]: if len(sys) == max_n and len(main) == max_n and len(common) == max_n: break rep = r.get(idtf) utf = idtf.decode('utf-8') addr = ScAddr.parse_binary(rep) if utf.startswith(u"idtf:sys:") and len(sys) < max_n: appendSorted(sys, [addr.to_int(), utf[9:]]) elif utf.startswith(u"idtf:main:") and len(main) < max_n: appendSorted(main, [addr.to_int(), utf[10:]]) elif utf.startswith(u"idtf:common:") and len(common) < max_n: appendSorted(common, [addr.to_int(), utf[12:]]) if cursor == 0: break with SctpClientInstance() as sctp_client: keys = Keynodes(sctp_client) keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] keynode_nrel_system_identifier = keys[KeynodeSysIdentifiers.nrel_system_identifier] keynode_nrel_idtf = keys[KeynodeSysIdentifiers.nrel_idtf] result['sys'] = sys result['main'] = main result['common'] = common self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))
def cmd_do(request): result = '[]' if request.is_ajax(): sctp_client = new_sctp_client() cmd_addr = ScAddr.parse_from_string(request.POST.get(u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(request.POST.get(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return serialize_error(404, "Invalid argument: %s" % arg) first = False idx += 1 if (len(arguments) > 0) and (cmd_addr is not None): keys = Keynodes(sctp_client) keynode_ui_rrel_commnad = keys[KeynodeSysIdentifiers.ui_rrel_commnad] keynode_ui_rrel_command_arguments = keys[KeynodeSysIdentifiers.ui_rrel_command_arguments] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user_command_question = keys[KeynodeSysIdentifiers.ui_user_command_question] keynode_ui_command_generate_instance = keys[KeynodeSysIdentifiers.ui_command_generate_instance] keynode_ui_command_initiated = keys[KeynodeSysIdentifiers.ui_command_initiated] keynode_ui_command_finished = keys[KeynodeSysIdentifiers.ui_command_finished] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user = keys[KeynodeSysIdentifiers.ui_user] #keynode_ui_displayed_answer = keys[KeynodeSysIdentifiers.ui_displayed_answer] keynode_nrel_authors = keys[KeynodeSysIdentifiers.nrel_authors] #keynode_ui_nrel_user_answer_formats = keys[KeynodeSysIdentifiers.ui_nrel_user_answer_formats] #keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] #keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_question_initiated = keys[KeynodeSysIdentifiers.question_initiated] keynode_question = keys[KeynodeSysIdentifiers.question] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # create command in sc-memory inst_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_addr) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_generate_instance, inst_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) inst_cmd_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_commnad, inst_cmd_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # create arguments args_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, args_addr) args_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, args_addr) append_to_system_elements(sctp_client, keynode_system_element, args_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_command_arguments, args_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) idx = 1 for arg in arguments: arg_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, args_addr, arg) append_to_system_elements(sctp_client, keynode_system_element, arg_arc) if arg_arc is None: return serialize_error(404, 'Error while create "create_instance" command') idx_addr = sctp_client.find_element_by_system_identifier(str(u'rrel_%d' % idx)) if idx_addr is None: return serialize_error(404, 'Error while create "create_instance" command') idx += 1 arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, idx_addr, arg_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) wait_time = 0 wait_dt = 0.1 # initialize command arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_initiated, inst_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) cmd_finished = check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) while cmd_finished is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for "create_instance" command finished') cmd_finished = check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) # get command result cmd_result = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, inst_cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_command_result ) if cmd_result is None: return serialize_error(404, 'Can\'t find "create_instance" command result') cmd_result = cmd_result[0][2] # @todo support all possible commands # try to find question node question = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, keynode_question, ScElementType.sc_type_arc_pos_const_perm, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, cmd_result ) if question is None: return serialize_error(404, "Can't find question node") question = question[0][2] append_to_system_elements(sctp_client, keynode_system_element, question) # create author sc_session = logic.ScSession(request.user, request.session, sctp_client, keys) user_node = sc_session.get_sc_addr() if not user_node: return serialize_error(404, "Can't resolve user node") arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_user, user_node) append_to_system_elements(sctp_client, keynode_system_element, arc) author_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, user_node) append_to_system_elements(sctp_client, keynode_system_element, author_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_authors, author_arc) append_to_system_elements(sctp_client, keynode_system_element, arc) # create output formats set '''output_formats_node = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, output_formats_node) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, output_formats_node, output_addr) append_to_system_elements(sctp_client, keynode_system_element, arc) format_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, output_formats_node) append_to_system_elements(sctp_client, keynode_system_element, format_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_user_answer_formats, format_arc) append_to_system_elements(sctp_client, keynode_system_element, arc)''' # initiate question arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_question_initiated, question) append_to_system_elements(sctp_client, keynode_system_element, arc) # first of all we need to wait answer to this question #print sctp_client.iterate_elements(SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_question_initiated, 0, 0) result = { 'question': question.to_id() } result = json.dumps(result) return HttpResponse(result, 'application/json')
def question_answer_translate(request): if request.is_ajax(): sctp_client = new_sctp_client() question_addr = ScAddr.parse_from_string(request.POST.get(u'question', None)) format_addr = ScAddr.parse_from_string(request.POST.get(u'format', None)) keys = Keynodes(sctp_client) keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # try to find answer for the question wait_time = 0 wait_dt = 0.1 answer = find_answer(question_addr, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for answer') answer = find_answer(question_addr, keynode_nrel_answer, sctp_client) if answer is None: return serialize_error(404, 'Answer not found') answer_addr = answer[0][2] result_link_addr = None # try to find translation to specified format result_link_addr = find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) # if link addr not found, then run translation of answer to specified format if result_link_addr is None: trans_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) append_to_system_elements(sctp_client, keynode_system_element, trans_cmd_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, answer_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction], arc_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, format_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_output_format], arc_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # add into translation command set arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_translate_from_sc], trans_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # initialize command arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_initiated], trans_cmd_addr) append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # now we need to wait translation result wait_time = 0 translation = find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > settings.EVENT_WAIT_TIMEOUT: return serialize_error(404, 'Timeout waiting for answer translation') translation = find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) if translation is not None: result_link_addr = translation # if result exists, then we need to return it content if result_link_addr is not None: result = json.dumps({"link": result_link_addr.to_id()}) return HttpResponse(result, 'application/json') return serialize_error(404, "Can't make translation")
def post(self): with SctpClientInstance() as sctp_client: question_addr = ScAddr.parse_from_string(self.get_argument(u'question', None)) format_addr = ScAddr.parse_from_string(self.get_argument(u'format', None)) keys = Keynodes(sctp_client) keynode_nrel_answer = keys[KeynodeSysIdentifiers.question_nrel_answer] keynode_nrel_translation = keys[KeynodeSysIdentifiers.nrel_translation] keynode_nrel_format = keys[KeynodeSysIdentifiers.nrel_format] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] # try to find answer for the question wait_time = 0 wait_dt = 0.1 answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) while answer is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error(self, 404, 'Timeout waiting for answer') answer = logic.find_answer(question_addr, keynode_nrel_answer, sctp_client) if answer is None: return logic.serialize_error(self, 404, 'Answer not found') answer_addr = answer[0][2] # try to find translation to specified format result_link_addr = logic.find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) # if link addr not found, then run translation of answer to specified format if result_link_addr is None: trans_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, trans_cmd_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, answer_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_source_sc_construction], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, trans_cmd_addr, format_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_rrel_output_format], arc_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # add into translation command set arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_translate_from_sc], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # initialize command arc_addr = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keys[KeynodeSysIdentifiers.ui_command_initiated], trans_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc_addr) # now we need to wait translation result wait_time = 0 translation = logic.find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) while translation is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return logic.serialize_error(self, 404, 'Timeout waiting for answer translation') translation = logic.find_translation_with_format(answer_addr, format_addr, keynode_nrel_format, keynode_nrel_translation, sctp_client) if translation is not None: result_link_addr = translation # if result exists, then we need to return it content if result_link_addr is not None: result = json.dumps({"link": result_link_addr.to_int()}) self.set_header("Content-Type", "application/json") self.finish(result)
def iterate_elements(self, iterator_type, *args): """Iterate element by specified template and return results """ params = None params_count = None if iterator_type == SctpIteratorType.SCTP_ITERATOR_3A_A_F: params_count = 3 params = struct.pack('=BHHHH', iterator_type, args[0], args[1], args[2].seg, args[2].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_3F_A_A: params_count = 3 params = struct.pack('=BHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_3F_A_F: params_count = 3 params = struct.pack('=BHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2].seg, args[2].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_A: params_count = 5 params = struct.pack('=BHHHHHH', iterator_type, args[0], args[1], args[2].seg, args[2].offset, args[3], args[4]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_A_A_F_A_F: params_count = 5 params = struct.pack('=BHHHHHHH', iterator_type, args[0], args[1], args[2].seg, args[2].offset, args[3], args[4].seg, args[4].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_F_A_A_A_A: params_count = 5 params = struct.pack('=BHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2], args[3], args[4]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_A: params_count = 5 params = struct.pack('=BHHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2].seg, args[2].offset, args[3], args[4]) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5_F_A_F_A_F: params_count = 5 params = struct.pack('=BHHHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2].seg, args[2].offset, args[3], args[4].seg, args[4].offset) elif iterator_type == SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F: params_count = 5 params = struct.pack('=BHHHHHHH', iterator_type, args[0].seg, args[0].offset, args[1], args[2], args[3], args[4].seg, args[4].offset) params_len = len(params) # send request data = struct.pack('=BBII', SctpCommandType.SCTP_CMD_ITERATE_ELEMENTS, 0, 0, params_len) alldata = data + params self.sock.send(alldata) # receive response data = self.receiveData(10) cmdCode, cmdId, resCode, resSize = struct.unpack('=BIBI', data) if resCode != SctpResultCode.SCTP_RESULT_OK or resSize == 0: return None res_count_data = self.receiveData(4) res_count = struct.unpack('=I', res_count_data)[0] if res_count == 0: return None results = [] for idx in xrange(res_count): result_item = [] for j in xrange(params_count): addr_data = self.receiveData(4) addr = ScAddr(0, 0) addr.seg, addr.offset = struct.unpack('=HH', addr_data) result_item.append(addr) results.append(result_item) return results
def post(self): result = '[]' with SctpClientInstance() as sctp_client: cmd_addr = ScAddr.parse_from_string(self.get_argument(u'cmd', None)) # parse arguments first = True arg = None arguments = [] idx = 0 while first or (arg is not None): arg = ScAddr.parse_from_string(self.get_argument(u'%d_' % idx, None)) if arg is not None: # check if sc-element exist if sctp_client.check_element(arg): arguments.append(arg) else: return serialize_error(404, "Invalid argument: %s" % arg) first = False idx += 1 if (len(arguments) > 0) and (cmd_addr is not None): keys = Keynodes(sctp_client) keynode_ui_rrel_commnad = keys[KeynodeSysIdentifiers.ui_rrel_commnad] keynode_ui_rrel_command_arguments = keys[KeynodeSysIdentifiers.ui_rrel_command_arguments] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_command_generate_instance = keys[KeynodeSysIdentifiers.ui_command_generate_instance] keynode_ui_command_initiated = keys[KeynodeSysIdentifiers.ui_command_initiated] keynode_ui_command_finished = keys[KeynodeSysIdentifiers.ui_command_finished] keynode_ui_nrel_command_result = keys[KeynodeSysIdentifiers.ui_nrel_command_result] keynode_ui_user = keys[KeynodeSysIdentifiers.ui_user] keynode_nrel_authors = keys[KeynodeSysIdentifiers.nrel_authors] keynode_question_initiated = keys[KeynodeSysIdentifiers.question_initiated] keynode_question = keys[KeynodeSysIdentifiers.question] keynode_system_element = keys[KeynodeSysIdentifiers.system_element] keynode_nrel_ui_nrel_command_lang_template = keys[KeynodeSysIdentifiers.nrel_ui_nrel_command_lang_template] keynode_languages = keys[KeynodeSysIdentifiers.languages] keynode_nrel_main_idtf = keys[KeynodeSysIdentifiers.nrel_main_idtf] # create command in sc-memory inst_cmd_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_addr) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_generate_instance, inst_cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) inst_cmd_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, cmd_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, inst_cmd_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_commnad, inst_cmd_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) # create arguments args_addr = sctp_client.create_node(ScElementType.sc_type_node | ScElementType.sc_type_const) logic.append_to_system_elements(sctp_client, keynode_system_element, args_addr) args_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, inst_cmd_addr, args_addr) logic.append_to_system_elements(sctp_client, keynode_system_element, args_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_rrel_command_arguments, args_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) idx = 1 for arg in arguments: arg_arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, args_addr, arg) logic.append_to_system_elements(sctp_client, keynode_system_element, arg_arc) if arg_arc is None: return serialize_error(self, 404, 'Error while create "create_instance" command') idx_addr = sctp_client.find_element_by_system_identifier(str(u'rrel_%d' % idx)) if idx_addr is None: return serialize_error(self, 404, 'Error while create "create_instance" command') idx += 1 arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, idx_addr, arg_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) wait_time = 0 wait_dt = 0.1 # initialize command arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_command_initiated, inst_cmd_addr) cmd_finished = logic.check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) while cmd_finished is None: time.sleep(wait_dt) wait_time += wait_dt if wait_time > tornado.options.options.event_wait_timeout: return serialize_error(self, 404, 'Timeout waiting for "create_instance" command finished') cmd_finished = logic.check_command_finished(inst_cmd_addr, keynode_ui_command_finished, sctp_client) # get command result cmd_result = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, inst_cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, keynode_ui_nrel_command_result ) if cmd_result is None: return serialize_error(self, 404, 'Can\'t find "create_instance" command result') cmd_result = cmd_result[0][2] # @todo support all possible commands # try to find question node question = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, keynode_question, ScElementType.sc_type_arc_pos_const_perm, ScElementType.sc_type_node | ScElementType.sc_type_const, ScElementType.sc_type_arc_pos_const_perm, cmd_result ) if question is None: return serialize_error(self, 404, "Can't find question node") question = question[0][2] logic.append_to_system_elements(sctp_client, keynode_system_element, question) # generate main identifiers langs = logic.get_languages_list(keynode_languages, sctp_client) if langs: templates = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_5F_A_A_A_F, cmd_addr, ScElementType.sc_type_arc_common | ScElementType.sc_type_const, ScElementType.sc_type_link, ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_ui_nrel_command_lang_template ) if templates: generated = {} identifiers = {} # get identifiers for l in langs: identifiers[str(l)] = {} for a in arguments: idtf_value = logic.get_identifier_translated(a, l, keys, sctp_client) if idtf_value: identifiers[str(l)][str(a)] = idtf_value for t in templates: input_arcs = sctp_client.iterate_elements( SctpIteratorType.SCTP_ITERATOR_3A_A_F, ScElementType.sc_type_node | ScElementType.sc_type_const | ScElementType.sc_type_node_class, ScElementType.sc_type_arc_pos_const_perm, t[2]) if input_arcs: for arc in input_arcs: for l in langs: if not generated.has_key(str(l)) and arc[0] == l: lang_idtfs = identifiers[str(l)] # get content of link data = sctp_client.get_link_content(t[2]).decode('utf-8') if data: for idx in xrange(len(arguments)): value = arguments[idx].to_id() if lang_idtfs.has_key(str(arguments[idx])): value = lang_idtfs[str(arguments[idx])] data = data.replace(u'$ui_arg_%d' % (idx + 1), value) # generate identifier idtf_link = sctp_client.create_link() sctp_client.set_link_content(idtf_link, str(data.encode('utf-8'))) sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, l, idtf_link) bin_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, idtf_link) sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_main_idtf, bin_arc) generated[str(l)] = True # create author sc_session = logic.ScSession(self, sctp_client, keys) user_node = sc_session.get_sc_addr() if not user_node: return serialize_error(self, 404, "Can't resolve user node") arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_ui_user, user_node) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) author_arc = sctp_client.create_arc(ScElementType.sc_type_arc_common | ScElementType.sc_type_const, question, user_node) logic.append_to_system_elements(sctp_client, keynode_system_element, author_arc) arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_nrel_authors, author_arc) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) # initiate question arc = sctp_client.create_arc(ScElementType.sc_type_arc_pos_const_perm, keynode_question_initiated, question) logic.append_to_system_elements(sctp_client, keynode_system_element, arc) # first of all we need to wait answer to this question #print sctp_client.iterate_elements(SctpIteratorType.SCTP_ITERATOR_3F_A_A, keynode_question_initiated, 0, 0) result = { 'question': question.to_id() } self.set_header("Content-Type", "application/json") self.finish(json.dumps(result))