def assertEventsEqual(self, ev1, ev2):
ev1 = self.get_plain_event(Event(ev1))
ev2 = self.get_plain_event(Event(ev2))
if ev1 is not NULL_EVENT and ev2 is not NULL_EVENT:
if (ev1[0][0] and not ev2[0][0]) or (ev2[0][0] and not ev1[0][0]):
ev1[0][0] = ev2[0][0] = "" # delete IDs
self.assertEqual(ev1, ev2)
def run(self, keywords, path, regex=False):
"""Run the Zeitgeist SearchMethod."""
self.stop_search = False
event_template = Event()
time_range = TimeRange.from_seconds_ago(60 * 3600 * 24)
# 60 days at most
results = iface.FindEvents(
time_range, # (min_timestamp, max_timestamp) in milliseconds
[event_template, ],
datamodel.StorageState.Any,
1000,
datamodel.ResultType.MostRecentSubjects
)
results = (datamodel.Event(result) for result in results)
uniques = []
for event in results:
if self.stop_search:
break
for subject in event.get_subjects():
uri = str(subject.uri)
if uri.startswith('file://'):
fullname = str(uri[7:])
filepath, filename = os.path.split(fullname)
if keywords.lower() in filename and \
uri not in uniques and \
path in filepath:
uniques.append(uri)
yield fullname
self.stop_search = True
def testFindEventIdsWithMultipleSubjects(self): subj1 = Subject.new_for_values(uri="file:///tmp/foo.txt") subj2 = Subject.new_for_values(uri="file:///tmp/loo.txt") event = new_event(subjects=[subj1, subj2]) orig_ids = self.insertEventsAndWait([event]) result_ids = self.findEventIdsAndWait([Event()], num_events=0, result_type=ResultType.LeastRecentEvents) self.assertEqual(orig_ids, list(result_ids))
def _get_base_template(self): base_template = Event() if self.has_uri: subj = Subject() subj.set_uri(self.uri+"/*") base_template.set_subjects([subj]) else: base_template.set_actor(self.uri) return base_template
def get_rss_by_usage(self):
print "Events: ",
event_template = Event.new_for_values(
actor=APP_ID, interpretation=Interpretation.VISIT_EVENT.uri)
results = []
ids = self.iface.FindEventIds((0, 0), [event_template], 0, 0, 5)
for event in self.iface.GetEvents(ids):
for subject in Event(event).subjects:
results.append(str(subject.uri))
return results
def testDeleteTwoSimilarEvents(self):
# Insert a couple similar events
event1 = parse_events("test/data/single_event.js")[0]
event2 = Event(event1)
event2.timestamp = int(event1.timestamp) + 1
ids = self.insertEventsAndWait([event1, event2])
# Try deleting one of them
self.deleteEventsAndWait([ids[0]])
# Make sure it's gone, but the second one is still there
retrieved_events = self.getEventsAndWait(ids)
self.assertEqual(retrieved_events[0], None)
self.assertEventsEqual(retrieved_events[1], event2)
def transport(self, events=[]):
'''
Update couchdb with events
'''
self.log(logging.INFO, "Insert events into couchdb")
if events == []:
last = self.last_transaction()
#get events
if (last):
self.log(logging.INFO, "getting itens created after %s", last)
#update of database
#count
from_last_to_now = TimeRange.until_now()
from_last_to_now.begin = int(last) + 1
_events = self._zdclient.FindEvents(
#timerange
from_last_to_now,
[],
StorageState.Any,
0,
ResultType.LeastRecentEvents
)
else:
self.log(logging.INFO, "First interaction, getting last item")
#fist interaction with database
_events = self._zdclient.FindEvents(
#timerange
TimeRange.always(),
[],
StorageState.Any,
1,
ResultType.MostRecentEvents
)
#convert into records
records = []
[records.append(
self.zgToDb(Event(event)) if isinstance(event, dbus.Struct)\
else self.zgToDb(event) if isinstance(event, Event)\
else event
) for event in events]
#put on couchdb
self.log(logging.INFO, "put %s records in couchdb", len(records))
self.put_records(records)
#save last as last_transaction
if len(records): self.last_transaction(records[-1]['timestamp'])
def load_events(self, start=0, end=0, actor=None):
self.set_title("Journal for "+actor)
def exists(uri):
return not uri.startswith("file://") or os.path.exists(urllib.unquote(str(uri[7:])))
def _handle_find_events(ids):
self._zg.get_events(ids, _handle_get_events)
def _handle_get_events(events):
uris = []
for event in events:
for subject in event.subjects:
if exists(subject.uri):
self.view.append_object(event)
event = Event()
event.set_actor(actor)
self._zg.find_events_for_templates([event],_handle_get_events, [start, end], StorageState.Any, 0, 4)
def dict2event(d):
ev = Event()
ev[0][Event.Id] = d.get("id", "")
ev.timestamp = d.get("timestamp", "")
ev.interpretation = d.get("interpretation", "")
ev.manifestation = d.get("manifestation", "")
ev.actor = d.get("actor", "")
ev.origin = d.get("origin", "")
ev.payload = d.get("payload", "")
subjects = d.get("subjects", [])
for sd in subjects:
subj = Subject()
subj.uri = sd.get("uri", "")
subj.current_uri = sd.get("current_uri", "")
subj.interpretation = sd.get("interpretation", "")
subj.manifestation = sd.get("manifestation", "")
subj.origin = sd.get("origin", "")
subj.current_origin = sd.get("current_origin", "")
subj.mimetype = sd.get("mimetype", "")
subj.text = sd.get("text", "")
subj.storage = sd.get("storage", "")
ev.append_subject(subj)
return ev
def testInsertGetWithoutTimestamp(self):
# We test two things, that Event creates a default timestamp
# and that the engine provides one for us if necessary
subj = Subject.new_for_values(interpretation="foo://interp",
manifestation="foo://manif",
uri="nowhere")
ev = Event.new_for_values(interpretation="foo://bar",
manifestation="foo://quiz",
actor="actor://myself",
subjects=[subj])
# Assert that timestamp is set
self.assertTrue(ev.timestamp)
# Clear the timestamp and insert event
ev.timestamp = ""
ids = self.insertEventsAndWait([ev])
result = self.getEventsAndWait(ids)
self.assertEqual(1, len(result))
resulting_event = Event(result.pop())
self.assertEqual("foo://bar", resulting_event.interpretation)
self.assertTrue(resulting_event.timestamp) # We should have a timestamp again
def testFindEventIdsForId(self): # Retrieve events for a particular event ID template = Event([["3", "", "", "", "", ""], [], ""]) ids = self.findEventIdsAndWait([template]) self.assertEqual(ids, [3])
#! /usr/bin/env python
from zeitgeist.client import ZeitgeistDBusInterface
from zeitgeist.datamodel import Event, Interpretation, TimeRange, \
StorageState, ResultType
from datetime import datetime
import dateutil
zg = ZeitgeistDBusInterface()
events = zg.FindEvents(
#timerange
TimeRange.always(),
#Evente template
[Event.new_for_values(
interpretation=\
Interpretation.EVENT_INTERPRETATION.LEAVE_EVENT)],
#Storage State
StorageState.Any,
#How many results
10,
#Result sort
ResultType.MostRecentEvents)
for event in events:
last_event = Event(event)
last_subject = last_event.get_subjects()[0]
print last_subject.uri, datetime.fromtimestamp(float(last_event.timestamp) / 1000)
def event(self):
events = CLIENT._iface.GetEvents([self.id])
if events:
return Event(events[0])
