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']))