fabfire_adapter/reader.py

import asyncio
import logging

import asyncio_mqtt

import fabapi
from host import Host
from timer import Timer


class Reader:
    def __init__(self, reader_id: str, machine_urn: str, bffhd_address: Host):
        self.reader_id = reader_id
        self.machine_urn = machine_urn
        self.bffhd_address = bffhd_address
        self.auth_cap = None
        self.session = None
        self.timeout_timer = None

    async def handle_messages(self, messages, client: asyncio_mqtt.Client):
        async for message in messages:
            try:
                print(message.topic)
                response_for_reader = None
                if message.topic == f"fabreader/{self.reader_id}/startOTA":
                    self.timeout_timer = Timer(10, lambda: self.handle_timeout(client))
                    self.auth_cap, response_for_reader = await fabapi.connect_with_fabfire_initial(self.bffhd_address.hostname, self.bffhd_address.port, message.payload)
                elif not self.session and message.topic == f"fabreader/{self.reader_id}/responseOTA":
                    response_for_reader, self.session = await fabapi.connect_with_fabfire_step(self.auth_cap, message.payload)
                    if self.session:
                        self.timeout_timer.cancel()
                        
                        info = self.session.machineSystem.info
                        ma = await info.getMachineURN(f"{self.machine_urn}").a_wait()

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

                        if ma.state == "inUse":
                            try:
                                await ma.inuse.giveBack().a_wait()
                            except:
                                await client.publish(f"fabreader/{self.reader_id}/display/info", payload="Wrong User", qos=1, retain=False)
                                await asyncio.sleep(2)
                                await client.publish(f"fabreader/{self.reader_id}/display/info", payload="", qos=1, retain=False)
                        else:
                            try:
                                await ma.use.use().a_wait()
                            except:
                                await client.publish(f"fabreader/{self.reader_id}/display/info", payload="No Authorization", qos=1, retain=False)
                                await asyncio.sleep(2)
                                await client.publish(f"fabreader/{self.reader_id}/display/info", payload="", qos=1, retain=False)

                        await client.publish(f"fabreader/{self.reader_id}/stopOTA", payload="", qos=2, retain=False)

                        self.session = None
                        self.auth_cap = None
                        response_for_reader = None

                if message.topic == f"fabreader/{self.reader_id}/cancelOTA" or message.topic == f"fabreader/{self.reader_id}/cancelOTA":
                    self.session = None
                    self.auth_cap = None
                    response_for_reader = None
                    self.timeout_timer.cancel()

                if response_for_reader:
                    await client.publish(f"fabreader/{self.reader_id}/requestOTA", payload=response_for_reader, qos=2, retain=False)
                
            except Exception as e:
                logging.error(f"Caught exception {e}")
                await client.publish(f"fabreader/{self.reader_id}/stopOTA", payload="", qos=2, retain=False)
                self.session = None
                self.auth_cap = None
                response_for_reader = None
                self.timeout_timer.cancel()

    async def handle_timeout(self, client):
        await client.publish(f"fabreader/{self.reader_id}/stopOTA", payload="", qos=2, retain=False)
        logging.error(f"authentication timed out on reader {self.reader_id}")
        self.auth_cap = None
        self.session = None