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 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):
# 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 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 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 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 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 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 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 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):
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))
