def __init__(self, rdfdbRoot, label):
"""
label is a string that the server will display in association
with your connection
"""
self.rdfdbRoot = rdfdbRoot
self.initiallySynced = defer.Deferred()
self._graph = ConjunctiveGraph()
self._receiver = PatchReceiver(self.rdfdbRoot, label, self._onPatch)
self._sender = PatchSender(self.rdfdbRoot + 'patches',
self._receiver.updateResource)
AutoDepGraphApi.__init__(self)
class SyncedGraph(CurrentStateGraphApi, AutoDepGraphApi, GraphEditApi):
"""
graph for clients to use. Changes are synced with the master graph
in the rdfdb process.
This api is like rdflib.Graph but it can also call you back when
there are graph changes to the parts you previously read.
You may want to attach to self.initiallySynced deferred so you
don't attempt patches before we've heard the initial contents of
the graph. It would be ok to accumulate some patches of new
material, but usually you won't correctly remove the existing
statements unless we have the correct graph.
If we get out of sync, we abandon our local graph (even any
pending local changes) and get the data again from the
server.
"""
def __init__(self, rdfdbRoot, label):
"""
label is a string that the server will display in association
with your connection
"""
self.rdfdbRoot = rdfdbRoot
self.initiallySynced = defer.Deferred()
self._graph = ConjunctiveGraph()
self._receiver = PatchReceiver(self.rdfdbRoot, label, self._onPatch)
self._sender = PatchSender(self.rdfdbRoot + 'patches',
self._receiver.updateResource)
AutoDepGraphApi.__init__(self)
# this needs more state to track if we're doing a resync (and
# everything has to error or wait) or if we're live
def resync(self):
"""
get the whole graph again from the server (e.g. we had a
conflict while applying a patch and want to return to the
truth).
To avoid too much churn, we remember our old graph and diff it
against the replacement. This way, our callers only see the
corrections.
Edits you make during a resync will surely be lost, so I
should just fail them. There should be a notification back to
UIs who want to show that we're doing a resync.
"""
log.info('resync')
self._sender.cancelAll()
# this should be locked so only one resync goes on at once
return cyclone.httpclient.fetch(
url=self.rdfdbRoot + "graph",
method="GET",
headers={'Accept':['x-trig']},
).addCallback(self._resyncGraph)
def _resyncGraph(self, response):
log.warn("new graph in")
#diff against old entire graph
#broadcast that change
def patch(self, p):
"""send this patch to the server and apply it to our local
graph and run handlers"""
if p.isNoop():
log.info("skipping no-op patch")
return
# these could fail if we're out of sync. One approach:
# Rerequest the full state from the server, try the patch
# again after that, then give up.
debugKey = '[id=%s]' % (id(p) % 1000)
log.debug("\napply local patch %s %s", debugKey, p)
try:
patchQuads(self._graph,
deleteQuads=p.delQuads,
addQuads=p.addQuads,
perfect=True)
except ValueError as e:
log.error(e)
self.sendFailed(None)
return
log.debug('runDepsOnNewPatch')
self.runDepsOnNewPatch(p)
log.debug('sendPatch')
self._sender.sendPatch(p).addErrback(self.sendFailed)
log.debug('patch is done %s', debugKey)
def sendFailed(self, result):
"""
we asked for a patch to be queued and sent to the master, and
that ultimately failed because of a conflict
"""
log.warn("sendFailed")
self.resync()
#i think we should receive back all the pending patches,
#do a resync here,
#then requeue all the pending patches (minus the failing one?) after that's done.
def _onPatch(self, p):
"""
central server has sent us a patch
"""
log.debug('_onPatch server has sent us %s', p)
patchQuads(self._graph, p.delQuads, p.addQuads, perfect=True)
log.debug("graph now has %s statements" % len(self._graph))
try:
self.runDepsOnNewPatch(p)
except Exception:
# don't reflect this error back to the server; we did
# receive its patch correctly. However, we're in a bad
# state since some dependencies may not have rerun
traceback.print_exc()
log.warn("some graph dependencies may not have completely run")
if self.initiallySynced:
self.initiallySynced.callback(None)
self.initiallySynced = None
