Beispiel #1
0
    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)
Beispiel #2
0
 def patch(self, p):
     if p.isNoop():
         return
     patchQuads(self._graph,
                deleteQuads=p.delQuads,
                addQuads=p.addQuads,
                perfect=False) # true?
     for ob in self._observers:
         ob(patchAsJson(p))
Beispiel #3
0
    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
Beispiel #4
0
    def onPatch(self, p, fullGraph):
        if fullGraph:
            self.graph = ConjunctiveGraph()
        patchQuads(self.graph,
                   deleteQuads=p.delQuads,
                   addQuads=p.addQuads,
                   perfect=True)

        ignorePredicates = [
            ROOM['signalStrength'],
            # perhaps anything with a number-datatype for its
            # object should be filtered out, and you have to make
            # an upstream quantization (e.g. 'temp high'/'temp
            # low') if you want to do reasoning on the difference
            URIRef("http://bigasterisk.com/map#lastSeenAgoSec"),
            URIRef("http://bigasterisk.com/map#lastSeenAgo"),
            ROOM['usingPower'],
            ROOM['idleTimeMinutes'],
            ROOM['idleTimeMs'],
            ROOM['graphLoadMs'],
            ROOM['localTimeToSecond'],
            ROOM['history'],
            ROOM['temperatureF'],
            ROOM['connectedAgo'],
            RDFS['comment'],
        ]
        ignoreContexts = [
            URIRef('http://bigasterisk.com/sse_collector/'),
            ]
        for affected in p.addQuads + p.delQuads:
            if (affected[1] not in ignorePredicates and
                affected[3] not in ignoreContexts):
                log.debug("  remote graph changed")
                self.onChange()
                break
        else:
            log.debug("  remote graph has no changes to trigger rules")