def setup_target_platform(target_platform, message_client_name):
# type: (str, Optional[str]) -> None
config = ConfigParser()
config.read(constants.get_config_file())
config_lock = Lock()
metrics_lock = Lock()
config_database_file = constants.get_config_database_file()
# Debugging options
try:
debug_logger = config.get('OpenMotics', 'debug_logger')
if debug_logger:
logging.getLogger(debug_logger).setLevel(logging.DEBUG)
except NoOptionError:
pass
# Webserver / Presentation layer
try:
https_port = int(config.get('OpenMotics', 'https_port'))
except NoOptionError:
https_port = 443
try:
http_port = int(config.get('OpenMotics', 'http_port'))
except NoOptionError:
http_port = 80
Injectable.value(https_port=https_port)
Injectable.value(http_port=http_port)
Injectable.value(ssl_private_key=constants.get_ssl_private_key_file())
Injectable.value(ssl_certificate=constants.get_ssl_certificate_file())
# TODO: Clean up dependencies more to reduce complexity
# IOC announcements
# When below modules are imported, the classes are registerd in the IOC graph. This is required for
# instances that are used in @Inject decorated functions below, and is also needed to specify
# abstract implementations depending on e.g. the platform (classic vs core) or certain settings (classic
# thermostats vs gateway thermostats)
from plugins import base
from gateway import (metrics_controller, webservice, scheduling, observer,
gateway_api, metrics_collector,
maintenance_controller, user_controller,
pulse_counter_controller, metrics_caching, watchdog,
output_controller, room_controller, sensor_controller,
shutter_controller, group_action_controller,
module_controller, ventilation_controller)
from cloud import events
_ = (metrics_controller, webservice, scheduling, observer, gateway_api,
metrics_collector, maintenance_controller, base, events,
user_controller, pulse_counter_controller, metrics_caching, watchdog,
output_controller, room_controller, sensor_controller,
shutter_controller, group_action_controller, module_controller,
ventilation_controller)
# IPC
message_client = None
if message_client_name is not None:
message_client = MessageClient(message_client_name)
Injectable.value(message_client=message_client)
# Cloud API
Injectable.value(gateway_uuid=config.get('OpenMotics', 'uuid'))
try:
parsed_url = urlparse(config.get('OpenMotics', 'vpn_check_url'))
except NoOptionError:
parsed_url = urlparse('')
Injectable.value(cloud_endpoint=parsed_url.hostname)
Injectable.value(cloud_port=parsed_url.port)
Injectable.value(cloud_ssl=parsed_url.scheme == 'https')
Injectable.value(cloud_api_version=0)
cloud_url = urlunparse(
(parsed_url.scheme, parsed_url.netloc, '', '', '', ''))
Injectable.value(cloud_url=cloud_url or None)
try:
firmware_url = config.get('OpenMotics', 'firmware_url')
except NoOptionError:
path = '/portal/firmware_metadata'
firmware_url = urlunparse(
(parsed_url.scheme, parsed_url.netloc, path, '', '', ''))
Injectable.value(firmware_url=firmware_url or None)
# User Controller
Injectable.value(user_db=config_database_file)
Injectable.value(user_db_lock=config_lock)
Injectable.value(token_timeout=3600)
Injectable.value(
config={
'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')
})
# Metrics Controller
Injectable.value(metrics_db=constants.get_metrics_database_file())
Injectable.value(metrics_db_lock=metrics_lock)
# Energy Controller
try:
power_serial_port = config.get('OpenMotics', 'power_serial')
except NoOptionError:
power_serial_port = ''
if power_serial_port:
Injectable.value(power_db=constants.get_power_database_file())
Injectable.value(power_store=PowerStore())
# TODO: make non blocking?
Injectable.value(power_serial=RS485(
Serial(power_serial_port, 115200, timeout=None)))
Injectable.value(power_communicator=PowerCommunicator())
Injectable.value(power_controller=PowerController())
Injectable.value(p1_controller=P1Controller())
else:
Injectable.value(power_serial=None)
Injectable.value(power_store=None)
Injectable.value(
power_communicator=None) # TODO: remove from gateway_api
Injectable.value(power_controller=None)
Injectable.value(p1_controller=None)
# Pulse Controller
Injectable.value(pulse_db=constants.get_pulse_counter_database_file())
# Master Controller
try:
controller_serial_port = config.get('OpenMotics', 'controller_serial')
except NoOptionError:
controller_serial_port = ''
if controller_serial_port:
Injectable.value(controller_serial=Serial(
controller_serial_port, 115200, exclusive=True))
if target_platform in [Platform.Type.DUMMY, Platform.Type.ESAFE]:
Injectable.value(maintenance_communicator=None)
Injectable.value(passthrough_service=None)
Injectable.value(master_controller=MasterDummyController())
Injectable.value(eeprom_db=None)
from gateway.hal.master_controller_dummy import DummyEepromObject
Injectable.value(eeprom_extension=DummyEepromObject())
elif target_platform in Platform.CoreTypes:
# FIXME don't create singleton for optional controller?
from master.core import ucan_communicator, slave_communicator
_ = ucan_communicator, slave_communicator
core_cli_serial_port = config.get('OpenMotics', 'cli_serial')
Injectable.value(cli_serial=Serial(core_cli_serial_port, 115200))
Injectable.value(passthrough_service=None) # Mark as "not needed"
# TODO: Remove; should not be needed for Core
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
Injectable.value(master_communicator=CoreCommunicator())
Injectable.value(
maintenance_communicator=MaintenanceCoreCommunicator())
Injectable.value(memory_file=MemoryFile())
Injectable.value(master_controller=MasterCoreController())
elif target_platform in Platform.ClassicTypes:
# FIXME don't create singleton for optional controller?
from master.classic import eeprom_extension
_ = eeprom_extension
leds_i2c_address = config.get('OpenMotics', 'leds_i2c_address')
passthrough_serial_port = config.get('OpenMotics',
'passthrough_serial')
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
Injectable.value(leds_i2c_address=int(leds_i2c_address, 16))
if passthrough_serial_port:
Injectable.value(
passthrough_serial=Serial(passthrough_serial_port, 115200))
from master.classic.passthrough import PassthroughService
_ = PassthroughService # IOC announcement
else:
Injectable.value(passthrough_service=None)
Injectable.value(master_communicator=MasterCommunicator())
Injectable.value(
maintenance_communicator=MaintenanceClassicCommunicator())
Injectable.value(master_controller=MasterClassicController())
else:
logger.warning('Unhandled master implementation for %s',
target_platform)
if target_platform in [Platform.Type.DUMMY, Platform.Type.ESAFE]:
Injectable.value(frontpanel_controller=None)
elif target_platform in Platform.CoreTypes:
Injectable.value(frontpanel_controller=FrontpanelCoreController())
elif target_platform in Platform.ClassicTypes:
Injectable.value(frontpanel_controller=FrontpanelClassicController())
else:
logger.warning('Unhandled frontpanel implementation for %s',
target_platform)
# Thermostats
thermostats_gateway_feature = Feature.get_or_none(
name='thermostats_gateway')
thermostats_gateway_enabled = thermostats_gateway_feature is not None and thermostats_gateway_feature.enabled
if target_platform not in Platform.ClassicTypes or thermostats_gateway_enabled:
Injectable.value(thermostat_controller=ThermostatControllerGateway())
else:
Injectable.value(thermostat_controller=ThermostatControllerMaster())
def _migrate(cls,
master_controller=INJECTED
): # type: (MasterClassicController) -> None
# Core(+) platforms never had non-ORM rooms
if Platform.get_platform() in Platform.CoreTypes:
return
# Import legacy code
@Inject
def _load_eeprom_extension(eeprom_extension=INJECTED):
# type: (EepromExtension) -> EepromExtension
return eeprom_extension
eext_controller = _load_eeprom_extension()
from master.classic.eeprom_models import (OutputConfiguration,
InputConfiguration,
SensorConfiguration,
ShutterConfiguration,
ShutterGroupConfiguration,
PulseCounterConfiguration)
rooms = {} # type: Dict[int, Room]
floors = {} # type: Dict[int, Floor]
# Rooms and floors
logger.info('* Rooms & floors')
for room_id in range(100):
try:
RoomsMigrator._get_or_create_room(eext_controller,
room_id,
rooms,
floors,
skip_empty=True)
except Exception:
logger.exception('Could not migrate single RoomConfiguration')
# Main objects
for eeprom_model, orm_model, filter_ in [
(OutputConfiguration, Output, lambda o: True),
(InputConfiguration, Input, lambda i: i.module_type in ['i', 'I']),
(SensorConfiguration, Sensor, lambda s: True),
(ShutterConfiguration, Shutter, lambda s: True),
(ShutterGroupConfiguration, ShutterGroup, lambda s: True)
]:
logger.info('* {0}s'.format(eeprom_model.__name__))
try:
for classic_orm in master_controller._eeprom_controller.read_all(
eeprom_model):
try:
object_id = classic_orm.id
if object_id is None:
continue
if not filter_(classic_orm):
RoomsMigrator._delete_eext_fields(
eext_controller, eeprom_model.__name__,
object_id, ['room'])
continue
try:
room_id = int(
RoomsMigrator._read_eext_fields(
eext_controller, eeprom_model.__name__,
object_id, ['room']).get('room', 255))
except ValueError:
room_id = 255
object_orm, _ = orm_model.get_or_create(
number=object_id) # type: ignore
if room_id == 255:
object_orm.room = None
else:
object_orm.room = RoomsMigrator._get_or_create_room(
eext_controller, room_id, rooms, floors)
object_orm.save()
RoomsMigrator._delete_eext_fields(
eext_controller, eeprom_model.__name__, object_id,
['room'])
except Exception:
logger.exception('Could not migrate single {0}'.format(
eeprom_model.__name__))
except Exception:
logger.exception('Could not migrate {0}s'.format(
eeprom_model.__name__))
# PulseCounters
pulse_counter = None # type: Optional[PulseCounter]
# - Master
try:
logger.info('* PulseCounters (master)')
for pulse_counter_classic_orm in master_controller._eeprom_controller.read_all(
PulseCounterConfiguration):
try:
pulse_counter_id = pulse_counter_classic_orm.id
try:
room_id = int(
RoomsMigrator._read_eext_fields(
eext_controller, 'PulseCounterConfiguration',
pulse_counter_id, ['room']).get('room', 255))
except ValueError:
room_id = 255
pulse_counter = PulseCounter.get_or_none(
number=pulse_counter_id)
if pulse_counter is None:
pulse_counter = PulseCounter(
number=pulse_counter_id,
name=pulse_counter_classic_orm.name,
persistent=False,
source=u'master')
else:
pulse_counter.name = pulse_counter_classic_orm.name
pulse_counter.persistent = False
pulse_counter.source = u'master'
if room_id == 255:
pulse_counter.room = None
else:
pulse_counter.room = RoomsMigrator._get_or_create_room(
eext_controller, room_id, rooms, floors)
pulse_counter.save()
RoomsMigrator._delete_eext_fields(
eext_controller, 'PulseCounterConfiguration',
pulse_counter_id, ['room'])
except Exception:
logger.exception(
'Could not migrate classic master PulseCounter')
except Exception:
logger.exception('Could not migrate classic master PulseCounters')
# - Old SQLite3
old_sqlite_db = constants.get_pulse_counter_database_file()
if os.path.exists(old_sqlite_db):
try:
logger.info('* PulseCounters (gateway)')
import sqlite3
connection = sqlite3.connect(
old_sqlite_db,
detect_types=sqlite3.PARSE_DECLTYPES,
check_same_thread=False,
isolation_level=None)
cursor = connection.cursor()
for row in cursor.execute(
'SELECT id, name, room, persistent FROM pulse_counters ORDER BY id ASC;'
):
try:
pulse_counter_id = int(row[0])
room_id = int(row[2])
pulse_counter = PulseCounter.get_or_none(
number=pulse_counter_id)
if pulse_counter is None:
pulse_counter = PulseCounter(
number=pulse_counter_id,
name=str(row[1]),
persistent=row[3] >= 1,
source=u'gateway')
else:
pulse_counter.name = str(row[1])
pulse_counter.persistent = row[3] >= 1
pulse_counter.source = u'gateway'
if room_id == 255:
pulse_counter.room = None
else:
pulse_counter.room = RoomsMigrator._get_or_create_room(
eext_controller, room_id, rooms, floors)
pulse_counter.save()
except Exception:
logger.exception(
'Could not migratie gateway PulseCounter')
os.rename(old_sqlite_db, '{0}.bak'.format(old_sqlite_db))
except Exception:
logger.exception('Could not migrate gateway PulseCounters')
def build_graph():
config = ConfigParser()
config.read(constants.get_config_file())
config_lock = Lock()
scheduling_lock = Lock()
metrics_lock = Lock()
config_database_file = constants.get_config_database_file()
# TODO: Clean up dependencies more to reduce complexity
# IOC announcements
# When below modules are imported, the classes are registerd in the IOC graph. This is required for
# instances that are used in @Inject decorated functions below, and is also needed to specify
# abstract implementations depending on e.g. the platform (classic vs core) or certain settings (classic
# thermostats vs gateway thermostats)
from power import power_communicator, power_controller
from plugins import base
from gateway import (metrics_controller, webservice, scheduling,
observer, gateway_api, metrics_collector,
maintenance_controller, comm_led_controller,
users, pulses, config as config_controller,
metrics_caching, watchdog)
from cloud import events
_ = (metrics_controller, webservice, scheduling, observer, gateway_api,
metrics_collector, maintenance_controller, base, events,
power_communicator, comm_led_controller, users, power_controller,
pulses, config_controller, metrics_caching, watchdog)
if Platform.get_platform() == Platform.Type.CORE_PLUS:
from gateway.hal import master_controller_core
from master_core import maintenance, core_communicator, ucan_communicator
from master import eeprom_extension # TODO: Obsolete, need to be removed
_ = master_controller_core, maintenance, core_communicator, ucan_communicator
else:
from gateway.hal import master_controller_classic
from master import maintenance, master_communicator, eeprom_extension
_ = master_controller_classic, maintenance, master_communicator, eeprom_extension
thermostats_gateway_feature = Feature.get_or_none(
name='thermostats_gateway')
thermostats_gateway_enabled = thermostats_gateway_feature is not None and thermostats_gateway_feature.enabled
if Platform.get_platform(
) == Platform.Type.CORE_PLUS or thermostats_gateway_enabled:
from gateway.thermostat.gateway import thermostat_controller_gateway
_ = thermostat_controller_gateway
else:
from gateway.thermostat.master import thermostat_controller_master
_ = thermostat_controller_master
# IPC
Injectable.value(message_client=MessageClient('openmotics_service'))
# Cloud API
parsed_url = urlparse(config.get('OpenMotics', 'vpn_check_url'))
Injectable.value(gateway_uuid=config.get('OpenMotics', 'uuid'))
Injectable.value(cloud_endpoint=parsed_url.hostname)
Injectable.value(cloud_port=parsed_url.port)
Injectable.value(cloud_ssl=parsed_url.scheme == 'https')
Injectable.value(cloud_api_version=0)
# User Controller
Injectable.value(user_db=config_database_file)
Injectable.value(user_db_lock=config_lock)
Injectable.value(token_timeout=3600)
Injectable.value(
config={
'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')
})
# Configuration Controller
Injectable.value(config_db=config_database_file)
Injectable.value(config_db_lock=config_lock)
# Energy Controller
power_serial_port = config.get('OpenMotics', 'power_serial')
Injectable.value(power_db=constants.get_power_database_file())
if power_serial_port:
Injectable.value(power_serial=RS485(
Serial(power_serial_port, 115200, timeout=None)))
else:
Injectable.value(power_serial=None)
Injectable.value(power_communicator=None)
Injectable.value(power_controller=None)
# Pulse Controller
Injectable.value(pulse_db=constants.get_pulse_counter_database_file())
# Scheduling Controller
Injectable.value(
scheduling_db=constants.get_scheduling_database_file())
Injectable.value(scheduling_db_lock=scheduling_lock)
# Master Controller
controller_serial_port = config.get('OpenMotics', 'controller_serial')
Injectable.value(
controller_serial=Serial(controller_serial_port, 115200))
if Platform.get_platform() == Platform.Type.CORE_PLUS:
from master_core.memory_file import MemoryFile, MemoryTypes
core_cli_serial_port = config.get('OpenMotics', 'cli_serial')
Injectable.value(cli_serial=Serial(core_cli_serial_port, 115200))
Injectable.value(passthrough_service=None) # Mark as "not needed"
Injectable.value(
memory_files={
MemoryTypes.EEPROM: MemoryFile(MemoryTypes.EEPROM),
MemoryTypes.FRAM: MemoryFile(MemoryTypes.FRAM)
})
# TODO: Remove; should not be needed for Core
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
else:
passthrough_serial_port = config.get('OpenMotics',
'passthrough_serial')
Injectable.value(
eeprom_db=constants.get_eeprom_extension_database_file())
if passthrough_serial_port:
Injectable.value(
passthrough_serial=Serial(passthrough_serial_port, 115200))
from master.passthrough import PassthroughService
_ = PassthroughService # IOC announcement
else:
Injectable.value(passthrough_service=None)
# Metrics Controller
Injectable.value(metrics_db=constants.get_metrics_database_file())
Injectable.value(metrics_db_lock=metrics_lock)
# Webserver / Presentation layer
Injectable.value(ssl_private_key=constants.get_ssl_private_key_file())
Injectable.value(ssl_certificate=constants.get_ssl_certificate_file())
def main():
""" Main function. """
log('Starting service...')
config = ConfigParser()
config.read(constants.get_config_file())
defaults = {'username': config.get('OpenMotics', 'cloud_user'),
'password': config.get('OpenMotics', 'cloud_pass')}
controller_serial_port = config.get('OpenMotics', 'controller_serial')
passthrough_serial_port = config.get('OpenMotics', 'passthrough_serial')
power_serial_port = config.get('OpenMotics', 'power_serial')
gateway_uuid = config.get('OpenMotics', 'uuid')
config_lock = threading.Lock()
user_controller = UserController(constants.get_config_database_file(), config_lock, defaults, 3600)
config_controller = ConfigurationController(constants.get_config_database_file(), config_lock)
dbus_service = DBusService('openmotics_service')
controller_serial = Serial(controller_serial_port, 115200)
power_serial = RS485(Serial(power_serial_port, 115200, timeout=None))
master_communicator = MasterCommunicator(controller_serial)
eeprom_controller = EepromController(
EepromFile(master_communicator),
EepromExtension(constants.get_eeprom_extension_database_file())
)
if passthrough_serial_port:
passthrough_serial = Serial(passthrough_serial_port, 115200)
passthrough_service = PassthroughService(master_communicator, passthrough_serial)
passthrough_service.start()
power_controller = PowerController(constants.get_power_database_file())
power_communicator = PowerCommunicator(power_serial, power_controller)
pulse_controller = PulseCounterController(
constants.get_pulse_counter_database_file(),
master_communicator,
eeprom_controller
)
observer = Observer(master_communicator, dbus_service)
gateway_api = GatewayApi(master_communicator, power_communicator, power_controller, eeprom_controller, pulse_controller, dbus_service, observer, config_controller)
observer.set_gateway_api(gateway_api)
scheduling_controller = SchedulingController(constants.get_scheduling_database_file(), config_lock, gateway_api)
maintenance_service = MaintenanceService(gateway_api, constants.get_ssl_private_key_file(),
constants.get_ssl_certificate_file())
web_interface = WebInterface(user_controller, gateway_api, maintenance_service, dbus_service,
config_controller, scheduling_controller)
scheduling_controller.set_webinterface(web_interface)
# Plugins
plugin_controller = PluginController(web_interface, config_controller)
web_interface.set_plugin_controller(plugin_controller)
gateway_api.set_plugin_controller(plugin_controller)
# Metrics
metrics_cache_controller = MetricsCacheController(constants.get_metrics_database_file(), threading.Lock())
metrics_collector = MetricsCollector(gateway_api, pulse_controller)
metrics_controller = MetricsController(plugin_controller, metrics_collector, metrics_cache_controller, config_controller, gateway_uuid)
metrics_collector.set_controllers(metrics_controller, plugin_controller)
metrics_controller.add_receiver(metrics_controller.receiver)
metrics_controller.add_receiver(web_interface.distribute_metric)
plugin_controller.set_metrics_controller(metrics_controller)
plugin_controller.set_metrics_collector(metrics_collector)
web_interface.set_metrics_collector(metrics_collector)
web_interface.set_metrics_controller(metrics_controller)
web_service = WebService(web_interface, config_controller)
plugin_controller.set_webservice(web_service)
observer.subscribe_master(Observer.MasterEvents.INPUT_TRIGGER, metrics_collector.on_input)
observer.subscribe_master(Observer.MasterEvents.INPUT_TRIGGER, plugin_controller.process_input_status)
observer.subscribe_master(Observer.MasterEvents.ON_OUTPUTS, metrics_collector.on_output)
observer.subscribe_master(Observer.MasterEvents.ON_OUTPUTS, plugin_controller.process_output_status)
observer.subscribe_master(Observer.MasterEvents.ON_SHUTTER_UPDATE, plugin_controller.process_shutter_status)
observer.subscribe_events(web_interface.process_observer_event)
led_thread = threading.Thread(target=led_driver, args=(dbus_service, master_communicator, power_communicator))
led_thread.setName("Serial led driver thread")
led_thread.daemon = True
led_thread.start()
master_communicator.start()
observer.start()
power_communicator.start()
metrics_controller.start()
scheduling_controller.start()
metrics_collector.start()
web_service.start()
gateway_api.start()
plugin_controller.start()
signal_request = {'stop': False}
def stop(signum, frame):
""" This function is called on SIGTERM. """
_ = signum, frame
log('Stopping service...')
web_service.stop()
metrics_collector.stop()
metrics_controller.stop()
plugin_controller.stop()
log('Stopping service... Done')
signal_request['stop'] = True
signal(SIGTERM, stop)
log('Starting service... Done')
while not signal_request['stop']:
time.sleep(1)