/** * Get all plan info. * @return */ struct ast_json* get_plans_all(void) { char* sql; struct ast_json* j_res; struct ast_json* j_tmp; db_res_t* db_res; ast_asprintf(&sql, "select * from plan where in_use=%d;", E_DL_USE_OK); db_res = db_query(sql); ast_free(sql); if(db_res == NULL) { ast_log(LOG_ERROR, "Could not get plan all info.\n"); return NULL; } j_res = ast_json_array_create(); while(1) { j_tmp = db_get_record(db_res); if(j_tmp == NULL) { break; } ast_json_array_append(j_res, j_tmp); } db_free(db_res); return j_res; }
int null_init(HNDLE hkey, void **pinfo) { HNDLE hDB, hkeybd; INT size, status; NULL_INFO *info; /* allocate info structure */ info = calloc(1, sizeof(NULL_INFO)); *pinfo = info; cm_get_experiment_database(&hDB, NULL); /* create NULL settings record */ status = db_create_record(hDB, hkey, "BD", NULL_SETTINGS_STR); if (status != DB_SUCCESS) return FE_ERR_ODB; db_find_key(hDB, hkey, "BD", &hkeybd); size = sizeof(info->settings); db_get_record(hDB, hkeybd, &info->settings, &size, 0); /* open port */ info->fd = null_open(info->settings.device); if (info->fd < 0) return FE_ERR_HW; return SUCCESS; }
INT master_ODB_get() { INT status; HNDLE hKey; char str[MAX_ODB_PATH]; char str_aux[MAX_ODB_PATH]; int size; sprintf(str_aux,"/Equipment/MasterGM2/Settings/Globals"); sprintf(str, str_aux); // create ODB structure /Equipment/%s/Settings if doesn't exist status = db_check_record(hDB, 0, str, MASTER_SETTINGS_ODB_STR, TRUE); if (status != DB_SUCCESS) { cm_msg(MERROR, __FILE__, "Cannot create [%s] entry in ODB, err = %i",str,status); ss_sleep(3000); } // returns key handle "hDB" to ODB name "str" for fast access status = db_find_key(hDB, 0, str, &hKey); if ( status != DB_SUCCESS ) { cm_msg(MERROR, __FILE__, "Cannot find [%s] key in ODB, err = %i",str,status); return FE_ERR_ODB; } // Copy a set of keys from local memory to the database size = sizeof(MASTER_SETTINGS_ODB); db_get_record(hDB, hKey, &master_settings_odb, &size, 0); print(str); return SUCCESS; }
int mscbbus_init(HNDLE hkey, void **pinfo) { HNDLE hDB, hkeybd; INT size, status; MSCBBUS_INFO *info; /* allocate info structure */ info = calloc(1, sizeof(MSCBBUS_INFO)); *pinfo = info; cm_get_experiment_database(&hDB, NULL); /* create MSCBBUS settings record */ status = db_create_record(hDB, hkey, "BD", MSCBBUS_SETTINGS_STR); if (status != DB_SUCCESS) return FE_ERR_ODB; db_find_key(hDB, hkey, "BD", &hkeybd); size = sizeof(info->settings); db_get_record(hDB, hkeybd, &info->settings, &size, 0); /* open port */ // check if ethernet submaster info->fd = mscb_init(info->settings.mscb_device, sizeof(info->settings.mscb_device), info->settings.pwd, FALSE); if (info->fd < 0) return FE_ERR_HW; /* check if scs_210 is alive */ status = mscb_addr(info->fd, MCMD_PING16, info->settings.address, 1); if (status != MSCB_SUCCESS) { if (status == MSCB_SEMAPHORE) printf("MSCB used by other process\n"); else if (status == MSCB_SUBM_ERROR) printf("Error: MSCB Submaster not responding\n"); else printf("MSCB Node %d does not respond\n", info->settings.address); return FE_ERR_HW; } return SUCCESS; }
/** * Get deleted plan info. * @param uuid * @return */ static struct ast_json* get_plan_deleted(const char* uuid) { char* sql; struct ast_json* j_res; db_res_t* db_res; if(uuid == NULL) { ast_log(LOG_WARNING, "Invalid input parameters.\n"); return NULL; } ast_asprintf(&sql, "select * from plan where in_use=%d and uuid=\"%s\";", E_DL_USE_NO, uuid); db_res = db_query(sql); ast_free(sql); if(db_res == NULL) { ast_log(LOG_ERROR, "Could not get plan info. uuid[%s]\n", uuid); return NULL; } j_res = db_get_record(db_res); db_free(db_res); return j_res; }
INT PKey::GetRecord(void *data, INT *size) { return db_get_record(fHDB, fHKey, data, size, 0); }
INT amc13simulator_ODB_get() { INT status; HNDLE hKey; char str[MAX_ODB_PATH]; char str_aux[MAX_ODB_PATH]; int size; sprintf(str_aux,"/Equipment/AMC13Simulator%02d/Settings/Globals",frontend_index); sprintf(str, str_aux, frontend_index); // create ODB structure /Equipment/%s/Settings/Globals if doesn't exist status = db_check_record(hDB, 0, str, AMC13SIMULATOR_SETTINGS_ODB_STR, TRUE); if (status != DB_SUCCESS) { cm_msg(MERROR, __FILE__, "Cannot create [%s] entry in ODB, err = %i",str,status); ss_sleep(3000); } // returns key handle "hDB" to ODB name "str" for fast access status = db_find_key(hDB, 0, str, &hKey); if ( status != DB_SUCCESS ) { cm_msg(MERROR, __FILE__, "Cannot find [%s] key in ODB, err = %i",str,status); return FE_ERR_ODB; } // Copy a set of keys from local memory to the database size = sizeof(AMC13SIMULATOR_SETTINGS_ODB); db_get_record(hDB, hKey, &amc13simulator_settings_odb, &size, 0); dbprintf("%s(%d): %s sync %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.sync ); dbprintf("%s(%d): %s write_root %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.write_root ); dbprintf("%s(%d): %s rider_header %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.rider_header ); dbprintf("%s(%d): %s n_seg_x %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.n_seg_x ); dbprintf("%s(%d): %s n_seg_y %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.n_seg_y ); dbprintf("%s(%d): %s seg_size %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.seg_size ); dbprintf("%s(%d): %s waveform length %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.waveform_length ); dbprintf("%s(%d): %s n_muons_mean %d\n", __func__, __LINE__, str, amc13simulator_settings_odb.n_muons_mean ); dbprintf("%s(%d): %s Emax %f\n", __func__, __LINE__, str, amc13simulator_settings_odb.Emax ); dbprintf("%s(%d): %s Elab_max %f\n", __func__, __LINE__, str, amc13simulator_settings_odb.Elab_max ); dbprintf("%s(%d): %s omega_a %f\n", __func__, __LINE__, str, amc13simulator_settings_odb.omega_a ); dbprintf("%s(%d): %s repeat_first_event %d\n",__func__,__LINE__,str,amc13simulator_settings_odb.repeat_first_event); dbprintf("%s(%d): %s laser_pulse %d\n",__func__,__LINE__,str,amc13simulator_settings_odb.laser_pulse); /* int i; for (i=0; i<AMC13SIMULATOR_NUM; i++) { sprintf(str,"/Equipment/AMC13Simulator%02d/Settings/Channel%02d",frontend_index,i+1); // create ODB structure /Equipment/%s/Settings/Channel%02d if doesn't exist status = db_check_record(hDB, 0, str, AMC13SIMULATOR_CHANNEL_ODB_STR, TRUE); if (status != DB_SUCCESS) { cm_msg(MERROR, __FILE__, "Cannot create [%s] entry in ODB, err = %i",str,status); ss_sleep(3000); } // returns key handle "hDB" to ODB name "str" for fast access status = db_find_key(hDB, 0, str, &hKey); if ( status != DB_SUCCESS ) { cm_msg(MERROR, __FILE__, "Cannot find [%s] key in ODB, err = %i",str,status); return FE_ERR_ODB; } // Copy a set of keys from local memory to the database size = sizeof(AMC13SIMULATOR_CHANNEL_ODB); db_get_record(hDB, hKey, &amc13simulator_channel_odb[i], &size, 0); dbprintf("%s(%d): %s enabled %d\n", __func__, __LINE__, str, amc13simulator_channel_odb[i].enabled ); dbprintf("%s(%d): %s port no %d\n", __func__, __LINE__, str, amc13simulator_channel_odb[i].port_no ); dbprintf("%s(%d): %s ip addr %s\n", __func__, __LINE__, str, amc13simulator_channel_odb[i].ip_addr ); } */ return SUCCESS; }
INT register_equipment(void) { INT index, size, status; char str[256]; EQUIPMENT_INFO *eq_info; EQUIPMENT_STATS *eq_stats; HNDLE hKey; /* get current ODB run state */ size = sizeof(run_state); run_state = STATE_STOPPED; db_get_value(hDB, 0, "/Runinfo/State", &run_state, &size, TID_INT, TRUE); size = sizeof(run_number); run_number = 1; status = db_get_value(hDB, 0, "/Runinfo/Run number", &run_number, &size, TID_INT, TRUE); assert(status == SUCCESS); /* scan EQUIPMENT table from mevb.C */ for (index = 0; equipment[index].name[0]; index++) { eq_info = &equipment[index].info; eq_stats = &equipment[index].stats; if (eq_info->event_id == 0) { printf("\nEvent ID 0 for %s not allowed\n", equipment[index].name); cm_disconnect_experiment(); ss_sleep(5000); exit(0); } /* init status */ equipment[index].status = EB_SUCCESS; sprintf(str, "/Equipment/%s/Common", equipment[index].name); /* get last event limit from ODB */ if (eq_info->eq_type != EQ_SLOW) { db_find_key(hDB, 0, str, &hKey); size = sizeof(double); if (hKey) db_get_value(hDB, hKey, "Event limit", &eq_info->event_limit, &size, TID_DOUBLE, TRUE); } /* Create common subtree */ status = db_check_record(hDB, 0, str, EQUIPMENT_COMMON_STR, TRUE); if (status != DB_SUCCESS) { printf("Cannot check equipment record, status = %d\n", status); ss_sleep(3000); } db_find_key(hDB, 0, str, &hKey); if (equal_ustring(eq_info->format, "FIXED")) equipment[index].format = FORMAT_FIXED; else /* default format is MIDAS */ equipment[index].format = FORMAT_MIDAS; gethostname(eq_info->frontend_host, sizeof(eq_info->frontend_host)); strcpy(eq_info->frontend_name, frontend_name); strcpy(eq_info->frontend_file_name, frontend_file_name); /* set record from equipment[] table in frontend.c */ db_set_record(hDB, hKey, eq_info, sizeof(EQUIPMENT_INFO), 0); /* get record once at the start equipment info */ size = sizeof(EQUIPMENT_INFO); db_get_record(hDB, hKey, eq_info, &size, 0); /*---- Create just the key , leave it empty ---------------------------------*/ sprintf(str, "/Equipment/%s/Variables", equipment[index].name); db_create_key(hDB, 0, str, TID_KEY); db_find_key(hDB, 0, str, &hKey); equipment[index].hkey_variables = hKey; /*---- Create and initialize statistics tree -------------------*/ sprintf(str, "/Equipment/%s/Statistics", equipment[index].name); status = db_check_record(hDB, 0, str, EQUIPMENT_STATISTICS_STR, TRUE); if (status != DB_SUCCESS) { printf("Cannot create/check statistics record, error %d\n", status); ss_sleep(3000); } status = db_find_key(hDB, 0, str, &hKey); if (status != DB_SUCCESS) { printf("Cannot find statistics record, error %d\n", status); ss_sleep(3000); } eq_stats->events_sent = 0; eq_stats->events_per_sec = 0; eq_stats->kbytes_per_sec = 0; /* open hot link to statistics tree */ status = db_open_record(hDB, hKey, eq_stats, sizeof(EQUIPMENT_STATS) , MODE_WRITE, NULL, NULL); if (status != DB_SUCCESS) { cm_msg(MERROR, "register_equipment", "Cannot open statistics record, error %d. Probably other FE is using it", status); ss_sleep(3000); } /*---- open event buffer ---------------------------------------*/ if (eq_info->buffer[0]) { status = bm_open_buffer(eq_info->buffer, 2 * max_event_size, &equipment[index].buffer_handle); if (status != BM_SUCCESS && status != BM_CREATED) { cm_msg(MERROR, "register_equipment", "Cannot open event buffer. Try to reduce EVENT_BUFFER_SIZE in midas.h \ and rebuild the system."); return 0; } if (1) { int level = 0; bm_get_buffer_level(equipment[index].buffer_handle, &level); printf("Buffer %s, level %d, info: \n", eq_info->buffer, level); } /* set the default buffer cache size */ bm_set_cache_size(equipment[index].buffer_handle, 0, SERVER_CACHE_SIZE); } else {
/** Scan ODB for alarms. @return AL_SUCCESS */ INT al_check() { if (rpc_is_remote()) return rpc_call(RPC_AL_CHECK); #ifdef LOCAL_ROUTINES { INT i, status, size, semaphore; HNDLE hDB, hkeyroot, hkey; KEY key; ALARM a; char str[256], value[256]; time_t now; PROGRAM_INFO program_info; BOOL flag; ALARM_CLASS_STR(alarm_class_str); ALARM_ODB_STR(alarm_odb_str); ALARM_PERIODIC_STR(alarm_periodic_str); 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) { printf("al_check: Something is wrong with our semaphore, ss_semaphore_wait_for() returned %d, aborting.\n", status); //abort(); // DOES NOT RETURN printf("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"); // NOT REACHED return AL_SUCCESS; } /* check ODB alarms */ db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyroot); if (!hkeyroot) { /* create default ODB alarm */ status = db_create_record(hDB, 0, "/Alarms/Alarms/Demo ODB", strcomb(alarm_odb_str)); db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyroot); if (!hkeyroot) { ss_semaphore_release(semaphore); return AL_SUCCESS; } status = db_create_record(hDB, 0, "/Alarms/Alarms/Demo periodic", strcomb(alarm_periodic_str)); db_find_key(hDB, 0, "/Alarms/Alarms", &hkeyroot); if (!hkeyroot) { ss_semaphore_release(semaphore); return AL_SUCCESS; } /* create default alarm classes */ status = db_create_record(hDB, 0, "/Alarms/Classes/Alarm", strcomb(alarm_class_str)); status = db_create_record(hDB, 0, "/Alarms/Classes/Warning", strcomb(alarm_class_str)); if (status != DB_SUCCESS) { ss_semaphore_release(semaphore); return AL_SUCCESS; } } for (i = 0;; i++) { status = db_enum_key(hDB, hkeyroot, i, &hkey); if (status == DB_NO_MORE_SUBKEYS) break; db_get_key(hDB, hkey, &key); size = sizeof(a); status = db_get_record(hDB, hkey, &a, &size, 0); if (status != DB_SUCCESS || a.type < 1 || a.type > AT_LAST) { /* make sure alarm record has right structure */ db_check_record(hDB, hkey, "", strcomb(alarm_odb_str), TRUE); size = sizeof(a); status = db_get_record(hDB, hkey, &a, &size, 0); if (status != DB_SUCCESS || a.type < 1 || a.type > AT_LAST) { cm_msg(MERROR, "al_check", "Cannot get alarm record"); continue; } } /* check periodic alarm only when active */ if (a.active && a.type == AT_PERIODIC && a.check_interval > 0 && (INT) ss_time() - (INT) a.checked_last > a.check_interval) { /* if checked_last has not been set, set it to current time */ if (a.checked_last == 0) { a.checked_last = ss_time(); db_set_record(hDB, hkey, &a, size, 0); } else al_trigger_alarm(key.name, a.alarm_message, a.alarm_class, "", AT_PERIODIC); } /* check alarm only when active and not internal */ if (a.active && a.type == AT_EVALUATED && a.check_interval > 0 && (INT) ss_time() - (INT) a.checked_last > a.check_interval) { /* if condition is true, trigger alarm */ if (al_evaluate_condition(a.condition, value)) { sprintf(str, a.alarm_message, value); al_trigger_alarm(key.name, str, a.alarm_class, "", AT_EVALUATED); } else { a.checked_last = ss_time(); status = db_set_value(hDB, hkey, "Checked last", &a.checked_last, sizeof(DWORD), 1, TID_DWORD); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_check", "Cannot change alarm record"); continue; } } } } /* check /programs alarms */ db_find_key(hDB, 0, "/Programs", &hkeyroot); if (hkeyroot) { for (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; size = sizeof(program_info); status = db_get_record(hDB, hkey, &program_info, &size, 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_check", "Cannot get program info record"); continue; } now = ss_time(); rpc_get_name(str); str[strlen(key.name)] = 0; if (!equal_ustring(str, key.name) && cm_exist(key.name, FALSE) == CM_NO_CLIENT) { if (program_info.first_failed == 0) { program_info.first_failed = (DWORD) now; db_set_record(hDB, hkey, &program_info, sizeof(program_info), 0); } /* fire alarm when not running for more than what specified in check interval */ if (now - program_info.first_failed >= program_info.check_interval / 1000) { /* if not running and alarm calss defined, trigger alarm */ if (program_info.alarm_class[0]) { sprintf(str, "Program %s is not running", key.name); al_trigger_alarm(key.name, str, program_info.alarm_class, "Program not running", AT_PROGRAM); } /* auto restart program */ if (program_info.auto_restart && program_info.start_command[0]) { ss_system(program_info.start_command); program_info.first_failed = 0; cm_msg(MTALK, "al_check", "Program %s restarted", key.name); } } } else { if (program_info.first_failed != 0) { program_info.first_failed = 0; db_set_record(hDB, hkey, &program_info, sizeof(program_info), 0); } } } } ss_semaphore_release(semaphore); } #endif /* LOCAL_COUTINES */ return SUCCESS; }
/** Reset (acknoledge) alarm. @param alarm_name Alarm name, defined in /alarms/alarms @return AL_SUCCESS, AL_RESETE, AL_INVALID_NAME */ INT al_reset_alarm(const char *alarm_name) { int status, size, i; HNDLE hDB, hkeyalarm, hkeyclass, hsubkey; KEY key; char str[256]; ALARM a; ALARM_CLASS ac; 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 */ sprintf(str, "/Alarms/Alarms/%s", alarm_name); db_find_key(hDB, 0, str, &hkeyalarm); if (!hkeyalarm) { /*cm_msg(MERROR, "al_reset_alarm", "Alarm %s not found in ODB", alarm_name);*/ return AL_INVALID_NAME; } size = sizeof(a); status = db_get_record(hDB, hkeyalarm, &a, &size, 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_reset_alarm", "Cannot get alarm record"); return AL_ERROR_ODB; } sprintf(str, "/Alarms/Classes/%s", a.alarm_class); db_find_key(hDB, 0, str, &hkeyclass); if (!hkeyclass) { cm_msg(MERROR, "al_reset_alarm", "Alarm class %s not found in ODB", a.alarm_class); return AL_INVALID_NAME; } size = sizeof(ac); status = db_get_record(hDB, hkeyclass, &ac, &size, 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_reset_alarm", "Cannot get alarm class record"); return AL_ERROR_ODB; } if (a.triggered) { a.triggered = 0; a.time_triggered_first[0] = 0; a.time_triggered_last[0] = 0; a.checked_last = 0; ac.system_message_last = 0; ac.execute_last = 0; status = db_set_record(hDB, hkeyalarm, &a, sizeof(a), 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_reset_alarm", "Cannot update alarm record"); return AL_ERROR_ODB; } status = db_set_record(hDB, hkeyclass, &ac, sizeof(ac), 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_reset_alarm", "Cannot update alarm class record"); return AL_ERROR_ODB; } cm_msg(MINFO, "al_reset_alarm", "Alarm \"%s\" reset", alarm_name); return AL_RESET; } return AL_SUCCESS; }
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 status, size, state; HNDLE hDB, hkeyclass; char str[256], command[256], tag[32], url[256]; ALARM_CLASS ac; DWORD now = ss_time(); tag[0] = 0; cm_get_experiment_database(&hDB, NULL); /* get alarm class */ sprintf(str, "/Alarms/Classes/%s", alarm_class); db_find_key(hDB, 0, str, &hkeyclass); if (!hkeyclass) { cm_msg(MERROR, "al_trigger_class", "Alarm class %s not found in ODB", alarm_class); return AL_INVALID_NAME; } size = sizeof(ac); status = db_get_record(hDB, hkeyclass, &ac, &size, 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_trigger_class", "Cannot get alarm class record"); return AL_ERROR_ODB; } /* write system message */ if (ac.write_system_message && (now - ac.system_message_last >= (DWORD)ac.system_message_interval)) { if (equal_ustring(alarm_class, "All")) sprintf(str, "General alarm: %s", alarm_message); else sprintf(str, "%s: %s", alarm_class, alarm_message); cm_msg(MTALK, "al_trigger_class", "%s", str); ac.system_message_last = now; } /* write elog message on first trigger if using internal ELOG */ size = sizeof(url); if (ac.write_elog_message && first && db_get_value(hDB, 0, "/Elog/URL", url, &size, TID_STRING, FALSE) != DB_SUCCESS) el_submit(0, "Alarm system", "Alarm", "General", alarm_class, str, "", "plain", "", "", 0, "", "", 0, "", "", 0, tag, sizeof(tag)); /* execute command */ if (ac.execute_command[0] && ac.execute_interval > 0 && (INT) ss_time() - (INT) ac.execute_last > ac.execute_interval) { if (equal_ustring(alarm_class, "All")) sprintf(str, "General alarm: %s", alarm_message); else sprintf(str, "%s: %s", alarm_class, alarm_message); sprintf(command, ac.execute_command, str); cm_msg(MINFO, "al_trigger_class", "Execute: %s", command); ss_system(command); ac.execute_last = ss_time(); } /* stop run */ if (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); } } status = db_set_record(hDB, hkeyclass, &ac, sizeof(ac), 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_trigger_class", "Cannot update alarm class record"); return AL_ERROR_ODB; } return AL_SUCCESS; }
/** Trigger a certain alarm. \code ... lazy.alarm[0] = 0; size = sizeof(lazy.alarm); db_get_value(hDB, pLch->hKey, "Settings/Alarm Class", lazy.alarm, &size, TID_STRING, TRUE); // trigger alarm if defined if (lazy.alarm[0]) al_trigger_alarm("Tape", "Tape full...load new one!", lazy.alarm, "Tape full", AT_INTERNAL); ... \endcode @param alarm_name Alarm name, defined in /alarms/alarms @param alarm_message Optional message which goes with alarm @param default_class If alarm is not yet defined under /alarms/alarms/\<alarm_name\>, a new one is created and this default class is used. @param cond_str String displayed in alarm condition @param type Alarm type, one of AT_xxx @return AL_SUCCESS, AL_INVALID_NAME */ 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 status, size; HNDLE hDB, hkeyalarm, hkey; char str[256]; ALARM a; BOOL flag; ALARM_ODB_STR(alarm_odb_str); 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 */ sprintf(str, "/Alarms/Alarms/%s", alarm_name); db_find_key(hDB, 0, str, &hkeyalarm); if (!hkeyalarm) { /* alarm must be an internal analyzer alarm, so create a default alarm */ status = db_create_record(hDB, 0, str, strcomb(alarm_odb_str)); db_find_key(hDB, 0, str, &hkeyalarm); if (!hkeyalarm) { cm_msg(MERROR, "al_trigger_alarm", "Cannot create alarm record"); return AL_ERROR_ODB; } if (default_class && default_class[0]) db_set_value(hDB, hkeyalarm, "Alarm Class", default_class, 32, 1, TID_STRING); status = TRUE; db_set_value(hDB, hkeyalarm, "Active", &status, sizeof(status), 1, TID_BOOL); } /* set parameters for internal alarms */ if (type != AT_EVALUATED && type != AT_PERIODIC) { db_set_value(hDB, hkeyalarm, "Type", &type, sizeof(INT), 1, TID_INT); strcpy(str, cond_str); db_set_value(hDB, hkeyalarm, "Condition", str, 256, 1, TID_STRING); } size = sizeof(a); status = db_get_record(hDB, hkeyalarm, &a, &size, 0); if (status != DB_SUCCESS || a.type < 1 || a.type > AT_LAST) { /* make sure alarm record has right structure */ db_check_record(hDB, hkeyalarm, "", strcomb(alarm_odb_str), TRUE); size = sizeof(a); status = db_get_record(hDB, hkeyalarm, &a, &size, 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_trigger_alarm", "Cannot get alarm record"); return AL_ERROR_ODB; } } /* if internal alarm, check if active and check interval */ if (a.type != AT_EVALUATED && a.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 (!a.active) return AL_SUCCESS; if ((INT) ss_time() - (INT) a.checked_last < a.check_interval) return AL_SUCCESS; /* now the alarm will be triggered, so save time */ a.checked_last = ss_time(); } /* write back alarm message for internal alarms */ if (a.type != AT_EVALUATED && a.type != AT_PERIODIC) { strncpy(a.alarm_message, alarm_message, 79); a.alarm_message[79] = 0; } /* now trigger alarm class defined in this alarm */ if (a.alarm_class[0]) al_trigger_class(a.alarm_class, alarm_message, a.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, a.triggered > 0); /* signal alarm being triggered */ cm_asctime(str, sizeof(str)); if (!a.triggered) strcpy(a.time_triggered_first, str); a.triggered++; strcpy(a.time_triggered_last, str); a.checked_last = ss_time(); status = db_set_record(hDB, hkeyalarm, &a, sizeof(a), 0); if (status != DB_SUCCESS) { cm_msg(MERROR, "al_trigger_alarm", "Cannot update alarm record"); return AL_ERROR_ODB; } } #endif /* LOCAL_ROUTINES */ return AL_SUCCESS; }