fabfire_adapter/single.py

import asyncio
import logging
import os
from asyncio_mqtt import Client
import json
import fabapi
from timer import Timer

BFFHD_HOST = "localhost"
MQTT_HOST = "127.0.0.1"
MACHINE_URN = "urn:fabaccess:resource:MachineA2"
READER_ID = "111"

auth_cap = None
session = None

async def main():
    global auth_cap
    global session

    async with Client(MQTT_HOST) as client:
        await client.publish(f"/cmnd/reader/{READER_ID}", payload='{"Cmd":"haltPICC"}', qos=2, retain=False)
        await client.publish(f"/cmnd/reader/{READER_ID}", payload='{"Cmd": "message", "MssgID": 0, "AddnTxt":"    Karte auflegen"}', qos=2, retain=False)
        async with client.filtered_messages(f"/rfid_reader/{READER_ID}") as messages:
            await client.subscribe("/rfid_reader/#")
            logging.info(f"Connected to reader {READER_ID} on MQTT Broker {MQTT_HOST}")
            async for message in messages:
                response_for_reader = None
                if not auth_cap:
                    timeout_timer = Timer(2, lambda: handle_timeout(client))
                    auth_cap, response_for_reader = await fabapi.connect_with_fabfire_initial(
                        BFFHD_HOST, 59661, message.payload)
                elif not session:
                    response_for_reader, session = await fabapi.connect_with_fabfire_step(auth_cap,
                                                                                               message.payload)
                    if session:
                        timeout_timer.cancel()
                        await client.publish(f"/cmnd/reader/{READER_ID}", payload='{"Cmd":"haltPICC"}', qos=2,
                                             retain=False)

                        info = session.machineSystem.info
                        ma = await info.getMachineURN(f"{MACHINE_URN}").a_wait()

                        if ma.which() == "just":
                            ma = ma.just
                        else:
                            logging.critical(
                                f"Could not get machine {MACHINE_URN}. Machine does not exist or insufficient permissions")
                            raise Exception(
                                f"Could not get machine {MACHINE_URN}. Machine does not exist or insufficient permissions")

                        if ma.state == "inUse":
                            await ma.inuse.giveBack().a_wait()
                            await client.publish(f"/cmnd/reader/{READER_ID}",
                                                 payload='{"Cmd":"message","MssgID":0,"AddnTxt":""}', qos=2,
                                                 retain=False)
                        else:
                            await ma.use.use().a_wait()
                            await client.publish(f"/cmnd/reader/{READER_ID}", payload=response_for_reader, qos=2,
                                                 retain=False)
                            await asyncio.sleep(2)
                            await client.publish(f"/cmnd/reader/{READER_ID}",
                                                 payload='{"Cmd":"message","MssgID":3,"AddnTxt":""}', qos=2,
                                                 retain=False)
                        session = None
                        auth_cap = None
                        response_for_reader = None
                if response_for_reader:
                    await client.publish(f"/cmnd/reader/{READER_ID}", payload=response_for_reader, qos=2, retain=False)

async def handle_timeout(client):
    global auth_cap 
    global session
    await client.publish(f"/cmnd/reader/{READER_ID}", payload='{"Cmd":"haltPICC"}', qos=2,
                             retain=False)
    logging.critical(f"authentication timed out on reader {READER_ID}")
    auth_cap = None
    session = None

if __name__ == "__main__":
    LOGLEVEL = os.environ.get('LOGLEVEL', 'INFO').upper()
    logging.basicConfig(level=LOGLEVEL)
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())