lemAutoRunFE.cxx

Go to the documentation of this file.

/********************************************************************************************

  lemAutoRunFE.cxx

*********************************************************************************************

    begin                : Andreas Suter, 2009/01/14
    modfied:             :
    copyright            : (C) 2009 by
    email                : andreas.suter@psi.ch

********************************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <ctype.h>

#include "midas.h"
#include "msystem.h"

#define LAR_STATE_STOPPED     0
#define LAR_STATE_PAUSED      1
#define LAR_STATE_STARTING    2
#define LAR_STATE_RUNNING     3
#define LAR_STATE_LOAD        4
#define LAR_STATE_LOADING     5
#define LAR_STATE_NEXT        6
 
extern INT EXPRT ss_system(const char *command);
extern INT ss_daemon_init(BOOL keep_stdout);

/***************************************************************************/
// global variables
/***************************************************************************/

int _done = FALSE;  

/***************************************************************************/
void lar_fe_syntax()
{
  printf("\nSYNTAX: lemAutoRunFE [-h host] [-e experiment] [-D] |");
  printf("\n                     [--help] |");
  printf("\n        frontend autorun handler for the LEM experiment.");
  printf("\n        host:       host on which the experiment is running.");
  printf("\n        experiment: name of the MIDAS experiment.");
  printf("\n        -D:         becoming a daemon.");
  printf("\n        --help:     prints this help.");
  printf("\n\n");
}

/***************************************************************************/
void lar_fe_ctrlc_handler(int sig)
{
   _done = TRUE;
}

/***************************************************************************/
int lar_strip(char *str, char *result, size_t result_size)
{
  unsigned int j;
  unsigned int ws_start, ws_end;

  // count number of initial whitespaces
  ws_start = 0;
  for (unsigned int i=0; i<strlen(str); i++) {
    if (isspace(str[i])) {
      ws_start++;
    } else {
      break;
    }
  }

  // count number of ending whitespaces
  ws_end = strlen(str)-1;
  for (unsigned int i=strlen(str)-1; i>=0; i--) {
    if (isspace(str[i])) {
      ws_end--;
    } else {
      break;
    }
  }

  // check for potential whitespaces in str
  for (unsigned int i=ws_start; i<ws_end; i++) {
    if (isspace(str[i]))
      return 1;
  }

  // check that result string length is fitting
  if (ws_end-ws_start+1 > result_size) {
    return 2;
  }

  // copy relevant parts from str to result
  j=0;
  for (unsigned int i=ws_start; i<=ws_end; i++) {
    result[j++] = str[i];
  }
  result[j] = '\0';

  return 0;
}

/***************************************************************************/
int lar_seq_name_check(HNDLE hDB) {

  HNDLE hKey;
  int status, size;
  char seqName[64], seqNameStripped[64];

  status = db_find_key(hDB, 0, "/AutoRun/Auto Run Sequence", &hKey);
  if (status != DB_SUCCESS) {
    return -1;
  }

  size = sizeof(seqName);
  status = db_get_data(hDB, hKey, seqName, &size, TID_STRING);
  if (status != DB_SUCCESS) {
    return -1;
  }

  status = lar_strip(seqName, seqNameStripped, sizeof(seqNameStripped));
  if (status != 0)
    return -1;

  if (!strcmp(seqNameStripped, "none"))
    return 1;

  return 0;
}

/***************************************************************************/
int lar_substr_eq(char *a, char *b)
{
  int len, i, eq = 1;
  
  if (strlen(a) > strlen(b))
    len = strlen(b);
  else
    len = strlen(a);
    
  for (i=0; i<len; i++) {
    if (a[i] != b[i]) {
      eq = 0;
      break;
    }
  }
  
  return eq;
}

/***************************************************************************/
int lar_client_running(HNDLE hDB)
{
  int status, i, size;
  HNDLE hKey, subKey;
  char str[NAME_LENGTH];
  int found_autorun = 0;

  // get the system client key
  status = db_find_key(hDB, 0, "/System/Clients", &hKey);
  if (status != DB_SUCCESS) {
    return -1;
  }

  // go through the system clients and check if lemAutoRun is present
  for (i=0; ; i++) {
    // check if there is a subkey
    if (db_enum_key(hDB, hKey, i, &subKey) == DB_NO_MORE_SUBKEYS)
      break;

    // get the content of the variable Name from the subkey
    size = sizeof(str);
    status = db_get_value(hDB, subKey, "Name", str, &size, TID_STRING, FALSE);

    if (status != DB_SUCCESS) {
      return -1;
    }

    // check if lemAutoRun is found
    if (!strcmp(str, "lemAutoRun1")) {
      found_autorun = 1;
      break;
    }
  }

  return found_autorun;
}

/***************************************************************************/
void lar_check_auto_run_sequence(INT hDB, INT hKey, void *autoRunSeq)
{
  char str[64];
  char cmd[256];
  char larseq[64];
  int status;

  if (autoRunSeq == 0)
    return;

  // strip whitespaces and make sure that the remaining name contains NO whitespaces!
  // Examples: 'title.lar'     -> allowed
  //           '  title.lar  ' -> allowed
  //           '\ttitle.lar  ' -> allowed
  //           'ti tle.lar'    -> NOT allowed
  status = lar_strip((char *)autoRunSeq, larseq, sizeof(larseq));
  if (status != 0) {
    snprintf(cmd, sizeof(cmd), "Sequence name: '%s' contains 'illegal' characters.", (char*)autoRunSeq);
    al_trigger_alarm("lemAutoRunFE", cmd, "Warning", cmd, AT_INTERNAL);
    strcpy(str, "none");
    db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
    return;
  }

  if (strlen(larseq) == 0) {
    strcpy(str, "none");
    db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
  }
}

/***************************************************************************/
void lar_check_next_autorun(INT hDB, INT hKey, void *next)
{
  char str[64];
  char nextAutoRun[1024];
  int status;
  char cmd[1024];

  if (next == nullptr)
    return;

  // strip whitespaces and make sure that the remaining name contains NO whitespaces!
  // Examples: 'title.lar'     -> allowed
  //           '  title.lar  ' -> allowed
  //           '\ttitle.lar  ' -> allowed
  //           'ti tle.lar'    -> NOT allowed
  status = lar_strip((char*)next, nextAutoRun, sizeof(nextAutoRun));
  if (status != 0) {
    snprintf(cmd, sizeof(cmd), "Next autorun name: '%s' contains 'illegal' characters.", (char*)next);
    al_trigger_alarm("lemAutoRunFE", cmd, "Warning", cmd, AT_INTERNAL);
    strcpy(str, "none");
    db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
    return;
  }

  // if next is set to 'none' nothing has to be done
  if (!strcmp(nextAutoRun, "none")) {
    return;
  }

  // prepend the autoRun directory path to the nextAutoRun
  memset(cmd, '\0', sizeof(cmd));
  sprintf(cmd, "/home/nemu/autoRun/%s", nextAutoRun);
  strcpy(nextAutoRun, cmd);

  // if next is set accidentely to '', i.e. empty, set it to 'none'
  if (strlen(nextAutoRun) == 0) {
    strcpy(str, "none");
    db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
    return;
  }

  // make sure the sequence name is anything but 'none'
  if ((status = lar_seq_name_check(hDB)) != 0) {
    snprintf(cmd, sizeof(cmd), "Next autorun name can only by set if a Sequence is set.");
    al_trigger_alarm("lemAutoRunFE", cmd, "Warning", cmd, AT_INTERNAL);
    strcpy(str, "none");
    db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
    return;
  }

  // validate the hopefully sensible autorun script
  memset(cmd, '\0', sizeof(cmd));
  char *path = getenv("MIDAS_PREFIX");
  snprintf(cmd, sizeof(cmd), "%s/bin/lemAutoRun_validate", path);
  pid_t p;
  p = fork();
  if (p == 0) { // child
    execl(cmd, cmd, nextAutoRun, NULL);
  } else { // parent
    wait(&status);
    if ( WIFEXITED(status) ) {
      int ret = WEXITSTATUS(status);
      if (ret != 0) {
        snprintf(cmd, sizeof(cmd), "Next autorun '%s' is invalid (status=%d)! Fix it first! Will set it to 'none' for now.", nextAutoRun, ret);
        al_trigger_alarm("lemAutoRunFE", cmd, "Warning", cmd, AT_INTERNAL);
        strcpy(str, "none");
        db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
      }
    } else {
      snprintf(cmd, sizeof(cmd), "Couldn't get exit status of next autorun validation for '%s'! Please try again! Will set it to 'none' for now.", nextAutoRun);
      al_trigger_alarm("lemAutoRunFE", cmd, "Warning", cmd, AT_INTERNAL);
      strcpy(str, "none");
      db_set_data(hDB, hKey, str, sizeof(str), 1, TID_STRING);
    }
  }
}

/***************************************************************************/
int main(int argc, char *argv[])
{
  int   unhappy = FALSE;
  int   status, size, i;
  int   daemon = 0;
  char  host[256], exp[256];
  char  cmd[128];
  char  str[32];
  char  autoRunSeq[64];
  char  nextFln[64];
  char  nextAutoRun[64];
  HNDLE hDB;
  HNDLE hKey, hKey2;
  INT   run_state;
  INT   val;
  int autorun_present = 0;
  
  // get host name and default experiment
  memset(host, 0, sizeof(host));
  memset(exp,  0, sizeof(exp));
  cm_get_environment(host, sizeof(host), exp, sizeof(exp));

  // check syntax
  switch (argc) {
    case 1:
      unhappy = TRUE;
      break;
    case 2:
      if (!strcmp(argv[1], "-D"))
        daemon = 1;
      else
        unhappy = TRUE;
      break;
    case 3:
      if (!strcmp(argv[1], "-h"))
        strcpy(host, argv[2]);
      else if (!strcmp(argv[1], "-e"))
        strcpy(exp, argv[2]);
      else if (!strcmp(argv[1], "-D"))
        daemon = TRUE;
      else
        unhappy = TRUE;
      break;
    case 4:
      if ((!strcmp(argv[1], "-h") || !strcmp(argv[1], "-e")) &&
          (!strcmp(argv[3], "-D"))) {
        if (!strcmp(argv[3], "-D"))
          daemon = 1;
        if (!strcmp(argv[1], "-h"))
          strcpy(host, argv[2]);
        else
          strcpy(exp, argv[2]);
      } else {
        unhappy = TRUE;
      }
      break;
    case 5:
      if (!strcmp(argv[1], "-h") && !strcmp(argv[3], "-e")) {
        strcpy(host, argv[2]);
        strcpy(exp,  argv[4]);
      } else if (!strcmp(argv[3], "-h") && !strcmp(argv[1], "-e")) {
        strcpy(host, argv[4]);
        strcpy(exp,  argv[2]);
      } else {
        unhappy = TRUE;
      }
      break;
    case 6:
      if (!strcmp(argv[5], "-D")) {
        daemon = 1;
        if (!strcmp(argv[1], "-h") || !strcmp(argv[3], "-e")) {
          strcpy(host, argv[2]);
          strcpy(exp,  argv[4]);
        } else if (!strcmp(argv[3], "-h") || !strcmp(argv[1], "-e")) {
          strcpy(host, argv[4]);
          strcpy(exp,  argv[2]);
        } else {
          unhappy = TRUE;
        }
      } else {
        unhappy = TRUE;
      }
      break;
    default:
      unhappy = TRUE;
      break;
  }
  
  if (unhappy) {
    lar_fe_syntax();
    return 0;
  }

  if (daemon) {
    printf("Becoming a daemon...\n");
    ss_daemon_init(FALSE);
  } else {
    printf("\nlemAutoRunFE running ...\n");
    printf("\n>> terminate from web-page, ODB, or CTRL-C\n\n");
  }

  // register with midas
  status = cm_connect_experiment(host, exp, "lemAutoRunFE", NULL);
  if (status != CM_SUCCESS) {
    cm_msg(MERROR, "lemAutoRunFE", "Couldn't register with MIDAS, will quit. status = %d", status);
    return -1;
  }

  // establish Ctrl-C handler
  ss_ctrlc_handler(lar_fe_ctrlc_handler);

  // get handle to the ODB
  cm_get_experiment_database(&hDB, NULL);

  // start a watchdog thread
  cm_start_watchdog_thread();

  /* save watchdog timeout */
  BOOL call_watchdog;
  cm_get_watchdog_params(&call_watchdog, NULL);
  cm_set_watchdog_params(call_watchdog, 60000);
  // increase RPC timeout to 2min
  rpc_set_timeout(RPC_HNDLE_MSERVER, 120000, &val);

  // get Auto Run Sequence
  status = db_find_key(hDB, 0, "/AutoRun/Auto Run Sequence", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "lemAutoRunFE", "Coulnd't get the ODB key for /AutoRun/Auto Run Sequence, will quit.");
    cm_disconnect_experiment();
    return -1;
  }
  // hotlink autorun sequence
  db_open_record(hDB, hKey, (void*)&autoRunSeq, sizeof(autoRunSeq), MODE_READ, &lar_check_auto_run_sequence, (void*)&autoRunSeq);

  // make sure AutoRun Run State is present in the ODB
  status = db_find_key(hDB, 0, "/AutoRun/Run State", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "lemAutoRunFE", "Coulnd't get the ODB key for /AutoRun/Run State, will quit.");
    cm_disconnect_experiment();
    return -1;
  }

  // get AutoRun Next from ODB
  status = db_find_key(hDB, 0, "/AutoRun/Next", &hKey);
  if (status != DB_SUCCESS) {
    cm_msg(MERROR, "lemAutoRunFE", "Coulnd't get the ODB key for /AutoRun/Next, will quit.");
    cm_disconnect_experiment();
    return -1;
  }
  // hotlink autorun next
  db_open_record(hDB, hKey, (void*)&nextAutoRun, sizeof(nextAutoRun), MODE_READ, &lar_check_next_autorun, (void*)&nextAutoRun);

  do {
    // get current LEM autorun run state
    size = sizeof(run_state);
    status = db_get_value(hDB, 0, "/AutoRun/Run State", (void*)&run_state, &size, TID_INT, 0);
    if (status != DB_SUCCESS) {
        cm_msg(MERROR, "lemAutoRunFE", "Couldn't get the LEM autorun state, will quit.");
        cm_disconnect_experiment();
        return -1;
    }

    // if Run State is changing to RUNNING start lemAutoRun if not already running
    if ((run_state == LAR_STATE_LOAD) || (run_state == LAR_STATE_STARTING)) {

      // check if an lemAutoRun is underway
      autorun_present = lar_client_running(hDB);
      if (autorun_present < 0) {
        cm_msg(MERROR, "lemAutoRunFE", "Couldn't get check clients, will quit.");
        cm_disconnect_experiment();
        return -1;
      }

      if (autorun_present == 0) { // no lemAutoRun present
        if (strlen(host) == 0)
          sprintf(cmd, "lemAutoRun -e %s -D", exp);
        else 
          sprintf(cmd, "lemAutoRun -h %s -e %s -D", host, exp);
        cm_msg(MINFO, "lemAutoRunFE", "lemAutoRunFE: Will start autorun via '%s'", cmd);
        ss_system(cmd);

        // switch to autorun state running or loading, depending on the run state
        status = db_find_key(hDB, 0, "/AutoRun/Run State", &hKey);
        if (status != DB_SUCCESS) {
          cm_msg(MERROR, "lemAutoRunFE", "Coulnd't get the ODB key for /AutoRun/Run State, will quit.");
          cm_disconnect_experiment();
          return -1;
        }
        if (run_state == LAR_STATE_STARTING) {
          val = LAR_STATE_RUNNING;
        } else {
          val = LAR_STATE_LOADING;
        }
        db_set_data(hDB, hKey, &val, sizeof(val), 1, TID_INT);
      }
    }
      
    // check if autorun needs to be stopped
    if (run_state == LAR_STATE_STOPPED) {
      // check if lemAutoRun is still present and if yes remove it
      status = db_find_key(hDB, 0, "System/Clients", &hKey);
      if (status != DB_SUCCESS) {
        cm_msg(MERROR, "lemAutoRunFE", "cannot find System/Clients entry in ODB.");
      } else {
        autorun_present = lar_client_running(hDB);
        if (autorun_present) {
          strncpy(str, "lemAutoRun", sizeof(str));
          cm_msg(MINFO, "lemAutoRunFE", "lemAutoRunFE: will shutdown '%s'", str);
          cm_shutdown(str, FALSE);
        }
      }
    }

    // check if there is a next autorun to be executed. LAR_STATE_NEXT will be set by lemAutoRun
    if (run_state == LAR_STATE_NEXT) {
      status = db_find_key(hDB, 0, "/AutoRun/Next", &hKey);
      if (status != DB_SUCCESS) {
        cm_msg(MERROR, "lemAutoRunFE", "cannot find '/AutoRun/Next' entry in ODB.");
      } else {
        // check if an autorun file name is present
        size = sizeof(nextFln);
        status = db_get_data(hDB, hKey, nextFln, &size, TID_STRING);
        if (status == DB_SUCCESS) {
          if (strcmp(nextFln, "none")) { // not none, i.e. something needs to be done
            // copy Next to "Auto Run Sequence", and set Next == "none"
            status = db_find_key(hDB, 0, "/AutoRun/Auto Run Sequence", &hKey2);
            if (status != DB_SUCCESS) {
              cm_msg(MERROR, "lemAutoRunFE", "cannot find '/AutoRun/Auto Run Sequence' entry in ODB.");
            } else {
              cm_msg(MINFO, "lemAutoRunFE", "will start NEXT autorun %s soon.", nextFln);
              db_set_data(hDB, hKey2, nextFln, sizeof(nextFln), 1, TID_STRING);
              strcpy(nextFln, "none");
              db_set_data(hDB, hKey, nextFln, sizeof(nextFln), 1, TID_STRING);
              // change run state to running such that the next autorun will be executed
              val = LAR_STATE_STARTING;
              status = db_find_key(hDB, 0, "/AutoRun/Run State", &hKey);
              if (status != DB_SUCCESS)
                cm_msg(MERROR, "lemAutoRunFE", "cannot get '/AutoRun/Run State' entry in ODB. Unlikely that NEXT autorun will start.");
              else
                db_set_data(hDB, hKey, &val, sizeof(val), 1, TID_INT);
            }
          }
        } else {
          cm_msg(MERROR, "lemAutoRunFE", "couldn't read /AutoRun/Next.");
        }
      }
    }

    // check for shutdown messages and feed watchdog
    status = cm_yield(1000);
    if ((status == RPC_SHUTDOWN) || (status == SS_ABORT)) {
      _done = TRUE;
    }

  } while (!_done);
  
  // get current LEM autorun run state
  size = sizeof(run_state);
  status = db_get_value(hDB, 0, "/AutoRun/Run State", (void*)&run_state, &size, TID_INT, 0);
  if (status != DB_SUCCESS) {
      cm_msg(MERROR, "lemAutoRunFE", "Couldn't get the LEM autorun state, will quit.");
      cm_disconnect_experiment();
      return -1;
  }
  if (run_state == LAR_STATE_RUNNING) {
    // wait a bit to give lemAutoRun a chance to stop by itself if it can
    for (i=0; i<5; i++) {
      status = cm_yield(100);
    }
  }

  // shutdown lemAutoRun if it is still running
  if (run_state == LAR_STATE_RUNNING) {
    // switch to autorun state stopped
    status = db_find_key(hDB, 0, "/AutoRun/Run State", &hKey);
    if (status != DB_SUCCESS) {
      cm_msg(MERROR, "lemAutoRunFE", "Couldn't get the ODB key for /AutoRun/Run State, will quit.");
      cm_disconnect_experiment();
      return -1;
    }
    val = LAR_STATE_STOPPED;
    db_set_data(hDB, hKey, &val, sizeof(val), 1, TID_INT);
    
    // wait a bit to give lemAutoRun a chance to stop by itself if it can
    for (i=0; i<5; i++) {
      status = cm_yield(100);
    }

    cm_msg(MINFO, "lemAutoRunFE", "lemAutoRunFE: Will stop lemAutoRun as well...");
    cm_shutdown("lemAutoRun", TRUE);
  }

  cm_disconnect_experiment();
  
  return 0;
}