craftbeerpi4-pione/cbpi/controller/satellite_controller.py
2021-12-03 13:26:18 +01:00

135 lines
5.3 KiB
Python

import asyncio
import json
from re import M
from asyncio_mqtt import Client, MqttError, Will, client
from contextlib import AsyncExitStack, asynccontextmanager
from cbpi import __version__
import logging
class SatelliteController:
def __init__(self, cbpi):
self.cbpi = cbpi
self.logger = logging.getLogger(__name__)
self.host = cbpi.static_config.get("mqtt_host", "localhost")
self.port = cbpi.static_config.get("mqtt_port", 1883)
self.username = cbpi.static_config.get("mqtt_username", None)
self.password = cbpi.static_config.get("mqtt_password", None)
self.client = None
self.topic_filters = [
("cbpi/actor/+/on", self._actor_on),
("cbpi/actor/+/off", self._actor_off),
("cbpi/actor/+/power", self._actor_power),
]
self.tasks = set()
async def init(self):
asyncio.create_task(self.init_client(self.cbpi))
async def publish(self, topic, message, retain=False):
if self.client is not None and self.client._connected:
try:
await self.client.publish(topic, message, qos=1, retain=retain)
except Exception as e:
self.logger.warning("Failed to push data via mqtt: {}".format(e))
async def _actor_on(self, messages):
async for message in messages:
try:
topic_key = message.topic.split("/")
await self.cbpi.actor.on(topic_key[2])
except Exception as e:
self.logger.warning("Failed to process actor on via mqtt: {}".format(e))
async def _actor_off(self, messages):
async for message in messages:
try:
topic_key = message.topic.split("/")
await self.cbpi.actor.off(topic_key[2])
except Exception as e:
self.logger.warning("Failed to process actor off via mqtt: {}".format(e))
async def _actor_power(self, messages):
async for message in messages:
try:
topic_key = message.topic.split("/")
try:
power=int(message.payload.decode())
if power > 100:
power = 100
if power < 0:
power = 0
await self.cbpi.actor.set_power(topic_key[2],power)
await self.cbpi.actor.actor_update(topic_key[2],power)
except:
self.logger.warning("Failed to set actor power via mqtt. No valid power in message")
except:
self.logger.warning("Failed to set actor power via mqtt")
def subcribe(self, topic, method):
task = asyncio.create_task(self._subcribe(topic, method))
return task
async def _subcribe(self, topic, method):
while True:
try:
if self.client._connected.done():
async with self.client.filtered_messages(topic) as messages:
await self.client.subscribe(topic)
async for message in messages:
await method(message.payload.decode())
except asyncio.CancelledError:
# Cancel
self.logger.warning("Sub Cancelled")
except MqttError as e:
self.logger.error("Sub MQTT Exception: {}".format(e))
except Exception as e:
self.logger.error("Sub Exception: {}".format(e))
# wait before try to resubscribe
await asyncio.sleep(5)
async def init_client(self, cbpi):
async def cancel_tasks(tasks):
for task in tasks:
if task.done():
continue
task.cancel()
try:
await task
except asyncio.CancelledError:
pass
while True:
try:
async with AsyncExitStack() as stack:
self.tasks = set()
stack.push_async_callback(cancel_tasks, self.tasks)
self.client = Client(self.host, port=self.port, username=self.username, password=self.password, will=Will(topic="cbpi/diconnect", payload="CBPi Server Disconnected"))
await stack.enter_async_context(self.client)
for topic_filter in self.topic_filters:
topic = topic_filter[0]
method = topic_filter[1]
manager = self.client.filtered_messages(topic)
messages = await stack.enter_async_context(manager)
task = asyncio.create_task(method(messages))
self.tasks.add(task)
for topic_filter in self.topic_filters:
topic = topic_filter[0]
await self.client.subscribe(topic)
self.logger.info("MQTT Connected to {}:{}".format(self.host, self.port))
await asyncio.gather(*self.tasks)
except MqttError as e:
self.logger.error("MQTT Exception: {}".format(e))
except Exception as e:
self.logger.error("MQTT General Exception: {}".format(e))
await asyncio.sleep(5)