if not ctx.startswith(self.topUri):

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

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

class Db(object):

    """

    the master graph, all the connected clients, all the files we're watching

    """

    def __init__(self, topDirsToWatch):

        self.clients = []

        self.graph = ConjunctiveGraph()

        self.watchedFiles = WatchedFiles(topDirsToWatch,

                                         self.patch, self.getSubgraph)

        self.summarizeToLog()

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

        """

        apply this patch to the master graph then notify everyone about it

        dueToFileChange if this is a patch describing an edit we read

        *from* the file (such that we shouldn't write it back to the file)

        if p has a senderUpdateUri attribute, we won't send this patch

        back to the sender with that updateUri

        """

        ctx = p.getContext()

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

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

        if hasattr(self, 'watchedFiles'): # not available during startup

            self.watchedFiles.aboutToPatch(ctx)

        patchQuads(self.graph, p.delQuads, p.addQuads, perfect=True)

        senderUpdateUri = getattr(p, 'senderUpdateUri', None)

        for c in self.clients:

            if c.updateUri == senderUpdateUri:

                # this client has self-applied the patch already

                continue

            d = c.sendPatch(p)

            d.addErrback(self.clientErrored, c)

        if not dueToFileChange:

            self.watchedFiles.dirtyFiles([ctx])

        sendToLiveClients(asJson=p.jsonRepr)

    def clientErrored(self, err, c):

        err.trap(twisted.internet.error.ConnectError)

        log.info("connection error- dropping client %r" % c)

        self.clients.remove(c)

        self.sendClientsToAllLivePages()

    def summarizeToLog(self):

        log.info("contexts in graph (%s total stmts):" % len(self.graph))

        for c in self.graph.contexts():

            log.info("  %s: %s statements" %

                     (c.identifier, len(self.getSubgraph(c.identifier))))

    def getSubgraph(self, uri):

        """

        this is meant to return a live view of the given subgraph, but

        if i'm still working around an rdflib bug, it might return a

        copy

        and it's returning triples, but I think quads would be better

        """

        # this is returning an empty Graph :(

        #return self.graph.get_context(uri)

        g = Graph()

        for s in self.graph.triples(ALLSTMTS, uri):

            g.add(s)

        return g

    def addClient(self, updateUri, label):

        [self.clients.remove(c)

         for c in self.clients if c.updateUri == updateUri]

        log.info("new client %s at %s" % (label, updateUri))

        self.clients.append(Client(updateUri, label, self))

        self.sendClientsToAllLivePages()

    def sendClientsToAllLivePages(self):

        sendToLiveClients({"clients":[

            dict(updateUri=c.updateUri, label=c.label)

            for c in self.clients]})

class GraphResource(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        accept = self.request.headers.get('accept', '')

        format = 'n3'

        if accept == 'text/plain':

            format = 'nt'

        self.write(self.settings.db.graph.serialize(format=format))

class Patches(PrettyErrorHandler, cyclone.web.RequestHandler):

    def __init__(self, *args, **kw):

        cyclone.web.RequestHandler.__init__(self, *args, **kw)

        p = makePatchEndpointPutMethod(self.settings.db.patch)

        self.put = lambda: p(self)

    def get(self):

        pass

class GraphClients(PrettyErrorHandler, cyclone.web.RequestHandler):

    def get(self):

        pass

    def post(self):

        upd = self.get_argument("clientUpdate")

        try:

            self.settings.db.addClient(upd, self.get_argument("label"))

        except:

            import traceback

            traceback.print_exc()

            raise

liveClients = set()

def sendToLiveClients(d=None, asJson=None):

    j = asJson or json.dumps(d)

    for c in liveClients:

        c.sendMessage(j)

class Live(cyclone.websocket.WebSocketHandler):

    def connectionMade(self, *args, **kwargs):

        log.info("websocket opened")

        liveClients.add(self)

        self.settings.db.sendClientsToAllLivePages()

    def connectionLost(self, reason):

        log.info("websocket closed")

        liveClients.remove(self)

    def messageReceived(self, message):

        log.info("got message %s" % message)

        self.sendMessage(message)

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)

if __name__ == "__main__":

    logging.basicConfig()

    log = logging.getLogger()

    parser = optparse.OptionParser()

    parser.add_option("-v", "--verbose", action="store_true",

                      help="logging.DEBUG")

    (options, args) = parser.parse_args()

    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    db = Db(topDirsToWatch=[os.environ['LIGHT9_SHOW']])

    from twisted.python import log as twlog

    twlog.startLogging(sys.stdout)

    port = 8051

    reactor.listenTCP(port, cyclone.web.Application(handlers=[

        (r'/live', Live),

        (r'/graph', GraphResource),

        (r'/patches', Patches),

        (r'/graphClients', GraphClients),

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

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

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

        ], debug=True, db=db))

    log.info("serving on %s" % port)

    prof.run(reactor.run, profile=False)