NetAlertX/server/api.py

import json
import time
import threading
import datetime

# Register NetAlertX modules 
import conf  
from const import (apiPath, sql_appevents, sql_devices_all, sql_events_pending_alert, sql_settings, sql_plugins_events, sql_plugins_history, sql_plugins_objects,sql_language_strings, sql_notifications_all, sql_online_history, sql_devices_tiles, sql_devices_filters)
from logger import mylog
from helper import write_file, get_setting_value, timeNowTZ
from app_state import updateState
from models.user_events_queue_instance import UserEventsQueueInstance
from messaging.in_app import write_notification

# Import the start_server function
from api_server.api_server_start import start_server 

apiEndpoints = []

# Lock for thread safety
api_lock = threading.Lock()
periodic_write_lock = threading.Lock()
stop_event = threading.Event()  # Event to signal thread termination

#===============================================================================
# API
#===============================================================================
def update_api(db, all_plugins, forceUpdate, updateOnlyDataSources=[], is_ad_hoc_user_event=False):
    mylog('debug', ['[API] Update API starting'])

    # Start periodic write if not running
    start_periodic_write(interval=1)

    # Update app_state.json and retrieve app_state to check if GraphQL server is running
    app_state = updateState()
    
    # Save plugins    
    write_file(apiPath + 'plugins.json', json.dumps({"data": all_plugins}))  

    # Prepare database tables we want to expose 
    dataSourcesSQLs = [
        ["appevents", sql_appevents],        
        ["devices", sql_devices_all],        
        ["events_pending_alert", sql_events_pending_alert],
        ["settings", sql_settings],
        ["plugins_events", sql_plugins_events],
        ["plugins_history", sql_plugins_history],
        ["plugins_objects", sql_plugins_objects],
        ["plugins_language_strings", sql_language_strings],
        ["notifications", sql_notifications_all],
        ["online_history", sql_online_history],
        ["devices_tiles", sql_devices_tiles],
        ["devices_filters", sql_devices_filters],
        ["custom_endpoint", conf.API_CUSTOM_SQL],
    ]

    # Save selected database tables
    for dsSQL in dataSourcesSQLs:
        if not updateOnlyDataSources or dsSQL[0] in updateOnlyDataSources:
            api_endpoint_class(db, forceUpdate, dsSQL[1], apiPath + 'table_' + dsSQL[0] + '.json', is_ad_hoc_user_event)
            
    # Start the GraphQL server
    graphql_port_value = get_setting_value("GRAPHQL_PORT")
    api_token_value = get_setting_value("API_TOKEN")

    # Start GraphQL server if not yet running
    if app_state.graphQLServerStarted == 0:
        if graphql_port_value is not None and len(api_token_value) > 1:
            try:
                graphql_port_value = int(graphql_port_value)  # Ensure port is an integer
                start_server(graphql_port_value, app_state)  # Start the server
            except ValueError:
                mylog('none', [f"[API] Invalid GRAPHQL_PORT value, must be an integer: {graphql_port_value}"])
        else:
            mylog('none', [f"[API] GRAPHQL_PORT or API_TOKEN is not set, will try later."])

#-------------------------------------------------------------------------------
class api_endpoint_class:
    def __init__(self, db, forceUpdate, query, path, is_ad_hoc_user_event=False):        
        global apiEndpoints

        current_time = timeNowTZ()

        self.db = db
        self.query = query
        self.jsonData = db.get_table_as_json(self.query).json
        self.path = path
        self.fileName = path.split('/')[-1]
        self.hash = hash(json.dumps(self.jsonData))
        self.debounce_interval = 3  # Time in seconds to wait before writing
        self.changeDetectedWhen  = None
        # self.last_update_time = current_time - datetime.timedelta(minutes=1)  # Last time data was updated
        self.is_ad_hoc_user_event = is_ad_hoc_user_event
        self.needsUpdate = False

        # Check if the endpoint needs to be updated
        found = False        
        index = 0
        
        # Search previous endpoint states to check if API needs updating
        for endpoint in apiEndpoints:
            # Match SQL and API endpoint path 
            if endpoint.query == self.query and endpoint.path == self.path:
                found = True 
                mylog('trace', [f'[API] api_endpoint_class: Hashes  (file|old|new): ({self.fileName}|{endpoint.hash}|{self.hash})'])
                if endpoint.hash != self.hash:                    
                    self.needsUpdate = True
                    # Only update changeDetectedWhen if it hasn't been set recently
                    if not self.changeDetectedWhen or current_time > (self.changeDetectedWhen + datetime.timedelta(seconds=self.debounce_interval)): 
                        self.changeDetectedWhen = current_time  # Set timestamp for change detection
                    if index < len(apiEndpoints):
                        apiEndpoints[index] = self
                    # check end of bounds and replace
                    if index < len(apiEndpoints):
                        apiEndpoints[index] = self

            index = index + 1

        # needs also an update if new endpoint
        if not found:
            self.needsUpdate = True
            # Only update changeDetectedWhen if it hasn't been set recently
            if not self.changeDetectedWhen or current_time > (self.changeDetectedWhen + datetime.timedelta(seconds=self.debounce_interval)):
                self.changeDetectedWhen = current_time  # Initialize timestamp for new endpoint
            apiEndpoints.append(self)

        # Needs to be called for initial updates
        self.try_write(forceUpdate)

    #----------------------------------------
    def try_write(self, forceUpdate):
        current_time = timeNowTZ()

        # Debugging info to understand the issue 
        # mylog('debug', [f'[API] api_endpoint_class: {self.fileName} is_ad_hoc_user_event {self.is_ad_hoc_user_event} last_update_time={self.last_update_time}, debounce time={self.last_update_time + datetime.timedelta(seconds=self.debounce_interval)}.'])

        # Only attempt to write if the debounce time has passed
        if forceUpdate == True or (self.needsUpdate and (self.changeDetectedWhen is None or current_time > (self.changeDetectedWhen + datetime.timedelta(seconds=self.debounce_interval)))):

            mylog('debug', [f'[API] api_endpoint_class: Writing {self.fileName} after debounce.'])

            write_file(self.path, json.dumps(self.jsonData))

            self.needsUpdate = False            
            self.last_update_time = timeNowTZ()  # Reset last_update_time after writing

            # Update user event execution log
            # mylog('verbose', [f'[API] api_endpoint_class: is_ad_hoc_user_event {self.is_ad_hoc_user_event}'])
            if self.is_ad_hoc_user_event:
                execution_log = UserEventsQueueInstance()
                execution_log.finalize_event("update_api")
                self.is_ad_hoc_user_event = False

        # else:
        #     # Debugging if write is skipped
        #     mylog('trace', [f'[API] api_endpoint_class: Skipping write for {self.fileName}, debounce time not passed.'])



#===============================================================================
# Periodic Write Functions
#===============================================================================
periodic_write_running = False
periodic_write_thread = None

def periodic_write(interval=1):
    """Periodically checks all endpoints for pending writes."""
    global apiEndpoints
    while not stop_event.is_set():
        with api_lock:
            for endpoint in apiEndpoints:
                endpoint.try_write(False)  # Attempt to write each endpoint if necessary
        time.sleep(interval)


def start_periodic_write(interval=1):
    """Start periodic_write if it's not already running."""
    global periodic_write_running, periodic_write_thread

    with periodic_write_lock:
        if not periodic_write_running:
            mylog('trace', ["[API] Starting periodic_write thread."])
            periodic_write_running = True
            periodic_write_thread = threading.Thread(target=periodic_write, args=(interval,), daemon=True)
            periodic_write_thread.start()
        else:
            mylog('trace', ["[API] periodic_write is already running."])

def stop_periodic_write():
    """Stop the periodic_write thread."""
    global periodic_write_running

    with periodic_write_lock:
        if periodic_write_running:
            stop_event.set()
            periodic_write_thread.join()
            periodic_write_running = False
            mylog('trace', ["[API] periodic_write thread stopped."])