def _process_rtm_task(self, rtm_task_id):
'''
Takes a rtm task id and carries out the necessary operations to
refresh the sync state
'''
self.cancellation_point()
if not self.rtm_proxy.is_authenticated():
return
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
is_syncable = self._rtm_task_is_syncable_per_attached_tags(rtm_task)
action, tid = self.sync_engine.analyze_remote_id(
rtm_task_id, self.datastore.has_task, self.rtm_proxy.has_rtm_task,
is_syncable)
Log.debug("GTG<-RTM set task (%s, %s)" % (action, is_syncable))
if action is None:
return
if action == SyncEngine.ADD:
if rtm_task.get_status() != Task.STA_ACTIVE:
# OPTIMIZATION:
# we don't sync tasks that have already been closed before we
# even saw them
return
tid = str(uuid.uuid4())
task = self.datastore.task_factory(tid)
self._populate_task(task, rtm_task)
meme = SyncMeme(task.get_modified(), rtm_task.get_modified(),
"RTM")
self.sync_engine.record_relationship(local_id=tid,
remote_id=rtm_task_id,
meme=meme)
self.datastore.push_task(task)
elif action == SyncEngine.UPDATE:
task = self.datastore.get_task(tid)
with self.datastore.get_backend_mutex():
meme = self.sync_engine.get_meme_from_remote_id(rtm_task_id)
newest = meme.which_is_newest(task.get_modified(),
rtm_task.get_modified())
if newest == "remote":
self._populate_task(task, rtm_task)
meme.set_remote_last_modified(rtm_task.get_modified())
meme.set_local_last_modified(task.get_modified())
else:
# we skip saving the state
return
elif action == SyncEngine.REMOVE:
try:
rtm_task.delete()
self.sync_engine.break_relationship(remote_id=rtm_task_id)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
self._exec_lost_syncability(tid, rtm_task)
self.save_state()
def test_which_is_newest(self):
"""
test the which_is_newest function
"""
meme = SyncMeme()
# tasks have not changed
local_modified = datetime.datetime.now()
remote_modified = datetime.datetime.now()
meme.set_local_last_modified(local_modified)
meme.set_remote_last_modified(remote_modified)
self.assertEqual(meme.which_is_newest(local_modified, remote_modified), None)
# we update the local
local_modified = datetime.datetime.now()
self.assertEqual(meme.which_is_newest(local_modified, remote_modified), "local")
# we update the remote
remote_modified = datetime.datetime.now()
self.assertEqual(meme.which_is_newest(local_modified, remote_modified), "remote")
def set_task(self, task):
'''
See GenericBackend for an explanation of this function.
'''
tid = task.get_id()
is_syncable = self._gtg_task_is_syncable_per_attached_tags(task)
action, evo_task_id = self.sync_engine.analyze_local_id(
tid,
self.datastore.has_task,
self._evo_has_task,
is_syncable)
Log.debug('GTG->Evo set task (%s, %s)' % (action, is_syncable))
if action is None:
return
if action == SyncEngine.ADD:
evo_task = evolution.ecal.ECalComponent(
ical=evolution.ecal.CAL_COMPONENT_TODO)
with self.datastore.get_backend_mutex():
self._evolution_tasks.add_object(evo_task)
self._populate_evo_task(task, evo_task)
meme = SyncMeme(task.get_modified(),
self._evo_get_modified(evo_task),
"GTG")
self.sync_engine.record_relationship(
local_id=tid, remote_id=evo_task.get_uid(),
meme=meme)
elif action == SyncEngine.UPDATE:
with self.datastore.get_backend_mutex():
evo_task = self._evo_get_task(evo_task_id)
meme = self.sync_engine.get_meme_from_local_id(task.get_id())
newest = meme.which_is_newest(task.get_modified(),
self._evo_get_modified(evo_task))
if newest == "local":
self._populate_evo_task(task, evo_task)
meme.set_remote_last_modified(
self._evo_get_modified(evo_task))
meme.set_local_last_modified(task.get_modified())
else:
# we skip saving the state
return
elif action == SyncEngine.REMOVE:
self.datastore.request_task_deletion(tid)
try:
self.sync_engine.break_relationship(local_id=tid)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
evo_task = self._evo_get_task(evo_task_id)
self._exec_lost_syncability(tid, evo_task)
self.save_state()
def set_task(self, task):
'''
See GenericBackend for an explanation of this function.
'''
tid = task.get_id()
is_syncable = self._gtg_task_is_syncable_per_attached_tags(task)
action, evo_task_id = self.sync_engine.analyze_local_id(
tid,
self.datastore.has_task,
self._evo_has_task,
is_syncable)
Log.debug('GTG->Evo set task (%s, %s)' % (action, is_syncable))
if action is None:
return
if action == SyncEngine.ADD:
evo_task = evolution.ecal.ECalComponent(
ical=evolution.ecal.CAL_COMPONENT_TODO)
with self.datastore.get_backend_mutex():
self._evolution_tasks.add_object(evo_task)
self._populate_evo_task(task, evo_task)
meme = SyncMeme(task.get_modified(),
self._evo_get_modified(evo_task),
"GTG")
self.sync_engine.record_relationship(
local_id=tid, remote_id=evo_task.get_uid(),
meme=meme)
elif action == SyncEngine.UPDATE:
with self.datastore.get_backend_mutex():
evo_task = self._evo_get_task(evo_task_id)
meme = self.sync_engine.get_meme_from_local_id(task.get_id())
newest = meme.which_is_newest(task.get_modified(),
self._evo_get_modified(evo_task))
if newest == "local":
self._populate_evo_task(task, evo_task)
meme.set_remote_last_modified(
self._evo_get_modified(evo_task))
meme.set_local_last_modified(task.get_modified())
else:
# we skip saving the state
return
elif action == SyncEngine.REMOVE:
self.datastore.request_task_deletion(tid)
try:
self.sync_engine.break_relationship(local_id=tid)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
evo_task = self._evo_get_task(evo_task_id)
self._exec_lost_syncability(tid, evo_task)
self.save_state()
def test_which_is_newest(self):
""" test the which_is_newest function """
meme = SyncMeme()
# tasks have not changed
local_modified = datetime.datetime.now()
remote_modified = datetime.datetime.now()
meme.set_local_last_modified(local_modified)
meme.set_remote_last_modified(remote_modified)
self.assertEqual(
meme.which_is_newest(local_modified, remote_modified),
None)
# we update the local
local_modified = datetime.datetime.now()
self.assertEqual(
meme.which_is_newest(local_modified, remote_modified),
'local')
# we update the remote
remote_modified = datetime.datetime.now()
self.assertEqual(
meme.which_is_newest(local_modified, remote_modified),
'remote')
def _process_evo_task(self, evo_task_id):
'''
Takes an evolution task id and carries out the necessary operations to
refresh the sync state
'''
self.cancellation_point()
evo_task = self._evo_get_task(evo_task_id)
is_syncable = self._evo_task_is_syncable(evo_task)
action, tid = self.sync_engine.analyze_remote_id(
evo_task_id,
self.datastore.has_task,
self._evo_has_task,
is_syncable)
Log.debug('GTG<-Evo set task (%s, %s)' % (action, is_syncable))
if action == SyncEngine.ADD:
with self.datastore.get_backend_mutex():
tid = str(uuid.uuid4())
task = self.datastore.task_factory(tid)
self._populate_task(task, evo_task)
meme = SyncMeme(task.get_modified(),
self._evo_get_modified(evo_task),
"GTG")
self.sync_engine.record_relationship(local_id=tid,
remote_id=evo_task_id,
meme=meme)
self.datastore.push_task(task)
elif action == SyncEngine.UPDATE:
with self.datastore.get_backend_mutex():
task = self.datastore.get_task(tid)
meme = self.sync_engine.get_meme_from_remote_id(evo_task_id)
newest = meme.which_is_newest(task.get_modified(),
self._evo_get_modified(evo_task))
if newest == "remote":
self._populate_task(task, evo_task)
meme.set_remote_last_modified(
self._evo_get_modified(evo_task))
meme.set_local_last_modified(task.get_modified())
elif action == SyncEngine.REMOVE:
return
try:
evo_task = self._evo_get_task(evo_task_id)
self._delete_evolution_task(evo_task)
self.sync_engine.break_relationship(remote_id=evo_task)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
self._exec_lost_syncability(tid, evo_task)
self.save_state()
def _process_evo_task(self, evo_task_id):
'''
Takes an evolution task id and carries out the necessary operations to
refresh the sync state
'''
self.cancellation_point()
evo_task = self._evo_get_task(evo_task_id)
is_syncable = self._evo_task_is_syncable(evo_task)
action, tid = self.sync_engine.analyze_remote_id(
evo_task_id,
self.datastore.has_task,
self._evo_has_task,
is_syncable)
Log.debug('GTG<-Evo set task (%s, %s)' % (action, is_syncable))
if action == SyncEngine.ADD:
with self.datastore.get_backend_mutex():
tid = str(uuid.uuid4())
task = self.datastore.task_factory(tid)
self._populate_task(task, evo_task)
meme = SyncMeme(task.get_modified(),
self._evo_get_modified(evo_task),
"GTG")
self.sync_engine.record_relationship(local_id=tid,
remote_id=evo_task_id,
meme=meme)
self.datastore.push_task(task)
elif action == SyncEngine.UPDATE:
with self.datastore.get_backend_mutex():
task = self.datastore.get_task(tid)
meme = self.sync_engine.get_meme_from_remote_id(evo_task_id)
newest = meme.which_is_newest(task.get_modified(),
self._evo_get_modified(evo_task))
if newest == "remote":
self._populate_task(task, evo_task)
meme.set_remote_last_modified(
self._evo_get_modified(evo_task))
meme.set_local_last_modified(task.get_modified())
elif action == SyncEngine.REMOVE:
return
try:
evo_task = self._evo_get_task(evo_task_id)
self._delete_evolution_task(evo_task)
self.sync_engine.break_relationship(remote_id=evo_task)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
self._exec_lost_syncability(tid, evo_task)
self.save_state()
def _process_rtm_task(self, rtm_task_id):
'''
Takes a rtm task id and carries out the necessary operations to
refresh the sync state
'''
self.cancellation_point()
if not self.rtm_proxy.is_authenticated():
return
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
is_syncable = self._rtm_task_is_syncable_per_attached_tags(rtm_task)
action, tid = self.sync_engine.analyze_remote_id(
rtm_task_id,
self.datastore.has_task,
self.rtm_proxy.has_rtm_task,
is_syncable)
Log.debug("GTG<-RTM set task (%s, %s)" % (action, is_syncable))
if action is None:
return
if action == SyncEngine.ADD:
if rtm_task.get_status() != Task.STA_ACTIVE:
# OPTIMIZATION:
# we don't sync tasks that have already been closed before we
# even saw them
return
tid = str(uuid.uuid4())
task = self.datastore.task_factory(tid)
self._populate_task(task, rtm_task)
meme = SyncMeme(task.get_modified(),
rtm_task.get_modified(),
"RTM")
self.sync_engine.record_relationship(
local_id=tid,
remote_id=rtm_task_id,
meme=meme)
self.datastore.push_task(task)
elif action == SyncEngine.UPDATE:
task = self.datastore.get_task(tid)
with self.datastore.get_backend_mutex():
meme = self.sync_engine.get_meme_from_remote_id(rtm_task_id)
newest = meme.which_is_newest(task.get_modified(),
rtm_task.get_modified())
if newest == "remote":
self._populate_task(task, rtm_task)
meme.set_remote_last_modified(rtm_task.get_modified())
meme.set_local_last_modified(task.get_modified())
else:
# we skip saving the state
return
elif action == SyncEngine.REMOVE:
try:
rtm_task.delete()
self.sync_engine.break_relationship(remote_id=rtm_task_id)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
self._exec_lost_syncability(tid, rtm_task)
self.save_state()
def set_task(self, task):
"""
See GenericBackend for an explanation of this function.
"""
if not self.rtm_proxy.is_authenticated():
return
self.cancellation_point()
tid = task.get_id()
is_syncable = self._gtg_task_is_syncable_per_attached_tags(task)
action, rtm_task_id = self.sync_engine.analyze_local_id(
tid,
self.datastore.has_task,
self.rtm_proxy.has_rtm_task,
is_syncable)
Log.debug("GTG->RTM set task (%s, %s)" % (action, is_syncable))
if action is None:
return
if action == SyncEngine.ADD:
if task.get_status() != Task.STA_ACTIVE:
# OPTIMIZATION:
# we don't sync tasks that have already been closed before we
# even synced them once
return
try:
rtm_task = self.rtm_proxy.create_new_rtm_task(task.get_title())
self._populate_rtm_task(task, rtm_task)
except:
rtm_task.delete()
raise
meme = SyncMeme(task.get_modified(),
rtm_task.get_modified(),
"GTG")
self.sync_engine.record_relationship(
local_id=tid, remote_id=rtm_task.get_id(), meme=meme)
elif action == SyncEngine.UPDATE:
try:
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
except KeyError:
# in this case, we don't have yet the task in our local cache
# of what's on the rtm website
self.rtm_proxy.refresh_rtm_tasks_dict()
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
with self.datastore.get_backend_mutex():
meme = self.sync_engine.get_meme_from_local_id(task.get_id())
newest = meme.which_is_newest(task.get_modified(),
rtm_task.get_modified())
if newest == "local":
transaction_ids = []
try:
self._populate_rtm_task(
task, rtm_task, transaction_ids)
except:
self.rtm_proxy.unroll_changes(transaction_ids)
raise
meme.set_remote_last_modified(rtm_task.get_modified())
meme.set_local_last_modified(task.get_modified())
else:
# we skip saving the state
return
elif action == SyncEngine.REMOVE:
self.datastore.request_task_deletion(tid)
try:
self.sync_engine.break_relationship(local_id=tid)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
try:
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
except KeyError:
# in this case, we don't have yet the task in our local cache
# of what's on the rtm website
self.rtm_proxy.refresh_rtm_tasks_dict()
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
self._exec_lost_syncability(tid, rtm_task)
self.save_state()
def set_task(self, task):
"""
See GenericBackend for an explanation of this function.
"""
if not self.rtm_proxy.is_authenticated():
return
self.cancellation_point()
tid = task.get_id()
is_syncable = self._gtg_task_is_syncable_per_attached_tags(task)
action, rtm_task_id = self.sync_engine.analyze_local_id(
tid, self.datastore.has_task, self.rtm_proxy.has_rtm_task,
is_syncable)
Log.debug("GTG->RTM set task (%s, %s)" % (action, is_syncable))
if action is None:
return
if action == SyncEngine.ADD:
if task.get_status() != Task.STA_ACTIVE:
# OPTIMIZATION:
# we don't sync tasks that have already been closed before we
# even synced them once
return
try:
rtm_task = self.rtm_proxy.create_new_rtm_task(task.get_title())
self._populate_rtm_task(task, rtm_task)
except:
rtm_task.delete()
raise
meme = SyncMeme(task.get_modified(), rtm_task.get_modified(),
"GTG")
self.sync_engine.record_relationship(local_id=tid,
remote_id=rtm_task.get_id(),
meme=meme)
elif action == SyncEngine.UPDATE:
try:
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
except KeyError:
# in this case, we don't have yet the task in our local cache
# of what's on the rtm website
self.rtm_proxy.refresh_rtm_tasks_dict()
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
with self.datastore.get_backend_mutex():
meme = self.sync_engine.get_meme_from_local_id(task.get_id())
newest = meme.which_is_newest(task.get_modified(),
rtm_task.get_modified())
if newest == "local":
transaction_ids = []
try:
self._populate_rtm_task(task, rtm_task,
transaction_ids)
except:
self.rtm_proxy.unroll_changes(transaction_ids)
raise
meme.set_remote_last_modified(rtm_task.get_modified())
meme.set_local_last_modified(task.get_modified())
else:
# we skip saving the state
return
elif action == SyncEngine.REMOVE:
self.datastore.request_task_deletion(tid)
try:
self.sync_engine.break_relationship(local_id=tid)
except KeyError:
pass
elif action == SyncEngine.LOST_SYNCABILITY:
try:
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
except KeyError:
# in this case, we don't have yet the task in our local cache
# of what's on the rtm website
self.rtm_proxy.refresh_rtm_tasks_dict()
rtm_task = self.rtm_proxy.get_rtm_tasks_dict()[rtm_task_id]
self._exec_lost_syncability(tid, rtm_task)
self.save_state()
