bool is_backup() {
MS_Mon_Process_Info_Type proc_info;
int ferr = msg_mon_get_process_info_detail(gname, &proc_info);
TEST_CHK_FEOK(ferr);
bool backup = proc_info.backup ? true : false;
return backup;
}
int tm_init_logging()
{
// Log4cxx logging
MS_Mon_Process_Info_Type proc_info;
msg_mon_get_process_info_detail(NULL, &proc_info);
int myNid = proc_info.nid;
char logNameSuffix[32];
sprintf( logNameSuffix, "_%d.log", myNid );
CommonLogger::instance().initLog4cxx("log4cxx.trafodion.tm.config",logNameSuffix);
gv_log4cxx_initialized = true;
ms_getenv_int ("TM_DUAL_LOGGING", &gv_dual_logging);
return gv_dual_logging;
}
bool is_backup() {
int ferr;
MS_Mon_Process_Info_Type proc_info;
ferr = msg_mon_get_process_info_detail(gname, &proc_info);
TEST_CHK_FEOK(ferr);
gnid = proc_info.nid;
gpid = proc_info.pid;
bool backup = proc_info.backup ? true : false;
if (backup) {
ferr = msg_mon_register_death_notification(proc_info.parent_nid,
proc_info.parent_pid);
assert(ferr == XZFIL_ERR_OK);
}
return backup;
}
// -----------------------------------------------------------------------
//
// ComRtGetProgramInfo()
//
// Outputs:
// 1) the pathname of the directory where the application program
// is being run from.
// For OSS processes, this will be the fully qualified oss directory
// pathname.
// For Guardian processes, pathname is not set
// 2) the process type (oss or guardian).
// 3) Other output values are: cpu, pin, nodename, nodename Len, processCreateTime
// and processNameString in the format <\node_name>.<cpu>,<pin>
//
// // Return status: 0, if all ok. <errnum>, in case of an error.
//
// -----------------------------------------------------------------------
Lng32 ComRtGetProgramInfo(char * pathName, /* out */
Lng32 pathNameMaxLen,
short &processType,/* out */
Int32 &cpu, /* cpu */
pid_t &pin, /* pin */
Lng32 &nodeNumber,
char * nodeName, // GuaNodeNameMaxLen+1
short &nodeNameLen,
Int64 &processCreateTime,
char *processNameString,
char *parentProcessNameString
#ifdef SQ_PHANDLE_VERIFIER
, SB_Verif_Type *verifier
#endif
)
{
Lng32 retcode = 0;
processType = 2;
strcpy(nodeName, "NSK");
nodeNameLen = strlen("NSK");
NAProcessHandle myPhandle;
myPhandle.getmine();
myPhandle.decompose();
cpu = myPhandle.getCpu();
pin = myPhandle.getPin();
#ifdef SQ_PHANDLE_VERIFIER
if (verifier)
*verifier = myPhandle.getSeqNum();
#endif
// Map the node number to cpu
nodeNumber = cpu;
strcpy(processNameString, myPhandle.getPhandleString());
MS_Mon_Process_Info_Type processInfo;
if ((retcode = msg_mon_get_process_info_detail(
processNameString, &processInfo))
!= XZFIL_ERR_OK)
return retcode;
processCreateTime = ComRtGetJulianFromUTC(processInfo.creation_time);
if (processInfo.parent_nid != -1 &&
processInfo.parent_pid != -1 && parentProcessNameString)
strcpy(parentProcessNameString, processInfo.parent_name);
else
parentProcessNameString = NULL;
return retcode;
}
// -----------------------------------------------------------
//
// sp_initialize - get setup information and exec into what
// exe we need to be
//
// -----------------------------------------------------------
void sp_initialize (int pv_argc, char *pa_argv[])
{
MS_Mon_Process_Info_Type lv_info;
int lv_type = atoi(pa_argv[1]);
int lv_error = msg_mon_get_process_info_detail(NULL, &lv_info);
if (lv_error)
return;
gvMyNid = lv_info.nid;
gvMyPid = lv_info.pid;
sprintf(gvMyName, "%s",lv_info.process_name);
switch (lv_type)
{
case SP_BROKER:
case SP_METRICS:
case SP_GENERIC_EXE:
{
execGeneric_exe(pv_argc, pa_argv);
break;
}
case SP_TPA_SCRIPTS:
case SP_HARNESS:
case SP_GENERIC_SCRIPT:
{
execGeneric_script(pv_argc, pa_argv);
break;
}
default:
{
LOG_AND_TRACE (1,("\nWrapper : Unknown process type(%d) for %s\n", lv_type, gvMyName));
break;
}
}
LOG_AND_TRACE (1,("SP_Process::sp_initialize (%s) EXIT (ERROR)\n", gvMyName));
// should never get here, but aborts are bad
return;
}
void restart_server() {
int disable;
int ferr;
MS_Mon_Process_Info_Type info;
char prog[BUFSIZ];
TPT_DECL (server_phandle);
ferr = msg_mon_get_process_info_detail((char *) "$srv", &info);
if (ferr == XZFIL_ERR_OK)
return; // server is alive
sprintf(prog, "%s/%s", getenv("PWD"), gargv[0]);
if (verbose)
printf("%s - starting server\n", who);
// TODO: remove disable/loop
disable = msg_test_assert_disable();
do {
ferr = msg_mon_start_process(prog, // prog
(char *) "$srv", // name
NULL, // ret name
*gargc,
gargv,
TPT_REF(server_phandle),
0, // open
NULL, // oid
MS_ProcessType_Generic, // type
0, // priority
0, // debug
0, // backup
NULL, // nid
NULL, // pid
NULL, // infile
NULL); // outfile
if (ferr == XZFIL_ERR_BOUNDSERR) {
printf("TODO: remove this sleep - $srv already in use\n");
sleep(1);
}
} while (ferr == XZFIL_ERR_BOUNDSERR);
TEST_CHK_FEOK(ferr);
msg_test_assert_enable(disable);
}
bool pp_is_backup() {
bool backup;
int disable;
int ferr;
MS_Mon_Node_Info_Type node_info;
MS_Mon_Process_Info_Type proc_info;
ferr = msg_mon_get_process_info_detail(gname, &proc_info);
TEST_CHK_FEOK(ferr);
gnid = proc_info.nid;
gpid = proc_info.pid;
backup = proc_info.backup ? true : false;
if (backup) {
gpeer_nid = proc_info.parent_nid;
gpeer_pid = proc_info.parent_pid;
// set this up in case register fails
strcpy(gdisplay_name, gname);
sprintf(&gdisplay_name[strlen(gdisplay_name)],
"-%d-%d-%d-B", gnid, gpid, getpid());
if (gverbosepp)
pp_printf("we are the backup process.\n");
disable = msg_test_assert_disable();
ferr = msg_mon_register_death_notification(gpeer_nid, gpeer_pid);
if (ferr != XZFIL_ERR_OK) {
if (gverbosepp)
pp_printf("msg_mon_register_death_notification FAILED ferr=%d.\n", ferr);
ferr = msg_mon_get_node_info_detail(gpeer_nid, &node_info);
myassert(ferr == XZFIL_ERR_OK);
if (gverbosepp)
pp_printf("node-state=%d.\n", node_info.node[0].state);
if (node_info.node[0].state == MS_Mon_State_Shutdown)
gshutdown = true;
}
msg_test_assert_enable(disable);
}
return backup;
}
// IN: if cpu, pin and nodeName are passed in, is that to find process.
// Otherwise, use current process
// OUT: processCreateTime: time when this process was created.
Lng32 ComRtGetProcessCreateTime(short *cpu, /* cpu */
pid_t *pin, /* pin */
short *nodeNumber,
Int64 &processCreateTime,
short &errorDetail
)
{
Lng32 retcode = 0;
MS_Mon_Process_Info_Type processInfo;
char processName[MS_MON_MAX_PROCESS_NAME];
Int32 lnxCpu = (Int32) (*cpu);
Int32 lnxPin = (Int32) (*pin);
processCreateTime = 0;
if ((retcode = msg_mon_get_process_name(lnxCpu, lnxPin, processName))
!= XZFIL_ERR_OK)
return retcode;
if ((retcode = msg_mon_get_process_info_detail(processName, &processInfo))
!= XZFIL_ERR_OK)
return retcode;
processCreateTime = ComRtGetJulianFromUTC(processInfo.creation_time);
return retcode;
}
void kill_server() {
int count;
int err;
int ferr;
char killcmd[100];
MS_Mon_Node_Info_Type ninfo;
bool pp;
MS_Mon_Process_Info_Type *ppinfo1;
MS_Mon_Process_Info_Type pinfo1[2];
MS_Mon_Process_Info_Type pinfo2;
do {
pp = false;
ferr = msg_mon_get_process_info_type(MS_ProcessType_TSE, // ptype
&count, // count
2, // max
pinfo1); // info
myassert(ferr == XZFIL_ERR_OK); // oops
myassert(count > 0);
if (count == 2)
pp = true;
else {
printf("server is not up yet\n");
usleep(10000); // 1/100 sec
}
} while (!pp);
// pick primary
if (pinfo1[0].backup)
ppinfo1 = &pinfo1[1];
else
ppinfo1 = &pinfo1[0];
assert(ferr == XZFIL_ERR_OK);
ferr = msg_mon_get_node_info_detail(ppinfo1->nid, &ninfo);
assert(ferr == XZFIL_ERR_OK);
usleep(gksleep);
if (gvirtual || (ppinfo1->nid == gcnid)) {
do {
if (gverbose)
printf("kc=kill(%d, SIGURG)\n", pinfo1->pid);
kill(ppinfo1->pid, SIGURG);
usleep(1000);
err = kill(ppinfo1->pid, 0);
if (err == 0)
sleep(1);
} while (err == 0);
} else {
assert(ninfo.num_returned == 1);
sprintf(killcmd, "pdsh -w %s kill -s URG %d",
ninfo.node[0].node_name, ppinfo1->pid);
do {
if (gverbose)
printf("kc=%s\n", killcmd);
system(killcmd);
ferr = msg_mon_get_process_info_detail((char *) "$srv", &pinfo2);
if (ferr == XZFIL_ERR_OK) {
if ((pinfo2.nid != ppinfo1->nid) && (pinfo2.pid != ppinfo1->pid))
ferr = XZFIL_ERR_NOSUCHDEV;
else
sleep(1);
}
} while (ferr == XZFIL_ERR_OK);
}
}
int main(int argc, char *argv[], char *envp[])
{
INITSRVRTRC
CEE_status sts = CEE_SUCCESS;
SRVR_INIT_PARAM_Def initParam;
DWORD processId;
char tmpString[128];
char tmpString2[32];
char tmpString3[512];
CEECFG_Transport transport;
CEECFG_TcpPortNumber portNumber;
BOOL retcode;
IDL_OBJECT_def srvrObjRef;
CEECFG_TcpProcessName TcpProcessName;
int TransportTrace = 0;
CALL_COMP_DOVERS(ndcs,argc,argv);
try
{
regZnodeName[0] = '\x0';
zkHost[0] = '\x0';
zkRootNode[0] = '\x0';
// Initialize seabed
int sbResult;
char buffer[FILENAME_MAX] = {0};
bzero(buffer, sizeof(buffer));
sbResult = file_init_attach(&argc, &argv, true, buffer);
if(sbResult != XZFIL_ERR_OK){
exit(3);
}
sbResult = file_mon_process_startup(true);
if(sbResult != XZFIL_ERR_OK){
exit(3);
}
msg_mon_enable_mon_messages(true);
}
catch(SB_Fatal_Excep sbfe)
{
exit(3);
}
sigset_t newset, oldset;
sigemptyset(&newset);
sigaddset(&newset,SIGQUIT);
sigaddset(&newset,SIGTERM);
sigprocmask(SIG_BLOCK,&newset,&oldset);
processId = GetCurrentProcessId();
retcode = getInitParamSrvr(argc, argv, initParam, tmpString, tmpString3);
retcode = TRUE;
mxosrvr_init_seabed_trace_dll();
atexit(mxosrvr_atexit_function);
// +++ Todo: Duplicating calls here. Should try to persist in srvrGlobal
MS_Mon_Process_Info_Type proc_info;
msg_mon_get_process_info_detail(NULL, &proc_info);
myNid = proc_info.nid;
myPid = proc_info.pid;
myProcName = proc_info.process_name;
char logNameSuffix[32];
sprintf( logNameSuffix, "_%d_%d.log", myNid, myPid );
CommonLogger::instance().initLog4cxx("log4cxx.trafodion.masterexe.config", logNameSuffix);
if(retcode == FALSE )
{
//LCOV_EXCL_START
SendEventMsg( MSG_SET_SRVR_CONTEXT_FAILED,
EVENTLOG_ERROR_TYPE,
processId,
ODBCMX_SERVER,
srvrObjRef,
2,
tmpString,
tmpString3);
exit(0);
//LCOV_EXCL_STOP
}
GTransport.initialize();
if(GTransport.error != 0 )
{
//LCOV_EXCL_START
SendEventMsg( MSG_SET_SRVR_CONTEXT_FAILED,
EVENTLOG_ERROR_TYPE,
processId,
ODBCMX_SERVER,
srvrObjRef,
1,
GTransport.error_message);
exit(0);
//LCOV_EXCL_STOP
}
chdir(GTransport.myPathname);
initParam.srvrType = CORE_SRVR;
//LCOV_EXCL_START
if (initParam.debugFlag & SRVR_DEBUG_BREAK)
{
volatile int done = 0;
while (!done) {
sleep(10);
}
}
//LCOV_EXCL_STOP
char zkErrStr[2048];
stringstream zk_ip_port;
// zoo_set_debug_level(ZOO_LOG_LEVEL_DEBUG);
if( zkHost[0] == '\x0' && regZnodeName[0] == '\x0' )
{
sprintf(zkErrStr, "***** Cannot get Zookeeper properties or registered znode info from startup params");
SendEventMsg( MSG_SET_SRVR_CONTEXT_FAILED,
EVENTLOG_ERROR_TYPE,
processId,
ODBCMX_SERVER,
srvrObjRef,
1,
zkErrStr);
// exit(1);
}
else
{
zk_ip_port << zkHost;
sprintf(zkErrStr, "zk_ip_port is: %s", zk_ip_port.str().c_str());
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
}
if (initParam.debugFlag & SRVR_DEBUG_BREAK)
zkSessionTimeout = 600;
zoo_deterministic_conn_order(1); // enable deterministic order
zh = zookeeper_init(zk_ip_port.str().c_str(), watcher, zkSessionTimeout * 1000, &myid, 0, 0);
if (zh == 0){
sprintf(zkErrStr, "***** zookeeper_init() failed for host:port %s",zk_ip_port.str().c_str());
SendEventMsg( MSG_SET_SRVR_CONTEXT_FAILED,
EVENTLOG_ERROR_TYPE,
processId,
ODBCMX_SERVER,
srvrObjRef,
1,
zkErrStr);
// exit(1);
}
bool found = false;
int rc;
stringstream ss;
ss.str("");
ss << zkRootNode << "/dcs/master";
string dcsMaster(ss.str());
Stat stat;
int startPortNum = 0, portRangeNum;
char masterHostName[MAX_HOST_NAME_LEN];
char startPort[12], portRange[12], masterTS[24];
struct String_vector children;
children.count = 0;
children.data = NULL;
// Get the instance ID from registered node
char *tkn;
char tmpStr[256];
strcpy( tmpStr, regZnodeName );
tkn = strtok(tmpStr, ":" );
if(tkn!=NULL)
strcpy(hostname,tkn);
tkn = strtok(NULL, ":" );
if( tkn != NULL )
strcpy( instanceId, tkn );
tkn = strtok(NULL, ":" );
if( tkn != NULL )
strcpy( childId, tkn );
else
; // +++ Todo handle error
while(!found)
{
rc = zoo_exists(zh, dcsMaster.c_str(), 0, &stat);
if( rc == ZNONODE )
continue;
else
if( rc == ZOK )
{
rc = zoo_get_children(zh, dcsMaster.c_str(), 0, &children);
if( children.count > 0 )
{
char zknodeName[2048];
strcpy(zknodeName, children.data[0]);
tkn = strtok(zknodeName, ":" );
if( tkn != NULL )
strcpy( masterHostName, tkn );
tkn = strtok(NULL, ":" );
if( tkn != NULL ) {
strcpy( startPort, tkn );
startPortNum = atoi(tkn);
}
tkn = strtok(NULL, ":" );
if( tkn != NULL ) {
strcpy( portRange, tkn );
portRangeNum = atoi(tkn);
}
tkn = strtok(NULL, ":" );
if( tkn != NULL )
strcpy( masterTS, tkn );
free_String_vector(&children);
found = true;
}
else
continue;
}
else // error
{
sprintf(zkErrStr, "***** zoo_exists() for %s failed with error %d",dcsMaster.c_str(), rc);
SendEventMsg( MSG_SET_SRVR_CONTEXT_FAILED,
EVENTLOG_ERROR_TYPE,
processId,
ODBCMX_SERVER,
srvrObjRef,
1,
zkErrStr);
break;
}
}
// Initialize initparam to defaults
initParam.transport = CEE_TRANSPORT_TCP; // -T 3
initParam.majorVersion = 3; // -V 3
// Will need to remove $ZTC0 and NonStopODBC from below
sprintf( initParam.asSrvrObjRef, "TCP:$ZTC0/%s:NonStopODBC", startPort); // -A TCP:$ZTC0/52500:NonStopODBC
// Will need to remove this after we get rid off all existing AS related processing
sprintf( initParam.ASProcessName, "$MXOAS" ); // -AS $MXOAS
// Will need to remove this after we get rid off all existing WMS related processing
sprintf( initParam.QSProcessName, "$ZWMGR" ); // -QS $ZWMGR
// moved this here from begining of the function
BUILD_OBJECTREF(initParam.asSrvrObjRef, srvrObjRef, "NonStopODBC", initParam.portNumber);
ss.str("");
ss << zkRootNode << "/dcs/servers/registered";
string dcsRegistered(ss.str());
char realpath[1024];
bool zk_error = false;
if( found )
{
sprintf(zkErrStr, "Found master node in Zookeeper");
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
found = false;
while(!found)
{
rc = zoo_exists(zh, dcsRegistered.c_str(), 0, &stat);
if( rc == ZNONODE )
continue;
else
if( rc == ZOK )
{
int i;
//This section is the original port finding mechanism.
//All servers (the herd) start looking for any available port
//between starting port number+2 through port range max.
//This is mainly for backward compatability for DcsServers
//that don't pass PORTMAPTOSECS and PORTBINDTOSECS param
if(portMapToSecs == -1 && portBindToSecs == -1) {
for(i = startPortNum+2; i < startPortNum+portRangeNum; i++) {
if (GTransport.m_listener->verifyPortAvailable("SRVR", i))
break;
}
if( i == startPortNum+portRangeNum )
{
zk_error = true;
sprintf(zkErrStr, "***** No ports free");
break;
}
} else {
//This section is for new port map params, PORTMAPTOSECS and PORTBINDTOSECS,
//passed in by DcsServer. DcsMaster writes the port map to data portion of
//<username>/dcs/servers/registered znode. Wait PORTMAPTOSECS for port map
//to appear in registered znode. When it appears read it and scan looking for
//match of instance and child Id.
long retryTimeout = 500;//.5 second
long long timeout = JULIANTIMESTAMP();
bool isPortsMapped = false;
char *zkData = new char[1000000];
int zkDataLen = 1000000;
while(! isPortsMapped) {
memset(zkData,0,1000000);
rc = zoo_get(zh, dcsRegistered.c_str(), false, zkData, &zkDataLen, &stat);
if( rc == ZOK && zkDataLen > 0 ) {
sprintf(zkErrStr, "DCS port map = %s", zkData);
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
int myInstanceId = atoi(instanceId);
int myChildId = atoi(childId);
sprintf(zkErrStr, "Searching for my id (%d:%d) in port map",myInstanceId,myChildId);
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
char portMapInstanceId[8];
char portMapChildId[8];
char portMapPortNum[8];
char* saveptr;
char* token = strtok_r (zkData,":",&saveptr);
while (token != NULL)
{
if( token != NULL )//instance Id
strcpy( portMapInstanceId, token );
token = strtok_r(NULL, ":",&saveptr);
if( token != NULL )//child id
strcpy( portMapChildId, token );
token = strtok_r(NULL, ":",&saveptr);
if( token != NULL )//port number
strcpy( portMapPortNum, token );
int currPortMapInstanceId = atoi(portMapInstanceId);
int currPortMapChildId = atoi(portMapChildId);
int currPortMapPortNum = atoi(portMapPortNum);
if(myInstanceId == currPortMapInstanceId && myChildId == currPortMapChildId) {
i = currPortMapPortNum;
sprintf(zkErrStr, "Found my port number = %d in port map", i);
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
break;
} else {
token = strtok_r (NULL, ":",&saveptr);
}
}
timeout = JULIANTIMESTAMP();
bool isAvailable = false;
while ( isAvailable == false ) {
if (GTransport.m_listener->verifyPortAvailable("SRVR", i)) {
isAvailable = true;
} else {
if((JULIANTIMESTAMP() - timeout) > (portBindToSecs * 1000000)) {
sprintf(zkErrStr, "Port bind timeout...exiting");
zk_error = true;
break;
} else {
sprintf(zkErrStr, "Port = %d is already in use...retrying", i);
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
DELAY(retryTimeout);
}
}
}
isPortsMapped = true;
} else {
if((JULIANTIMESTAMP() - timeout) > (portMapToSecs * 1000000)) {
sprintf(zkErrStr, "Port map read timeout...exiting");
zk_error = true;
break;
} else {
sprintf(zkErrStr, "Waiting for port map");
SendEventMsg(MSG_SERVER_TRACE_INFO, EVENTLOG_INFORMATION_TYPE,
processId, ODBCMX_SERVER,
srvrObjRef, 1, zkErrStr);
DELAY(retryTimeout);
rc = zoo_exists(zh, dcsRegistered.c_str(), 0, &stat);
}
}
}
delete[] zkData;
}
initParam.portNumber = i;
stringstream newpath;
newpath.str("");
newpath << dcsRegistered.c_str() << "/" << regZnodeName;
// dcsRegisteredNode.str("");
// dcsRegisteredNode << dcsRegistered.c_str() << "/" << regZnodeName;
dcsRegisteredNode = newpath.str();
ss.str("");
ss << myPid;
string pid(ss.str());
ss.str("");
ss << "STARTING"
<< ":"
<< JULIANTIMESTAMP()
<< ":"
<< ":" // Dialogue ID
<< myNid
<< ":"
<< myPid
<< ":"
<< myProcName.c_str()
<< ":" // Server IP address
<< ":" // Server Port
<< ":" // Client computer name
<< ":" // Client address
<< ":" // Client port
<< ":" // Client Appl name
<< ":";
regSrvrData = ss.str();
rc = zoo_create(zh, dcsRegisteredNode.c_str(), regSrvrData.c_str(), regSrvrData.length(), &ZOO_OPEN_ACL_UNSAFE, ZOO_EPHEMERAL, realpath, sizeof(realpath)-1);
if( rc != ZOK )
{
zk_error = true;
sprintf(zkErrStr, "***** zoo_create() failed with error %d", rc);
break;
}
found = true;
}
else // error
{
zk_error = true;
sprintf(zkErrStr, "***** zoo_exists() for %s failed with error %d",dcsRegistered.c_str(), rc);
break;
}
}
}
if( zk_error ) {
SendEventMsg( MSG_SET_SRVR_CONTEXT_FAILED,
EVENTLOG_ERROR_TYPE,
processId,
ODBCMX_SERVER,
srvrObjRef,
1,
zkErrStr);
exit(1);
}
//LCOV_EXCL_START
// when a server dies, the MXOAS sends message to CFG. CFG creates the MXOSRVR process
// and passess only one command line atribute: -SQL CLEANUP OBSOLETE VOLATILE TABLES
// It is for cleanup resources (volatile tables).
// Newly created MXOSRVR process executes CLEANUP OBSOLETE VOLATILE TABLES and exits.
// (This process is not managed by AS!. It is only a helper.
if (initParam.sql != NULL)
{
if (strncmp(initParam.sql, "SELECT COUNT", 12) == 0)
{
//You can specify a completion code with any positive value in a PROCESS_STOP_.
//Negative completion codes are reserved for HP use.
//Therefore negative codes will return as 1000 + abs(completionCode)
short completionCode = -1;
completionCode = SQL_EXECDIRECT_FETCH(&initParam);
if (completionCode < 0)
completionCode = 1000 + abs(completionCode);
#ifdef NSK_PLATFORM
PROCESS_STOP_(,,,completionCode,,,,);
#else
/*
* TODO:
* need to revisit this logic to return a value via exit code
*
*/
#endif
}
else
{
int main(int argc, char *argv[]) {
enum { MAX_RETRIES = 100 };
enum { SLEEP_US = 1000 };
bool attach = false;
_xcc_status cc;
bool client = false;
int count;
int count_read;
int count_written;
bool dif = false;
double dloop;
double dms;
double dsec;
int err;
bool exec = false;
int ferr;
bool fin = false;
MS_Mon_Process_Info_Type info;
MS_Mon_Process_Info_Type *infop;
int inx;
int inx2;
int inx3;
short len;
short lerr;
short lerr2;
int loop = 10;
int max;
int nid;
pid_t pid;
int sargc;
ssize_t size;
int snid;
int spid;
bool startup = false;
xzsys_ddl_smsg_def *sys_msgp = (xzsys_ddl_smsg_def *) recv_buffer;
int sys_msg;
int sys_msg_count;
bool verbose = false;
TAD zargs[] = {
{ "-attach", TA_Bool, TA_NOMAX, &attach },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-dif", TA_Bool, TA_NOMAX, &dif },
{ "-exec", TA_Bool, TA_NOMAX, &exec },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxsp", TA_Int, TA_NOMAX, &maxsp },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-startup", TA_Bool, TA_NOMAX, &startup },
{ "-trace", TA_Bool, TA_NOMAX, &trace },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "-verbose", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
sprintf(fifo1, "%s-%s", FIFO1, getenv("USER"));
sprintf(fifo2, "%s-%s", FIFO2, getenv("USER"));
if (trace)
msg_init_trace();
if (exec)
return 0;
if (startup) {
err = fifo_open(fifo1, O_WRONLY);
assert(err != -1);
ffds[1] = err;
err = fifo_open(fifo2, O_RDONLY);
assert(err != -1);
ffds[0] = err;
if (trace)
trace_printf("cli: writing fifo\n");
size = write(ffds[1], recv_buffer, 1);
if (trace)
trace_printf("cli: fifo write, size=%d\n", (int) size);
assert(size == 1);
if (trace)
trace_printf("cli: fifo written\n");
close(ffds[1]);
return 0;
}
if (attach)
ferr = file_init_attach(&argc, &argv, false, NULL);
else
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
util_test_start(client);
ferr = msg_mon_process_startup(true); // system messages
util_check("msg_mon_process_startup", ferr);
ferr = msg_mon_get_my_process_name(procname, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
ferr = msg_mon_get_process_info(procname, &nid, &pid);
TEST_CHK_FEOK(ferr);
if (trace)
trace_printf("proc=%s, nid=%d, pid=%d\n", procname, nid, pid);
dloop = (double) loop;
for (inx = 0; inx < T_MAX; inx++)
t_elapsed[inx] = 0.0;
if (client) {
printf("loop=%d, maxsp=%d\n", loop, maxsp);
sargc = argc;
assert(sargc < MAX_ARGS);
for (inx2 = 0; inx2 < argc; inx2++) {
if (strcmp(argv[inx2], "-client") == 0)
sargv[inx2] = (char *) "-server";
else
sargv[inx2] = argv[inx2];
if (strcmp(argv[inx2], "-attach") == 0)
sargv[inx2] = (char *) "-server";
}
sargv[argc] = NULL;
sprintf(sprog, "%s/%s", getenv("PWD"), argv[0]);
time_start(T_TOTAL);
for (inx = 0; inx < loop; inx += maxsp) {
if (dif)
snid = -1;
else
snid = nid;
max = loop - inx;
if (max > maxsp)
max = maxsp;
for (inx2 = 0; inx2 < max; inx2++)
sname[inx2][0] = 0; // mon picks name
if (trace)
trace_printf("cli: newproc, inx=%d\n", inx);
time_start(T_NEWPROC);
for (inx2 = 0; inx2 < max; inx2++) {
ferr = msg_mon_start_process(sprog, // prog
sname[inx2], // name
sname[inx2], // ret_name
sargc, // argc
sargv, // argv
TPT_REF2(sphandle,inx2),// phandle
false, // open
&soid[inx2], // oid
MS_ProcessType_Generic, // type
0, // priority
false, // debug
false, // backup
&snid, // nid
&spid, // pid
NULL, // infile
NULL); // outfile
TEST_CHK_FEOK(ferr);
}
time_stop(T_NEWPROC);
time_elapsed(T_NEWPROC);
// wait here until processes are 'up'
// so that open timing is correct
inx3 = 0;
for (inx2 = 0; inx2 < max; inx2++) {
ferr = msg_mon_get_process_info_detail(sname[inx2], &info);
TEST_CHK_FEOK(ferr);
if (info.state != MS_Mon_State_Up) {
inx3++;
if (inx3 > MAX_RETRIES) {
printf("process %s did not enter 'UP' state\n", sname[inx2]);
assert(inx3 < MAX_RETRIES);
}
usleep(SLEEP_US);
inx2--;
continue;
} else
inx3 = 0;
}
if (trace)
trace_printf("cli: open, inx=%d\n", inx);
time_start(T_OPEN);
for (inx2 = 0; inx2 < max; inx2++) {
if (trace)
trace_printf("cli: opening inx=%d, name=%s\n", inx, sname[inx2]);
len = (short) strlen(sname[inx2]);
ferr = BFILE_OPEN_(sname[inx2], len, &sfilenum[inx2],
0, 0, 0,
0, 0, 0, 0);
if (trace)
trace_printf("cli: open, inx=%d, name=%s, ferr=%d\n",
inx, sname[inx2], ferr);
TEST_CHK_FEOK(ferr);
}
time_stop(T_OPEN);
time_elapsed(T_OPEN);
if (trace)
trace_printf("cli: procinfo, inx=%d\n", inx);
time_start(T_PROCINFO);
for (inx2 = 0; inx2 < max; inx2++) {
ferr = msg_mon_get_process_info_detail(sname[inx2], &info);
TEST_CHK_FEOK(ferr);
}
time_stop(T_PROCINFO);
time_elapsed(T_PROCINFO);
if (trace)
trace_printf("cli: procinfo-type, inx=%d\n", inx);
time_start(T_PROCINFO_TYPE);
ferr = msg_mon_get_process_info_type(MS_ProcessType_Generic,
&count,
MAX_SRV,
infotype);
TEST_CHK_FEOK(ferr);
time_stop(T_PROCINFO_TYPE);
time_elapsed(T_PROCINFO_TYPE);
if (verbose) {
for (inx2 = 0; inx2 < count; inx2++) {
infop = &infotype[inx2];
char s_em = infop->event_messages ? 'E' : '-';
char s_sm = infop->system_messages ? 'S' : '-';
char s_pr = infop->pending_replication ? 'R' : '-';
char s_pd = infop->pending_delete ? 'D' : '-';
char s_s = infop->state == MS_Mon_State_Up ? 'A' : 'U';
char s_o = infop->opened ? 'O' : '-';
char s_p = infop->paired ? 'P' : infop->backup ? 'B' : '-';
printf("%3.3d,%8.8d %3.3d %d %c%c%c%c%c%c%c %-11s %-11s %-15s\n",
infop->nid,
infop->pid,
infop->priority,
infop->state,
s_em, s_sm, s_pr, s_pd, s_s, s_o, s_p,
infop->process_name,
infop->parent_name,
infop->program);
}
}
if (trace)
trace_printf("cli: close, inx=%d\n", inx);
time_start(T_CLOSE);
for (inx2 = 0; inx2 < max; inx2++) {
ferr = BFILE_CLOSE_(sfilenum[inx2]);
TEST_CHK_FEOK(ferr);
}
time_stop(T_CLOSE);
time_elapsed(T_CLOSE);
// re-open/close
for (inx2 = 0; inx2 < max; inx2++) {
if (trace)
trace_printf("cli: re-opening inx=%d, name=%s\n",
inx, sname[inx2]);
len = (short) strlen(sname[inx2]);
ferr = BFILE_OPEN_(sname[inx2], len, &sfilenum[inx2],
0, 0, 0,
0, 0, 0, 0);
TEST_CHK_FEOK(ferr);
}
if (trace)
trace_printf("cli: re-close, inx=%d\n", inx);
for (inx2 = 0; inx2 < max; inx2++) {
ferr = BFILE_CLOSE_(sfilenum[inx2]);
TEST_CHK_FEOK(ferr);
}
if (trace)
trace_printf("cli: newproc-forkexec, inx=%d\n", inx);
sargc = 2;
sargv[0] = argv[0];
sargv[1] = (char *) "-exec";
if (trace)
sargv[sargc++] = (char *) "-trace";
sargv[sargc] = NULL;
time_start(T_FORKEXEC);
for (inx2 = 0; inx2 < max; inx2++) {
pid = fork();
assert(pid >= 0);
if (pid == 0) {
// child
err = execv(sprog, sargv);
assert(err == 0);
}
}
time_stop(T_FORKEXEC);
time_elapsed(T_FORKEXEC);
if (trace)
trace_printf("cli: newproc-forkexec-su, inx=%d\n", inx);
sargc = 2;
sargv[0] = argv[0];
sargv[1] = (char *) "-startup";
if (trace)
sargv[sargc++] = (char *) "-trace";
sargv[sargc] = NULL;
time_start(T_FORKEXEC_SU);
for (inx2 = 0; inx2 < max; inx2++) {
fifo_create(fifo1, fifo2);
pid = fork();
assert(pid >= 0);
if (pid > 0) {
// parent
err = fifo_open(fifo1, O_RDONLY);
assert(err != -1);
ffds[0] = err;
err = fifo_open(fifo2, O_WRONLY);
assert(err != -1);
ffds[1] = err;
if (trace)
trace_printf("cli: reading fifo, inx=%d\n", inx2);
size = ::read(ffds[0], recv_buffer, 1);
if (trace)
trace_printf("cli: fifo read, size=%d\n", (int) size);
assert(size == 1);
if (trace)
trace_printf("cli: fifo read, inx=%d\n", inx2);
::read(ffds[0], recv_buffer, 1);
err = fifo_close(ffds[0]);
assert(err == 0);
err = fifo_close(ffds[1]);
assert(err == 0);
fifo_destroy(fifo1, fifo1);
} else {
// child
err = execv(sprog, sargv);
assert(err == 0);
}
}
fifo_destroy(fifo2, fifo2);
time_stop(T_FORKEXEC_SU);
time_elapsed(T_FORKEXEC_SU);
}
} else {
sys_msg_count = 0;
time_start(T_TOTAL);
ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, 0,
1, 0); // sys msgs
TEST_CHK_FEOK(ferr);
for (inx = 0; !fin; inx++) {
if (trace)
trace_printf("srv: readupdate, inx=%d\n", inx);
cc = BREADUPDATEX(filenumr,
recv_buffer,
4,
&count_read,
0);
sys_msg = _xstatus_ne(cc);
if (trace && sys_msg)
trace_printf("srv: rcvd sys msg=%d\n",
sys_msgp->u_z_msg.z_msgnumber[0]);
if (sys_msg) {
sys_msg_count++;
inx--;
}
lerr2 = BFILE_GETINFO_(filenumr, &lerr);
TEST_CHK_FEIGNORE(lerr2);
if (trace)
trace_printf("srv: reply, inx=%d\n", inx);
cc = BREPLYX(recv_buffer,
(unsigned short) 0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
if (sys_msg_count >= 4)
fin = true;
}
}
time_stop(T_TOTAL);
time_elapsed(T_TOTAL);
if (client) {
dsec = time_sec(T_TOTAL);
dms = dsec * 1000.0;
printf("elapsed=%f\n", dms);
printf("open/close/newprocess/processinfo/forkexec=%d\n", loop);
dsec = time_sec(T_OPEN);
dms = dsec * 1000.0;
printf("open : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
dsec = time_sec(T_CLOSE);
dms = dsec * 1000.0;
printf("close : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
dsec = time_sec(T_PROCINFO);
dms = dsec * 1000.0;
printf("procinfo : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
dsec = time_sec(T_PROCINFO_TYPE);
dms = dsec * 1000.0;
printf("procinfo-type : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
dsec = time_sec(T_NEWPROC);
dms = dsec * 1000.0;
printf("newproc : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
dsec = time_sec(T_FORKEXEC);
dms = dsec * 1000.0;
printf("forkexec : total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
dsec = time_sec(T_FORKEXEC_SU);
dms = dsec * 1000.0;
printf("forkexec-startup: total-time=%f ms, time/loop=%f ms, ops/sec=%f\n",
dms, dms / dloop, dloop / dsec);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
SB_Export short XPROCESS_GETPAIRINFO_(SB_Phandle_Type *pp_phandle,
char *pp_pair,
short pv_maxlen,
short *pp_pair_length,
SB_Phandle_Type *pp_primary_phandle,
SB_Phandle_Type *pp_backup_phandle,
int *pp_search,
SB_Phandle_Type *pp_ancestor_phandle,
char *pp_node,
short pv_node_len,
short pv_options,
char *pp_ancestor_desc,
short pv_ancestor_desc_maxlen,
short *pp_ancestor_desc_len,
short *pp_error_detail) {
const char *WHERE = "XPROCESS_GETPAIRINFO_";
char la_name[MS_MON_MAX_PROCESS_NAME];
char *lp_name;
short *lp_phandles;
int lv_fserr;
short lv_param;
SB_Phandle_Type lv_phandle;
bool lv_phandle_null;
MS_Mon_Process_Info_Type lv_pi;
bool lv_pi_get;
bool lv_pi_ok;
short lv_ret;
int lv_status;
SB_API_CTR (lv_zctr, XPROCESS_GETPAIRINFO_);
lv_pi_get = true;
lv_pi_ok = false;
lp_phandles = reinterpret_cast<short *>(pp_phandle);
if ((pp_phandle == NULL) || (lp_phandles[0] == -1))
lv_phandle_null = true;
else
lv_phandle_null = false;
if (gv_ms_trace_params) {
char la_phandlet[MSG_UTIL_PHANDLE_LEN];
msg_util_format_phandle(la_phandlet, pp_phandle);
trace_where_printf(WHERE, "ENTER phandle=%s, pair=%p, maxlen=%d, pair-length=%p, p-phandle=%p, b-phandle=%p\n",
la_phandlet,
pfp(pp_pair),
pv_maxlen,
pfp(pp_pair_length),
pfp(pp_primary_phandle),
pfp(pp_backup_phandle));
trace_where_printf(WHERE, "search=%p(%d), a-phandle=%p, node=%p, nodelen=%d, options=%d, a-desc=%p, a-desc-maxlen=%d, a-desc-len=%p, err-detail=%p\n",
pfp(pp_search),
(pp_search != NULL) ? *pp_search : -1,
pfp(pp_ancestor_phandle),
pfp(pp_node),
pv_node_len,
pv_options,
pfp(pp_ancestor_desc),
pv_ancestor_desc_maxlen,
pfp(pp_ancestor_desc_len),
pfp(pp_error_detail));
}
if (!gv_ms_calls_ok) {
lv_ret = XPROC_INVSTATE;
return ms_err_rtn_msg(WHERE, "msg_init() not called or shutdown",
lv_ret);
}
lv_ret = XPROC_OK;
lv_fserr = XZFIL_ERR_OK;
if (pp_error_detail != NULL)
*pp_error_detail = 0;
// check 'legacy' parameters and reject
if ((pp_search != NULL) && (*pp_search != -1)) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_SEARCH;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "search (non -1) parameter unsupported", lv_ret);
}
if (pp_ancestor_phandle != NULL) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_ANCESTOR_PHANDLE;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "ancestor-phandle parameter unsupported", lv_ret);
}
if ((pp_node != NULL) && pv_node_len) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_NODE;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "node/len parameter unsupported", lv_ret);
}
if (pv_options) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_OPTIONS;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "options (non-zero) parameter unsupported", lv_ret);
}
if ((pp_ancestor_desc != NULL) && pv_ancestor_desc_maxlen) {
lv_ret = XPROC_PRM_UNSUP;
lv_param = PGPI_PARAM_ANCESTOR_DESC;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "ancestor-desc/maxlen parameter unsupported", lv_ret);
}
if (lv_phandle_null) {
// null phandle, check pair param
if (pp_pair_length == NULL) { // in
// use pair name to create phandle
if (pp_pair == NULL) {
lv_ret = XPROC_BNDS;
lv_param = PGPI_PARAM_PAIR;
if (pp_error_detail != NULL)
*pp_error_detail = lv_param;
return ms_err_rtn_msg(WHERE, "invalid pair", lv_ret);
}
if (gv_ms_trace_params)
trace_where_printf(WHERE, "pair=%s\n", pp_pair);
lp_name = la_name;
memcpy(la_name, pp_pair, sbmin(pv_maxlen, static_cast<int>(sizeof(la_name))));
if (pv_maxlen < static_cast<int>(sizeof(la_name)))
la_name[pv_maxlen] = '\0';
else
la_name[MS_MON_MAX_PROCESS_NAME-1] = '\0';
lv_pi_get = false;
lv_fserr = msg_mon_get_process_info_detail(la_name, &lv_pi);
if (lv_fserr == XZFIL_ERR_OK) {
ms_util_fill_phandle_name(&lv_phandle,
la_name,
lv_pi.nid,
lv_pi.pid
#ifdef SQ_PHANDLE_VERIFIER
,lv_pi.verifier
#endif
);
lv_pi_ok = true;
} else if (lv_fserr == XZFIL_ERR_NOTFOUND)
lv_ret = XPROC_NONEXTANT;
else
lv_ret = XPROC_NODEDOWN;
} else { // out
// use our phandle and return pair
lv_fserr = XPROCESSHANDLE_GETMINE_(&lv_phandle);
lp_name = ms_od_map_phandle_to_name(&lv_phandle);
if ((pp_pair != NULL) && (lv_fserr == XZFIL_ERR_OK)) {
*pp_pair_length = static_cast<short>(strlen(lp_name));
memcpy(pp_pair, lp_name, *pp_pair_length);
if (gv_ms_trace_params)
trace_where_printf(WHERE, "pair=%s\n", lp_name);
}
if (lv_fserr != XZFIL_ERR_OK)
lv_ret = XPROC_INVSTATE;
}
} else {
lp_name = ms_od_map_phandle_to_name(pp_phandle);
lv_pi_get = false;
lv_fserr = msg_mon_get_process_info_detail(lp_name, &lv_pi);
if (lv_fserr == XZFIL_ERR_OK) {
lv_pi_ok = true;
ms_util_fill_phandle_name(&lv_phandle,
lp_name,
lv_pi.nid,
lv_pi.pid
#ifdef SQ_PHANDLE_VERIFIER
,lv_pi.verifier
#endif
);
if (pp_pair_length != NULL) { // out
*pp_pair_length = static_cast<short>(strlen(lp_name));
memcpy(pp_pair, lp_name, *pp_pair_length);
if (gv_ms_trace_params)
trace_where_printf(WHERE, "pair=%s\n", lp_name);
}
} else if (lv_fserr == XZFIL_ERR_NOTFOUND)
lv_ret = XPROC_NONEXTANT;
else
lv_ret = XPROC_NODEDOWN;
}
// at this point, name pair should be setup
if (lv_fserr == XZFIL_ERR_OK) {
if (lv_pi_get)
lv_fserr = msg_mon_get_process_info_detail(lp_name, &lv_pi);
if (lv_fserr == XZFIL_ERR_OK) {
lv_pi_ok = true;
if (pp_primary_phandle != NULL) {
ms_util_fill_phandle_name(pp_primary_phandle,
lp_name,
!lv_pi.backup ? lv_pi.nid : lv_pi.parent_nid,
!lv_pi.backup ? lv_pi.pid : lv_pi.parent_pid
#ifdef SQ_PHANDLE_VERIFIER
,!lv_pi.backup ? lv_pi.verifier : lv_pi.parent_verifier
#endif
);
if (gv_ms_trace_params) {
char la_phandlet[MSG_UTIL_PHANDLE_LEN];
msg_util_format_phandle(la_phandlet, pp_primary_phandle);
trace_where_printf(WHERE, "p-phandle=%s\n", la_phandlet);
}
}
if (pp_backup_phandle != NULL) {
if (strcmp(lv_pi.parent_name, lv_pi.process_name) == 0)
ms_util_fill_phandle_name(pp_backup_phandle,
lp_name,
!lv_pi.backup ? lv_pi.parent_nid : lv_pi.nid,
!lv_pi.backup ? lv_pi.parent_pid : lv_pi.pid
#ifdef SQ_PHANDLE_VERIFIER
,!lv_pi.backup ? lv_pi.parent_verifier : lv_pi.verifier
#endif
);
else {
lv_status = XPROCESSHANDLE_NULLIT_(pp_backup_phandle);
CHK_FEIGNORE(lv_status);
}
if (gv_ms_trace_params) {
char la_phandlet[MSG_UTIL_PHANDLE_LEN];
msg_util_format_phandle(la_phandlet, pp_backup_phandle);
trace_where_printf(WHERE, "b-phandle=%s\n", la_phandlet);
}
}
} else if (lv_fserr == XZFIL_ERR_NOTFOUND)
lv_ret = XPROC_NONEXTANT;
else
lv_ret = XPROC_NODEDOWN;
}
if (lv_pi_ok) {
if (strcmp(lv_pi.parent_name, lv_pi.process_name) == 0) {
// process-pair
if (!lv_pi.backup) {
if ((lv_pi.nid == gv_ms_su_nid) &&
(lv_pi.pid == gv_ms_su_pid))
lv_ret = XPROC_PRIMARY;
else if ((lv_pi.parent_nid == gv_ms_su_nid) &&
(lv_pi.parent_pid == gv_ms_su_pid))
lv_ret = XPROC_BACKUP;
else
lv_ret = XPROC_OK; // not the calling process
} else {
if ((lv_pi.nid == gv_ms_su_nid) &&
(lv_pi.pid == gv_ms_su_pid))
lv_ret = XPROC_BACKUP;
else if ((lv_pi.parent_nid == gv_ms_su_nid) &&
(lv_pi.parent_pid == gv_ms_su_pid))
lv_ret = XPROC_PRIMARY;
else
lv_ret = XPROC_OK; // not the calling process
}
} else
lv_ret = XPROC_SINGLE;
}
return ms_err_rtn_msg_noassert(WHERE, "EXIT", lv_ret);
}
int main(int argc, char *argv[]) {
void *buf;
_xcc_status cc;
bool client = false;
unsigned short count_written;
unsigned short count_xferred;
int disable;
bool done;
int ferr;
short filenum1;
short filenum2;
int inx;
int loop = 10;
char my_name[BUFSIZ];
char my_pname[BUFSIZ];
int out;
MS_Mon_Process_Info_Type proc_info;
char recv_buffer[BUFSIZ];
char send_buffer[BUFSIZ];
int send_len;
SB_Tag_Type tag;
int timeout = -1;
short tfilenum;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = file_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, file_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
util_gethostname(my_name, (int) sizeof(my_name));
ferr = msg_mon_get_my_process_name(my_pname, sizeof(my_pname));
if (client) {
ferr = XFILE_OPEN_(srv1, (short) strlen(srv1), &filenum1,
0, 0, MAX_OUT, 0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_process_info_detail(srv1, &proc_info);
TEST_CHK_FEOK(ferr);
ferr = XFILE_OPEN_(srv2, (short) strlen(srv2), &filenum2,
0, 0, MAX_OUT, 0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
send_len = (int) strlen(send_buffer) + 1; // cast
if (verbose)
printf("client doing writereadx's to fn1\n");
for (out = 0; out < MAX_OUT; out++) {
cc = XWRITEREADX(filenum1,
send_buffer,
(ushort) send_len,
BUFSIZ,
&count_written,
0);
TEST_CHK_CCEQ(cc);
}
if (verbose)
printf("client doing writereadx's to fn2\n");
for (out = 0; out < MAX_OUT; out++) {
cc = XWRITEREADX(filenum2,
send_buffer,
(ushort) send_len,
BUFSIZ,
&count_written,
0);
TEST_CHK_CCEQ(cc);
}
if (verbose)
printf("client killing srv1 (pid=%d), closing fn1\n",
proc_info.os_pid);
kill(proc_info.os_pid, SIGTERM);
disable = msg_test_assert_disable();
ferr = XFILE_CLOSE_(filenum1);
TEST_CHK_FEIGNORE(ferr);
msg_test_assert_enable(disable);
if (verbose)
printf("client doing awaitios on fn1\n");
for (out = 0; out < MAX_OUT; out++) {
tfilenum = -2;
disable = msg_test_assert_disable();
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
msg_test_assert_enable(disable);
// can't check cc because of -2
if (_xstatus_eq(cc))
printf("%s\n", send_buffer);
}
if (verbose)
printf("client restarting srv1, reopening fn1\n");
restart_server(argc, argv);
ferr = XFILE_OPEN_(srv1, (short) strlen(srv1), &filenum1,
0, 0, MAX_OUT, 0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_process_info_detail(srv1, &proc_info);
}
if (verbose)
printf("client sending stop to srv1\n");
strcpy(send_buffer, "stop");
send_len = (int) strlen(send_buffer) + 1; // cast
cc = XWRITEREADX(filenum1,
send_buffer,
(ushort) send_len,
BUFSIZ,
&count_written,
0);
TEST_CHK_CCEQ(cc);
tfilenum = filenum1;
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
strcpy(send_buffer, "stop");
if (verbose)
printf("client sending stop to srv2\n");
cc = XWRITEREADX(filenum2,
send_buffer,
(ushort) send_len,
BUFSIZ,
&count_written,
0);
TEST_CHK_CCEQ(cc);
tfilenum = filenum2;
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
if (verbose)
printf("client finishing\n");
} else {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum1,
0, 0, 0,
1, 1, // no sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
do {
if (verbose)
printf("server-%s: doing readupdate\n", my_pname);
cc = XREADUPDATEX(filenum1,
recv_buffer,
BUFSIZ,
NULL,
0);
if (verbose)
printf("server-%s: readupdate done cc=%d\n", my_pname, cc);
TEST_CHK_CCEQ(cc);
util_time_sleep_ms(10);
done = (strcmp(recv_buffer, "stop") == 0);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
if (verbose)
printf("server-%s: doing reply, done=%d\n", my_pname, done);
cc = XREPLYX(NULL,
0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
assert(count_written == 0);
} while (!done);
ferr = XFILE_CLOSE_(filenum1, 0);
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
