write buffer to output hardware (may be throttled if updates are

        too fast, or repeated if they are too slow)

        """

        pass

    def crash(self):

        log.error('unrecoverable- exiting')

        cast(IReactorCore, reactor).crash()

class DummyOutput(Output):

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

        super().__init__(uri)

    def update(self, buf: bytes):

        log.info(f'dummy update {list(map(int,buf[:80]))}')

class BackgroundLoopOutput(Output):

    """Call _write forever at 20hz in background threads"""

    rate: float

        super().__init__(uri)

        self.rate = rate

        self._currentBuffer = b''

        self._task = asyncio.create_task(self._loop())

    async def _loop(self):

        while True:

            t1 = time.time()

            self._loop_one()

            remain = max(0, 1 / self.rate - (time.time() - t1))

            await asyncio.sleep(remain)

    def _loop_one(self):

        start = time.time()

        sendingBuffer = self._currentBuffer

        #tenacity retry

        self._write(sendingBuffer)

class FtdiDmx(BackgroundLoopOutput):

    def __init__(self, uri, lastDmxChannel, rate=22):

        super().__init__(uri)

            client, clientSession, settings, sendTime = parseJsonMessage(collector.graph, msg)

            collector.setAttrs(client, clientSession, settings, sendTime)

    except:

        traceback.print_exc()

        raise

def findDevice():

    for line in subprocess.check_output("lsusb").decode('utf8').splitlines():

        if '16c0:05dc' in line:

            words = line.split(':')[0].split()

            dev = f'/dev/bus/usb/{words[1]}/{words[3]}'

            log.info(f'device will be {dev}')

            return dev ,int(words[3])

    raise ValueError("no matching uDMX found")

def main():

    logging.getLogger('autodepgraphapi').setLevel(logging.INFO)

    logging.getLogger('syncedgraph').setLevel(logging.INFO)

    logging.getLogger('output.allDmx').setLevel(logging.WARNING)

    logging.getLogger().setLevel(logging.DEBUG)

    logging.getLogger('collector').setLevel(logging.DEBUG)

    graph = SyncedGraph(networking.rdfdb.url, "collector")

            # if user doesn't have r/w, fail now

    try:

        # todo: drive outputs with config files

        outputs: List[Output] = [

            # ArtnetDmx(L9['output/dmxA/'],

            #           host='127.0.0.1',

            #           port=6445,

            #           rate=rate),

            #sudo chmod a+rw /dev/bus/usb/003/021

        ]

    except Exception:

        log.error("setting up outputs:")

        traceback.print_exc()

        raise

    listeners = WebListeners()

    c = Collector(graph, outputs, listeners)

    zl = asyncio.create_task(zmqListener(c))

    app = Starlette(

        debug=True,

        routes=[

            # Route('/recentRequests', lambda req: get_recentRequests(req, db)),

            WebSocketRoute('/updates', endpoint=functools.partial(Updates, listeners)),

            Route('/attrs', functools.partial(PutAttrs, c), methods=['PUT']),

        ],

    )

    app.add_middleware(PrometheusMiddleware)

    app.add_route("/metrics", handle_metrics)

    # loadtest = os.environ.get('LOADTEST', False)  # call myself with some synthetic load then exit

    # if loadtest:

    #     # in a subprocess since we don't want this client to be

    #     # cooperating with the main event loop and only sending

    #     # requests when there's free time