# move to syncedgraph patchMapping

                                 random.randrange(999999999))

        # move this to syncedgraph readMapping

        # files from cwd become uris starting with this. *should* be

        # building uris from the show uri in $LIGHT9_SHOW/URI

        # instead. Who wants to keep their data in the same dir tree

        # as the source code?!

        self.topUri = URIRef("http://light9.bigasterisk.com/")

        self.notifier = INotify()

        self.notifier.startReading()

        self.graphFiles = {} # context uri : GraphFile

        self.findAndLoadFiles()

    def findAndLoadFiles(self):

        self.initialLoad = True

        try:

            dirs = [

                "show/dance2012/sessions",

                "show/dance2012/subs",

                "show/dance2012/subterms",

                ]

            for topdir in dirs:

                for dirpath, dirnames, filenames in os.walk(topdir):

                    for base in filenames:

                        self.watchFile(os.path.join(dirpath, base))

                # todo: also notice new files in this dir

            self.watchFile("show/dance2012/config.n3")

            self.watchFile("show/dance2012/patch.n3")

        finally:

            self.initialLoad = False

        self.summarizeToLog()

    def uriFromFile(self, filename):

        if filename.endswith('.n3'):

            # some legacy files don't end with n3. when we write them

            # back this might not go so well

            filename = filename[:-len('.n3')]

        return URIRef(self.topUri + filename)

    def fileForUri(self, ctx):

        if not ctx.startswith(self.topUri):

            raise ValueError("don't know what filename to use for %s" % ctx)

        return ctx[len(self.topUri):] + ".n3"

    def watchFile(self, inFile):

        ctx = self.uriFromFile(inFile)

        gf = GraphFile(self.notifier, inFile, ctx, self.patch, self.getSubgraph)

        self.graphFiles[ctx] = gf

        gf.reread()

    def patch(self, p, dueToFileChange=False):

        ctx = p.getContext()

        log.info("patching graph %s -%d +%d" % (

            ctx, len(p.delQuads), len(p.addQuads)))

        #if not self.initialLoad:

        #    self.summarizeToLog()

        if not dueToFileChange:

            self.dirtyFiles([ctx])

    def dirtyFiles(self, ctxs):

        """mark dirty the files that we watch in these contexts.

        the ctx might not be a file that we already read; it might be

        for a new file we have to create, or it might be for a

        transient context that we're not going to save

        if it's a ctx with no file, error

        """

        for ctx in ctxs:

            g = self.getSubgraph(ctx)

            if ctx not in self.graphFiles:

                outFile = self.fileForUri(ctx)

                self.graphFiles[ctx] = GraphFile(self.notifier, outFile, ctx,

                                                 self.patch, self.getSubgraph)

            self.graphFiles[ctx].dirty(g)

class NoExts(cyclone.web.StaticFileHandler):

    # .xhtml pages can be get() without .xhtml on them

    def get(self, path, *args, **kw):

        if path and '.' not in path:

            path = path + ".xhtml"

        cyclone.web.StaticFileHandler.get(self, path, *args, **kw)

    from twisted.python import log as twlog

    twlog.startLogging(sys.stdout)

        (r'/(.*)', NoExts,

         {"path" : "light9/rdfdb/web",

          "default_filename" : "index.xhtml"}),

        ], debug=True, db=db))

from light9 import showconfig

    return URIRef("%s/sessions/%s/%s" % (showconfig.showUri(), appName,

                                         quote(opts.session, safe='')))

import logging, traceback, os, time

from twisted.internet import reactor

log = logging.getLogger('graphfile')

iolog = logging.getLogger('io')

        if not os.path.exists(path):

            # can't start notify until file exists

            try:

                os.makedirs(os.path.dirname(path))

            except OSError:

                pass

            f = open(path, "w")

            f.close()

            iolog.info("created %s", path)

        self.flushDelay = 2 # seconds until we have to call flush() when dirty

        self.writeCall = None # or DelayedCall

        self.lastWriteTimestamp = 0 # mtime from the last time _we_ wrote

        if filepath.getModificationTime() == self.lastWriteTimestamp:

            log.debug("file %s changed, but we did this write", filepath)

            return

        log.info("file %s changed", filepath)

        # we're probably out of sync with the master now, since

        # SyncedGraph.patch optimistically applied the patch to our

        # local graph already. What happens to this patch? What

        # happens to further pending patches? Some of the further

        # patches, especially, may be commutable with the bad one and

        # might still make sense to apply to the master graph.

        # if someday we are folding pending patches together, this

        # would be the time to UNDO that and attempt the original

        # separate patches again

        # this should screen for 409 conflict responses and raise a

        # special exception for that, so SyncedGraph.sendFailed can

        # screen for only that type

        # this code is going away; we're going to raise an exception that contains all the pending patches

        log.error("_sendPatchErr")

    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.

        """

        return cyclone.httpclient.fetch(

            url="http://localhost:8051/graph",

            method="GET",

            headers={'Accept':'x-trig'},

            ).addCallback(self._resyncGraph)

    def _resyncGraph(self, response):

        pass

        #diff against old entire graph

        #broadcast that change

        self._sender.sendPatch(p).addErrback(self.sendFailed)

    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

        """

        #i think we should receive back all the pending patches,

        #do a resysnc here,

        #then requeue all the pending patches (minus the failing one?) after that's done.

    def patchMapping(self, context, subject, predicate, keyPred, valuePred, newKey, newValue):

        """

        proposed api for updating things like ?session :subSetting [

        :sub ?s; :level ?v ]. Keyboardcomposer has an implementation

        already. There should be a complementary readMapping that gets

        you a value since that's tricky too

        """