tmfe.cxx File Reference

#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <signal.h>
#include <sys/time.h>
#include "tmfe.h"
#include "midas.h"
#include "msystem.h"
#include "mrpc.h"
#include "mstrlcpy.h"

Include dependency graph for tmfe.cxx:

Go to the source code of this file.

Classes
class	TMFrontendRpcHelper

Functions
TMFeResult	TMFeErrorMessage (const std::string &message)
TMFeResult	TMFeMidasError (const std::string &message, const char *midas_function_name, int midas_status)
static INT	rpc_callback (INT index, void *prpc_param[])
static INT	rpc_cxx_callback (INT index, void *prpc_param[])
static INT	binary_rpc_callback (INT index, void *prpc_param[])
static INT	binary_rpc_cxx_callback (INT index, void *prpc_param[])
static INT	tr_start (INT run_number, char *errstr)
static INT	tr_stop (INT run_number, char *errstr)
static INT	tr_pause (INT run_number, char *errstr)
static INT	tr_resume (INT run_number, char *errstr)
static INT	tr_startabort (INT run_number, char *errstr)

Function Documentation

binary_rpc_callback()

static INT binary_rpc_callback ( INT  index, void *  prpc_param[]  )

static

Definition at line 1203 of file tmfe.cxx.

{
   const char* cmd  = CSTRING(0);
   const char* args = CSTRING(1);
   char* return_buf = CSTRING(2);
   size_t return_max_length = CINT(3);
 
   if (TMFE::gfVerbose)
      printf("TMFE::binary_rpc_callback: index %d, max_length %zu, cmd [%s], args [%s]\n", index, return_max_length, cmd, args);
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleRpc() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      std::vector<char> result;
      TMFeResult r = h->HandleBinaryRpc(cmd, args, result);
      if (result.size() > 0) {
         if (result.size() > return_max_length) {
            TMFE::Instance()->Msg(MERROR, "TMFE::binary_rpc_callback", "RPC handler returned too much data, %zu bytes truncated to %zu bytes", result.size(), return_max_length);
            result.resize(return_max_length);
         }
         //printf("Handler reply [%s]\n", C(r));
         assert(result.size() <= return_max_length);
         memcpy(return_buf, result.data(), result.size());
         CINT(3) = result.size();
         return RPC_SUCCESS;
      }
   }
 
   CINT(3) = 0;
   return_buf[0] = 0;
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

binary_rpc_cxx_callback()

static INT binary_rpc_cxx_callback ( INT  index, void *  prpc_param[]  )

static

Definition at line 1240 of file tmfe.cxx.

{
   const char* cmd  = CSTRING(0);
   const char* args = CSTRING(1);
   std::vector<char>* pbuf = CPSTDVECTOR(2);
 
   if (TMFE::gfVerbose)
      printf("TMFE::binary_rpc_callback: index %d, cmd [%s], args [%s]\n", index, cmd, args);
 
   pbuf->clear();
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleRpc() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      TMFeResult r = h->HandleBinaryRpc(cmd, args, *pbuf);
      if (pbuf->size() > 0) {
         return RPC_SUCCESS;
      }
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_callback()

static INT rpc_callback ( INT  index, void *  prpc_param[]  )

static

Definition at line 1145 of file tmfe.cxx.

{
   const char* cmd  = CSTRING(0);
   const char* args = CSTRING(1);
   char* return_buf = CSTRING(2);
   int   return_max_length = CINT(3);
 
   if (TMFE::gfVerbose)
      printf("TMFE::rpc_callback: index %d, max_length %d, cmd [%s], args [%s]\n", index, return_max_length, cmd, args);
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleRpc() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      std::string result = "";
      TMFeResult r = h->HandleRpc(cmd, args, result);
      if (result.length() > 0) {
         //printf("Handler reply [%s]\n", C(r));
         mstrlcpy(return_buf, result.c_str(), return_max_length);
         return RPC_SUCCESS;
      }
   }
 
   return_buf[0] = 0;
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_cxx_callback()

static INT rpc_cxx_callback ( INT  index, void *  prpc_param[]  )

static

Definition at line 1175 of file tmfe.cxx.

{
   const char* cmd  = CSTRING(0);
   const char* args = CSTRING(1);
   std::string* pstr = CPSTDSTRING(2);
 
   pstr->clear();
 
   if (TMFE::gfVerbose)
      printf("TMFE::rpc_cxx_callback: index %d, cmd [%s], args [%s]\n", index, cmd, args);
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleRpc() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      TMFeResult r = h->HandleRpc(cmd, args, *pstr);
      if (pstr->length() > 0) {
         //printf("Handler reply [%s]\n", pstr->c_str());
         return RPC_SUCCESS;
      }
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TMFeErrorMessage()

TMFeResult TMFeErrorMessage

(

const std::string &

message

)

Definition at line 29 of file tmfe.cxx.

{
   return TMFeResult(0, message);
}

Here is the caller graph for this function:

TMFeMidasError()

TMFeResult TMFeMidasError	(	const std::string &	message,
		const char *	midas_function_name,
		int	midas_status
	)

Definition at line 34 of file tmfe.cxx.

{
   return TMFeResult(midas_status, message + msprintf(", %s() status %d", midas_function_name, midas_status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_pause()

static INT tr_pause ( INT  run_number, char *  errstr  )

static

Definition at line 1408 of file tmfe.cxx.

{
   cm_msg(MINFO, "tr_pause", "tr_pause");
 
   TMFeResult result;
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandlePauseRun() modifies fEquipments. K.O.
   // NOTE: tr_pause runs in reverse order to match tr_stop. K.O.
   for (int i = (int)mfe->fRpcHandlers.size() - 1; i >= 0; i--) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      result = h->HandlePauseRun(run_number);
      if (result.error_flag) {
         // error handling in this function matches general transition error handling:
         // logic is same as "start run"
         break;
      }
   }
 
   if (result.error_flag) {
      mstrlcpy(errstr, result.error_message.c_str(), TRANSITION_ERROR_STRING_LENGTH);
      return FE_ERR_DRIVER;
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

tr_resume()

static INT tr_resume ( INT  run_number, char *  errstr  )

static

Definition at line 1438 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::tr_resume!\n");
 
   TMFeResult result;
 
   TMFE* mfe = TMFE::Instance();
 
   mfe->fRunNumber = run_number;
   mfe->fStateRunning = true;
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleResumeRun() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      result = h->HandleResumeRun(run_number);
      if (result.error_flag) {
         // error handling in this function matches general transition error handling:
         // logic is same as "start run"
         break;
      }
   }
 
   if (result.error_flag) {
      mstrlcpy(errstr, result.error_message.c_str(), TRANSITION_ERROR_STRING_LENGTH);
      return FE_ERR_DRIVER;
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

tr_start()

static INT tr_start ( INT  run_number, char *  errstr  )

static

Definition at line 1330 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::tr_start!\n");
 
   TMFE* mfe = TMFE::Instance();
 
   mfe->fRunNumber = run_number;
   mfe->fStateRunning = true;
   
   TMFeResult result;
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleBeginRun() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      result = h->HandleBeginRun(run_number);
      if (result.error_flag) {
         // error handling in this function matches general transition error handling:
         // on run start, the first user handler to return an error code
         // will abort the transition. This leaves everything in an
         // inconsistent state: frontends called before the abort
         // think the run is running, which it does not. They should register
         // a handler for the "start abort" transition. This transition calls
         // all already started frontends so they can cleanup their state. K.O.
         // 
         break;
      }
   }
 
   if (result.error_flag) {
      mstrlcpy(errstr, result.error_message.c_str(), TRANSITION_ERROR_STRING_LENGTH);
      return FE_ERR_DRIVER;
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

tr_startabort()

static INT tr_startabort ( INT  run_number, char *  errstr  )

static

Definition at line 1471 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::tr_startabort!\n");
 
   TMFeResult result;
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleStartAbortRun() modifies fEquipments. K.O.
   for (unsigned i=0; i<mfe->fRpcHandlers.size(); i++) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      result = h->HandleStartAbortRun(run_number);
      if (result.error_flag) {
         // error handling in this function matches general transition error handling:
         // logic is same as "start run"
         break;
      }
   }
 
   mfe->fStateRunning = false;
 
   if (result.error_flag) {
      mstrlcpy(errstr, result.error_message.c_str(), TRANSITION_ERROR_STRING_LENGTH);
      return FE_ERR_DRIVER;
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_stop()

static INT tr_stop ( INT  run_number, char *  errstr  )

static

Definition at line 1369 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::tr_stop!\n");
 
   TMFeResult result;
 
   TMFE* mfe = TMFE::Instance();
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleEndRun() modifies fEquipments. K.O.
   // NOTE: we need to stop thing in reverse order, otherwise TMFrontend code
   // does not work right - TMFrontend is registered first, and (correctly) runs
   // first at begin of run (to clear statistics, etc). But at the end of run
   // it needs to run last, to update the statistics, etc. after all the equipments
   // have done their end of run things and are finished. K.O.
   for (int i = (int)mfe->fRpcHandlers.size() - 1; i >= 0; i--) {
      TMFeRpcHandlerInterface* h = mfe->fRpcHandlers[i];
      if (!h)
         continue;
      TMFeResult xresult = h->HandleEndRun(run_number);
      if (xresult.error_flag) {
         // error handling in this function matches general transition error handling:
         // the "run stop" transition is always sucessful, the run always stops.
         // if some frontend returns an error, this error is remembered and is returned
         // as the transition over all status. K.O.
         result = xresult;
      }
   }
 
   mfe->fStateRunning = false;
 
   if (result.error_flag) {
      mstrlcpy(errstr, result.error_message.c_str(), TRANSITION_ERROR_STRING_LENGTH);
      return FE_ERR_DRIVER;
   }
 
   return SUCCESS;
}

Here is the call graph for this function: