OpenOrchestrator 1.3.0__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

OpenOrchestrator/orchestrator/application.py

@@ -10,29 +10,32 @@ from OpenOrchestrator.orchestrator.tabs.settings_tab import SettingsTab
 from OpenOrchestrator.orchestrator.tabs.logging_tab import LoggingTab
 from OpenOrchestrator.orchestrator.tabs.constants_tab import ConstantTab
 from OpenOrchestrator.orchestrator.tabs.queue_tab import QueueTab
+from OpenOrchestrator.orchestrator.tabs.schedulers_tab import SchedulerTab
 
 
 class Application():
     """The main application of Orchestrator.
     It contains a header and the four tabs of the application.
     """
-    def __init__(self) -> None:
+    def __init__(self, port: int | None = None, show: bool = True) -> None:
         with ui.header():
             with ui.tabs() as self.tabs:
-                ui.tab('Triggers')
-                ui.tab('Logs')
-                ui.tab('Constants')
-                ui.tab('Queues')
-                ui.tab('Settings')
+                ui.tab('Triggers').props("auto-id=trigger_tab")
+                ui.tab('Logs').props("auto-id=logs_tab")
+                ui.tab('Constants').props("auto-id=constants_tab")
+                ui.tab('Schedulers').props("auto-id=schedulers_tab")
+                ui.tab('Queues').props("auto-id=queues_tab")
+                ui.tab('Settings').props("auto-id=settings_tab")
 
             ui.space()
             ui.button(icon="contrast", on_click=ui.dark_mode().toggle)
-            ui.button(icon='refresh', on_click=self.update_tab)
+            ui.button(icon='refresh', on_click=self.update_tab).props("auto-id=refresh_button")
 
         with ui.tab_panels(self.tabs, value='Settings', on_change=self.update_tab).classes('w-full') as self.tab_panels:
             self.t_tab = TriggerTab('Triggers')
             self.l_tab = LoggingTab("Logs")
             self.c_tab = ConstantTab("Constants")
+            self.s_tab = SchedulerTab("Schedulers")
             self.q_tab = QueueTab("Queues")
             SettingsTab('Settings')
 
@@ -41,7 +44,7 @@ class Application():
         app.on_connect(self.update_loop)
         app.on_disconnect(app.shutdown)
         app.on_exception(lambda exc: ui.notify(exc, type='negative'))
-        ui.run(title="Orchestrator", favicon='🤖', native=False, port=get_free_port(), reload=False)
+        ui.run(title="Orchestrator", favicon='🤖', native=False, port=port or get_free_port(), reload=False, show=show)
 
     def update_tab(self):
         """Update the date in the currently selected tab."""
@@ -52,6 +55,8 @@ class Application():
                 self.l_tab.update()
             case 'Constants':
                 self.c_tab.update()
+            case 'Schedulers':
+                self.s_tab.update()
             case 'Queues':
                 self.q_tab.update()
 

OpenOrchestrator/orchestrator/datetime_input.py

@@ -43,7 +43,7 @@ class DatetimeInput(ui.input):
 
     def _define_validation(self, allow_empty: bool):
         if not allow_empty:
-            self.validation = {
+            self._validation = {  # pylint: disable=protected-access
                 "Please enter a datetime": bool,
                 f"Invalid datetime: {self.PY_FORMAT}": lambda v: self.get_datetime() is not None
             }
@@ -55,7 +55,7 @@ class DatetimeInput(ui.input):
 
                 return self.get_datetime() is not None
 
-            self.validation = {f"Invalid datetime: {self.PY_FORMAT}": validate}
+            self._validation = {f"Invalid datetime: {self.PY_FORMAT}": validate}  # pylint: disable=protected-access
 
     def get_datetime(self) -> datetime | None:
         """Get the text from the input as a datetime object, if

OpenOrchestrator/orchestrator/popups/constant_popup.py

@@ -8,12 +8,13 @@ from nicegui import ui
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.constants import Constant
 from OpenOrchestrator.orchestrator.popups.generic_popups import question_popup
+from OpenOrchestrator.orchestrator import test_helper
 
 if TYPE_CHECKING:
     from OpenOrchestrator.orchestrator.tabs.constants_tab import ConstantTab
 
 
-# pylint: disable-next=too-few-public-methods
+# pylint: disable-next=too-few-public-methods, too-many-instance-attributes
 class ConstantPopup():
     """A popup for creating/updating queue triggers."""
     def __init__(self, constant_tab: ConstantTab, constant: Constant | None = None):
@@ -34,19 +35,20 @@ class ConstantPopup():
             self.value_input = ui.input("Constant Value").classes("w-full")
 
             with ui.row():
-                ui.button(button_text, on_click=self._create_constant)
-                ui.button("Cancel", on_click=self.dialog.close)
+                self.save_button = ui.button(button_text, on_click=self._create_constant)
+                self.cancel_button = ui.button("Cancel", on_click=self.dialog.close)
 
                 if constant:
-                    ui.button("Delete", color='red', on_click=self._delete_constant)
+                    self.delete_button = ui.button("Delete", color='red', on_click=self._delete_constant)
 
         self._define_validation()
         self._pre_populate()
+        test_helper.set_automation_ids(self, "constant_popup")
 
     def _define_validation(self):
         """Define validation rules for input elements."""
-        self.name_input.validation = {"Please enter a name": bool}
-        self.value_input.validation = {"Please enter a value": bool}
+        self.name_input._validation = {"Please enter a name": bool}  # pylint: disable=protected-access
+        self.value_input._validation = {"Please enter a value": bool}  # pylint: disable=protected-access
 
     def _pre_populate(self):
         """Pre populate the inputs with an existing constant."""

OpenOrchestrator/orchestrator/popups/credential_popup.py

@@ -8,12 +8,13 @@ from nicegui import ui
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.constants import Credential
 from OpenOrchestrator.orchestrator.popups.generic_popups import question_popup
+from OpenOrchestrator.orchestrator import test_helper
 
 if TYPE_CHECKING:
     from OpenOrchestrator.orchestrator.tabs.constants_tab import ConstantTab
 
 
-# pylint: disable-next=too-few-public-methods
+# pylint: disable-next=too-few-public-methods, too-many-instance-attributes
 class CredentialPopup():
     """A popup for creating/updating queue triggers."""
     def __init__(self, constant_tab: ConstantTab, credential: Credential | None = None):
@@ -36,20 +37,21 @@ class CredentialPopup():
             self.password_input = ui.input("Password").classes("w-full")
 
             with ui.row():
-                ui.button(button_text, on_click=self._save_credential)
-                ui.button("Cancel", on_click=self.dialog.close)
+                self.save_button = ui.button(button_text, on_click=self._save_credential)
+                self.cancel_button = ui.button("Cancel", on_click=self.dialog.close)
 
                 if credential:
-                    ui.button("Delete", color='red', on_click=self._delete_credential)
+                    self.delete_button = ui.button("Delete", color='red', on_click=self._delete_credential)
 
         self._define_validation()
         self._pre_populate()
+        test_helper.set_automation_ids(self, "credential_popup")
 
     def _define_validation(self):
         """Define validation functions for ui elements."""
-        self.name_input.validation = {"Please enter a name": bool}
-        self.username_input.validation = {"Please enter a username": bool}
-        self.password_input.validation = {"Please enter a password": bool}
+        self.name_input._validation = {"Please enter a name": bool}  # pylint: disable=protected-access
+        self.username_input._validation = {"Please enter a username": bool}  # pylint: disable=protected-access
+        self.password_input._validation = {"Please enter a password": bool}  # pylint: disable=protected-access
 
     def _pre_populate(self):
         """Pre populate the inputs with an existing credential."""
@@ -76,7 +78,7 @@ class CredentialPopup():
         else:
             # Check if credential already exists
             try:
-                db_util.get_credential(name)
+                db_util.get_credential(name, decrypt_password=False)
                 exists = True
             except ValueError:
                 exists = False

OpenOrchestrator/orchestrator/popups/generic_popups.py

@@ -21,7 +21,20 @@ async def question_popup(question: str, option1: str, option2: str, color1: str
     with ui.dialog(value=True).props('persistent') as dialog, ui.card():
         ui.label(question).classes("text-lg")
         with ui.row():
-            ui.button(option1, on_click=lambda e: dialog.submit(True), color=color1)
-            ui.button(option2, on_click=lambda e: dialog.submit(False), color=color2)
+            ui.button(option1, on_click=lambda e: dialog.submit(True), color=color1).props("auto-id=popup_option1_button")
+            ui.button(option2, on_click=lambda e: dialog.submit(False), color=color2).props("auto-id=popup_option2_button")
 
         return await dialog
+
+
+async def info_popup(text: str) -> None:
+    """Show a generic popup with the given text.
+
+    Args:
+        text: The text to display in the popup.
+    """
+    with ui.dialog(value=True).props('persistent') as dialog, ui.card():
+        ui.label(text).classes("text-lg")
+        ui.button("Close", on_click=lambda e: dialog.submit(True)).props("auto-id=popup_button")
+
+        await dialog

OpenOrchestrator/orchestrator/popups/trigger_popup.py

@@ -3,14 +3,16 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 from datetime import datetime
+import json
 
 from nicegui import ui
-from croniter import croniter, CroniterBadCronError  # type: ignore
+from cronsim import CronSim, CronSimError
 
 from OpenOrchestrator.orchestrator.datetime_input import DatetimeInput
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.triggers import Trigger, TriggerStatus, TriggerType, ScheduledTrigger, SingleTrigger, QueueTrigger
 from OpenOrchestrator.orchestrator.popups import generic_popups
+from OpenOrchestrator.orchestrator import test_helper
 
 if TYPE_CHECKING:
     from OpenOrchestrator.orchestrator.tabs.trigger_tab import TriggerTab
@@ -48,39 +50,42 @@ class TriggerPopup():
             self.path_input = ui.input("Process Path").classes("w-full")
             self.git_check = ui.checkbox("Is path a Git Repo?")
             self.args_input = ui.input("Process Arguments").classes("w-full")
-            self.blocking_check = ui.checkbox("Is process blocking?")
+            self.blocking_check = ui.checkbox(text="Is process blocking?", value=True)
+            self.priority_input = ui.number("Priority", value=0, precision=0, format="%.0f")
+            self.whitelist_input = ui.input_chips("Scheduler whitelist").classes("w-full")
 
             if trigger:
                 with ui.row():
-                    ui.button("Enable", on_click=self._enable_trigger)
-                    ui.button("Disable", on_click=self._disable_trigger)
-                    ui.button("Delete", on_click=self._delete_trigger, color='red')
+                    self.enable_button = ui.button("Enable", on_click=self._enable_trigger)
+                    self.disable_button = ui.button("Disable", on_click=self._disable_trigger)
+                    self.delete_button = ui.button("Delete", on_click=self._delete_trigger, color='red')
             else:
                 # Dialog should only be persistent when a new trigger is being created
                 self.dialog.props('persistent')
 
             with ui.row():
-                ui.button("Save", on_click=self._create_trigger)
-                ui.button("Cancel", on_click=self.dialog.close)
+                self.save_button = ui.button("Save", on_click=self._create_trigger)
+                self.cancel_button = ui.button("Cancel", on_click=self.dialog.close)
 
         self._disable_unused()
         self._define_validation()
         self._pre_populate()
+        test_helper.set_automation_ids(self, "trigger_popup")
 
     def _define_validation(self):
-        self.trigger_input.validation = {"Please enter a trigger name": bool}
-        self.name_input.validation = {"Please enter a process name": bool}
-        self.path_input.validation = {"Please enter a process path": bool}
-        self.queue_input.validation = {"Please enter a queue name": bool}
+        self.trigger_input._validation = {"Please enter a trigger name": bool}  # pylint: disable=protected-access
+        self.name_input._validation = {"Please enter a process name": bool}  # pylint: disable=protected-access
+        self.path_input._validation = {"Please enter a process path": bool}  # pylint: disable=protected-access
+        self.queue_input._validation = {"Please enter a queue name": bool}  # pylint: disable=protected-access
 
         def validate_cron(value: str):
             try:
-                croniter(value)
+                CronSim(value, datetime.now())
                 return True
-            except CroniterBadCronError:
+            except CronSimError:
                 return False
 
-        self.cron_input.validation = {"Invalid cron expression": validate_cron}
+        self.cron_input._validation = {"Invalid cron expression": validate_cron}  # pylint: disable=protected-access
 
     def _pre_populate(self):
         """Populate the form with values from an existing trigger"""
@@ -93,6 +98,8 @@ class TriggerPopup():
         self.args_input.value = self.trigger.process_args
         self.git_check.value = self.trigger.is_git_repo
         self.blocking_check.value = self.trigger.is_blocking
+        self.priority_input.value = self.trigger.priority
+        self.whitelist_input.value = json.loads(self.trigger.scheduler_whitelist)
 
         if isinstance(self.trigger, ScheduledTrigger):
             self.cron_input.value = self.trigger.cron_expr
@@ -118,8 +125,8 @@ class TriggerPopup():
 
     def _cron_change(self):
         if self.cron_input.validate():
-            cron_iter = croniter(self.cron_input.value, datetime.now())
-            self.time_input.set_datetime(cron_iter.next(datetime))
+            cron_iter = CronSim(self.cron_input.value, datetime.now())
+            self.time_input.set_datetime(next(cron_iter))
 
     async def _validate(self) -> bool:
         result = True
@@ -163,15 +170,17 @@ class TriggerPopup():
         args = self.args_input.value
         is_git = self.git_check.value
         is_blocking = self.blocking_check.value
+        priority = self.priority_input.value
+        whitelist = self.whitelist_input.value
 
         if self.trigger is None:
             # Create new trigger in database
             if self.trigger_type == TriggerType.SINGLE:
-                db_util.create_single_trigger(trigger_name, process_name, next_run, path, args, is_git, is_blocking)
+                db_util.create_single_trigger(trigger_name, process_name, next_run, path, args, is_git, is_blocking, priority, whitelist)
             elif self.trigger_type == TriggerType.SCHEDULED:
-                db_util.create_scheduled_trigger(trigger_name, process_name, cron_expr, next_run, path, args, is_git, is_blocking)
+                db_util.create_scheduled_trigger(trigger_name, process_name, cron_expr, next_run, path, args, is_git, is_blocking, priority, whitelist)
             elif self.trigger_type == TriggerType.QUEUE:
-                db_util.create_queue_trigger(trigger_name, process_name, queue_name, path, args, is_git, is_blocking, min_batch_size)
+                db_util.create_queue_trigger(trigger_name, process_name, queue_name, path, args, is_git, is_blocking, min_batch_size, priority, whitelist)
 
             ui.notify("Trigger created", type='positive')
         else:
@@ -182,6 +191,8 @@ class TriggerPopup():
             self.trigger.process_args = args
             self.trigger.is_git_repo = is_git
             self.trigger.is_blocking = is_blocking
+            self.trigger.priority = priority
+            self.trigger.scheduler_whitelist = json.dumps(whitelist)
 
             if isinstance(self.trigger, SingleTrigger):
                 self.trigger.next_run = next_run

OpenOrchestrator/orchestrator/tabs/constants_tab.py

@@ -6,6 +6,7 @@ from nicegui import ui
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.orchestrator.popups.constant_popup import ConstantPopup
 from OpenOrchestrator.orchestrator.popups.credential_popup import CredentialPopup
+from OpenOrchestrator.orchestrator import test_helper
 
 CONSTANT_COLUMNS = ("Constant Name", "Value", "Last Changed")
 CREDENTIAL_COLUMNS = ("Credential Name", "Username", "Password", "Last Changed")
@@ -16,8 +17,8 @@ class ConstantTab():
     def __init__(self, tab_name: str) -> None:
         with ui.tab_panel(tab_name):
             with ui.row():
-                ui.button("New Constant", icon='add', on_click=lambda e: ConstantPopup(self))
-                ui.button("New Credential", icon='add', on_click=lambda e: CredentialPopup(self))
+                self.constant_button = ui.button("New Constant", icon='add', on_click=lambda e: ConstantPopup(self))
+                self.credential_button = ui.button("New Credential", icon='add', on_click=lambda e: CredentialPopup(self))
 
             columns = [{'name': label, 'label': label, 'field': label, 'align': 'left', 'sortable': True} for label in CONSTANT_COLUMNS]
             self.constants_table = ui.table(title="Constants", columns=columns, rows=[], row_key='Constant Name', pagination=10).classes("w-full")
@@ -27,6 +28,8 @@ class ConstantTab():
             self.credentials_table = ui.table(title="Credentials", columns=columns, rows=[], row_key='Credential Name', pagination=10).classes("w-full")
             self.credentials_table.on('rowClick', self.row_click_credential)
 
+        test_helper.set_automation_ids(self, "constants_tab")
+
     def row_click_constant(self, event):
         """Callback for when a row is clicked in the table."""
         row = event.args[1]

OpenOrchestrator/orchestrator/tabs/logging_tab.py

@@ -6,6 +6,7 @@ from nicegui import ui
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.logs import LogLevel
 from OpenOrchestrator.orchestrator.datetime_input import DatetimeInput
+from OpenOrchestrator.orchestrator import test_helper
 
 
 COLUMNS = [
@@ -32,6 +33,8 @@ class LoggingTab():
             self.logs_table = ui.table(title="Logs", columns=COLUMNS, rows=[], row_key='ID', pagination=50).classes("w-full")
             self.logs_table.on("rowClick", self._row_click)
 
+        test_helper.set_automation_ids(self, "logs_tab")
+
     def update(self):
         """Update the logs table and Process input list"""
         self._update_table()

OpenOrchestrator/orchestrator/tabs/queue_tab.py

@@ -6,6 +6,7 @@ from nicegui import ui
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.queues import QueueStatus
 from OpenOrchestrator.orchestrator.datetime_input import DatetimeInput
+from OpenOrchestrator.orchestrator import test_helper
 
 
 QUEUE_COLUMNS = [
@@ -37,6 +38,7 @@ class QueueTab():
         with ui.tab_panel(tab_name):
             self.queue_table = ui.table(title="Queues", columns=QUEUE_COLUMNS, rows=[], row_key='Queue Name', pagination={'rowsPerPage': 50, 'sortBy': 'Queue Name'}).classes("w-full")
             self.queue_table.on("rowClick", self._row_click)
+        test_helper.set_automation_ids(self, "queues_tab")
 
     def update(self):
         """Update the queue table with data from the database."""
@@ -85,11 +87,12 @@ class QueuePopup():
                 ui.switch("Dense", on_change=lambda e: self._dense_table(e.value))
                 self._create_column_filter()
                 ui.button(icon='refresh', on_click=self._update)
-                ui.button(icon="close", on_click=dialog.close)
+                self.close_button = ui.button(icon="close", on_click=dialog.close)
             with ui.scroll_area().classes("h-full"):
                 self.table = ui.table(columns=ELEMENT_COLUMNS, rows=[], row_key='ID', title=queue_name, pagination=100).classes("w-full")
 
         self._update()
+        test_helper.set_automation_ids(self, "queue_popup")
 
     def _dense_table(self, value: bool):
         """Change if the table is dense or not."""

OpenOrchestrator/orchestrator/tabs/schedulers_tab.py

@@ -0,0 +1,45 @@
+"""This module is responsible for the layout and functionality of the Schedulers tab
+in Orchestrator."""
+
+from nicegui import ui
+
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.orchestrator import test_helper
+
+COLUMNS = [
+    {'name': "machine_name", 'label': "Machine Name", 'field': "Machine Name", 'align': 'left', 'sortable': True},
+    {'name': "last_connection", 'label': "Last Connection", 'field': "Last Connection", 'align': 'left', 'sortable': True},
+    {'name': "latest_trigger", 'label': "Latest Trigger", 'field': "Latest Trigger", 'align': 'left', 'sortable': True},
+    {'name': "latest_trigger_time", 'label': "Latest Trigger Time", 'field': "Latest Trigger Time", 'align': 'left', 'sortable': True},
+]
+
+
+class SchedulerTab():
+    """A class for the scheduler tab."""
+    def __init__(self, tab_name: str) -> None:
+        with ui.tab_panel(tab_name):
+            self.schedulers_table = ui.table(title="Schedulers", columns=COLUMNS, rows=[], row_key='Machine Name', pagination=50).classes("w-full")
+            self.add_column_colors()
+        test_helper.set_automation_ids(self, "schedulers_tab")
+
+    def update(self):
+        """Updates the tables on the tab."""
+        schedulers = db_util.get_schedulers()
+        self.schedulers_table.rows = [s.to_row_dict() for s in schedulers]
+        self.schedulers_table.update()
+
+    def add_column_colors(self):
+        """Add red coloring to the scheduler if more than a minute has passed since last ping."""
+        self.schedulers_table.add_slot(
+            "body-cell-last_connection",
+            '''
+            <q-td key="last_connection" :props="props">
+                <q-badge v-if="(new Date() - new Date(+props.value.substr(6,4), +props.value.substr(3,2)-1, +props.value.substr(0,2), +props.value.substr(11,2), +props.value.substr(14,2))) > 60 * 1000" color='red'>
+                    {{props.value}}
+                </q-badge>
+                <p v-else>
+                    {{props.value}}
+                </p>
+            </q-td>
+            '''
+        )

OpenOrchestrator/orchestrator/tabs/settings_tab.py

@@ -3,8 +3,8 @@ in Orchestrator."""
 
 from nicegui import ui
 
-from OpenOrchestrator.database import db_util
 from OpenOrchestrator.common.connection_frame import ConnectionFrame
+from OpenOrchestrator.orchestrator import test_helper
 
 
 # pylint: disable-next=too-few-public-methods
@@ -15,8 +15,5 @@ class SettingsTab():
             conn_frame = ConnectionFrame()
             with ui.row().classes("w-full"):
                 self.key_button = ui.button("Generate Key", on_click=conn_frame.new_key)
-                self.init_button = ui.button("Initialize Database", on_click=self._init_database)
 
-    def _init_database(self):
-        db_util.initialize_database()
-        ui.notify("Database initialized!", type='positive')
+        test_helper.set_automation_ids(self, "settings_tab")

OpenOrchestrator/orchestrator/tabs/trigger_tab.py

@@ -6,9 +6,11 @@ from nicegui import ui
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.triggers import SingleTrigger, ScheduledTrigger, QueueTrigger, TriggerType
 from OpenOrchestrator.orchestrator.popups.trigger_popup import TriggerPopup
+from OpenOrchestrator.orchestrator import test_helper
 
 COLUMNS = [
     {'name': "Trigger Name", 'label': "Trigger Name", 'field': "Trigger Name", 'align': 'left', 'sortable': True},
+    {'name': "Priority", 'label': "Priority", 'field': "Priority", 'align': 'left', 'sortable': True, ':sort': '(a, b, rowA, rowB) => b-a'},
     {'name': "Type", 'label': "Type", 'field': "Type", 'align': 'left', 'sortable': True},
     {'name': "Status", 'label': "Status", 'field': "Status", 'align': 'left', 'sortable': True},
     {'name': "Process Name", 'label': "Process Name", 'field': "Process Name", 'align': 'left', 'sortable': True},
@@ -24,14 +26,16 @@ class TriggerTab():
     def __init__(self, tab_name: str) -> None:
         with ui.tab_panel(tab_name):
             with ui.row():
-                ui.button("New Single Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.SINGLE))
-                ui.button("New Scheduled Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.SCHEDULED))
-                ui.button("New Queue Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.QUEUE))
+                self.single_button = ui.button("New Single Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.SINGLE))
+                self.scheduled_button = ui.button("New Scheduled Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.SCHEDULED))
+                self.queue_button = ui.button("New Queue Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.QUEUE))
 
-            self.trigger_table = ui.table(COLUMNS, [], title="Triggers", pagination={'rowsPerPage': 50, 'sortBy': 'Trigger Name'}, row_key='ID').classes("w-full")
+            self.trigger_table = ui.table(columns=COLUMNS, rows=[], title="Triggers", pagination={'rowsPerPage': 50, 'sortBy': 'Trigger Name'}, row_key='ID').classes("w-full")
             self.trigger_table.on('rowClick', self._row_click)
             self.add_column_colors()
 
+        test_helper.set_automation_ids(self, "trigger_tab")
+
     def _row_click(self, event):
         """Callback for when a row is clicked in the table."""
         row = event.args[1]
@@ -58,7 +62,7 @@ class TriggerTab():
             "body-cell-Status",
             '''
             <q-td key="Status" :props="props">
-                <q-badge v-if="{Running: 'green', Pausing: 'orange', Failed: 'red'}[props.value]" :color="{Running: 'green', Pausing: 'orange', Failed: 'red'}[props.value]">
+                <q-badge v-if="{Running: 'green', Pausing: 'orange', Paused: 'orange', Failed: 'red'}[props.value]" :color="{Running: 'green', Pausing: 'orange', Paused: 'orange', Failed: 'red'}[props.value]">
                     {{props.value}}
                 </q-badge>
                 <p v-else>

OpenOrchestrator/orchestrator/test_helper.py

@@ -0,0 +1,17 @@
+"""This module contains helper functions for automated tests."""
+
+from nicegui import ui
+
+
+def set_automation_ids(container, prefix: str):
+    """Set automation ids for automated tests.
+    Iterate though all attributes of the container and set 'auto-id'
+    on any ui-elements.
+
+    Args:
+        container: The object that contains a number of ui-elements.
+        prefix: The prefix to add to the automation ids for all elements.
+    """
+    for name, obj in container.__dict__.items():
+        if isinstance(obj, (ui.button, ui.input, ui.checkbox, ui.number, ui.table, ui.tab, ui.select, ui.input_chips)):
+            obj.props(f"auto-id={prefix}_{name}")

OpenOrchestrator/orchestrator_connection/connection.py

@@ -10,6 +10,7 @@ from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.queues import QueueElement, QueueStatus
 from OpenOrchestrator.database.logs import LogLevel
 from OpenOrchestrator.database.constants import Constant, Credential
+from OpenOrchestrator.database.triggers import TriggerStatus
 
 
 class OrchestratorConnection:
@@ -19,16 +20,18 @@ class OrchestratorConnection:
     to instead of initializing the object manually.
     """
 
-    def __init__(self, process_name: str, connection_string: str, crypto_key: str, process_arguments: str):
+    def __init__(self, process_name: str, connection_string: str, crypto_key: str, process_arguments: str, trigger_id: str):
         """
         Args:
             process_name: A human friendly tag to identify the process.
-            connection_string: An ODBC connection to the OpenOrchestrator database
-            crypto_key: Secret key for decrypting database content
+            connection_string: An ODBC connection to the OpenOrchestrator database.
+            crypto_key: Secret key for decrypting database content.
             process_arguments (optional): Arguments for the controlling how the process should run.
+            trigger_id: ID of trigger used to start this process.
         """
         self.process_name = process_name
         self.process_arguments = process_arguments
+        self.trigger_id = trigger_id
         crypto_util.set_key(crypto_key)
         db_util.connect(connection_string)
 
@@ -188,6 +191,19 @@ class OrchestratorConnection:
         """
         db_util.delete_queue_element(element_id)
 
+    def is_trigger_pausing(self) -> bool:
+        """Check if my trigger is pausing.
+
+        Returns:
+            bool: Whether or not the trigger used to start this process is pausing.
+        """
+        my_trigger = db_util.get_trigger(self.trigger_id)
+        return my_trigger.process_status in (TriggerStatus.PAUSING, TriggerStatus.PAUSED)
+
+    def pause_my_trigger(self) -> None:
+        """Pause the trigger used to start this process."""
+        db_util.set_trigger_status(self.trigger_id, TriggerStatus.PAUSING)
+
     @classmethod
     def create_connection_from_args(cls):
         """Create a Connection object using the arguments passed to sys.argv.
@@ -196,4 +212,5 @@ class OrchestratorConnection:
         connection_string = sys.argv[2]
         crypto_key = sys.argv[3]
         process_arguments = sys.argv[4]
-        return OrchestratorConnection(process_name, connection_string, crypto_key, process_arguments)
+        trigger_id = sys.argv[5]
+        return OrchestratorConnection(process_name, connection_string, crypto_key, process_arguments, trigger_id)

OpenOrchestrator/scheduler/application.py

@@ -3,6 +3,7 @@ that when created starts the application."""
 
 import tkinter
 from tkinter import ttk, messagebox
+
 from OpenOrchestrator.scheduler import settings_tab, run_tab
 
 
@@ -27,10 +28,10 @@ class Application(tkinter.Tk):
         notebook.pack(expand=True, fill='both')
 
         run_tab_ = run_tab.RunTab(notebook, self)
-        settings_tab_ = settings_tab.create_tab(notebook)
+        self.settings_tab_ = settings_tab.SettingsTab(notebook)
 
         notebook.add(run_tab_, text='Run')
-        notebook.add(settings_tab_, text="Settings")
+        notebook.add(self.settings_tab_, text="Settings")
 
         notebook.select(1)
 

OpenOrchestrator/scheduler/run_tab.py

@@ -12,7 +12,7 @@ from sqlalchemy import exc as alc_exc
 
 from OpenOrchestrator.common import crypto_util
 from OpenOrchestrator.database import db_util
-from OpenOrchestrator.scheduler import runner
+from OpenOrchestrator.scheduler import runner, util
 
 if TYPE_CHECKING:
     from OpenOrchestrator.scheduler.application import Application
@@ -111,13 +111,15 @@ def loop(app: Application) -> None:
         app: The Scheduler Application object.
     """
     try:
+        send_ping_to_orchestrator()
+
         check_heartbeats(app)
 
         if app.running:
             check_triggers(app)
 
-    except alc_exc.OperationalError:
-        print("Couldn't connect to database.")
+    except (alc_exc.OperationalError, alc_exc.ProgrammingError) as e:
+        print(f"Couldn't connect to database. {e}")
 
     if len(app.running_jobs) == 0:
         print("Doing cleanup...")
@@ -169,7 +171,15 @@ def check_triggers(app: Application) -> None:
     # Check triggers
     if not blocking:
         print('Checking triggers...')
-        job = runner.poll_triggers(app)
+        trigger = runner.poll_triggers(app)
+
+        if trigger:
+            job = runner.run_trigger(trigger)
+
+            if job:
+                app.running_jobs.append(job)
+
 
-        if job is not None:
-            app.running_jobs.append(job)
+def send_ping_to_orchestrator():
+    """Send a ping to the connected Orchestrator with the Scheduler application's name."""
+    db_util.send_ping_from_scheduler(util.get_scheduler_name())