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

OpenOrchestrator/scheduler/runner.py

@@ -1,14 +1,22 @@
 """This module is responsible for checking triggers and running processes."""
 
+from __future__ import annotations
+from typing import TYPE_CHECKING
 import os
+import shutil
 import subprocess
 from dataclasses import dataclass
 import uuid
+import json
 
 from OpenOrchestrator.common import crypto_util
 from OpenOrchestrator.database import db_util
 from OpenOrchestrator.database.triggers import Trigger, SingleTrigger, ScheduledTrigger, QueueTrigger, TriggerStatus
 from OpenOrchestrator.database.logs import LogLevel
+from OpenOrchestrator.scheduler import util
+
+if TYPE_CHECKING:
+    from OpenOrchestrator.scheduler.application import Application
 
 
 @dataclass
@@ -19,91 +27,64 @@ class Job():
     process_folder: str | None
 
 
-def poll_triggers(app) -> Job | None:
-    """Checks if any triggers are waiting to run. If any the first will be run and a
-    corresponding job object will be returned.
+def poll_triggers(app: Application) -> Trigger | None:
+    """Checks for pending triggers and returns the first viable one.
+    This takes priority and whitelist of the triggers into account.
 
     Args:
         app: The Application object of the Scheduler app.
 
     Returns:
-        Job: A job object describing the job that has been launched, if any else None.
+        The first viable trigger to run if any.
     """
-
-    other_processes_running = len(app.running_jobs) != 0
-
-    # Single triggers
-    next_single_trigger = db_util.get_next_single_trigger()
-
-    if next_single_trigger and not (next_single_trigger.is_blocking and other_processes_running):
-        return run_single_trigger(next_single_trigger)
-
-    # Scheduled triggers
-    next_scheduled_trigger = db_util.get_next_scheduled_trigger()
-
-    if next_scheduled_trigger and not (next_scheduled_trigger.is_blocking and other_processes_running):
-        return run_scheduled_trigger(next_scheduled_trigger)
-
-    # Queue triggers
-    next_queue_trigger = db_util.get_next_queue_trigger()
-
-    if next_queue_trigger and not (next_queue_trigger.is_blocking and other_processes_running):
-        return run_queue_trigger(next_queue_trigger)
+    # Get all pending triggers
+    trigger_list = (
+        db_util.get_pending_single_triggers() +
+        db_util.get_pending_scheduled_triggers() +
+        db_util.get_pending_queue_triggers()
+    )
+
+    # Sort by priority and type
+    # Single > Scheduled > Queue
+    trigger_order = {SingleTrigger: 0, ScheduledTrigger: 1, QueueTrigger: 2}
+    trigger_list.sort(key=lambda t: (-t.priority, trigger_order[type(t)]))
+
+    # Run the first eligible trigger
+    other_jobs_running = len(app.running_jobs) > 0
+    scheduler_name = util.get_scheduler_name()
+    is_exclusive = app.settings_tab_.whitelist_value.get()
+
+    for trigger in trigger_list:
+        trigger_whitelist = json.loads(trigger.scheduler_whitelist)
+        whitelisted = scheduler_name in trigger_whitelist  # Is the Scheduler in the whitelist
+        unlisted_allowed = not is_exclusive and not trigger_whitelist  # Is the scheduler allowed to run non-designated triggers
+
+        if whitelisted or unlisted_allowed:
+            if not (trigger.is_blocking and other_jobs_running):
+                return trigger
 
     return None
 
 
-def run_single_trigger(trigger: SingleTrigger) -> Job | None:
-    """Mark a single trigger as running in the database
+def run_trigger(trigger: Trigger) -> Job | None:
+    """Mark a trigger as running in the database
     and start the process.
 
     Args:
         trigger: The trigger to run.
 
     Returns:
-        Job: A Job object describing the process if successful.
+        A Job object describing the process if successful.
     """
-
     print('Running trigger: ', trigger.trigger_name)
 
-    if db_util.begin_single_trigger(trigger.id):
+    if isinstance(trigger, SingleTrigger) and db_util.begin_single_trigger(trigger.id):
         return run_process(trigger)
 
-    return None
-
-
-def run_scheduled_trigger(trigger: ScheduledTrigger) -> Job | None:
-    """Mark a scheduled trigger as running in the database,
-    calculate the next run datetime,
-    and start the process.
-
-    Args:
-        trigger: The trigger to run.
-
-    Returns:
-        Job: A Job object describing the process if successful.
-    """
-    print('Running trigger: ', trigger.trigger_name)
-
-    if db_util.begin_scheduled_trigger(trigger.id):
+    if isinstance(trigger, ScheduledTrigger) and db_util.begin_scheduled_trigger(trigger.id):
         return run_process(trigger)
 
-    return None
-
-
-def run_queue_trigger(trigger: QueueTrigger) -> Job | None:
-    """Mark a queue trigger as running in the database
-    and start the process.
-
-    Args:
-        trigger: The trigger to run.
-
-    Returns:
-        Job: A Job object describing the process if successful.
-    """
-    print('Running trigger: ', trigger.trigger_name)
-
-    if db_util.begin_queue_trigger(trigger.id):
+    if isinstance(trigger, QueueTrigger) and db_util.begin_queue_trigger(trigger.id):
         return run_process(trigger)
 
     return None
@@ -123,6 +104,10 @@ def clone_git_repo(repo_url: str) -> str:
     repo_path = os.path.join(repo_folder, unique_id)
 
     os.makedirs(repo_path)
+
+    if shutil.which('git') is None:
+        raise RuntimeError('git is not installed or not found in the system PATH.')
+
     try:
         subprocess.run(['git', 'clone', repo_url, repo_path], check=True)
     except subprocess.CalledProcessError as exc:
@@ -232,7 +217,7 @@ def run_process(trigger: Trigger) -> Job | None:
         trigger: The trigger whose process to run.
 
     Returns:
-        Job: A Job object referencing the process if succesful.
+        Job: A Job object referencing the process if successful.
     """
     process_path = trigger.process_path
     folder_path = None
@@ -255,6 +240,9 @@ def run_process(trigger: Trigger) -> Job | None:
 
         process = subprocess.Popen(command_args, stderr=subprocess.PIPE, text=True)  # pylint: disable=consider-using-with
 
+        machine_name = util.get_scheduler_name()
+        db_util.start_trigger_from_machine(machine_name, str(trigger.trigger_name))
+
         return Job(process, trigger, folder_path)
 
     # We actually want to catch any exception here

OpenOrchestrator/scheduler/settings_tab.py

@@ -1,24 +1,100 @@
 """This module is responsible for the layout and functionality of the settings tab
 in Scheduler."""
 
-from tkinter import ttk
+import os
+import tkinter
+from tkinter import ttk, messagebox
 
-from OpenOrchestrator.scheduler.connection_frame import ConnectionFrame
+from OpenOrchestrator.common import crypto_util
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.scheduler import util
 
 
-def create_tab(parent: ttk.Notebook) -> ttk.Frame:
-    """Creates a new Settings tab object.
+# pylint: disable=too-many-ancestors
+class SettingsTab(ttk.Frame):
+    """A ttk.Frame object containing the functionality of the settings tab in Scheduler."""
+    def __init__(self, parent: ttk.Notebook):
+        super().__init__(parent)
+        self.pack(fill='both', expand=True)
 
-    Args:
-        parent (ttk.Notebook): The ttk.Notebook that this tab is a child of.
+        self.columnconfigure(1, weight=1)
 
-    Returns:
-        ttk.Frame: The created tab object as a ttk.Frame.
-    """
-    tab = ttk.Frame(parent)
-    tab.pack(fill='both', expand=True)
+        ttk.Label(self, text="Connection string:").grid(row=0, column=0, sticky='w')
 
-    conn_frame = ConnectionFrame(tab)
-    conn_frame.pack(fill='x')
+        self._conn_entry = ttk.Entry(self)
+        self._conn_entry.grid(row=0, column=1, sticky='ew')
 
-    return tab
+        self._conn_button = ttk.Button(self, text="Connect", command=self._connect)
+        self._conn_button.grid(row=0, column=2, sticky='e')
+
+        ttk.Label(self, text="Encryption key:").grid(row=1, column=0, sticky='w')
+
+        self._key_entry = ttk.Entry(self)
+        self._key_entry.grid(row=1, column=1, sticky='ew')
+
+        self._disconn_button = ttk.Button(self, text="Disconnect", command=self._disconnect, state='disabled')
+        self._disconn_button.grid(row=1, column=2, sticky='e')
+
+        ttk.Label(self, text=f"Scheduler name: {util.get_scheduler_name()}").grid(row=2, column=0, sticky='w', columnspan=2, pady=10)
+
+        self.whitelist_value = tkinter.BooleanVar()
+        self._whitelist_check = ttk.Checkbutton(self, text="Only run whitelisted triggers", variable=self.whitelist_value)
+        self._whitelist_check.grid(row=3, column=0, sticky='w', columnspan=2)
+
+        self._auto_fill()
+
+    def _connect(self) -> None:
+        """Validate the connection string and encryption key
+        and connect to the database.
+        """
+        conn_string = self._conn_entry.get()
+        crypto_key = self._key_entry.get()
+
+        if not crypto_util.validate_key(crypto_key):
+            messagebox.showerror("Invalid encryption key", "The entered encryption key is not a valid AES key.")
+            return
+
+        if db_util.connect(conn_string):
+            crypto_util.set_key(crypto_key)
+            self._set_state(True)
+            if not db_util.check_database_revision():
+                messagebox.showerror("Warning", "This version of Scheduler doesn't match the version of the connected database. Unexpected errors might occur.")
+
+    def _disconnect(self) -> None:
+        db_util.disconnect()
+        crypto_util.set_key(None)
+        self._set_state(False)
+
+    def _set_state(self, connected: bool) -> None:
+        if connected:
+            self._conn_entry.configure(state='disabled')
+            self._key_entry.configure(state='disabled')
+            self._conn_button.configure(state='disabled')
+            self._disconn_button.configure(state='normal')
+            self._whitelist_check.configure(state='disabled')
+        else:
+            self._conn_entry.configure(state='normal')
+            self._key_entry.configure(state='normal')
+            self._conn_button.configure(state='normal')
+            self._disconn_button.configure(state='disabled')
+            self._whitelist_check.configure(state='normal')
+
+    def _auto_fill(self) -> None:
+        """Check the environment for a connection string
+        and encryption key and autofill the inputs.
+        """
+        conn_string = os.environ.get('OpenOrchestratorConnString', None)
+        if conn_string:
+            self._conn_entry.insert(0, conn_string)
+
+        crypto_key = os.environ.get('OpenOrchestratorKey', None)
+        if crypto_key:
+            self._key_entry.insert(0, crypto_key)
+
+    def new_key(self):
+        """Creates a new encryption key and inserts it
+        into the key entry.
+        """
+        key = crypto_util.generate_key().decode()
+        self._key_entry.delete(0, 'end')
+        self._key_entry.insert(0, key)

OpenOrchestrator/scheduler/util.py

@@ -0,0 +1,8 @@
+"""This module contains miscellaneous utility functions."""
+
+import platform
+
+
+def get_scheduler_name():
+    """Get the name of the Scheduler application."""
+    return platform.node()

OpenOrchestrator/tests/db_test_util.py

@@ -0,0 +1,40 @@
+"""This module contains database utility functions used in testing."""
+
+from datetime import datetime, timedelta
+import os
+
+from OpenOrchestrator.database import db_util, base
+
+from OpenOrchestrator.common import crypto_util
+
+
+def establish_clean_database():
+    """Connect to the database, drop all tables and recreate them."""
+    db_util.connect(os.environ["CONN_STRING"])
+    crypto_util.set_key(crypto_util.generate_key().decode())
+
+    drop_all_tables()
+    base.Base.metadata.create_all(db_util._connection_engine)  # pylint: disable=protected-access
+
+
+def drop_all_tables():
+    """Drop all ORM tables from the database."""
+    engine = db_util._connection_engine  # pylint: disable=protected-access
+    if not engine:
+        raise RuntimeError("Not connected to a database.")
+
+    base.Base.metadata.drop_all(engine)
+
+
+def reset_triggers():
+    """Delete all triggers in the database and create a new of each."""
+    for t in db_util.get_all_triggers():
+        db_util.delete_trigger(t.id)
+
+    if len(db_util.get_all_triggers()) != 0:
+        raise RuntimeError("Not all triggers were deleted.")
+
+    next_run = datetime.now() - timedelta(seconds=2)
+    db_util.create_single_trigger("Single", "Process1", next_run, "Path", "Args", False, False, 0, "")
+    db_util.create_scheduled_trigger("Scheduled", "Process1", "0 0 * * *", next_run, "Path", "Args", False, False, 0, "")
+    db_util.create_queue_trigger("Queue", "Process1", "Trigger Queue", "Path", "Args", False, False, 2, 0, "")