alarm.cxx

Go to the documentation of this file.

/********************************************************************\
 
  Name:         ALARM.C
  Created by:   Stefan Ritt
 
  Contents:     MIDAS alarm functions
 
  $Id$
 
\********************************************************************/
 
#include "midas.h"
#include "msystem.h"
#include "mstrlcpy.h"
#include "odbxx.h"
#include <assert.h>
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/********************************************************************\
*                                                                    *
*                     Alarm functions                                *
*                                                                    *
\********************************************************************/
 
/********************************************************************/
static BOOL al_evaluate_single_condition(const char* alarm_name, const char *condition, std::string *pvalue)
{
   int i, j, size, status;
 
   //char str[256];
   //strcpy(str, condition);
 
   std::vector<char> buf;
   buf.insert(buf.end(), condition, condition+strlen(condition)+1);
   char* str = buf.data();
 
   /* find value and operator */
   char op[3];
   op[0] = op[1] = op[2] = 0;
   for (i = strlen(str) - 1; i > 0; i--)
      if (strchr("<>=!&", str[i]) != NULL)
         break;
   op[0] = str[i];
   for (j = 1; str[i + j] == ' '; j++)
      ;
 
   std::string value2_str = str + i + j;
   double      value2 = atof(value2_str.c_str());
 
   str[i] = 0;
 
   if (i > 0 && strchr("<>=!&", str[i - 1])) {
      op[1] = op[0];
      op[0] = str[--i];
      str[i] = 0;
   }
 
   i--;
   while (i > 0 && str[i] == ' ')
      i--;
   str[i + 1] = 0;
 
   /* check if function */
   std::string function;
   if (str[i] == ')') {
      str[i--] = 0;
      if (strchr(str, '(')) {
         *strchr(str, '(') = 0;
         function = str;
         for (i = strlen(str) + 1, j = 0; str[i]; i++, j++)
            str[j] = str[i];
         str[j] = 0;
         i = j - 1;
      }
   }
 
   std::vector<int> indices;
   bool index_present = false;
 
   // process indices
   if (strchr(str, '[') && str[strlen(str)-1] == ']') {
      index_present = true;
 
      // Remove the square brackets from the string
      std::string cleanInput = strchr(str, '[') + 1;
      cleanInput.pop_back();
 
      // Remove index from str
      *strchr(str, '[') = 0;
 
      // retrieve key
      if (!midas::odb::exists(str)) {
         cm_msg(MERROR, "al_evaluate_condition", "Alarm \"%s\": Cannot find ODB key \"%s\" to evaluate alarm condition", alarm_name, str);
         if (pvalue)
            *pvalue = "(cannot find in odb)";
         return FALSE;
      }
      midas::odb k((const char *)str);
 
      // Split the string by commas
      std::stringstream ss(cleanInput);
      std::string token;
      while (std::getline(ss, token, ',')) {
         // Remove whitespace
         token.erase(std::remove_if(token.begin(), token.end(), ::isspace), token.end());
 
         // Check if token is "*", if so set all indices
         if (token == "*") {
            for (int i = 0; i < k.get_num_values(); ++i)
               indices.push_back(i);
         } else {
            // Check if the token represents a range (e.g., "4-7")
            auto dashPos = token.find('-');
            if (dashPos != std::string::npos) {
               // Extract the start and end of the range
               int start = std::stoi(token.substr(0, dashPos));
               int end = std::stoi(token.substr(dashPos + 1));
 
               // Add all numbers in the range [start, end]
               for (int i = start; i <= end; ++i) {
                  indices.push_back(i);
               }
            } else {
               // It's a single number, add it to the list
               indices.push_back(std::stoi(token));
            }
         }
      }
   }
 
   HNDLE hDB, hkey;
   cm_get_experiment_database(&hDB, NULL);
   db_find_key(hDB, 0, str, &hkey);
   if (!hkey) {
      cm_msg(MERROR, "al_evaluate_condition", "Alarm \"%s\": Cannot find ODB key \"%s\" to evaluate alarm condition", alarm_name, str);
      if (pvalue)
         *pvalue = "(cannot find in odb)";
      return FALSE;
   }
 
   KEY key;
   db_get_key(hDB, hkey, &key);
 
   //printf("Alarm \"%s\": [%s], idx1 %d, idx2 %d, op [%s], value2 [%s] %g, function [%s]\n", alarm_name, condition, idx1, idx2, op, value2_str.c_str(), value2, function.c_str());
 
   // put at least one value into the indices
   if (indices.empty())
      indices.push_back(0);
 
   // go through all indices
   for (int idx : indices) {
      std::string value1_str;
      double value1 = 0;
 
      if (equal_ustring(function.c_str(), "access")) {
         /* check key access time */
         DWORD dtime;
         db_get_key_time(hDB, hkey, &dtime);
         value1_str = msprintf("%d", dtime);
         value1 = atof(value1_str.c_str());
      } else if (equal_ustring(function.c_str(), "access_running")) {
         /* check key access time if running */
         DWORD dtime;
         db_get_key_time(hDB, hkey, &dtime);
         int state = 0;
         size = sizeof(state);
         db_get_value(hDB, 0, "/Runinfo/State", &state, &size, TID_INT, FALSE);
         if (state == STATE_RUNNING) {
            value1_str = msprintf("%d", dtime);
            value1 = atof(value1_str.c_str());
         } else {
            value1_str = "0";
            value1 = 0;
         }
      } else {
         /* get key data and convert to double */
         status = db_get_key(hDB, hkey, &key);
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "al_evaluate_condition", "Alarm \"%s\": Cannot get ODB key \"%s\" to evaluate alarm condition", alarm_name, str);
            if (pvalue)
               *pvalue = "(odb error)";
            return FALSE;
         } else {
            char data[256];
            size = sizeof(data);
            status = db_get_data_index(hDB, hkey, data, &size, idx, key.type);
            if (status != DB_SUCCESS) {
               cm_msg(MERROR, "al_evaluate_condition", "Alarm \"%s\": Cannot get ODB value \"%s\" index %d to evaluate alarm condition", alarm_name, str, idx);
               if (pvalue)
                  *pvalue = "(odb error)";
               return FALSE;
            }
 
            value1_str = db_sprintf(data, size, 0, key.type);
            value1 = atof(value1_str.c_str());
         }
      }
 
      /* convert boolean values to integers */
      if (key.type == TID_BOOL) {
         value1 = (value1_str[0] == 'Y' || value1_str[0] == 'y' || value1_str[0] == '1');
         value2 = (value2_str[0] == 'Y' || value2_str[0] == 'y' || value2_str[0] == '1');
      }
      
      /* return value */
      if (pvalue) {
         if (index_present)
            *pvalue = msprintf("[%d] %s", idx, value1_str.c_str());
         else
            *pvalue = value1_str;
      }
      
      /* now do logical operation */
      if (strcmp(op, "=") == 0)
         if (value1 == value2)
            return TRUE;
      if (strcmp(op, "==") == 0)
         if (value1 == value2)
            return TRUE;
      if (strcmp(op, "!=") == 0)
         if (value1 != value2)
            return TRUE;
      if (strcmp(op, "<") == 0)
         if (value1 < value2)
            return TRUE;
      if (strcmp(op, ">") == 0)
         if (value1 > value2)
            return TRUE;
      if (strcmp(op, "<=") == 0)
         if (value1 <= value2)
            return TRUE;
      if (strcmp(op, ">=") == 0)
         if (value1 >= value2)
            return TRUE;
      if (strcmp(op, "&") == 0)
         if (((unsigned int) value1 & (unsigned int) value2) > 0)
            return TRUE;
   }
 
   return FALSE;
}
 
/********************************************************************/
BOOL al_evaluate_condition(const char* alarm_name, const char *condition, std::string *pvalue)
{
   auto trim = [](const std::string& s) {
      size_t first = s.find_first_not_of(" \t\r\n");
      if (first == std::string::npos)
         return std::string();
      size_t last = s.find_last_not_of(" \t\r\n");
      return s.substr(first, last - first + 1);
   };
 
   auto invalid_condition = [alarm_name, pvalue](const char* condition) {
      cm_msg(MERROR, "al_evaluate_condition", "Alarm \"%s\": Invalid alarm condition \"%s\"",
             alarm_name, condition ? condition : "");
      if (pvalue)
         *pvalue = "(invalid condition)";
      return FALSE;
   };
 
   if (condition == nullptr || trim(condition).empty())
      return invalid_condition(condition);
 
   std::string expression(condition);
   std::vector<std::vector<std::string>> groups;
   size_t or_begin = 0;
 
   // Split into OR groups and AND terms before evaluating anything, so
   // malformed expressions are reported even if short-circuiting would
   // otherwise skip the malformed part.
   while (or_begin <= expression.size()) {
      size_t or_end = expression.find("||", or_begin);
      std::string group = expression.substr(or_begin, or_end - or_begin);
      if (trim(group).empty())
         return invalid_condition(condition);
 
      std::vector<std::string> terms;
      size_t and_begin = 0;
      while (and_begin <= group.size()) {
         size_t and_end = group.find("&&", and_begin);
         std::string term = trim(group.substr(and_begin, and_end - and_begin));
         if (term.empty())
            return invalid_condition(condition);
         terms.push_back(term);
         if (and_end == std::string::npos)
            break;
         and_begin = and_end + 2;
      }
      groups.push_back(terms);
 
      if (or_end == std::string::npos)
         break;
      or_begin = or_end + 2;
   }
 
   std::string all_values;
   bool expression_result = false;
 
   // Evaluate all terms so callers can display one current value per
   // condition. Values are returned as one newline-separated string.
   for (const auto& group : groups) {
      bool group_result = true;
      for (const auto& term : group) {
         std::string term_value;
         BOOL term_result = al_evaluate_single_condition(alarm_name, term.c_str(), &term_value);
         if (!term_result)
            group_result = false;
         if (!all_values.empty())
            all_values += "\n";
         all_values += term_value;
      }
      if (group_result)
         expression_result = true;
   }
 
   if (pvalue)
      *pvalue = all_values;
 
   return expression_result;
}
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
static midas::odb al_make_alarm_odb(bool periodic = false)
{
   std::string time_triggered(31, '\0');
   std::string condition(255, '\0');
   std::string alarm_class = periodic ? "Warning" : "Alarm";
   std::string alarm_message = periodic ? "Please do your shift checks" : "Run number became too large";
   alarm_class.resize(31, '\0');
   alarm_message.resize(79, '\0');
 
   midas::odb alarm = {
      {"Active", false},
      {"Triggered", 0},
      {"Type", periodic ? AT_PERIODIC : AT_EVALUATED},
      {"Check interval", periodic ? 28800 : 60},
      {"Checked last", (uint32_t)0},
      {"Trigger count", (uint32_t)0},
      {"Trigger count required", (uint32_t)0},
      {"Time triggered first", time_triggered},
      {"Time triggered last", time_triggered},
      {"Condition", condition},
      {"Alarm Class", alarm_class},
      {"Alarm Message", alarm_message}
   };
 
   if (!periodic) {
      condition.replace(0, strlen("/Runinfo/Run number > 100"), "/Runinfo/Run number > 100");
      alarm["Condition"].set(condition);
   }
 
   return alarm;
}
 
/********************************************************************/
INT al_trigger_alarm(const char *alarm_name, const char *alarm_message, const char *default_class, const char *cond_str,
                     INT type) {
   if (rpc_is_remote())
      return rpc_call(RPC_AL_TRIGGER_ALARM, alarm_name, alarm_message, default_class, cond_str, type);
 
#ifdef LOCAL_ROUTINES
   {
      int size;
      HNDLE hDB, hkey;
      BOOL flag;
 
      cm_get_experiment_database(&hDB, NULL);
 
      /* check online mode */
      flag = TRUE;
      size = sizeof(flag);
      db_get_value(hDB, 0, "/Runinfo/Online Mode", &flag, &size, TID_INT, TRUE);
      if (!flag)
         return AL_SUCCESS;
 
      /* find alarm */
      std::string alarm_path = msprintf("/Alarms/Alarms/%s", alarm_name);
 
      bool new_alarm = !midas::odb::exists(alarm_path);
      midas::odb alarm = al_make_alarm_odb();
      alarm.connect_and_fix_structure(alarm_path);
      if (new_alarm) {
         /* alarm must be an internal analyzer alarm, so create a default alarm */
         if (default_class && default_class[0])
            alarm["Alarm Class"] = default_class;
         alarm["Active"] = true;
      }
 
      /* set parameters for internal alarms */
      if (type != AT_EVALUATED && type != AT_PERIODIC) {
         alarm["Type"] = type;
         alarm["Condition"] = cond_str;
      }
 
      int alarm_type = alarm["Type"];
 
      /* if internal alarm, check if active and check interval */
      if (alarm_type != AT_EVALUATED && alarm_type != AT_PERIODIC) {
         /* check global alarm flag */
         flag = TRUE;
         size = sizeof(flag);
         db_get_value(hDB, 0, "/Alarms/Alarm system active", &flag, &size, TID_BOOL, TRUE);
         if (!flag)
            return AL_SUCCESS;
 
         if (!(bool)alarm["Active"])
            return AL_SUCCESS;
 
         DWORD checked_last = alarm["Checked last"];
         int check_interval = alarm["Check interval"];
         if ((INT) ss_time() - (INT) checked_last < check_interval)
            return AL_SUCCESS;
      }
 
      std::string alarm_class = alarm["Alarm Class"];
      if (alarm_type == AT_PROGRAM) {
         /* alarm class of "program not running" alarms is set in two places,
          * complain if they do not match */
         if (!equal_ustring(alarm_class.c_str(), default_class)) {
            cm_msg(MERROR, "al_trigger_alarm",
                   "Program alarm class mismatch: \"%s/Alarm class\" set to \"%s\" does not match \"/Programs/%s/Alarm "
                   "Class\" set to \"%s\"",
                   alarm_path.c_str(), alarm_class.c_str(), alarm_name, default_class);
         }
      }
 
      /* write back alarm message for internal alarms */
      if (alarm_type != AT_EVALUATED && alarm_type != AT_PERIODIC)
         alarm["Alarm Message"] = alarm_message;
 
      /* now trigger alarm class defined in this alarm */
      int triggered = alarm["Triggered"];
      if (!alarm_class.empty())
         al_trigger_class(alarm_class.c_str(), alarm_message, triggered > 0);
 
      /* check for and trigger "All" class */
      if (db_find_key(hDB, 0, "/Alarms/Classes/All", &hkey) == DB_SUCCESS)
         al_trigger_class("All", alarm_message, triggered > 0);
 
      /* signal alarm being triggered */
      std::string now = cm_asctime();
 
      if (!triggered)
         alarm["Time triggered first"] = now;
 
      alarm["Triggered"] = ++triggered;
      alarm["Time triggered last"] = now;
      alarm["Checked last"] = (uint32_t)ss_time();
   }
#endif /* LOCAL_ROUTINES */
 
   return AL_SUCCESS;
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
/********************************************************************/
INT al_trigger_class(const char *alarm_class, const char *alarm_message, BOOL first)
/********************************************************************\
 
  Routine: al_trigger_class
 
  Purpose: Trigger a certain alarm class
 
  Input:
    char   *alarm_class     Alarm class, must be defined in
                            /alarms/classes
    char   *alarm_message   Optional message which goes with alarm
    BOOL   first            TRUE if alarm is triggered first time
                            (used for elog)
 
  Output:
 
  Function value:
    AL_INVALID_NAME         Alarm class not defined
    AL_SUCCESS              Successful completion
 
\********************************************************************/
{
   int size, state;
   HNDLE hDB;
   DWORD now = ss_time();
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* get alarm class */
   std::string alarm_path = msprintf("/Alarms/Classes/%s", alarm_class);
   if (!midas::odb::exists(alarm_path)) {
      cm_msg(MERROR, "al_trigger_class", "Alarm class \"%s\" for alarm \"%s\" not found in ODB", alarm_class, alarm_message);
      return AL_INVALID_NAME;
   }
 
   midas::odb ac(alarm_path);
 
   std::string msg;
 
   /* write system message */
   bool write_system_message = ac["Write system message"];
   int system_message_interval = ac["System message interval"];
   DWORD system_message_last = ac["System message last"];
   if (write_system_message && (now - system_message_last >= (DWORD) system_message_interval)) {
      if (equal_ustring(alarm_class, "All"))
         msg = msprintf("General alarm: %s", alarm_message);
      else
         msg = msprintf("%s: %s", alarm_class, alarm_message);
      cm_msg(MTALK, "al_trigger_class", "%s", msg.c_str());
      system_message_last = now;
      ac["System message last"] = (uint32_t)system_message_last;
   }
 
   /* write elog message on first trigger if using internal ELOG */
   if ((bool)ac["Write Elog message"] && first) {
      BOOL external_elog = FALSE;
      size = sizeof(external_elog);
      db_get_value(hDB, 0, "/Elog/External Elog", &external_elog, &size, TID_BOOL, FALSE);
      if (!external_elog) {
         char tag[32];
         tag[0] = 0;
         el_submit(0, "Alarm system", "Alarm", "General", alarm_class, msg.c_str(), "", "plain", "", "", 0, "", "", 0, "", "", 0, tag, sizeof(tag));
      }
   }
 
   /* execute command */
   std::string execute_command = ac["Execute command"];
   int execute_interval = ac["Execute interval"];
   DWORD execute_last = ac["Execute last"];
   if (!execute_command.empty() && execute_interval > 0 && (INT) ss_time() - (INT) execute_last > execute_interval) {
      if (equal_ustring(alarm_class, "All"))
         msg = msprintf("General alarm: %s", alarm_message);
      else
         msg = msprintf("%s: %s", alarm_class, alarm_message);
      std::string command = msprintf(execute_command.c_str(), msg.c_str());
      cm_msg(MINFO, "al_trigger_class", "Execute: %s", command.c_str());
      ss_system(command.c_str());
      execute_last = ss_time();
      ac["Execute last"] = (uint32_t)execute_last;
   }
 
   /* stop run */
   if ((bool)ac["Stop run"]) {
      state = STATE_STOPPED;
      size = sizeof(state);
      db_get_value(hDB, 0, "/Runinfo/State", &state, &size, TID_INT, TRUE);
      if (state != STATE_STOPPED) {
         cm_msg(MINFO, "al_trigger_class", "Stopping the run from alarm class \'%s\', message \'%s\'", alarm_class,
                alarm_message);
         cm_transition(TR_STOP, 0, NULL, 0, TR_DETACH, FALSE);
      }
   }
 
   return AL_SUCCESS;
}
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
/********************************************************************/
INT al_reset_alarm(const char *alarm_name) {
   int i;
   HNDLE hDB, hkeyalarm, hsubkey;
   KEY key;
 
   cm_get_experiment_database(&hDB, NULL);
 
   if (alarm_name == NULL) {
      /* reset all alarms */
      db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyalarm);
      if (hkeyalarm) {
         for (i = 0;; i++) {
            db_enum_link(hDB, hkeyalarm, i, &hsubkey);
 
            if (!hsubkey)
               break;
 
            db_get_key(hDB, hsubkey, &key);
            al_reset_alarm(key.name);
         }
      }
      return AL_SUCCESS;
   }
 
   /* find alarm and alarm class */
   std::string str = msprintf("/Alarms/Alarms/%s", alarm_name);
   db_find_key(hDB, 0, str.c_str(), &hkeyalarm);
   if (!hkeyalarm) {
      /*cm_msg(MERROR, "al_reset_alarm", "Alarm %s not found in ODB", alarm_name);*/
      return AL_INVALID_NAME;
   }
 
   midas::odb alarm = al_make_alarm_odb();
   alarm.connect_and_fix_structure(str);
 
   std::string alarm_class = alarm["Alarm Class"];
   str = msprintf("/Alarms/Classes/%s", alarm_class.c_str());
   if (!midas::odb::exists(str)) {
      cm_msg(MERROR, "al_reset_alarm", "Alarm class %s not found in ODB", alarm_class.c_str());
      return AL_INVALID_NAME;
   }
 
   midas::odb ac(str);
 
   int triggered = alarm["Triggered"];
   if (triggered) {
      int alarm_type = alarm["Type"];
      if (alarm_type == AT_PERIODIC) {
 
         // set checked_last to occurrence of alarm, to get exactly one period until next alarm
 
         struct tm tm_time;
         memset(&tm_time, 0, sizeof(tm_time));
 
         std::string time_triggered_first = alarm["Time triggered first"];
         strptime(time_triggered_first.c_str(), "%a %b %d %H:%M:%S %Y", &tm_time);
         time_t t = mktime(&tm_time);
 
         int check_interval = alarm["Check interval"];
         while ((int)ss_time() > t + check_interval)
            t += check_interval;
 
         alarm["Checked last"] = (uint32_t)t;
      } else {
         alarm["Checked last"] = (uint32_t)0;
      }
 
      alarm["Triggered"] = 0;
      alarm["Time triggered first"] = "";
      alarm["Time triggered last"] = "";
      alarm["Trigger count"] = (uint32_t)0;
 
      ac["System message last"] = (uint32_t)0;
      ac["Execute last"] = (uint32_t)0;
 
      cm_msg(MINFO, "al_reset_alarm", "Alarm \"%s\" reset", alarm_name);
      return AL_RESET;
   }
 
   return AL_SUCCESS;
}
 
/********************************************************************/
INT al_check() {
   if (rpc_is_remote()) {
      return rpc_call(RPC_AL_CHECK);
   }
 
#ifdef LOCAL_ROUTINES
   {
      INT status, size, semaphore;
      HNDLE hDB, hkeyroot, hkey;
      KEY key;
      //char str[256];
      BOOL flag;
 
      cm_get_experiment_database(&hDB, NULL);
 
      if (hDB == 0)
         return AL_SUCCESS; /* called from server not yet connected */
 
      /* check online mode */
      flag = TRUE;
      size = sizeof(flag);
      db_get_value(hDB, 0, "/Runinfo/Online Mode", &flag, &size, TID_INT, TRUE);
      if (!flag)
         return AL_SUCCESS;
 
      /* check global alarm flag */
      flag = TRUE;
      size = sizeof(flag);
      db_get_value(hDB, 0, "/Alarms/Alarm system active", &flag, &size, TID_BOOL, TRUE);
      if (!flag)
         return AL_SUCCESS;
 
      /* request semaphore */
      cm_get_experiment_semaphore(&semaphore, NULL, NULL, NULL);
      status = ss_semaphore_wait_for(semaphore, 100);
      if (status == SS_TIMEOUT)
         return AL_SUCCESS; /* someone else is doing alarm business */
      if (status != SS_SUCCESS) {
         fprintf(stderr, "al_check: Something is wrong with our semaphore, ss_semaphore_wait_for() returned %d, aborting.\n", status);
         // abort(); // DOES NOT RETURN
         // NOT REACHED
         fprintf(stderr, "al_check: Cannot abort - this will lock you out of odb. From this point, MIDAS will not work correctly. Please read the discussion at https://midas.triumf.ca/elog/Midas/945\n");
         return AL_SUCCESS;
      }
 
      /* check ODB alarms */
      db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyroot);
      if (!hkeyroot) {
         /* create default ODB alarm */
         midas::odb demo_odb = al_make_alarm_odb();
         demo_odb.connect("/Alarms/Alarms/Demo ODB");
 
         db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyroot);
         if (!hkeyroot) {
            ss_semaphore_release(semaphore);
            return AL_SUCCESS;
         }
 
         midas::odb demo_periodic = al_make_alarm_odb(true);
         demo_periodic.connect("/Alarms/Alarms/Demo periodic");
 
         db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyroot);
         if (!hkeyroot) {
            ss_semaphore_release(semaphore);
            return AL_SUCCESS;
         }
 
         /* create default alarm classes */
         midas::odb alarm = {
            {"Write system message", true},
            {"Write Elog message", false},
            {"System message interval", 60},
            {"System message last", (uint32_t)0},
            {"Execute command", ""},
            {"Execute interval", 0},
            {"Execute last", (uint32_t)0},
            {"Stop run", false},
            {"Display BGColor", "red"},
            {"Display FGColor", "black"},
            {"Alarm sound", true}
         };
         auto warning = alarm;
         alarm.connect("/Alarms/Classes/Alarm");
         warning["Display BGColor"] = "yellow";
         warning.connect("/Alarms/Classes/Warning");
      }
 
      for (int i = 0;; i++) {
         status = db_enum_key(hDB, hkeyroot, i, &hkey);
         if (status == DB_NO_MORE_SUBKEYS)
            break;
 
         db_get_key(hDB, hkey, &key);
 
         std::string alarm_path = "/Alarms/Alarms/" + std::string(key.name);
         midas::odb alarm = al_make_alarm_odb();
         alarm.connect_and_fix_structure(alarm_path);
 
         int alarm_type = alarm["Type"];
         if (alarm_type < 1 || alarm_type > AT_LAST) {
            cm_msg(MERROR, "al_check", "Alarm \"%s\" has invalid type %d", key.name, alarm_type);
            continue;
         }
 
         bool active = alarm["Active"];
         int check_interval = alarm["Check interval"];
         DWORD checked_last = alarm["Checked last"];
 
         /* check periodic alarm only when active */
         if (active && alarm_type == AT_PERIODIC && check_interval > 0 && (INT) ss_time() - (INT) checked_last > check_interval) {
            /* if checked_last has not been set, set it to current time */
            if (checked_last == 0) {
               checked_last = ss_time();
               alarm["Checked last"] = checked_last;
            } else {
               std::string alarm_message = alarm["Alarm Message"];
               std::string alarm_class = alarm["Alarm Class"];
               al_trigger_alarm(key.name, alarm_message.c_str(), alarm_class.c_str(), "", AT_PERIODIC);
            }
         }
 
         /* check alarm only when active and not internal */
         if (active && alarm_type == AT_EVALUATED && check_interval > 0 && (INT) ss_time() - (INT) checked_last > check_interval) {
            /* if condition is true, trigger alarm */
            std::string condition = alarm["Condition"];
            std::string value;
            if (al_evaluate_condition(key.name, condition.c_str(), &value)) {
               alarm["Checked last"] = (uint32_t)ss_time();
               DWORD trigger_count = alarm["Trigger count"];
               DWORD trigger_count_required = alarm["Trigger count required"];
               alarm["Trigger count"] = ++trigger_count;
               if (trigger_count >= trigger_count_required) {
                  alarm["Trigger count"] = (uint32_t)0;
 
                  std::string str = alarm["Alarm Message"];
                  size_t value_pos = str.find("%s");
                  if (value_pos != std::string::npos)
                     str.replace(value_pos, 2, value);
                  if (trigger_count_required > 0)
                     str += " (for more than " + std::to_string(trigger_count_required) + "*" +
                        std::to_string(check_interval) + " seconds)";
                  std::string alarm_class = alarm["Alarm Class"];
                  al_trigger_alarm(key.name, str.c_str(), alarm_class.c_str(), "", AT_EVALUATED);
               }
            } else {
               alarm["Checked last"] = (uint32_t)ss_time();
               alarm["Trigger count"] = (uint32_t)0;
            }
         }
      }
 
      /* check /programs alarms */
      db_find_key(hDB, 0, "/Programs", &hkeyroot);
      if (hkeyroot) {
         for (int i = 0;; i++) {
            status = db_enum_key(hDB, hkeyroot, i, &hkey);
            if (status == DB_NO_MORE_SUBKEYS)
               break;
 
            db_get_key(hDB, hkey, &key);
 
            /* don't check "execute on xxx" */
            if (key.type != TID_KEY)
               continue;
 
            midas::odb program_info("/Programs/" + std::string(key.name));
 
            time_t now = ss_time();
 
            // get name of this client
            std::string name = rpc_get_name();
            std::string str = name;
 
            // truncate name of this client to the length of program name in /Programs/xxx
            // to get rid if "odbedit1", "odbedit2", etc.
            str.resize(strlen(key.name));
 
            //printf("str [%s], key.name [%s]\n", str.c_str(), key.name);
 
            // cm_exist() must be called with bUnique set to FALSE because we want
            // the "program is not running" alarm check all
            // alternative names "client", "client1", "client2", etc. K.O. Aug 2026
 
            if (!equal_ustring(str.c_str(), key.name) && cm_exist(key.name, FALSE) == CM_NO_CLIENT) {
               DWORD first_failed = program_info["First failed"];
               if (first_failed == 0) {
                  first_failed = (DWORD) now;
                  program_info["First failed"] = first_failed;
               }
 
               // printf("check %d-%d = %d >= %d\n", now, program_info.first_failed, now - program_info.first_failed,
               // program_info.check_interval / 1000);
 
               /* fire alarm when not running for more than what specified in check interval */
               DWORD check_interval = program_info["Check interval"];
               if (now - first_failed >= check_interval / 1000) {
                  /* if not running and alarm class defined, trigger alarm */
                  std::string alarm_class = program_info["Alarm class"];
                  if (!alarm_class.empty()) {
                     std::string str = msprintf("Program %s is not running", key.name);
                     al_trigger_alarm(key.name, str.c_str(), alarm_class.c_str(), "Program not running", AT_PROGRAM);
                  }
 
                  /* auto restart program */
                  bool auto_restart = program_info["Auto restart"];
                  std::string start_command = program_info["Start command"];
                  if (auto_restart && !start_command.empty()) {
                     ss_system(start_command.c_str());
                     program_info["First failed"] = (uint32_t)0;
                     cm_msg(MTALK, "al_check", "Program %s restarted", key.name);
                  }
               }
            } else {
               DWORD first_failed = program_info["First failed"];
               if (first_failed != 0)
                  program_info["First failed"] = (uint32_t)0;
            }
         }
      }
 
      ss_semaphore_release(semaphore);
   }
#endif /* LOCAL_COUTINES */
 
   return SUCCESS;
}
 
/********************************************************************/
INT al_get_alarms(std::string *presult)
{
   if (!presult)
      return 0;
 
   HNDLE hDB, hkey;
 
   cm_get_experiment_database(&hDB, NULL);
   presult->clear();
   int n = 0;
   db_find_key(hDB, 0, "/Alarms/Alarms", &hkey);
   if (hkey) {
      /* check global alarm flag */
      int flag = TRUE;
      int size = sizeof(flag);
      db_get_value(hDB, 0, "/Alarms/Alarm System active", &flag, &size, TID_BOOL, FALSE);
      if (flag) {
         for (int i = 0;; i++) {
            HNDLE hsubkey;
 
            db_enum_link(hDB, hkey, i, &hsubkey);
 
            if (!hsubkey)
               break;
 
            KEY key;
            db_get_key(hDB, hsubkey, &key);
 
            flag = 0;
            size = sizeof(flag);
            db_get_value(hDB, hsubkey, "Triggered", &flag, &size, TID_INT, FALSE);
            if (flag) {
               n++;
 
               std::string alarm_class, msg;
               int alarm_type;
 
               db_get_value_string(hDB, hsubkey, "Alarm Class", 0, &alarm_class);
               db_get_value_string(hDB, hsubkey, "Alarm Message", 0, &msg);
 
               size = sizeof(alarm_type);
               db_get_value(hDB, hsubkey, "Type", &alarm_type, &size, TID_INT, FALSE);
 
               std::string str;
 
               if (alarm_type == AT_EVALUATED) {
                  db_get_value_string(hDB, hsubkey, "Condition", 0, &str);
 
                  /* retrieve value */
                  std::string value;
                  al_evaluate_condition(key.name, str.c_str(), &value);
                  str = msprintf(msg.c_str(), value.c_str());
               } else
                  str = msg;
 
               *presult += alarm_class;
               *presult += ": ";
               *presult += str;
               *presult += "\n";
            }
         }
      }
   }
 
   return n;
}
 
/********************************************************************/
INT EXPRT al_define_odb_alarm(const char *name, const char *condition, const char *aclass, const char *message) {
   std::string str = msprintf("/Alarms/Alarms/%s", name);
 
   midas::odb alarm = al_make_alarm_odb();
   alarm.connect(str);
   alarm["Condition"] = condition;
   alarm["Alarm Class"] = aclass;
   alarm["Alarm Message"] = message;
 
   return AL_SUCCESS;
}
 
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */