Ejemplo n.º 1
0
 def __init__(self, graph, masterGraph, uri):
     self.graph, self.uri = graph, uri
     self.masterGraph = masterGraph
     self.masterGraph.patch(Patch(addQuads=self.staticStmts()))
     self.pi = pigpio.pi()
     self._devs = devices.makeDevices(graph, self.uri, self.pi)
     log.debug('found %s devices', len(self._devs))
     self._statementsFromInputs = {} # input device uri: latest statements
     self._lastPollTime = {} # input device uri: time()
     self._influx = InfluxExporter(self.graph)
     for d in self._devs:
         self.syncMasterGraphToHostStatements(d)
Ejemplo n.º 2
0
    def __init__(self, dev, configGraph, masterGraph, uri):
        """
        each connected thing has some pins.
        """
        self.uri = uri
        self.configGraph = configGraph
        self.masterGraph = masterGraph
        self.dev = dev

        self.masterGraph.setToGraph(self.staticStmts())

        # The order of this list needs to be consistent between the
        # deployToArduino call and the poll call.
        self._devs = devices.makeDevices(configGraph, self.uri)
        self._devCommandNum = dict((dev.uri, ACTION_BASE + devIndex)
                                   for devIndex, dev in enumerate(self._devs))
        self._polledDevs = [d for d in self._devs if d.generatePollCode()]

        self._statementsFromInputs = {} # input device uri: latest statements
        self._lastPollTime = {} # input device uri: time()
        self._influx = InfluxExporter(self.configGraph)
        self.open()
        for d in self._devs:
            self.syncMasterGraphToHostStatements(d)
Ejemplo n.º 3
0
    def __init__(self, dev, configGraph, masterGraph, uri):
        """
        each connected thing has some pins.
        """
        self.uri = uri
        self.configGraph = configGraph
        self.masterGraph = masterGraph
        self.dev = dev

        self.masterGraph.patch(Patch(addQuads=self.staticStmts()))

        # The order of this list needs to be consistent between the
        # deployToArduino call and the poll call.
        self._devs = devices.makeDevices(configGraph, self.uri)
        self._devCommandNum = dict((dev.uri, ACTION_BASE + devIndex)
                                   for devIndex, dev in enumerate(self._devs))
        self._polledDevs = [d for d in self._devs if d.generatePollCode()]
        
        self._statementsFromInputs = {} # input device uri: latest statements
        self._lastPollTime = {} # input device uri: time()
        self._influx = InfluxExporter(self.configGraph)
        self.open()
        for d in self._devs:
            self.syncMasterGraphToHostStatements(d)
Ejemplo n.º 4
0
class Board(object):
    """an arduino connected to this computer"""
    baudrate = 115200
    def __init__(self, dev, configGraph, masterGraph, uri):
        """
        each connected thing has some pins.
        """
        self.uri = uri
        self.configGraph = configGraph
        self.masterGraph = masterGraph
        self.dev = dev

        self.masterGraph.patch(Patch(addQuads=self.staticStmts()))

        # The order of this list needs to be consistent between the
        # deployToArduino call and the poll call.
        self._devs = devices.makeDevices(configGraph, self.uri)
        self._devCommandNum = dict((dev.uri, ACTION_BASE + devIndex)
                                   for devIndex, dev in enumerate(self._devs))
        self._polledDevs = [d for d in self._devs if d.generatePollCode()]
        
        self._statementsFromInputs = {} # input device uri: latest statements
        self._lastPollTime = {} # input device uri: time()
        self._influx = InfluxExporter(self.configGraph)
        self.open()
        for d in self._devs:
            self.syncMasterGraphToHostStatements(d)

    def description(self):
        """for web page"""
        return {
            'uri': self.uri,
            'dev': self.dev,
            'baudrate': self.baudrate,
            'devices': [d.description() for d in self._devs],
            }
        
    def open(self):
        self.ser = LoggingSerial(port=self.dev, baudrate=self.baudrate,
                                 timeout=2)
        
    def startPolling(self, period=.5):
        task.LoopingCall(self._poll).start(period)
            
    def _poll(self):
        """
        even boards with no inputs need some polling to see if they're
        still ok
        """
        try:
            self._pollWork()
        except serial.SerialException:
            reactor.crash()
            raise
        except Exception as e:
            import traceback; traceback.print_exc()
            log.warn("poll: %r" % e)
            
    def _pollWork(self):
        t1 = time.time()
        self.ser.write("\x60\x00") # "poll everything"
        for i in self._polledDevs:
            try:
                now = time.time()
                new = i.readFromPoll(self.ser.read)
                if isinstance(new, dict): # new style
                    oneshot = new['oneshot']
                    new = new['latest']
                else:
                    oneshot = None
                prev = self._statementsFromInputs.get(i.uri, [])
                if new or prev:
                    self._statementsFromInputs[i.uri] = new
                    # it's important that quads from different devices
                    # don't clash, since that can lead to inconsistent
                    # patches (e.g.
                    #   dev1 changes value from 1 to 2;
                    #   dev2 changes value from 2 to 3;
                    #   dev1 changes from 2 to 4 but this patch will
                    #     fail since the '2' statement is gone)
                    self.masterGraph.patch(Patch.fromDiff(inContext(prev, i.uri),
                                                          inContext(new, i.uri)))
                if oneshot:
                    self._sendOneshot(oneshot)
                self._lastPollTime[i.uri] = now
            except:
                log.warn('while polling %r:', i.uri)
                raise
        #plus statements about succeeding or erroring on the last poll
        byte = self.ser.read(1)
        if byte != 'x':
            raise ValueError("after poll, got %x instead of 'x'" % byte)
        elapsed = time.time() - t1
        if elapsed > 1.0:
            log.warn('poll took %.1f seconds' % elapsed)

        stmts = set()
        for v in self._statementsFromInputs.values():
            stmts.update(v)
        self._influx.exportToInflux(stmts)

    def _sendOneshot(self, oneshot):
        body = (' '.join('%s %s %s .' % (s.n3(), p.n3(), o.n3())
                         for s,p,o in oneshot)).encode('utf8')
        bang6 = 'fcb8:4119:fb46:96f8:8b07:1260:0f50:fcfa'
        fetch(method='POST',
              url='http://[%s]:9071/oneShot' % bang6,
              headers={'Content-Type': ['text/n3']}, postdata=body,
              timeout=5)

    def outputStatements(self, stmts):
        unused = set(stmts)
        for dev in self._devs:
            stmtsForDev = []
            for pat in dev.outputPatterns():
                if [term is None for term in pat] != [False, False, True]:
                    raise NotImplementedError
                for stmt in stmts:
                    if stmt[:2] == pat[:2]:
                        stmtsForDev.append(stmt)
                        unused.discard(stmt)
            if stmtsForDev:
                log.info("output goes to action handler for %s" % dev.uri)
                self.ser.write("\x60" + chr(self._devCommandNum[dev.uri]))
                dev.sendOutput(stmtsForDev, self.ser.write, self.ser.read)
                if self.ser.read(1) != 'k':
                    raise ValueError(
                        "%s sendOutput/generateActionCode didn't use "
                        "matching output bytes" % dev.__class__)
                # Dev *could* change hostStatements at any time, and
                # we're not currently tracking that, but the usual is
                # to change them in response to sendOutput so this
                # should be good enough. The right answer is to give
                # each dev the masterGraph for it to write to.
                self.syncMasterGraphToHostStatements(dev)
                log.info("output and masterGraph sync complete")
        if unused:
            log.info("Board %s doesn't care about these statements:", self.uri)
            for s in unused:
                log.warn("%r", s)

    def syncMasterGraphToHostStatements(self, dev):
        hostStmtCtx = URIRef(dev.uri + '/host')
        newQuads = inContext(dev.hostStatements(), hostStmtCtx)
        p = self.masterGraph.patchSubgraph(hostStmtCtx, newQuads)
        log.debug("patch master with these host stmts %s", p)

    def staticStmts(self):
        return [(HOST[hostname], ROOM['connectedTo'], self.uri, CTX)]

    def generateArduinoCode(self):
        code = write_arduino_code.writeCode(self.baudrate, self._devs,
                                            self._devCommandNum)
        code = write_arduino_code.indent(code)
        cksum = hashlib.sha1(code).hexdigest()
        code = code.replace('CODE_CHECKSUM', cksum)
        return code, cksum

    def _readBoardChecksum(self, length):
        # this is likely right after reset, so it might take 2 seconds
        for tries in range(6):
            self.ser.write("\x60\x01")
            try:
                return self.ser.read(length)
            except ValueError:
                if tries == 5:
                    raise
            time.sleep(.5)
        raise ValueError

    def _boardIsCurrent(self, currentChecksum):
        try:
            boardCksum = self._readBoardChecksum(len(currentChecksum))
            if boardCksum == currentChecksum:
                log.info("board has current code (%s)" % currentChecksum)
                return True
            else:
                log.info("board responds with incorrect code version")
        except Exception as e:
            log.info("can't get code version from board: %r" % e)
        return False
        
    def deployToArduino(self):
        code, cksum = self.generateArduinoCode()

        if self._boardIsCurrent(cksum):
            return
        
        try:
            if hasattr(self, 'ser'):
                self.ser.close()
            workDir = tempfile.mkdtemp(prefix='arduinoNode_board_deploy')
            try:
                self._arduinoMake(workDir, code)
            finally:
                shutil.rmtree(workDir)
        finally:
            self.open()

    def _arduinoMake(self, workDir, code):
        with open(workDir + '/makefile', 'w') as makefile:
            makefile.write(write_arduino_code.writeMakefile(
                dev=self.dev,
                tag=self.configGraph.value(self.uri, ROOM['boardTag']),
                allLibs=sum((d.generateArduinoLibs() for d in self._devs), [])))

        with open(workDir + '/main.ino', 'w') as main:
            main.write(code)

        subprocess.check_call(['make', 'upload'], cwd=workDir)
        

    def currentGraph(self):
        g = Graph()
        

        for dev in self._devs:
            for stmt in dev.hostStatements():
                g.add(stmt)
        return g
Ejemplo n.º 5
0
    -v                    Verbose
    --overwrite_any_tag   Rewrite any unknown tag with a new random body
    -n                    Fake reader
    """)
    log.setLevel(logging.INFO)
    if arg['-v']:
        enableTwistedLog()
        log.setLevel(logging.DEBUG)
        log.info(f'cyclone {cyclone.__version__}')
        defer.setDebugging(True)

    masterGraph = PatchableGraph()
    reader = NfcDevice() if not arg['-n'] else FakeNfc()

    ie = InfluxExporter(Graph())
    ie.exportStats(
        STATS,
        [
            'root.cardReadPoll.count',
            'root.cardReadPoll.95percentile',
            'root.newCardReads',
        ],
        period_secs=10,
        retain_days=7,
    )

    loop = ReadLoop(reader,
                    masterGraph,
                    overwrite_any_tag=arg['--overwrite_any_tag'])
Ejemplo n.º 6
0
    -v                    Verbose
    --overwrite_any_tag   Rewrite any unknown tag with a new random body
    -n                    Fake reader
    """)
    log.setLevel(logging.INFO)
    if arg['-v']:
        enableTwistedLog()
        log.setLevel(logging.DEBUG)
        log.info(f'cyclone {cyclone.__version__}')
        defer.setDebugging(True)
        
    masterGraph = PatchableGraph()
    reader = NfcDevice() if not arg['-n'] else FakeNfc()

    ie=InfluxExporter(Graph())
    ie.exportStats(STATS, ['root.cardReadPoll.count',
                           'root.cardReadPoll.95percentile',
                           'root.newCardReads',
                       ],
                    period_secs=10,
                    retain_days=7,
    )

    loop = ReadLoop(reader, masterGraph, overwrite_any_tag=arg['--overwrite_any_tag'])

    port = 10012
    reactor.listenTCP(port, cyclone.web.Application([
        (r"/(|.+\.html)", cyclone.web.StaticFileHandler,
         {"path": ".", "default_filename": "index.html"}),
        (r"/graph", CycloneGraphHandler, {'masterGraph': masterGraph}),
Ejemplo n.º 7
0
class Board(object):
    """similar to arduinoNode.Board but without the communications stuff"""
    def __init__(self, graph, masterGraph, uri, hubHost):
        self.graph, self.uri = graph, uri
        self.hubHost = hubHost
        self.masterGraph = masterGraph
        self.masterGraph.setToGraph(self.staticStmts())
        self.pi = pigpio.pi()
        self._devs = devices.makeDevices(graph, self.uri, self.pi)
        log.debug('found %s devices', len(self._devs))
        self._statementsFromInputs = {} # input device uri: latest statements
        self._lastPollTime = {} # input device uri: time()
        self._influx = InfluxExporter(self.graph)
        for d in self._devs:
            self.syncMasterGraphToHostStatements(d)
            
    def startPolling(self):
        task.LoopingCall(self._poll).start(.05)

    @STATS.boardPoll.time() # not differentiating multiple boards here
    def _poll(self):
        try:
            self._pollMaybeError()
        except Exception:
            STATS.pollException += 1
            log.exception("During poll:")
            
    def _pollMaybeError(self):
        pollTime = {} # uri: sec
        for i in self._devs:
            now = time.time()
            if (hasattr(i, 'pollPeriod') and
                self._lastPollTime.get(i.uri, 0) + i.pollPeriod > now):
                continue
            #need something like:
            #  with i.pollTiming.time():
            new = i.poll()
            pollTime[i.uri] = time.time() - now
            if isinstance(new, dict): # new style
                oneshot = new['oneshot']
                new = new['latest']
            else:
                oneshot = None

            self._updateMasterWithNewPollStatements(i.uri, new)

            if oneshot:
                self._sendOneshot(oneshot)
            self._lastPollTime[i.uri] = now
        if log.isEnabledFor(logging.DEBUG):
            log.debug('poll times:')
            for u, s in sorted(pollTime.items()):
                log.debug("  %.4f ms %s", s * 1000, u)
            log.debug('total poll time: %f ms', sum(pollTime.values()) * 1000)
            
        pollResults = map(set, self._statementsFromInputs.values())
        if pollResults:
            self._influx.exportToInflux(set.union(*pollResults))

    def _updateMasterWithNewPollStatements(self, dev, new):
        prev = self._statementsFromInputs.get(dev, set())

        # it's important that quads from different devices
        # don't clash, since that can lead to inconsistent
        # patches (e.g.
        #   dev1 changes value from 1 to 2;
        #   dev2 changes value from 2 to 3;
        #   dev1 changes from 2 to 4 but this patch will
        #     fail since the '2' statement is gone)
        self.masterGraph.patch(Patch.fromDiff(inContext(prev, dev),
                                              inContext(new, dev)))
        self._statementsFromInputs[dev] = new

    @STATS.sendOneshot.time()
    def _sendOneshot(self, oneshot):
        body = (' '.join('%s %s %s .' % (s.n3(), p.n3(), o.n3())
                         for s,p,o in oneshot)).encode('utf8')
        url = 'http://%s:9071/oneShot' % self.hubHost
        d = fetch(method='POST',
                  url=url,
                  headers={'Content-Type': ['text/n3']},
                  postdata=body,
                  timeout=5)
        def err(e):
            log.info('oneshot post to %r failed:  %s',
                     url, e.getErrorMessage())
        d.addErrback(err)

    @STATS.outputStatements.time()
    def outputStatements(self, stmts):
        unused = set(stmts)
        for dev in self._devs:
            stmtsForDev = []
            for pat in dev.outputPatterns():
                if [term is None for term in pat] != [False, False, True]:
                    raise NotImplementedError
                for stmt in stmts:
                    if stmt[:2] == pat[:2]:
                        stmtsForDev.append(stmt)
                        unused.discard(stmt)
            if stmtsForDev:
                log.info("output goes to action handler for %s" % dev.uri)
                dev.sendOutput(stmtsForDev)

                # Dev *could* change hostStatements at any time, and
                # we're not currently tracking that, but the usual is
                # to change them in response to sendOutput so this
                # should be good enough. The right answer is to give
                # each dev the masterGraph for it to write to.
                self.syncMasterGraphToHostStatements(dev)
                log.info("output and masterGraph sync complete")
        if unused:
            log.info("Board %s doesn't care about these statements:", self.uri)
            for s in unused:
                log.warn("%r", s)

    def syncMasterGraphToHostStatements(self, dev):
        hostStmtCtx = URIRef(dev.uri + '/host')
        newQuads = inContext(dev.hostStatements(), hostStmtCtx)
        p = self.masterGraph.patchSubgraph(hostStmtCtx, newQuads)
        log.debug("patch master with these host stmts %s", p)

    def staticStmts(self):
        return [(HOST[hostname], ROOM['connectedTo'], self.uri, CTX)]

    def description(self):
        """for web page"""
        return {
            'uri': self.uri,
            'devices': [d.description() for d in self._devs],
            'graph': 'http://sticker:9059/graph', #todo
            }
Ejemplo n.º 8
0
class Board(object):
    """an arduino connected to this computer"""
    baudrate = 115200
    def __init__(self, dev, configGraph, masterGraph, uri):
        """
        each connected thing has some pins.
        """
        self.uri = uri
        self.configGraph = configGraph
        self.masterGraph = masterGraph
        self.dev = dev

        self.masterGraph.setToGraph(self.staticStmts())

        # The order of this list needs to be consistent between the
        # deployToArduino call and the poll call.
        self._devs = devices.makeDevices(configGraph, self.uri)
        self._devCommandNum = dict((dev.uri, ACTION_BASE + devIndex)
                                   for devIndex, dev in enumerate(self._devs))
        self._polledDevs = [d for d in self._devs if d.generatePollCode()]

        self._statementsFromInputs = {} # input device uri: latest statements
        self._lastPollTime = {} # input device uri: time()
        self._influx = InfluxExporter(self.configGraph)
        self.open()
        for d in self._devs:
            self.syncMasterGraphToHostStatements(d)

    def description(self):
        """for web page"""
        return {
            'uri': self.uri,
            'dev': self.dev,
            'baudrate': self.baudrate,
            'devices': [d.description() for d in self._devs],
            }

    def open(self):
        self.ser = LoggingSerial(port=self.dev, baudrate=self.baudrate,
                                 timeout=2)

    def startPolling(self, period=.5):
        task.LoopingCall(self._poll).start(period)

    def _poll(self):
        """
        even boards with no inputs need some polling to see if they're
        still ok
        """
        try:
            self._pollWork()
        except serial.SerialException:
            reactor.crash()
            raise
        except Exception as e:
            import traceback; traceback.print_exc()
            log.warn("poll: %r" % e)

    def _pollWork(self):
        t1 = time.time()
        self.ser.write("\x60\x00") # "poll everything"
        for i in self._polledDevs:
            with i._stats.poll.time():
                try:
                    now = time.time()
                    new = i.readFromPoll(self.ser.read)
                    if isinstance(new, dict): # new style
                        oneshot = new['oneshot']
                        new = new['latest']
                    else:
                        oneshot = None

                    self._updateMasterWithNewPollStatements(i.uri, new)

                    if oneshot:
                        self._sendOneshot(oneshot)
                    self._lastPollTime[i.uri] = now
                except:
                    log.warn('while polling %r:', i.uri)
                    raise
        #plus statements about succeeding or erroring on the last poll
        byte = self.ser.read(1)
        if byte != 'x':
            raise ValueError("after poll, got %x instead of 'x'" % byte)
        for i in self._devs:
            if i.wantIdleOutput():
                self.ser.write("\x60" + chr(self._devCommandNum[i.uri]))
                i.outputIdle(self.ser.write)
                if self.ser.read(1) != 'k':
                    raise ValueError('no ack after outputIdle')
        elapsed = time.time() - t1
        if elapsed > 1.0:
            log.warn('poll took %.1f seconds' % elapsed)

        stmts = set()
        for v in self._statementsFromInputs.values():
            stmts.update(v)
        self._influx.exportToInflux(stmts)

    def _updateMasterWithNewPollStatements(self, dev, new):
        prev = self._statementsFromInputs.get(dev, set())

        # it's important that quads from different devices
        # don't clash, since that can lead to inconsistent
        # patches (e.g.
        #   dev1 changes value from 1 to 2;
        #   dev2 changes value from 2 to 3;
        #   dev1 changes from 2 to 4 but this patch will
        #     fail since the '2' statement is gone)
        self.masterGraph.patch(Patch.fromDiff(inContext(prev, dev),
                                              inContext(new, dev)))
        self._statementsFromInputs[dev] = new

    def _sendOneshot(self, oneshot):
        body = (' '.join('%s %s %s .' % (s.n3(), p.n3(), o.n3())
                         for s,p,o in oneshot)).encode('utf8')
        fetch(method='POST',
              url='http://bang6:9071/oneShot',
              headers={'Content-Type': ['text/n3']}, postdata=body,
              timeout=5)

    def outputStatements(self, stmts):
        unused = set(stmts)
        for dev in self._devs:
            stmtsForDev = []
            for pat in dev.outputPatterns():
                if [term is None for term in pat] != [False, False, True]:
                    raise NotImplementedError
                for stmt in stmts:
                    if stmt[:2] == pat[:2]:
                        stmtsForDev.append(stmt)
                        unused.discard(stmt)
            if stmtsForDev:
                log.info("output goes to action handler for %s" % dev.uri)
                with dev._stats.output.time():
                    self.ser.write("\x60" + chr(self._devCommandNum[dev.uri]))
                    dev.sendOutput(stmtsForDev, self.ser.write, self.ser.read)
                    if self.ser.read(1) != 'k':
                        raise ValueError(
                            "%s sendOutput/generateActionCode didn't use "
                            "matching output bytes" % dev.__class__)
                # Dev *could* change hostStatements at any time, and
                # we're not currently tracking that, but the usual is
                # to change them in response to sendOutput so this
                # should be good enough. The right answer is to give
                # each dev the masterGraph for it to write to.
                self.syncMasterGraphToHostStatements(dev)
                log.info("output and masterGraph sync complete")
        if unused:
            log.info("Board %s doesn't care about these statements:", self.uri)
            for s in unused:
                log.info("%r", s)

    def syncMasterGraphToHostStatements(self, dev):
        hostStmtCtx = URIRef(dev.uri + '/host')
        newQuads = inContext(dev.hostStatements(), hostStmtCtx)
        p = self.masterGraph.patchSubgraph(hostStmtCtx, newQuads)
        log.debug("patch master with these host stmts %s", p)

    def staticStmts(self):
        return [(HOST[hostname], ROOM['connectedTo'], self.uri, CTX)]

    def generateArduinoCode(self):
        code = write_arduino_code.writeCode(self.baudrate, self._devs,
                                            self._devCommandNum)
        code = write_arduino_code.indent(code)
        cksum = hashlib.sha1(code).hexdigest()
        code = code.replace('CODE_CHECKSUM', cksum)
        return code, cksum

    def _readBoardChecksum(self, length):
        # this is likely right after reset, so it might take 2 seconds
        for tries in range(6):
            self.ser.write("\x60\x01")
            try:
                return self.ser.read(length)
            except ValueError:
                if tries == 5:
                    raise
            time.sleep(.5)
        raise ValueError

    def _boardIsCurrent(self, currentChecksum):
        try:
            boardCksum = self._readBoardChecksum(len(currentChecksum))
            if boardCksum == currentChecksum:
                log.info("board has current code (%s)" % currentChecksum)
                return True
            else:
                log.info("board responds with incorrect code version")
        except Exception as e:
            log.info("can't get code version from board: %r" % e)
        return False

    def deployToArduino(self):
        code, cksum = self.generateArduinoCode()

        if self._boardIsCurrent(cksum):
            return

        try:
            if hasattr(self, 'ser'):
                self.ser.close()
            workDir = tempfile.mkdtemp(prefix='arduinoNode_board_deploy')
            try:
                self._arduinoMake(workDir, code)
            finally:
                shutil.rmtree(workDir)
        finally:
            self.open()

    def _arduinoMake(self, workDir, code):
        with open(workDir + '/makefile', 'w') as makefile:
            makefile.write(write_arduino_code.writeMakefile(
                dev=self.dev,
                tag=self.configGraph.value(self.uri, ROOM['boardTag']),
                allLibs=sum((d.generateArduinoLibs() for d in self._devs), [])))

        with open(workDir + '/main.ino', 'w') as main:
            main.write(code)

        subprocess.check_call(['make', 'upload'], cwd=workDir)


    def currentGraph(self):
        g = Graph()


        for dev in self._devs:
            for stmt in dev.hostStatements():
                g.add(stmt)
        return g
Ejemplo n.º 9
0
            "config_nightlight_ari.n3",
            "config_bed_bar.n3",
            "config_air_quality_indoor.n3",
            "config_air_quality_outdoor.n3",
            "config_living_lamps.n3",
            "config_kitchen.n3",
    ]:
        if not arg['--cs'] or arg['--cs'] in fn:
            config.parse(fn, format='n3')

    masterGraph = PatchableGraph()

    mqtt = MqttClient(clientId='mqtt_to_rdf',
                      brokerHost='bang',
                      brokerPort=1883)
    influx = InfluxExporter(config)

    srcs = []
    for src in config.subjects(RDF.type, ROOM['MqttStatementSource']):
        srcs.append(MqttStatementSource(src, config, masterGraph, mqtt,
                                        influx))
    log.info(f'set up {len(srcs)} sources')

    port = 10018
    reactor.listenTCP(
        port,
        cyclone.web.Application([
            (r"/()", cyclone.web.StaticFileHandler, {
                "path": ".",
                "default_filename": "index.html"
            }),