def __init__(self, log=log):
self.log = log
self._zclient = ZeitgeistClient()
self._zdclient = ZeitgeistDBusInterface()
self._database = DesktopDatabase(DATABASE_NAME, create=True)
self._user = os.environ.get('USERNAME')
self._machine = os.uname()
def on_db_change(self, callback=None, dbname=DATABASE_NAME, every=2):
'''
Set some function to be called when db entry content changed
Call this function with callback=False to remove change watch
The callback will be called with same keyworkd that in _changes
Consult _changes for more info
http://wiki.apache.org/couchdb/HTTP_database_API#Continuous_.28Nohangeshangesn-Polling.29_Feed
Examples:
Insert or Update case
>>> callback(**{
>>> "seq":331,
>>> "id":"<_id of document entry>",
>>> "changes":[{"rev":"<_rev of document entry>"}]
>>> })
Delete case
>>> callback(**{
>>> "seq":334,
>>> "id":"<_id of document entry>",
>>> "changes":[{"rev":"<_rev of document entry>"}],
>>> "deleted":True
>>> })
callback: callable, called with changes
dbname: name of database do watch
every: time in seconds, how many seconds to wait and rescan for changes
'''
db = self._databases.get(dbname)
if db:
gobject.source_remove(db['onchangeeventid'])
else:
self._databases[dbname] = db = {
'dbinstance': self._database if dbname is DATABASE_NAME\
else DesktopDatabase(dbname)
}
def watch_changes():
db['dbinstance'].report_changes(callback)
db['onchangeeventid'] = \
gobject.timeout_add_seconds(every, watch_changes)
if callback:
watch_changes()
class _CouchdbCommon(object):
def __init__(self, log=log):
self.log = log
self._zclient = ZeitgeistClient()
self._zdclient = ZeitgeistDBusInterface()
self._database = DesktopDatabase(DATABASE_NAME, create=True)
self._user = os.environ.get('USERNAME')
self._machine = os.uname()
def _add_view(self, view):
#create views if not exist
if not self._database.view_exists(view.name, DATABASE_NAME):
self.log(logging.DEBUG, """adding in %s view %s with: %s""", DATABASE_NAME, view.name, view.view)
self._database.add_view(view.name, view.view, None, DATABASE_NAME)
self._database.execute_view(view.name)
else:
self.log(logging.DEBUG, """view %s exist in %s""", view.name, DATABASE_NAME)
def _execute_view(self, view):
self._add_view(view)
return self._database.execute_view(view.name, DATABASE_NAME)
def last_transaction(self, when=None):
'''
Getter or Setter for last_transaction
event: dict, last sync item
return dict
'''
if when:
self.save_config("last_transaction", when)
else:
when = self.config("last_transaction")
if not when:
self._database.execute_view(VIEW.TIMESTAMP.name)
return when
def save_config(self, attr, val):
self.log(logging.DEBUG, "setting value %s for %s", attr, val)
if self._database.record_exists(attr):
record = self._database.get_record(attr)
self._database.update_fields(attr, {'value': val})
else:
record = CouchRecord({'value': val}, COUCH_CFG_TYPE, attr)
self.put_record(record)
def config(self, attr):
self.log(logging.DEBUG, "getting info: %s", attr)
if self._database.record_exists(attr):
cfg = self._database.get_record(attr)
self.log(logging.DEBUG, "value of info %s is %s", attr, cfg['value'])
return cfg['value']
self.log(logging.DEBUG, "can't get config %s", attr)
def dbToZg(self, obj):
'''
Convert courchrecord in zeiteist event
'''
return Event.new_for_values(**obj)
def zgToDb(self, obj):
'''
Convert zeitgeist event in couchrecord
'''
result = {
'application_annotations':{
'zeitgeist':{
'user': self._user,
'machine': self._machine
}
}
}
if obj.get_actor(): result['actor'] = obj.get_actor()
if obj.get_id(): result['id'] = int(obj.get_id())
if obj.get_interpretation(): result['interpretation'] = obj.get_interpretation()
if obj.get_manifestation(): result['manifestation'] = obj.get_manifestation()
if obj.get_origin(): result['origin'] = obj.get_origin()
if obj.get_payload(): result['payload'] = obj.get_payload()
if obj.get_timestamp(): result['timestamp'] = int(obj.get_timestamp())
result['subjects'] = []
for subject in obj.get_subjects():
sub = {}
if subject.get_interpretation(): sub['interpretation'] = subject.get_interpretation()
if subject.get_manifestation(): sub['manifestation'] = subject.get_manifestation()
if subject.get_mimetype(): sub['mimetype'] = subject.get_mimetype()
if subject.get_origin(): sub['origin'] = subject.get_origin()
if subject.get_storage(): sub['storage'] = subject.get_storage()
if subject.get_text(): sub['text'] = subject.get_text()
if subject.get_uri(): sub['uri'] = subject.get_uri()
result['subjects'].append(sub)
return CouchRecord(result, COUCH_OBJ_TYPE)
def put_record(self, record):
self._database.put_record(record)
def put_records(self, records):
self._database.put_records_batch(records)
