Common Functions (cm_xxx)

Classes
struct	exptab_entry
struct	exptab_struct
class	bm_lock_buffer_guard
struct	TrClient
struct	TrState

Functions
INT	cm_synchronize (DWORD *seconds)
INT	cm_asctime (char *str, INT buf_size)
std::string	cm_asctime ()
INT	cm_time (DWORD *t)
const char *	cm_get_version ()
const char *	cm_get_revision ()
INT	cm_set_path (const char *path)
INT	cm_get_path (char *path, int path_size)
std::string	cm_get_path ()
INT EXPRT	cm_get_path_string (std::string *path)
INT	cm_set_experiment_name (const char *name)
INT	cm_get_experiment_name (char *name, int name_length)
std::string	cm_get_experiment_name ()
INT	cm_read_exptab (exptab_struct *exptab)
int	cm_get_exptab_filename (char *s, int size)
std::string	cm_get_exptab_filename ()
int	cm_get_exptab (const char *expname, std::string *dir, std::string *user)
int	cm_get_exptab (const char *expname, char *dir, int dir_size, char *user, int user_size)
INT	cm_delete_client_info (HNDLE hDB, INT pid)
INT	cm_check_client (HNDLE hDB, HNDLE hKeyClient)
INT	cm_set_client_info (HNDLE hDB, HNDLE *hKeyClient, const char *host_name, char *client_name, INT hw_type, const char *password, DWORD watchdog_timeout)
std::string	cm_get_client_name ()
INT	cm_get_environment (char *host_name, int host_name_size, char *exp_name, int exp_name_size)
INT	cm_get_environment (std::string *host_name, std::string *exp_name)
int	cm_set_experiment_local (const char *exp_name)
void	cm_check_connect (void)
INT	cm_connect_experiment (const char *host_name, const char *exp_name, const char *client_name, void(*func)(char *))
INT	cm_connect_experiment1 (const char *host_name, const char *default_exp_name, const char *client_name, void(*func)(char *), INT odb_size, DWORD watchdog_timeout)
INT	cm_list_experiments_local (STRING_LIST *exp_names)
INT	cm_list_experiments_remote (const char *host_name, STRING_LIST *exp_names)
INT	cm_select_experiment_local (std::string *exp_name)
INT	cm_select_experiment_remote (const char *host_name, std::string *exp_name)
INT	cm_connect_client (const char *client_name, HNDLE *hConn)
static void	rpc_client_shutdown ()
INT	cm_disconnect_client (HNDLE hConn, BOOL bShutdown)
INT	cm_disconnect_experiment (void)
INT	cm_set_experiment_database (HNDLE hDB, HNDLE hKeyClient)
INT	cm_set_experiment_semaphore (INT semaphore_alarm, INT semaphore_elog, INT semaphore_history, INT semaphore_msg)
INT	cm_get_experiment_database (HNDLE *hDB, HNDLE *hKeyClient)
INT	cm_get_experiment_semaphore (INT *semaphore_alarm, INT *semaphore_elog, INT *semaphore_history, INT *semaphore_msg)
static int	bm_validate_client_index (const BUFFER *buf, BOOL abort_if_invalid)
static BUFFER_CLIENT *	bm_get_my_client (BUFFER *pbuf, BUFFER_HEADER *pheader)
static BUFFER *	bm_get_buffer (const char *who, INT buffer_handle, int *pstatus)
static int	bm_lock_buffer_read_cache (BUFFER *pbuf)
static int	bm_lock_buffer_write_cache (BUFFER *pbuf)
static int	bm_lock_buffer_mutex (BUFFER *pbuf)
static int	xbm_lock_buffer (BUFFER *pbuf)
static void	xbm_unlock_buffer (BUFFER *pbuf)
static INT	bm_notify_client (const char *buffer_name, int s)
static void	bm_defragment_event (HNDLE buffer_handle, HNDLE request_id, EVENT_HEADER *pevent, void *pdata, EVENT_HANDLER *dispatcher)
INT	cm_set_watchdog_params_local (BOOL call_watchdog, DWORD timeout)
INT	cm_set_watchdog_params (BOOL call_watchdog, DWORD timeout)
INT	cm_get_watchdog_params (BOOL *call_watchdog, DWORD *timeout)
INT	cm_get_watchdog_info (HNDLE hDB, const char *client_name, DWORD *timeout, DWORD *last)
static void	load_rpc_hosts (HNDLE hDB, HNDLE hKey, int index, void *info)
static void	init_rpc_hosts (HNDLE hDB)
INT	cm_register_server (void)
INT	cm_register_transition (INT transition, INT(*func)(INT, char *), INT sequence_number)
INT	cm_deregister_transition (INT transition)
INT	cm_set_transition_sequence (INT transition, INT sequence_number)
INT	cm_set_client_run_state (INT state)
INT	cm_register_deferred_transition (INT transition, BOOL(*func)(INT, BOOL))
INT	cm_check_deferred_transition ()
static bool	tr_compare (const std::unique_ptr< TrClient > &arg1, const std::unique_ptr< TrClient > &arg2)
static int	tr_finish (HNDLE hDB, TrState *tr, int transition, int status, const char *errorstr)
static void	write_tr_client_to_odb (HNDLE hDB, const TrClient *tr_client)
static int	cm_transition_detach (INT transition, INT run_number, char *errstr, INT errstr_size, INT async_flag, INT debug_flag)
static int	cm_transition_call (TrState *s, int idx)
static int	cm_transition_call_direct (TrClient *tr_client)
static INT	cm_transition2 (INT transition, INT run_number, char *errstr, INT errstr_size, INT async_flag, INT debug_flag)
static INT	cm_transition1 (INT transition, INT run_number, char *errstr, INT errstr_size, INT async_flag, INT debug_flag)
static INT	tr_main_thread (void *param)
INT	cm_transition_cleanup ()
INT	cm_transition (INT transition, INT run_number, char *errstr, INT errstr_size, INT async_flag, INT debug_flag)
INT	cm_dispatch_ipc (const char *message, int message_size, int client_socket)
void	cm_ctrlc_handler (int sig)
BOOL	cm_is_ctrlc_pressed ()
void	cm_ack_ctrlc_pressed ()
int	cm_exec_script (const char *odb_path_to_script)
static void	bm_cleanup (const char *who, DWORD actual_time, BOOL wrong_interval)
INT	cm_periodic_tasks ()
INT	cm_yield (INT millisec)
INT	cm_execute (const char *command, char *result, INT bufsize)
INT	cm_register_function (INT id, INT(*func)(INT, void **))
std::string	cm_get_history_path (const char *history_channel)
INT	cm_watchdog_thread (void *unused)
static void	xcm_watchdog_thread ()
INT	cm_start_watchdog_thread ()
INT	cm_stop_watchdog_thread ()
INT	cm_shutdown (const char *name, BOOL bUnique)
INT	cm_exist (const char *name, BOOL bUnique)
INT	cm_cleanup (const char *client_name, BOOL ignore_timeout)
std::string	cm_expand_env (const char *str)
static bool	test_cm_expand_env1 (const char *str, const char *expected)
void	cm_test_expand_env ()

Variables
static exptab_struct	_exptab
static INT	_requested_transition
static DWORD	_deferred_transition_mask
static BOOL	_ctrlc_pressed = FALSE
static std::atomic< bool >	_watchdog_thread_run {false}
static std::atomic< bool >	_watchdog_thread_is_running {false}
static std::atomic< std::thread * >	_watchdog_thread {NULL}

Detailed Description

dox dox

dox

Function Documentation

bm_cleanup()

static void bm_cleanup ( const char *  who, DWORD  actual_time, BOOL  wrong_interval  )

static

dox

Check all clients on all buffers, remove invalid clients

Definition at line 6115 of file midas.cxx.

{
#ifdef LOCAL_ROUTINES
 
   //printf("bm_cleanup: called by %s, actual_time %d, wrong_interval %d\n", who, actual_time, wrong_interval);
 
   std::vector<BUFFER*> mybuffers;
 
   gBuffersMutex.lock();
   mybuffers = gBuffers;
   gBuffersMutex.unlock();
 
   /* check buffers */
   for (BUFFER* pbuf : mybuffers) {
      if (!pbuf)
         continue;
      if (pbuf->attached) {
         /* update the last_activity entry to show that we are alive */
 
         bm_lock_buffer_guard pbuf_guard(pbuf);
         
         if (!pbuf_guard.is_locked())
            continue;
 
         BUFFER_HEADER *pheader = pbuf->buffer_header;
         BUFFER_CLIENT *pclient = bm_get_my_client(pbuf, pheader);
         pclient->last_activity = actual_time;
 
         /* don't check other clients if interval is strange */
         if (!wrong_interval)
            bm_cleanup_buffer_locked(pbuf, who, actual_time);
      }
   }
#endif // LOCAL_ROUTINES
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_defragment_event()

static void bm_defragment_event ( HNDLE  buffer_handle, HNDLE  request_id, EVENT_HEADER *  pevent, void *  pdata, EVENT_HANDLER *  dispatcher  )

static

Definition at line 11251 of file midas.cxx.

{
   INT i;
 
   if ((uint16_t(pevent->event_id) & uint16_t(0xF000)) == uint16_t(EVENTID_FRAG1)) {
      /*---- start new event ----*/
 
      //printf("First Frag detected : Ser#:%d ID=0x%x \n", pevent->serial_number, pevent->event_id);
 
      /* check if fragments already stored */
      for (i = 0; i < MAX_DEFRAG_EVENTS; i++)
         if (defrag_buffer[i].event_id == (pevent->event_id & 0x0FFF))
            break;
 
      if (i < MAX_DEFRAG_EVENTS) {
         free(defrag_buffer[i].pevent);
         defrag_buffer[i].pevent = NULL;
         memset(&defrag_buffer[i].event_id, 0, sizeof(EVENT_DEFRAG_BUFFER));
         cm_msg(MERROR, "bm_defragement_event",
                "Received new event with ID %d while old fragments were not completed",
                (pevent->event_id & 0x0FFF));
      }
 
      /* search new slot */
      for (i = 0; i < MAX_DEFRAG_EVENTS; i++)
         if (defrag_buffer[i].event_id == 0)
            break;
 
      if (i == MAX_DEFRAG_EVENTS) {
         cm_msg(MERROR, "bm_defragment_event",
                "Not enough defragment buffers, please increase MAX_DEFRAG_EVENTS and recompile");
         return;
      }
 
      /* check event size */
      if (pevent->data_size != sizeof(DWORD)) {
         cm_msg(MERROR, "bm_defragment_event",
                "Received first event fragment with %d bytes instead of %d bytes, event ignored",
                pevent->data_size, (int) sizeof(DWORD));
         return;
      }
 
      /* setup defragment buffer */
      defrag_buffer[i].event_id = (pevent->event_id & 0x0FFF);
      defrag_buffer[i].data_size = *(DWORD *) pdata;
      defrag_buffer[i].received = 0;
      defrag_buffer[i].pevent = (EVENT_HEADER *) malloc(sizeof(EVENT_HEADER) + defrag_buffer[i].data_size);
 
      if (defrag_buffer[i].pevent == NULL) {
         memset(&defrag_buffer[i].event_id, 0, sizeof(EVENT_DEFRAG_BUFFER));
         cm_msg(MERROR, "bm_defragement_event", "Not enough memory to allocate event defragment buffer");
         return;
      }
 
      memcpy(defrag_buffer[i].pevent, pevent, sizeof(EVENT_HEADER));
      defrag_buffer[i].pevent->event_id = defrag_buffer[i].event_id;
      defrag_buffer[i].pevent->data_size = defrag_buffer[i].data_size;
 
      // printf("First frag[%d] (ID %d) Ser#:%d sz:%d\n", i, defrag_buffer[i].event_id,
      //       pevent->serial_number, defrag_buffer[i].data_size);
 
      return;
   }
 
   /* search buffer for that event */
   for (i = 0; i < MAX_DEFRAG_EVENTS; i++)
      if (defrag_buffer[i].event_id == (pevent->event_id & 0xFFF))
         break;
 
   if (i == MAX_DEFRAG_EVENTS) {
      /* no buffer available -> no first fragment received */
      cm_msg(MERROR, "bm_defragement_event",
             "Received fragment without first fragment (ID %d) Ser#:%d",
             pevent->event_id & 0x0FFF, pevent->serial_number);
      return;
   }
 
   /* add fragment to buffer */
   if (pevent->data_size + defrag_buffer[i].received > defrag_buffer[i].data_size) {
      free(defrag_buffer[i].pevent);
      defrag_buffer[i].pevent = NULL;
      memset(&defrag_buffer[i].event_id, 0, sizeof(EVENT_DEFRAG_BUFFER));
      cm_msg(MERROR, "bm_defragement_event",
             "Received fragments with more data (%d) than event size (%d)",
             pevent->data_size + defrag_buffer[i].received, defrag_buffer[i].data_size);
      return;
   }
 
   memcpy(((char *) defrag_buffer[i].pevent) + sizeof(EVENT_HEADER) +
          defrag_buffer[i].received, pdata, pevent->data_size);
 
   defrag_buffer[i].received += pevent->data_size;
 
   //printf("Other frag[%d][%d] (ID %d) Ser#:%d sz:%d\n", i, j++,
   //       defrag_buffer[i].event_id, pevent->serial_number, pevent->data_size);
 
   if (defrag_buffer[i].received == defrag_buffer[i].data_size) {
      /* event complete */
      dispatcher(buffer_handle, request_id, defrag_buffer[i].pevent, defrag_buffer[i].pevent + 1);
      free(defrag_buffer[i].pevent);
      defrag_buffer[i].pevent = NULL;
      memset(&defrag_buffer[i].event_id, 0, sizeof(EVENT_DEFRAG_BUFFER));
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_get_buffer()

static BUFFER * bm_get_buffer ( const char *  who, INT  buffer_handle, int *  pstatus  )

static

Definition at line 6586 of file midas.cxx.

{
   size_t sbuffer_handle = buffer_handle;
 
   size_t  nbuf = 0;
   BUFFER* pbuf = NULL;
 
   gBuffersMutex.lock();
 
   nbuf = gBuffers.size();
   if (buffer_handle >=1 && sbuffer_handle <= nbuf) {
      pbuf = gBuffers[buffer_handle-1];
   }
 
   gBuffersMutex.unlock();
 
   if (sbuffer_handle > nbuf || buffer_handle <= 0) {
      if (who)
         cm_msg(MERROR, who, "invalid buffer handle %d: out of range [1..%d]", buffer_handle, (int)nbuf);
      if (pstatus)
         *pstatus = BM_INVALID_HANDLE;
      return NULL;
   }
   
   if (!pbuf) {
      if (who)
         cm_msg(MERROR, who, "invalid buffer handle %d: empty slot", buffer_handle);
      if (pstatus)
         *pstatus = BM_INVALID_HANDLE;
      return NULL;
   }
   
   if (!pbuf->attached) {
      if (who)
         cm_msg(MERROR, who, "invalid buffer handle %d: not attached", buffer_handle);
      if (pstatus)
         *pstatus = BM_INVALID_HANDLE;
      return NULL;
   }
   
   if (pstatus)
      *pstatus = BM_SUCCESS;
 
   return pbuf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_get_my_client()

static BUFFER_CLIENT * bm_get_my_client ( BUFFER *  pbuf, BUFFER_HEADER *  pheader  )

static

Definition at line 5962 of file midas.cxx.

                                                                             {
   int my_client_index = bm_validate_client_index(pbuf, TRUE);
   return pheader->client + my_client_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_lock_buffer_mutex()

static int bm_lock_buffer_mutex ( BUFFER *  pbuf )

static

Definition at line 7911 of file midas.cxx.

{
   //printf("bm_lock_buffer_mutex %s!\n", pbuf->buffer_name);
 
   bool locked = ss_timed_mutex_wait_for_sec(pbuf->buffer_mutex, "buffer mutex", _bm_mutex_timeout_sec);
 
   if (!locked) {
      fprintf(stderr, "bm_lock_buffer_mutex: Error: Cannot lock buffer \"%s\", ss_timed_mutex_wait_for_sec() timeout, aborting...\n", pbuf->buffer_name);
      cm_msg(MERROR, "bm_lock_buffer_mutex", "Cannot lock buffer \"%s\", ss_timed_mutex_wait_for_sec() timeout, aborting...", pbuf->buffer_name);
      abort();
      /* DOES NOT RETURN */
   }
 
   if (!pbuf->attached) {
      pbuf->buffer_mutex.unlock();
      fprintf(stderr, "bm_lock_buffer_mutex: Error: Cannot lock buffer \"%s\", buffer was closed while we waited for the buffer_mutex\n", pbuf->buffer_name);
      return BM_INVALID_HANDLE;
   }
 
   //static int counter = 0;
   //counter++;
   //printf("locked %d!\n", counter);
   //if (counter > 50)
   //   ::sleep(3);
 
   return BM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_lock_buffer_read_cache()

static int bm_lock_buffer_read_cache ( BUFFER *  pbuf )

static

Definition at line 7869 of file midas.cxx.

{
   bool locked = ss_timed_mutex_wait_for_sec(pbuf->read_cache_mutex, "buffer read cache", _bm_mutex_timeout_sec);
 
   if (!locked) {
      fprintf(stderr, "bm_lock_buffer_read_cache: Error: Cannot lock read cache of buffer \"%s\", ss_timed_mutex_wait_for_sec() timeout, aborting...\n", pbuf->buffer_name);
      cm_msg(MERROR, "bm_lock_buffer_read_cache", "Cannot lock read cache of buffer \"%s\", ss_timed_mutex_wait_for_sec() timeout, aborting...", pbuf->buffer_name);
      abort();
      /* DOES NOT RETURN */
   }
 
   if (!pbuf->attached) {
      pbuf->read_cache_mutex.unlock();
      fprintf(stderr, "bm_lock_buffer_read_cache: Error: Cannot lock read cache of buffer \"%s\", buffer was closed while we waited for the buffer_mutex\n", pbuf->buffer_name);
      return BM_INVALID_HANDLE;
   }
 
   return BM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_lock_buffer_write_cache()

static int bm_lock_buffer_write_cache ( BUFFER *  pbuf )

static

Definition at line 7890 of file midas.cxx.

{
   bool locked = ss_timed_mutex_wait_for_sec(pbuf->write_cache_mutex, "buffer write cache", _bm_mutex_timeout_sec);
 
   if (!locked) {
      fprintf(stderr, "bm_lock_buffer_write_cache: Error: Cannot lock write cache of buffer \"%s\", ss_timed_mutex_wait_for_sec() timeout, aborting...\n", pbuf->buffer_name);
      cm_msg(MERROR, "bm_lock_buffer_write_cache", "Cannot lock write cache of buffer \"%s\", ss_timed_mutex_wait_for_sec() timeout, aborting...", pbuf->buffer_name);
      abort();
      /* DOES NOT RETURN */
   }
 
   if (!pbuf->attached) {
      pbuf->write_cache_mutex.unlock();
      fprintf(stderr, "bm_lock_buffer_write_cache: Error: Cannot lock write cache of buffer \"%s\", buffer was closed while we waited for the buffer_mutex\n", pbuf->buffer_name);
      return BM_INVALID_HANDLE;
   }
 
   return BM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_notify_client()

static INT bm_notify_client ( const char *  buffer_name, int  s  )

static

Definition at line 11015 of file midas.cxx.

{
   static DWORD last_time = 0;
   DWORD now = ss_millitime();
 
   //printf("bm_notify_client: buffer [%s], socket %d, time %d\n", buffer_name, client_socket, now - last_time);
 
   BUFFER* fbuf = NULL;
 
   gBuffersMutex.lock();
 
   for (size_t i = 0; i < gBuffers.size(); i++) {
      BUFFER* pbuf = gBuffers[i];
      if (!pbuf || !pbuf->attached)
         continue;
      if (strcmp(buffer_name, pbuf->buffer_header->name) == 0) {
         fbuf = pbuf;
         break;
      }
   }
 
   gBuffersMutex.unlock();
 
   if (!fbuf)
      return BM_INVALID_HANDLE;
 
   /* don't send notification if client has no callback defined
      to receive events -> client calls bm_receive_event manually */
   if (!fbuf->callback)
      return DB_SUCCESS;
 
   int convert_flags = rpc_get_convert_flags();
 
   /* only send notification once each 500ms */
   if (now - last_time < 500)
      return DB_SUCCESS;
 
   last_time = now;
 
   char buffer[32];
   NET_COMMAND *nc = (NET_COMMAND *) buffer;
 
   nc->header.routine_id = MSG_BM;
   nc->header.param_size = 0;
 
   if (convert_flags) {
      rpc_convert_single(&nc->header.routine_id, TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc->header.param_size, TID_UINT32, RPC_OUTGOING, convert_flags);
   }
 
   //printf("bm_notify_client: Sending MSG_BM! buffer [%s]\n", buffer_name);
 
   /* send the update notification to the client */
   send_tcp(client_socket, (char *) buffer, sizeof(NET_COMMAND_HEADER), 0);
 
   return BM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bm_validate_client_index()

static int bm_validate_client_index ( const BUFFER *  buf, BOOL  abort_if_invalid  )

static

dox

Definition at line 5918 of file midas.cxx.

                                                                              {
   static int prevent_recursion = 1;
   int badindex = 0;
   BUFFER_CLIENT *bcl = buf->buffer_header->client;
 
   if (buf->client_index < 0)
      badindex = 1;
   else if (buf->client_index > buf->buffer_header->max_client_index)
      badindex = 1;
   else {
      bcl = &(buf->buffer_header->client[buf->client_index]);
      if (bcl->name[0] == 0)
         badindex = 1;
      else if (bcl->pid != ss_getpid())
         badindex = 1;
   }
 
#if 0
   printf("bm_validate_client_index: badindex=%d, buf=%p, client_index=%d, max_client_index=%d, client_name=\'%s\', client_pid=%d, pid=%d\n",
        badindex, buf, buf->client_index, buf->buffer_header->max_client_index,
        buf->buffer_header->client[buf->client_index].name, buf->buffer_header->client[buf->client_index].pid,
        ss_getpid());
#endif
 
   if (badindex) {
 
      if (!abort_if_invalid)
         return -1;
 
      if (prevent_recursion) {
         prevent_recursion = 0;
         cm_msg(MERROR, "bm_validate_client_index",
                "My client index %d in buffer \'%s\' is invalid: client name \'%s\', pid %d should be my pid %d",
                buf->client_index, buf->buffer_header->name, bcl->name, bcl->pid, ss_getpid());
         cm_msg(MERROR, "bm_validate_client_index",
                "Maybe this client was removed by a timeout. See midas.log. Cannot continue, aborting...");
      }
 
      abort();
   }
 
   return buf->client_index;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_ack_ctrlc_pressed()

void cm_ack_ctrlc_pressed

(

void

)

Definition at line 5452 of file midas.cxx.

                            {
   _ctrlc_pressed = FALSE;
}

Here is the caller graph for this function:

cm_asctime() [1/2]

std::string cm_asctime

(

)

Get time from MIDAS server and set local time.

Returns

return time string

Definition at line 1414 of file midas.cxx.

                       {
   /* if connected to server, get time from there */
   if (rpc_is_remote()) {
      char buf[256];
      int status = rpc_call(RPC_CM_ASCTIME, buf, sizeof(buf));
      if (status == CM_SUCCESS) {
         return buf;
      } else {
         return "";
      }
   }
 
   /* return local time */
   return ss_asctime();
}

Here is the call graph for this function:

cm_asctime() [2/2]

INT cm_asctime	(	char *	str,
		INT	buf_size
	)

Get time from MIDAS server and set local time.

Parameters

str	return time string
buf_size	Maximum size of str

Returns

CM_SUCCESS

Definition at line 1398 of file midas.cxx.

                                        {
   /* if connected to server, get time from there */
   if (rpc_is_remote())
      return rpc_call(RPC_CM_ASCTIME, str, buf_size);
 
   /* return local time */
   strlcpy(str, ss_asctime().c_str(), buf_size);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_check_client()

INT cm_check_client	(	HNDLE	hDB,
		HNDLE	hKeyClient
	)

Check if a client with a /system/client/xxx entry has a valid entry in the ODB client table. If not, remove that client from the /system/client tree.

Parameters

hDB	Handle to online database
hKeyClient	Handle to client key

Returns

CM_SUCCESS, CM_NO_CLIENT

Definition at line 1871 of file midas.cxx.

                                                 {
   if (rpc_is_remote())
      return rpc_call(RPC_CM_CHECK_CLIENT, hDB, hKeyClient);
 
#ifdef LOCAL_ROUTINES
   return db_check_client(hDB, hKeyClient);
#endif                          /*LOCAL_ROUTINES */
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_check_connect()

void cm_check_connect

(

void

)

Definition at line 2203 of file midas.cxx.

                            {
   if (_hKeyClient) {
      cm_msg(MERROR, "cm_check_connect", "cm_disconnect_experiment not called at end of program");
      cm_msg_flush_buffer();
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_check_deferred_transition()

INT cm_check_deferred_transition

(

void

)

Check for any deferred transition. If a deferred transition handler has been registered via the cm_register_deferred_transition function, this routine should be called regularly. It checks if a transition request is pending. If so, it calld the registered handler if the transition should be done and then actually does the transition.

Returns

CM_SUCCESS, <error> Error from cm_transition()

Definition at line 3885 of file midas.cxx.

                                   {
   INT i, status;
   char str[256];
   static BOOL first;
 
   if (_requested_transition == 0)
      first = TRUE;
 
   if (_requested_transition & _deferred_transition_mask) {
      for (i = 0; _deferred_trans_table[i].transition; i++)
         if (_deferred_trans_table[i].transition == _requested_transition)
            break;
 
      if (_deferred_trans_table[i].transition == _requested_transition) {
         if (((BOOL(*)(INT, BOOL)) _deferred_trans_table[i].func)(_requested_transition, first)) {
            status = cm_transition(_requested_transition | TR_DEFERRED, 0, str, sizeof(str), TR_SYNC, FALSE);
            if (status != CM_SUCCESS)
               cm_msg(MERROR, "cm_check_deferred_transition", "Cannot perform deferred transition: %s", str);
 
            /* bypass hotlink and set _requested_transition directly to zero */
            _requested_transition = 0;
 
            return status;
         }
         first = FALSE;
      }
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_cleanup()

INT cm_cleanup	(	const char *	client_name,
		BOOL	ignore_timeout
	)

Remove hanging clients independent of their watchdog timeout.

Since this function does not obey the client watchdog timeout, it should be only called to remove clients which have their watchdog checking turned off or which are known to be dead. The normal client removement is done via cm_watchdog().

Currently (Sept. 02) there are two applications for that:

1. The ODBEdit command "cleanup", which can be used to remove clients which have their watchdog checking off, like the analyzer started with the "-d" flag for a debugging session.
2. The frontend init code to remove previous frontends. This can be helpful if a frontend dies. Normally, one would have to wait 60 sec. for a crashed frontend to be removed. Only then one can start again the frontend. Since the frontend init code contains a call to cm_cleanup(<frontend_name>), one can restart a frontend immediately.

Added ignore_timeout on Nov.03. A logger might have an increased tiemout of up to 60 sec. because of tape operations. If ignore_timeout is FALSE, the logger is then not killed if its inactivity is less than 60 sec., while in the previous implementation it was always killed after 2*WATCHDOG_INTERVAL.

Parameters

client_name	Client name, if zero check all clients
ignore_timeout	If TRUE, ignore a possible increased timeout defined by each client.

Returns

CM_SUCCESS

Definition at line 7574 of file midas.cxx.

                                                             {
   if (rpc_is_remote())
      return rpc_call(RPC_CM_CLEANUP, client_name);
 
#ifdef LOCAL_ROUTINES
   {
      DWORD interval;
      DWORD now = ss_millitime();
 
      std::vector<BUFFER*> mybuffers;
      
      gBuffersMutex.lock();
      mybuffers = gBuffers;
      gBuffersMutex.unlock();
 
      /* check buffers */
      for (BUFFER* pbuf : mybuffers) {
         if (!pbuf)
            continue;
         if (pbuf->attached) {
            std::string msg;
 
            bm_lock_buffer_guard pbuf_guard(pbuf);
 
            if (!pbuf_guard.is_locked())
               continue;
 
            /* update the last_activity entry to show that we are alive */
            BUFFER_HEADER *pheader = pbuf->buffer_header;
            BUFFER_CLIENT *pbclient = pheader->client;
            int idx = bm_validate_client_index(pbuf, FALSE);
            if (idx >= 0)
               pbclient[idx].last_activity = ss_millitime();
 
            /* now check other clients */
            for (int j = 0; j < pheader->max_client_index; j++, pbclient++) {
               if (j != pbuf->client_index && pbclient->pid &&
                   (client_name == NULL || client_name[0] == 0
                    || strncmp(pbclient->name, client_name, strlen(client_name)) == 0)) {
                  if (ignore_timeout)
                     interval = 2 * WATCHDOG_INTERVAL;
                  else
                     interval = pbclient->watchdog_timeout;
 
                  /* If client process has no activity, clear its buffer entry. */
                  if (interval > 0
                      && now > pbclient->last_activity && now - pbclient->last_activity > interval) {
 
                     /* now make again the check with the buffer locked */
                     if (interval > 0
                         && now > pbclient->last_activity && now - pbclient->last_activity > interval) {
                        msg = msprintf(
                                "Client \'%s\' on \'%s\' removed by cm_cleanup (idle %1.1lfs, timeout %1.0lfs)",
                                pbclient->name, pheader->name,
                                (ss_millitime() - pbclient->last_activity) / 1000.0,
                                interval / 1000.0);
 
                        bm_remove_client_locked(pheader, j);
                     }
 
                     /* go again through whole list */
                     j = 0;
                  }
               }
            }
 
            // unlock buffer before calling cm_msg(), if we are SYSMSG, we will deadlock.
            pbuf_guard.unlock();
 
            /* display info message after unlocking buffer */
            if (!msg.empty())
               cm_msg(MINFO, "cm_cleanup", "%s", msg.c_str());
         }
      }
 
      db_cleanup2(client_name, ignore_timeout, now, "cm_cleanup");
   }
#endif                          /* LOCAL_ROUTINES */
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_connect_client()

INT cm_connect_client	(	const char *	client_name,
		HNDLE *	hConn
	)

Connect to a MIDAS client of the current experiment

Parameters

client_name	Name of client to connect to. This name is set by the other client via the cm_connect_experiment call.
hConn	Connection handle

Returns

CM_SUCCESS, CM_NO_CLIENT

Definition at line 2760 of file midas.cxx.

                                                             {
   HNDLE hDB, hKeyRoot, hSubkey, hKey;
   INT status, i, length, port;
   char name[NAME_LENGTH], host_name[HOST_NAME_LENGTH];
 
   /* find client entry in ODB */
   cm_get_experiment_database(&hDB, &hKey);
 
   status = db_find_key(hDB, 0, "System/Clients", &hKeyRoot);
   if (status != DB_SUCCESS)
      return status;
 
   i = 0;
   do {
      /* search for client with specific name */
      status = db_enum_key(hDB, hKeyRoot, i++, &hSubkey);
      if (status == DB_NO_MORE_SUBKEYS)
         return CM_NO_CLIENT;
 
      status = db_find_key(hDB, hSubkey, "Name", &hKey);
      if (status != DB_SUCCESS)
         return status;
 
      length = NAME_LENGTH;
      status = db_get_data(hDB, hKey, name, &length, TID_STRING);
      if (status != DB_SUCCESS)
         return status;
 
      if (equal_ustring(name, client_name)) {
         status = db_find_key(hDB, hSubkey, "Server Port", &hKey);
         if (status != DB_SUCCESS)
            return status;
 
         length = sizeof(INT);
         status = db_get_data(hDB, hKey, &port, &length, TID_INT32);
         if (status != DB_SUCCESS)
            return status;
 
         status = db_find_key(hDB, hSubkey, "Host", &hKey);
         if (status != DB_SUCCESS)
            return status;
 
         length = sizeof(host_name);
         status = db_get_data(hDB, hKey, host_name, &length, TID_STRING);
         if (status != DB_SUCCESS)
            return status;
 
         /* client found -> connect to its server port */
         return rpc_client_connect(host_name, port, client_name, hConn);
      }
 
 
   } while (TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_connect_experiment()

INT cm_connect_experiment	(	const char *	host_name,
		const char *	exp_name,
		const char *	client_name,
		void(*)(char *)	func
	)

This function connects to an existing MIDAS experiment. This must be the first call in a MIDAS application. It opens three TCP connection to the remote host (one for RPC calls, one to send events and one for hot-link notifications from the remote host) and writes client information into the ODB under /System/Clients.

Attention

All MIDAS applications should evaluate the MIDAS_SERVER_HOST and MIDAS_EXPT_NAME environment variables as defaults to the host name and experiment name (see Environment_variables). For that purpose, the function cm_get_environment() should be called prior to cm_connect_experiment(). If command line parameters -h and -e are used, the evaluation should be done between cm_get_environment() and cm_connect_experiment(). The function cm_disconnect_experiment() must be called before a MIDAS application exits.

#include <stdio.h>
#include <midas.h>
main(int argc, char *argv[])
{
  INT  status, i;
  char host_name[256],exp_name[32];
 
  // get default values from environment
  cm_get_environment(host_name, exp_name);
 
  // parse command line parameters
  for (i=1 ; i<argc ; i++)
    {
    if (argv[i][0] == '-')
      {
      if (i+1 >= argc || argv[i+1][0] == '-')
        goto usage;
      if (argv[i][1] == 'e')
        strcpy(exp_name, argv[++i]);
      else if (argv[i][1] == 'h')
        strcpy(host_name, argv[++i]);
      else
        {
usage:
        printf("usage: test [-h Hostname] [-e Experiment]\n\n");
        return 1;
        }
      }
    }
  status = cm_connect_experiment(host_name, exp_name, "Test", NULL);
  if (status != CM_SUCCESS)
    return 1;
  ...do operations...
  cm_disconnect_experiment();
}

Parameters

host_name	Specifies host to connect to. Must be a valid IP host name. The string can be empty ("") if to connect to the local computer.
exp_name	Specifies the experiment to connect to. If this string is empty, the number of defined experiments in exptab is checked. If only one experiment is defined, the function automatically connects to this one. If more than one experiment is defined, a list is presented and the user can interactively select one experiment.
client_name	Client name of the calling program as it can be seen by others (like the scl command in ODBEdit).
func	Callback function to read in a password if security has been enabled. In all command line applications this function is NULL which invokes an internal ss_gets() function to read in a password. In windows environments (MS Windows, X Windows) a function can be supplied to open a dialog box and read in the password. The argument of this function must be the returned password.

Returns

CM_SUCCESS, CM_UNDEF_EXP, CM_SET_ERROR, RPC_NET_ERROR
CM_VERSION_MISMATCH MIDAS library version different on local and remote computer

Definition at line 2280 of file midas.cxx.

                                                                                                                      {
   INT status;
 
   status = cm_connect_experiment1(host_name, exp_name, client_name, func, DEFAULT_ODB_SIZE, DEFAULT_WATCHDOG_TIMEOUT);
   cm_msg_flush_buffer();
   if (status != CM_SUCCESS) {
      std::string s = cm_get_error(status);
      puts(s.c_str());
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_connect_experiment1()

INT cm_connect_experiment1	(	const char *	host_name,
		const char *	default_exp_name,
		const char *	client_name,
		void(*)(char *)	func,
		INT	odb_size,
		DWORD	watchdog_timeout
	)

Connect to a MIDAS experiment (to the online database) on a specific host.

Definition at line 2299 of file midas.cxx.

                                                                                                                {
   INT status, size;
   char client_name1[NAME_LENGTH];
   char password[NAME_LENGTH], str[256];
   HNDLE hDB = 0, hKeyClient = 0;
   BOOL call_watchdog;
 
   ss_tzset(); // required for localtime_r()
 
   if (_hKeyClient)
      cm_disconnect_experiment();
 
   cm_msg_early_init();
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg before connecting to experiment");
   //cm_msg_flush_buffer();
 
   rpc_set_name(client_name);
 
   /* check for local host */
   if (equal_ustring(host_name, "local"))
      host_name = NULL;
 
#ifdef OS_WINNT
   {
      WSADATA WSAData;
 
      /* Start windows sockets */
      if (WSAStartup(MAKEWORD(1, 1), &WSAData) != 0)
         return RPC_NET_ERROR;
   }
#endif
 
   std::string default_exp_name1;
   if (default_exp_name)
      default_exp_name1 = default_exp_name;
 
   /* connect to MIDAS server */
   if (host_name && host_name[0]) {
      if (default_exp_name1.length() == 0) {
         status = cm_select_experiment_remote(host_name, &default_exp_name1);
         if (status != CM_SUCCESS)
            return status;
      }
 
      cm_set_experiment_name(default_exp_name1.c_str());
 
      status = rpc_server_connect(host_name, default_exp_name1.c_str());
      if (status != RPC_SUCCESS)
         return status;
 
      /* register MIDAS library functions */
      status = rpc_register_functions(rpc_get_internal_list(1), NULL);
      if (status != RPC_SUCCESS)
         return status;
   } else {
      /* lookup path for *SHM files and save it */
 
#ifdef LOCAL_ROUTINES
      status = cm_set_experiment_local(default_exp_name1.c_str());
      if (status != CM_SUCCESS)
         return status;
 
      default_exp_name1 = cm_get_experiment_name();
 
      ss_suspend_init_odb_port();
 
      INT semaphore_elog, semaphore_alarm, semaphore_history, semaphore_msg;
 
      /* create alarm and elog semaphores */
      status = ss_semaphore_create("ALARM", &semaphore_alarm);
      if (status != SS_CREATED && status != SS_SUCCESS) {
         cm_msg(MERROR, "cm_connect_experiment", "Cannot create alarm semaphore");
         return status;
      }
      status = ss_semaphore_create("ELOG", &semaphore_elog);
      if (status != SS_CREATED && status != SS_SUCCESS) {
         cm_msg(MERROR, "cm_connect_experiment", "Cannot create elog semaphore");
         return status;
      }
      status = ss_semaphore_create("HISTORY", &semaphore_history);
      if (status != SS_CREATED && status != SS_SUCCESS) {
         cm_msg(MERROR, "cm_connect_experiment", "Cannot create history semaphore");
         return status;
      }
      status = ss_semaphore_create("MSG", &semaphore_msg);
      if (status != SS_CREATED && status != SS_SUCCESS) {
         cm_msg(MERROR, "cm_connect_experiment", "Cannot create message semaphore");
         return status;
      }
 
      cm_set_experiment_semaphore(semaphore_alarm, semaphore_elog, semaphore_history, semaphore_msg);
#else
      return CM_UNDEF_EXP;
#endif
   }
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg before open ODB");
   //cm_msg_flush_buffer();
 
   /* open ODB */
   if (odb_size == 0)
      odb_size = DEFAULT_ODB_SIZE;
 
   status = db_open_database("ODB", odb_size, &hDB, client_name);
   if (status != DB_SUCCESS && status != DB_CREATED) {
      cm_msg(MERROR, "cm_connect_experiment1", "cannot open database, db_open_database() status %d", status);
      return status;
   }
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg after open ODB");
   //cm_msg_flush_buffer();
 
   int odb_timeout = db_set_lock_timeout(hDB, 0);
   size = sizeof(odb_timeout);
   status = db_get_value(hDB, 0, "/Experiment/ODB timeout", &odb_timeout, &size, TID_INT32, TRUE);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_connect_experiment1", "cannot get ODB /Experiment/ODB timeout, status %d", status);
   }
 
   if (odb_timeout > 0) {
      db_set_lock_timeout(hDB, odb_timeout);
   }
 
   BOOL protect_odb = FALSE;
   size = sizeof(protect_odb);
   status = db_get_value(hDB, 0, "/Experiment/Protect ODB", &protect_odb, &size, TID_BOOL, TRUE);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_connect_experiment1", "cannot get ODB /Experiment/Protect ODB, status %d", status);
   }
 
   if (protect_odb) {
      db_protect_database(hDB);
   }
 
   BOOL enable_core_dumps = FALSE;
   size = sizeof(enable_core_dumps);
   status = db_get_value(hDB, 0, "/Experiment/Enable core dumps", &enable_core_dumps, &size, TID_BOOL, TRUE);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_connect_experiment1", "cannot get ODB /Experiment/Enable core dumps, status %d", status);
   }
 
   if (enable_core_dumps) {
#ifdef RLIMIT_CORE
      struct rlimit limit;
      limit.rlim_cur = RLIM_INFINITY;
      limit.rlim_max = RLIM_INFINITY;
      status = setrlimit(RLIMIT_CORE, &limit);
      if (status != 0) {
         cm_msg(MERROR, "cm_connect_experiment", "Cannot setrlimit(RLIMIT_CORE, RLIM_INFINITY), errno %d (%s)", errno,
                strerror(errno));
      }
#else
#warning setrlimit(RLIMIT_CORE) is not available
#endif
   }
 
   size = sizeof(disable_bind_rpc_to_localhost);
   status = db_get_value(hDB, 0, "/Experiment/Security/Enable non-localhost RPC", &disable_bind_rpc_to_localhost, &size,
                         TID_BOOL, TRUE);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_connect_experiment1",
             "cannot get ODB /Experiment/Security/Enable non-localhost RPC, status %d", status);
   }
 
   std::string local_host_name;
   
   /* now setup client info */
   if (!disable_bind_rpc_to_localhost)
      local_host_name = "localhost";
   else
      local_host_name = ss_gethostname();
 
   /* check watchdog timeout */
   if (watchdog_timeout == 0)
      watchdog_timeout = DEFAULT_WATCHDOG_TIMEOUT;
 
   strcpy(client_name1, client_name);
   password[0] = 0;
   status = cm_set_client_info(hDB, &hKeyClient, local_host_name.c_str(), client_name1, rpc_get_hw_type(), password, watchdog_timeout);
 
   if (status == CM_WRONG_PASSWORD) {
      if (func == NULL)
         strcpy(str, ss_getpass("Password: "));
      else
         func(str);
 
      strcpy(password, ss_crypt(str, "mi"));
      status = cm_set_client_info(hDB, &hKeyClient, local_host_name.c_str(), client_name1, rpc_get_hw_type(), password, watchdog_timeout);
      if (status != CM_SUCCESS) {
         /* disconnect */
         if (rpc_is_remote())
            rpc_server_disconnect();
         cm_disconnect_experiment();
 
         return status;
      }
   }
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg after set client info");
   //cm_msg_flush_buffer();
 
   /* tell the rest of MIDAS that ODB is open for business */
 
   cm_set_experiment_database(hDB, hKeyClient);
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg after set experiment database");
   //cm_msg_flush_buffer();
 
   /* cm_msg_open_buffer() calls bm_open_buffer() calls ODB function
    * to get event buffer size, etc */
 
   status = cm_msg_open_buffer();
   if (status != CM_SUCCESS) {
      cm_msg(MERROR, "cm_connect_experiment1", "cannot open message buffer, cm_msg_open_buffer() status %d", status);
      return status;
   }
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg after message system is ready");
   //cm_msg_flush_buffer();
 
   /* set experiment name in ODB if not present */
   std::string current_name;
   db_get_value_string(hDB, 0, "/Experiment/Name", 0, &current_name, TRUE);
   if (current_name.length() == 0 || current_name == "Default") {
      db_set_value_string(hDB, 0, "/Experiment/Name", &default_exp_name1);
   }
 
   if (!rpc_is_remote()) {
      /* experiment path is only set for local connections */
      /* set data dir in ODB */
      std::string path = cm_get_path();
      db_get_value_string(hDB, 0, "/Logger/Data dir", 0, &path, TRUE);
   }
 
   /* register server to be able to be called by other clients */
   status = cm_register_server();
   if (status != CM_SUCCESS) {
      cm_msg(MERROR, "cm_connect_experiment", "Cannot register RPC server, cm_register_server() status %d", status);
      if (!equal_ustring(client_name, "odbedit")) {
         return status;
      }
   }
 
   /* set watchdog timeout */
   cm_get_watchdog_params(&call_watchdog, &watchdog_timeout);
   size = sizeof(watchdog_timeout);
   sprintf(str, "/Programs/%s/Watchdog Timeout", client_name);
   db_get_value(hDB, 0, str, &watchdog_timeout, &size, TID_INT32, TRUE);
   cm_set_watchdog_params(call_watchdog, watchdog_timeout);
 
   /* get final client name */
   std::string xclient_name = rpc_get_name();
 
   /* startup message is not displayed */
   cm_msg(MLOG, "cm_connect_experiment", "Program %s on host %s started", xclient_name.c_str(), local_host_name.c_str());
 
   /* enable system and user messages to stdout as default */
   cm_set_msg_print(MT_ALL, MT_ALL, puts);
 
   /* call cm_check_connect when exiting */
   atexit((void (*)(void)) cm_check_connect);
 
   /* register ctrl-c handler */
   ss_ctrlc_handler(cm_ctrlc_handler);
 
   //cm_msg(MERROR, "cm_connect_experiment", "test cm_msg after connect to experiment is complete");
   //cm_msg_flush_buffer();
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_ctrlc_handler()

void cm_ctrlc_handler

(

int

sig

)

Definition at line 5437 of file midas.cxx.

                               {
   if (_ctrlc_pressed) {
      printf("Received 2nd Ctrl-C, hard abort\n");
      exit(0);
   }
   printf("Received Ctrl-C, aborting...\n");
   _ctrlc_pressed = TRUE;
 
   ss_ctrlc_handler(cm_ctrlc_handler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_delete_client_info()

INT cm_delete_client_info	(	HNDLE	hDB,
		INT	pid
	)

Delete client info from database

Parameters

hDB	Database handle
pid	PID of entry to delete, zero for this process.

Returns

CM_SUCCESS

Definition at line 1854 of file midas.cxx.

                                              {
   /* only do it if local */
   if (!rpc_is_remote()) {
      db_delete_client_info(hDB, pid);
   }
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_deregister_transition()

INT cm_deregister_transition

(

INT

transition

)

Definition at line 3665 of file midas.cxx.

                                             {
   INT status;
   HNDLE hDB, hKey, hKeyTrans;
   char str[256];
 
   /* check for valid transition */
   if (transition != TR_START && transition != TR_STOP && transition != TR_PAUSE && transition != TR_RESUME && transition != TR_STARTABORT) {
      cm_msg(MERROR, "cm_deregister_transition", "Invalid transition request \"%d\"", transition);
      return CM_INVALID_TRANSITION;
   }
 
   cm_get_experiment_database(&hDB, &hKey);
 
   {
      std::lock_guard<std::mutex> guard(_trans_table_mutex);
 
      /* remove existing transition request */
      for (size_t i = 0; i < _trans_table.size(); i++) {
         if (_trans_table[i].transition == transition) {
            _trans_table[i].transition = 0;
            _trans_table[i].sequence_number = 0;
            _trans_table[i].func = NULL;
         }
      }
 
      // implicit unlock
   }
      
   sprintf(str, "Transition %s", cm_transition_name(transition).c_str());
 
   /* unlock database */
   db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
 
   /* set value */
   status = db_find_key(hDB, hKey, str, &hKeyTrans);
   if (hKeyTrans) {
      status = db_delete_key(hDB, hKeyTrans, FALSE);
      if (status != DB_SUCCESS)
         return status;
   }
 
   /* re-lock database */
   db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_disconnect_client()

INT cm_disconnect_client	(	HNDLE	hConn,
		BOOL	bShutdown
	)

Disconnect from a MIDAS client

Parameters

hConn	Connection handle obtained via cm_connect_client()
bShutdown	If TRUE, disconnect from client and shut it down (exit the client program) by sending a RPC_SHUTDOWN message

Returns

see rpc_client_disconnect()

Definition at line 2827 of file midas.cxx.

                                                      {
   return rpc_client_disconnect(hConn, bShutdown);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_disconnect_experiment()

INT cm_disconnect_experiment

(

void

)

Disconnect from a MIDAS experiment.

Attention

Should be the last call to a MIDAS library function in an application before it exits. This function removes the client information from the ODB, disconnects all TCP connections and frees all internal allocated memory. See cm_connect_experiment() for example.

Returns

CM_SUCCESS

Definition at line 2840 of file midas.cxx.

                                   {
   HNDLE hDB, hKey;
 
   //cm_msg(MERROR, "cm_disconnect_experiment", "test cm_msg before disconnect from experiment");
   //cm_msg_flush_buffer();
 
   /* wait on any transition thread */
   if (_trp.transition && !_trp.finished) {
      printf("Waiting for transition to finish...\n");
      do {
         ss_sleep(10);
      } while (!_trp.finished);
   }
 
   /* stop the watchdog thread */
   cm_stop_watchdog_thread();
 
   /* send shutdown notification */
   std::string client_name = rpc_get_name();
 
   std::string local_host_name;
   
   if (!disable_bind_rpc_to_localhost)
      local_host_name = "localhost";
   else {
      local_host_name = ss_gethostname();
      //if (strchr(local_host_name, '.'))
      //   *strchr(local_host_name, '.') = 0;
   }
 
   /* disconnect message not displayed */
   cm_msg(MLOG, "cm_disconnect_experiment", "Program %s on host %s stopped", client_name.c_str(), local_host_name.c_str());
   cm_msg_flush_buffer();
 
   if (rpc_is_remote()) {
      if (rpc_is_connected()) {
         /* close open records */
         db_close_all_records();
 
         cm_msg_close_buffer();
      }
 
      rpc_client_shutdown();
      rpc_server_disconnect();
 
      cm_set_experiment_database(0, 0);
   } else {
      rpc_client_shutdown();
 
      /* delete client info */
      cm_get_experiment_database(&hDB, &hKey);
 
      if (hDB)
         cm_delete_client_info(hDB, 0);
 
      //cm_msg(MERROR, "cm_disconnect_experiment", "test cm_msg before close all buffers, close all databases");
      //cm_msg_flush_buffer();
 
      cm_msg_close_buffer();
      bm_close_all_buffers();
      db_close_all_databases();
 
      cm_set_experiment_database(0, 0);
 
      //cm_msg(MERROR, "cm_disconnect_experiment", "test cm_msg after close all buffers, close all databases");
      //cm_msg_flush_buffer();
   }
 
   if (!rpc_is_mserver())
      rpc_server_shutdown();
 
   /* free RPC list */
   rpc_deregister_functions();
 
   //cm_msg(MERROR, "cm_disconnect_experiment", "test cm_msg before deleting the message ring buffer");
   //cm_msg_flush_buffer();
 
   /* last flush before we delete the message ring buffer */
   cm_msg_flush_buffer();
 
   //cm_msg(MERROR, "cm_disconnect_experiment", "test cm_msg after disconnect is completed");
   //cm_msg_flush_buffer();
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_dispatch_ipc()

INT cm_dispatch_ipc	(	const char *	message,
		int	message_size,
		int	client_socket
	)

dox

Definition at line 5381 of file midas.cxx.

{
   if (message[0] == 'O') {
      HNDLE hDB, hKey, hKeyRoot;
      INT index;
      index = 0;
      sscanf(message + 2, "%d %d %d %d", &hDB, &hKeyRoot, &hKey, &index);
      if (client_socket) {
         return db_update_record_mserver(hDB, hKeyRoot, hKey, index, client_socket);
      } else {
         return db_update_record_local(hDB, hKeyRoot, hKey, index);
      }
   }
 
   /* message == "B" means "resume event sender" */
   if (message[0] == 'B' && message[2] != ' ') {
      char str[NAME_LENGTH];
 
      //printf("cm_dispatch_ipc: message [%s], s=%d\n", message, s);
 
      strlcpy(str, message + 2, sizeof(str));
      if (strchr(str, ' '))
         *strchr(str, ' ') = 0;
 
      if (client_socket)
         return bm_notify_client(str, client_socket);
      else
         return bm_push_event(str);
   }
 
   //printf("cm_dispatch_ipc: message [%s] ignored\n", message);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_exec_script()

int cm_exec_script

(

const char *

odb_path_to_script

)

Definition at line 5457 of file midas.cxx.

{
   HNDLE hDB, hkey;
   KEY key;
   int status;
 
   status = cm_get_experiment_database(&hDB, NULL);
   if (status != DB_SUCCESS)
      return status;
 
   status = db_find_key(hDB, 0, odb_path_to_script, &hkey);
   if (status != DB_SUCCESS)
      return status;
 
   status = db_get_key(hDB, hkey, &key);
   if (status != DB_SUCCESS)
      return status;
 
   std::string command;
 
   if (key.type == TID_STRING) {
      int status = db_get_value_string(hDB, 0, odb_path_to_script, 0, &command, FALSE);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_exec_script", "Script ODB \"%s\" of type TID_STRING, db_get_value_string() error %d",
                odb_path_to_script, status);
         return status;
      }
   } else if (key.type == TID_KEY) {
      for (int i = 0;; i++) {
         HNDLE hsubkey;
         KEY subkey;
         db_enum_key(hDB, hkey, i, &hsubkey);
         if (!hsubkey)
            break;
         db_get_key(hDB, hsubkey, &subkey);
 
         if (i > 0)
            command += " ";
 
         if (subkey.type == TID_KEY) {
            cm_msg(MERROR, "cm_exec_script", "Script ODB \"%s/%s\" should not be TID_KEY", odb_path_to_script,
                   subkey.name);
            return DB_TYPE_MISMATCH;
         } else {
            int size = subkey.item_size;
            char *buf = (char *) malloc(size);
            assert(buf != NULL);
            int status = db_get_data(hDB, hsubkey, buf, &size, subkey.type);
            if (status != DB_SUCCESS) {
               cm_msg(MERROR, "cm_exec_script", "Script ODB \"%s/%s\" of type %d, db_get_data() error %d",
                      odb_path_to_script, subkey.name, subkey.type, status);
               free(buf);
               return status;
            }
            if (subkey.type == TID_STRING) {
               command += buf;
            } else {
               command += db_sprintf(buf, subkey.item_size, 0, subkey.type);
            }
            free(buf);
         }
      }
   } else {
      cm_msg(MERROR, "cm_exec_script", "Script ODB \"%s\" has invalid type %d, should be TID_STRING or TID_KEY",
             odb_path_to_script, key.type);
      return DB_TYPE_MISMATCH;
   }
 
   // printf("exec_script: %s\n", command.c_str());
 
   if (command.length() > 0) {
      cm_msg(MINFO, "cm_exec_script", "Executing script \"%s\" from ODB \"%s\"", command.c_str(), odb_path_to_script);
      ss_system(command.c_str());
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_execute()

INT cm_execute	(	const char *	command,
		char *	result,
		INT	bufsize
	)

Executes command via system() call

Parameters

command	Command string to execute
result	stdout of command
bufsize	string size in byte

Returns

CM_SUCCESS

Definition at line 5719 of file midas.cxx.

                                                               {
   char str[256];
   INT n;
   int fh;
   int status = 0;
   static int check_cm_execute = 1;
   static int enable_cm_execute = 0;
 
   if (rpc_is_remote())
      return rpc_call(RPC_CM_EXECUTE, command, result, bufsize);
 
   if (check_cm_execute) {
      int status;
      int size;
      HNDLE hDB;
      check_cm_execute = 0;
 
      status = cm_get_experiment_database(&hDB, NULL);
      assert(status == DB_SUCCESS);
 
      size = sizeof(enable_cm_execute);
      status = db_get_value(hDB, 0, "/Experiment/Enable cm_execute", &enable_cm_execute, &size, TID_BOOL, TRUE);
      assert(status == DB_SUCCESS);
 
      //printf("enable_cm_execute %d\n", enable_cm_execute);
   }
 
   if (!enable_cm_execute) {
      char buf[32];
      strlcpy(buf, command, sizeof(buf));
      cm_msg(MERROR, "cm_execute", "cm_execute(%s...) is disabled by ODB \"/Experiment/Enable cm_execute\"", buf);
      return CM_WRONG_PASSWORD;
   }
 
   if (bufsize > 0) {
      strcpy(str, command);
      sprintf(str, "%s > %d.tmp", command, ss_getpid());
 
      status = system(str);
 
      sprintf(str, "%d.tmp", ss_getpid());
      fh = open(str, O_RDONLY, 0644);
      result[0] = 0;
      if (fh) {
         n = read(fh, result, bufsize - 1);
         result[MAX(0, n)] = 0;
         close(fh);
      }
      remove(str);
   } else {
      status = system(command);
   }
 
   if (status < 0) {
      cm_msg(MERROR, "cm_execute", "cm_execute(%s) error %d", command, status);
      return CM_SET_ERROR;
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_exist()

INT cm_exist	(	const char *	name,
		BOOL	bUnique
	)

Check if a MIDAS client exists in current experiment

Parameters

name	Client name
bUnique	If true, look for the exact client name. If false, look for namexxx where xxx is a any number

Returns

CM_SUCCESS, CM_NO_CLIENT

Definition at line 7484 of file midas.cxx.

                                             {
   INT status, i, size;
   HNDLE hDB, hKeyClient, hKey, hSubkey;
   char client_name[NAME_LENGTH];
 
   if (rpc_is_remote())
      return rpc_call(RPC_CM_EXIST, name, bUnique);
 
   cm_get_experiment_database(&hDB, &hKeyClient);
 
   status = db_find_key(hDB, 0, "System/Clients", &hKey);
   if (status != DB_SUCCESS)
      return DB_NO_KEY;
 
   db_lock_database(hDB);
 
   /* loop over all clients */
   for (i = 0;; i++) {
      status = db_enum_key(hDB, hKey, i, &hSubkey);
      if (status == DB_NO_MORE_SUBKEYS)
         break;
 
      if (hSubkey == hKeyClient)
         continue;
 
      if (status == DB_SUCCESS) {
         /* get client name */
         size = sizeof(client_name);
         status = db_get_value(hDB, hSubkey, "Name", client_name, &size, TID_STRING, FALSE);
 
         if (status != DB_SUCCESS) {
            //fprintf(stderr, "cm_exist: name %s, i=%d, hSubkey=%d, status %d, client_name %s, my name %s\n", name, i, hSubkey, status, client_name, _client_name);
            continue;
         }
 
         if (equal_ustring(client_name, name)) {
            db_unlock_database(hDB);
            return CM_SUCCESS;
         }
 
         if (!bUnique) {
            client_name[strlen(name)] = 0;      /* strip number */
            if (equal_ustring(client_name, name)) {
               db_unlock_database(hDB);
               return CM_SUCCESS;
            }
         }
      }
   }
 
   db_unlock_database(hDB);
 
   return CM_NO_CLIENT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_expand_env()

std::string cm_expand_env

(

const char *

str

)

Expand environment variables in filesystem file path names

Examples of expansion: $FOO=foo, $BAR=bar, $UNDEF is undefined (undefined, not empty)

ok &= test_cm_expand_env1("aaa", "aaa"); ok &= test_cm_expand_env1("$FOO", "foo"); ok &= test_cm_expand_env1("/$FOO", "/foo"); ok &= test_cm_expand_env1("/$FOO/", "/foo/"); ok &= test_cm_expand_env1("$FOO/$BAR", "foo/bar"); ok &= test_cm_expand_env1("$FOO1", "$FOO1"); ok &= test_cm_expand_env1("1$FOO", "1foo"); ok &= test_cm_expand_env1("$UNDEF", "$UNDEF"); ok &= test_cm_expand_env1("/$UNDEF/", "/$UNDEF/");

Parameters

str	Input file path

Returns

expanded file path

Definition at line 7675 of file midas.cxx.

                                         {
   const char *s = str;
   std::string r;
   for (; *s;) {
      if (*s == '$') {
         s++;
         std::string envname;
         for (; *s;) {
            if (*s == DIR_SEPARATOR)
               break;
            envname += *s;
            s++;
         }
         const char *e = getenv(envname.c_str());
         //printf("expanding [%s] at [%s] envname [%s] value [%s]\n", filename, s, envname.c_str(), e);
         if (!e) {
            //cm_msg(MERROR, "expand_env", "Env.variable \"%s\" cannot be expanded in \"%s\"", envname.c_str(), filename);
            r += '$';
            r += envname;
         } else {
            r += e;
            //if (r[r.length()-1] != DIR_SEPARATOR)
            //r += DIR_SEPARATOR_STR;
         }
      } else {
         r += *s;
         s++;
      }
   }
   return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_client_name()

std::string cm_get_client_name

(

)

Get current client name

Returns

current client name

Definition at line 2061 of file midas.cxx.

{
   INT status;
   HNDLE hDB, hKey;
 
   /* get root key of client */
   cm_get_experiment_database(&hDB, &hKey);
   if (!hDB) {
      return "unknown";
   }
 
   std::string name;
 
   status = db_get_value_string(hDB, hKey, "Name", 0, &name);
   if (status != DB_SUCCESS) {
      return "unknown";
   }
 
   //printf("get client name: [%s]\n", name.c_str());
 
   return name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_environment() [1/2]

INT cm_get_environment	(	char *	host_name,
		int	host_name_size,
		char *	exp_name,
		int	exp_name_size
	)

Returns MIDAS environment variables.

Attention

This function can be used to evaluate the standard MIDAS environment variables before connecting to an experiment (see Environment_variables). The usual way is that the host name and experiment name are first derived from the environment variables MIDAS_SERVER_HOST and MIDAS_EXPT_NAME. They can then be superseded by command line parameters with -h and -e flags.

#include <stdio.h>
#include <midas.h>
main(int argc, char *argv[])
{
  INT  status, i;
  char host_name[256],exp_name[32];
 
  // get default values from environment
  cm_get_environment(host_name, exp_name);
 
  // parse command line parameters
  for (i=1 ; i<argc ; i++)
    {
    if (argv[i][0] == '-')
      {
      if (i+1 >= argc || argv[i+1][0] == '-')
        goto usage;
      if (argv[i][1] == 'e')
        strcpy(exp_name, argv[++i]);
      else if (argv[i][1] == 'h')
        strcpy(host_name, argv[++i]);
      else
        {
usage:
        printf("usage: test [-h Hostname] [-e Experiment]\n\n");
        return 1;
        }
      }
    }
  status = cm_connect_experiment(host_name, exp_name, "Test", NULL);
  if (status != CM_SUCCESS)
    return 1;
    ...do anyting...
  cm_disconnect_experiment();
}

Parameters

host_name	Contents of MIDAS_SERVER_HOST environment variable.
host_name_size	string length
exp_name	Contents of MIDAS_EXPT_NAME environment variable.
exp_name_size	string length

Returns

CM_SUCCESS

Definition at line 2136 of file midas.cxx.

                                                                                               {
   if (host_name)
      host_name[0] = 0;
   if (exp_name)
      exp_name[0] = 0;
 
   if (host_name && getenv("MIDAS_SERVER_HOST"))
      strlcpy(host_name, getenv("MIDAS_SERVER_HOST"), host_name_size);
 
   if (exp_name && getenv("MIDAS_EXPT_NAME"))
      strlcpy(exp_name, getenv("MIDAS_EXPT_NAME"), exp_name_size);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_environment() [2/2]

INT cm_get_environment	(	std::string *	host_name,
		std::string *	exp_name
	)

Definition at line 2151 of file midas.cxx.

                                                                  {
   if (host_name)
      *host_name = "";
   if (exp_name)
      *exp_name = "";
 
   if (host_name && getenv("MIDAS_SERVER_HOST"))
      *host_name = getenv("MIDAS_SERVER_HOST");
 
   if (exp_name && getenv("MIDAS_EXPT_NAME"))
      *exp_name = getenv("MIDAS_EXPT_NAME");
 
   return CM_SUCCESS;
}

cm_get_experiment_database()

INT cm_get_experiment_database	(	HNDLE *	hDB,
		HNDLE *	hKeyClient
	)

dox Get the handle to the ODB from the currently connected experiment.

Attention

This function returns the handle of the online database (ODB) which can be used in future db_xxx() calls. The hkeyclient key handle can be used to access the client information in the ODB. If the client key handle is not needed, the parameter can be NULL.

HNDLE hDB, hkeyclient;
 char  name[32];
 int   size;
 db_get_experiment_database(&hdb, &hkeyclient);
 size = sizeof(name);
 db_get_value(hdb, hkeyclient, "Name", name, &size, TID_STRING, TRUE);
 printf("My name is %s\n", name);

Parameters

hDB	Database handle.
hKeyClient	Handle for key where search starts, zero for root.

Returns

CM_SUCCESS

Definition at line 3005 of file midas.cxx.

                                                              {
   if (_hDB) {
      //printf("cm_get_experiment_database %d %d\n", _hDB, _hKeyClient);
      if (hDB != NULL)
         *hDB = _hDB;
      if (hKeyClient != NULL)
         *hKeyClient = _hKeyClient;
      return CM_SUCCESS;
   } else {
      //printf("cm_get_experiment_database no init\n");
      if (hDB != NULL)
         *hDB = 0;
      if (hKeyClient != NULL)
         *hKeyClient = 0;
      return CM_DB_ERROR;
   }
}

cm_get_experiment_name() [1/2]

std::string cm_get_experiment_name

(

)

Return the experiment name

Returns

experiment name

Definition at line 1582 of file midas.cxx.

                                   {
   return _experiment_name;
}

cm_get_experiment_name() [2/2]

INT cm_get_experiment_name	(	char *	name,
		int	name_length
	)

Return the experiment name

Parameters

name	Pointer to user string, size should be at least NAME_LENGTH
name_size	Size of user string

Returns

CM_SUCCESS

Definition at line 1572 of file midas.cxx.

                                                        {
   strlcpy(name, _experiment_name.c_str(), name_length);
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_experiment_semaphore()

INT cm_get_experiment_semaphore	(	INT *	semaphore_alarm,
		INT *	semaphore_elog,
		INT *	semaphore_history,
		INT *	semaphore_msg
	)

dox

Definition at line 3027 of file midas.cxx.

{
   if (semaphore_alarm)
      *semaphore_alarm = _semaphore_alarm;
   if (semaphore_elog)
      *semaphore_elog = _semaphore_elog;
   if (semaphore_history)
      *semaphore_history = _semaphore_history;
   //if (semaphore_msg)
   //   *semaphore_msg = _semaphore_msg;
   if (semaphore_msg)
      *semaphore_msg = -1;
 
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_get_exptab() [1/2]

int cm_get_exptab	(	const char *	expname,
		char *	dir,
		int	dir_size,
		char *	user,
		int	user_size
	)

Return exptab information for given experiment

Parameters

s	Pointer to string buffer
size	Size of string buffer

Returns

CM_SUCCESS

Definition at line 1832 of file midas.cxx.

                                                                                           {
   std::string sdir, suser;
   int status = cm_get_exptab(expname, &sdir, &suser);
   if (status == CM_SUCCESS) {
      if (dir)
         strlcpy(dir, sdir.c_str(), dir_size);
      if (user)
         strlcpy(user, suser.c_str(), user_size);
      return CM_SUCCESS;
   }
   return CM_UNDEF_EXP;
}

Here is the call graph for this function:

cm_get_exptab() [2/2]

int cm_get_exptab	(	const char *	expname,
		std::string *	dir,
		std::string *	user
	)

Return exptab information for given experiment

Parameters

s	Pointer to string buffer
size	Size of string buffer

Returns

CM_SUCCESS

Definition at line 1801 of file midas.cxx.

                                                                        {
 
   if (_exptab.exptab.size() == 0) {
      int status = cm_read_exptab(&_exptab);
      if (status != CM_SUCCESS)
         return status;
   }
 
   for (unsigned i = 0; i < _exptab.exptab.size(); i++) {
      if (_exptab.exptab[i].name == expname) {
         if (dir)
            *dir = _exptab.exptab[i].directory;
         if (user)
            *user = _exptab.exptab[i].user;
         return CM_SUCCESS;
      }
   }
   if (dir)
      *dir = "";
   if (user)
      *user = "";
   return CM_UNDEF_EXP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_exptab_filename() [1/2]

std::string cm_get_exptab_filename

(

)

Definition at line 1790 of file midas.cxx.

                                   {
   return _exptab.filename;
}

cm_get_exptab_filename() [2/2]

int cm_get_exptab_filename	(	char *	s,
		int	size
	)

Return location of exptab file

Parameters

s	Pointer to string buffer
size	Size of string buffer

Returns

CM_SUCCESS

Definition at line 1785 of file midas.cxx.

                                              {
   strlcpy(s, _exptab.filename.c_str(), size);
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_history_path()

std::string cm_get_history_path

(

const char *

history_channel

)

dox

Definition at line 5839 of file midas.cxx.

{
   int status;
   HNDLE hDB;
   std::string path;
 
   cm_get_experiment_database(&hDB, NULL);
 
   if (history_channel && (strlen(history_channel) > 0)) {
      std::string p;
      p += "/Logger/History/";
      p += history_channel;
      p += "/History dir";
 
      // NB: be careful to avoid creating odb entries under /logger
      // for whatever values of "history_channel" we get called with!
      status = db_get_value_string(hDB, 0, p.c_str(), 0, &path, FALSE);
      if (status == DB_SUCCESS && path.length() > 0) {
         // if not absolute path, prepend with experiment directory
         if (path[0] != DIR_SEPARATOR)
            path = cm_get_path() + path;
         // append directory separator
         if (path.back() != DIR_SEPARATOR)
            path += DIR_SEPARATOR_STR;
         //printf("for [%s] returning [%s] from [%s]\n", history_channel, path.c_str(), p.c_str());
         return path;
      }
   }
 
   status = db_get_value_string(hDB, 0, "/Logger/History dir", 0, &path, TRUE);
   if (status == DB_SUCCESS && path.length() > 0) {
      // if not absolute path, prepend with experiment directory
      if (path[0] != DIR_SEPARATOR)
         path = cm_get_path() + path;
      // append directory separator
      if (path.back() != DIR_SEPARATOR)
         path += DIR_SEPARATOR_STR;
      //printf("for [%s] returning /Logger/History dir [%s]\n", history_channel, path.c_str());
      return path;
   }
 
   status = db_get_value_string(hDB, 0, "/Logger/Data dir", 0, &path, FALSE);
   if (status == DB_SUCCESS && path.length() > 0) {
      // if not absolute path, prepend with experiment directory
      if (path[0] != DIR_SEPARATOR)
         path = cm_get_path() + path;
      // append directory separator
      if (path.back() != DIR_SEPARATOR)
         path += DIR_SEPARATOR_STR;
      //printf("for [%s] returning /Logger/Data dir [%s]\n", history_channel, path.c_str());
      return path;
   }
 
   //printf("for [%s] returning experiment dir [%s]\n", history_channel, cm_get_path().c_str());
   return cm_get_path();
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_path() [1/2]

std::string cm_get_path

(

)

Return the path name previously set with cm_set_path.

Parameters

path

Pathname

Returns

CM_SUCCESS

Definition at line 1539 of file midas.cxx.

                        {
   assert(_path_name.length() > 0);
   return _path_name;
}

cm_get_path() [2/2]

INT cm_get_path	(	char *	path,
		int	path_size
	)

Return the path name previously set with cm_set_path.

Parameters

path

Pathname

Returns

CM_SUCCESS

Definition at line 1520 of file midas.cxx.

                                           {
   // check that we were not accidentally called
   // with the size of the pointer to a string
   // instead of the size of the string buffer
   assert(path_size != sizeof(char *));
   assert(path);
   assert(_path_name.length() > 0);
 
   strlcpy(path, _path_name.c_str(), path_size);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_path_string()

INT EXPRT cm_get_path_string

(

std::string *

path

)

Definition at line 1547 of file midas.cxx.

                                              {
   assert(path != NULL);
   assert(_path_name.length() > 0);
   *path = _path_name;
   return CM_SUCCESS;
}

cm_get_revision()

const char* cm_get_revision

(

void

)

Return git revision number of current MIDAS library as a string

Returns

revision number

Definition at line 1486 of file midas.cxx.

                              {
   return GIT_REVISION;
}

Here is the caller graph for this function:

cm_get_version()

const char* cm_get_version

(

void

)

Return version number of current MIDAS library as a string

Returns

version number

Definition at line 1478 of file midas.cxx.

                             {
   return MIDAS_VERSION;
}

Here is the caller graph for this function:

cm_get_watchdog_info()

INT cm_get_watchdog_info	(	HNDLE	hDB,
		const char *	client_name,
		DWORD *	timeout,
		DWORD *	last
	)

Return watchdog information about specific client

Parameters

hDB	ODB handle
client_name	ODB client name
timeout	Timeout for this application in seconds
last	Last time watchdog was called in msec

Returns

CM_SUCCESS, CM_NO_CLIENT, DB_INVALID_HANDLE

Definition at line 3332 of file midas.cxx.

                                                                                          {
   if (rpc_is_remote())
      return rpc_call(RPC_CM_GET_WATCHDOG_INFO, hDB, client_name, timeout, last);
 
#ifdef LOCAL_ROUTINES
   return db_get_watchdog_info(hDB, client_name, timeout, last);
#else                           /* LOCAL_ROUTINES */
   return CM_SUCCESS;
#endif                          /* LOCAL_ROUTINES */
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_get_watchdog_params()

INT cm_get_watchdog_params	(	BOOL *	call_watchdog,
		DWORD *	timeout
	)

Return the current watchdog parameters

Parameters

call_watchdog	Call the cm_watchdog routine periodically
timeout	Timeout for this application in seconds

Returns

CM_SUCCESS

Definition at line 3313 of file midas.cxx.

                                                                {
   if (call_watchdog)
      *call_watchdog = FALSE;
   if (timeout)
      *timeout = _watchdog_timeout;
 
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_is_ctrlc_pressed()

BOOL cm_is_ctrlc_pressed

(

void

)

Definition at line 5448 of file midas.cxx.

                           {
   return _ctrlc_pressed;
}

Here is the caller graph for this function:

cm_list_experiments_local()

INT cm_list_experiments_local

(

STRING_LIST *

exp_names

)

Read exptab and return all defined experiments in *exp_name[MAX_EXPERIMENTS]

Parameters

host_name	Internet host name.
exp_name	list of experiment names

Returns

CM_SUCCESS, RPC_NET_ERROR

Definition at line 2580 of file midas.cxx.

                                                      {
   assert(exp_names != NULL);
   exp_names->clear();
 
   if (_exptab.exptab.size() == 0) {
      int status = cm_read_exptab(&_exptab);
      if (status != CM_SUCCESS)
         return status;
   }
   
   for (unsigned i=0; i<_exptab.exptab.size(); i++) {
      exp_names->push_back(_exptab.exptab[i].name);
   }
   
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_list_experiments_remote()

INT cm_list_experiments_remote	(	const char *	host_name,
		STRING_LIST *	exp_names
	)

Connect to a MIDAS server and return all defined experiments in *exp_name[MAX_EXPERIMENTS]

Parameters

host_name	Internet host name.
exp_name	list of experiment names

Returns

CM_SUCCESS, RPC_NET_ERROR

Definition at line 2606 of file midas.cxx.

                                                                              {
   INT status;
   INT sock;
   int port = MIDAS_TCP_PORT;
   char hname[256];
   char *s;
 
   assert(exp_names != NULL);
   exp_names->clear();
 
   /* extract port number from host_name */
   strlcpy(hname, host_name, sizeof(hname));
   s = strchr(hname, ':');
   if (s) {
      *s = 0;
      port = strtoul(s + 1, NULL, 0);
   }
 
   std::string errmsg;
 
   status = ss_socket_connect_tcp(hname, port, &sock, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "cm_list_experiments_remote", "Cannot connect to \"%s\" port %d: %s", hname, port, errmsg.c_str());
      return RPC_NET_ERROR;
   }
 
   /* request experiment list */
   send(sock, "I", 2, 0);
 
   while (1) {
      char str[256];
 
      status = recv_string(sock, str, sizeof(str), _rpc_connect_timeout);
 
      if (status < 0)
         return RPC_NET_ERROR;
 
      if (status == 0)
         break;
 
      exp_names->push_back(str);
   }
 
   ss_socket_close(&sock);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_periodic_tasks()

INT cm_periodic_tasks

(

void

)

Perform midas periodic tasks - check alarms, update and check timeouts on odb and on event buffers, etc. Normally called by cm_yield(). Programs that do not use cm_yield(), i.e. the mserver, should call this function periodically, every 1 or 2 seconds.

Returns

CM_SUCCESS

Definition at line 5575 of file midas.cxx.

                        {
   static DWORD alarm_last_checked_sec = 0;
   DWORD now_sec = ss_time();
 
   DWORD now_millitime = ss_millitime();
   static DWORD last_millitime = 0;
   DWORD tdiff_millitime = now_millitime - last_millitime;
   const DWORD kPeriod = 1000;
   if (last_millitime == 0) {
      last_millitime = now_millitime;
      tdiff_millitime = kPeriod; // make sure first time we come here we do something.
   }
 
   //printf("cm_periodic_tasks! tdiff_millitime %d\n", (int)tdiff_millitime);
 
   //if (now_millitime < last_millitime) {
   //   printf("millitime wraparound 0x%08x -> 0x%08x\n", last_millitime, now_millitime);
   //}
 
   /* check alarms once every 10 seconds */
   if (now_sec - alarm_last_checked_sec > 10) {
      al_check();
      alarm_last_checked_sec = now_sec;
   }
 
   /* run periodic checks previously done by cm_watchdog */
 
   if (tdiff_millitime >= kPeriod) {
      BOOL wrong_interval = FALSE;
      if (tdiff_millitime > 60000)
         wrong_interval = TRUE;
 
      //printf("millitime %u, diff %u, wrong_interval %d\n", now_millitime, tdiff_millitime, wrong_interval);
 
      bm_cleanup("cm_periodic_tasks", now_millitime, wrong_interval);
      db_cleanup("cm_periodic_tasks", now_millitime, wrong_interval);
 
      bm_write_statistics_to_odb();
 
      last_millitime = now_millitime;
   }
 
   /* reap transition thread */
 
   cm_transition_cleanup();
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_read_exptab()

INT cm_read_exptab

(

exptab_struct *

exptab

)

Scan the "exptab" file for MIDAS experiment names and save them for later use by rpc_server_accept(). The file is first searched under $MIDAS/exptab if present, then the directory from argv[0] is probed.

Returns

CM_SUCCESS
CM_UNDEF_EXP exptab not found and MIDAS_DIR not set

Definition at line 1616 of file midas.cxx.

{
   exptab->exptab.clear();
 
   /* MIDAS_DIR overrides exptab */
   if (getenv("MIDAS_DIR")) {
      exptab->filename = "";
 
      exptab_entry e;
 
      if (getenv("MIDAS_EXPT_NAME")) {
         e.name = getenv("MIDAS_EXPT_NAME");
      } else {
         e.name = "Default";
         cm_msg(MERROR, "cm_read_exptab", "Experiments that use MIDAS_DIR must also set MIDAS_EXPT_NAME to the name of the experiment! Using experiment name \"%s\"", e.name.c_str());
      }
 
      e.directory = getenv("MIDAS_DIR");
      e.user = "";
 
      exptab->exptab.push_back(e);
 
      return CM_SUCCESS;
   }
 
   /* default directory for different OSes */
#if defined (OS_WINNT)
   std::string str;
   if (getenv("SystemRoot"))
      str = getenv("SystemRoot");
   else if (getenv("windir"))
      str = getenv("windir");
   else
      str = "";
 
   std::string alt_str = str;
   str += "\\system32\\exptab";
   alt_str += "\\system\\exptab";
#elif defined (OS_UNIX)
   std::string str = "/etc/exptab";
   std::string alt_str = "/exptab";
#else
   std::strint str = "exptab";
   std::string alt_str = "exptab";
#endif
 
   /* MIDAS_EXPTAB overrides default directory */
   if (getenv("MIDAS_EXPTAB")) {
      str = getenv("MIDAS_EXPTAB");
      alt_str = getenv("MIDAS_EXPTAB");
   }
   
   exptab->filename = str;
 
   /* read list of available experiments */
   FILE* f = fopen(str.c_str(), "r");
   if (f == NULL) {
      f = fopen(alt_str.c_str(), "r");
      if (f == NULL)
         return CM_UNDEF_ENVIRON;
      exptab->filename = alt_str;
   }
 
   if (f != NULL) {
      do {
         char buf[256];
         memset(buf, 0, sizeof(buf));
         char* str = fgets(buf, sizeof(buf)-1, f);
         if (str == NULL)
            break;
         if (str[0] == 0) continue; // empty line
         if (str[0] == '#') continue; // comment line
 
         exptab_entry e;
 
         // following code emulates the function of this sprintf():
         //sscanf(str, "%s %s %s", exptab[i].name, exptab[i].directory, exptab[i].user);
 
         // skip leading spaces
         while (*str && isspace(*str))
            str++;
 
         char* p1 = str;
         char* p2 = str;
 
         while (*p2 && !isspace(*p2))
            p2++;
 
         ssize_t len = p2-p1;
 
         if (len<1)
            continue;
         
         //printf("str %d [%s] p1 [%s] p2 %d [%s] len %d\n", *str, str, p1, *p2, p2, (int)len);
 
         e.name = std::string(p1, len);
 
         if (*p2 == 0)
            continue;
 
         str = p2;
 
         // skip leading spaces
         while (*str && isspace(*str))
            str++;
         
         p1 = str;
         p2 = str;
 
         while (*p2 && !isspace(*p2))
            p2++;
 
         len = p2-p1;
 
         if (len<1)
            continue;
         
         //printf("str %d [%s] p1 [%s] p2 %d [%s] len %d\n", *str, str, p1, *p2, p2, (int)len);
 
         e.directory = std::string(p1, len);
 
         if (*p2 == 0)
            continue;
 
         str = p2;
 
         // skip leading spaces
         while (*str && isspace(*str))
            str++;
         
         p1 = str;
         p2 = str;
 
         while (*p2 && !isspace(*p2))
            p2++;
 
         len = p2-p1;
 
         //printf("str %d [%s] p1 [%s] p2 %d [%s] len %d\n", *str, str, p1, *p2, p2, (int)len);
 
         e.user = std::string(p1, len);
         
         /* check for trailing directory separator */
         if (!ends_with_char(e.directory, DIR_SEPARATOR)) {
            e.directory += DIR_SEPARATOR_STR;
         }
         
         exptab->exptab.push_back(e);
      } while (!feof(f));
      fclose(f);
   }
 
#if 0
   cm_msg(MINFO, "cm_read_exptab", "Read exptab \"%s\":", exptab->filename.c_str()); 
   for (unsigned j=0; j<exptab->exptab.size(); j++) {
      cm_msg(MINFO, "cm_read_exptab", "entry %d, experiment \"%s\", directory \"%s\", user \"%s\"", j, exptab->exptab[j].name.c_str(), exptab->exptab[j].directory.c_str(), exptab->exptab[j].user.c_str());
   }
#endif
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_register_deferred_transition()

INT cm_register_deferred_transition	(	INT	transition,
		BOOL(*)(INT, BOOL)	func
	)

dox Register a deferred transition handler. If a client is registered as a deferred transition handler, it may defer a requested transition by returning FALSE until a certain condition (like a motor reaches its end position) is reached.

Parameters

transition	One of TR_xxx
(*func)	Function which gets called whenever a transition is requested. If it returns FALSE, the transition is not performed.

Returns

CM_SUCCESS, <error> Error from ODB access

Definition at line 3833 of file midas.cxx.

                                                                            {
   INT status, size;
   char tr_key_name[256];
   HNDLE hDB, hKey;
 
   cm_get_experiment_database(&hDB, &hKey);
 
   for (int i = 0; _deferred_trans_table[i].transition; i++)
      if (_deferred_trans_table[i].transition == transition)
         _deferred_trans_table[i].func = (int (*)(int, char *)) func;
 
   /* set new transition mask */
   _deferred_transition_mask |= transition;
 
   sprintf(tr_key_name, "Transition %s DEFERRED", cm_transition_name(transition).c_str());
 
   /* unlock database */
   db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE, TRUE);
 
   /* set value */
   int i = 0;
   status = db_set_value(hDB, hKey, tr_key_name, &i, sizeof(INT), 1, TID_INT32);
   if (status != DB_SUCCESS)
      return status;
 
   /* re-lock database */
   db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
   /* hot link requested transition */
   size = sizeof(_requested_transition);
   db_get_value(hDB, 0, "/Runinfo/Requested Transition", &_requested_transition, &size, TID_INT32, TRUE);
   db_find_key(hDB, 0, "/Runinfo/Requested Transition", &hKey);
   status = db_open_record(hDB, hKey, &_requested_transition, sizeof(INT), MODE_READ, NULL, NULL);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_register_deferred_transition", "Cannot hotlink /Runinfo/Requested Transition");
      return status;
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_register_function()

INT cm_register_function	(	INT	id,
		INT(*)(INT, void **)	func
	)

dox

Definition at line 5786 of file midas.cxx.

{
   HNDLE hDB, hKey;
   INT status;
   char str[80];
 
   status = rpc_register_function(id, func);
   if (status != RPC_SUCCESS)
      return status;
 
   cm_get_experiment_database(&hDB, &hKey);
 
   /* create new key for this id */
   status = 1;
   sprintf(str, "RPC/%d", id);
 
   db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE, TRUE);
   status = db_set_value(hDB, hKey, str, &status, sizeof(BOOL), 1, TID_BOOL);
   db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
   if (status != DB_SUCCESS)
      return status;
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_register_server()

INT cm_register_server

(

void

)

Definition at line 3448 of file midas.cxx.

{
   if (!_rpc_registered) {
      INT status;
      int size;
      HNDLE hDB, hKey;
      char name[NAME_LENGTH];
      char str[256];
      int port = 0;
 
      cm_get_experiment_database(&hDB, &hKey);
 
      size = sizeof(name);
      status = db_get_value(hDB, hKey, "Name", &name, &size, TID_STRING, FALSE);
 
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_register_server", "cannot get client name, db_get_value() status %d", status);
         return status;
      }
 
      strlcpy(str, "/Experiment/Security/RPC ports/", sizeof(str));
      strlcat(str, name, sizeof(str));
 
      size = sizeof(port);
      status = db_get_value(hDB, 0, str, &port, &size, TID_UINT32, TRUE);
 
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_register_server", "cannot get RPC port number, db_get_value(%s) status %d", str, status);
         return status;
      }
 
      int lport = 0; // actual port number assigned to us by the OS
 
      status = rpc_register_server(port, &_rpc_listen_socket, &lport);
      if (status != RPC_SUCCESS) {
         cm_msg(MERROR, "cm_register_server", "error, rpc_register_server(port=%d) status %d", port, status);
         return status;
      }
 
      _rpc_registered = TRUE;
 
      /* register MIDAS library functions */
      rpc_register_functions(rpc_get_internal_list(1), NULL);
 
      /* store port number in ODB */
 
      status = db_find_key(hDB, hKey, "Server Port", &hKey);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_register_server", "error, db_find_key(\"Server Port\") status %d", status);
         return status;
      }
 
      /* unlock database */
      db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE, TRUE);
 
      /* set value */
      status = db_set_data(hDB, hKey, &lport, sizeof(INT), 1, TID_INT32);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_register_server", "error, db_set_data(\"Server Port\"=%d) status %d", port, status);
         return status;
      }
 
      /* lock database */
      db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
      init_rpc_hosts(hDB);
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_register_transition()

INT cm_register_transition	(	INT	transition,
		INT(*)(INT, char *)	func,
		INT	sequence_number
	)

dox Registers a callback function for run transitions. This function internally registers the transition callback function and publishes its request for transition notification by writing a transition request to /System/Clients/<pid>/Transition XXX. Other clients making a transition scan the transition requests of all clients and call their transition callbacks via RPC.

Clients can register for transitions (Start/Stop/Pause/Resume) in a given sequence. All sequence numbers given in the registration are sorted on a transition and the clients are contacted in ascending order. By default, all programs register with a sequence number of 500. The logger however uses 200 for start, so that it can open files before the other clients are contacted, and 800 for stop, so that the files get closed when all other clients have gone already through the stop trantition.

The callback function returns CM_SUCCESS if it can perform the transition or a value larger than one in case of error. An error string can be copied into the error variable.

Attention

The callback function will be called on transitions from inside the cm_yield() function which therefore must be contained in the main program loop.

INT start(INT run_number, char *error)
{
  if (<not ok>)
    {
    strcpy(error, "Cannot start because ...");
    return 2;
    }
  printf("Starting run %d\n", run_number);
  return CM_SUCCESS;
}
main()
{
  ...
  cm_register_transition(TR_START, start, 500);
  do
    {
    status = cm_yield(1000);
    } while (status != RPC_SHUTDOWN &&
             status != SS_ABORT);
  ...
}

Parameters

transition	Transition to register for (see state_transition)
func	Callback function.
sequence_number	Sequence number for that transition (1..1000)

Returns

CM_SUCCESS

Definition at line 3589 of file midas.cxx.

                                                                                         {
   INT status;
   HNDLE hDB, hKey, hKeyTrans;
   KEY key;
   char str[256];
 
   /* check for valid transition */
   if (transition != TR_START && transition != TR_STOP && transition != TR_PAUSE && transition != TR_RESUME && transition != TR_STARTABORT) {
      cm_msg(MERROR, "cm_register_transition", "Invalid transition request \"%d\"", transition);
      return CM_INVALID_TRANSITION;
   }
 
   cm_get_experiment_database(&hDB, &hKey);
 
   rpc_register_function(RPC_RC_TRANSITION, rpc_transition_dispatch);
 
   /* register new transition request */
 
   {
      std::lock_guard<std::mutex> guard(_trans_table_mutex);
 
      for (size_t i = 0; i < _trans_table.size(); i++) {
         if (_trans_table[i].transition == transition && _trans_table[i].sequence_number == sequence_number) {
            cm_msg(MERROR, "cm_register_transition", "transition %s with sequence number %d is already registered", cm_transition_name(transition).c_str(), sequence_number);
            return CM_INVALID_TRANSITION;
         }
      }
 
      bool found = false;
      for (size_t i = 0; i < _trans_table.size(); i++) {
         if (!_trans_table[i].transition) {
            _trans_table[i].transition = transition;
            _trans_table[i].sequence_number = sequence_number;
            _trans_table[i].func = func;
            found = true;
            break;
         }
      }
 
      if (!found) {
         TRANS_TABLE tt;
         tt.transition = transition;
         tt.sequence_number = sequence_number;
         tt.func = func;
         _trans_table.push_back(tt);
      }
 
      // implicit unlock
   }
 
   sprintf(str, "Transition %s", cm_transition_name(transition).c_str());
 
   /* unlock database */
   db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
 
   /* set value */
   status = db_find_key(hDB, hKey, str, &hKeyTrans);
   if (!hKeyTrans) {
      status = db_set_value(hDB, hKey, str, &sequence_number, sizeof(INT), 1, TID_INT32);
      if (status != DB_SUCCESS)
         return status;
   } else {
      status = db_get_key(hDB, hKeyTrans, &key);
      if (status != DB_SUCCESS)
         return status;
      status = db_set_data_index(hDB, hKeyTrans, &sequence_number, sizeof(INT), key.num_values, TID_INT32);
      if (status != DB_SUCCESS)
         return status;
   }
 
   /* re-lock database */
   db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_select_experiment_local()

INT cm_select_experiment_local

(

std::string *

exp_name

)

Read exptab and select an experiment from the experiments available on this server

Parameters

exp_name

selected experiment name

Returns

CM_SUCCESS

Definition at line 2664 of file midas.cxx.

                                                    {
   INT status;
   STRING_LIST expts;
 
   assert(exp_name != NULL);
 
   /* retrieve list of experiments and make selection */
   status = cm_list_experiments_local(&expts);
   if (status != CM_SUCCESS)
      return status;
 
   if (expts.size() == 1) {
      *exp_name = expts[0];
   } else if (expts.size() > 1) {
      printf("Available experiments on local computer:\n");
 
      for (unsigned i = 0; i < expts.size(); i++) {
         printf("%d : %s\n", i, expts[i].c_str());
      }
 
      while (1) {
         printf("Select number from 0 to %d: ", ((int)expts.size())-1);
         char str[32];
         ss_gets(str, 32);
         int isel = atoi(str);
         if (isel < 0)
            continue;
         if (isel >= (int)expts.size())
            continue;
         *exp_name = expts[isel];
         break;
      }
   } else {
      return CM_UNDEF_EXP;
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_select_experiment_remote()

INT cm_select_experiment_remote	(	const char *	host_name,
		std::string *	exp_name
	)

Connect to a MIDAS server and select an experiment from the experiments available on this server

Parameters

host_name	Internet host name.
exp_name	selected experiment name

Returns

CM_SUCCESS, RPC_NET_ERROR

Definition at line 2713 of file midas.cxx.

                                                                            {
   INT status;
   STRING_LIST expts;
 
   assert(exp_name != NULL);
 
   /* retrieve list of experiments and make selection */
   status = cm_list_experiments_remote(host_name, &expts);
   if (status != CM_SUCCESS)
      return status;
 
   if (expts.size() > 1) {
      printf("Available experiments on server %s:\n", host_name);
 
      for (unsigned i = 0; i < expts.size(); i++) {
         printf("%d : %s\n", i, expts[i].c_str());
      }
 
      while (1) {
         printf("Select number from 0 to %d: ", ((int)expts.size())-1);
         char str[32];
         ss_gets(str, 32);
         int isel = atoi(str);
         if (isel < 0)
            continue;
         if (isel >= (int)expts.size())
            continue;
         *exp_name = expts[isel];
         break;
      }
   } else {
      *exp_name = expts[0];
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_client_info()

INT cm_set_client_info	(	HNDLE	hDB,
		HNDLE *	hKeyClient,
		const char *	host_name,
		char *	client_name,
		INT	hw_type,
		const char *	password,
		DWORD	watchdog_timeout
	)

Set client information in online database and return handle

Parameters

hDB	Handle to online database
hKeyClient	returned key
host_name	server name
client_name	Name of this program as it will be seen by other clients.
hw_type	Type of byte order
password	MIDAS password
watchdog_timeout	Default watchdog timeout, can be overwritten by ODB setting /programs/<name>/Watchdog timeout

Returns

CM_SUCCESS

Definition at line 1895 of file midas.cxx.

                                                                                                     {
   if (rpc_is_remote())
      return rpc_call(RPC_CM_SET_CLIENT_INFO, hDB, hKeyClient,
                      host_name, client_name, hw_type, password, watchdog_timeout);
 
#ifdef LOCAL_ROUTINES
   {
      INT status, pid, data, i, idx, size;
      HNDLE hKey, hSubkey;
      char str[256], name[NAME_LENGTH], orig_name[NAME_LENGTH], pwd[NAME_LENGTH];
      BOOL call_watchdog, allow;
      PROGRAM_INFO_STR(program_info_str);
 
      /* check security if password is present */
      status = db_find_key(hDB, 0, "/Experiment/Security/Password", &hKey);
      if (hKey) {
         /* get password */
         size = sizeof(pwd);
         db_get_data(hDB, hKey, pwd, &size, TID_STRING);
 
         /* first check allowed hosts list */
         allow = FALSE;
         db_find_key(hDB, 0, "/Experiment/Security/Allowed hosts", &hKey);
         if (hKey && db_find_key(hDB, hKey, host_name, &hKey) == DB_SUCCESS)
            allow = TRUE;
 
         /* check allowed programs list */
         db_find_key(hDB, 0, "/Experiment/Security/Allowed programs", &hKey);
         if (hKey && db_find_key(hDB, hKey, client_name, &hKey) == DB_SUCCESS)
            allow = TRUE;
 
         /* now check password */
         if (!allow && strcmp(password, pwd) != 0) {
            if (password[0])
               cm_msg(MINFO, "cm_set_client_info", "Wrong password for host %s", host_name);
            return CM_WRONG_PASSWORD;
         }
      }
 
      /* make following operation atomic by locking database */
      db_lock_database(hDB);
 
      /* check if entry with this pid exists already */
      pid = ss_getpid();
 
      sprintf(str, "System/Clients/%0d", pid);
      status = db_find_key(hDB, 0, str, &hKey);
      if (status == DB_SUCCESS) {
         db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
         db_delete_key(hDB, hKey, TRUE);
      }
 
      if (strlen(client_name) >= NAME_LENGTH)
         client_name[NAME_LENGTH] = 0;
 
      strcpy(name, client_name);
      strcpy(orig_name, client_name);
 
      /* check if client name already exists */
      status = db_find_key(hDB, 0, "System/Clients", &hKey);
 
      for (idx = 1; status != DB_NO_MORE_SUBKEYS; idx++) {
         for (i = 0;; i++) {
            status = db_enum_key(hDB, hKey, i, &hSubkey);
            if (status == DB_NO_MORE_SUBKEYS)
               break;
 
            if (status == DB_SUCCESS) {
               size = sizeof(str);
               status = db_get_value(hDB, hSubkey, "Name", str, &size, TID_STRING, FALSE);
               if (status != DB_SUCCESS)
                  continue;
            }
 
            /* check if client is living */
            if (cm_check_client(hDB, hSubkey) == CM_NO_CLIENT)
               continue;
 
            if (equal_ustring(str, name)) {
               sprintf(name, "%s%d", client_name, idx);
               break;
            }
         }
      }
 
      /* set name */
      sprintf(str, "System/Clients/%0d/Name", pid);
      status = db_set_value(hDB, 0, str, name, NAME_LENGTH, 1, TID_STRING);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         cm_msg(MERROR, "cm_set_client_info", "cannot set client name, db_set_value(%s) status %d", str, status);
         return status;
      }
 
      /* copy new client name */
      strcpy(client_name, name);
      db_set_client_name(hDB, client_name);
 
      /* set also as rpc name */
      rpc_set_name(client_name);
 
      /* use /system/clients/PID as root */
      sprintf(str, "System/Clients/%0d", pid);
      db_find_key(hDB, 0, str, &hKey);
 
      /* set host name */
      status = db_set_value(hDB, hKey, "Host", host_name, HOST_NAME_LENGTH, 1, TID_STRING);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      /* set computer id */
      status = db_set_value(hDB, hKey, "Hardware type", &hw_type, sizeof(hw_type), 1, TID_INT32);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      /* set server port */
      data = 0;
      status = db_set_value(hDB, hKey, "Server Port", &data, sizeof(INT), 1, TID_INT32);
      if (status != DB_SUCCESS) {
         db_unlock_database(hDB);
         return status;
      }
 
      /* lock client entry */
      db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
      /* get (set) default watchdog timeout */
      size = sizeof(watchdog_timeout);
      sprintf(str, "/Programs/%s/Watchdog Timeout", orig_name);
      db_get_value(hDB, 0, str, &watchdog_timeout, &size, TID_INT32, TRUE);
 
      /* define /programs entry */
      sprintf(str, "/Programs/%s", orig_name);
      db_create_record(hDB, 0, str, strcomb1(program_info_str).c_str());
 
      /* save handle for ODB and client */
      cm_set_experiment_database(hDB, hKey);
 
      /* save watchdog timeout */
      cm_get_watchdog_params(&call_watchdog, NULL);
      cm_set_watchdog_params(call_watchdog, watchdog_timeout);
 
      /* end of atomic operations */
      db_unlock_database(hDB);
 
      /* touch notify key to inform others */
      data = 0;
      db_set_value(hDB, 0, "/System/Client Notify", &data, sizeof(data), 1, TID_INT32);
 
      *hKeyClient = hKey;
   }
#endif                          /* LOCAL_ROUTINES */
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_client_run_state()

INT cm_set_client_run_state

(

INT

state

)

Definition at line 3779 of file midas.cxx.

                                       {
   INT status;
   HNDLE hDB, hKey;
   KEY key;
 
   cm_get_experiment_database(&hDB, &hKey);
 
   /* check that hKey is still valid */
   status = db_get_key(hDB, hKey, &key);
 
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_set_client_run_state",
             "Cannot set client run state, client hKey %d into /System/Clients is not valid, maybe this client was removed by a watchdog timeout",
             hKey);
      return status;
   }
 
   /* unlock database */
   db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE, TRUE);
 
   /* set value */
   status = db_set_value(hDB, hKey, "Run state", &state, sizeof(INT), 1, TID_INT32);
   if (status != DB_SUCCESS)
      return status;
 
   /* re-lock database */
   db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
   return CM_SUCCESS;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_experiment_database()

INT cm_set_experiment_database	(	HNDLE	hDB,
		HNDLE	hKeyClient
	)

Set the handle to the ODB for the currently connected experiment

Parameters

hDB	Database handle
hKeyClient	Key handle of client structure

Returns

CM_SUCCESS

Definition at line 2933 of file midas.cxx.

                                                            {
   //printf("cm_set_experiment_database: hDB %d, hKeyClient %d\n", hDB, hKeyClient);
 
   _hDB = hDB;
   _hKeyClient = hKeyClient;
 
   //if (hDB == 0) {
   //   rpc_set_server_option(RPC_ODB_HANDLE, 0);
   //}
 
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_set_experiment_local()

int cm_set_experiment_local

(

const char *

exp_name

)

Definition at line 2168 of file midas.cxx.

{
   std::string exp_name1;
 
   if ((exp_name != NULL) && (strlen(exp_name) > 0)) {
      exp_name1 = exp_name;
   } else {
      int status = cm_select_experiment_local(&exp_name1);
      if (status != CM_SUCCESS)
         return status;
   }
 
   std::string expdir, expuser;
   
   int status = cm_get_exptab(exp_name1.c_str(), &expdir, &expuser);
   
   if (status != CM_SUCCESS) {
      cm_msg(MERROR, "cm_set_experiment_local", "Experiment \"%s\" not found in exptab file \"%s\"", exp_name1.c_str(), cm_get_exptab_filename().c_str());
      return CM_UNDEF_EXP;
   }
 
   if (!ss_dir_exist(expdir.c_str())) {
      cm_msg(MERROR, "cm_set_experiment_local", "Experiment \"%s\" directory \"%s\" does not exist", exp_name1.c_str(), expdir.c_str());
      return CM_UNDEF_EXP;
   }
   
   cm_set_experiment_name(exp_name1.c_str());
   cm_set_path(expdir.c_str());
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_experiment_name()

INT cm_set_experiment_name

(

const char *

name

)

Set name of the experiment

Parameters

name	Experiment name

Returns

CM_SUCCESS

Definition at line 1560 of file midas.cxx.

                                             {
   _experiment_name = name;
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_set_experiment_semaphore()

INT cm_set_experiment_semaphore	(	INT	semaphore_alarm,
		INT	semaphore_elog,
		INT	semaphore_history,
		INT	semaphore_msg
	)

dox

Definition at line 2952 of file midas.cxx.

{
   _semaphore_alarm = semaphore_alarm;
   _semaphore_elog = semaphore_elog;
   _semaphore_history = semaphore_history;
   //_semaphore_msg = semaphore_msg;
 
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_set_path()

INT cm_set_path

(

const char *

path

)

Set path to actual experiment. This function gets called by cm_connect_experiment if the connection is established to a local experiment (not through the TCP/IP server). The path is then used for all shared memory routines.

Parameters

path

Pathname

Returns

CM_SUCCESS

Definition at line 1499 of file midas.cxx.

                                  {
   assert(path);
   assert(path[0] != 0);
 
   _path_name = path;
 
   if (_path_name.back() != DIR_SEPARATOR) {
      _path_name += DIR_SEPARATOR_STR;
   }
 
   //printf("cm_set_path [%s]\n", _path_name.c_str());
 
   return CM_SUCCESS;
}

Here is the caller graph for this function:

cm_set_transition_sequence()

INT cm_set_transition_sequence	(	INT	transition,
		INT	sequence_number
	)

Change the transition sequence for the calling program.

Parameters

transition	TR_START, TR_PAUSE, TR_RESUME or TR_STOP.
sequence_number	New sequence number, should be between 1 and 1000

Returns

CM_SUCCESS

Definition at line 3719 of file midas.cxx.

                                                                    {
   INT status;
   HNDLE hDB, hKey;
   char str[256];
 
   /* check for valid transition */
   if (transition != TR_START && transition != TR_STOP && transition != TR_PAUSE && transition != TR_RESUME) {
      cm_msg(MERROR, "cm_set_transition_sequence", "Invalid transition request \"%d\"", transition);
      return CM_INVALID_TRANSITION;
   }
 
   {
      std::lock_guard<std::mutex> guard(_trans_table_mutex);
 
      int count = 0;
      for (size_t i = 0; i < _trans_table.size(); i++) {
         if (_trans_table[i].transition == transition) {
            _trans_table[i].sequence_number = sequence_number;
            count++;
         }
      }
 
      if (count == 0) {
         cm_msg(MERROR, "cm_set_transition_sequence", "transition %s is not registered", cm_transition_name(transition).c_str());
         return CM_INVALID_TRANSITION;
      } else if (count > 1) {
         cm_msg(MERROR, "cm_set_transition_sequence", "cannot change sequence number, transition %s is registered %d times", cm_transition_name(transition).c_str(), count);
         return CM_INVALID_TRANSITION;
      }
 
      /* Change local sequence number for this transition type */
 
      for (size_t i = 0; i < _trans_table.size(); i++) {
         if (_trans_table[i].transition == transition) {
            _trans_table[i].sequence_number = sequence_number;
         }
      }
 
      // implicit unlock
   }
 
   cm_get_experiment_database(&hDB, &hKey);
 
   /* unlock database */
   db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE, TRUE);
 
   sprintf(str, "Transition %s", cm_transition_name(transition).c_str());
 
   /* set value */
   status = db_set_value(hDB, hKey, str, &sequence_number, sizeof(INT), 1, TID_INT32);
   if (status != DB_SUCCESS)
      return status;
 
   /* re-lock database */
   db_set_mode(hDB, hKey, MODE_READ, TRUE);
 
   return CM_SUCCESS;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_watchdog_params()

INT cm_set_watchdog_params	(	BOOL	call_watchdog,
		DWORD	timeout
	)

Definition at line 3279 of file midas.cxx.

{
   /* set also local timeout to requested value (needed by cm_enable_watchdog()) */
   _watchdog_timeout = timeout;
 
   if (rpc_is_remote()) { // we are connected remotely
      return rpc_call(RPC_CM_SET_WATCHDOG_PARAMS, call_watchdog, timeout);
   } else if (rpc_is_mserver()) { // we are the mserver
      RPC_SERVER_ACCEPTION* sa = rpc_get_mserver_acception();
      if (sa)
         sa->watchdog_timeout = timeout;
      
      /* write timeout value to client enty in ODB */
      HNDLE hDB, hKey;
      cm_get_experiment_database(&hDB, &hKey);
      
      if (hDB) {
         db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE, TRUE);
         db_set_value(hDB, hKey, "Link timeout", &timeout, sizeof(timeout), 1, TID_INT32);
         db_set_mode(hDB, hKey, MODE_READ, TRUE);
      }
      return DB_SUCCESS;
   } else {
      return cm_set_watchdog_params_local(call_watchdog, timeout);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_set_watchdog_params_local()

INT cm_set_watchdog_params_local	(	BOOL	call_watchdog,
		DWORD	timeout
	)

Sets the internal watchdog flags and the own timeout. If call_watchdog is TRUE, the cm_watchdog routine is called periodically from the system to show other clients that this application is "alive". On UNIX systems, the alarm() timer is used which is then not available for user purposes.

The timeout specifies the time, after which the calling application should be considered "dead" by other clients. Normally, the cm_watchdog() routines is called periodically. If a client crashes, this does not occur any more. Then other clients can detect this and clear all buffer and database entries of this application so they are not blocked any more. If this application should not checked by others, the timeout can be specified as zero. It might be useful for debugging purposes to do so, because if a debugger comes to a breakpoint and stops the application, the periodic call of cm_watchdog is disabled and the client looks like dead.

If the timeout is not zero, but the watchdog is not called (call_watchdog == FALSE), the user must ensure to call cm_watchdog periodically with a period of WATCHDOG_INTERVAL milliseconds or less.

An application which calles system routines which block the alarm signal for some time, might increase the timeout to the maximum expected blocking time before issuing the calls. One example is the logger doing Exabyte tape IO, which can take up to one minute.

Parameters

call_watchdog	Call the cm_watchdog routine periodically
timeout	Timeout for this application in ms

Returns

CM_SUCCESS

Definition at line 3239 of file midas.cxx.

{
#ifdef LOCAL_ROUTINES
   _watchdog_timeout = timeout;
 
   std::vector<BUFFER*> mybuffers;
 
   gBuffersMutex.lock();
   mybuffers = gBuffers;
   gBuffersMutex.unlock();
 
   /* set watchdog timeout of all open buffers */
   for (BUFFER* pbuf : mybuffers) {
      
      if (!pbuf || !pbuf->attached)
         continue;
 
      bm_lock_buffer_guard pbuf_guard(pbuf);
 
      if (!pbuf_guard.is_locked())
         continue;
      
      BUFFER_HEADER *pheader = pbuf->buffer_header;
      BUFFER_CLIENT *pclient = bm_get_my_client(pbuf, pheader);
      
      /* clear entry from client structure in buffer header */
      pclient->watchdog_timeout = timeout;
      
      /* show activity */
      pclient->last_activity = ss_millitime();
   }
 
   /* set watchdog timeout for ODB */
   db_set_watchdog_params(timeout);
 
#endif /* LOCAL_ROUTINES */
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_shutdown()

INT cm_shutdown	(	const char *	name,
		BOOL	bUnique
	)

Shutdown (exit) other MIDAS client

Parameters

name	Client name or "all" for all clients
bUnique	If true, look for the exact client name. If false, look for namexxx where xxx is a any number.

Returns

CM_SUCCESS, CM_NO_CLIENT, DB_NO_KEY

Definition at line 7364 of file midas.cxx.

                                                {
   INT status, return_status, i, size;
   HNDLE hDB, hKeyClient, hKey, hSubkey, hKeyTmp, hConn;
   KEY key;
   char client_name[NAME_LENGTH], remote_host[HOST_NAME_LENGTH];
   INT port;
   DWORD start_time;
   DWORD timeout;
   DWORD last;
 
   cm_get_experiment_database(&hDB, &hKeyClient);
 
   status = db_find_key(hDB, 0, "System/Clients", &hKey);
   if (status != DB_SUCCESS)
      return DB_NO_KEY;
 
   return_status = CM_NO_CLIENT;
 
   /* loop over all clients */
   for (i = 0;; i++) {
      status = db_enum_key(hDB, hKey, i, &hSubkey);
      if (status == DB_NO_MORE_SUBKEYS)
         break;
 
      /* don't shutdown ourselves */
      if (hSubkey == hKeyClient)
         continue;
 
      if (status == DB_SUCCESS) {
         db_get_key(hDB, hSubkey, &key);
 
         /* contact client */
         size = sizeof(client_name);
         status = db_get_value(hDB, hSubkey, "Name", client_name, &size, TID_STRING, FALSE);
         if (status != DB_SUCCESS)
            continue;
 
         if (!bUnique)
            client_name[strlen(name)] = 0;      /* strip number */
 
         /* check if individual client */
         if (!equal_ustring("all", name) && !equal_ustring(client_name, name))
            continue;
 
         size = sizeof(port);
         db_get_value(hDB, hSubkey, "Server Port", &port, &size, TID_INT32, TRUE);
 
         size = sizeof(remote_host);
         db_get_value(hDB, hSubkey, "Host", remote_host, &size, TID_STRING, TRUE);
 
         cm_get_watchdog_info(hDB, name, &timeout, &last);
         if (timeout == 0)
            timeout = 5000;
 
         /* client found -> connect to its server port */
         status = rpc_client_connect(remote_host, port, client_name, &hConn);
         if (status != RPC_SUCCESS) {
            int client_pid = atoi(key.name);
            return_status = CM_NO_CLIENT;
            cm_msg(MERROR, "cm_shutdown", "Cannot connect to client \'%s\' on host \'%s\', port %d",
                   client_name, remote_host, port);
#ifdef SIGKILL
            cm_msg(MERROR, "cm_shutdown", "Killing and Deleting client \'%s\' pid %d", client_name,
                   client_pid);
            kill(client_pid, SIGKILL);
            return_status = CM_SUCCESS;
            status = cm_delete_client_info(hDB, client_pid);
            if (status != CM_SUCCESS)
               cm_msg(MERROR, "cm_shutdown", "Cannot delete client info for client \'%s\', pid %d, status %d",
                      name, client_pid, status);
#endif
         } else {
            /* call disconnect with shutdown=TRUE */
            rpc_client_disconnect(hConn, TRUE);
 
            /* wait until client has shut down */
            start_time = ss_millitime();
            do {
               ss_sleep(100);
               status = db_find_key(hDB, hKey, key.name, &hKeyTmp);
            } while (status == DB_SUCCESS && (ss_millitime() - start_time < timeout));
 
            if (status == DB_SUCCESS) {
               int client_pid = atoi(key.name);
               return_status = CM_NO_CLIENT;
               cm_msg(MERROR, "cm_shutdown", "Client \'%s\' not responding to shutdown command", client_name);
#ifdef SIGKILL
               cm_msg(MERROR, "cm_shutdown", "Killing and Deleting client \'%s\' pid %d", client_name,
                      client_pid);
               kill(client_pid, SIGKILL);
               status = cm_delete_client_info(hDB, client_pid);
               if (status != CM_SUCCESS)
                  cm_msg(MERROR, "cm_shutdown",
                         "Cannot delete client info for client \'%s\', pid %d, status %d", name, client_pid,
                         status);
#endif
               return_status = CM_NO_CLIENT;
            } else {
               return_status = CM_SUCCESS;
               i--;
            }
         }
      }
 
      /* display any message created during each shutdown */
      cm_msg_flush_buffer();
   }
 
   return return_status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_start_watchdog_thread()

INT cm_start_watchdog_thread

(

void

)

Definition at line 7319 of file midas.cxx.

                               {
   /* watchdog does not run inside remote clients.
    * watchdog timeout timers are maintained by the mserver */
   if (rpc_is_remote())
      return CM_SUCCESS;
#ifdef LOCAL_ROUTINES
   /* only start once */
   if (_watchdog_thread)
      return CM_SUCCESS;
   _watchdog_thread_run = true;
   _watchdog_thread.store(new std::thread(xcm_watchdog_thread));
#endif
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_stop_watchdog_thread()

INT cm_stop_watchdog_thread

(

void

)

Definition at line 7334 of file midas.cxx.

                              {
   /* watchdog does not run inside remote clients.
    * watchdog timeout timers are maintained by the mserver */
   if (rpc_is_remote())
      return CM_SUCCESS;
#ifdef LOCAL_ROUTINES
   _watchdog_thread_run = false;
   while (_watchdog_thread_is_running) {
      //printf("waiting for watchdog thread to shut down\n");
      ss_sleep(10);
   }
   if (_watchdog_thread != NULL) {
      _watchdog_thread.load()->join();
      delete static_cast<std::thread *>(_watchdog_thread);
      _watchdog_thread = NULL;
   }
#endif
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_synchronize()

INT cm_synchronize

(

DWORD *

seconds

)

Get time from MIDAS server and set local time.

Parameters

seconds

Time in seconds

Returns

CM_SUCCESS

Definition at line 1371 of file midas.cxx.

                                   {
   INT sec, status;
 
   /* if connected to server, get time from there */
   if (rpc_is_remote()) {
      status = rpc_call(RPC_CM_SYNCHRONIZE, &sec);
 
      /* set local time */
      if (status == CM_SUCCESS)
         ss_settime(sec);
   }
 
   /* return time to caller */
   if (seconds != NULL) {
      *seconds = ss_time();
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_test_expand_env()

void cm_test_expand_env

(

)

Definition at line 7722 of file midas.cxx.

                          {
   printf("Test expand_end()\n");
   setenv("FOO", "foo", 1);
   setenv("BAR", "bar", 1);
   setenv("EMPTY", "", 1);
   unsetenv("UNDEF");
 
   bool ok = true;
 
   ok &= test_cm_expand_env1("aaa", "aaa");
   ok &= test_cm_expand_env1("$FOO", "foo");
   ok &= test_cm_expand_env1("/$FOO", "/foo");
   ok &= test_cm_expand_env1("/$FOO/", "/foo/");
   ok &= test_cm_expand_env1("$FOO/$BAR", "foo/bar");
   ok &= test_cm_expand_env1("$FOO1", "$FOO1");
   ok &= test_cm_expand_env1("1$FOO", "1foo");
   ok &= test_cm_expand_env1("$UNDEF", "$UNDEF");
   ok &= test_cm_expand_env1("/$UNDEF/", "/$UNDEF/");
 
   if (ok) {
      printf("test_expand_env: all tests passed!\n");
   } else {
      printf("test_expand_env: test FAILED!\n");
   }
}

Here is the call graph for this function:

cm_time()

INT cm_time

(

DWORD *

t

)

Get time from ss_time on server.

Parameters

t

string

Returns

CM_SUCCESS

Definition at line 1436 of file midas.cxx.

                      {
   /* if connected to server, get time from there */
   if (rpc_is_remote())
      return rpc_call(RPC_CM_TIME, t);
 
   /* return local time */
   *t = ss_time();
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition()

INT cm_transition	(	INT	transition,
		INT	run_number,
		char *	errstr,
		INT	errstr_size,
		INT	async_flag,
		INT	debug_flag
	)

Definition at line 5282 of file midas.cxx.

                                                                                                                 {
   int mflag = async_flag & TR_MTHREAD;
   int sflag = async_flag & TR_SYNC;
 
   int status = cm_transition_cleanup();
 
   if (status != CM_SUCCESS) {
      cm_msg(MERROR, "cm_transition", "previous transition did not finish yet");
      return CM_TRANSITION_IN_PROGRESS;
   }
 
   /* get key of local client */
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   bool deferred = (transition & TR_DEFERRED) > 0;
   INT trans_raw = (transition & ~TR_DEFERRED);
 
   /* check for valid transition */
   if (trans_raw != TR_START && trans_raw != TR_STOP && trans_raw != TR_PAUSE && trans_raw != TR_RESUME && trans_raw != TR_STARTABORT) {
      cm_msg(MERROR, "cm_transition", "Invalid transition request \"%d\"", transition);
      if (errstr) {
         strlcpy(errstr, "Invalid transition request", errstr_size);
      }
      return CM_INVALID_TRANSITION;
   }
 
   /* check if transition in progress */
   if (!deferred) {
      int i = 0;
      int size = sizeof(i);
      db_get_value(hDB, 0, "/Runinfo/Transition in progress", &i, &size, TID_INT32, TRUE);
      if (i == 1) {
         if (errstr) {
            sprintf(errstr, "Start/Stop transition %d already in progress, please try again later\n", i);
            strlcat(errstr, "or set \"/Runinfo/Transition in progress\" manually to zero.\n", errstr_size);
         }
         cm_msg(MERROR, "cm_transition", "another transition is already in progress");
         return CM_TRANSITION_IN_PROGRESS;
      }
   }
 
   if (mflag) {
      _trp.transition = transition;
      _trp.run_number = run_number;
      if (sflag) {
         /* in MTHREAD|SYNC mode, we wait until the main thread finishes and it is safe for it to write into errstr */
         _trp.errstr = errstr;
         _trp.errstr_size = errstr_size;
      } else {
         /* in normal MTHREAD mode, we return right away and
          * if errstr is a local variable in the caller and they return too,
          * errstr becomes a stale reference and writing into it will corrupt the stack
          * in the mlogger, errstr is a local variable in "start_the_run", "stop_the_run"
          * and we definitely corrupt mlogger memory with out this: */
         _trp.errstr = NULL;
         _trp.errstr_size = 0;
      }
      _trp.async_flag = async_flag;
      _trp.debug_flag = debug_flag;
      _trp.status = 0;
      _trp.finished = FALSE;
 
      if (errstr)
         *errstr = 0; // null error string
 
      //ss_thread_create(tr_main_thread, &_trp);
 
      std::thread* t = _trp.thread.exchange(new std::thread(tr_main_thread, &_trp));
 
      assert(t==NULL); // previous thread should have been reaped by cm_transition_cleanup()
 
      if (sflag) {
 
         /* wait until main thread has finished */
         do {
            ss_sleep(10);
         } while (!_trp.finished);
 
         std::thread* t = _trp.thread.exchange(NULL);
 
         if (t) {
            t->join();
            delete t;
            t = NULL;
         }
 
         return _trp.status;
      }
   } else
      return cm_transition1(transition, run_number, errstr, errstr_size, async_flag, debug_flag);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition1()

static INT cm_transition1 ( INT  transition, INT  run_number, char *  errstr, INT  errstr_size, INT  async_flag, INT  debug_flag  )

static

Definition at line 5234 of file midas.cxx.

                                                                                                                         {
   int status;
 
   status = cm_transition2(transition, run_number, errstr, errstr_size, async_flag, debug_flag);
 
   if (transition == TR_START && status != CM_SUCCESS) {
      cm_msg(MERROR, "cm_transition", "Could not start a run: cm_transition() status %d, message \'%s\'", status,
             errstr);
      cm_transition2(TR_STARTABORT, run_number, NULL, 0, async_flag, debug_flag);
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition2()

static INT cm_transition2 ( INT  transition, INT  run_number, char *  errstr, INT  errstr_size, INT  async_flag, INT  debug_flag  )

static

Performs a run transition (Start/Stop/Pause/Resume).

Synchronous/Asynchronous flag. If set to TR_ASYNC, the transition is done asynchronously, meaning that clients are connected and told to execute their callback routine, but no result is awaited. The return value is specified by the transition callback function on the remote clients. If all callbacks can perform the transition, CM_SUCCESS is returned. If one callback cannot perform the transition, the return value of this callback is returned from cm_transition(). The async_flag is usually FALSE so that transition callbacks can block a run transition in case of problems and return an error string. The only exception are situations where a run transition is performed automatically by a program which cannot block in a transition. For example the logger can cause a run stop when a disk is nearly full but it cannot block in the cm_transition() function since it has its own run stop callback which must flush buffers and close disk files and tapes.

...
    i = 1;
    db_set_value(hDB, 0, "/Runinfo/Transition in progress", &i, sizeof(INT), 1, TID_INT32);
 
      status = cm_transition(TR_START, new_run_number, str, sizeof(str), SYNC, debug_flag);
      if (status != CM_SUCCESS)
      {
        // in case of error
        printf("Error: %s\n", str);
      }
    ...

Parameters

transition	TR_START, TR_PAUSE, TR_RESUME or TR_STOP.
run_number	New run number. If zero, use current run number plus one.
errstr	returned error string.
errstr_size	Size of error string.
async_flag	TR_SYNC: synchronization flag (TR_SYNC:wait completion, TR_ASYNC: retun immediately)
debug_flag	If 1 output debugging information, if 2 output via cm_msg().

Returns

CM_SUCCESS, <error> error code from remote client

Definition at line 4519 of file midas.cxx.

{
   INT i, status, size, sequence_number, port, state;
   HNDLE hDB, hRootKey, hSubkey, hKey, hKeylocal, hKeyTrans;
   DWORD seconds;
   char str[256], tr_key_name[256];
   KEY key;
   BOOL deferred;
   char xerrstr[TRANSITION_ERROR_STRING_LENGTH];
 
   //printf("cm_transition2: transition %d, run_number %d, errstr %p, errstr_size %d, async_flag %d, debug_flag %d\n", transition, run_number, errstr, errstr_size, async_flag, debug_flag);
 
   /* if needed, use internal error string */
   if (!errstr) {
      errstr = xerrstr;
      errstr_size = sizeof(xerrstr);
   }
 
   /* erase error string */
   errstr[0] = 0;
 
   /* get key of local client */
   cm_get_experiment_database(&hDB, &hKeylocal);
 
   deferred = (transition & TR_DEFERRED) > 0;
   transition &= ~TR_DEFERRED;
 
   /* check for valid transition */
   if (transition != TR_START && transition != TR_STOP && transition != TR_PAUSE && transition != TR_RESUME
       && transition != TR_STARTABORT) {
      cm_msg(MERROR, "cm_transition", "Invalid transition request \"%d\"", transition);
      strlcpy(errstr, "Invalid transition request", errstr_size);
      return CM_INVALID_TRANSITION;
   }
 
   /* check if transition in progress */
   if (!deferred) {
      i = 0;
      size = sizeof(i);
      db_get_value(hDB, 0, "/Runinfo/Transition in progress", &i, &size, TID_INT32, TRUE);
      if (i == 1) {
         if (errstr) {
            sprintf(errstr, "Start/Stop transition %d already in progress, please try again later\n", i);
            strlcat(errstr, "or set \"/Runinfo/Transition in progress\" manually to zero.\n", errstr_size);
         }
         cm_msg(MERROR, "cm_transition", "another transition is already in progress");
         return CM_TRANSITION_IN_PROGRESS;
      }
   }
 
   /* indicate transition in progress */
   i = transition;
   db_set_value(hDB, 0, "/Runinfo/Transition in progress", &i, sizeof(INT), 1, TID_INT32);
 
   /* clear run abort flag */
   i = 0;
   db_set_value(hDB, 0, "/Runinfo/Start abort", &i, sizeof(INT), 1, TID_INT32);
 
   /* construct new transition state */
 
   TrState s;
   
   s.transition = transition;
   s.run_number = run_number;
   s.async_flag = async_flag;
   s.debug_flag = debug_flag;
   s.status = 0;
   s.errorstr[0] = 0;
   s.start_time = ss_millitime();
   s.end_time = 0;
 
   /* construct the ODB tree /System/Transition */
 
   status = db_find_key(hDB, 0, "/System/Transition/TR_STARTABORT", &hKey);
   if (status == DB_SUCCESS) {
      db_delete_key(hDB, hKey, FALSE);
   }
 
   if (transition != TR_STARTABORT) {
      status = db_find_key(hDB, 0, "/System/Transition/Clients", &hKey);
      if (status == DB_SUCCESS) {
         db_delete_key(hDB, hKey, FALSE);
      }
   }
 
   if (transition != TR_STARTABORT) {
      db_set_value(hDB, 0, "/System/Transition/transition", &transition, sizeof(INT), 1, TID_INT32);
      db_set_value(hDB, 0, "/System/Transition/run_number", &run_number, sizeof(INT), 1, TID_INT32);
      db_set_value(hDB, 0, "/System/Transition/start_time", &s.start_time, sizeof(DWORD), 1, TID_UINT32);
      db_set_value(hDB, 0, "/System/Transition/end_time", &s.end_time, sizeof(DWORD), 1, TID_UINT32);
      status = 0;
      db_set_value(hDB, 0, "/System/Transition/status", &status, sizeof(INT), 1, TID_INT32);
      db_set_value(hDB, 0, "/System/Transition/error", "", 1, 1, TID_STRING);
      db_set_value(hDB, 0, "/System/Transition/deferred", "", 1, 1, TID_STRING);
   }
 
   /* check for alarms */
   i = 0;
   size = sizeof(i);
   db_get_value(hDB, 0, "/Experiment/Prevent start on alarms", &i, &size, TID_BOOL, TRUE);
   if (i == TRUE && transition == TR_START) {
      al_check();
      if (al_get_alarms(str, sizeof(str)) > 0) {
         cm_msg(MERROR, "cm_transition", "Run start abort due to alarms: %s", str);
         sprintf(errstr, "Cannot start run due to alarms: ");
         strlcat(errstr, str, errstr_size);
         return tr_finish(hDB, &s, transition, AL_TRIGGERED, errstr);
      }
   }
 
   /* check for required programs */
   i = 0;
   size = sizeof(i);
   db_get_value(hDB, 0, "/Experiment/Prevent start on required progs", &i, &size, TID_BOOL, TRUE);
   if (i == TRUE && transition == TR_START) {
 
      HNDLE hkeyroot, hkey;
 
      /* check /programs alarms */
      db_find_key(hDB, 0, "/Programs", &hkeyroot);
      if (hkeyroot) {
         for (i = 0;; i++) {
            BOOL program_info_required = FALSE;
            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_required);
            status = db_get_value(hDB, hkey, "Required", &program_info_required, &size, TID_BOOL, TRUE);
            if (status != DB_SUCCESS) {
               cm_msg(MERROR, "cm_transition", "Cannot get program info required, status %d", status);
               continue;
            }
 
            if (program_info_required) {
               std::string name = rpc_get_name();
               strlcpy(str, name.c_str(), sizeof(str));
               str[strlen(key.name)] = 0;
               if (!equal_ustring(str, key.name) && cm_exist(key.name, FALSE) == CM_NO_CLIENT) {
                  cm_msg(MERROR, "cm_transition", "Run start abort due to program \"%s\" not running", key.name);
                  sprintf(errstr, "Run start abort due to program \"%s\" not running", key.name);
                  return tr_finish(hDB, &s, transition, AL_TRIGGERED, errstr);
               }
            }
         }
      }
   }
 
   /* do detached transition via mtransition tool */
   if (async_flag & TR_DETACH) {
      status = cm_transition_detach(transition, run_number, errstr, errstr_size, async_flag, debug_flag);
      return tr_finish(hDB, &s, transition, status, errstr);
   }
 
   strlcpy(errstr, "Unknown error", errstr_size);
 
   if (debug_flag == 0) {
      size = sizeof(i);
      db_get_value(hDB, 0, "/Experiment/Transition debug flag", &debug_flag, &size, TID_INT32, TRUE);
   }
 
   /* if no run number is given, get it from ODB and increment it */
   if (run_number == 0) {
      size = sizeof(run_number);
      status = db_get_value(hDB, 0, "Runinfo/Run number", &run_number, &size, TID_INT32, TRUE);
      assert(status == SUCCESS);
      if (transition == TR_START) {
         run_number++;
      }
      s.run_number = run_number;
 
      if (transition != TR_STARTABORT) {
         db_set_value(hDB, 0, "/System/Transition/run_number", &run_number, sizeof(INT), 1, TID_INT32);
      }
   }
 
   if (run_number <= 0) {
      cm_msg(MERROR, "cm_transition", "aborting on attempt to use invalid run number %d", run_number);
      abort();
   }
 
   /* Set new run number in ODB */
   if (transition == TR_START) {
      if (debug_flag == 1)
         printf("Setting run number %d in ODB\n", run_number);
      if (debug_flag == 2)
         cm_msg(MINFO, "cm_transition", "cm_transition: Setting run number %d in ODB", run_number);
 
      status = db_set_value(hDB, 0, "Runinfo/Run number", &run_number, sizeof(run_number), 1, TID_INT32);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_transition", "cannot set Runinfo/Run number in database, status %d", status);
         abort();
      }
   }
 
   if (deferred) {
      if (debug_flag == 1)
         printf("Clearing /Runinfo/Requested transition\n");
      if (debug_flag == 2)
         cm_msg(MINFO, "cm_transition", "cm_transition: Clearing /Runinfo/Requested transition");
 
      /* remove transition request */
      i = 0;
      db_set_value(hDB, 0, "/Runinfo/Requested transition", &i, sizeof(int), 1, TID_INT32);
   } else {
      status = db_find_key(hDB, 0, "System/Clients", &hRootKey);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "cm_transition", "cannot find System/Clients entry in database");
         if (errstr)
            strlcpy(errstr, "Cannot find /System/Clients in ODB", errstr_size);
         return tr_finish(hDB, &s, transition, status, errstr);
      }
 
      /* check if deferred transition already in progress */
      size = sizeof(i);
      db_get_value(hDB, 0, "/Runinfo/Requested transition", &i, &size, TID_INT32, TRUE);
      if (i) {
         if (errstr) {
            strlcpy(errstr, "Deferred transition already in progress", errstr_size);
            strlcat(errstr, ", to cancel, set \"/Runinfo/Requested transition\" to zero", errstr_size);
         }
         return tr_finish(hDB, &s, transition, CM_TRANSITION_IN_PROGRESS, errstr);
      }
 
      std::string trname = cm_transition_name(transition);
 
      sprintf(tr_key_name, "Transition %s DEFERRED", trname.c_str());
 
      /* search database for clients with deferred transition request */
      for (i = 0, status = 0;; i++) {
         status = db_enum_key(hDB, hRootKey, i, &hSubkey);
         if (status == DB_NO_MORE_SUBKEYS)
            break;
 
         if (status == DB_SUCCESS) {
            size = sizeof(sequence_number);
            status = db_get_value(hDB, hSubkey, tr_key_name, &sequence_number, &size, TID_INT32, FALSE);
 
            /* if registered for deferred transition, set flag in ODB and return */
            if (status == DB_SUCCESS) {
               size = NAME_LENGTH;
               db_get_value(hDB, hSubkey, "Name", str, &size, TID_STRING, TRUE);
 
               if (debug_flag == 1)
                  printf("---- Transition %s deferred by client \"%s\" ----\n", trname.c_str(), str);
               if (debug_flag == 2)
                  cm_msg(MINFO, "cm_transition", "cm_transition: ---- Transition %s deferred by client \"%s\" ----", trname.c_str(), str);
 
               if (debug_flag == 1)
                  printf("Setting /Runinfo/Requested transition\n");
               if (debug_flag == 2)
                  cm_msg(MINFO, "cm_transition", "cm_transition: Setting /Runinfo/Requested transition");
 
               /* /Runinfo/Requested transition is hot-linked by mfe.c and writing to it
                * will activate the deferred transition code in the frontend.
                * the transition itself will be run from the frontend via cm_transition(TR_DEFERRED) */
 
               db_set_value(hDB, 0, "/Runinfo/Requested transition", &transition, sizeof(int), 1, TID_INT32);
 
               db_set_value(hDB, 0, "/System/Transition/deferred", str, strlen(str) + 1, 1, TID_STRING);
 
               if (errstr)
                  sprintf(errstr, "Transition %s deferred by client \"%s\"", trname.c_str(), str);
 
               return tr_finish(hDB, &s, transition, CM_DEFERRED_TRANSITION, errstr);
            }
         }
      }
   }
 
   /* execute programs on start */
   if (transition == TR_START) {
      str[0] = 0;
      size = sizeof(str);
      db_get_value(hDB, 0, "/Programs/Execute on start run", str, &size, TID_STRING, TRUE);
      if (str[0])
         ss_system(str);
 
      db_find_key(hDB, 0, "/Programs", &hRootKey);
      if (hRootKey) {
         for (i = 0;; i++) {
            BOOL program_info_auto_start = FALSE;
            status = db_enum_key(hDB, hRootKey, 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_auto_start);
            status = db_get_value(hDB, hKey, "Auto start", &program_info_auto_start, &size, TID_BOOL, TRUE);
            if (status != DB_SUCCESS) {
               cm_msg(MERROR, "cm_transition", "Cannot get program info auto start, status %d", status);
               continue;
            }
 
            if (program_info_auto_start) {
               char start_command[MAX_STRING_LENGTH];
               start_command[0] = 0;
 
               size = sizeof(start_command);
               status = db_get_value(hDB, hKey, "Start command", &start_command, &size, TID_STRING, TRUE);
               if (status != DB_SUCCESS) {
                  cm_msg(MERROR, "cm_transition", "Cannot get program info start command, status %d", status);
                  continue;
               }
 
               if (start_command[0]) {
                  cm_msg(MINFO, "cm_transition", "Auto Starting program \"%s\", command \"%s\"", key.name,
                         start_command);
                  ss_system(start_command);
               }
            }
         }
      }
   }
 
   /* make sure odb entry is always created, otherwise we only see it after the first aborted run start, maybe never */
   str[0] = 0;
   size = sizeof(str);
   db_get_value(hDB, 0, "/Programs/Execute on start abort", str, &size, TID_STRING, TRUE);
 
   /* execute programs on startabort */
   if (transition == TR_STARTABORT) {
      if (str[0])
         ss_system(str);
   }
 
   /* set new start time in database */
   if (transition == TR_START) {
      /* ASCII format */
      cm_asctime(str, sizeof(str));
      db_set_value(hDB, 0, "Runinfo/Start Time", str, 32, 1, TID_STRING);
 
      /* reset stop time */
      seconds = 0;
      db_set_value(hDB, 0, "Runinfo/Stop Time binary", &seconds, sizeof(seconds), 1, TID_UINT32);
 
      /* Seconds since 1.1.1970 */
      cm_time(&seconds);
      db_set_value(hDB, 0, "Runinfo/Start Time binary", &seconds, sizeof(seconds), 1, TID_UINT32);
   }
 
   size = sizeof(state);
   status = db_get_value(hDB, 0, "Runinfo/State", &state, &size, TID_INT32, TRUE);
 
   /* set stop time in database */
   if (transition == TR_STOP) {
      if (status != DB_SUCCESS)
         cm_msg(MERROR, "cm_transition", "cannot get Runinfo/State in database");
 
      if (state != STATE_STOPPED) {
         /* stop time binary */
         cm_time(&seconds);
         status = db_set_value(hDB, 0, "Runinfo/Stop Time binary", &seconds, sizeof(seconds), 1, TID_UINT32);
         if (status != DB_SUCCESS)
            cm_msg(MERROR, "cm_transition", "cannot set \"Runinfo/Stop Time binary\" in database");
 
         /* stop time ascii */
         cm_asctime(str, sizeof(str));
         status = db_set_value(hDB, 0, "Runinfo/Stop Time", str, 32, 1, TID_STRING);
         if (status != DB_SUCCESS)
            cm_msg(MERROR, "cm_transition", "cannot set \"Runinfo/Stop Time\" in database");
      }
   }
 
   status = db_find_key(hDB, 0, "System/Clients", &hRootKey);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "cm_transition", "cannot find System/Clients entry in database");
      if (errstr)
         strlcpy(errstr, "Cannot find /System/Clients in ODB", errstr_size);
      return tr_finish(hDB, &s, transition, status, errstr);
   }
 
   std::string trname = cm_transition_name(transition);
 
   /* check that all transition clients are alive */
   for (int i = 0;;) {
      status = db_enum_key(hDB, hRootKey, i, &hSubkey);
      if (status != DB_SUCCESS)
         break;
 
      status = cm_check_client(hDB, hSubkey);
 
      if (status == DB_SUCCESS) {
         /* this client is alive. Check next one! */
         i++;
         continue;
      }
 
      assert(status == CM_NO_CLIENT);
 
      /* start from scratch: removing odb entries as we iterate over them
       * does strange things to db_enum_key() */
      i = 0;
   }
 
   /* check for broken RPC connections */
   rpc_client_check();
 
   if (debug_flag == 1)
      printf("---- Transition %s started ----\n", trname.c_str());
   if (debug_flag == 2)
      cm_msg(MINFO, "cm_transition", "cm_transition: ---- Transition %s started ----", trname.c_str());
 
   sprintf(tr_key_name, "Transition %s", trname.c_str());
 
   /* search database for clients which registered for transition */
 
   for (int i = 0, status = 0;; i++) {
      KEY subkey;
      status = db_enum_key(hDB, hRootKey, i, &hSubkey);
      if (status == DB_NO_MORE_SUBKEYS)
         break;
 
      status = db_get_key(hDB, hSubkey, &subkey);
      assert(status == DB_SUCCESS);
 
      if (status == DB_SUCCESS) {
         status = db_find_key(hDB, hSubkey, tr_key_name, &hKeyTrans);
 
         if (status == DB_SUCCESS) {
 
            db_get_key(hDB, hKeyTrans, &key);
 
            for (int j = 0; j < key.num_values; j++) {
               size = sizeof(sequence_number);
               status = db_get_data_index(hDB, hKeyTrans, &sequence_number, &size, j, TID_INT32);
               assert(status == DB_SUCCESS);
 
               TrClient *c = new TrClient;
 
               c->init_time  = ss_millitime();
               c->transition = transition;
               c->run_number = run_number;
               c->async_flag = async_flag;
               c->debug_flag = debug_flag;
               c->sequence_number = sequence_number;
               c->status = 0;
               c->key_name = subkey.name;
 
               /* get client info */
               char client_name[NAME_LENGTH];
               size = sizeof(client_name);
               db_get_value(hDB, hSubkey, "Name", client_name, &size, TID_STRING, TRUE);
               c->client_name = client_name;
 
               char host_name[HOST_NAME_LENGTH];
               size = sizeof(host_name);
               db_get_value(hDB, hSubkey, "Host", host_name, &size, TID_STRING, TRUE);
               c->host_name = host_name;
 
               //printf("Found client [%s] name [%s] transition [%s], i=%d, j=%d\n", subkey.name, client_name, tr_key_name, i, j);
 
               if (hSubkey == hKeylocal && ((async_flag & TR_MTHREAD) == 0)) {
                  /* remember own client */
                  c->port = 0;
               } else {
                  size = sizeof(port);
                  db_get_value(hDB, hSubkey, "Server Port", &port, &size, TID_INT32, TRUE);
                  c->port = port;
               }
 
               /* check for duplicates */
 
               bool found = false;
               for (size_t k=0; k<s.clients.size(); k++) {
                  TrClient* cc = s.clients[k].get();
                  if (cc->client_name == c->client_name)
                     if (cc->host_name == c->host_name)
                        if (cc->port == c->port)
                           if (cc->sequence_number == c->sequence_number)
                              found = true;
               }
 
               if (!found) {
                  s.clients.push_back(std::unique_ptr<TrClient>(c));
                  c = NULL;
               } else {
                  cm_msg(MERROR, "cm_transition", "transition %s: client \"%s\" is registered with sequence number %d more than once", trname.c_str(), c->client_name.c_str(), c->sequence_number);
                  delete c;
                  c = NULL;
               }
            }
         }
      }
   }
 
   std::sort(s.clients.begin(), s.clients.end(), tr_compare);
 
   /* set predecessor for multi-threaded transitions */
   for (size_t idx = 0; idx < s.clients.size(); idx++) {
      if (s.clients[idx]->sequence_number == 0) {
         // sequence number 0 means "don't care"
      } else {
         /* find clients with smaller sequence number */
         if (idx > 0) {
            for (size_t i = idx - 1; ; i--) {
               if (s.clients[i]->sequence_number < s.clients[idx]->sequence_number) {
                  if (s.clients[i]->sequence_number > 0) {
                     s.clients[idx]->wait_for_index.push_back(i);
                  }
               }
               if (i==0)
                  break;
            }
         }
      }
   }
 
   for (size_t idx = 0; idx < s.clients.size(); idx++) {
      write_tr_client_to_odb(hDB, s.clients[idx].get());
   }
 
#if 0
   for (size_t idx = 0; idx < s.clients.size(); idx++) {
      printf("TrClient[%d]: ", int(idx));
      s.clients[idx]->Print();
      printf("\n");
   }
#endif
 
   /* contact ordered clients for transition -----------------------*/
   status = CM_SUCCESS;
   for (size_t idx = 0; idx < s.clients.size(); idx++) {
      if (debug_flag == 1)
         printf("\n==== Found client \"%s\" with sequence number %d\n",
                s.clients[idx]->client_name.c_str(), s.clients[idx]->sequence_number);
      if (debug_flag == 2)
         cm_msg(MINFO, "cm_transition",
                "cm_transition: ==== Found client \"%s\" with sequence number %d",
                s.clients[idx]->client_name.c_str(), s.clients[idx]->sequence_number);
 
      if (async_flag & TR_MTHREAD) {
         status = CM_SUCCESS;
         assert(s.clients[idx]->thread == NULL);
         s.clients[idx]->thread = new std::thread(cm_transition_call, &s, idx);
      } else {
         if (s.clients[idx]->port == 0) {
            /* if own client call transition callback directly */
            status = cm_transition_call_direct(s.clients[idx].get());
         } else {
            /* if other client call transition via RPC layer */
            status = cm_transition_call(&s, idx);
         }
 
         if (status == CM_SUCCESS && transition != TR_STOP)
            if (s.clients[idx]->status != SUCCESS) {
               cm_msg(MERROR, "cm_transition", "transition %s aborted: client \"%s\" returned status %d", trname.c_str(),
                      s.clients[idx]->client_name.c_str(), int(s.clients[idx]->status));
               break;
            }
      }
 
      if (status != CM_SUCCESS)
         break;
   }
 
   /* wait until all threads have finished */
   for (size_t idx = 0; idx < s.clients.size(); idx++) {
      if (s.clients[idx]->thread) {
         // join() will wait forever until thread finishes
         s.clients[idx]->thread->join();
         delete s.clients[idx]->thread;
         s.clients[idx]->thread = NULL;
      }
   }
 
   /* at this point, all per-client threads have stopped and it is safe to delete TrState and return */
 
   i = 0;
   size = sizeof(i);
   status = db_get_value(hDB, 0, "/Runinfo/Transition in progress", &i, &size, TID_INT32, FALSE);
 
   if (status == DB_SUCCESS && i == 0) {
      cm_msg(MERROR, "cm_transition", "transition %s aborted: \"/Runinfo/Transition in progress\" was cleared", trname.c_str());
 
      if (errstr != NULL)
         strlcpy(errstr, "Canceled", errstr_size);
 
      return tr_finish(hDB, &s, transition, CM_TRANSITION_CANCELED, "Canceled");
   }
 
   /* search for any error */
   for (size_t idx = 0; idx < s.clients.size(); idx++)
      if (s.clients[idx]->status != CM_SUCCESS) {
         status = s.clients[idx]->status;
         if (errstr)
            strlcpy(errstr, s.clients[idx]->errorstr.c_str(), errstr_size);
         s.errorstr = msprintf("Aborted by client \"%s\"", s.clients[idx]->client_name.c_str());
         break;
      }
 
   if (transition != TR_STOP && status != CM_SUCCESS) {
      /* indicate abort */
      i = 1;
      db_set_value(hDB, 0, "/Runinfo/Start abort", &i, sizeof(INT), 1, TID_INT32);
      i = 0;
      db_set_value(hDB, 0, "/Runinfo/Transition in progress", &i, sizeof(INT), 1, TID_INT32);
 
      return tr_finish(hDB, &s, transition, status, errstr);
   }
 
   if (debug_flag == 1)
      printf("\n---- Transition %s finished ----\n", trname.c_str());
   if (debug_flag == 2)
      cm_msg(MINFO, "cm_transition", "cm_transition: ---- Transition %s finished ----", trname.c_str());
 
   /* set new run state in database */
   if (transition == TR_START || transition == TR_RESUME)
      state = STATE_RUNNING;
 
   if (transition == TR_PAUSE)
      state = STATE_PAUSED;
 
   if (transition == TR_STOP)
      state = STATE_STOPPED;
 
   if (transition == TR_STARTABORT)
      state = STATE_STOPPED;
 
   size = sizeof(state);
   status = db_set_value(hDB, 0, "Runinfo/State", &state, size, 1, TID_INT32);
   if (status != DB_SUCCESS)
      cm_msg(MERROR, "cm_transition", "cannot set Runinfo/State in database, db_set_value() status %d", status);
 
   /* send notification message */
   str[0] = 0;
   if (transition == TR_START)
      sprintf(str, "Run #%d started", run_number);
   if (transition == TR_STOP)
      sprintf(str, "Run #%d stopped", run_number);
   if (transition == TR_PAUSE)
      sprintf(str, "Run #%d paused", run_number);
   if (transition == TR_RESUME)
      sprintf(str, "Run #%d resumed", run_number);
   if (transition == TR_STARTABORT)
      sprintf(str, "Run #%d start aborted", run_number);
 
   if (str[0])
      cm_msg(MINFO, "cm_transition", "%s", str);
 
   /* lock/unlock ODB values if present */
   db_find_key(hDB, 0, "/Experiment/Lock when running", &hKey);
   if (hKey) {
      if (state == STATE_STOPPED)
         db_set_mode(hDB, hKey, MODE_READ | MODE_WRITE | MODE_DELETE, TRUE);
      else
         db_set_mode(hDB, hKey, MODE_READ, TRUE);
   }
 
   /* flush online database */
   if (transition == TR_STOP)
      db_flush_database(hDB);
 
   /* execute/stop programs on stop */
   if (transition == TR_STOP) {
      str[0] = 0;
      size = sizeof(str);
      db_get_value(hDB, 0, "/Programs/Execute on stop run", str, &size, TID_STRING, TRUE);
      if (str[0])
         ss_system(str);
 
      db_find_key(hDB, 0, "/Programs", &hRootKey);
      if (hRootKey) {
         for (i = 0;; i++) {
            BOOL program_info_auto_stop = FALSE;
            status = db_enum_key(hDB, hRootKey, 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_auto_stop);
            status = db_get_value(hDB, hKey, "Auto stop", &program_info_auto_stop, &size, TID_BOOL, TRUE);
            if (status != DB_SUCCESS) {
               cm_msg(MERROR, "cm_transition", "Cannot get program info auto stop, status %d", status);
               continue;
            }
 
            if (program_info_auto_stop) {
               cm_msg(MINFO, "cm_transition", "Auto Stopping program \"%s\"", key.name);
               cm_shutdown(key.name, FALSE);
            }
         }
      }
   }
 
 
   /* indicate success */
   i = 0;
   db_set_value(hDB, 0, "/Runinfo/Transition in progress", &i, sizeof(INT), 1, TID_INT32);
 
   if (errstr != NULL)
      strlcpy(errstr, "Success", errstr_size);
 
   return tr_finish(hDB, &s, transition, CM_SUCCESS, "Success");
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition_call()

static int cm_transition_call ( TrState *  s, int  idx  )

static

Definition at line 4161 of file midas.cxx.

                                                   {
   INT old_timeout, status, i, t1, t0, size;
   HNDLE hDB;
   HNDLE hConn = -1;
   int connect_timeout = 10000;
   int timeout = 120000;
 
   cm_get_experiment_database(&hDB, NULL);
   assert(hDB);
 
   TrClient *tr_client = s->clients[idx].get();
 
   tr_client->errorstr = "";
   //tr_client->init_time = ss_millitime();
   tr_client->waiting_for_client = "";
   tr_client->connect_timeout = 0;
   tr_client->connect_start_time = 0;
   tr_client->connect_end_time = 0;
   tr_client->rpc_timeout = 0;
   tr_client->rpc_start_time = 0;
   tr_client->rpc_end_time = 0;
   tr_client->end_time = 0;
 
   write_tr_client_to_odb(hDB, tr_client);
 
   /* wait for predecessor if set */
   if (tr_client->async_flag & TR_MTHREAD && !tr_client->wait_for_index.empty()) {
      while (1) {
         TrClient* wait_for = NULL;
 
         for (size_t i = 0; i < tr_client->wait_for_index.size(); i++) {
            int wait_for_index = tr_client->wait_for_index[i];
 
            assert(wait_for_index >= 0);
            assert(wait_for_index < (int)s->clients.size());
 
            TrClient *t = s->clients[wait_for_index].get();
 
            if (!t)
               continue;
 
            if (t->status == 0) {
               wait_for = t;
               break;
            }
 
            if (t->status != SUCCESS && tr_client->transition != TR_STOP) {
               cm_msg(MERROR, "cm_transition_call", "Transition %d aborted: client \"%s\" returned status %d", tr_client->transition, t->client_name.c_str(), int(t->status));
               tr_client->status = -1;
               tr_client->errorstr = msprintf("Aborted by failure of client \"%s\"", t->client_name.c_str());
               tr_client->end_time = ss_millitime();
               write_tr_client_to_odb(hDB, tr_client);
               return CM_SUCCESS;
            }
         }
 
         if (wait_for == NULL)
            break;
 
         tr_client->waiting_for_client = wait_for->client_name;
         write_tr_client_to_odb(hDB, tr_client);
 
         if (tr_client->debug_flag == 1)
            printf("Client \"%s\" waits for client \"%s\"\n", tr_client->client_name.c_str(), wait_for->client_name.c_str());
 
         i = 0;
         size = sizeof(i);
         status = db_get_value(hDB, 0, "/Runinfo/Transition in progress", &i, &size, TID_INT32, FALSE);
 
         if (status == DB_SUCCESS && i == 0) {
            cm_msg(MERROR, "cm_transition_call", "Client \"%s\" transition %d aborted while waiting for client \"%s\": \"/Runinfo/Transition in progress\" was cleared", tr_client->client_name.c_str(), tr_client->transition, wait_for->client_name.c_str());
            tr_client->status = -1;
            tr_client->errorstr = "Canceled";
            tr_client->end_time = ss_millitime();
            write_tr_client_to_odb(hDB, tr_client);
            return CM_SUCCESS;
         }
 
         ss_sleep(100);
      };
   }
 
   tr_client->waiting_for_client[0] = 0;
 
   /* contact client if transition mask set */
   if (tr_client->debug_flag == 1)
      printf("Connecting to client \"%s\" on host %s...\n", tr_client->client_name.c_str(), tr_client->host_name.c_str());
   if (tr_client->debug_flag == 2)
      cm_msg(MINFO, "cm_transition_call", "cm_transition_call: Connecting to client \"%s\" on host %s...", tr_client->client_name.c_str(), tr_client->host_name.c_str());
 
   /* get transition timeout for rpc connect */
   size = sizeof(timeout);
   db_get_value(hDB, 0, "/Experiment/Transition connect timeout", &connect_timeout, &size, TID_INT32, TRUE);
 
   if (connect_timeout < 1000)
      connect_timeout = 1000;
 
   /* get transition timeout */
   size = sizeof(timeout);
   db_get_value(hDB, 0, "/Experiment/Transition timeout", &timeout, &size, TID_INT32, TRUE);
 
   if (timeout < 1000)
      timeout = 1000;
 
   /* set our timeout for rpc_client_connect() */
   //old_timeout = rpc_get_timeout(RPC_HNDLE_CONNECT);
   rpc_set_timeout(RPC_HNDLE_CONNECT, connect_timeout, &old_timeout);
 
   tr_client->connect_timeout = connect_timeout;
   tr_client->connect_start_time = ss_millitime();
 
   write_tr_client_to_odb(hDB, tr_client);
 
   /* client found -> connect to its server port */
   status = rpc_client_connect(tr_client->host_name.c_str(), tr_client->port, tr_client->client_name.c_str(), &hConn);
 
   rpc_set_timeout(RPC_HNDLE_CONNECT, old_timeout);
 
   tr_client->connect_end_time = ss_millitime();
   write_tr_client_to_odb(hDB, tr_client);
 
   if (status != RPC_SUCCESS) {
      cm_msg(MERROR, "cm_transition_call",
             "cannot connect to client \"%s\" on host %s, port %d, status %d",
             tr_client->client_name.c_str(), tr_client->host_name.c_str(), tr_client->port, status);
      tr_client->errorstr = msprintf("Cannot connect to client \"%s\"", tr_client->client_name.c_str());
 
      /* clients that do not respond to transitions are dead or defective, get rid of them. K.O. */
      cm_shutdown(tr_client->client_name.c_str(), TRUE);
      cm_cleanup(tr_client->client_name.c_str(), TRUE);
 
      if (tr_client->transition != TR_STOP) {
         /* indicate abort */
         i = 1;
         db_set_value(hDB, 0, "/Runinfo/Start abort", &i, sizeof(INT), 1, TID_INT32);
         i = 0;
         db_set_value(hDB, 0, "/Runinfo/Transition in progress", &i, sizeof(INT), 1, TID_INT32);
      }
 
      tr_client->status = status;
      tr_client->end_time = ss_millitime();
 
      write_tr_client_to_odb(hDB, tr_client);
      return status;
   }
 
   if (tr_client->debug_flag == 1)
      printf("Connection established to client \"%s\" on host %s\n", tr_client->client_name.c_str(), tr_client->host_name.c_str());
   if (tr_client->debug_flag == 2)
      cm_msg(MINFO, "cm_transition_call",
             "cm_transition: Connection established to client \"%s\" on host %s",
             tr_client->client_name.c_str(), tr_client->host_name.c_str());
 
   /* call RC_TRANSITION on remote client with increased timeout */
   //old_timeout = rpc_get_timeout(hConn);
   rpc_set_timeout(hConn, timeout, &old_timeout);
 
   tr_client->rpc_timeout = timeout;
   tr_client->rpc_start_time = ss_millitime();
   write_tr_client_to_odb(hDB, tr_client);
 
   if (tr_client->debug_flag == 1)
      printf("Executing RPC transition client \"%s\" on host %s...\n",
             tr_client->client_name.c_str(), tr_client->host_name.c_str());
   if (tr_client->debug_flag == 2)
      cm_msg(MINFO, "cm_transition_call",
             "cm_transition: Executing RPC transition client \"%s\" on host %s...",
             tr_client->client_name.c_str(), tr_client->host_name.c_str());
 
   t0 = ss_millitime();
 
   char errorstr[TRANSITION_ERROR_STRING_LENGTH];
   errorstr[0] = 0;
 
   status = rpc_client_call(hConn, RPC_RC_TRANSITION, tr_client->transition, tr_client->run_number, errorstr, sizeof(errorstr), tr_client->sequence_number);
 
   tr_client->errorstr = errorstr;
 
   t1 = ss_millitime();
 
   tr_client->rpc_end_time = ss_millitime();
 
   write_tr_client_to_odb(hDB, tr_client);
 
   /* fix for clients returning 0 as error code */
   if (status == 0)
      status = FE_ERR_HW;
 
   /* reset timeout */
   rpc_set_timeout(hConn, old_timeout);
 
   //DWORD t2 = ss_millitime();
 
   if (tr_client->debug_flag == 1)
      printf("RPC transition finished client \"%s\" on host \"%s\" in %d ms with status %d\n",
             tr_client->client_name.c_str(), tr_client->host_name.c_str(), t1 - t0, status);
   if (tr_client->debug_flag == 2)
      cm_msg(MINFO, "cm_transition_call",
             "cm_transition: RPC transition finished client \"%s\" on host \"%s\" in %d ms with status %d",
             tr_client->client_name.c_str(), tr_client->host_name.c_str(), t1 - t0, status);
 
   if (status == RPC_NET_ERROR || status == RPC_TIMEOUT) {
      tr_client->errorstr = msprintf("RPC network error or timeout from client \'%s\' on host \"%s\"", tr_client->client_name.c_str(), tr_client->host_name.c_str());
      /* clients that do not respond to transitions are dead or defective, get rid of them. K.O. */
      cm_shutdown(tr_client->client_name.c_str(), TRUE);
      cm_cleanup(tr_client->client_name.c_str(), TRUE);
   } else if (status != CM_SUCCESS && tr_client->errorstr.empty()) {
      tr_client->errorstr = msprintf("Unknown error %d from client \'%s\' on host \"%s\"", status, tr_client->client_name.c_str(), tr_client->host_name.c_str());
   }
 
   tr_client->status = status;
   tr_client->end_time = ss_millitime();
 
   // write updated status and end_time to ODB
 
   write_tr_client_to_odb(hDB, tr_client);
 
#if 0
   printf("hconn %d cm_transition_call(%s) finished init %d connect %d end %d rpc %d end %d xxx %d end %d\n",
          hConn,
          tr_client->client_name.c_str(),
          tr_client->init_time - tr_client->init_time,
          tr_client->connect_start_time - tr_client->init_time,
          tr_client->connect_end_time - tr_client->init_time,
          tr_client->rpc_start_time - tr_client->init_time,
          tr_client->rpc_end_time - tr_client->init_time,
          t2 - tr_client->init_time,
          tr_client->end_time - tr_client->init_time);
#endif
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition_call_direct()

static int cm_transition_call_direct ( TrClient *  tr_client )

static

Definition at line 4396 of file midas.cxx.

{
   HNDLE hDB;
 
   cm_get_experiment_database(&hDB, NULL);
 
   DWORD now = ss_millitime();
 
   tr_client->errorstr = "";
   //tr_client->init_time = now;
   tr_client->waiting_for_client = "";
   tr_client->connect_timeout = 0;
   tr_client->connect_start_time = now;
   tr_client->connect_end_time = now;
   tr_client->rpc_timeout = 0;
   tr_client->rpc_start_time = 0;
   tr_client->rpc_end_time = 0;
   tr_client->end_time = 0;
 
   write_tr_client_to_odb(hDB, tr_client);
 
   // find registered handler
   // NB: this code should match same code in rpc_transition_dispatch()
   // NB: only use the first handler, this is how MIDAS always worked
   // NB: we could run all handlers, but we can return the status and error string of only one of them.
 
   _trans_table_mutex.lock();
   size_t n = _trans_table.size();
   _trans_table_mutex.unlock();
 
   for (size_t i = 0; i < n; i++) {
      _trans_table_mutex.lock();
      TRANS_TABLE tt = _trans_table[i];
      _trans_table_mutex.unlock();
      if (tt.transition == tr_client->transition && tt.sequence_number == tr_client->sequence_number) {
         /* call registered function */
         if (tt.func) {
            if (tr_client->debug_flag == 1)
               printf("Calling local transition callback\n");
            if (tr_client->debug_flag == 2)
               cm_msg(MINFO, "cm_transition_call_direct", "cm_transition: Calling local transition callback");
            
            tr_client->rpc_start_time = ss_millitime();
 
            write_tr_client_to_odb(hDB, tr_client);
 
            char errorstr[TRANSITION_ERROR_STRING_LENGTH];
            errorstr[0] = 0;
            
            tr_client->status = tt.func(tr_client->run_number, errorstr);
 
            tr_client->errorstr = errorstr;
            
            tr_client->rpc_end_time = ss_millitime();
            
            if (tr_client->debug_flag == 1)
               printf("Local transition callback finished, status %d\n", int(tr_client->status));
            if (tr_client->debug_flag == 2)
               cm_msg(MINFO, "cm_transition_call_direct", "cm_transition: Local transition callback finished, status %d", int(tr_client->status));
 
            tr_client->end_time = ss_millitime();
 
            // write status and end_time to ODB
 
            write_tr_client_to_odb(hDB, tr_client);
 
            return tr_client->status;
         }
      }
   }
 
   cm_msg(MERROR, "cm_transition_call_direct", "no handler for transition %d with sequence number %d", tr_client->transition, tr_client->sequence_number);
 
   tr_client->status = CM_SUCCESS;
   tr_client->end_time = ss_millitime();
 
   // write status and end_time to ODB
 
   write_tr_client_to_odb(hDB, tr_client);
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition_cleanup()

INT cm_transition_cleanup

(

)

Definition at line 5263 of file midas.cxx.

{
   if (_trp.thread && !_trp.finished) {
      //printf("main transition thread did not finish yet!\n");
      return CM_TRANSITION_IN_PROGRESS;
   }
 
   std::thread* t = _trp.thread.exchange(NULL);
 
   if (t) {
      t->join();
      delete t;
      t = NULL;
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_transition_detach()

static int cm_transition_detach ( INT  transition, INT  run_number, char *  errstr, INT  errstr_size, INT  async_flag, INT  debug_flag  )

static

Definition at line 4078 of file midas.cxx.

                                                                                                                               {
   HNDLE hDB;
   int status;
   const char *args[100];
   std::string path;
   char debug_arg[256];
   char start_arg[256];
   std::string expt_name;
   std::string mserver_hostname;
 
   int iarg = 0;
 
   cm_get_experiment_database(&hDB, NULL);
 
   const char *midassys = getenv("MIDASSYS");
   if (midassys) {
      path += midassys;
      path += DIR_SEPARATOR_STR;
      path += "bin";
      path += DIR_SEPARATOR_STR;
   }
   path += "mtransition";
 
   args[iarg++] = path.c_str();
 
   if (rpc_is_remote()) {
      /* if connected to mserver, pass connection info to mtransition */
      mserver_hostname = rpc_get_mserver_hostname();
      args[iarg++] = "-h";
      args[iarg++] = mserver_hostname.c_str();
   }
 
   /* get experiment name from ODB */
   db_get_value_string(hDB, 0, "/Experiment/Name", 0, &expt_name, FALSE);
 
   if (expt_name.length() > 0) {
      args[iarg++] = "-e";
      args[iarg++] = expt_name.c_str();
   }
 
   if (debug_flag) {
      args[iarg++] = "-d";
 
      sprintf(debug_arg, "%d", debug_flag);
      args[iarg++] = debug_arg;
   }
 
   if (transition == TR_STOP)
      args[iarg++] = "STOP";
   else if (transition == TR_PAUSE)
      args[iarg++] = "PAUSE";
   else if (transition == TR_RESUME)
      args[iarg++] = "RESUME";
   else if (transition == TR_START) {
      args[iarg++] = "START";
 
      sprintf(start_arg, "%d", run_number);
      args[iarg++] = start_arg;
   }
 
   args[iarg++] = NULL;
 
#if 0
   for (iarg = 0; args[iarg] != NULL; iarg++) {
      printf("arg[%d] [%s]\n", iarg, args[iarg]);
   }
#endif
 
   status = ss_spawnv(P_DETACH, args[0], args);
 
   if (status != SS_SUCCESS) {
      if (errstr != NULL) {
         sprintf(errstr, "Cannot execute mtransition, ss_spawnv() returned %d", status);
      }
      return CM_SET_ERROR;
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_watchdog_thread()

INT cm_watchdog_thread

(

void *

unused

)

Watchdog thread to maintain the watchdog timeout timestamps for this client

Definition at line 7293 of file midas.cxx.

                                     {
   _watchdog_thread_is_running = true;
   //printf("cm_watchdog_thread started!\n");
   while (_watchdog_thread_run) {
      //printf("cm_watchdog_thread runs!\n");
      DWORD now = ss_millitime();
      bm_update_last_activity(now);
      db_update_last_activity(now);
      int i;
      for (i = 0; i < 20; i++) {
         ss_sleep(100);
         if (!_watchdog_thread_run)
            break;
      }
   }
   //printf("cm_watchdog_thread stopped!\n");
   _watchdog_thread_is_running = false;
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_yield()

INT cm_yield

(

INT

millisec

)

Central yield functions for clients. This routine should be called in an infinite loop by a client in order to give the MIDAS system the opportunity to receive commands over RPC channels, update database records and receive events.

Parameters

millisec

Timeout in millisec. If no message is received during the specified timeout, the routine returns. If millisec=-1, it only returns when receiving an RPC_SHUTDOWN message.

Returns

CM_SUCCESS, RPC_SHUTDOWN

Definition at line 5638 of file midas.cxx.

                           {
   INT status;
   INT bMore;
   //static DWORD last_yield = 0;
   //static DWORD last_yield_time = 0;
   //DWORD start_yield = ss_millitime();
 
   /* check for ctrl-c */
   if (_ctrlc_pressed)
      return RPC_SHUTDOWN;
 
   /* flush the cm_msg buffer */
   cm_msg_flush_buffer();
 
   if (!rpc_is_remote()) {
      /* flush the ODB to its binary file */
      /* for remote clients, ODB is flushed by the mserver */
      HNDLE hDB;
      cm_get_experiment_database(&hDB, NULL);
      db_flush_database(hDB);
   }
 
   /* check for available events */
   if (rpc_is_remote()) {
      //printf("cm_yield() calling bm_poll_event()\n");
      status = bm_poll_event();
 
      if (status == SS_ABORT) {
         return status;
      }
 
      if (status == BM_SUCCESS) {
         /* one or more events received by bm_poll_event() */
         status = ss_suspend(0, 0);
      } else {
         status = ss_suspend(millisec, 0);
      }
 
      return status;
   }
 
   status = cm_periodic_tasks();
 
   if (status != CM_SUCCESS)
      return status;
 
   //DWORD start_check = ss_millitime();
 
   bMore = bm_check_buffers();
 
   //DWORD end_check = ss_millitime();
   //printf("cm_yield: timeout %4d, yield period %4d, last yield time %4d, bm_check_buffers() elapsed %4d, returned %d\n", millisec, start_yield - last_yield, last_yield_time, end_check - start_check, bMore);
   //fflush(stdout);
 
   if (bMore == BM_CORRUPTED) {
      status = SS_ABORT;
   } else if (bMore) {
      /* if events available, quickly check other IPC channels */
      status = ss_suspend(0, 0);
   } else {
      status = ss_suspend(millisec, 0);
   }
 
   /* flush the cm_msg buffer */
   cm_msg_flush_buffer();
 
   //DWORD end_yield = ss_millitime();
   //last_yield_time = end_yield - start_yield;
   //last_yield = start_yield;
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_rpc_hosts()

static void init_rpc_hosts ( HNDLE  hDB )

static

Definition at line 3400 of file midas.cxx.

                                      {
   int status;
   char buf[256];
   int size, i;
   HNDLE hKey;
 
   strcpy(buf, "localhost");
   size = sizeof(buf);
 
   status = db_get_value(hDB, 0, "/Experiment/Security/RPC hosts/Allowed hosts[0]", buf, &size, TID_STRING, TRUE);
 
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "init_rpc_hosts", "Cannot create the RPC hosts access control list, db_get_value() status %d",
             status);
      return;
   }
 
   size = sizeof(i);
   i = 0;
   status = db_get_value(hDB, 0, "/Experiment/Security/Disable RPC hosts check", &i, &size, TID_BOOL, TRUE);
 
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "init_rpc_hosts", "Cannot create \"Disable RPC hosts check\", db_get_value() status %d", status);
      return;
   }
 
   if (i != 0) // RPC hosts check is disabled
      return;
 
   status = db_find_key(hDB, 0, "/Experiment/Security/RPC hosts/Allowed hosts", &hKey);
 
   if (status != DB_SUCCESS || hKey == 0) {
      cm_msg(MERROR, "init_rpc_hosts", "Cannot find the RPC hosts access control list, db_find_key() status %d",
             status);
      return;
   }
 
   load_rpc_hosts(hDB, hKey, -99, NULL);
 
   status = db_watch(hDB, hKey, load_rpc_hosts, NULL);
 
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "init_rpc_hosts", "Cannot watch the RPC hosts access control list, db_watch() status %d", status);
      return;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_rpc_hosts()

static void load_rpc_hosts ( HNDLE  hDB, HNDLE  hKey, int  index, void *  info  )

static

dox

Definition at line 3349 of file midas.cxx.

                                                                         {
   int status;
   int i, last;
   KEY key;
   int max_size;
   char *str;
 
//   if (index != -99)
//      cm_msg(MINFO, "load_rpc_hosts", "Reloading RPC hosts access control list via hotlink callback");
 
   status = db_get_key(hDB, hKey, &key);
 
   if (status != DB_SUCCESS)
      return;
 
   //printf("clear rpc hosts!\n");
   rpc_clear_allowed_hosts();
 
   max_size = key.item_size;
   str = (char *) malloc(max_size);
 
   last = 0;
   for (i = 0; i < key.num_values; i++) {
      int size = max_size;
      status = db_get_data_index(hDB, hKey, str, &size, i, TID_STRING);
      if (status != DB_SUCCESS)
         break;
 
      if (strlen(str) < 1) // skip emties
         continue;
 
      if (str[0] == '#') // skip commented-out entries
         continue;
 
      //printf("add rpc hosts %d [%s]\n", i, str);
      rpc_add_allowed_host(str);
      last = i;
   }
 
   if (key.num_values - last < 10) {
      int new_size = last + 10;
      status = db_set_num_values(hDB, hKey, new_size);
      if (status != DB_SUCCESS) {
         cm_msg(MERROR, "load_rpc_hosts",
                "Cannot resize the RPC hosts access control list, db_set_num_values(%d) status %d", new_size, status);
      }
   }
 
   free(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_shutdown()

static void rpc_client_shutdown ( )

static

Definition at line 12599 of file midas.cxx.

{
   /* close all open connections */
 
   _client_connections_mutex.lock();
 
   for (unsigned i = 0; i < _client_connections.size(); i++) {
      RPC_CLIENT_CONNECTION* c = _client_connections[i];
      if (c && c->connected) {
         int index = c->index;
         // must unlock the array, otherwise we hang -
         // rpc_client_disconnect() will do rpc_call_client()
         // which needs to lock the array to convert handle
         // to connection pointer. Ouch! K.O. Dec 2020.
         _client_connections_mutex.unlock();
         rpc_client_disconnect(index, FALSE);
         _client_connections_mutex.lock();
      }
   }
 
   for (unsigned i = 0; i < _client_connections.size(); i++) {
      RPC_CLIENT_CONNECTION* c = _client_connections[i];
      //printf("client connection %d %p\n", i, c);
      if (c) {
         //printf("client connection %d %p connected %d\n", i, c, c->connected);
         if (!c->connected) {
            delete c;
            _client_connections[i] = NULL;
         }
      }
   }
 
   _client_connections_mutex.unlock();
 
   /* close server connection from other clients */
   for (unsigned i = 0; i < _server_acceptions.size(); i++) {
      if (_server_acceptions[i] && _server_acceptions[i]->recv_sock) {
         send(_server_acceptions[i]->recv_sock, "EXIT", 5, 0);
         _server_acceptions[i]->close();
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_cm_expand_env1()

static bool test_cm_expand_env1 ( const char *  str, const char *  expected  )

static

Definition at line 7707 of file midas.cxx.

                                                                       {
   std::string s = cm_expand_env(str);
   printf("test_expand_env: [%s] -> [%s] expected [%s]",
          str,
          s.c_str(),
          expected);
   if (s != expected) {
      printf(", MISMATCH!\n");
      return false;
   }
 
   printf("\n");
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_compare()

static bool tr_compare ( const std::unique_ptr< TrClient > &  arg1, const std::unique_ptr< TrClient > &  arg2  )

static

Definition at line 3972 of file midas.cxx.

                                                                                                 {
   return arg1->sequence_number < arg2->sequence_number;
}

Here is the caller graph for this function:

tr_finish()

static int tr_finish ( HNDLE  hDB, TrState *  tr, int  transition, int  status, const char *  errorstr  )

static

Definition at line 3992 of file midas.cxx.

{
   DWORD end_time = ss_millitime();
 
   if (transition != TR_STARTABORT) {
      db_set_value(hDB, 0, "/System/Transition/end_time", &end_time, sizeof(DWORD), 1, TID_UINT32);
      db_set_value(hDB, 0, "/System/Transition/status", &status, sizeof(INT), 1, TID_INT32);
 
      if (errorstr) {
         db_set_value(hDB, 0, "/System/Transition/error", errorstr, strlen(errorstr) + 1, 1, TID_STRING);
      } else if (status == CM_SUCCESS) {
         const char *buf = "Success";
         db_set_value(hDB, 0, "/System/Transition/error", buf, strlen(buf) + 1, 1, TID_STRING);
      } else {
         char buf[256];
         sprintf(buf, "status %d", status);
         db_set_value(hDB, 0, "/System/Transition/error", buf, strlen(buf) + 1, 1, TID_STRING);
      }
   }
 
   tr->status = status;
   tr->end_time = end_time;
   if (errorstr) {
      tr->errorstr = errorstr;
   } else {
      tr->errorstr = "(null)";
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tr_main_thread()

static INT tr_main_thread ( void *  param )

static

Definition at line 5250 of file midas.cxx.

                                       {
   INT status;
   TR_PARAM *trp;
 
   trp = (TR_PARAM *) param;
   status = cm_transition1(trp->transition, trp->run_number, trp->errstr, trp->errstr_size, trp->async_flag, trp->debug_flag);
 
   trp->status = status;
   trp->finished = TRUE;
 
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_tr_client_to_odb()

static void write_tr_client_to_odb ( HNDLE  hDB, const TrClient *  tr_client  )

static

Definition at line 4025 of file midas.cxx.

                                                                         {
   //printf("Writing client [%s] to ODB\n", tr_client->client_name.c_str());
 
   int status;
   HNDLE hKey;
 
   if (tr_client->transition == TR_STARTABORT) {
      status = db_create_key(hDB, 0, "/System/Transition/TR_STARTABORT", TID_KEY);
      status = db_find_key(hDB, 0, "/System/Transition/TR_STARTABORT", &hKey);
      if (status != DB_SUCCESS)
         return;
   } else {
      status = db_create_key(hDB, 0, "/System/Transition/Clients", TID_KEY);
      status = db_find_key(hDB, 0, "/System/Transition/Clients", &hKey);
      if (status != DB_SUCCESS)
         return;
   }
 
   // same client_name can exist with different sequence numbers!
   std::string keyname = msprintf("%s_%d", tr_client->client_name.c_str(), tr_client->sequence_number);
 
   status = db_create_key(hDB, hKey, keyname.c_str(), TID_KEY);
   status = db_find_key(hDB, hKey, keyname.c_str(), &hKey);
   if (status != DB_SUCCESS)
      return;
   
   DWORD now = ss_millitime();
 
   //int   transition;
   //int   run_number;
   //int   async_flag;
   //int   debug_flag;
   status = db_set_value(hDB, hKey, "sequence_number", &tr_client->sequence_number, sizeof(INT), 1, TID_INT32);
   status = db_set_value(hDB, hKey, "client_name", tr_client->client_name.c_str(), tr_client->client_name.length() + 1, 1, TID_STRING);
   status = db_set_value(hDB, hKey, "host_name", tr_client->host_name.c_str(), tr_client->host_name.length() + 1, 1, TID_STRING);
   status = db_set_value(hDB, hKey, "port", &tr_client->port, sizeof(INT), 1, TID_INT32);
   status = db_set_value(hDB, hKey, "init_time", &tr_client->init_time, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "waiting_for_client", tr_client->waiting_for_client.c_str(), tr_client->waiting_for_client.length() + 1, 1, TID_STRING);
   status = db_set_value(hDB, hKey, "connect_timeout", &tr_client->connect_timeout, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "connect_start_time", &tr_client->connect_start_time, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "connect_end_time", &tr_client->connect_end_time, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "rpc_timeout", &tr_client->rpc_timeout, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "rpc_start_time", &tr_client->rpc_start_time, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "rpc_end_time", &tr_client->rpc_end_time, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "end_time", &tr_client->end_time, sizeof(DWORD), 1, TID_UINT32);
   status = db_set_value(hDB, hKey, "status", &tr_client->status, sizeof(INT), 1, TID_INT32);
   status = db_set_value(hDB, hKey, "error", tr_client->errorstr.c_str(), tr_client->errorstr.length() + 1, 1, TID_STRING);
   status = db_set_value(hDB, hKey, "last_updated", &now, sizeof(DWORD), 1, TID_UINT32);
}

Here is the call graph for this function:

Here is the caller graph for this function:

xbm_lock_buffer()

static int xbm_lock_buffer ( BUFFER *  pbuf )

static

Definition at line 7940 of file midas.cxx.

{
   int status;
 
   // NB: locking order: 1st buffer mutex, 2nd buffer semaphore. Unlock in reverse order.
 
   //if (pbuf->locked) {
   //   fprintf(stderr, "double lock, abort!\n");
   //   abort();
   //}
 
   status = bm_lock_buffer_mutex(pbuf);
 
   if (status != BM_SUCCESS)
      return status;
 
   status = ss_semaphore_wait_for(pbuf->semaphore, 1000);
 
   if (status != SS_SUCCESS) {
      fprintf(stderr, "bm_lock_buffer: Lock buffer \"%s\" is taking longer than 1 second!\n", pbuf->buffer_name);
 
      status = ss_semaphore_wait_for(pbuf->semaphore, 10000);
 
      if (status != SS_SUCCESS) {
         fprintf(stderr, "bm_lock_buffer: Lock buffer \"%s\" is taking longer than 10 seconds, buffer semaphore is probably stuck, delete %s.SHM and try again!\n", pbuf->buffer_name, pbuf->buffer_name);
 
         if (pbuf->buffer_header) {
            for (int i=0; i<MAX_CLIENTS; i++) {
               fprintf(stderr, "bm_lock_buffer: Buffer \"%s\" client %d \"%s\" pid %d\n", pbuf->buffer_name, i, pbuf->buffer_header->client[i].name, pbuf->buffer_header->client[i].pid);
            }
         }
            
         status = ss_semaphore_wait_for(pbuf->semaphore, _bm_lock_timeout);
         
         if (status != SS_SUCCESS) {
            fprintf(stderr, "bm_lock_buffer: Error: Cannot lock buffer \"%s\", ss_semaphore_wait_for() status %d, aborting...\n", pbuf->buffer_name, status);
            cm_msg(MERROR, "bm_lock_buffer", "Cannot lock buffer \"%s\", ss_semaphore_wait_for() status %d, aborting...", pbuf->buffer_name, status);
            abort();
            /* DOES NOT RETURN */
         }
      }
   }
 
   // protect against double lock
   assert(!pbuf->locked);
   pbuf->locked = TRUE;
 
#if 0
   int x = MAX_CLIENTS - 1;
   if (pbuf->buffer_header->client[x].unused1 != 0) {
      printf("lllock [%s] unused1 %d pid %d\n", pbuf->buffer_name, pbuf->buffer_header->client[x].unused1, getpid());
   }
   //assert(pbuf->buffer_header->client[x].unused1 == 0);
   pbuf->buffer_header->client[x].unused1 = getpid();
#endif
 
   pbuf->count_lock++;
 
   return BM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xbm_unlock_buffer()

static void xbm_unlock_buffer ( BUFFER *  pbuf )

static

Definition at line 8002 of file midas.cxx.

                                            {
   // NB: locking order: 1st buffer mutex, 2nd buffer semaphore. Unlock in reverse order.
 
#if 0
   int x = MAX_CLIENTS-1;
   if (pbuf->attached) {
      if (pbuf->buffer_header->client[x].unused1 != getpid()) {
         printf("unlock [%s] unused1 %d pid %d\n", pbuf->buffer_header->name, pbuf->buffer_header->client[x].unused1, getpid());
      }
      pbuf->buffer_header->client[x].unused1 = 0;
   } else {
      printf("unlock [??????] unused1 ????? pid %d\n", getpid());
   }
#endif
 
   // protect against double unlock
   assert(pbuf->locked);
   pbuf->locked = FALSE;
 
   ss_semaphore_release(pbuf->semaphore);
   pbuf->buffer_mutex.unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

xcm_watchdog_thread()

static void xcm_watchdog_thread ( )

static

Definition at line 7313 of file midas.cxx.

                                  {
   cm_watchdog_thread(NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_ctrlc_pressed

BOOL _ctrlc_pressed = FALSE

static

Definition at line 5435 of file midas.cxx.

_deferred_transition_mask

DWORD _deferred_transition_mask

static

Definition at line 3815 of file midas.cxx.

_exptab

exptab_struct _exptab

static

Definition at line 1607 of file midas.cxx.

_requested_transition

INT _requested_transition

static

dox

Definition at line 3814 of file midas.cxx.

_watchdog_thread

std::atomic<std::thread*> _watchdog_thread {NULL}

static

Definition at line 7287 of file midas.cxx.

_watchdog_thread_is_running

std::atomic<bool> _watchdog_thread_is_running {false}

static

Definition at line 7286 of file midas.cxx.

_watchdog_thread_run

std::atomic<bool> _watchdog_thread_run {false}

static

Definition at line 7285 of file midas.cxx.