mjsonrpc.cxx File Reference

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <map>
#include "mjson.h"
#include "midas.h"
#include "msystem.h"
#include "mstrlcpy.h"
#include "mjsonrpc.h"
#include <mutex>
#include "history.h"

Include dependency graph for mjsonrpc.cxx:

Go to the source code of this file.

Classes
class	JsonHistoryBuffer
class	BinaryHistoryBuffer
struct	EventStashEntry
struct	MethodsTableEntry
struct	NestedLine
class	NestedOutput

Typedefs
typedef std::map< std::string, MidasHistoryInterface * >	MhiMap
typedef std::map< std::string, MethodsTableEntry >	MethodsTable
typedef MethodsTable::iterator	MethodsTableIterator

Functions
static double	GetTimeSec ()
MJsonNode *	mjsonrpc_make_error (int code, const char *message, const char *data)
MJsonNode *	mjsonrpc_make_result (MJsonNode *node)
MJsonNode *	mjsonrpc_make_result (const char *name, MJsonNode *value, const char *name2, MJsonNode *value2, const char *name3, MJsonNode *value3)
MJsonNode *	mjsonrpc_make_result (const char *name, MJsonNode *value, const char *name2, MJsonNode *value2, const char *name3, MJsonNode *value3, const char *name4, MJsonNode *value4)
const MJsonNode *	mjsonrpc_get_param (const MJsonNode *params, const char *name, MJsonNode **error)
const MJsonNodeVector *	mjsonrpc_get_param_array (const MJsonNode *params, const char *name, MJsonNode **error)
static std::string	remove (const std::string s, char c)
static MJsonNode *	xnull (const MJsonNode *params)
static MJsonNode *	js_cm_exist (const MJsonNode *params)
static MJsonNode *	js_cm_shutdown (const MJsonNode *params)
static MJsonNode *	start_program (const MJsonNode *params)
static MJsonNode *	exec_script (const MJsonNode *params)
static int	parse_array_index_list (const char *method, const char *path, std::vector< unsigned > *list)
static MJsonNode *	js_db_get_values (const MJsonNode *params)
static MJsonNode *	js_db_ls (const MJsonNode *params)
static MJsonNode *	js_db_copy (const MJsonNode *params)
static MJsonNode *	js_db_paste (const MJsonNode *params)
static MJsonNode *	js_db_create (const MJsonNode *params)
static MJsonNode *	js_db_delete (const MJsonNode *params)
static MJsonNode *	js_db_resize (const MJsonNode *params)
static MJsonNode *	js_db_resize_string (const MJsonNode *params)
static MJsonNode *	js_db_key (const MJsonNode *params)
static MJsonNode *	js_db_rename (const MJsonNode *params)
static MJsonNode *	js_db_link (const MJsonNode *params)
static MJsonNode *	js_db_reorder (const MJsonNode *params)
static MJsonNode *	js_db_sor (const MJsonNode *params)
static MJsonNode *	js_db_scl (const MJsonNode *params)
static MJsonNode *	js_cm_msg_facilities (const MJsonNode *params)
static MJsonNode *	js_cm_msg1 (const MJsonNode *params)
static MJsonNode *	js_cm_msg_retrieve (const MJsonNode *params)
static MJsonNode *	js_al_reset_alarm (const MJsonNode *params)
static MJsonNode *	js_al_trigger_alarm (const MJsonNode *params)
static MJsonNode *	js_al_trigger_class (const MJsonNode *params)
static MJsonNode *	js_hs_get_active_events (const MJsonNode *params)
static MidasHistoryInterface *	GetHistory (const char *name)
static void	js_hs_exit ()
static MJsonNode *	js_hs_get_channels (const MJsonNode *params)
static MJsonNode *	js_hs_get_events (const MJsonNode *params)
static MJsonNode *	js_hs_reopen (const MJsonNode *params)
static MJsonNode *	js_hs_get_tags (const MJsonNode *params)
static MJsonNode *	js_hs_get_last_written (const MJsonNode *params)
static MJsonNode *	js_hs_read (const MJsonNode *params)
static MJsonNode *	js_hs_read_binned (const MJsonNode *params)
static MJsonNode *	js_hs_read_arraybuffer (const MJsonNode *params)
static MJsonNode *	js_hs_read_binned_arraybuffer (const MJsonNode *params)
static MJsonNode *	js_hs_image_retrieve (const MJsonNode *params)
static MJsonNode *	js_el_retrieve (const MJsonNode *params)
static MJsonNode *	js_el_query (const MJsonNode *params)
static MJsonNode *	js_el_delete (const MJsonNode *params)
static MJsonNode *	jrpc_cxx (const MJsonNode *params)
static MJsonNode *	jrpc_old (const MJsonNode *params)
static MJsonNode *	brpc_cxx (const MJsonNode *params)
static MJsonNode *	brpc_old (const MJsonNode *params)
static MJsonNode *	js_cm_transition (const MJsonNode *params)
static const EVENT_HEADER *	CopyEvent (const EVENT_HEADER *pevent)
static void	StashEvent (const std::string buffer_name, int event_id, int trigger_mask, const EVENT_HEADER *pevent)
static void	MatchEvent (const std::string buffer_name, const EVENT_HEADER *pevent)
static void	DeleteEventStash ()
static const EVENT_HEADER *	FindEvent (const std::string buffer_name, int event_id, int trigger_mask, int last_event_id, int last_trigger_mask, DWORD last_serial_number, DWORD last_time_stamp)
static MJsonNode *	js_bm_receive_event (const MJsonNode *params)
static MJsonNode *	js_ss_millitime (const MJsonNode *params)
static MJsonNode *	get_alarms (const MJsonNode *params)
static MJsonNode *	js_make_subdir (const MJsonNode *params)
static MJsonNode *	js_ext_list_files (const MJsonNode *params)
static MJsonNode *	js_ext_save_file (const MJsonNode *params)
static MJsonNode *	js_ext_read_file (const MJsonNode *params)
static MJsonNode *	js_read_binary_file (const MJsonNode *params)
static MJsonNode *	get_debug (const MJsonNode *params)
static MJsonNode *	set_debug (const MJsonNode *params)
static MJsonNode *	get_sleep (const MJsonNode *params)
static MJsonNode *	set_sleep (const MJsonNode *params)
static MJsonNode *	get_time (const MJsonNode *params)
static MJsonNode *	set_time (const MJsonNode *params)
static MJsonNode *	get_schema (const MJsonNode *params)
static MJsonNode *	js_get_timezone (const MJsonNode *params)
void	mjsonrpc_add_handler (const char *method, mjsonrpc_handler_t *handler, bool needs_locking)
void	mjsonrpc_set_std_mutex (void *mutex)
void	mjsonrpc_init ()
void	mjsonrpc_exit ()
static MJsonNode *	mjsonrpc_make_schema (MethodsTable *h)
MJsonNode *	mjsonrpc_get_schema ()
static std::string	indent (int x, const char *p=" ")
static std::string	mjsonrpc_schema_to_html_anything (const MJsonNode *schema, int nest_level, NestedOutput *o)
static std::string	mjsonrpc_schema_to_html_object (const MJsonNode *schema, int nest_level, NestedOutput *o)
static std::string	mjsonrpc_schema_to_html_array (const MJsonNode *schema, int nest_level, NestedOutput *o)
std::string	mjsonrpc_schema_to_text (const MJsonNode *schema)
static void	add (std::string *s, const char *text)
static MJsonNode *	mjsonrpc_handle_request (const MJsonNode *request)
MJsonNode *	mjsonrpc_decode_post_data (const char *post_data)

Variables
int	mjsonrpc_debug = 0
static int	mjsonrpc_sleep = 0
static int	mjsonrpc_time = 0
static MJsonNode *	gNullNode = NULL
static MhiMap	gHistoryChannels
static std::mutex	gEventStashMutex
static std::vector< EventStashEntry * >	gEventStash
static MethodsTable	gMethodsTable
static std::mutex *	gMutex = NULL

Typedef Documentation

MethodsTable

typedef std::map<std::string, MethodsTableEntry> MethodsTable

Definition at line 4729 of file mjsonrpc.cxx.

MethodsTableIterator

typedef MethodsTable::iterator MethodsTableIterator

Definition at line 4730 of file mjsonrpc.cxx.

MhiMap

typedef std::map<std::string,MidasHistoryInterface*> MhiMap

Definition at line 1682 of file mjsonrpc.cxx.

Function Documentation

add()

static void add ( std::string *  s, const char *  text  )

static

Definition at line 5197 of file mjsonrpc.cxx.

{
   assert(s != NULL);
   if (s->length() > 0)
      *s += ", ";
   *s += text;
}

brpc_cxx()

static MJsonNode * brpc_cxx ( const MJsonNode *  params )

static

Definition at line 3467 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("make RPC call into frontend program via RPC_BRPC_CXX");
      doc->P("client_name", MJSON_STRING, "Connect to this MIDAS client, see cm_connect_client()");
      doc->P("cmd", MJSON_STRING, "Command passed to client");
      doc->P("args", MJSON_STRING, "Parameters passed to client as a string, could be JSON encoded");
      doc->R("reply", MJSON_STRING, "Reply from client as a string, could be JSON encoded");
      doc->R("status", MJSON_INT, "return status of cm_connect_client() and rpc_client_call()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name   = mjsonrpc_get_param(params, "client_name", &error)->GetString(); if (error) return error;
   std::string cmd    = mjsonrpc_get_param(params, "cmd", &error)->GetString(); if (error) return error;
   std::string args   = mjsonrpc_get_param(params, "args", &error)->GetString(); if (error) return error;
 
   int status;
 
   HNDLE hconn;
 
   status = cm_connect_client(name.c_str(), &hconn);
 
   if (status != RPC_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   std::vector<char> *pbuf = new std::vector<char>;
 
   status = rpc_client_call(hconn, RPC_BRPC_CXX, cmd.c_str(), args.c_str(), pbuf);
 
   // disconnect return status ignored on purpose.
   // disconnect not needed, there is no limit on number
   // of connections. dead and closed connections are reaped
   // automatically. K.O. Feb 2021.
   // cm_disconnect_client(hconn, FALSE);
 
   if (status != RPC_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   return MJsonNode::MakeArrayBuffer(pbuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

brpc_old()

static MJsonNode * brpc_old ( const MJsonNode *  params )

static

Definition at line 3513 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("make RPC call into frontend program via RPC_BRPC");
      doc->P("client_name", MJSON_STRING, "Connect to this MIDAS client, see cm_connect_client()");
      doc->P("cmd", MJSON_STRING, "Command passed to client");
      doc->P("args", MJSON_STRING, "Parameters passed to client as a string, could be JSON encoded");
      doc->P("max_reply_length?", MJSON_INT, "Optional maximum length of client reply. MIDAS RPC does not support returning data of arbitrary length, maximum length has to be known ahead of time.");
      doc->R("reply", MJSON_STRING, "Reply from client as a string, could be JSON encoded");
      doc->R("status", MJSON_INT, "return status of cm_connect_client() and rpc_client_call()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name   = mjsonrpc_get_param(params, "client_name", &error)->GetString(); if (error) return error;
   std::string cmd    = mjsonrpc_get_param(params, "cmd", &error)->GetString(); if (error) return error;
   std::string args   = mjsonrpc_get_param(params, "args", &error)->GetString(); if (error) return error;
   int max_reply_length = mjsonrpc_get_param(params, "max_reply_length", NULL)->GetInt();
 
   int status;
 
   int buf_length = 1024;
 
   if (max_reply_length > buf_length)
      buf_length = max_reply_length;
 
   char* buf = (char*)malloc(buf_length);
 
   if (buf == NULL) {
      return mjsonrpc_make_error(-32602, "Invalid params", msprintf("malloc(%d) failed, likely invalid max_reply_length value %d", buf_length, max_reply_length).c_str());
   }
 
   buf[0] = 0;
 
   HNDLE hconn;
 
   status = cm_connect_client(name.c_str(), &hconn);
 
   if (status != RPC_SUCCESS) {
      free(buf);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   status = rpc_client_call(hconn, RPC_BRPC, cmd.c_str(), args.c_str(), buf, &buf_length);
 
   // disconnect return status ignored on purpose.
   // disconnect not needed, there is no limit on number
   // of connections. dead and closed connections are reaped
   // automatically. K.O. Feb 2021.
   // cm_disconnect_client(hconn, FALSE);
 
   if (status != RPC_SUCCESS) {
      free(buf);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   return MJsonNode::MakeArrayBuffer(buf, buf_length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CopyEvent()

static const EVENT_HEADER * CopyEvent ( const EVENT_HEADER *  pevent )

static

Definition at line 3640 of file mjsonrpc.cxx.

{
   size_t event_size = sizeof(EVENT_HEADER) + pevent->data_size;
   //size_t total_size = ALIGN8(event_size);
   EVENT_HEADER* ptr = (EVENT_HEADER*)malloc(event_size);
   assert(ptr);
   memcpy(ptr, pevent, event_size);
   return ptr;
}

Here is the caller graph for this function:

DeleteEventStash()

static void DeleteEventStash ( )

static

Definition at line 3728 of file mjsonrpc.cxx.

{
   std::lock_guard<std::mutex> guard(gEventStashMutex);
   for (size_t i=0; i<gEventStash.size(); i++) {
      if (gEventStash[i]) {
         delete gEventStash[i];
         gEventStash[i] = NULL;
      }
   }
}

Here is the caller graph for this function:

exec_script()

static MJsonNode * exec_script ( const MJsonNode *  params )

static

Definition at line 516 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("execute custom script defined in ODB /Script (scripts show in the menu) or /CustomScript (scripts from custom pages)");
      doc->P("script?", MJSON_STRING, "Execute ODB /Script/xxx");
      doc->P("customscript?", MJSON_STRING, "Execute ODB /CustomScript/xxx");
      doc->R("status", MJSON_INT, "return status of cm_exec_script()");
      return doc;
   }
 
   std::string script = mjsonrpc_get_param(params, "script", NULL)->GetString();
   std::string customscript = mjsonrpc_get_param(params, "customscript", NULL)->GetString();
 
   std::string path;
   
   if (script.length() > 0) {
      path += "/Script";
      path += "/";
      path += script;
   } else if (customscript.length() > 0) {
      path += "/CustomScript";
      path += "/";
      path += customscript;
   }
 
   int status = 0;
 
   if (path.length() > 0) {
      status = cm_exec_script(path.c_str());
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

FindEvent()

static const EVENT_HEADER * FindEvent ( const std::string  buffer_name, int  event_id, int  trigger_mask, int  last_event_id, int  last_trigger_mask, DWORD  last_serial_number, DWORD  last_time_stamp  )

static

Definition at line 3739 of file mjsonrpc.cxx.

{
   std::lock_guard<std::mutex> guard(gEventStashMutex);
   for (EventStashEntry* s : gEventStash) {
      if (s->buffer_name != buffer_name)
         continue;
      if (bm_match_event(event_id, trigger_mask, s->pevent)) {
         if (s->pevent->event_id == last_event_id
             && s->pevent->trigger_mask == last_trigger_mask
             && s->pevent->serial_number == last_serial_number
             && s->pevent->time_stamp == last_time_stamp) {
            //s->Print(); printf(", already sent for %d,0x%x\n", event_id, trigger_mask);
            return NULL;
         } else {
            //s->Print(); printf(", serving for %d,0x%x\n", event_id, trigger_mask);
            return CopyEvent(s->pevent);
         }
      }
   }
   return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_alarms()

static MJsonNode * get_alarms ( const MJsonNode *  params )

static

Definition at line 3947 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get alarm data");
      doc->P("get_all?", MJSON_BOOL, "get all alarms, even in alarm system not active and alarms not triggered");
      doc->R("status", MJSON_INT, "return status of midas library calls");
      doc->R("alarm_system_active", MJSON_BOOL, "value of ODB \"/Alarms/alarm system active\"");
      doc->R("alarms", MJSON_OBJECT, "alarm data, keyed by alarm name");
      doc->R("alarms[].triggered", MJSON_BOOL, "alarm is triggered");
      doc->R("alarms[].active", MJSON_BOOL, "alarm is enabled");
      doc->R("alarms[].class", MJSON_STRING, "alarm class");
      doc->R("alarms[].type", MJSON_INT, "alarm type AT_xxx");
      doc->R("alarms[].bgcolor", MJSON_STRING, "display background color");
      doc->R("alarms[].fgcolor", MJSON_STRING, "display foreground color");
      doc->R("alarms[].message", MJSON_STRING, "alarm ODB message field");
      doc->R("alarms[].condition", MJSON_STRING, "alarm ODB condition field");
      doc->R("alarms[].evaluated_value?", MJSON_STRING, "evaluated alarm condition (AT_EVALUATED alarms only)");
      doc->R("alarms[].periodic_next_time?", MJSON_STRING, "next time the periodic alarm will fire (AT_PERIODIC alarms only)");
      doc->R("alarms[].time_triggered_first", MJSON_STRING, "time when alarm was triggered");
      doc->R("alarms[].show_to_user", MJSON_STRING, "final alarm text shown to user by mhttpd");
      return doc;
   }
 
   //MJsonNode* error = NULL;
 
   bool get_all = mjsonrpc_get_param(params, "get_all", NULL)->GetBool();
 
   int status;
   HNDLE hDB;
 
   status = cm_get_experiment_database(&hDB, NULL);
 
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   int flag;
   int size;
   int alarm_system_active = 0;
 
   /* check global alarm flag */
   flag = TRUE;
   size = sizeof(flag);
   status = db_get_value(hDB, 0, "/Alarms/Alarm System active", &flag, &size, TID_BOOL, TRUE);
 
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   alarm_system_active = flag;
 
   if (!alarm_system_active)
      if (!get_all) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(SUCCESS),
                                     "alarm_system_active", MJsonNode::MakeBool(alarm_system_active!=0),
                                     "alarms", MJsonNode::MakeObject());
      }
 
   /* go through all alarms */
   HNDLE hkey;
   status = db_find_key(hDB, 0, "/Alarms/Alarms", &hkey);
 
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   MJsonNode* alarms = MJsonNode::MakeObject();
 
   for (int i = 0;; i++) {
      HNDLE hsubkey;
      KEY key;
 
      db_enum_link(hDB, hkey, i, &hsubkey);
 
      if (!hsubkey)
         break;
 
      status = db_get_key(hDB, hsubkey, &key);
         
      const char* name = key.name;
 
      flag = 0;
      size = sizeof(flag);
      status = db_get_value(hDB, hsubkey, "Triggered", &flag, &size, TID_INT, TRUE);
 
      // skip un-triggered alarms
      if (!flag)
         if (!get_all)
            continue;
 
      MJsonNode* a = MJsonNode::MakeObject();
 
      a->AddToObject("triggered", MJsonNode::MakeBool(flag!=0));
 
      flag = 1;
      size = sizeof(BOOL);
      status = db_get_value(hDB, hsubkey, "Active", &flag, &size, TID_BOOL, FALSE);
 
      a->AddToObject("active", MJsonNode::MakeBool(flag!=0));
 
      std::string alarm_class{"Alarm"};
 
      db_get_value_string(hDB, hsubkey, "Alarm Class", 0, &alarm_class);
 
      ss_repair_utf8(alarm_class);
 
      a->AddToObject("class", MJsonNode::MakeString(alarm_class.c_str()));
 
      int atype = 0;
      size = sizeof(atype);
      db_get_value(hDB, hsubkey, "Type", &atype, &size, TID_INT, FALSE);
         
      a->AddToObject("type", MJsonNode::MakeInt(atype));
 
      std::string bgcol{"red"};
 
      if (alarm_class.length() > 0) {
         std::string path = msprintf("/Alarms/Classes/%s/Display BGColor", alarm_class.c_str());
         db_get_value_string(hDB, 0, path.c_str(), 0, &bgcol);
      }
         
      ss_repair_utf8(bgcol);
 
      a->AddToObject("bgcolor", MJsonNode::MakeString(bgcol.c_str()));
 
      std::string fgcol{"black"};
 
      if (alarm_class.length() > 0) {
         std::string path = msprintf("/Alarms/Classes/%s/Display FGColor", alarm_class.c_str());
         db_get_value_string(hDB, 0, path.c_str(), 0, &fgcol);
      }
         
      ss_repair_utf8(fgcol);
 
      a->AddToObject("fgcolor", MJsonNode::MakeString(fgcol.c_str()));
 
      flag = 1;
      if (alarm_class.length() > 0) {
         size = sizeof(BOOL);
         std::string path = msprintf("/Alarms/Classes/%s/Alarm sound", alarm_class.c_str());
         db_get_value(hDB, 0, path.c_str(), &flag, &size, TID_BOOL, FALSE);
      }
 
      a->AddToObject("alarm_sound", MJsonNode::MakeBool(flag!=0));
 
      std::string msg;
      db_get_value_string(hDB, hsubkey, "Alarm Message", 0, &msg);
         
      ss_repair_utf8(msg);
 
      a->AddToObject("message", MJsonNode::MakeString(msg.c_str()));
 
      std::string cond;
      db_get_value_string(hDB, hsubkey, "Condition", 0, &cond);
 
      ss_repair_utf8(cond);
 
      a->AddToObject("condition", MJsonNode::MakeString(cond.c_str()));
 
      std::string show_to_user;
      
      if (atype == AT_EVALUATED) {
         /* retrieve value */
         std::string value;
         al_evaluate_condition(name, cond.c_str(), &value);
         show_to_user = msprintf(msg.c_str(), value.c_str());
         ss_repair_utf8(value);
         a->AddToObject("evaluated_value", MJsonNode::MakeString(value.c_str()));
      } else
         show_to_user = msg;
      
      ss_repair_utf8(show_to_user);
 
      a->AddToObject("show_to_user", MJsonNode::MakeString(show_to_user.c_str()));
 
      std::string triggered_first;
      status = db_get_value_string(hDB, hsubkey, "Time triggered first", 0, &triggered_first);
 
      ss_repair_utf8(triggered_first);
 
      a->AddToObject("time_triggered_first", MJsonNode::MakeString(triggered_first.c_str()));
 
      if (atype == AT_PERIODIC) {
         DWORD last = 0;
         size = sizeof(last);
         db_get_value(hDB, hsubkey, "Checked last", &last, &size, TID_DWORD, FALSE);
 
         if (last == 0) {
            last = ss_time();
            db_set_value(hDB, hsubkey, "Checked last", &last, size, 1, TID_DWORD);
         }
 
         int interval = 0;
         size = sizeof(interval);
         db_get_value(hDB, hsubkey, "Check interval", &interval, &size, TID_INT, FALSE);
 
         time_t tnext = last + interval;
 
         char ctimebuf[32];
         ctime_r(&tnext, ctimebuf);
 
         //ss_repair_utf8(ctimebuf); redundant!
 
         a->AddToObject("periodic_next_time", MJsonNode::MakeString(ctimebuf));
      }
 
      alarms->AddToObject(name, a);
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(SUCCESS),
                               "alarm_system_active", MJsonNode::MakeBool(alarm_system_active!=0),
                               "alarms", alarms);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_debug()

static MJsonNode * get_debug ( const MJsonNode *  params )

static

Definition at line 4600 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("get current value of mjsonrpc_debug");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_INT, "current value of mjsonrpc_debug");
      return doc;
   }
 
   return mjsonrpc_make_result("debug", MJsonNode::MakeInt(mjsonrpc_debug));
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_schema()

static MJsonNode * get_schema ( const MJsonNode *  params )

static

Definition at line 4681 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Get the MIDAS JSON-RPC schema JSON object");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_OBJECT, "returns the MIDAS JSON-RPC schema JSON object");
      return doc;
   }
 
   return mjsonrpc_make_result(mjsonrpc_get_schema());
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_sleep()

static MJsonNode * get_sleep ( const MJsonNode *  params )

static

Definition at line 4627 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("get current value of mjsonrpc_sleep");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_INT, "current value of mjsonrpc_sleep");
      return doc;
   }
 
   return mjsonrpc_make_result("sleep", MJsonNode::MakeInt(mjsonrpc_sleep));
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_time()

static MJsonNode * get_time ( const MJsonNode *  params )

static

Definition at line 4654 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("get current value of mjsonrpc_time");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_INT, "current value of mjsonrpc_time");
      return doc;
   }
 
   return mjsonrpc_make_result("time", MJsonNode::MakeInt(mjsonrpc_time));
}

Here is the call graph for this function:

GetHistory()

static MidasHistoryInterface * GetHistory ( const char *  name )

static

Definition at line 1686 of file mjsonrpc.cxx.

{
   // empty name means use the default reader channel
 
   MhiMap::iterator ci = gHistoryChannels.find(name);
   if (ci != gHistoryChannels.end()) {
      return ci->second;
   };
 
   int verbose = 0;
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   HNDLE hKey = 0;
 
   if (strlen(name) < 1) {
      int status = hs_find_reader_channel(hDB, &hKey, verbose);
      if (status != HS_SUCCESS) {
         return NULL;
      }
   } else {
      HNDLE hKeyChan;
      int status = db_find_key(hDB, 0, "/Logger/History", &hKeyChan);
      if (status != DB_SUCCESS) {
         return NULL;
      }
      status = db_find_key(hDB, hKeyChan, name, &hKey);
      if (status != DB_SUCCESS) {
         return NULL;
      }
   }
 
   MidasHistoryInterface* mh = NULL;
 
   int status = hs_get_history(hDB, hKey, HS_GET_READER|HS_GET_INACTIVE, verbose, &mh);
   if (status != HS_SUCCESS || mh==NULL) {
      cm_msg(MERROR, "GetHistory", "Cannot configure history, hs_get_history() status %d", status);
      return NULL;
   }
 
   //printf("hs_get_history: \"%s\" -> mh %p\n", name, mh);
 
   gHistoryChannels[name] = mh;
   
   // cm_msg(MINFO, "GetHistory", "Reading history channel \"%s\" from channel \'%s\' type \'%s\'", name, mh->name, mh->type);
 
   return mh;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetTimeSec()

static double GetTimeSec ( )

static

Definition at line 116 of file mjsonrpc.cxx.

{
   struct timeval tv;
   gettimeofday(&tv, NULL);
   return tv.tv_sec*1.0 + tv.tv_usec/1000000.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

indent()

static std::string indent ( int  x, const char *  p = " "  )

static

Definition at line 4891 of file mjsonrpc.cxx.

{
   if (x<1)
      return "";
   std::string s;
   for (int i=0; i<x; i++)
      s += p;
   return s;
}

Here is the caller graph for this function:

jrpc_cxx()

static MJsonNode * jrpc_cxx ( const MJsonNode *  params )

static

Definition at line 3345 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("make RPC call into frontend program via RPC_JRPC_CXX");
      doc->P("client_name", MJSON_STRING, "Connect to this MIDAS client, see cm_connect_client()");
      doc->P("cmd", MJSON_STRING, "Command passed to client");
      doc->P("args", MJSON_STRING, "Parameters passed to client as a string, could be JSON encoded");
      doc->R("reply", MJSON_STRING, "Reply from client as a string, could be JSON encoded");
      doc->R("status", MJSON_INT, "return status of cm_connect_client() and rpc_client_call()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name   = mjsonrpc_get_param(params, "client_name", &error)->GetString(); if (error) return error;
   std::string cmd    = mjsonrpc_get_param(params, "cmd", &error)->GetString(); if (error) return error;
   std::string args   = mjsonrpc_get_param(params, "args", &error)->GetString(); if (error) return error;
 
   int status;
 
   HNDLE hconn;
 
   status = cm_connect_client(name.c_str(), &hconn);
 
   if (status != RPC_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   std::string reply;
 
   status = rpc_client_call(hconn, RPC_JRPC_CXX, cmd.c_str(), args.c_str(), &reply);
 
   // disconnect return status ignored on purpose.
   // disconnect not needed, there is no limit on number
   // of connections. dead and closed connections are reaped
   // automatically. K.O. Feb 2021.
   // cm_disconnect_client(hconn, FALSE);
 
   if (status != RPC_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   ss_repair_utf8(reply);
 
   MJsonNode* rn = MJsonNode::MakeString(reply.c_str());
   
   return mjsonrpc_make_result("reply", rn, "status", MJsonNode::MakeInt(SUCCESS));
}

Here is the call graph for this function:

Here is the caller graph for this function:

jrpc_old()

static MJsonNode * jrpc_old ( const MJsonNode *  params )

static

Definition at line 3395 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("make RPC call into frontend program via RPC_JRPC");
      doc->P("client_name", MJSON_STRING, "Connect to this MIDAS client, see cm_connect_client()");
      doc->P("cmd", MJSON_STRING, "Command passed to client");
      doc->P("args", MJSON_STRING, "Parameters passed to client as a string, could be JSON encoded");
      doc->P("max_reply_length?", MJSON_INT, "Optional maximum length of client reply. MIDAS RPC does not support returning strings of arbitrary length, maximum length has to be known ahead of time.");
      doc->R("reply", MJSON_STRING, "Reply from client as a string, could be JSON encoded");
      doc->R("status", MJSON_INT, "return status of cm_connect_client() and rpc_client_call()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name   = mjsonrpc_get_param(params, "client_name", &error)->GetString(); if (error) return error;
   std::string cmd    = mjsonrpc_get_param(params, "cmd", &error)->GetString(); if (error) return error;
   std::string args   = mjsonrpc_get_param(params, "args", &error)->GetString(); if (error) return error;
   int max_reply_length = mjsonrpc_get_param(params, "max_reply_length", NULL)->GetInt();
 
   int status;
 
   int buf_length = 1024;
 
   if (max_reply_length > buf_length)
      buf_length = max_reply_length;
 
   char* buf = (char*)malloc(buf_length);
 
   if (buf == NULL) {
      return mjsonrpc_make_error(-32602, "Invalid params", msprintf("malloc(%d) failed, likely invalid max_reply_length value %d", buf_length, max_reply_length).c_str());
   }
 
   buf[0] = 0;
 
   HNDLE hconn;
 
   status = cm_connect_client(name.c_str(), &hconn);
 
   if (status != RPC_SUCCESS) {
      free(buf);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   status = rpc_client_call(hconn, RPC_JRPC, cmd.c_str(), args.c_str(), buf, buf_length);
 
   // disconnect return status ignored on purpose.
   // disconnect not needed, there is no limit on number
   // of connections. dead and closed connections are reaped
   // automatically. K.O. Feb 2021.
   // cm_disconnect_client(hconn, FALSE);
 
   if (status != RPC_SUCCESS) {
      free(buf);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   ss_repair_utf8(buf);
 
   MJsonNode* reply = MJsonNode::MakeString(buf);
   free(buf);
   
   return mjsonrpc_make_result("reply", reply, "status", MJsonNode::MakeInt(SUCCESS));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_al_reset_alarm()

static MJsonNode * js_al_reset_alarm ( const MJsonNode *  params )

static

Definition at line 1576 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("reset alarms");
      doc->P("alarms[]", MJSON_STRING, "array of alarm names");
      doc->R("status[]", MJSON_INT, "return status of al_reset_alarm() for each alarm");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* alarms  = mjsonrpc_get_param_array(params, "alarms",  &error); if (error) return error;
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   for (unsigned i=0; i<alarms->size(); i++) {
      int status = al_reset_alarm((*alarms)[i]->GetString().c_str());
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_al_trigger_alarm()

static MJsonNode * js_al_trigger_alarm ( const MJsonNode *  params )

static

Definition at line 1600 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("trigger an alarm");
      doc->P("name", MJSON_STRING, "alarm name");
      doc->P("message", MJSON_STRING, "alarm message");
      doc->P("class", MJSON_STRING, "alarm class");
      doc->P("condition", MJSON_STRING, "alarm condition");
      doc->P("type", MJSON_INT, "alarm type (AT_xxx)");
      doc->R("status", MJSON_INT, "return status of al_trigger_alarm()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name = mjsonrpc_get_param(params, "name", &error)->GetString(); if (error) return error;
   std::string message = mjsonrpc_get_param(params, "message", &error)->GetString(); if (error) return error;
   std::string xclass = mjsonrpc_get_param(params, "class", &error)->GetString(); if (error) return error;
   std::string condition = mjsonrpc_get_param(params, "condition", &error)->GetString(); if (error) return error;
   int type = mjsonrpc_get_param(params, "type", &error)->GetInt(); if (error) return error;
 
   int status = al_trigger_alarm(name.c_str(), message.c_str(), xclass.c_str(), condition.c_str(), type);
   
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_al_trigger_class()

static MJsonNode * js_al_trigger_class ( const MJsonNode *  params )

static

Definition at line 1627 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("trigger an alarm");
      doc->P("class", MJSON_STRING, "alarm class");
      doc->P("message", MJSON_STRING, "alarm message");
      doc->P("first?", MJSON_BOOL, "see al_trigger_class() in midas.c");
      doc->R("status", MJSON_INT, "return status of al_trigger_class()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string xclass = mjsonrpc_get_param(params, "class", &error)->GetString(); if (error) return error;
   std::string message = mjsonrpc_get_param(params, "message", &error)->GetString(); if (error) return error;
   bool first = mjsonrpc_get_param(params, "first", NULL)->GetBool();
 
   int status = al_trigger_class(xclass.c_str(), message.c_str(), first);
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_bm_receive_event()

static MJsonNode * js_bm_receive_event ( const MJsonNode *  params )

static

Definition at line 3761 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("read event buffers");
      doc->P("buffer_name", MJSON_STRING, "name of event buffer");
      doc->P("event_id?", MJSON_INT, "requested event id, -1 means any event id");
      doc->P("trigger_mask?", MJSON_INT, "requested trigger mask, -1 means any trigger mask");
      doc->P("get_recent?", MJSON_BOOL, "get last available event that matches this event request");
      doc->P("last_event_header[]?", MJSON_INT, "do not resend an event we already received: event header of last received event [event_id,trigger_mask,serial_number,time_stamp]");
      doc->P("timeout_millisec?", MJSON_NUMBER, "how long to wait for an event");
      doc->R("binary data", MJSON_ARRAYBUFFER, "binary event data");
      doc->R("status", MJSON_INT, "return status of bm_open_buffer(), bm_request_event(), bm_set_cache_size(), bm_receive_alloc()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string buffer_name  = mjsonrpc_get_param(params, "buffer_name", &error)->GetString(); if (error) return error;
   int event_id = mjsonrpc_get_param(params, "event_id", NULL)->GetInt();
   int trigger_mask = mjsonrpc_get_param(params, "trigger_mask", NULL)->GetInt();
   bool get_recent  = mjsonrpc_get_param(params, "get_recent", NULL)->GetBool();
   const MJsonNodeVector* last_event_header = mjsonrpc_get_param(params, "last_event_header", NULL)->GetArray();
   int timeout_millisec = mjsonrpc_get_param(params, "timeout_millisec", NULL)->GetInt();
 
   int last_event_id      = 0;
   int last_trigger_mask  = 0;
   int last_serial_number = 0;
   int last_time_stamp    = 0;
 
   if (last_event_header && last_event_header->size() > 0) {
      if (last_event_header->size() != 4) {
         return mjsonrpc_make_error(-32602, "Invalid params", "last_event_header should be an array with 4 elements");
      }
      
      last_event_id      = (*last_event_header)[0]->GetInt();
      last_trigger_mask  = (*last_event_header)[1]->GetInt();
      last_serial_number = (*last_event_header)[2]->GetInt();
      last_time_stamp    = (*last_event_header)[3]->GetInt();
   }
 
   //printf("last event header: %d %d %d %d\n", last_event_id, last_trigger_mask, last_serial_number, last_time_stamp);
 
   if (event_id == 0)
      event_id = EVENTID_ALL;
 
   if (trigger_mask == 0)
      trigger_mask = TRIGGER_ALL;
 
   //printf("js_bm_receive_event: buffer \"%s\", event_id %d, trigger_mask 0x%04x\n", buffer_name.c_str(), event_id, trigger_mask);
 
   int status;
 
   HNDLE buffer_handle = 0;
 
   status = bm_get_buffer_handle(buffer_name.c_str(), &buffer_handle);
 
   if (status != BM_SUCCESS) {
      // if buffer not already open, we need to open it,
      // but we must hold a lock in case multiple RPC handler threads
      // try to open it at the same time. K.O.
      static std::mutex gMutex;
      std::lock_guard<std::mutex> lock_guard(gMutex); // lock the mutex
 
      // we have the lock. now we check if some other thread
      // opened the buffer while we were waiting for the lock. K.O.
      status = bm_get_buffer_handle(buffer_name.c_str(), &buffer_handle);
 
      if (status != BM_SUCCESS) {
         status = bm_open_buffer(buffer_name.c_str(), 0, &buffer_handle);
         if (status != BM_SUCCESS && status != BM_CREATED) {
            MJsonNode* result = MJsonNode::MakeObject();
            result->AddToObject("status", MJsonNode::MakeInt(status));
            return mjsonrpc_make_result(result);
         }
         status = bm_set_cache_size(buffer_handle, 0, 0);
         if (status != BM_SUCCESS) {
            MJsonNode* result = MJsonNode::MakeObject();
            result->AddToObject("status", MJsonNode::MakeInt(status));
            return mjsonrpc_make_result(result);
         }
         int request_id = 0;
         status = bm_request_event(buffer_handle, EVENTID_ALL, TRIGGER_ALL, GET_NONBLOCKING, &request_id, NULL);
         if (status != BM_SUCCESS) {
            MJsonNode* result = MJsonNode::MakeObject();
            result->AddToObject("status", MJsonNode::MakeInt(status));
            return mjsonrpc_make_result(result);
         }
      }
   }
 
   if (timeout_millisec <= 0)
      timeout_millisec = 100.0;
 
   double start_time = ss_time_sec();
   double end_time = start_time + timeout_millisec/1000.0;
 
   // in "GET_RECENT" mode, we read all avialable events from the event buffer
   // and save them in the event stash (MatchEvent()), after we empty the event
   // buffer (BM_ASYNC_RETURN), we send the last saved event. K.O.
 
   while (1) {
      EVENT_HEADER* pevent = NULL;
      
      status = bm_receive_event_alloc(buffer_handle, &pevent, BM_NO_WAIT);
 
      if (status == BM_SUCCESS) {
         //printf("got event_id %d, trigger_mask 0x%04x\n", pevent->event_id, pevent->trigger_mask);
 
         if (get_recent) {
            if (bm_match_event(event_id, trigger_mask, pevent)) {
               StashEvent(buffer_name, event_id, trigger_mask, pevent);
            } else {
               MatchEvent(buffer_name, pevent);
            }
            free(pevent);
            pevent = NULL;
         } else {
            if (bm_match_event(event_id, trigger_mask, pevent)) {
               StashEvent(buffer_name, event_id, trigger_mask, pevent);
 
               size_t event_size = sizeof(EVENT_HEADER) + pevent->data_size;
               //size_t total_size = ALIGN8(event_size);
               return MJsonNode::MakeArrayBuffer((char*)pevent, event_size);
            }
 
            MatchEvent(buffer_name, pevent);
            
            free(pevent);
            pevent = NULL;
         }
      } else if (status == BM_ASYNC_RETURN) {
         if (get_recent) {
            //printf("bm_async_return!\n");
            break;
         }
         ss_sleep(10);
      } else {
         MJsonNode* result = MJsonNode::MakeObject();
         result->AddToObject("status", MJsonNode::MakeInt(status));
         return mjsonrpc_make_result(result);
      }
 
      if (ss_time_sec() > end_time) {
         //printf("timeout!\n");
         break;
      }
   }
 
   const EVENT_HEADER* pevent = FindEvent(buffer_name, event_id, trigger_mask, last_event_id, last_trigger_mask, last_serial_number, last_time_stamp);
   if (pevent) {
      size_t event_size = sizeof(EVENT_HEADER) + pevent->data_size;
      //size_t total_size = ALIGN8(event_size);
      return MJsonNode::MakeArrayBuffer((char*)pevent, event_size);
   }
      
   MJsonNode* result = MJsonNode::MakeObject();
   result->AddToObject("status", MJsonNode::MakeInt(BM_ASYNC_RETURN));
   return mjsonrpc_make_result(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_cm_exist()

static MJsonNode * js_cm_exist ( const MJsonNode *  params )

static

Definition at line 432 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("calls MIDAS cm_exist() to check if given MIDAS program is running");
      doc->P("name", MJSON_STRING, "name of the program, corresponding to ODB /Programs/name");
      doc->P("unique?", MJSON_BOOL, "bUnique argument to cm_exist()");
      doc->R("status", MJSON_INT, "return status of cm_exist()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name = mjsonrpc_get_param(params, "name", &error)->GetString();
   if (error)
      return error;
 
   int unique = mjsonrpc_get_param(params, "unique", NULL)->GetBool();
 
   int status = cm_exist(name.c_str(), unique);
 
   if (mjsonrpc_debug)
      printf("cm_exist(%s,%d) -> %d\n", name.c_str(), unique, status);
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_cm_msg1()

static MJsonNode * js_cm_msg1 ( const MJsonNode *  params )

static

Definition at line 1497 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("Generate a midas message using cm_msg1()");
      doc->P("facility?", MJSON_STRING, "message facility, default is \"midas\"");
      doc->P("user?", MJSON_STRING, "message user, default is \"javascript_commands\"");
      doc->P("type?", MJSON_INT, "message type, MT_xxx from midas.h, default is MT_INFO");
      doc->P("message", MJSON_STRING, "message text");
      doc->R("status", MJSON_INT, "return status of cm_msg1()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string facility = mjsonrpc_get_param(params, "facility", NULL)->GetString();
   std::string user = mjsonrpc_get_param(params, "user", NULL)->GetString();
   int type = mjsonrpc_get_param(params, "type", NULL)->GetInt();
   std::string message = mjsonrpc_get_param(params, "message", &error)->GetString(); if (error) return error;
 
   if (facility.size() <1)
      facility = "midas";
   if (user.size()<1)
      user = "javascript_commands";
   if (type == 0)
      type = MT_INFO;
 
   int status = cm_msg1(type, __FILE__, __LINE__, facility.c_str(), user.c_str(), "%s", message.c_str());
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_cm_msg_facilities()

static MJsonNode * js_cm_msg_facilities ( const MJsonNode *  params )

static

Definition at line 1472 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get message facilities using cm_msg_facilities()");
      doc->R("status", MJSON_INT, "return status of cm_msg_facilities()");
      doc->R("facilities[]", MJSON_STRING, "array of facility names");
      return doc;
   }
 
   STRING_LIST list;
   
   int status = cm_msg_facilities(&list);
 
   MJsonNode* facilities = MJsonNode::MakeArray();
 
   for (unsigned i=0; i<list.size(); i++) {
      ss_repair_utf8(list[i]);
      facilities->AddToArray(MJsonNode::MakeString(list[i].c_str()));
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status),
                               "facilities", facilities);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_cm_msg_retrieve()

static MJsonNode * js_cm_msg_retrieve ( const MJsonNode *  params )

static

Definition at line 1529 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("Retrieve midas messages using cm_msg_retrieve2()");
      doc->P("facility?", MJSON_STRING, "message facility, default is \"midas\"");
      doc->P("min_messages?", MJSON_INT, "get at least this many messages, default is 1");
      doc->P("time?", MJSON_NUMBER, "start from given timestamp, value 0 means give me newest messages, default is 0");
      doc->R("num_messages", MJSON_INT, "number of messages returned");
      doc->R("messages", MJSON_STRING, "messages separated by \\n");
      doc->R("status", MJSON_INT, "return status of cm_msg_retrieve2()");
      return doc;
   }
 
   std::string facility = mjsonrpc_get_param(params, "facility", NULL)->GetString();
   int min_messages = mjsonrpc_get_param(params, "min_messages", NULL)->GetInt();
   double time = mjsonrpc_get_param(params, "time", NULL)->GetDouble();
 
   if (facility.size() < 1)
      facility = "midas";
 
   int num_messages = 0;
   char* messages = NULL;
 
   int status = cm_msg_retrieve2(facility.c_str(), (time_t)time, min_messages, &messages, &num_messages);
 
   MJsonNode* result = MJsonNode::MakeObject();
 
   result->AddToObject("status", MJsonNode::MakeInt(status));
   result->AddToObject("num_messages", MJsonNode::MakeInt(num_messages));
 
   if (messages) {
      ss_repair_utf8(messages);
      result->AddToObject("messages", MJsonNode::MakeString(messages));
      free(messages);
      messages = NULL;
   }
 
   return mjsonrpc_make_result(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_cm_shutdown()

static MJsonNode * js_cm_shutdown ( const MJsonNode *  params )

static

Definition at line 459 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("calls MIDAS cm_shutdown() to stop given MIDAS program");
      doc->P("name", MJSON_STRING, "name of the program, corresponding to ODB /Programs/name");
      doc->R("status", MJSON_INT, "return status of cm_shutdown()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name = mjsonrpc_get_param(params, "name", &error)->GetString();
   if (error)
      return error;
 
   int status = cm_shutdown(name.c_str());
 
   if (mjsonrpc_debug)
      printf("cm_shutdown(%s) -> %d\n", name.c_str(), status);
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_cm_transition()

static MJsonNode * js_cm_transition ( const MJsonNode *  params )

static

Definition at line 3580 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("start and stop runs");
      doc->P("transition", MJSON_STRING, "requested transition: TR_START, TR_STOP, TR_PAUSE, TR_RESUME");
      doc->P("run_number?", MJSON_INT, "New run number, value 0 means /runinfo/run_number + 1, default is 0");
      doc->P("async_flag?", MJSON_INT, "Transition type. Default is multithreaded transition TR_MTHREAD");
      doc->P("debug_flag?", MJSON_INT, "See cm_transition(), value 1: trace to stdout, value 2: trace to midas.log");
      doc->R("status", MJSON_INT, "return status of cm_transition()");
      doc->R("error_string?", MJSON_STRING, "return error string from cm_transition()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string xtransition = mjsonrpc_get_param(params, "transition", &error)->GetString(); if (error) return error;
   int run_number = mjsonrpc_get_param(params, "run_number", NULL)->GetInt();
   int async_flag = mjsonrpc_get_param(params, "async_flag", NULL)->GetInt();
   int debug_flag = mjsonrpc_get_param(params, "debug_flag", NULL)->GetInt();
 
   int status;
 
   int transition = 0;
 
   if (xtransition == "TR_START")
      transition = TR_START;
   else if (xtransition == "TR_STOP")
      transition = TR_STOP;
   else if (xtransition == "TR_PAUSE")
      transition = TR_PAUSE;
   else if (xtransition == "TR_RESUME")
      transition = TR_RESUME;
   else {
      return mjsonrpc_make_error(15, "invalid value of \"transition\"", xtransition.c_str());
   }
 
   if (async_flag == 0)
      async_flag = TR_MTHREAD;
 
   char error_str[1024];
   
   status = cm_transition(transition, run_number, error_str, sizeof(error_str), async_flag, debug_flag);
 
   MJsonNode* result = MJsonNode::MakeObject();
 
   result->AddToObject("status", MJsonNode::MakeInt(status));
   if (strlen(error_str) > 0) {
      ss_repair_utf8(error_str);
      result->AddToObject("error_string", MJsonNode::MakeString(error_str));
   }
   return mjsonrpc_make_result(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_copy()

static MJsonNode * js_db_copy ( const MJsonNode *  params )

static

Definition at line 857 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get complete ODB data in the \"save\" json encoding, suitable for reloading with odbedit command \"load\"");
      doc->P("paths[]",  MJSON_STRING, "array of ODB subtree paths");
      doc->R("data[]",   MJSON_OBJECT, "keys and values of ODB data for each path");
      doc->R("status[]", MJSON_INT, "return status of db_copy_json_save() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths = mjsonrpc_get_param_array(params, "paths", &error); if (error) return error;
 
   MJsonNode* dresult = MJsonNode::MakeArray();
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         dresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      char* buf = NULL;
      int bufsize = 0;
      int end = 0;
 
      status = db_copy_json_save(hDB, hkey, &buf, &bufsize, &end);
 
      if (status == DB_SUCCESS) {
         ss_repair_utf8(buf);
         dresult->AddToArray(MJsonNode::MakeJSON(buf));
         sresult->AddToArray(MJsonNode::MakeInt(status));
      } else {
         dresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
      }
 
      if (buf)
         free(buf);
   }
 
   return mjsonrpc_make_result("data", dresult, "status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_create()

static MJsonNode * js_db_create ( const MJsonNode *  params )

static

Definition at line 1027 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Create new ODB entries");
      MJSO* o = doc->PA("array of ODB paths to be created")->AddObject("", "arguments to db_create_key() and db_set_num_values()");
      o->Add("path", MJSON_STRING, "ODB path to be created");
      o->Add("type", MJSON_INT, "MIDAS TID_xxx type");
      o->Add("array_length?", MJSON_INT, "optional array length, default is 1");
      o->Add("string_length?", MJSON_INT, "for TID_STRING, optional string length, default is NAME_LENGTH");
      doc->R("status[]", MJSON_INT, "return status of db_create_key(), db_set_num_values() and db_set_data() (for TID_STRING) for each path");
      return doc;
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   const MJsonNodeVector* pp = params->GetArray();
 
   if (!pp) {
      delete sresult;
      return mjsonrpc_make_error(-32602, "Invalid params", "parameters must be an array of objects");
   }
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<pp->size(); i++) {
      const MJsonNode* p = (*pp)[i];
      std::string path = mjsonrpc_get_param(p, "path", NULL)->GetString();
      int type = mjsonrpc_get_param(p, "type", NULL)->GetInt();
      int array_length = mjsonrpc_get_param(p, "array_length", NULL)->GetInt();
      int string_length = mjsonrpc_get_param(p, "string_length", NULL)->GetInt();
 
      //printf("create odb [%s], type %d, array %d, string %d\n", path.c_str(), type, array_length, string_length);
 
      if (string_length == 0)
         string_length = NAME_LENGTH;
 
      int status = db_create_key(hDB, 0, path.c_str(), type);
 
      if (status == DB_SUCCESS && string_length > 0 && type == TID_STRING) {
         HNDLE hKey;
         status = db_find_key(hDB, 0, path.c_str(), &hKey);
         if (status == DB_SUCCESS) {
            char* buf = (char*)calloc(1, string_length);
            assert(buf != NULL);
            int size = string_length;
            status = db_set_data(hDB, hKey, buf, size, 1, TID_STRING);
            free(buf);
         }
      }
 
      if (status == DB_SUCCESS && array_length > 1) {
         HNDLE hKey;
         status = db_find_key(hDB, 0, path.c_str(), &hKey);
         if (status == DB_SUCCESS)
            status = db_set_num_values(hDB, hKey, array_length);
      }
 
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_delete()

static MJsonNode * js_db_delete ( const MJsonNode *  params )

static

Definition at line 1092 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("delete ODB keys");
      doc->P("paths[]", MJSON_STRING, "array of ODB paths to delete");
      doc->R("status[]", MJSON_INT, "return status of db_delete() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths  = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      std::string path = (*paths)[i]->GetString();
      int status = db_delete(hDB, 0, path.c_str());
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_get_values()

static MJsonNode * js_db_get_values ( const MJsonNode *  params )

static

Definition at line 637 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get values of ODB data from given subtrees");
      doc->P("paths[]", MJSON_STRING, "array of ODB subtree paths, see note on array indices");
      doc->P("omit_names?", MJSON_BOOL, "omit the /name entries");
      doc->P("omit_last_written?", MJSON_BOOL, "omit the /last_written entries and the last_written[] result");
      doc->P("omit_tid?", MJSON_BOOL, "omit the tid[] result");
      doc->P("omit_old_timestamp?", MJSON_NUMBER, "omit data older than given ODB timestamp");
      doc->P("preserve_case?", MJSON_BOOL, "preserve the capitalization of ODB key names (WARNING: ODB is not case sensitive); note that this will also have side effect of setting the omit_names option");
      doc->R("data[]", 0, "values of ODB data for each path, all key names are in lower case, all symlinks are followed");
      doc->R("status[]", MJSON_INT, "return status of db_copy_json_values() or db_copy_json_index() for each path");
      doc->R("tid?[]", MJSON_INT, "odb type id for each path, absent if omit_tid is true");
      doc->R("last_written?[]", MJSON_NUMBER, "last_written value of the ODB subtree for each path, absent if omit_last_written is true");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths = mjsonrpc_get_param_array(params, "paths", &error); if (error) return error;
 
   bool omit_names = mjsonrpc_get_param(params, "omit_names", NULL)->GetBool();
   bool omit_last_written = mjsonrpc_get_param(params, "omit_last_written", NULL)->GetBool();
   bool omit_tid = mjsonrpc_get_param(params, "omit_tid", NULL)->GetBool();
   double xomit_old_timestamp = mjsonrpc_get_param(params, "omit_old_timestamp", NULL)->GetDouble();
   time_t omit_old_timestamp = (time_t)xomit_old_timestamp;
   bool preserve_case = mjsonrpc_get_param(params, "preserve_case", NULL)->GetBool();
   
   MJsonNode* dresult = MJsonNode::MakeArray();
   MJsonNode* sresult = MJsonNode::MakeArray();
   MJsonNode* tresult = MJsonNode::MakeArray();
   MJsonNode* lwresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      KEY key;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         dresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
         tresult->AddToArray(MJsonNode::MakeNull());
         lwresult->AddToArray(MJsonNode::MakeNull());
         continue;
      }
 
      status = db_get_key(hDB, hkey, &key);
      if (status != DB_SUCCESS) {
         dresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
         tresult->AddToArray(MJsonNode::MakeNull());
         lwresult->AddToArray(MJsonNode::MakeNull());
         continue;
      }
 
      if (path.find("[") != std::string::npos) {
         std::vector<unsigned> list;
         status = parse_array_index_list("js_db_get_values", path.c_str(), &list);
 
         if (status != SUCCESS) {
            dresult->AddToArray(MJsonNode::MakeNull());
            sresult->AddToArray(MJsonNode::MakeInt(status));
            tresult->AddToArray(MJsonNode::MakeInt(key.type));
            lwresult->AddToArray(MJsonNode::MakeInt(key.last_written));
            continue;
         }
 
         if (list.size() > 1) {
            MJsonNode *ddresult = MJsonNode::MakeArray();
            MJsonNode *ssresult = MJsonNode::MakeArray();
 
            for (unsigned i=0; i<list.size(); i++) {
               char* buf = NULL;
               int bufsize = 0;
               int end = 0;
               
               status = db_copy_json_index(hDB, hkey, list[i], &buf, &bufsize, &end);
               if (status == DB_SUCCESS) {
                  ss_repair_utf8(buf);
                  ddresult->AddToArray(MJsonNode::MakeJSON(buf));
                  ssresult->AddToArray(MJsonNode::MakeInt(status));
               } else {
                  ddresult->AddToArray(MJsonNode::MakeNull());
                  ssresult->AddToArray(MJsonNode::MakeInt(status));
               }
 
               if (buf)
                  free(buf);
            }
 
            dresult->AddToArray(ddresult);
            sresult->AddToArray(ssresult);
            tresult->AddToArray(MJsonNode::MakeInt(key.type));
            lwresult->AddToArray(MJsonNode::MakeInt(key.last_written));
 
         } else {
            char* buf = NULL;
            int bufsize = 0;
            int end = 0;
            
            status = db_copy_json_index(hDB, hkey, list[0], &buf, &bufsize, &end);
            if (status == DB_SUCCESS) {
               ss_repair_utf8(buf);
               dresult->AddToArray(MJsonNode::MakeJSON(buf));
               sresult->AddToArray(MJsonNode::MakeInt(status));
               tresult->AddToArray(MJsonNode::MakeInt(key.type));
               lwresult->AddToArray(MJsonNode::MakeInt(key.last_written));
            } else {
               dresult->AddToArray(MJsonNode::MakeNull());
               sresult->AddToArray(MJsonNode::MakeInt(status));
               tresult->AddToArray(MJsonNode::MakeInt(key.type));
               lwresult->AddToArray(MJsonNode::MakeInt(key.last_written));
            }
            
            if (buf)
               free(buf);
         }
      } else {
         char* buf = NULL;
         int bufsize = 0;
         int end = 0;
 
         status = db_copy_json_values(hDB, hkey, &buf, &bufsize, &end, omit_names,
                                      omit_last_written, omit_old_timestamp, preserve_case);
 
         if (status == DB_SUCCESS) {
            ss_repair_utf8(buf);
            dresult->AddToArray(MJsonNode::MakeJSON(buf));
            sresult->AddToArray(MJsonNode::MakeInt(status));
            tresult->AddToArray(MJsonNode::MakeInt(key.type));
            lwresult->AddToArray(MJsonNode::MakeInt(key.last_written));
         } else {
            dresult->AddToArray(MJsonNode::MakeNull());
            sresult->AddToArray(MJsonNode::MakeInt(status));
            tresult->AddToArray(MJsonNode::MakeInt(key.type));
            lwresult->AddToArray(MJsonNode::MakeInt(key.last_written));
         }
 
         if (buf)
            free(buf);
      }
   }
 
   MJsonNode* result = MJsonNode::MakeObject();
 
   result->AddToObject("data", dresult);
   result->AddToObject("status", sresult);
   if (!omit_tid)
      result->AddToObject("tid", tresult);
   else
      delete tresult;
   if (!omit_last_written)
      result->AddToObject("last_written", lwresult);
   else
      delete lwresult;
 
   return mjsonrpc_make_result(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_key()

static MJsonNode * js_db_key ( const MJsonNode *  params )

static

Definition at line 1222 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get ODB keys");
      doc->P("paths[]", MJSON_STRING, "array of ODB paths");
      doc->R("status[]", MJSON_INT, "return status of db_key() for each path");
      doc->R("keys[]", MJSON_OBJECT, "key data for each path");
      doc->R("keys[].type", MJSON_INT, "key type TID_xxx");
      doc->R("keys[].num_values", MJSON_INT, "array length, 1 for normal entries");
      doc->R("keys[].name", MJSON_STRING, "key name");
      doc->R("keys[].total_size", MJSON_INT, "data total size in bytes");
      doc->R("keys[].item_size", MJSON_INT, "array element size, string length for TID_STRING");
      doc->R("keys[].access_mode", MJSON_INT, "access mode bitmap of MODE_xxx");
      doc->R("keys[].notify_count", MJSON_INT, "number of hotlinks attached to this key");
      doc->R("keys[].last_written", MJSON_INT, "timestamp when data was last updated");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths  = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
 
   MJsonNode* kresult = MJsonNode::MakeArray();
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      KEY key;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         kresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      status = db_get_key(hDB, hkey, &key);
      if (status != DB_SUCCESS) {
         kresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      MJsonNode* jkey = MJsonNode::MakeObject();
 
      jkey->AddToObject("type", MJsonNode::MakeInt(key.type));
      jkey->AddToObject("num_values", MJsonNode::MakeInt(key.num_values));
      ss_repair_utf8(key.name);
      jkey->AddToObject("name", MJsonNode::MakeString(key.name));
      jkey->AddToObject("total_size", MJsonNode::MakeInt(key.total_size));
      jkey->AddToObject("item_size", MJsonNode::MakeInt(key.item_size));
      jkey->AddToObject("access_mode", MJsonNode::MakeInt(key.access_mode));
      jkey->AddToObject("notify_count", MJsonNode::MakeInt(key.notify_count));
      jkey->AddToObject("last_written", MJsonNode::MakeInt(key.last_written));
 
      kresult->AddToArray(jkey);
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("keys", kresult, "status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_link()

static MJsonNode * js_db_link ( const MJsonNode *  params )

static

Definition at line 1340 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Create ODB symlinks");
      doc->P("new_links[]", MJSON_STRING, "array of new symlinks to be created");
      doc->P("target_paths[]", MJSON_STRING, "array of existing ODB paths for each link");
      doc->R("status[]", MJSON_INT, "return status of db_create_link() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* target_paths = mjsonrpc_get_param_array(params, "target_paths",  &error); if (error) return error;
   const MJsonNodeVector* new_links = mjsonrpc_get_param_array(params, "new_links", &error); if (error) return error;
 
   if (target_paths->size() != new_links->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "arrays \"target_paths\" and \"new_links\" should have the same length");
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<new_links->size(); i++) {
      int status = 0;
      std::string target_path = (*target_paths)[i]->GetString();
      std::string new_link = (*new_links)[i]->GetString();
      if (new_link.length() < 1) {
         sresult->AddToArray(MJsonNode::MakeInt(DB_INVALID_PARAM));
         continue;
      }
 
      status = db_create_link(hDB, 0, new_link.c_str(), target_path.c_str());
 
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_ls()

static MJsonNode * js_db_ls ( const MJsonNode *  params )

static

Definition at line 802 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get contents of given ODB subdirectory in the \"ls\" json encoding - similar to odbedit command \"ls -l\"");
      doc->P("paths[]",  MJSON_STRING, "array of ODB subtree paths");
      doc->R("data[]",   MJSON_OBJECT, "keys and values of ODB data for each path");
      doc->R("status[]", MJSON_INT, "return status of db_copy_json_ls() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths = mjsonrpc_get_param_array(params, "paths", &error); if (error) return error;
 
   MJsonNode* dresult = MJsonNode::MakeArray();
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         dresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      char* buf = NULL;
      int bufsize = 0;
      int end = 0;
 
      status = db_copy_json_ls(hDB, hkey, &buf, &bufsize, &end);
 
      if (status == DB_SUCCESS) {
         ss_repair_utf8(buf);
         dresult->AddToArray(MJsonNode::MakeJSON(buf));
         sresult->AddToArray(MJsonNode::MakeInt(status));
      } else {
         dresult->AddToArray(MJsonNode::MakeNull());
         sresult->AddToArray(MJsonNode::MakeInt(status));
      }
 
      if (buf)
         free(buf);
   }
 
   return mjsonrpc_make_result("data", dresult, "status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_paste()

static MJsonNode * js_db_paste ( const MJsonNode *  params )

static

Definition at line 912 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("write data into ODB");
      doc->P("paths[]", MJSON_STRING, "array of ODB subtree paths, see note on array indices");
      doc->P("values[]", 0, "array of data values written to ODB via db_paste_json() for each path");
      doc->R("status[]", MJSON_INT, "array of return status of db_paste_json() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths  = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
   const MJsonNodeVector* values = mjsonrpc_get_param_array(params, "values", &error); if (error) return error;
 
   if (paths->size() != values->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "paths and values should have the same length");
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      const MJsonNode* v = (*values)[i];
      assert(v != NULL);
 
      if (path.find("[*]") != std::string::npos) {
 
         KEY key;
         db_get_key(hDB, hkey, &key);
         for (int j=0 ; j<key.num_values ; j++)
            status = db_paste_json_node(hDB, hkey, j, v);
 
      } else if (path.find("[") != std::string::npos) {
         std::vector<unsigned> list;
         status = parse_array_index_list("js_db_paste", path.c_str(), &list);
 
         if (status != SUCCESS) {
            sresult->AddToArray(MJsonNode::MakeInt(status));
            continue;
         }
 
         // supported permutations of array indices and data values:
         // single index: intarray[1] -> data should be a single value: MJSON_ARRAY is rejected right here, MJSON_OBJECT is rejected by db_paste
         // multiple index intarray[1,2,3] -> data should be an array of equal length, or
         // multiple index intarray[1,2,3] -> if data is a single value, all array elements are set to this same value
         
         if (list.size() < 1) {
            cm_msg(MERROR, "js_db_paste", "invalid array indices for array path \"%s\"", path.c_str());
            sresult->AddToArray(MJsonNode::MakeInt(DB_TYPE_MISMATCH));
            continue;
         } else if (list.size() == 1) {
            if (v->GetType() == MJSON_ARRAY) {
               cm_msg(MERROR, "js_db_paste", "unexpected array of values for array path \"%s\"", path.c_str());
               sresult->AddToArray(MJsonNode::MakeInt(DB_TYPE_MISMATCH));
               continue;
            }
 
            status = db_paste_json_node(hDB, hkey, list[0], v);
            sresult->AddToArray(MJsonNode::MakeInt(status));
         } else if ((list.size() > 1) && (v->GetType() == MJSON_ARRAY)) {
            const MJsonNodeVector* vvalues = v->GetArray();
 
            if (list.size() != vvalues->size()) {
               cm_msg(MERROR, "js_db_paste", "length of values array %d should be same as number of indices %d for array path \"%s\"", (int)vvalues->size(), (int)list.size(), path.c_str());
               sresult->AddToArray(MJsonNode::MakeInt(DB_TYPE_MISMATCH));
               continue;
            }
 
            MJsonNode *ssresult = MJsonNode::MakeArray();
 
            for (unsigned j =0; j <list.size(); j++) {
               const MJsonNode* vv = (*vvalues)[j];
 
               if (vv == NULL) {
                  cm_msg(MERROR, "js_db_paste", "internal error: NULL array value at index %d for array path \"%s\"", j, path.c_str());
                  sresult->AddToArray(MJsonNode::MakeInt(DB_TYPE_MISMATCH));
                  continue;
               }
 
               status = db_paste_json_node(hDB, hkey, list[j], vv);
               ssresult->AddToArray(MJsonNode::MakeInt(status));
            }
            
            sresult->AddToArray(ssresult);
         } else {
            MJsonNode *ssresult = MJsonNode::MakeArray();
            for (unsigned j =0; j <list.size(); j++) {
               status = db_paste_json_node(hDB, hkey, list[j], v);
               ssresult->AddToArray(MJsonNode::MakeInt(status));
            }
            sresult->AddToArray(ssresult);
         }
      } else {
         status = db_paste_json_node(hDB, hkey, 0, v);
         sresult->AddToArray(MJsonNode::MakeInt(status));
      }
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_rename()

static MJsonNode * js_db_rename ( const MJsonNode *  params )

static

Definition at line 1290 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Change size of ODB arrays");
      doc->P("paths[]", MJSON_STRING, "array of ODB paths to rename");
      doc->P("new_names[]", MJSON_STRING, "array of new names for each ODB path");
      doc->R("status[]", MJSON_INT, "return status of db_rename_key() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
   const MJsonNodeVector* names = mjsonrpc_get_param_array(params, "new_names", &error); if (error) return error;
 
   if (paths->size() != names->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "arrays \"paths\" and \"new_names\" should have the same length");
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_link(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      std::string new_name = (*names)[i]->GetString();
      if (new_name.length() < 1) {
         sresult->AddToArray(MJsonNode::MakeInt(DB_INVALID_PARAM));
         continue;
      }
 
      status = db_rename_key(hDB, hkey, new_name.c_str());
 
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_reorder()

static MJsonNode * js_db_reorder ( const MJsonNode *  params )

static

Definition at line 1382 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Change order of ODB keys in a subdirectory");
      doc->P("paths[]", MJSON_STRING, "array of new symlinks to be created");
      doc->P("indices[]", MJSON_INT, "array of existing ODB paths for each link");
      doc->R("status[]", MJSON_INT, "return status of db_reorder_key() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
   const MJsonNodeVector* indices = mjsonrpc_get_param_array(params, "indices", &error); if (error) return error;
 
   if (paths->size() != indices->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "arrays \"paths\" and \"indices\" should have the same length");
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      std::string path = (*paths)[i]->GetString();
      int index = (*indices)[i]->GetInt();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      status = db_reorder_key(hDB, hkey, index);
 
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_resize()

static MJsonNode * js_db_resize ( const MJsonNode *  params )

static

Definition at line 1120 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Change size of ODB arrays");
      doc->P("paths[]", MJSON_STRING, "array of ODB paths to resize");
      doc->P("new_lengths[]", MJSON_INT, "array of new lengths for each ODB path");
      doc->R("status[]", MJSON_INT, "return status of db_set_num_values() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths   = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
   const MJsonNodeVector* lengths = mjsonrpc_get_param_array(params, "new_lengths", &error); if (error) return error;
 
   if (paths->size() != lengths->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "arrays \"paths\" and \"new_lengths\" should have the same length");
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      int status = 0;
      HNDLE hkey;
      std::string path = (*paths)[i]->GetString();
 
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         sresult->AddToArray(MJsonNode::MakeInt(status));
         continue;
      }
 
      int length = (*lengths)[i]->GetInt();
      if (length < 1) {
         sresult->AddToArray(MJsonNode::MakeInt(DB_INVALID_PARAM));
         continue;
      }
 
      status = db_set_num_values(hDB, hkey, length);
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_resize_string()

static MJsonNode * js_db_resize_string ( const MJsonNode *  params )

static

Definition at line 1169 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Change size of ODB string arrays");
      doc->P("paths[]", MJSON_STRING, "array of ODB paths to resize");
      doc->P("new_lengths[]", MJSON_INT, "array of new lengths for each ODB path");
      doc->P("new_string_lengths[]", MJSON_INT, "array of new string lengths for each ODB path");
      doc->R("status[]", MJSON_INT, "return status of db_resize_string() for each path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   const MJsonNodeVector* paths   = mjsonrpc_get_param_array(params, "paths",  &error); if (error) return error;
   const MJsonNodeVector* lengths = mjsonrpc_get_param_array(params, "new_lengths", &error); if (error) return error;
   const MJsonNodeVector* string_lengths = mjsonrpc_get_param_array(params, "new_string_lengths", &error); if (error) return error;
 
   if (paths->size() != lengths->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "arrays \"paths\" and \"new_lengths\" should have the same length");
   }
 
   if (paths->size() != string_lengths->size()) {
      return mjsonrpc_make_error(-32602, "Invalid params", "arrays \"paths\" and \"new_string_lengths\" should have the same length");
   }
 
   MJsonNode* sresult = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   for (unsigned i=0; i<paths->size(); i++) {
      std::string path = (*paths)[i]->GetString();
 
      int length = (*lengths)[i]->GetInt();
      if (length < 0) {
         sresult->AddToArray(MJsonNode::MakeInt(DB_INVALID_PARAM));
         continue;
      }
 
      int string_length = (*string_lengths)[i]->GetInt();
      if (length < 0) {
         sresult->AddToArray(MJsonNode::MakeInt(DB_INVALID_PARAM));
         continue;
      }
 
      int status = db_resize_string(hDB, 0, path.c_str(), length, string_length);
      sresult->AddToArray(MJsonNode::MakeInt(status));
   }
 
   return mjsonrpc_make_result("status", sresult);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_scl()

static MJsonNode * js_db_scl ( const MJsonNode *  params )

static

Definition at line 1449 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Show ODB clients");
      doc->R("scl", MJSON_JSON, "return value of db_scl()");
      return doc;
   }
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   MJsonNode* scl = db_scl(hDB);
 
   return mjsonrpc_make_result("scl", scl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_db_sor()

static MJsonNode * js_db_sor ( const MJsonNode *  params )

static

Definition at line 1427 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Show ODB open records starting from given ODB path");
      doc->P("path?", MJSON_STRING, "ODB path");
      doc->R("sor", MJSON_JSON, "return value of db_sor()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string path = mjsonrpc_get_param(params, "path", NULL)->GetString(); if (error) return error;
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   MJsonNode* sor = db_sor(hDB, path.c_str());
 
   return mjsonrpc_make_result("sor", sor);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_el_delete()

static MJsonNode * js_el_delete ( const MJsonNode *  params )

static

Definition at line 3322 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Delete elog message");
      doc->P("tag", MJSON_STRING, "tag of message to delete");
      doc->R("status", MJSON_INT, "return status of el_delete");
      return doc;
   }
 
   MJsonNode* error = NULL;
   std::string tag = mjsonrpc_get_param(params, "tag", &error)->GetString(); if (error) return error;
   int status = el_delete_message(tag.c_str());
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_el_query()

static MJsonNode * js_el_query ( const MJsonNode *  params )

static

Definition at line 3047 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Query elog messages");
      doc->P("last_n_hours?", MJSON_INT, "return messages from the last N hours");
      doc->R("status", MJSON_INT, "return status of el_retrieve");
      doc->R("msg[].tag", MJSON_STRING, "message tag");
      return doc;
   }
 
   //MJsonNode* error = NULL;
 
   //int last_n = mjsonrpc_get_param(params, "last_n_hours", &error)->GetInt(); if (error) return error;
   int last_n = mjsonrpc_get_param(params, "last_n_hours", NULL)->GetInt();
 
   std::string pd1 = mjsonrpc_get_param(params, "d1", NULL)->GetString();
   std::string pm1 = mjsonrpc_get_param(params, "m1", NULL)->GetString();
   std::string py1 = mjsonrpc_get_param(params, "y1", NULL)->GetString();
 
   std::string pd2 = mjsonrpc_get_param(params, "d2", NULL)->GetString();
   std::string pm2 = mjsonrpc_get_param(params, "m2", NULL)->GetString();
   std::string py2 = mjsonrpc_get_param(params, "y2", NULL)->GetString();
 
   std::string pr1 = mjsonrpc_get_param(params, "r1", NULL)->GetString();
   std::string pr2 = mjsonrpc_get_param(params, "r2", NULL)->GetString();
 
   std::string ptype = mjsonrpc_get_param(params, "type", NULL)->GetString();
   std::string psystem = mjsonrpc_get_param(params, "system", NULL)->GetString();
   std::string pauthor = mjsonrpc_get_param(params, "author", NULL)->GetString();
   std::string psubject = mjsonrpc_get_param(params, "subject", NULL)->GetString();
   std::string psubtext = mjsonrpc_get_param(params, "subtext", NULL)->GetString();
 
   MJsonNode* msg_array = MJsonNode::MakeArray();
 
   int i, size, run, status;
   char date[80], author[80], type[80], system[80], subject[256], text[10000],
       orig_tag[80], reply_tag[80], attachment[3][256], encoding[80];
   char str[256], str2[10000], tag[256];
   struct tm tms;
 
   // month name from midas.c
   extern const char *mname[];
 
   /*---- convert end date to ltime ----*/
 
   int y1 = -1;
   int m1 = -1;
   int d1 = -1;
 
   int y2 = -1;
   int m2 = -1;
   int d2 = -1;
 
   int r1 = -1;
   int r2 = -1;
 
   if (pr1.length()>0)
      r1 = atoi(pr1.c_str());
 
   if (pr2.length()>0)
      r2 = atoi(pr2.c_str());
   
   time_t ltime_start = 0;
   time_t ltime_end = 0;
 
   if (!last_n) {
      // decode starting date year, day and month
      
      if (py1.length() > 0)
         y1 = atoi(py1.c_str());
 
      if (pd1.length() > 0)
         d1 = atoi(pd1.c_str());
 
      mstrlcpy(str, pm1.c_str(), sizeof(str));
      for (m1 = 0; m1 < 12; m1++)
         if (equal_ustring(str, mname[m1]))
            break;
      if (m1 == 12)
         m1 = 0;
 
      if (pd2.length() > 0) {
         d2 = atoi(pd2.c_str());
      }
         
      if (py2.length() > 0) {
         // decode ending date year, day and month
 
         mstrlcpy(str, pm2.c_str(), sizeof(str));
         for (m2 = 0; m2 < 12; m2++)
            if (equal_ustring(str, mname[m2]))
               break;
         if (m2 == 12) {
            m2 = 0;
         }
      }
 
      if (py2.length() > 0) {
         y2 = atoi(py2.c_str());
      }
 
      if (y2>=0 && m2>=0 && d2>=0) {
         memset(&tms, 0, sizeof(struct tm));
         tms.tm_year = y2 % 100;
         tms.tm_mon = m2;
         tms.tm_mday = d2;
         tms.tm_hour = 24;
         
         if (tms.tm_year < 90)
            tms.tm_year += 100;
         ltime_end = ss_mktime(&tms);
      }
   }
 
   /*---- do query ----*/
 
   tag[0] = 0;
 
   if (last_n) {
      ss_tzset(); // required for localtime_r()
      time_t now = time(NULL);
      ltime_start = now - 3600 * last_n;
      struct tm tms;
      localtime_r(&ltime_start, &tms);
      sprintf(tag, "%02d%02d%02d.0", tms.tm_year % 100, tms.tm_mon + 1, tms.tm_mday);
   } else if (r1 > 0) {
      /* do run query */
      el_search_run(r1, tag);
   } else if (y1>=0 && m1>=0 && d1>=0) {
      /* do date-date query */
      sprintf(tag, "%02d%02d%02d.0", y1 % 100, m1 + 1, d1);
   }
 
#if 0
   printf("js_el_query: y1 %d, m1 %d, d1 %d, y2 %d, m2 %d, d2 %d, r1 %d, r2 %d, last_n_hours %d, start time %lu, end time %lu, tag [%s]\n",
          y1, m1, d1,
          y2, m2, d2,
          r1, r2,
          last_n,
          ltime_start,
          ltime_end,
          tag);
#endif
 
   do {
      size = sizeof(text);
      status = el_retrieve(tag, date, &run, author, type, system, subject,
                           text, &size, orig_tag, reply_tag,
                           attachment[0], attachment[1], attachment[2], encoding);
 
      std::string this_tag = tag;
 
      //printf("js_el_query: el_retrieve: size %d, status %d, tag [%s], run %d, tags [%s] [%s]\n", size, status, tag, run, orig_tag, reply_tag);
      
      mstrlcat(tag, "+1", sizeof(tag));
 
      /* check for end run */
      if ((r2 > 0) && (r2 < run)) {
         break;
      }
 
      /* convert date to unix format */
      memset(&tms, 0, sizeof(struct tm));
      tms.tm_year = (tag[0] - '0') * 10 + (tag[1] - '0');
      tms.tm_mon = (tag[2] - '0') * 10 + (tag[3] - '0') - 1;
      tms.tm_mday = (tag[4] - '0') * 10 + (tag[5] - '0');
      tms.tm_hour = (date[11] - '0') * 10 + (date[12] - '0');
      tms.tm_min = (date[14] - '0') * 10 + (date[15] - '0');
      tms.tm_sec = (date[17] - '0') * 10 + (date[18] - '0');
 
      if (tms.tm_year < 90)
         tms.tm_year += 100;
 
      time_t ltime_current = ss_mktime(&tms);
 
      //printf("js_el_query: ltime: start %ld, end %ld, current %ld\n", ltime_start, ltime_end, ltime_current);
 
      /* check for start date */
      if (ltime_start > 0)
         if (ltime_current < ltime_start)
            continue;
 
      /* check for end date */
      if (ltime_end > 0) {
         if (ltime_current > ltime_end)
            break;
      }
 
      if (status == EL_SUCCESS) {
         /* do filtering */
         if ((ptype.length()>0) && !equal_ustring(ptype.c_str(), type))
            continue;
         if ((psystem.length()>0) && !equal_ustring(psystem.c_str(), system))
            continue;
 
         if (pauthor.length()>0) {
            mstrlcpy(str, pauthor.c_str(), sizeof(str));
            for (i = 0; i < (int) strlen(str); i++)
               str[i] = toupper(str[i]);
            str[i] = 0;
            for (i = 0; i < (int) strlen(author) && author[i] != '@'; i++)
               str2[i] = toupper(author[i]);
            str2[i] = 0;
 
            if (strstr(str2, str) == NULL)
               continue;
         }
 
         if (psubject.length()>0) {
            mstrlcpy(str, psubject.c_str(), sizeof(str));
            for (i = 0; i < (int) strlen(str); i++)
               str[i] = toupper(str[i]);
            str[i] = 0;
            for (i = 0; i < (int) strlen(subject); i++)
               str2[i] = toupper(subject[i]);
            str2[i] = 0;
 
            if (strstr(str2, str) == NULL)
               continue;
         }
 
         if (psubtext.length()>0) {
            mstrlcpy(str, psubtext.c_str(), sizeof(str));
            for (i = 0; i < (int) strlen(str); i++)
               str[i] = toupper(str[i]);
            str[i] = 0;
            for (i = 0; i < (int) strlen(text); i++)
               str2[i] = toupper(text[i]);
            str2[i] = 0;
 
            if (strstr(str2, str) == NULL)
               continue;
         }
 
         /* filter passed: display line */
 
         MJsonNode* msg = MJsonNode::MakeObject();
         
         ss_repair_utf8(this_tag);
         msg->AddToObject("tag", MJsonNode::MakeString(this_tag.c_str()));
         ss_repair_utf8(date);
         msg->AddToObject("date", MJsonNode::MakeString(date));
         msg->AddToObject("run", MJsonNode::MakeInt(run));
         ss_repair_utf8(author);
         msg->AddToObject("author", MJsonNode::MakeString(author));
         ss_repair_utf8(type);
         msg->AddToObject("type", MJsonNode::MakeString(type));
         ss_repair_utf8(system);
         msg->AddToObject("system", MJsonNode::MakeString(system));
         ss_repair_utf8(subject);
         msg->AddToObject("subject", MJsonNode::MakeString(subject));
         ss_repair_utf8(text);
         msg->AddToObject("text", MJsonNode::MakeString(text));
         ss_repair_utf8(orig_tag);
         msg->AddToObject("orig_tag", MJsonNode::MakeString(orig_tag));
         ss_repair_utf8(reply_tag);
         msg->AddToObject("reply_tag", MJsonNode::MakeString(reply_tag));
         ss_repair_utf8(attachment[0]);
         msg->AddToObject("attachment0", MJsonNode::MakeString(attachment[0]));
         ss_repair_utf8(attachment[1]);
         msg->AddToObject("attachment1", MJsonNode::MakeString(attachment[1]));
         ss_repair_utf8(attachment[2]);
         msg->AddToObject("attachment2", MJsonNode::MakeString(attachment[2]));
         ss_repair_utf8(encoding);
         msg->AddToObject("encoding", MJsonNode::MakeString(encoding));
 
         msg_array->AddToArray(msg);
      }
 
   } while (status == EL_SUCCESS);
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "msg", msg_array);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_el_retrieve()

static MJsonNode * js_el_retrieve ( const MJsonNode *  params )

static

Definition at line 2981 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("Get an elog message");
      doc->P("tag", MJSON_STRING, "elog message tag");
      doc->R("status", MJSON_INT, "return status of el_retrieve");
      doc->R("msg.tag", MJSON_STRING, "message tag");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string tag = mjsonrpc_get_param(params, "tag", &error)->GetString(); if (error) return error;
 
   int run = 0;
   char date[80], author[80], type[80], system[80], subject[256], text[10000];
   char orig_tag[80], reply_tag[80], attachment[3][256], encoding[80];
 
   char xtag[80];
   mstrlcpy(xtag, tag.c_str(), sizeof(xtag));
 
   int size = sizeof(text);
 
   int status = el_retrieve(xtag,
                            date, &run, author, type, system, subject,
                            text, &size, orig_tag, reply_tag,
                            attachment[0], attachment[1], attachment[2], encoding);
 
   //printf("js_el_retrieve: size %d, status %d, tag [%s]\n", size, status, xtag);
 
   MJsonNode* msg = MJsonNode::MakeObject();
 
   if (status == EL_SUCCESS) {
      ss_repair_utf8(xtag);
      msg->AddToObject("tag", MJsonNode::MakeString(xtag));
      ss_repair_utf8(date);
      msg->AddToObject("date", MJsonNode::MakeString(date));
      msg->AddToObject("run", MJsonNode::MakeInt(run));
      ss_repair_utf8(author);
      msg->AddToObject("author", MJsonNode::MakeString(author));
      ss_repair_utf8(type);
      msg->AddToObject("type", MJsonNode::MakeString(type));
      ss_repair_utf8(system);
      msg->AddToObject("system", MJsonNode::MakeString(system));
      ss_repair_utf8(subject);
      msg->AddToObject("subject", MJsonNode::MakeString(subject));
      ss_repair_utf8(text);
      msg->AddToObject("text", MJsonNode::MakeString(text));
      ss_repair_utf8(orig_tag);
      msg->AddToObject("orig_tag", MJsonNode::MakeString(orig_tag));
      ss_repair_utf8(reply_tag);
      msg->AddToObject("reply_tag", MJsonNode::MakeString(reply_tag));
      ss_repair_utf8(attachment[0]);
      msg->AddToObject("attachment0", MJsonNode::MakeString(attachment[0]));
      ss_repair_utf8(attachment[1]);
      msg->AddToObject("attachment1", MJsonNode::MakeString(attachment[1]));
      ss_repair_utf8(attachment[2]);
      msg->AddToObject("attachment2", MJsonNode::MakeString(attachment[2]));
      ss_repair_utf8(encoding);
      msg->AddToObject("encoding", MJsonNode::MakeString(encoding));
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "msg", msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_ext_list_files()

static MJsonNode * js_ext_list_files ( const MJsonNode *  params )

static

Definition at line 4234 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("js_ext_list_files");
      doc->P("subdir", MJSON_STRING, "List files in experiment_directory/userfiles/subdir");
      doc->P("fileext", MJSON_STRING, "Filename extension");
      doc->R("status", MJSON_INT, "return status of midas library calls");
      doc->R("path", MJSON_STRING, "Search path");
      doc->R("subdirs[]", MJSON_STRING, "list of subdirectories");
      doc->R("files[].filename", MJSON_STRING, "script filename");
      doc->R("files[].description", MJSON_STRING, "script description");
      return doc;
   }
 
   MJsonNode* error = NULL;
   std::string subdir = mjsonrpc_get_param(params, "subdir", &error)->GetString(); if (error) return error;
   std::string fileext  = mjsonrpc_get_param(params, "fileext", &error)->GetString(); if (error) return error;
 
   /*---- Not allowed to contain ../ - safety feature ----*/
   if (subdir.find("..") != std::string::npos) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("The subdir is not permitted"));
   }
 
   /*---- ext must start with *. and some not allowed ext - safety feature */
   if (fileext.find("..") != std::string::npos) {
      /*
       fileext.find("/") != std::string::npos ||
       fileext.find("*.") != 0 ||
       fileext.find("*.html") != std::string::npos || fileext.find("*.HTML") != std::string::npos ||
       fileext.find("*.htm") != std::string::npos || fileext.find("*.HTM") != std::string::npos ||
       fileext.find("*.js") != std::string::npos || fileext.find("*.JS") != std::string::npos ||
       fileext.find("*.pl") != std::string::npos || fileext.find("*.PL") != std::string::npos ||
       fileext.find("*.cgi") != std::string::npos || fileext.find("*.CGI") != std::string::npos ||
       fileext.find("*.*") != std::string::npos
       ) {
      */
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("The filename extension is not permitted"));
   }
   
   int status;
   HNDLE hDB;
 
   status = cm_get_experiment_database(&hDB, NULL);
 
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   std::string path = cm_expand_env(cm_get_path().c_str());
   if (path[path.length()-1] != DIR_SEPARATOR) {
      path += DIR_SEPARATOR_STR;
   }
   path += "userfiles";
   
   // Check if the userfiles folder exists
   if (access(path.c_str(), F_OK) != 0) {
      // Create the path if it doesn't exist
      if (mkdir(path.c_str(), 0777) != 0) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Failed to create the userfiles folder"));
      }
   }
   
   if (subdir.length() > 0) {
      if (subdir[0] != DIR_SEPARATOR) {
         path += DIR_SEPARATOR_STR;
      }
      path += subdir;
   }
 
   char* flist = NULL;
   MJsonNode* s = MJsonNode::MakeArray();
   
   /*---- go over subdirectories ----*/
   int n = ss_dirlink_find(path.c_str(), "*", &flist);
 
   for (int i=0 ; i<n ; i++) {
      if (flist[i*MAX_STRING_LENGTH] != '.') {
         //printf("subdir %d: [%s]\n", i, flist+i*MAX_STRING_LENGTH);
         ss_repair_utf8(flist+i*MAX_STRING_LENGTH);
         s->AddToArray(MJsonNode::MakeString(flist+i*MAX_STRING_LENGTH));
      }
   }
   
   MJsonNode* f = MJsonNode::MakeArray();
   time_t modtime = time(NULL);
   double fsize;
   /*---- go over files with extension fileext in path ----*/
   n = ss_file_find(path.c_str(), fileext.c_str(), &flist);
 
   if (n == -1) {
      // path does not exist, return an error
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Subdirectory does not exist, create it first."));
   }
   
   for (int i=0 ; i<n ; i++) {
      //printf("file %d: [%s]\n", i, flist+i*MAX_STRING_LENGTH);
      MJsonNode* o = MJsonNode::MakeObject();
      ss_repair_utf8(flist+i*MAX_STRING_LENGTH);
      o->AddToObject("filename", MJsonNode::MakeString(flist+i*MAX_STRING_LENGTH));
      /* description is msl specific, do we need it? */
      std::string full_name = path;
      if (full_name.back() != DIR_SEPARATOR)
         full_name += DIR_SEPARATOR;
      full_name.append(flist+i*MAX_STRING_LENGTH);
      // o->AddToObject("description", MJsonNode::MakeString(full_name.c_str()));
      o->AddToObject("description", MJsonNode::MakeString("description"));
      modtime = ss_file_time(full_name.c_str());
      o->AddToObject("modtime", MJsonNode::MakeInt(modtime));
      fsize = ss_file_size(full_name.c_str());
      o->AddToObject("size", MJsonNode::MakeInt(fsize));
      f->AddToArray(o);
   }
 
   free(flist);
   flist = NULL;
 
   MJsonNode* r = MJsonNode::MakeObject();
   r->AddToObject("status", MJsonNode::MakeInt(SUCCESS));
   ss_repair_utf8(path);
   r->AddToObject("path", MJsonNode::MakeString(path.c_str()));
   r->AddToObject("subdirs", s);
   r->AddToObject("files", f);
   
   return mjsonrpc_make_result(r);
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_ext_read_file()

static MJsonNode * js_ext_read_file ( const MJsonNode *  params )

static

Definition at line 4438 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("js_ext_read_script");
      doc->P("filename", MJSON_STRING, "File name, read from experiment_directory/userfiles/filename");
      doc->R("content", MJSON_STRING, "ASCII file content");
      doc->R("status", MJSON_INT, "return status of midas library calls");
      doc->R("error", MJSON_STRING, "error text");
      return doc;
   }
   
   MJsonNode* error = NULL;
   std::string filename = mjsonrpc_get_param(params, "filename", &error)->GetString(); if (error) return error;
   
   /*---- filename should not contain the following - safety feature */
   if (filename.find("..") != std::string::npos ||
       filename.find("*") != std::string::npos) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("The filename is not permitted"));
   }
   
   int status;
   HNDLE hDB;
   
   status = cm_get_experiment_database(&hDB, NULL);
   
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString("cm_get_experiment_database() error"));
   }
 
   std::string path = cm_expand_env(cm_get_path().c_str());
   if (path[path.length()-1] != DIR_SEPARATOR) {
      path += DIR_SEPARATOR_STR;
   }
   path += "userfiles";
 
   // Check if the userfiles folder exists
   if (access(path.c_str(), F_OK) != 0) {
      // Create the path if it doesn't exist
      if (mkdir(path.c_str(), 0777) != 0) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Failed to create the userfiles folder"));
      }
   }
 
   path += DIR_SEPARATOR_STR;
   path += filename;
   
   FILE* fp = fopen(path.c_str(), "r");
   if (!fp) {
      status = SS_FILE_ERROR;
      char errstr[256];
      sprintf(errstr, "fopen() errno %d (%s)", errno, strerror(errno));
      ss_repair_utf8(errstr);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString(errstr));
   }
   
   fseek(fp, 0, SEEK_END);
   size_t file_size = ftell(fp);
   rewind(fp);
   
   char* buffer = new char[file_size+1];
   fread(buffer, file_size, 1, fp);
   // Maybe not needed here
   buffer[file_size] = '\0';
   fclose(fp);
   
   std::string content = buffer;
   delete[] buffer;
   buffer = NULL;
   
   status = CM_SUCCESS;
   std::string errstr = "no error";
   
   return mjsonrpc_make_result("content", MJsonNode::MakeString(content.c_str()), "status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString(errstr.c_str()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_ext_save_file()

static MJsonNode * js_ext_save_file ( const MJsonNode *  params )

static

Definition at line 4362 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("js_ext_save_file");
      doc->P("filename", MJSON_STRING, "File name, save in experiment_directory/userfiles/filename");
      doc->P("script", MJSON_STRING, "ASCII content");
      doc->R("status", MJSON_INT, "return status of midas library calls");
      doc->R("error", MJSON_STRING, "error text");
      return doc;
   }
 
   /* Need to make sure that content cannot be abused (e.g. not Javascript code), how?? */
   
   MJsonNode* error = NULL;
   std::string filename = mjsonrpc_get_param(params, "filename", &error)->GetString(); if (error) return error;
   std::string script = mjsonrpc_get_param(params, "script", &error)->GetString(); if (error) return error;
 
   /*---- filename should not contain the following - safety feature */
   if (filename.find("..") != std::string::npos ) {
      /*
       filename.find("*") != std::string::npos ||
       filename.find(".html") != std::string::npos || filename.find(".HTML") != std::string::npos ||
       filename.find(".htm") != std::string::npos || filename.find(".HTM") != std::string::npos ||
       filename.find(".js") != std::string::npos || filename.find(".JS") != std::string::npos ||
       filename.find(".pl") != std::string::npos || filename.find(".PL") != std::string::npos ||
       filename.find(".cgi") != std::string::npos || filename.find(".CGI") != std::string::npos
       ) {
      */
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("The filename is not permitted"));
   }
 
   int status;
   HNDLE hDB;
 
   status = cm_get_experiment_database(&hDB, NULL);
 
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString("cm_get_experiment_database() error"));
   }
 
   std::string path = cm_expand_env(cm_get_path().c_str());
   path += "userfiles";
 
   // Check if the userfiles folder exists
   if (access(path.c_str(), F_OK) != 0) {
      // Create the path if it doesn't exist
      if (mkdir(path.c_str(), 0777) != 0) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Failed to create the userfiles folder"));
      }
   }
   
   path += DIR_SEPARATOR_STR;
   path += filename;
 
   FILE* fp = fopen(path.c_str(), "w");
   if (!fp) {
      status = SS_FILE_ERROR;
      char errstr[256];
      sprintf(errstr, "fopen() errno %d (%s)", errno, strerror(errno));
      ss_repair_utf8(errstr);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString(errstr));
   }
 
   fwrite(script.c_str(), script.length(), 1, fp);
   //fprintf(fp, "\n");
   fclose(fp);
   fp = NULL;
 
   status = CM_SUCCESS;
   std::string errstr = "no error";
 
   //ss_repair_utf8(errstr); redundant!
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString(errstr.c_str()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_get_timezone()

static MJsonNode * js_get_timezone ( const MJsonNode *  params )

static

Definition at line 4694 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("get current server timezone offset in seconds");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_INT, "offset in seconds");
      return doc;
   }
 
   ss_tzset(); // required for localtime_r()
   time_t rawtime = time(NULL);
   struct tm gmt_tms;
   gmtime_r(&rawtime, &gmt_tms);
   time_t gmt = ss_mktime(&gmt_tms);
   struct tm tms;
   localtime_r(&rawtime, &tms);
   time_t offset = rawtime - gmt + (tms.tm_isdst ? 3600 : 0);
 
   return mjsonrpc_make_result(MJsonNode::MakeNumber(offset));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_exit()

static void js_hs_exit ( )

static

Definition at line 1736 of file mjsonrpc.cxx.

{
   for (auto& e : gHistoryChannels) {
      //printf("history channel \"%s\" mh %p\n", e.first.c_str(), e.second);
      delete e.second;
   }
   gHistoryChannels.clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_get_active_events()

static MJsonNode * js_hs_get_active_events ( const MJsonNode *  params )

static

Definition at line 1658 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get list of active history events using hs_read_event_list()");
      doc->R("status", MJSON_INT, "return status of hs_read_event_list()");
      doc->R("events[]", MJSON_STRING, "array of history event names");
      return doc;
   }
 
   STRING_LIST list;
   
   int status = hs_read_event_list(&list);
 
   MJsonNode* events = MJsonNode::MakeArray();
 
   for (unsigned i=0; i<list.size(); i++) {
      ss_repair_utf8(list[i]);
      events->AddToArray(MJsonNode::MakeString(list[i].c_str()));
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "events", events);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_get_channels()

static MJsonNode * js_hs_get_channels ( const MJsonNode *  params )

static

Definition at line 1745 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get list of history channels in /Logger/History");
      doc->R("status", MJSON_INT, "return success or failure status");
      doc->R("default_channel", MJSON_STRING, "name of the default logger history channel");
      doc->R("channels[]", MJSON_STRING, "all logger history channel names");
      doc->R("active_channels[]", MJSON_STRING, "active logger history channel names");
      return doc;
   }
 
   MJsonNode* channels = MJsonNode::MakeArray();
   MJsonNode* active_channels = MJsonNode::MakeArray();
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
   
   // get history channel name selected by user in ODB
 
   //std::string selected_channel;
   //db_get_value_string(hDB, 0, "/History/LoggerHistoryChannel", 0, &selected_channel, TRUE);
   
   int status;
   HNDLE hKeyChan;
 
   status = db_find_key(hDB, 0, "/Logger/History", &hKeyChan);
   if (status == DB_SUCCESS) {
      for (int ichan=0; ; ichan++) {
         HNDLE hKey;
         status = db_enum_key(hDB, hKeyChan, ichan, &hKey);
         if (status == DB_NO_MORE_SUBKEYS) {
            status = DB_SUCCESS;
            break;
         }
         if (status != DB_SUCCESS)
            break;
 
         KEY key;
 
         status = db_get_key(hDB, hKey, &key);
 
         if (status == DB_SUCCESS) {
            ss_repair_utf8(key.name);
            channels->AddToArray(MJsonNode::MakeString(key.name));
 
            INT active = 0;
            INT size = sizeof(active);
            status = db_get_value(hDB, hKey, "Active", &active, &size, TID_BOOL, FALSE);
            if (status == DB_SUCCESS) {
               if (active) {
                  active_channels->AddToArray(MJsonNode::MakeString(key.name));
               }
            }
         }
      }
   }
 
   std::string default_channel;
 
   HNDLE hKey;
   status = hs_find_reader_channel(hDB, &hKey, 0);
   if (status == DB_SUCCESS) {
      KEY key;
      status = db_get_key(hDB, hKey, &key);
      if (status == DB_SUCCESS) {
         default_channel = key.name;
      }
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(1),
                               //"selected_channel", MJsonNode::MakeString(selected_channel.c_str()),
                               "default_channel", MJsonNode::MakeString(default_channel.c_str()),
                               "active_channels", active_channels,
                               "channels", channels);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_get_events()

static MJsonNode * js_hs_get_events ( const MJsonNode *  params )

static

Definition at line 1822 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get list of history events that existed at give time using hs_get_events()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("time?", MJSON_NUMBER, "timestamp, value 0 means current time, default is 0");
      doc->R("status", MJSON_INT, "return status of hs_get_events()");
      doc->R("channel", MJSON_STRING, "logger history channel name");
      doc->R("events[]", MJSON_STRING, "array of history event names");
      return doc;
   }
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double time = mjsonrpc_get_param(params, "time", NULL)->GetDouble();
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   MJsonNode* events = MJsonNode::MakeArray();
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "events", events);
   }
 
   if (time == 0) {
      time = ::time(NULL);
   }
 
   STRING_LIST list;
   
   int status = mh->hs_get_events(time, &list);
 
   for (unsigned i=0; i<list.size(); i++) {
      ss_repair_utf8(list[i]);
      events->AddToArray(MJsonNode::MakeString(list[i].c_str()));
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "channel", MJsonNode::MakeString(mh->name), "events", events);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_get_last_written()

static MJsonNode * js_hs_get_last_written ( const MJsonNode *  params )

static

Definition at line 1966 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get list of history tags for given history events that existed at give time using hs_get_last_written()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("time?", MJSON_NUMBER, "timestamp, value 0 means current time, default is 0");
      doc->P("events[]", MJSON_STRING, "array of history event names");
      doc->P("tags[]", MJSON_STRING, "array of history event tag names");
      doc->P("index[]", MJSON_STRING, "array of history event tag array indices");
      doc->R("status", MJSON_INT, "return status");
      doc->R("channel", MJSON_STRING, "logger history channel name");
      doc->R("last_written[]", MJSON_NUMBER, "array of last-written times for each history event");
      return doc;
   }
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double time = mjsonrpc_get_param(params, "time", NULL)->GetDouble();
 
   const MJsonNodeVector* events_array = mjsonrpc_get_param_array(params, "events", NULL);
   const MJsonNodeVector* tags_array = mjsonrpc_get_param_array(params, "tags", NULL);
   const MJsonNodeVector* index_array = mjsonrpc_get_param_array(params, "index", NULL);
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   MJsonNode* lw = MJsonNode::MakeArray();
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "last_written", lw);
   }
 
   unsigned num_var = events_array->size();
 
   if (tags_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and tags should have the same length");
   }
 
   if (index_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and index should have the same length");
   }
 
   std::vector<std::string> event_names(num_var);
   std::vector<std::string> tag_names(num_var);
   // const char** event_name = new const char*[num_var];
   // const char** tag_name = new const char*[num_var];
   int* var_index = new int[num_var];
   time_t* last_written = new time_t[num_var];
 
   for (unsigned i=0; i<num_var; i++) {
      //event_name[i] = (*events_array)[i]->GetString().c_str();
      //tag_name[i] = (*tags_array)[i]->GetString().c_str();
      event_names[i] = (*events_array)[i]->GetString();
      tag_names[i] = (*tags_array)[i]->GetString();
      var_index[i] = (*index_array)[i]->GetInt();
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("time %f, num_vars %d:\n", time, num_var);
      for (unsigned i=0; i<num_var; i++) {
         printf("%d: [%s] [%s] [%d]\n", i, event_names[i].c_str(), tag_names[i].c_str(), var_index[i]);
      }
   }
 
   if (time == 0) {
      time = ::time(NULL);
   }
 
   
   const char** event_name = new const char*[num_var];
   const char** tag_name = new const char*[num_var];
   for (unsigned i=0; i<num_var; i++) {
      event_name[i] = event_names[i].c_str();
      tag_name[i] = tag_names[i].c_str();
   }
   int status = mh->hs_get_last_written(time, num_var, event_name, tag_name, var_index, last_written);
 
   for (unsigned i=0; i<num_var; i++) {
      if (/* DISABLES CODE */ (0)) {
         printf("%d: last_written %d\n", i, (int)last_written[i]);
      }
      lw->AddToArray(MJsonNode::MakeNumber(last_written[i]));
   }
 
   delete[] event_name;
   delete[] tag_name;
   delete[] var_index;
   delete[] last_written;
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "channel", MJsonNode::MakeString(mh->name), "last_written", lw);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_get_tags()

static MJsonNode * js_hs_get_tags ( const MJsonNode *  params )

static

Definition at line 1888 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get list of history tags for given history events that existed at give time using hs_get_tags()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("time?", MJSON_NUMBER, "timestamp, value 0 means current time, default is 0");
      doc->P("events[]?", MJSON_STRING, "array of history event names, default is get all events using hs_get_events()");
      doc->R("status", MJSON_INT, "return status");
      doc->R("channel", MJSON_STRING, "logger history channel name");
      doc->R("events[].name", MJSON_STRING, "array of history event names for each history event");
      doc->R("events[].status", MJSON_INT, "array of status ohistory tags for each history event");
      doc->R("events[].tags[]", MJSON_STRING, "array of history tags for each history event");
      doc->R("events[].tags[].name", MJSON_STRING, "history tag name");
      doc->R("events[].tags[].type", MJSON_INT, "history tag midas data type");
      doc->R("events[].tags[].n_data?", MJSON_INT, "history tag number of array elements, omitted if 1");
      return doc;
   }
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double time = mjsonrpc_get_param(params, "time", NULL)->GetDouble();
   const MJsonNodeVector* events_array = mjsonrpc_get_param_array(params, "events", NULL);
 
   if (time == 0) {
      time = ::time(NULL);
   }
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   MJsonNode* events = MJsonNode::MakeArray();
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "events", events);
   }
 
   std::vector<std::string> event_names;
 
   if (events_array && events_array->size() > 0) {
      for (unsigned i=0; i<events_array->size(); i++) {
         event_names.push_back((*events_array)[i]->GetString());
      }
   }
 
   if (event_names.size() < 1) {
      int status = mh->hs_get_events(time, &event_names);
      if (status != HS_SUCCESS) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "events", events);
      }
   }
 
   for (unsigned i=0; i<event_names.size(); i++) {
      MJsonNode* o = MJsonNode::MakeObject();
      const char* event_name = event_names[i].c_str();
      std::vector<TAG> tags;
      int status = mh->hs_get_tags(event_name, time, &tags);
      //ss_repair_utf8(event_name); redundant!
      o->AddToObject("name", MJsonNode::MakeString(event_name));
      o->AddToObject("status", MJsonNode::MakeInt(status));
      MJsonNode *ta = MJsonNode::MakeArray();
      for (unsigned j=0; j<tags.size(); j++) {
         MJsonNode* to = MJsonNode::MakeObject();
         ss_repair_utf8(tags[j].name);
         to->AddToObject("name", MJsonNode::MakeString(tags[j].name));
         to->AddToObject("type", MJsonNode::MakeInt(tags[j].type));
         if (tags[j].n_data != 1) {
            to->AddToObject("n_data", MJsonNode::MakeInt(tags[j].n_data));
         }
         ta->AddToArray(to);
      }
      o->AddToObject("tags", ta);
      events->AddToArray(o);
   }
 
   int status = HS_SUCCESS;
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "channel", MJsonNode::MakeString(mh->name), "events", events);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_image_retrieve()

static MJsonNode * js_hs_image_retrieve ( const MJsonNode *  params )

static

Definition at line 2936 of file mjsonrpc.cxx.

                                                                {
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("Get a list of history image files");
      doc->P("image?", MJSON_STRING, "image name as defined under /History/Images/<image>");
      doc->P("start_time", MJSON_NUMBER, "start time of the data");
      doc->P("end_time", MJSON_NUMBER, "end time of the data");
      doc->R("time[]", MJSON_ARRAYBUFFER, "array of time stamps in seconds");
      doc->R("filename[]", MJSON_ARRAYBUFFER, "array of file names");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string image = mjsonrpc_get_param(params, "image", NULL)->GetString();
   double start_time = mjsonrpc_get_param(params, "start_time", &error)->GetDouble(); if (error) return error;
   double end_time = mjsonrpc_get_param(params, "end_time", &error)->GetDouble(); if (error) return error;
 
   std::vector<time_t>vtime{};
   std::vector<std::string>vfilename{};
 
   int status = hs_image_retrieve(image, start_time, end_time, vtime, vfilename);
   int count = 10;
   MJsonNode *tj = MJsonNode::MakeArray();
   MJsonNode *fj = MJsonNode::MakeArray();
 
   for (int i=0 ; i<(int)vtime.size() ; i++) {
      tj->AddToArray(MJsonNode::MakeInt(vtime[i]));
      ss_repair_utf8(vfilename[i]);
      fj->AddToArray(MJsonNode::MakeString(vfilename[i].c_str()));
   }
   MJsonNode* data = MJsonNode::MakeObject();
   data->AddToObject("count", MJsonNode::MakeInt(count));
   data->AddToObject("time", tj);
   data->AddToObject("filename", fj);
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "data", data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_read()

static MJsonNode * js_hs_read ( const MJsonNode *  params )

static

Definition at line 2095 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get history data for given history events that existed at give time using hs_read_buffer()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("start_time", MJSON_NUMBER, "start time of the data");
      doc->P("end_time", MJSON_NUMBER, "end time of the data");
      doc->P("events[]", MJSON_STRING, "array of history event names");
      doc->P("tags[]", MJSON_STRING, "array of history event tag names");
      doc->P("index[]", MJSON_STRING, "array of history event tag array indices");
      doc->R("status", MJSON_INT, "return status");
      doc->R("channel", MJSON_STRING, "logger history channel name");
      doc->R("data[]", MJSON_ARRAY, "array of history data");
      doc->R("data[].status", MJSON_INT, "status for each event");
      doc->R("data[].count", MJSON_INT, "number of data for each event");
      doc->R("data[].time[]", MJSON_NUMBER, "time data");
      doc->R("data[].value[]", MJSON_NUMBER, "value data");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double start_time = mjsonrpc_get_param(params, "start_time", &error)->GetDouble(); if (error) return error;
   double end_time = mjsonrpc_get_param(params, "end_time", &error)->GetDouble(); if (error) return error;
 
   const MJsonNodeVector* events_array = mjsonrpc_get_param_array(params, "events", NULL);
   const MJsonNodeVector* tags_array = mjsonrpc_get_param_array(params, "tags", NULL);
   const MJsonNodeVector* index_array = mjsonrpc_get_param_array(params, "index", NULL);
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   MJsonNode* data = MJsonNode::MakeArray();
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "data", data);
   }
 
   unsigned num_var = events_array->size();
 
   if (tags_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and tags should have the same length");
   }
 
   if (index_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and index should have the same length");
   }
 
   std::vector<std::string> event_names(num_var);
   std::vector<std::string> tag_names(num_var);
   int* var_index = new int[num_var];
   JsonHistoryBuffer** jbuf = new JsonHistoryBuffer*[num_var];
   MidasHistoryBufferInterface** buf = new MidasHistoryBufferInterface*[num_var];
   int* hs_status = new int[num_var];
 
   for (unsigned i=0; i<num_var; i++) {
      //event_name[i] = (*events_array)[i]->GetString().c_str();
      //tag_name[i] = (*tags_array)[i]->GetString().c_str();
      event_names[i] = (*events_array)[i]->GetString();
      tag_names[i] = (*tags_array)[i]->GetString();
      var_index[i] = (*index_array)[i]->GetInt();
      jbuf[i] = new JsonHistoryBuffer();
      buf[i] = jbuf[i];
      hs_status[i] = 0;
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("time %f %f, num_vars %d:\n", start_time, end_time, num_var);
      for (unsigned i=0; i<num_var; i++) {
         printf("%d: [%s] [%s] [%d]\n", i, event_names[i].c_str(), tag_names[i].c_str(), var_index[i]);
      }
   }
 
   const char** event_name = new const char*[num_var];
   const char** tag_name = new const char*[num_var];
   for (unsigned i=0; i<num_var; i++) {
      event_name[i] = event_names[i].c_str();
      tag_name[i] = tag_names[i].c_str();
   }
 
   int status = mh->hs_read_buffer(start_time, end_time, num_var, event_name, tag_name, var_index, buf, hs_status);
 
   for (unsigned i=0; i<num_var; i++) {
      jbuf[i]->Finish();
 
      MJsonNode* obj = MJsonNode::MakeObject();
      obj->AddToObject("status", MJsonNode::MakeInt(hs_status[i]));
      obj->AddToObject("count", MJsonNode::MakeInt(jbuf[i]->fCount));
      obj->AddToObject("time", MJsonNode::MakeJSON(jbuf[i]->fTimeJson.c_str()));
      obj->AddToObject("value", MJsonNode::MakeJSON(jbuf[i]->fValueJson.c_str()));
      data->AddToArray(obj);
 
      delete jbuf[i];
      jbuf[i] = NULL;
      buf[i] = NULL;
   }
 
   delete[] event_name;
   delete[] tag_name;
   delete[] var_index;
   delete[] buf;
   delete[] jbuf;
   delete[] hs_status;
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "channel", MJsonNode::MakeString(mh->name), "data", data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_read_arraybuffer()

static MJsonNode * js_hs_read_arraybuffer ( const MJsonNode *  params )

static

Definition at line 2438 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get history data for given history events that existed at give time using hs_read_buffer()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("start_time", MJSON_NUMBER, "start time of the data");
      doc->P("end_time", MJSON_NUMBER, "end time of the data");
      doc->P("events[]", MJSON_STRING, "array of history event names");
      doc->P("tags[]", MJSON_STRING, "array of history event tag names");
      doc->P("index[]", MJSON_STRING, "array of history event tag array indices");
      doc->R("binary data", MJSON_ARRAYBUFFER, "binary data, see documentation");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double start_time = mjsonrpc_get_param(params, "start_time", &error)->GetDouble(); if (error) return error;
   double end_time = mjsonrpc_get_param(params, "end_time", &error)->GetDouble(); if (error) return error;
 
   const MJsonNodeVector* events_array = mjsonrpc_get_param_array(params, "events", NULL);
   const MJsonNodeVector* tags_array = mjsonrpc_get_param_array(params, "tags", NULL);
   const MJsonNodeVector* index_array = mjsonrpc_get_param_array(params, "index", NULL);
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   size_t num_var = events_array->size();
 
   if (tags_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and tags should have the same length");
   }
 
   if (index_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and index should have the same length");
   }
 
   std::vector<std::string> event_names(num_var);
   std::vector<std::string> tag_names(num_var);
   int* var_index = new int[num_var];
   BinaryHistoryBuffer** jbuf = new BinaryHistoryBuffer*[num_var];
   MidasHistoryBufferInterface** buf = new MidasHistoryBufferInterface*[num_var];
   int* hs_status = new int[num_var];
 
   for (size_t i=0; i<num_var; i++) {
      //event_name[i] = (*events_array)[i]->GetString().c_str();
      //tag_name[i] = (*tags_array)[i]->GetString().c_str();
      event_names[i] = (*events_array)[i]->GetString();
      tag_names[i] = (*tags_array)[i]->GetString();
      var_index[i] = (*index_array)[i]->GetInt();
      jbuf[i] = new BinaryHistoryBuffer();
      buf[i] = jbuf[i];
      hs_status[i] = 0;
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("time %f %f, num_vars %d:\n", start_time, end_time, int(num_var));
      for (size_t i=0; i<num_var; i++) {
         printf("%d: [%s] [%s] [%d]\n", int(i), event_names[i].c_str(), tag_names[i].c_str(), var_index[i]);
      }
   }
 
   const char** event_name = new const char*[num_var];
   const char** tag_name = new const char*[num_var];
   for (unsigned i=0; i<num_var; i++) {
      event_name[i] = event_names[i].c_str();
      tag_name[i] = tag_names[i].c_str();
   }
 
   int status = mh->hs_read_buffer(start_time, end_time, num_var, event_name, tag_name, var_index, buf, hs_status);
 
   size_t num_values = 0;
 
   for (unsigned i=0; i<num_var; i++) {
      jbuf[i]->Finish();
      num_values += jbuf[i]->fValues.size();
   }
 
   // NB: beware of 32-bit integer overflow. all values are now 64-bit size_t, overflow should not happen.
   size_t p0_size = sizeof(double)*(2+2*num_var+2*num_values);
 
   size_t size_limit = 1000*1024*1024;
 
   if (p0_size > size_limit) {
      cm_msg(MERROR, "js_hs_read_binned_arraybuffer", "Refusing to return %zu bytes of history data, limit is %zu bytes\n", p0_size, size_limit);
 
      for (size_t i=0; i<num_var; i++) {
         delete jbuf[i];
         jbuf[i] = NULL;
         buf[i] = NULL;
      }
      
      delete[] event_name;
      delete[] tag_name;
      delete[] var_index;
      delete[] buf;
      delete[] jbuf;
      delete[] hs_status;
      
      return mjsonrpc_make_error(-32603, "Internal error", "Too much history data");
   }
 
   double* p0 = (double*)malloc(p0_size);
 
   if (p0 == NULL) {
      cm_msg(MERROR, "js_hs_read_binned_arraybuffer", "Cannot allocate return buffer %d bytes\n", int(p0_size));
      
      for (size_t i=0; i<num_var; i++) {
         delete jbuf[i];
         jbuf[i] = NULL;
         buf[i] = NULL;
      }
      
      delete[] event_name;
      delete[] tag_name;
      delete[] var_index;
      delete[] buf;
      delete[] jbuf;
      delete[] hs_status;
      
      return mjsonrpc_make_error(-32603, "Internal error", "Cannot allocate buffer, too much data");
   }
 
   double *pptr = p0;
   
   //
   // Binary data format:
   //
   // - hs_read() status
   // - num_var
   // - hs_status[0..num_var-1]
   // - num_values[0..num_var-1]
   // - data for var0:
   // - t[0][0], v[0][0] ... t[0][num_values[0]-1], v[0][num_values[0]-1]
   // - data for var1:
   // - t[1][0], v[1][0] ... t[1][num_values[1]-1], v[1][num_values[1]-1]
   // ...
   // - data for last variable:
   // - t[num_var-1][0], v[num_var-1][0] ... t[num_var-1][num_values[num_var-1]-1], v[num_var-1][num_values[num_var-1]-1]
   //
 
   *pptr++ = status;
   *pptr++ = num_var;
 
   for (size_t i=0; i<num_var; i++) {
      *pptr++ = hs_status[i];
   }
 
   for (size_t i=0; i<num_var; i++) {
      *pptr++ = jbuf[i]->fValues.size();
   }
 
   for (size_t i=0; i<num_var; i++) {
      size_t nv = jbuf[i]->fValues.size();
      for (size_t j=0; j<nv; j++) {
         *pptr++ = jbuf[i]->fTimes[j];
         *pptr++ = jbuf[i]->fValues[j];
      }
 
      delete jbuf[i];
      jbuf[i] = NULL;
      buf[i] = NULL;
   }
 
   //printf("p0_size %d, %d/%d\n", (int)p0_size, (int)(pptr-p0), (int)((pptr-p0)*sizeof(double)));
 
   assert(p0_size == ((pptr-p0)*sizeof(double)));
 
   delete[] event_name;
   delete[] tag_name;
   delete[] var_index;
   delete[] buf;
   delete[] jbuf;
   delete[] hs_status;
 
   MJsonNode* result = MJsonNode::MakeArrayBuffer((char*)p0, p0_size);
 
   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_read_binned()

static MJsonNode * js_hs_read_binned ( const MJsonNode *  params )

static

Definition at line 2204 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get history data for given history events that existed at give time using hs_read_buffer()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("start_time", MJSON_NUMBER, "start time of the data");
      doc->P("end_time", MJSON_NUMBER, "end time of the data");
      doc->P("num_bins", MJSON_INT, "number of time bins");
      doc->P("events[]", MJSON_STRING, "array of history event names");
      doc->P("tags[]", MJSON_STRING, "array of history event tag names");
      doc->P("index[]", MJSON_STRING, "array of history event tag array indices");
      doc->R("status", MJSON_INT, "return status");
      doc->R("channel", MJSON_STRING, "logger history channel name");
      doc->R("data[]", MJSON_ARRAY, "array of history data");
      doc->R("data[].status", MJSON_INT, "status for each event");
      doc->R("data[].num_entries", MJSON_INT, "number of data points for each event");
      doc->R("data[].count[]", MJSON_INT, "number of data points for each bin");
      doc->R("data[].mean[]", MJSON_NUMBER, "mean for each bin");
      doc->R("data[].rms[]", MJSON_NUMBER, "rms for each bin");
      doc->R("data[].min[]", MJSON_NUMBER, "minimum value for each bin");
      doc->R("data[].max[]", MJSON_NUMBER, "maximum value for each bin");
      doc->R("data[].bins_first_time[]", MJSON_NUMBER, "first data point in each bin");
      doc->R("data[].bins_first_value[]", MJSON_NUMBER, "first data point in each bin");
      doc->R("data[].bins_last_time[]", MJSON_NUMBER, "last data point in each bin");
      doc->R("data[].bins_last_value[]", MJSON_NUMBER, "last data point in each bin");
      doc->R("data[].last_time", MJSON_NUMBER, "time of last data entry");
      doc->R("data[].last_value", MJSON_NUMBER, "value of last data entry");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double start_time = mjsonrpc_get_param(params, "start_time", &error)->GetDouble(); if (error) return error;
   double end_time = mjsonrpc_get_param(params, "end_time", &error)->GetDouble(); if (error) return error;
   int num_bins = mjsonrpc_get_param(params, "num_bins", &error)->GetInt(); if (error) return error;
 
   if (num_bins < 1) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Value of num_bins should be 1 or more");
   }
 
   const MJsonNodeVector* events_array = mjsonrpc_get_param_array(params, "events", NULL);
   const MJsonNodeVector* tags_array = mjsonrpc_get_param_array(params, "tags", NULL);
   const MJsonNodeVector* index_array = mjsonrpc_get_param_array(params, "index", NULL);
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   MJsonNode* data = MJsonNode::MakeArray();
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "data", data);
   }
 
   unsigned num_var = events_array->size();
 
   if (num_var < 1) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Array of events should have 1 or more elements");
   }
 
   if (tags_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and tags should have the same length");
   }
 
   if (index_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and index should have the same length");
   }
   
   std::vector<std::string> event_names(num_var);
   std::vector<std::string> tag_names(num_var);
   //const char** event_name = new const char*[num_var];
   //const char** tag_name = new const char*[num_var];
   int* var_index = new int[num_var];
 
   int* num_entries = new int[num_var];
   time_t* last_time = new time_t[num_var];
   double* last_value = new double[num_var];
   int* hs_status = new int[num_var];
 
   int** count_bins = new int*[num_var];
   double** mean_bins = new double*[num_var];
   double** rms_bins = new double*[num_var];
   double** min_bins = new double*[num_var];
   double** max_bins = new double*[num_var];
 
   time_t** bins_first_time = new time_t*[num_var];
   time_t** bins_last_time  = new time_t*[num_var];
 
   double** bins_first_value = new double*[num_var];
   double** bins_last_value  = new double*[num_var];
 
   for (unsigned i=0; i<num_var; i++) {
      //event_name[i] = (*events_array)[i]->GetString().c_str();
      //tag_name[i] = (*tags_array)[i]->GetString().c_str();
      event_names[i] = (*events_array)[i]->GetString();
      tag_names[i] = (*tags_array)[i]->GetString();
      var_index[i] = (*index_array)[i]->GetInt();
      num_entries[i] = 0;
      last_time[i] = 0;
      last_value[i] = 0;
      hs_status[i] = 0;
      count_bins[i] = new int[num_bins];
      mean_bins[i] = new double[num_bins];
      rms_bins[i] = new double[num_bins];
      min_bins[i] = new double[num_bins];
      max_bins[i] = new double[num_bins];
 
      bins_first_time[i] = new time_t[num_bins];
      bins_last_time[i] = new time_t[num_bins];
 
      bins_first_value[i] = new double[num_bins];
      bins_last_value[i] = new double[num_bins];
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("time %f %f, num_vars %d:\n", start_time, end_time, num_var);
      for (unsigned i=0; i<num_var; i++) {
         printf("%d: [%s] [%s] [%d]\n", i, event_names[i].c_str(), tag_names[i].c_str(), var_index[i]);
      }
   }
 
   const char** event_name = new const char*[num_var];
   const char** tag_name = new const char*[num_var];
   for (unsigned i=0; i<num_var; i++) {
      event_name[i] = event_names[i].c_str();
      tag_name[i] = tag_names[i].c_str();
   }
 
   int status = mh->hs_read_binned(start_time, end_time, num_bins, num_var, event_name, tag_name, var_index, num_entries, count_bins, mean_bins, rms_bins, min_bins, max_bins, bins_first_time, bins_first_value, bins_last_time, bins_last_value, last_time, last_value, hs_status);
 
   for (unsigned i=0; i<num_var; i++) {
      MJsonNode* obj = MJsonNode::MakeObject();
      obj->AddToObject("status", MJsonNode::MakeInt(hs_status[i]));
      obj->AddToObject("num_entries", MJsonNode::MakeInt(num_entries[i]));
      
      MJsonNode* a1 = MJsonNode::MakeArray();
      MJsonNode* a2 = MJsonNode::MakeArray();
      MJsonNode* a3 = MJsonNode::MakeArray();
      MJsonNode* a4 = MJsonNode::MakeArray();
      MJsonNode* a5 = MJsonNode::MakeArray();
 
      MJsonNode* b1 = MJsonNode::MakeArray();
      MJsonNode* b2 = MJsonNode::MakeArray();
      MJsonNode* b3 = MJsonNode::MakeArray();
      MJsonNode* b4 = MJsonNode::MakeArray();
 
      for (int j=0; j<num_bins; j++) {
         a1->AddToArray(MJsonNode::MakeInt(count_bins[i][j]));
         a2->AddToArray(MJsonNode::MakeNumber(mean_bins[i][j]));
         a3->AddToArray(MJsonNode::MakeNumber(rms_bins[i][j]));
         a4->AddToArray(MJsonNode::MakeNumber(min_bins[i][j]));
         a5->AddToArray(MJsonNode::MakeNumber(max_bins[i][j]));
 
         b1->AddToArray(MJsonNode::MakeNumber(bins_first_time[i][j]));
         b2->AddToArray(MJsonNode::MakeNumber(bins_first_value[i][j]));
         b3->AddToArray(MJsonNode::MakeNumber(bins_last_time[i][j]));
         b4->AddToArray(MJsonNode::MakeNumber(bins_last_value[i][j]));
      }
 
      obj->AddToObject("count", a1);
      obj->AddToObject("mean", a2);
      obj->AddToObject("rms", a3);
      obj->AddToObject("min", a4);
      obj->AddToObject("max", a5);
      obj->AddToObject("bins_first_time", b1);
      obj->AddToObject("bins_first_value", b2);
      obj->AddToObject("bins_last_time", b3);
      obj->AddToObject("bins_last_value", b4);
      obj->AddToObject("last_time", MJsonNode::MakeNumber(last_time[i]));
      obj->AddToObject("last_value", MJsonNode::MakeNumber(last_value[i]));
      data->AddToArray(obj);
 
      delete count_bins[i];
      delete mean_bins[i];
      delete rms_bins[i];
      delete min_bins[i];
      delete max_bins[i];
 
      delete bins_first_time[i];
      delete bins_first_value[i];
      delete bins_last_time[i];
      delete bins_last_value[i];
   }
 
   delete[] count_bins;
   delete[] mean_bins;
   delete[] rms_bins;
   delete[] min_bins;
   delete[] max_bins;
 
   delete[] bins_first_time;
   delete[] bins_first_value;
   delete[] bins_last_time;
   delete[] bins_last_value;
 
   delete[] event_name;
   delete[] tag_name;
   delete[] var_index;
 
   delete[] num_entries;
   delete[] last_time;
   delete[] last_value;
   delete[] hs_status;
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "channel", MJsonNode::MakeString(mh->name), "data", data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_read_binned_arraybuffer()

static MJsonNode * js_hs_read_binned_arraybuffer ( const MJsonNode *  params )

static

Definition at line 2623 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("get history data for given history events that existed at give time using hs_read_buffer()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->P("start_time", MJSON_NUMBER, "start time of the data");
      doc->P("end_time", MJSON_NUMBER, "end time of the data");
      doc->P("num_bins", MJSON_INT, "number of time bins");
      doc->P("events[]", MJSON_STRING, "array of history event names");
      doc->P("tags[]", MJSON_STRING, "array of history event tag names");
      doc->P("index[]", MJSON_STRING, "array of history event tag array indices");
      doc->R("binary data", MJSON_ARRAYBUFFER, "binary data, see documentation");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
   double start_time = mjsonrpc_get_param(params, "start_time", &error)->GetDouble(); if (error) return error;
   double end_time = mjsonrpc_get_param(params, "end_time", &error)->GetDouble(); if (error) return error;
   int inum_bins = mjsonrpc_get_param(params, "num_bins", &error)->GetInt(); if (error) return error;
 
   if (inum_bins < 1) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Value of num_bins should be 1 or more");
   }
 
   size_t num_bins = inum_bins;
 
   const MJsonNodeVector* events_array = mjsonrpc_get_param_array(params, "events", NULL);
   const MJsonNodeVector* tags_array = mjsonrpc_get_param_array(params, "tags", NULL);
   const MJsonNodeVector* index_array = mjsonrpc_get_param_array(params, "index", NULL);
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   size_t num_var = events_array->size();
 
   if (num_var < 1) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Array of events should have 1 or more elements");
   }
 
   if (tags_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and tags should have the same length");
   }
 
   if (index_array->size() != num_var) {
      return mjsonrpc_make_error(-32602, "Invalid params", "Arrays events and index should have the same length");
   }
   
   std::vector<std::string> event_names(num_var);
   std::vector<std::string> tag_names(num_var);
   //const char** event_name = new const char*[num_var];
   //const char** tag_name = new const char*[num_var];
   int* var_index = new int[num_var];
 
   int* num_entries = new int[num_var];
   time_t* last_time = new time_t[num_var];
   double* last_value = new double[num_var];
   int* hs_status = new int[num_var];
 
   int** count_bins = new int*[num_var];
   double** mean_bins = new double*[num_var];
   double** rms_bins = new double*[num_var];
   double** min_bins = new double*[num_var];
   double** max_bins = new double*[num_var];
 
   time_t** bins_first_time = new time_t*[num_var];
   time_t** bins_last_time  = new time_t*[num_var];
 
   double** bins_first_value = new double*[num_var];
   double** bins_last_value  = new double*[num_var];
 
   for (unsigned i=0; i<num_var; i++) {
      //event_name[i] = (*events_array)[i]->GetString().c_str();
      //tag_name[i] = (*tags_array)[i]->GetString().c_str();
      event_names[i] = (*events_array)[i]->GetString();
      tag_names[i] = (*tags_array)[i]->GetString();
      var_index[i] = (*index_array)[i]->GetInt();
      num_entries[i] = 0;
      last_time[i] = 0;
      last_value[i] = 0;
      hs_status[i] = 0;
      count_bins[i] = new int[num_bins];
      mean_bins[i] = new double[num_bins];
      rms_bins[i] = new double[num_bins];
      min_bins[i] = new double[num_bins];
      max_bins[i] = new double[num_bins];
      bins_first_time[i] = new time_t[num_bins];
      bins_last_time[i] = new time_t[num_bins];
      bins_first_value[i] = new double[num_bins];
      bins_last_value[i] = new double[num_bins];
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("time %f %f, num_vars %d:\n", start_time, end_time, int(num_var));
      for (size_t i=0; i<num_var; i++) {
         printf("%d: [%s] [%s] [%d]\n", int(i), event_names[i].c_str(), tag_names[i].c_str(), var_index[i]);
      }
   }
 
   const char** event_name = new const char*[num_var];
   const char** tag_name = new const char*[num_var];
   for (size_t i=0; i<num_var; i++) {
      event_name[i] = event_names[i].c_str();
      tag_name[i] = tag_names[i].c_str();
   }
 
   int status = mh->hs_read_binned(start_time, end_time, num_bins, num_var, event_name, tag_name, var_index, num_entries, count_bins, mean_bins, rms_bins, min_bins, max_bins, bins_first_time, bins_first_value, bins_last_time, bins_last_value, last_time, last_value, hs_status);
 
   // NB: beware of 32-bit integer overflow: all variables are now 64-bit size_t, overflow should not happen
   size_t p0_size = sizeof(double)*(5+4*num_var+9*num_var*num_bins);
 
   size_t size_limit = 100*1024*1024;
 
   if (p0_size > size_limit) {
      cm_msg(MERROR, "js_hs_read_binned_arraybuffer", "Refusing to return %d bytes. limit is %d bytes\n", int(p0_size), int(size_limit));
 
      for (size_t i=0; i<num_var; i++) {
         delete count_bins[i];
         delete mean_bins[i];
         delete rms_bins[i];
         delete min_bins[i];
         delete max_bins[i];
         delete bins_first_time[i];
         delete bins_first_value[i];
         delete bins_last_time[i];
         delete bins_last_value[i];
      }
 
      delete[] count_bins;
      delete[] mean_bins;
      delete[] rms_bins;
      delete[] min_bins;
      delete[] max_bins;
      
      delete[] bins_first_time;
      delete[] bins_first_value;
      delete[] bins_last_time;
      delete[] bins_last_value;
      
      delete[] event_name;
      delete[] tag_name;
      delete[] var_index;
      
      delete[] num_entries;
      delete[] last_time;
      delete[] last_value;
      delete[] hs_status;
 
      return mjsonrpc_make_error(-32603, "Internal error", "Refuse to return too much data");
   }
 
   double* p0 = (double*)malloc(p0_size);
 
   if (p0 == NULL) {
      cm_msg(MERROR, "js_hs_read_binned_arraybuffer", "Cannot allocate return buffer %d bytes\n", int(p0_size));
 
      for (size_t i=0; i<num_var; i++) {
         delete count_bins[i];
         delete mean_bins[i];
         delete rms_bins[i];
         delete min_bins[i];
         delete max_bins[i];
         delete bins_first_time[i];
         delete bins_first_value[i];
         delete bins_last_time[i];
         delete bins_last_value[i];
      }
 
      delete[] count_bins;
      delete[] mean_bins;
      delete[] rms_bins;
      delete[] min_bins;
      delete[] max_bins;
 
      delete[] bins_first_time;
      delete[] bins_first_value;
      delete[] bins_last_time;
      delete[] bins_last_value;
      
      delete[] event_name;
      delete[] tag_name;
      delete[] var_index;
      
      delete[] num_entries;
      delete[] last_time;
      delete[] last_value;
      delete[] hs_status;
 
      return mjsonrpc_make_error(-32603, "Internal error", "Cannot allocate buffer, too much data");
   }
 
   double *pptr = p0;
   
   //
   // Binary data format:
   //
   // * header
   // -- hs_read() status
   // -- start_time
   // -- end_time
   // -- num_bins
   // -- num_var
   // * per variable info
   // -- hs_status[0..num_var-1]
   // -- num_entries[0..num_var-1]
   // -- last_time[0..num_var-1]
   // -- last_value[0..num_var-1]
   // * data for var0 bin0
   // -- count - number of entries in this bin
   // -- mean - mean value
   // -- rms - rms value
   // -- min - minimum value
   // -- max - maximum value
   // -- bins_first_time - first data point in each bin
   // -- bins_first_value
   // -- bins_last_time - last data point in each bin
   // -- bins_last_value
   // - data for var0 bin1
   // - ... bin[num_bins-1]
   // - data for var1 bin0
   // - ...
   // - data for var[num_vars-1] bin[0]
   // - ...
   // - data for var[num_vars-1] bin[num_bins-1]
   //
 
   *pptr++ = status;
   *pptr++ = start_time;
   *pptr++ = end_time;
   *pptr++ = num_bins;
   *pptr++ = num_var;
 
   for (unsigned i=0; i<num_var; i++) {
      *pptr++ = hs_status[i];
   }
 
   for (unsigned i=0; i<num_var; i++) {
      *pptr++ = num_entries[i];
   }
 
   for (unsigned i=0; i<num_var; i++) {
      *pptr++ = last_time[i];
   }
 
   for (unsigned i=0; i<num_var; i++) {
      *pptr++ = last_value[i];
   }
 
   for (size_t i=0; i<num_var; i++) {
      for (size_t j=0; j<num_bins; j++) {
         *pptr++ = count_bins[i][j];
         *pptr++ = mean_bins[i][j];
         *pptr++ = rms_bins[i][j];
         *pptr++ = min_bins[i][j];
         *pptr++ = max_bins[i][j];
         *pptr++ = bins_first_time[i][j];
         *pptr++ = bins_first_value[i][j];
         *pptr++ = bins_last_time[i][j];
         *pptr++ = bins_last_value[i][j];
      }
 
      delete count_bins[i];
      delete mean_bins[i];
      delete rms_bins[i];
      delete min_bins[i];
      delete max_bins[i];
      delete bins_first_time[i];
      delete bins_first_value[i];
      delete bins_last_time[i];
      delete bins_last_value[i];
   }
 
   //printf("p0_size %d, %d/%d\n", (int)p0_size, (int)(pptr-p0), (int)((pptr-p0)*sizeof(double)));
 
   assert(p0_size == ((pptr-p0)*sizeof(double)));
 
   delete[] count_bins;
   delete[] mean_bins;
   delete[] rms_bins;
   delete[] min_bins;
   delete[] max_bins;
 
   delete[] bins_first_time;
   delete[] bins_first_value;
   delete[] bins_last_time;
   delete[] bins_last_value;
 
   delete[] event_name;
   delete[] tag_name;
   delete[] var_index;
 
   delete[] num_entries;
   delete[] last_time;
   delete[] last_value;
   delete[] hs_status;
 
   MJsonNode* result = MJsonNode::MakeArrayBuffer((char*)p0, p0_size);
 
   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_hs_reopen()

static MJsonNode * js_hs_reopen ( const MJsonNode *  params )

static

Definition at line 1863 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("reopen the history channel to make sure we see the latest list of events using hs_clear_cache()");
      doc->P("channel?", MJSON_STRING, "midas history channel, default is the default reader channel");
      doc->R("status", MJSON_INT, "return status of hs_get_events()");
      doc->R("channel", MJSON_STRING, "logger history channel name");
      return doc;
   }
 
   std::string channel = mjsonrpc_get_param(params, "channel", NULL)->GetString();
 
   MidasHistoryInterface* mh = GetHistory(channel.c_str());
 
   if (!mh) {
      int status = HS_FILE_ERROR;
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   int status = mh->hs_clear_cache();
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "channel", MJsonNode::MakeString(mh->name));
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_make_subdir()

static MJsonNode * js_make_subdir ( const MJsonNode *  params )

static

Definition at line 4168 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("js_make_subdir");
      doc->P("subdir", MJSON_STRING, "Create folder experiment_directory/userfiles/subdir");
      doc->R("status", MJSON_INT, "return status of midas library calls");
      doc->R("path", MJSON_STRING, "Search path");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string subdir = mjsonrpc_get_param(params, "subdir", &error)->GetString(); if (error) return error;
 
   /*---- Not allowed to contain ../ - safety feature ----*/
   if (subdir.find("..") != std::string::npos) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("The subdir is not permitted"));
   }
 
   int status;
   HNDLE hDB;
 
   status = cm_get_experiment_database(&hDB, NULL);
 
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
   }
 
   std::string path = cm_expand_env(cm_get_path().c_str());
   if (path[path.length()-1] != DIR_SEPARATOR) {
      path += DIR_SEPARATOR_STR;
   }
   path += "userfiles";
   
   // Check if the userfiles folder exists
   if (access(path.c_str(), F_OK) != 0) {
      // Create the path if it doesn't exist
      if (mkdir(path.c_str(), 0777) != 0) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Failed to create the userfiles folder"));
      }
   }
 
   // Add subdir to userfiles
   if (subdir.length() > 0) {
      if (subdir[0] != DIR_SEPARATOR) {
         path += DIR_SEPARATOR_STR;
      }
      path += subdir;
   }
   // Check if the subdir exisits in userfiles, otherwise create it
   if (access(path.c_str(), F_OK) != 0) {
      // Create the path if it doesn't exist
      if (mkdir(path.c_str(), 0777) != 0) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Failed to create subdirectory"));
      }
   }
   
   
   MJsonNode* r = MJsonNode::MakeObject();
   r->AddToObject("status", MJsonNode::MakeInt(SUCCESS));
   ss_repair_utf8(path);
   r->AddToObject("path", MJsonNode::MakeString(path.c_str()));
   return mjsonrpc_make_result(r);
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_read_binary_file()

static MJsonNode * js_read_binary_file ( const MJsonNode *  params )

static

Definition at line 4520 of file mjsonrpc.cxx.

                                                               {
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("js_read_binary_file");
      doc->P("filename", MJSON_STRING, "File name, read from experiment_directory/userfiles/filename");
      doc->R("binary data", MJSON_ARRAYBUFFER, "Binary file content");
      doc->R("status", MJSON_INT, "Return status of midas library calls");
      doc->R("error", MJSON_STRING, "Error text");
      return doc;
   }
   
   MJsonNode* error = NULL;
   std::string filename = mjsonrpc_get_param(params, "filename", &error)->GetString();
   if (error) return error;
   
   /*---- filename should not contain the following - safety feature */
   if (filename.find("..") != std::string::npos ||
       filename.find("*") != std::string::npos) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("The filename is not permitted"));
   }
   
   int status;
   HNDLE hDB;
   
   status = cm_get_experiment_database(&hDB, NULL);
   
   if (status != DB_SUCCESS) {
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString("cm_get_experiment_database() error"));
   }
   
   std::string path = cm_expand_env(cm_get_path().c_str());
   if (path[path.length()-1] != DIR_SEPARATOR) {
      path += DIR_SEPARATOR_STR;
   }
   path += "userfiles";
   
   // Check if the userfiles folder exists
   if (access(path.c_str(), F_OK) != 0) {
      // Create the path if it doesn't exist
      if (mkdir(path.c_str(), 0777) != 0) {
         return mjsonrpc_make_result("status", MJsonNode::MakeInt(DB_INVALID_PARAM), "error", MJsonNode::MakeString("Failed to create the userfiles folder"));
      }
   }
   
   path += DIR_SEPARATOR_STR;
   path += filename;
   
   FILE* fp = fopen(path.c_str(), "rb");
   if (!fp) {
      status = SS_FILE_ERROR;
      char errstr[256];
      sprintf(errstr, "fopen() errno %d (%s)", errno, strerror(errno));
      ss_repair_utf8(errstr);
      return mjsonrpc_make_result("status", MJsonNode::MakeInt(status), "error", MJsonNode::MakeString(errstr));
   }
    
   fseek(fp, 0, SEEK_END);
   size_t file_size = ftell(fp);
   rewind(fp);
   
   char* buffer = new char[file_size];
   fread(buffer, file_size, 1, fp);
   // maybe not needed here
   //buffer[file_size] = '\0';
   fclose(fp);
   
   status = CM_SUCCESS;
   std::string errstr = "no error";
    
   MJsonNode* result = MJsonNode::MakeArrayBuffer(buffer, file_size);
   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

js_ss_millitime()

static MJsonNode * js_ss_millitime ( const MJsonNode *  params )

static

Definition at line 3928 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("get current MIDAS time using ss_millitime()");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_INT, "current value of ss_millitime()");
      return doc;
   }
 
   return mjsonrpc_make_result(MJsonNode::MakeNumber(ss_millitime()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

MatchEvent()

static void MatchEvent ( const std::string  buffer_name, const EVENT_HEADER *  pevent  )

static

Definition at line 3715 of file mjsonrpc.cxx.

{
   std::lock_guard<std::mutex> guard(gEventStashMutex);
   for (EventStashEntry* s : gEventStash) {
      if (s->buffer_name != buffer_name)
         continue;
      if (bm_match_event(s->event_id, s->trigger_mask, pevent)) {
         s->ReplaceEvent(pevent);
         //s->Print(); printf(", matched\n");
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mjsonrpc_get_param_array()

const MJsonNodeVector * mjsonrpc_get_param_array	(	const MJsonNode *	params,
		const char *	name,
		MJsonNode **	error
	)

Definition at line 201 of file mjsonrpc.cxx.

{
   // NULL params is a request for documentation, return NULL
   if (!params) {
      if (error)
         *error = MJsonNode::MakeObject();
      return NULL;
   }
 
   const MJsonNode* node = mjsonrpc_get_param(params, name, error);
 
   // handle error return from mjsonrpc_get_param()
   if (error && *error) {
      return NULL;
   }
 
   const MJsonNodeVector* v = node->GetArray();
 
   if (!v) {
      if (error)
         *error = mjsonrpc_make_error(-32602, "Invalid params", (std::string("parameter must be an array: ") + name).c_str());
      return NULL;
   }
 
   if (error)
      *error = NULL;
   return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mjsonrpc_handle_request()

static MJsonNode * mjsonrpc_handle_request ( const MJsonNode *  request )

static

Definition at line 5205 of file mjsonrpc.cxx.

{
   // find required request elements
   const MJsonNode* version = request->FindObjectNode("jsonrpc");
   const MJsonNode* method  = request->FindObjectNode("method");
   const MJsonNode* params  = request->FindObjectNode("params");
   const MJsonNode* id      = request->FindObjectNode("id");
 
   std::string bad = "";
 
   if (!version)
      add(&bad, "jsonrpc version is missing");
   if (!method)
      add(&bad, "method is missing");
   if (!params)
      add(&bad, "params is missing");
   if (!id)
      add(&bad, "id is missing");
 
   if (version && (version->GetType() != MJSON_STRING))
      add(&bad, "jsonrpc version is not a string");
   if (version && (version->GetString() != "2.0"))
      add(&bad, "jsonrpc version is not 2.0");
 
   if (method && (method->GetType() != MJSON_STRING))
      add(&bad, "method is not a string");
 
   if (!method || bad.length() > 0) {
      MJsonNode* response = mjsonrpc_make_error(-32600, "Invalid request", bad.c_str());
      response->AddToObject("jsonrpc", MJsonNode::MakeString("2.0"));
      if (id) {
         response->AddToObject("id", id->Copy());
      } else {
         response->AddToObject("id", MJsonNode::MakeNull());
      }
 
      if (mjsonrpc_debug) {
         printf("mjsonrpc: invalid request: reply:\n");
         printf("%s\n", response->Stringify().c_str());
         printf("\n");
      }
 
      return response;
   }
 
   double start_time = 0;
 
   if (mjsonrpc_time) {
      start_time = GetTimeSec();
   }
 
   const std::string ms = method->GetString();
   const char* m = ms.c_str();
 
   MJsonNode* result = NULL;
 
   // special built-in methods
 
   if (strcmp(m, "echo") == 0) {
      result = mjsonrpc_make_result(request->Copy());
   } else if (strcmp(m, "error") == 0) {
      result = mjsonrpc_make_error(1, "test error", "test error");
   } else if (strcmp(m, "invalid_json") == 0) {
      if (mjsonrpc_debug) {
         printf("mjsonrpc: reply with invalid json\n");
      }
      return MJsonNode::MakeJSON("this is invalid json data");
   } else if (strcmp(m, "test_nan_inf") == 0) {
      double one = 1;
      double zero = 0;
      double nan = zero/zero;
      double plusinf = one/zero;
      double minusinf = -one/zero;
      MJsonNode* n = MJsonNode::MakeArray();
      n->AddToArray(MJsonNode::MakeNumber(nan));
      n->AddToArray(MJsonNode::MakeNumber(plusinf));
      n->AddToArray(MJsonNode::MakeNumber(minusinf));
      result = mjsonrpc_make_result("test_nan_plusinf_minusinf", n);
   } else if (strcmp(m, "test_arraybuffer") == 0) {
      if (mjsonrpc_debug) {
         printf("mjsonrpc: reply with test arraybuffer data\n");
      }
      size_t size = 32;
      char* ptr = (char*)malloc(size);
      assert(ptr != NULL);
      for (size_t i=0; i<size; i++) {
         ptr[i] = 'A' + i;
      }
      *((short*)(ptr+4*2*1)) = 111; // int16[4]
      *((int*)(ptr+4*2*2)) = 1234; // int32[4]
      *((double*)(ptr+4*2*3)) = 3.14; // float64[3]
      return MJsonNode::MakeArrayBuffer(ptr, size);
   } else {
      MethodsTableIterator s = gMethodsTable.find(ms);
      if (s != gMethodsTable.end()) {
         bool lock = s->second.fNeedsLocking;
         if (lock && gMutex)
            gMutex->lock();
         result = s->second.fHandler(params);
         if (lock && gMutex)
            gMutex->unlock();
      } else {
         result = mjsonrpc_make_error(-32601, "Method not found", (std::string("unknown method: ") + ms).c_str());
      }
   }
 
   if (mjsonrpc_debug) {
      printf("mjsonrpc: handler reply:\n");
      result->Dump();
      printf("\n");
   }
 
   double end_time = 0;
   double elapsed_time = 0;
   if (mjsonrpc_time) {
      end_time = GetTimeSec();
      elapsed_time = end_time - start_time;
      if (mjsonrpc_time > 1) {
         printf("request took %.3f seconds, method [%s]\n", elapsed_time, m);
      }
   }
 
   if (result->GetType() == MJSON_ARRAYBUFFER) {
      return result;
   }
   
   const MJsonNode *nerror  = result->FindObjectNode("error");
   const MJsonNode *nresult = result->FindObjectNode("result");
 
   if (nerror) {
      result->DeleteObjectNode("result");
   } else if (nresult) {
      result->DeleteObjectNode("error");
   } else {
      delete result;
      result = mjsonrpc_make_error(-32603, "Internal error", "bad dispatcher reply: no result and no error");
   }
 
   result->AddToObject("jsonrpc", MJsonNode::MakeString("2.0"));
 
   if (id) {
      result->AddToObject("id", id->Copy());
   } else {
      result->AddToObject("id", MJsonNode::MakeNull());
   }
 
   if (mjsonrpc_time) {
      result->AddToObject("elapsed_time", MJsonNode::MakeNumber(elapsed_time));
   }
 
   assert(result != NULL);
 
   return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mjsonrpc_make_result()

MJsonNode * mjsonrpc_make_result	(	const char *	name,
		MJsonNode *	value,
		const char *	name2,
		MJsonNode *	value2,
		const char *	name3,
		MJsonNode *	value3,
		const char *	name4,
		MJsonNode *	value4
	)

Definition at line 158 of file mjsonrpc.cxx.

{
   MJsonNode* node = MJsonNode::MakeObject();
 
   if (name)
      node->AddToObject(name, value);
   if (name2)
      node->AddToObject(name2, value2);
   if (name3)
      node->AddToObject(name3, value3);
   if (name4)
      node->AddToObject(name4, value4);
 
   MJsonNode* result = MJsonNode::MakeObject();
   result->AddToObject("result", node);
   return result;
}

mjsonrpc_make_schema()

static MJsonNode * mjsonrpc_make_schema ( MethodsTable *  h )

static

Definition at line 4846 of file mjsonrpc.cxx.

{
   MJsonNode* s = MJsonNode::MakeObject();
 
   s->AddToObject("$schema", MJsonNode::MakeString("http://json-schema.org/schema#"));
   s->AddToObject("id", MJsonNode::MakeString("MIDAS JSON-RPC autogenerated schema"));
   s->AddToObject("title", MJsonNode::MakeString("MIDAS JSON-RPC schema"));
   s->AddToObject("description", MJsonNode::MakeString("Autogenerated schema for all MIDAS JSON-RPC methods"));
   s->AddToObject("type", MJsonNode::MakeString("object"));
 
   MJsonNode* m = MJsonNode::MakeObject();
 
   for (MethodsTableIterator iterator = h->begin(); iterator != h->end(); iterator++) {
      // iterator->first = key
      // iterator->second = value
      //printf("build schema for method \"%s\"!\n", iterator->first.c_str());
      MJsonNode* doc = iterator->second.fHandler(NULL);
      if (doc == NULL)
         doc = MJsonNode::MakeObject();
      m->AddToObject(iterator->first.c_str(), doc);
   }
 
   s->AddToObject("properties", m);
   s->AddToObject("required", MJsonNode::MakeArray());
 
   return s;
}

Here is the caller graph for this function:

mjsonrpc_schema_to_html_anything()

std::string mjsonrpc_schema_to_html_anything ( const MJsonNode *  schema, int  nest_level, NestedOutput *  o  )

static

Definition at line 5145 of file mjsonrpc.cxx.

{
   std::string type;
   std::string description;
   //bool        optional = false;
 
   const MJsonNode* t = schema->FindObjectNode("type");
   if (t)
      type = t->GetString();
   else
      type = "any";
 
   const MJsonNode* d = schema->FindObjectNode("description");
   if (d)
      description = d->GetString();
 
   //const MJsonNode* o = schema->FindObjectNode("optional");
   //if (o)
   //   optional = o->GetBool();
 
   if (type == "object") {
      return mjsonrpc_schema_to_html_object(schema, nest_level, o);
   } else if (type == "array") {
      return mjsonrpc_schema_to_html_array(schema, nest_level, o);
   } else {
      //if (optional)
      //   output(nest_level, false, "?");
      //else
      //   output(nest_level, false, "!");
      o->Output(nest_level, false, type);
      o->Output(nest_level+1, true, description);
      if (description.length() > 1) {
         return (type + "</td><td>" + description);
      } else {
         return (type);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mjsonrpc_schema_to_html_array()

static std::string mjsonrpc_schema_to_html_array ( const MJsonNode *  schema, int  nest_level, NestedOutput *  o  )

static

Definition at line 5089 of file mjsonrpc.cxx.

{
   const MJsonNode* d = schema->FindObjectNode("description");
   std::string description;
   if (d)
      description = d->GetString();
 
   std::string xshort = "array";
   if (description.length() > 1)
      xshort += "</td><td>" + description;
 
   const MJsonNode* items = schema->FindObjectNode("items");
 
   if (!items) {
      o->Output(nest_level, false, "array");
      o->Output(nest_level+1, true, description);
      return xshort;
   }
 
   const MJsonNodeVector *nodes = items->GetArray();
 
   if (!nodes) {
      o->Output(nest_level, false, "array");
      o->Output(nest_level+1, true, description);
      return xshort;
   }
 
   std::string nest = indent(nest_level * 4);
 
   std::string s;
 
   //s += "array</td><td>";
 
   s += nest + "<table border=1>\n";
 
   if (description.length() > 1) {
      s += nest + "<tr>\n";
      s += nest + "  <td>" + description + "</td>\n";
      s += nest + "</tr>\n";
   }
 
   o->Output(nest_level, true, description);
 
   for (unsigned i=0; i<nodes->size(); i++) {
      o->Output(nest_level, false, "array of");
 
      s += nest + "<tr>\n";
      s += nest + "  <td> array of " + mjsonrpc_schema_to_html_anything((*nodes)[i], nest_level + 1, o) + "</td>\n";
      s += nest + "</tr>\n";
   }
 
   s += nest + "</table>\n";
 
   return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mjsonrpc_schema_to_html_object()

static std::string mjsonrpc_schema_to_html_object ( const MJsonNode *  schema, int  nest_level, NestedOutput *  o  )

static

Definition at line 5003 of file mjsonrpc.cxx.

{
   const MJsonNode* d = schema->FindObjectNode("description");
   std::string description;
   if (d)
      description = d->GetString();
 
   std::string xshort = "object";
   if (description.length() > 1)
      xshort += "</td><td>" + description;
 
   const MJsonNode* properties = schema->FindObjectNode("properties");
 
   const MJsonNodeVector* required_list = NULL;
   const MJsonNode* r = schema->FindObjectNode("required");
   if (r)
      required_list = r->GetArray();
 
   if (!properties) {
      o->Output(nest_level, false, "object");
      o->Output(nest_level+1, true, description);
      return xshort;
   }
 
   const MJsonStringVector *names = properties->GetObjectNames();
   const MJsonNodeVector *nodes = properties->GetObjectNodes();
 
   if (!names || !nodes) {
      o->Output(nest_level, false, "object");
      o->Output(nest_level+1, true, description);
      return xshort;
   }
 
   std::string nest = indent(nest_level * 4);
 
   std::string s;
 
   s += nest + "<table border=1>\n";
 
   if (description.length() > 1) {
      s += nest + "<tr>\n";
      s += nest + "  <td colspan=3>" + description + "</td>\n";
      s += nest + "</tr>\n";
   }
 
   o->Output(nest_level, true, description);
 
   for (unsigned i=0; i<names->size(); i++) {
      std::string name = (*names)[i];
      const MJsonNode* node = (*nodes)[i];
 
      bool required = false;
      if (required_list)
         for (unsigned j=0; j<required_list->size(); j++)
            if ((*required_list)[j])
               if ((*required_list)[j]->GetString() == name) {
                  required = true;
                  break;
               }
 
      bool is_array = false;
      const MJsonNode* type = node->FindObjectNode("type");
      if (type && type->GetString() == "array")
         is_array = true;
 
      if (is_array)
         name += "[]";
 
      if (!required)
         name += "?";
 
      o->Output(nest_level, false, name);
 
      s += nest + "<tr>\n";
      s += nest + "  <td>" + name + "</td>\n";
      s += nest + "  <td>";
      s += mjsonrpc_schema_to_html_anything(node, nest_level + 1, o);
      s += "</td>\n";
      s += nest + "</tr>\n";
   }
 
   s += nest + "</table>\n";
 
   return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_array_index_list()

static int parse_array_index_list ( const char *  method, const char *  path, std::vector< unsigned > *  list  )

static

Definition at line 557 of file mjsonrpc.cxx.

{
   // parse array index in form of:
   // odbpath[number]
   // odbpath[number,number]
   // odbpath[number-number]
   // or any combination of them, i.e. odbpath[1,10-15,20,30-40]
 
   const char*s = strchr(path, '[');
 
   if (!s) {
      cm_msg(MERROR, method, "expected an array index character \'[\' in \"%s\"", path);
      return DB_OUT_OF_RANGE;
   }
  
   s++; // skip '[' itself
 
   while (s && (*s != 0)) {
 
      // check that we have a number
      if (!isdigit(*s)) {
         cm_msg(MERROR, method, "expected a number in array index in \"%s\" at \"%s\"", path, s);
         return DB_OUT_OF_RANGE;
      }
 
      unsigned value1 = strtoul(s, (char**)&s, 10);
      
      // array range, 
      if (*s == '-') {
         s++; // skip the minus char
 
         if (!isdigit(*s)) {
            cm_msg(MERROR, method, "expected a number in array index in \"%s\" at \"%s\"", path, s);
            return DB_OUT_OF_RANGE;
         }
 
         unsigned value2 = strtoul(s, (char**)&s, 10);
 
         if (value2 >= value1)
            for (unsigned i=value1; i<=value2; i++)
               list->push_back(i);
         else {
            // this is stupid. simple loop like this
            // for (unsigned i=value1; i>=value2; i--)
            // does not work for range 4-0, because value2 is 0,
            // and x>=0 is always true for unsigned numbers,
            // so we would loop forever... K.O.
            for (unsigned i=value1; i!=value2; i--)
               list->push_back(i);
            list->push_back(value2);
         }
      } else {
         list->push_back(value1);
      }
 
      if (*s == ',') {
         s++; // skip the comma char
         continue; // back to the begin of loop
      }
 
      if (*s == ']') {
         s++; // skip the closing bracket
         s = NULL;
         continue; // done
      }
 
      cm_msg(MERROR, method, "invalid char in array index in \"%s\" at \"%s\"", path, s);
      return DB_OUT_OF_RANGE;
   }
 
#if 0
   printf("parsed array indices for \"%s\" size is %d: ", path, (int)list->size());
   for (unsigned i=0; i<list->size(); i++)
      printf(" %d", (*list)[i]);
   printf("\n");
#endif
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

remove()

static std::string remove ( const std::string  s, char  c  )

static

Definition at line 253 of file mjsonrpc.cxx.

{
   std::string::size_type pos = s.find(c);
   if (pos == std::string::npos)
      return s;
   else
      return s.substr(0, pos);
}

Here is the caller graph for this function:

set_debug()

static MJsonNode * set_debug ( const MJsonNode *  params )

static

Definition at line 4613 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("set new value of mjsonrpc_debug");
      doc->P(NULL, MJSON_INT, "new value of mjsonrpc_debug");
      doc->R(NULL, MJSON_INT, "new value of mjsonrpc_debug");
      return doc;
   }
 
   mjsonrpc_debug = params->GetInt();
   return mjsonrpc_make_result("debug", MJsonNode::MakeInt(mjsonrpc_debug));
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_sleep()

static MJsonNode * set_sleep ( const MJsonNode *  params )

static

Definition at line 4640 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("set new value of mjsonrpc_sleep");
      doc->P(NULL, MJSON_INT, "new value of mjsonrpc_sleep");
      doc->R(NULL, MJSON_INT, "new value of mjsonrpc_sleep");
      return doc;
   }
 
   mjsonrpc_sleep = params->GetInt();
   return mjsonrpc_make_result("sleep", MJsonNode::MakeInt(mjsonrpc_sleep));
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_time()

static MJsonNode * set_time ( const MJsonNode *  params )

static

Definition at line 4667 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("set new value of mjsonrpc_time");
      doc->P(NULL, MJSON_INT, "new value of mjsonrpc_time");
      doc->R(NULL, MJSON_INT, "new value of mjsonrpc_time");
      return doc;
   }
 
   mjsonrpc_time = params->GetInt();
   return mjsonrpc_make_result("time", MJsonNode::MakeInt(mjsonrpc_time));
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_program()

static MJsonNode * start_program ( const MJsonNode *  params )

static

Definition at line 483 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("start MIDAS program defined in ODB /Programs/name");
      doc->P("name", MJSON_STRING, "name of the program, corresponding to ODB /Programs/name");
      doc->R("status", MJSON_INT, "return status of ss_system()");
      return doc;
   }
 
   MJsonNode* error = NULL;
 
   std::string name = mjsonrpc_get_param(params, "name", &error)->GetString(); if (error) return error;
 
   std::string path = "";
   path += "/Programs/";
   path += name;
   path += "/Start command";
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   std::string command;
   int status = db_get_value_string(hDB, 0, path.c_str(), 0, &command);
 
   if (status == DB_SUCCESS && command.length() > 0) {
      //printf("ss_system(\"%s\")\n", command.c_str());
      status = ss_system(command.c_str());
   }
 
   return mjsonrpc_make_result("status", MJsonNode::MakeInt(status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

StashEvent()

static void StashEvent ( const std::string  buffer_name, int  event_id, int  trigger_mask, const EVENT_HEADER *  pevent  )

static

Definition at line 3688 of file mjsonrpc.cxx.

{
   std::lock_guard<std::mutex> guard(gEventStashMutex);
   bool found = false;
   for (EventStashEntry* s : gEventStash) {
      if (s->buffer_name != buffer_name)
         continue;
      if (s->event_id == event_id && s->trigger_mask == trigger_mask) {
         found = true;
         s->ReplaceEvent(pevent);
         //s->Print(); printf(", replaced\n");
      } else if (bm_match_event(s->event_id, s->trigger_mask, pevent)) {
         s->ReplaceEvent(pevent);
         //s->Print(); printf(", matched\n");
      }
   }
   if (!found) {
      EventStashEntry* s = new EventStashEntry();
      s->buffer_name = buffer_name;
      s->event_id = event_id;
      s->trigger_mask = trigger_mask;
      s->pevent = CopyEvent(pevent);
      //s->Print(); printf(", added\n");
      gEventStash.push_back(s);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

xnull()

static MJsonNode * xnull ( const MJsonNode *  params )

static

Definition at line 413 of file mjsonrpc.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("RPC method always returns null");
      doc->P(NULL, 0, "method parameters are ignored");
      doc->R(NULL, MJSON_NULL, "always returns null");
      return doc;
   }
 
   return mjsonrpc_make_result(MJsonNode::MakeNull());
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

gEventStash

std::vector<EventStashEntry*> gEventStash

static

Definition at line 3686 of file mjsonrpc.cxx.

gEventStashMutex

std::mutex gEventStashMutex

static

Definition at line 3685 of file mjsonrpc.cxx.

gHistoryChannels

MhiMap gHistoryChannels

static

Definition at line 1684 of file mjsonrpc.cxx.

gMethodsTable

MethodsTable gMethodsTable

static

Definition at line 4732 of file mjsonrpc.cxx.

gMutex

std::mutex* gMutex = NULL

static

Definition at line 4733 of file mjsonrpc.cxx.

gNullNode

MJsonNode* gNullNode = NULL

static

Definition at line 176 of file mjsonrpc.cxx.

mjsonrpc_sleep

int mjsonrpc_sleep = 0

static

Definition at line 113 of file mjsonrpc.cxx.

mjsonrpc_time

int mjsonrpc_time = 0

static

Definition at line 114 of file mjsonrpc.cxx.