def _find_work_node(self, session):
"""
Find a node to work over.
:param session:
:return:
"""
def _handle_cypher_result(_result):
"""
Handle the results from the cypher result. If there as no result found then reject the promise, otherwise
update the session with the uri of the node, and
:param _result:
:return:
"""
if not _result.results:
raise Exception("No results to work")
node_uri = _result.results[0].about
session["node_uri"] = node_uri
return session
payload = StoragePayload()
payload.add_property(key=NEO4J.cypher, value=self.query)
promise = self._storage_client.execute_cypher(payload).then(_handle_cypher_result)
return promise
def test_unpack(self):
form = Form()
payload = StoragePayload(form)
about = "urn:rho:identified_by:asdf"
see_also = "urn:rho.value"
mbox = "mailto:[email protected]"
create_if_missing = True
payload.about = about
payload.add_type(FOAF.Person)
payload.add_property(RDFS.seeAlso, see_also)
payload.add_reference(FOAF.mbox, mbox)
payload.add_flag(FindFlags.CREATE_IF_MISSING, create_if_missing)
content = payload.populate_payload()
second_payload = StoragePayload(content)
self.assertEqual(second_payload.about, about)
self.assertIn(str(FOAF.Person), second_payload.types)
self.assertEqual(second_payload.properties[str(RDFS.seeAlso)], [see_also])
self.assertEqual(second_payload.references[str(FOAF.mbox)], [mbox])
self.assertEqual(FindFlags.CREATE_IF_MISSING.fetch_from(second_payload.flags), create_if_missing)
def test_pack_unpacked_payload(self):
form = Form()
payload = StoragePayload(form)
about = "urn:rho:identified_by:asdf"
see_also = "urn:rho.value"
mbox = "mailto:[email protected]"
create_if_missing = True
payload.about = about
payload.add_type(FOAF.Person)
payload.add_property(RDFS.seeAlso, see_also)
payload.add_reference(FOAF.mbox, mbox)
payload.add_flag(FindFlags.CREATE_IF_MISSING, create_if_missing)
content = payload.populate_payload()
second_payload = StoragePayload(content)
second_content = second_payload.populate_payload()
self.assertIsNotNone(second_content)
self.assertEqual(second_content.get_fields()[str(RDF.about)].get_value(), about)
self.assertEqual(second_content.get_fields()[str(RDFS.seeAlso)].get_value(), [see_also])
self.assertEqual(second_content.get_fields()[str(FOAF.mbox)].get_value(), [mbox])
self.assertEqual(second_content.get_fields()[FindFlags.CREATE_IF_MISSING.var].get_value(), create_if_missing)
def test_get_node(self):
self.storage_client._store_found('[email protected]/storage')
payload = StoragePayload()
payload.about = 'http://www.example.org/instance/01'
payload.add_type(FOAF.Person)
payload.add_property(FOAF.name, 'Robert')
promise = self.storage_client.get_node(payload)
def handle_result(result):
self.session['result'] = result
promise.then(handle_result)
self.assertTrue(hasattr(promise, 'then'))
self.send("""
<iq type="set" to="[email protected]/storage" id="1">
<command xmlns="http://jabber.org/protocol/commands"
node="get_node"
action="execute">
<x xmlns="jabber:x:data" type="form">
<field var="http://www.w3.org/1999/02/22-rdf-syntax-ns#about" type="text-single">
<value>http://www.example.org/instance/01</value>
</field>
<field var="http://www.w3.org/1999/02/22-rdf-syntax-ns#type" type="list-multi">
<value>http://xmlns.com/foaf/0.1/Person</value>
</field>
<field var="http://xmlns.com/foaf/0.1/name" type="list-multi">
<value>Robert</value>
<validate xmlns="http://jabber.org/protocol/xdata-validate" datatype="xs:string" />
</field>
</x>
</command>
</iq>
""")
self.assertNotIn('result', self.session)
self.recv("""
<iq type='result' from='[email protected]/storage' to='tester@localhost/full' id='1'>
<command xmlns='http://jabber.org/protocol/commands'
sessionid='list:20020923T213616Z-700'
node='get_node'
status='completed'>
%s
</command>
</iq>
""" % payload.populate_payload())
time.sleep(0.2)
self.assertIn('result', self.session)
result = self.session['result']
self.assertEqual(result.about, 'http://www.example.org/instance/01')
self.assertEquals(result.types[0], str(FOAF.Person))
def convert_rdf_json_to_storage(
definition, store_types=True, store_properties=True, store_bnodes=True, bnode_mappings=None
):
"""
Convert RDF JSON values into a storage payload.
:param definition: dictionary containing the json data.
:param store_types: should store the type values of the definition.
:param store_properties: should store the property values of the definition.
:param store_bnodes: should store the bnodes of the definition.
:param bnode_mappings: dictionary containing a translation key for the bnodes.
:return: newly created storage payload object.
"""
if not bnode_mappings:
bnode_mappings = {}
result = StoragePayload()
for node_uri, values in definition.iteritems():
if node_uri == str(RDF.type):
if store_types:
for value in values:
result.add_type(value["value"])
else:
for value in values:
if store_properties and value["type"] == "literal":
result.add_property(node_uri, value["value"])
elif store_bnodes and value["type"] == "bnode":
if value["value"] in bnode_mappings:
result.add_reference(node_uri, bnode_mappings[value["value"]])
else:
logger.error("Couldn't find bnode mapping for: %s" % value["value"])
return result
def _create_event(self, session, form_payload):
"""
Convert the form payload into a storage payload for creating a new event.
:param session:
:param form_payload:
:return:
"""
create_event_payload = StoragePayload()
create_event_payload.add_type(EVENT.Event)
create_event_payload.add_reference(key=EVENT.agent, value=session['owner'])
create_event_payload.add_reference(key=DCTERMS.creator, value=self._representation_manager.representation_uri)
if 'title' in form_payload.get_values():
create_event_payload.add_property(key=DC.title, value=form_payload.get_values()['title'])
if 'description' in form_payload.get_values():
create_event_payload.add_property(key=DC.description, value=form_payload.get_values()['description'])
if session['location']:
create_event_payload.add_reference(key=EVENT.place, value=session['location'])
if session['interval']:
create_event_payload.add_reference(key=EVENT.time, value=session['interval'])
promise = self._storage_client.create_node(create_event_payload)
return promise
def _create_payload(self):
update_payload = StoragePayload()
update_payload.add_type(FOAF.Agent, RDFS.Resource)
update_payload.add_property(RDFS.seeAlso, self.xmpp.get_uri())
update_payload.add_property(FOAF.name, self.xmpp.name)
return update_payload
def test_execute_cypher(self):
self.storage_client._store_found('[email protected]/storage')
payload = StoragePayload()
payload.add_property(NEO4J.cypher, 'Match (n) RETURN n LIMIT 25')
promise = self.storage_client.execute_cypher(payload)
def handle_result(result):
self.session['result'] = result
promise.then(handle_result)
self.assertTrue(hasattr(promise, 'then'))
self.send("""
<iq type="set" to="[email protected]/storage" id="1">
<command xmlns="http://jabber.org/protocol/commands"
node="cypher"
action="execute">
<x xmlns="jabber:x:data" type="form">
<field var="http://www.neo4j.com/terms/#cypher" type="list-multi">
<value>Match (n) RETURN n LIMIT 25</value>
<validate xmlns="http://jabber.org/protocol/xdata-validate" datatype="xs:string" />
</field>
</x>
</command>
</iq>
""")
self.assertNotIn('result', self.session)
result_payload = ResultCollectionPayload()
result_payload.append(ResultPayload(about='http://www.example.org/instance/01',
types=[FOAF.Person]))
self.recv("""
<iq type='result' from='[email protected]/storage' to='tester@localhost/full' id='1'>
<command xmlns='http://jabber.org/protocol/commands'
sessionid='list:20020923T213616Z-700'
node='cypher'
status='completed'>
%s
</command>
</iq>
""" % result_payload.populate_payload())
time.sleep(0.2)
self.assertIn('result', self.session)
result = self.session['result']
self.assertEqual(1, len(result.results))
self.assertEqual(result.results[0].about, 'http://www.example.org/instance/01')
self.assertEquals(result.results[0].types[0], str(FOAF.Person))
def _start(self, event):
payload = StoragePayload()
payload.add_type(FOAF.Agent, RDFS.Resource)
payload.add_property(RDFS.seeAlso, self.xmpp.get_uri())
promise = self._storage_client.find_nodes(payload)
node_found_promise = promise.then(self._node_found)
node_found_promise.then(self._update_node, self._create_node)
def test_request_data_with_payload(self):
foursquare_uri = 'foursquare://venues/4be0b4f0652b0f475f607311'
storage_payload = StoragePayload()
storage_payload.add_type(WGS_84.SpatialThing)
storage_payload.add_property(RDFS.seeAlso, foursquare_uri)
result = get_foursquare_venue(storage_payload)
self.assertEqual(result, foursquare_uri.split('/')[-1])
def _find_work_node(self, session):
"""
Find node to do work over.
:return:
"""
logger.debug('Executing query: %s' % self.query)
payload = StoragePayload()
payload.add_property(key=NEO4J.cypher, value=self.query)
promise = self._storage_client.execute_cypher(payload).then(
self._scheduler.generate_promise_handler(self._handle_results, session))
return promise
def _process_lookup_result(self, result, payload):
"""
This will split the promise chain in two. If the result returns a value, then the promise will drop off. If
the result doesn't exist, then do an rdf publish and return the result of that.
:param result: the result of the get_command.
:param payload: the payload that was used to look up the data.
:return: a value or a promise that will return the value.
"""
if result.about:
return result.about
location_request = StoragePayload()
location_request.add_type(*payload.types)
location_request.add_property(RDFS.seeAlso, payload.about)
promise = self._rdf_publish.send_out_request(location_request)
promise.then(self._lookup_handler)
return promise
def command_start(self, iq, initial_session):
"""
Starting point for creating a new node.
:param iq:
:param initial_session:
:return:
"""
if not initial_session['payload']:
initial_session['notes'] = [('error', 'Cannot execute without a payload')]
else:
logger.info('Get Node iq: %s' % iq)
logger.info('Initial_session: %s' % initial_session)
payload = StoragePayload(initial_session['payload'])
logger.debug('about: %s' % payload.about)
node = self._command_handler.get_node(payload.about, create=False)
if node:
result_payload = StoragePayload()
result_payload.about = node.uri
# Get the types into place.
for label in node.labels:
result_payload.add_type(label)
# Gather up all of the references
for relationship in node.match_outgoing():
result_payload.add_reference(relationship.type, relationship.end_node.uri)
# Gather up all of the properties
for key, value in node.properties.iteritems():
if isinstance(value, list):
for val in value:
result_payload.add_property(key, val)
else:
result_payload.add_property(key, value)
initial_session['payload'] = result_payload.populate_payload()
return initial_session
def _update_node(self, node_identifier, start_time, end_time):
"""
Update the node and schedule the publishing of the update method.
:param start_time:
:param end_time:
:return:
"""
payload = StoragePayload()
payload.about = node_identifier
payload.add_type(TIMELINE.Interval)
if start_time:
payload.add_property(TIMELINE.start, start_time)
if end_time:
payload.add_property(TIMELINE.end, end_time)
promise = self._storage_client.update_node(payload)
promise.then(self._scheduler.generate_promise_handler(self._rdf_publish.publish_all_results, created=False))
return promise.then(self._handle_result)
def test_no_storage_defined(self):
payload = StoragePayload()
payload.add_property(NEO4J.cypher, 'Match (n) RETURN n LIMIT 25')
promise = self.storage_client.execute_cypher(payload)
def handle_result(result):
self.session['result'] = result
def handle_error(result):
self.session['error'] = result
promise.then(handle_result, handle_error)
self.assertTrue(hasattr(promise, 'then'))
time.sleep(0.2)
self.assertNotIn('result', self.session)
self.assertIn('error', self.session)
def _create_interval(self, session, form_payload):
"""
Convert the form payload into a storage payload for creating a new interval.
:param session:
:param form_payload:
:return:
"""
def _translate_search_to_about(result):
if result.results:
return result.results[0].about
raise RuntimeError('Interval was not created.')
# Handle the creation of the interval.
create_interval_payload = StoragePayload()
create_interval_payload.add_type(TIMELINE.Interval)
if 'event_start' in form_payload.get_values():
create_interval_payload.add_property(TIMELINE.start, form_payload.get_values()['event_start'])
if 'event_stop' in form_payload.get_values():
create_interval_payload.add_property(TIMELINE.end, form_payload.get_values()['event_stop'])
creator = self._representation_manager.representation_uri
if creator:
create_interval_payload.add_property(DCTERMS.creator, creator)
promise = self._storage_client.create_node(create_interval_payload)
promise = promise.then(_translate_search_to_about)
promise = promise.then(self._scheduler.generate_promise_handler(self._update_session, session, 'interval'))
return promise
def test_no_storage_defined(self):
payload = StoragePayload()
payload.about = 'some_urn'
payload.add_type(FOAF.Person)
payload.add_property(FOAF.name, 'Robert')
promise = self.storage_client.update_node(payload)
def handle_result(result):
self.session['result'] = result
def handle_error(result):
self.session['error'] = result
promise.then(handle_result, handle_error)
self.assertTrue(hasattr(promise, 'then'))
time.sleep(0.2)
self.assertNotIn('result', self.session)
self.assertIn('error', self.session)
def test_no_about_defined(self):
self.storage_client._store_found('[email protected]/storage')
payload = StoragePayload()
payload.add_type(FOAF.Person)
payload.add_property(FOAF.name, 'Robert')
promise = self.storage_client.get_node(payload)
def handle_result(result):
self.session['result'] = result
def handle_error(result):
self.session['error'] = result
promise.then(handle_result, handle_error)
self.assertTrue(hasattr(promise, 'then'))
time.sleep(0.2)
self.assertNotIn('result', self.session)
self.assertIn('error', self.session)
def _find_or_create_relative_map_for_date(self, date):
"""
Find or create a relative timeline scale that connects to an origin map with the correct date value.
:param date: date object
:return:
"""
def _handle_find_node(_result):
if not _result.about:
raise Exception("Result not found")
return _result
origin = isodate.isodatetime.datetime_isoformat(date)
search_payload = StoragePayload()
search_payload.add_type(TIMELINE.OriginMap)
search_payload.add_property(TIMELINE.origin, origin)
promise = self._get_or_create(search_payload)
promise = promise.then(_handle_find_node)
promise = promise.then(self._get_range_timeline)
return promise
def _rdf_request_message(self, rdf_payload):
"""
Find node to do work over.
:return:
"""
form = rdf_payload.get('form', None)
payload = StoragePayload(form)
if not self._process_payload(payload):
return None
translation_key = dict(json.loads(CypherFlags.TRANSLATION_KEY.default))
translation_key[str(SCHEMA.name)] = 'name'
translation_key[str(GRAPH.degree)] = 'rels'
logger.debug('Executing query: %s' % self.query)
payload = StoragePayload()
payload.add_property(key=NEO4J.cypher, value=self.query)
payload.add_flag(CypherFlags.TRANSLATION_KEY, json.dumps(translation_key))
promise = self._storage_client.execute_cypher(payload).then(self._process_results)
return promise
def _create_node(self, start_time, end_time):
"""
Create the node and schedule the publishing of the update method.
:param start_time:
:param end_time:
:return:
"""
payload = StoragePayload()
payload.add_type(TIMELINE.Interval)
if start_time:
payload.add_property(TIMELINE.start, start_time)
if end_time:
payload.add_property(TIMELINE.end, end_time)
creator = self._representation_manager.representation_uri
if creator:
payload.add_property(DCTERMS.creator, creator)
promise = self._storage_client.create_node(payload)
promise.then(self._scheduler.generate_promise_handler(self._rdf_publish.publish_all_results, created=True))
return promise.then(self._handle_result)
