def store_results(self, payload, session):
"""
Store the results into the database.
:param payload:
:param session:
:return:
"""
logger.info('Payload: %s' % payload)
logger.info('Session: %s' % session)
storage_session = dict()
if 'locations' in payload.get_values():
storage_payload = StoragePayload()
storage_payload.about = payload.get_values()['locations']
storage_payload.add_type(WGS_84.SpatialThing)
promise = self._get_or_lookup(storage_payload).then(
self._scheduler.generate_promise_handler(self._update_session, storage_session, 'location'))
else:
promise = self._scheduler.defer(lambda: storage_session)
promise = promise.then(self._get_owner)
promise = promise.then(self._scheduler.generate_promise_handler(self._create_interval, payload))
promise = promise.then(self._scheduler.generate_promise_handler(self._create_event, payload))
promise = promise.then(lambda s: session)
session['payload'] = None
session['next'] = None
session['has_next'] = False
return promise
def test_basic_creation(self):
message = self.Message()
payload = StoragePayload()
payload.about = 'urn:rho:instance:owner'
payload.add_type(FOAF.Person, RHO.Owner)
rdf = RDFStanza()
rdf['type'] = RDFStanzaType.CREATE.value
rdf.append(payload.populate_payload())
message.append(rdf)
self.check(message, """
<message>
<rdf xmlns="urn:rho:rdf" type="create">
<x xmlns="jabber:x:data" type="form">
<field var="%s" type="text-single">
<value>%s</value>
</field>
<field var="%s" type="list-multi">
<value>%s</value>
<value>%s</value>
</field>
</x>
</rdf>
</message>
""" % (str(RDF.about), payload.about,
str(RDF.type), str(FOAF.Person), str(RHO.Owner), ), use_values=False)
def test_publish_create(self):
publish_urn = 'rho:instances.owner'
payload = StoragePayload()
payload.add_type(FOAF.Person, RHO.Owner)
payload.about = publish_urn
self.rdf_publisher.publish_create(payload)
self.assertEqual(1, self.roster_plugin.send_message.call_count)
args, kwargs = self.roster_plugin.send_message.call_args
self.assertIn('thread_id', kwargs)
self.assertIn('payload', kwargs)
self.assertIsNone(kwargs['thread_id'])
self.assertIsNotNone(kwargs['payload'])
payload = kwargs['payload']
self.assertEqual(payload['type'], RDFStanzaType.CREATE.value)
form = payload['form']
self.assertIsNotNone(form.get_fields()[str(RDF.type)])
values = form.get_fields()[str(RDF.type)].get_value()
self.assertIn(str(FOAF.Person), values)
self.assertIn(str(RHO.Owner), values)
self.assertIsNotNone(form.get_fields()[str(RDF.about)])
values = form.get_fields()[str(RDF.about)].get_value()
self.assertEqual(publish_urn, values)
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_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_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 _publish_update(self, storage_result):
publish_payload = StoragePayload()
publish_payload.about = storage_result.results[0].about
publish_payload.add_type(*storage_result.results[0].types)
self._node_id = publish_payload.about
self._rdf_publish.publish_update(publish_payload)
def _get_node(self, uri):
"""
Retrieve the actual node.
:param uri:
:return:
"""
get_payload = StoragePayload()
get_payload.about = uri
return self._storage_client.get_node(get_payload)
def publish_all_results(self, result_collection, created=True):
"""
Publish all of the results in the collection to the correct type.
:param result_collection: collection to publish the results of.
:return:
"""
for res in result_collection.results:
publish_payload = StoragePayload()
publish_payload.about = res.about
publish_payload.add_type(*res.types)
if created:
self.publish_create(publish_payload)
else:
self.publish_update(publish_payload)
def _handle_create_and_update_session(_result):
timeline = _result.results[0].about
update_payload = StoragePayload()
update_payload.about = timeline_map.about
update_payload.add_reference(TIMELINE.rangeTimeLine, timeline)
# Publish the create event
self._rdf_publish.publish_all_results(_result, created=True)
_promise = self._storage_client.update_node(update_payload)
_promise = _promise.then(
self._scheduler.generate_promise_handler(self._rdf_publish.publish_all_results, created=False)
)
_promise = _promise.then(lambda s: timeline)
return _promise
def _update_interval(self, session):
"""
Now that the timeline stuff has been found, update the interval as well.
:param session:
:return:
"""
def return_session(result):
self._rdf_publish.publish_all_results(result, created=False)
return session
update_payload = StoragePayload()
update_payload.about = session["node"].about
update_payload.add_reference(TIMELINE.timeline, session["timelines"])
update_payload.add_flag(UpdateFlags.REPLACE_DEFINED, True)
return self._storage_client.update_node(update_payload).then(return_session)
def lookup_foursquare_content(self, node_uri, foursquare_identifier=None):
"""
Looks up the foursquare details of a venue.
:param node_uri: the uri of the node to look up.
:param foursquare_identifier: the identifier of the foursquare data. If this is not provided, the node will be
fetched and the first seeAlso property from the node will be used as this parameter.
:return:
"""
def update_venue_details(venue):
# No point in continuing this exercise if certain requirements are not resolved.
if not venue:
raise RuntimeError('Venue identifier is not defined')
if not self._foursquare_client:
raise RuntimeError('Foursquare client is not defined')
# Finished checking requirements, fetch the details and update.
logger.debug('Looking up venue: %s' % venue)
venue_details = self._foursquare_client.venues(venue)
# Translate the venue details into a rdf storage payload for sending to update.
if 'venue' in venue_details:
storage_payload = StoragePayload()
foursquare_to_storage(venue_details['venue'], storage_payload)
storage_payload.about = node_uri
storage_payload.add_reference(DCTERMS.creator, self._representation_manager.representation_uri)
return self._storage_client.update_node(storage_payload)
# Attempt to look up the venue id from the details in the node.
if foursquare_identifier is None:
search_payload = StoragePayload()
search_payload.about = node_uri
promise = self._storage_client.get_node(search_payload).then(self._handle_get_node)
else:
promise = self._scheduler.promise()
venue_identifier = get_foursquare_venue_from_url(foursquare_identifier)
promise.resolved(venue_identifier)
promise = promise.then(update_venue_details)
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_venue_details(venue):
# No point in continuing this exercise if certain requirements are not resolved.
if not venue:
raise RuntimeError('Venue identifier is not defined')
if not self._foursquare_client:
raise RuntimeError('Foursquare client is not defined')
# Finished checking requirements, fetch the details and update.
logger.debug('Looking up venue: %s' % venue)
venue_details = self._foursquare_client.venues(venue)
# Translate the venue details into a rdf storage payload for sending to update.
if 'venue' in venue_details:
storage_payload = StoragePayload()
foursquare_to_storage(venue_details['venue'], storage_payload)
storage_payload.about = node_uri
storage_payload.add_reference(DCTERMS.creator, self._representation_manager.representation_uri)
return self._storage_client.update_node(storage_payload)
def _get_interval_properties(self, session):
"""
Fetch the properties of the the node stored in the session.
:param session:
:return:
"""
def _handle_get_results(_result):
if not _result.about:
# This is a weird case, and should never happen
raise Exception("Node does not exist")
session["node"] = _result
return session
payload = StoragePayload()
payload.about = session["node_uri"]
promise = self._storage_client.get_node(payload).then(_handle_get_results)
return promise
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.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_create_handler(self):
publish_urn = 'rho:instances.owner'
payload = StoragePayload()
payload.add_type(FOAF.Person, RHO.Owner)
payload.about = publish_urn
self.rdf_publisher.publish_create(payload)
args, kwargs = self.roster_plugin.send_message.call_args
payload = kwargs['payload']
message = Message()
message.append(payload)
self.rdf_publisher._receive_message(message)
create_handler = mock.MagicMock()
self.rdf_publisher.add_create_handler(create_handler)
self.rdf_publisher._receive_message(message)
self.assertEqual(self.scheduler_plugin.defer.call_args[0][0], create_handler)
self.assertEqual(str(self.scheduler_plugin.defer.call_args[0][1]), str(message['rdf']))
