int main(int argc, char *argv[]) {
int csize = 0;
int dinx;
int disable;
int dloop = 10;
int dsize = 1024;
int ferr;
TPT_DECL2 (phandle,MAX_SERVERS);
int inx;
int lerr;
int loop = 10;
int max;
int maxsp = 1;
int msgid;
int msgids[MAX_SERVERS];
bool nowait = false;
int oid;
int pinx;
RT results;
MS_SRE sre;
bool toomany = false;
bool verbose = false;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-csize", TA_Int, MAX_CBUF, &csize },
{ "-dloop", TA_Int, TA_NOMAX, &dloop },
{ "-dsize", TA_Int, MAX_DBUF, &dsize },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLIENTS, &maxcp },
{ "-maxsp", TA_Int, MAX_SERVERS, &maxsp },
{ "-nowait", TA_Bool, TA_NOMAX, &nowait },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-toomany", TA_Bool, TA_NOMAX, &toomany },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
ferr = msg_init(&argc, &argv);
TEST_CHK_FEOK(ferr);
msfs_util_init_fs(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
if (maxcp < 0)
maxcp = 1;
if (maxsp < 0)
maxsp = 1;
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (!client)
msg_mon_enable_mon_messages(true);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
TEST_CHK_FEOK(ferr);
// process-wait for clients/servers/shell
ferr = msfs_util_wait_process_count(MS_ProcessType_Generic,
maxcp + maxsp + 1,
NULL,
verbose);
TEST_CHK_FEOK(ferr);
sleep(3); // wait for all process_count's to complete
if (client) {
pinx = atoi(&my_name[4]);
assert(pinx >= 0);
printf("loop=%d\n", loop);
for (inx = 0; inx < loop; inx++) {
for (pinx = 0; pinx < maxsp; pinx++) {
sprintf(serv, "$srv%d", pinx);
if (toomany)
disable = msg_test_assert_disable();
else
disable = 0;
ferr = msg_mon_open_process(serv,
TPT_REF2(phandle,pinx),
&oid);
if (toomany) {
msg_test_assert_enable(disable);
if (ferr == XZFIL_ERR_TOOMANY) {
sleep(1);
pinx--;
continue;
}
}
TEST_CHK_FEOK(ferr);
}
for (pinx = 0; pinx < maxsp; pinx++) {
if (nowait) {
for (dinx = 0; dinx < dloop; dinx++) {
ferr = XMSG_LINK_(TPT_REF2(phandle,pinx), // phandle
&msgids[dinx], // msgid
send_buffer2, // reqctrl
(short) csize, // reqctrlsize
recv_buffer3, // replyctrl
(short) csize, // replyctrlmax
send_buffer, // reqdata
(short) dsize, // reqdatasize
recv_buffer, // replydata
(short) dsize, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
}
for (dinx = 0; dinx < dloop; dinx++) {
ferr = XMSG_BREAK_(msgids[dinx],
results.u.s,
TPT_REF2(phandle,pinx));
util_check("XMSG_BREAK_", ferr);
assert((int) results.u.t.ctrl_size == csize);
assert((int) results.u.t.data_size == dsize);
assert(results.u.t.errm == RT_DATA_RCVD); // data
}
} else {
for (dinx = 0; dinx < dloop; dinx++) {
ferr = XMSG_LINK_(TPT_REF2(phandle,pinx), // phandle
&msgid, // msgid
send_buffer2, // reqctrl
(short) csize, // reqctrlsize
recv_buffer3, // replyctrl
(short) csize, // replyctrlmax
send_buffer, // reqdata
(short) dsize, // reqdatasize
recv_buffer, // replydata
(short) dsize, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
ferr = XMSG_BREAK_(msgid,
results.u.s,
TPT_REF2(phandle,pinx));
util_check("XMSG_BREAK_", ferr);
assert((int) results.u.t.ctrl_size == csize);
assert((int) results.u.t.data_size == dsize);
assert(results.u.t.errm == RT_DATA_RCVD); // data
}
}
if (verbose)
printf("%s-open-count=%d\n", my_name, inx);
}
for (pinx = 0; pinx < maxsp; pinx++) {
ferr = msg_mon_close_process(TPT_REF2(phandle,pinx));
TEST_CHK_FEOK(ferr);
if (verbose)
printf("%s-close-count=%d\n", my_name, inx);
}
}
} else {
max = 2 * maxcp * loop + maxcp * dloop * loop;
for (inx = 0; inx < max; inx++) {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
recv_buffer2, // reqctrl
sre.sre_reqCtrlSize); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
sre.sre_reqDataSize); // bytecount
util_check("XMSG_READDATA_", ferr);
XMSG_REPLY_(sre.sre_msgId, // msgid
recv_buffer2, // replyctrl
sre.sre_reqCtrlSize, // replyctrlsize
recv_buffer, // replydata
sre.sre_reqDataSize, // replydatasize
0, // errorclass
NULL); // newphandle
if (verbose)
printf("%s-count=%d\n", my_name, inx);
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
int cycle;
int disable;
int ferr;
#ifndef USE_OPEN
int lnid;
int lpid;
#endif
int msgid;
char process_name[MS_MON_MAX_PROCESS_NAME];
char recvbuf[100];
MS_Result_Type results;
int retries;
int sendbuf[3];
ferr = msfs_util_init_role(true, &argc, &argv, msg_debug_hook);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(gdisplay_name, sizeof(gdisplay_name));
assert(ferr == XZFIL_ERR_OK);
myprintf("processing startup.\n");
util_test_start(true);
ferr = msg_mon_process_startup(true); // system messages
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_process_info(gdisplay_name, &gnid, &gpid);
TEST_CHK_FEOK(ferr);
strcpy(process_name, "$srv");
myprintf("opening server %s.\n", process_name);
#ifdef USE_OPEN
ferr = msg_mon_open_process(process_name, TPT_REF(gserver_phandle), &gserver_oid);
TEST_CHK_FEOK(ferr);
#else
gserver_phandlep = msg_get_phandle(process_name);
assert(gserver_phandlep != NULL);
#endif
// do the work
myprintf("Starting work with server\n");
disable = msg_test_assert_disable();
for (cycle = 0; cycle < MAX_CYCLES + 1; cycle++) {
sendbuf[0] = gpid;
sendbuf[1] = cycle;
switch (cycle) {
case 5:
sendbuf[2] = CMD_ABORT;
break;
case 6:
sendbuf[2] = CMD_CP_AB;
break;
case MAX_CYCLES:
sendbuf[2] = CMD_END;
break;
default:
sendbuf[2] = CMD_CONT;
}
retries = 5;
do {
myprintf("sending %d.%d.%d to server\n",
sendbuf[0], sendbuf[1], sendbuf[2]);
#ifdef USE_OPEN
ferr = XMSG_LINK_(TPT_REF(gserver_phandle), // phandle
#else
ferr = XPROCESSHANDLE_DECOMPOSE_(gserver_phandlep, &lnid, &lpid);
assert(ferr == XZFIL_ERR_OK);
printf("phandle nid=%d, pid=%d\n", lnid, lpid);
ferr = XMSG_LINK_(gserver_phandlep, // phandle
#endif
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
(char *) sendbuf, // reqdata
sizeof(sendbuf), // reqdatasize
recvbuf, // replydata
sizeof(recvbuf), // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
TEST_CHK_FEOK(ferr);
ferr = XMSG_BREAK_(msgid,
(short *) &results,
#ifdef USE_OPEN
TPT_REF(gserver_phandle));
#else
gserver_phandlep);
#endif
if (ferr == XZFIL_ERR_OK)
myprintf("Cycle # %d - %s\n", cycle, recvbuf);
else
myprintf("XMSG_BREAK_ error ferr=%d\n", ferr);
if (ferr != XZFIL_ERR_OK) {
retries--;
sleep(1);
if (retries <= 0) {
myprintf("retries exhausted\n");
assert(retries > 0);
}
myprintf("retrying\n");
} else
retries = 0;
} while (retries > 0);
}
msg_test_assert_enable(disable);
// close the server processes
myprintf("closing server %s.\n", process_name);
#ifdef USE_OPEN
ferr = msg_mon_close_process(TPT_REF(gserver_phandle));
#else
ferr = msg_mon_close_process(gserver_phandlep);
#endif
TEST_CHK_FEOK(ferr);
myprintf("sending exit process message.\n");
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(true);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int client_mon;
int cnid = -1;
bool commit_rcvd = false;
int cpid = -1;
int disable;
bool done = false;
int event_len;
int ferr;
int first;
int handle;
int inx;
int len;
int lerr;
int loop = 10;
int msgid;
int nid;
bool open_rcvd = false;
int orig_tag;
TPT_DECL2 (phandle,MAX_SERVERS);
int pid;
int pinx;
RT results;
int send_len;
MS_SRE sre;
int status;
bool sync = false;
bool threaded = false;
bool verbose = false;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-quiet", TA_Bool, TA_NOMAX, &quiet },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-sync", TA_Bool, TA_NOMAX, &sync },
{ "-threaded", TA_Bool, TA_NOMAX, &threaded },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
msfs_util_init(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
sleep(1); // wait for client to get into msg_mon_process_info
ferr = msg_mon_get_my_process_name(pname, sizeof(pname));
TEST_CHK_FEOK(ferr);
if (strcasecmp(pname, "$tm0") == 0)
tag = TAG0;
else if (strcasecmp(pname, "$tm1") == 0)
tag = TAG1;
else
tag = TAG2;
ferr = msg_mon_get_process_info(NULL, &snid, &spid);
TEST_CHK_FEOK(ferr);
if (client) {
char serv[BUFSIZ];
for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
sprintf(serv, "$tm%d", pinx);
ferr = msg_mon_open_process(serv, // name
TPT_REF2(phandle,pinx),
&oid[pinx]);
TEST_CHK_FEOK(ferr);
}
} else {
first = (strcasecmp(pname, "$tm0") == 0);
disable = msg_test_assert_disable();
ferr = msg_mon_tm_leader_set(&nid, &pid, lname);
msg_test_assert_enable(disable);
if (first) {
TEST_CHK_FEOK(ferr);
} else
assert(ferr != XZFIL_ERR_OK);
printf("leader is p-id=%d/%d, name=%s\n",
nid, pid, lname);
}
util_gethostname(my_name, sizeof(my_name));
msg_mon_enable_mon_messages(true);
if (!client) {
ferr = msg_mon_event_wait(1, &event_len, event_data);
util_check("msg_mon_event_wait", ferr);
ferr = msg_mon_tmsync_register(tmsync_cb);
util_check("msg_mon_tmsync_register", ferr);
if (sync) {
char serv[BUFSIZ];
for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
sprintf(serv, "$tm%d", pinx);
if (strcasecmp(serv, pname) != 0) {
ferr = msg_mon_open_process(serv, // name
TPT_REF2(phandle,pinx),
&oid[pinx]);
TEST_CHK_FEOK(ferr);
}
}
// at this point, we know everyone is registered
// if everyone isn't registered, there will be an abort
do_sync();
if (threaded)
do_sync_threaded();
}
}
if (client) {
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;
for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
if (verbose)
printf("%s: sending message, pinx=%d, inx=%d\n",
pname, pinx, inx);
ferr = XMSG_LINK_(TPT_REF2(phandle,pinx), // phandle
&msgid, // msgid
send_buffer2, // reqctrl
(ushort) (inx & 1), // reqctrlsize
recv_buffer3, // replyctrl
1, // replyctrlmax
send_buffer, // reqdata
(ushort) send_len, // reqdatasize
recv_buffer, // replydata
BUFSIZ, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF2(phandle,pinx));
util_check("XMSG_BREAK_", ferr);
assert(results.u.t.ctrl_size == (uint) (inx & 1));
assert(results.u.t.data_size > (strlen(send_buffer) + 14));
assert(results.u.t.errm == RT_DATA_RCVD); // data
if (!quiet)
printf("%s\n", recv_buffer);
}
}
for (pinx = 0; pinx < MAX_SERVERS; pinx++) {
ferr = msg_mon_close_process(TPT_REF2(phandle,pinx));
TEST_CHK_FEOK(ferr);
}
} else {
inx = 0;
while (!done) {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
for (;;) {
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
if (lerr == XSRETYPE_NOWORK)
break;
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
recv_buffer2, // reqctrl
1); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
BUFSIZ); // bytecount
util_check("XMSG_READDATA_", ferr);
if (sre.sre_flags & XSRE_MON) {
MS_Mon_Msg *msg = (MS_Mon_Msg *) recv_buffer;
if (cnid < 0) {
ferr = msg_mon_get_process_info((char *) "$cli", &cnid, &cpid);
if (ferr != XZFIL_ERR_OK) {
cnid = -1;
cpid = -1;
}
}
client_mon = true;
Item *item_hdl;
Item *item_tag;
const char *type;
switch (msg->type) {
case MS_MsgType_Close:
type = "close";
if ((cnid == msg->u.close.nid) &&
(cpid == msg->u.close.pid)) {
} else
client_mon = false;
break;
case MS_MsgType_NodeDown:
type = "node-down";
break;
case MS_MsgType_Open:
type = "open";
if ((cnid == msg->u.open.nid) &&
(cpid == msg->u.open.pid))
open_rcvd = true;
else
client_mon = false;
break;
case MS_MsgType_ProcessDeath:
type = "process-death";
break;
case MS_MsgType_Shutdown:
type = "shutdown";
done = true;
break;
case MS_MsgType_TmSyncAbort:
case MS_MsgType_TmSyncCommit:
if (msg->type == MS_MsgType_TmSyncAbort)
type = "tmsync-abort";
else
type = "tmsync-commit";
nid = msg->u.tmsync.nid[0];
handle = msg->u.tmsync.handle[0];
if (msg->u.tmsync.orig_count == 0) {
msg->u.tmsync.orig_tag[0] = -1;
msg->u.tmsync.orig_handle[0] = -1;
}
orig_tag = msg->u.tmsync.orig_tag[0];
if (!quiet) {
printf("server (%s) received (%s) mon message, type=%s(%d), nid=%d\n",
pname,
client_mon ? "cli" : "dtm",
type,
msg->type,
nid);
printf(" orig_count=%d, orig_tag=%d, orig_handle=%d, count=%d, handle[0]=%d\n",
msg->u.tmsync.orig_count,
orig_tag,
msg->u.tmsync.orig_handle[0],
msg->u.tmsync.count,
handle);
}
if (nid == snid) {
if (!quiet)
printf("server (%s) commit handle=%d, orig-count=%d\n",
pname, handle, msg->u.tmsync.orig_count);
for (int inx2 = 0;
inx2 < msg->u.tmsync.count;
inx2++) {
int ltag = msg->u.tmsync.orig_tag[inx2];
int lhandle = msg->u.tmsync.orig_handle[inx2];
if (!quiet)
printf("server (%s) commit orig-tag/handle=%d/%d\n",
pname, ltag, lhandle);
item_tag = (Item *) tag_issue_map.remove(ltag);
assert(item_tag != NULL);
delete item_tag;
item_hdl = (Item *) handle_issue_map.remove(lhandle);
assert(item_hdl != NULL);
delete item_hdl;
}
} else {
assert(msg->u.tmsync.orig_count == 0);
}
commit_rcvd = true;
break;
default:
type = "<unknown>";
}
if (!quiet)
printf("server (%s) received (%s) mon message, type=%s(%d)\n",
pname, client_mon ? "cli" : "dtm", type, msg->type);
len = 0;
} else {
inx++;
if (verbose)
printf("%s: received non-mon message, inx=%d\n",
pname, inx);
if (!sync)
assert(sync_rcvd);
assert(commit_rcvd);
assert(open_rcvd);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
strcat(recv_buffer, " - ");
strcat(recv_buffer, pname);
len = (int) strlen(recv_buffer) + 1;
}
XMSG_REPLY_(sre.sre_msgId, // msgid
recv_buffer2, // replyctrl
sre.sre_reqCtrlSize, // replyctrlsize
recv_buffer, // replydata
(ushort) len, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
assert(inx == loop);
assert(tag_issue_map.empty());
assert(handle_issue_map.empty());
// need to wait for shutdown to be started
ferr = msg_mon_event_wait(2, &event_len, event_data);
util_check("msg_mon_event_wait", ferr);
if (sync && threaded) {
sync_thr_shutdown = true;
for (int thr = 0; thr < MAX_THR; thr++) {
void *larg;
status = sync_thr[thr]->join(&larg);
TEST_CHK_STATUSOK(status);
}
}
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
int arg;
_xcc_status cc;
bool client = false;
unsigned short count_read;
unsigned short count_written;
bool death = false;
#ifdef SQ_PHANDLE_VERIFIER
int disable;
#endif
int ferr;
short filenumr;
short filenums;
#ifdef SQ_PHANDLE_VERIFIER
short filenums2;
#endif
int inxl;
short len;
#ifdef SQ_PHANDLE_VERIFIER
short len2;
#endif
int loop = 10;
int nid;
int pid;
char prog[MS_MON_MAX_PROCESS_PATH];
char retname[BUFSIZ];
char sname[10];
char sname_seq1[40];
#ifdef SQ_PHANDLE_VERIFIER
char sname_seq2[40];
#endif
int status;
bool verbose = false;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-death", TA_Bool, TA_NOMAX, &death },
{ "-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);
for (arg = 1; arg < argc; arg++) {
if (strcmp(argv[arg], "-client") == 0) // start_process
argv[arg] = (char *) "-server";
}
util_test_start(client);
if (death)
ferr = file_mon_process_startup(true); // system messages?
else
ferr = file_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
if (client) {
if (death) {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, 0,
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
}
strcpy(sname, "$srv");
if (verbose)
printf("client starting server %s\n", sname);
sprintf(prog, "%s/%s", getenv("PWD"), argv[0]);
nid = -1;
ferr =
msg_mon_start_process_nowait_cb(cb, // callback
prog, // prog
sname, // name
retname, // ret-name
argc, // argc
argv, // argv
MS_ProcessType_Generic,// ptype
0, // priority
false, // debug
false, // backup
0, // tag
&nid, // nid
&pid, // pid
NULL, // infile
NULL); // outfile
TEST_CHK_FEOK(ferr);
if (verbose)
printf("client waiting for server=%s start\n", sname);
status = cv.wait(true);
assert(status == 0);
#ifdef SQ_PHANDLE_VERIFIER
ferr = msg_mon_create_name_seq(sname,
srv_verifier,
sname_seq1,
(int) sizeof(sname_seq1));
TEST_CHK_FEOK(ferr);
ferr = msg_mon_create_name_seq(sname,
srv_verifier + 99,
sname_seq2,
(int) sizeof(sname_seq2));
TEST_CHK_FEOK(ferr);
#else
strcpy(sname_seq1, sname);
#endif
len = (short) strlen(sname_seq1);
if (verbose)
printf("client opening server %s\n", sname);
ferr = XFILE_OPEN_(sname_seq1, len, &filenums,
0, 0, 0, 0,
0,
0, 0, NULL);
TEST_CHK_FEOK(ferr);
#ifdef SQ_PHANDLE_VERIFIER
len2 = (short) strlen(sname_seq2);
disable = msg_test_assert_disable();
// make sure seq # is checked
ferr = XFILE_OPEN_(sname_seq2, len2, &filenums2,
0, 0, 0, 0,
0,
0, 0, NULL);
assert(ferr != XZFIL_ERR_OK);
msg_test_assert_enable(disable);
#endif
if (verbose)
printf("open filenums=%d\n", filenums);
for (inxl = 0; inxl < loop; inxl++) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inxl);
cc = XWRITEREADX(filenums,
send_buffer,
(unsigned short) (strlen(send_buffer) + 1), // cast
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
printf("%s\n", send_buffer);
}
disable = msg_test_assert_disable();
ferr = XFILE_CLOSE_(filenums, 0);
TEST_CHK_FEOK(ferr);
msg_test_assert_enable(disable);
if (death) {
sleep(2);
}
if (verbose)
printf("client calling shutdown\n");
} else {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, 0,
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
cc = XREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
0);
TEST_CHK_CCNE(cc);
count_read = 0;
cc = XREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
for (inxl = 0; inxl < loop; inxl++) {
cc = XREADUPDATEX(filenumr,
recv_buffer,
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
count_read = (unsigned short) (strlen(recv_buffer) + 1); // cast
cc = XREPLYX(recv_buffer,
count_read,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
if (death) {
sleep(1);
util_abort_core_free();
}
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int disable;
int ferr;
int inx;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
MS_SRE sre;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
msfs_util_init(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (client) {
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
}
util_gethostname(my_name, sizeof(my_name));
if (client) {
for (inx = 0; inx < loop; inx++) {
disable = msg_test_assert_disable();
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer, // reqdata
0, // reqdatasize
recv_buffer, // replydata
0, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
assert(ferr);
msg_test_assert_enable(disable);
}
} else {
msg_mon_enable_mon_messages(true);
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
0, // replydatasize
0, // errorclass
NULL); // newphandle
util_abort_core_free();
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
} else {
ferr = msg_mon_process_close();
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
//
// plugin - send msg to ms-ic
//
static void sb_pi_ic_send(MS_Mon_Node_Info_Entry_Type *pp_node,
MS_Mon_Process_Info_Type *pp_proc,
Sqstate_Pi_Info_Type *pp_info,
char *pp_title,
bool pv_title,
const char *pp_lib,
const char *pp_call,
char *pp_rsp,
int pv_rsplen,
int *pp_rsplen) {
char la_ctrl[200];
char *lp_data;
char *lp_p;
char la_rsp[MAX_RSP];
short *lp_ctrl;
short *lp_results;
char *lp_rsp;
int lv_clen;
int lv_disable;
int lv_dlen;
int lv_fserr;
int lv_inx;
int lv_len;
int lv_msgid;
int lv_oid;
bool lv_open;
MS_Result_Type lv_results;
int lv_rsplen;
pp_node = pp_node; // touch
if (pp_rsplen != NULL)
*pp_rsplen = 0;
lv_open = (strcmp(pp_proc->process_name, gp_pname) != 0);
gp_pname = pp_proc->process_name;
if (strcmp(pp_call, "ic_unload") == 0)
sprintf(la_ctrl, "unload" ":" ":" "all");
else
sprintf(la_ctrl, "call" ":" "%s" ":" "%s", pp_lib, pp_call);
lv_clen = static_cast<int>(strlen(la_ctrl)) + 1;
lv_dlen = 0;
for (lv_inx = 0; lv_inx < pp_info->ic_argc; lv_inx++)
lv_dlen += static_cast<int>(strlen(pp_info->ic_argv[lv_inx])) + 1;
if (lv_dlen > 0) {
lp_data = new char[lv_dlen];
lp_p = lp_data;
for (lv_inx = 0; lv_inx < pp_info->ic_argc; lv_inx++) {
lv_len = sprintf(lp_p, "%s", pp_info->ic_argv[lv_inx]);
lp_p += lv_len + 1;
}
} else
lp_data = NULL;
if (lv_open) {
if (gv_verbosev)
sb_pi_verb_printf("opening %s...\n", gp_pname);
if (gv_opened) {
gv_opened = false;
lv_fserr = msg_mon_close_process(&gv_phandle);
CHK_FEIGNORE(lv_fserr);
}
lv_disable = msg_test_assert_disable();
if (pp_info->self)
lv_fserr = msg_mon_open_process_self_ic(&gv_phandle, &lv_oid);
else
lv_fserr = msg_mon_open_process_ic(gp_pname, &gv_phandle, &lv_oid);
msg_test_assert_enable(lv_disable);
sb_pi_verb_ok(lv_fserr, "open");
} else
lv_fserr = XZFIL_ERR_OK;
if (lv_fserr != XZFIL_ERR_OK) {
sb_pi_verb_printf("ERROR: could not open %s, fserr=%d\n",
gp_pname,
lv_fserr);
} else {
lp_ctrl = reinterpret_cast<short *>(la_ctrl);
gv_opened = true;
if (gv_verbose)
sb_pi_verb_printf("linking %s, ctrl=%s...\n", gp_pname, la_ctrl);
lv_disable = msg_test_assert_disable();
if (pp_rsp == NULL) {
lp_rsp = la_rsp;
lv_rsplen = MAX_RSP;
} else {
lp_rsp = pp_rsp;
lv_rsplen = pv_rsplen;
}
lv_fserr = BMSG_LINK_(&gv_phandle, // phandle
&lv_msgid, // msgid
lp_ctrl, // reqctrl
lv_clen, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
lp_data, // reqdata
lv_dlen, // reqdatasize
lp_rsp, // replydata
lv_rsplen, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
BMSG_LINK_MSINTERCEPTOR); // linkopts
msg_test_assert_enable(lv_disable);
sb_pi_verb_ok(lv_fserr, "link");
if (lv_fserr != XZFIL_ERR_OK) {
sb_pi_printf("ERROR: error in link to %s, fserr=%d\n",
gp_pname, lv_fserr);
} else {
if (gv_verbosev)
sb_pi_verb_printf("breaking %s...\n", gp_pname);
lp_results = reinterpret_cast<short *>(&lv_results);
lv_disable = msg_test_assert_disable();
lv_fserr = BMSG_BREAK_(lv_msgid, lp_results, &gv_phandle);
msg_test_assert_enable(lv_disable);
sb_pi_verb_ok(lv_fserr, "break");
if (lv_fserr == XZFIL_ERR_OK) {
if (pp_rsp == NULL)
sb_pi_ic_call_print_rsp(pp_title,
pv_title,
la_rsp,
lv_results.rr_datasize);
else if (pp_rsplen != NULL)
*pp_rsplen = lv_results.rr_datasize;
} else {
sb_pi_printf("ERROR: error in break to %s, fserr=%d\n",
gp_pname, lv_fserr);
}
}
}
}
int main(int argc, char *argv[]) {
int arg;
char buf[BUFSIZ];
bool client = false;
int disable;
int ferr;
int inx;
int len;
int lerr;
int oid;
void *result;
MS_SRE sre;
int status;
SB_Thread::Thread *thr_send[MAX_THREADS];
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-threads", TA_Int, MAX_THREADS, &threads },
{ "-v", TA_Bool, TA_NOMAX, &verbose },
{ "", TA_End, TA_NOMAX, NULL }
};
msfs_util_init(&argc, &argv, msg_debug_hook);
gargc = &argc;
gargv = argv;
arg_proc_args(zargs, false, argc, argv);
for (arg = 1; arg < argc; arg++) {
if (strcmp(argv[arg], "-client") == 0) // start_process
argv[arg] = (char *) "-server"; // set to server for start-process
}
if (threads < 1)
threads = 1;
if (client)
strcpy(who, "client");
else
strcpy(who, "server");
util_test_start(client);
ferr = msg_mon_process_startup(true); // system messages?
TEST_CHK_FEOK(ferr);
if (client) {
if (verbose)
printf("%s - opening server\n", who);
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
}
util_gethostname(my_name, sizeof(my_name));
if (client) {
disable = msg_test_assert_disable();
for (inx = 0; inx < threads; inx++) {
sprintf(buf, "%d", inx);
thr_send[inx] = new SB_Thread::Thread(thread_send_fun, buf);
thr_send[inx]->start();
}
for (inx = 0; inx < threads; inx++) {
status = thr_send[inx]->join(&result);
TEST_CHK_STATUSOK(status);
delete thr_send[inx];
}
thread_send_fun(NULL);
msg_test_assert_enable(disable);
} else {
inx = 0;
for (;;) {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
inx++;
if (inx > 4)
util_abort_core_free(); // don't reply
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
NULL, // reqctrl
0); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
40000); // bytecount
util_check("XMSG_READDATA_", ferr);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
len = (int) strlen(recv_buffer) + 1;
len = len; // touch
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
39000, // replydatasize
0, // errorclass
NULL); // newphandle
if (sre.sre_reqDataSize == 0)
break;
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
bool client = false;
int disable;
int ferr;
int inx;
int len;
int lerr;
int loop = 10;
int msgid;
int oid;
TPT_DECL (phandle);
RT results;
MS_SRE sre;
TPT_DECL (xphandle);
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
setenv("MS_STREAMS_MAX", "10", 1);
msfs_util_init(&argc, &argv, msg_debug_hook);
arg_proc_args(zargs, false, argc, argv);
util_test_start(client);
ferr = msg_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (client) {
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(phandle),
&oid);
TEST_CHK_FEOK(ferr);
} else {
disable = msg_test_assert_disable();
for (inx = 0; inx < 20; inx++) {
ferr = msg_mon_open_process((char *) "$crap", // name
TPT_REF(xphandle),
&oid);
assert(ferr != XZFIL_ERR_OK);
}
msg_test_assert_enable(disable);
}
util_gethostname(my_name, sizeof(my_name));
for (inx = 0; inx < loop; inx++) {
if (client) {
sprintf(send_buffer, "hello, greetings from %s, inx=%d",
my_name, inx);
ferr = XMSG_LINK_(TPT_REF(phandle), // phandle
&msgid, // msgid
NULL, // reqctrl
0, // reqctrlsize
NULL, // replyctrl
0, // replyctrlmax
send_buffer, // reqdata
39000, // reqdatasize
recv_buffer, // replydata
40000, // replydatamax
0, // linkertag
0, // pri
0, // xmitclass
0); // linkopts
util_check("XMSG_LINK_", ferr);
ferr = XMSG_BREAK_(msgid, results.u.s, TPT_REF(phandle));
util_check("XMSG_BREAK_", ferr);
assert(results.u.t.ctrl_size == 0);
assert(results.u.t.errm == RT_DATA_RCVD); // data
printf("%s\n", recv_buffer);
} else {
do {
lerr = XWAIT(LREQ, -1);
TEST_CHK_WAITIGNORE(lerr);
lerr = XMSG_LISTEN_((short *) &sre, // sre
0, // listenopts
0); // listenertag
} while (lerr == XSRETYPE_NOWORK);
ferr = XMSG_READCTRL_(sre.sre_msgId, // msgid
NULL, // reqctrl
0); // bytecount
util_check("XMSG_READCTRL_", ferr);
ferr = XMSG_READDATA_(sre.sre_msgId, // msgid
recv_buffer, // reqdata
40000); // bytecount
util_check("XMSG_READDATA_", ferr);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
len = (int) strlen(recv_buffer) + 1;
len = len; // touch - not currently used
XMSG_REPLY_(sre.sre_msgId, // msgid
NULL, // replyctrl
0, // replyctrlsize
recv_buffer, // replydata
39000, // replydatasize
0, // errorclass
NULL); // newphandle
}
}
if (client) {
ferr = msg_mon_close_process(TPT_REF(phandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
int main(int argc, char *argv[]) {
void *buf;
_xcc_status cc;
bool client = false;
unsigned short count_read;
unsigned short count_written;
unsigned short count_xferred;
int disable;
int ferr;
short filenum;
int linx;
int loop = 1;
int maxopen1;
int maxopen2;
char my_name[BUFSIZ];
int ninx;
int oinx;
int rd;
int recvdepth = 1;
int rinx;
SB_Tag_Type tag;
short tfilenum;
int timeout = -1;
bool verbose = false;
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-recvdepth", TA_Int, MAXRCVDEPTH, &recvdepth },
{ "-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));
if (client) {
maxopen1 = (recvdepth + MAXNOWAIT - 1 ) / MAXNOWAIT;
maxopen2 = RDOVER / MAXNOWAIT;
if (verbose)
printf("client maxopen=%d, recvdepth=%d\n", maxopen1, recvdepth);
for (oinx = 0; oinx < maxopen1; oinx++) {
ferr = XFILE_OPEN_((char *) "$SRV", 8, &filenumc1[oinx],
0, 0, MAXNOWAIT, // nowait
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
}
for (oinx = 0; oinx < maxopen2; oinx++) {
ferr = XFILE_OPEN_((char *) "$SRV", 8, &filenumc2[oinx],
0, 0, MAXNOWAIT, // nowait
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
}
for (linx = 0; linx < loop; linx++) {
rd = 0;
for (oinx = 0; oinx < maxopen1; oinx++) {
for (ninx = 0; ninx < MAXNOWAIT; ninx++) {
if (verbose)
printf("client wr1, fnum=%d, linx=%d, oinx=%d, ninx=%d, rd=%d\n",
filenumc1[oinx], linx, oinx, ninx, rd);
sprintf(send_buffer1[oinx][ninx], "hello1, greetings from %s, oinx=%d, ninx=%d, rd=%d",
my_name, oinx, ninx, rd);
cc = XWRITEREADX(filenumc1[oinx],
send_buffer1[oinx][ninx],
(short) (strlen(send_buffer1[oinx][ninx]) + 1),
BUFSIZ,
&count_read,
rd);
TEST_CHK_CCEQ(cc);
rd++;
if (rd >= recvdepth)
break;
}
}
for (oinx = 0; oinx < maxopen2; oinx++) {
for (ninx = 0; ninx < MAXNOWAIT; ninx++) {
if (verbose)
printf("client wr2, fnum=%d, linx=%d, oinx=%d, ninx=%d, rd=%d\n",
filenumc2[oinx], linx, oinx, ninx, rd);
sprintf(send_buffer2[oinx][ninx], "hello2, greetings from %s, oinx=%d, ninx=%d, rd=%d",
my_name, oinx, ninx, rd);
cc = XWRITEREADX(filenumc2[oinx],
send_buffer2[oinx][ninx],
(short) (strlen(send_buffer2[oinx][ninx]) + 1),
BUFSIZ,
&count_read,
rd);
TEST_CHK_CCEQ(cc);
rd++;
if (rd >= (recvdepth + RDOVER))
break;
}
}
rd = 0;
for (oinx = 0; oinx < maxopen1; oinx++) {
for (ninx = 0; ninx < MAXNOWAIT; ninx++) {
tfilenum = filenumc1[oinx];
if (verbose)
printf("client awaitio1, fnum=%d, linx=%d, oinx=%d, ninx=%d, rd=%d\n",
tfilenum, linx, oinx, ninx, rd);
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
send_buffer1[oinx][ninx][count_xferred] = 0;
printf("%s\n", send_buffer1[oinx][ninx]);
rd++;
if (rd >= recvdepth)
break;
}
}
rinx = 0;
for (oinx = 0; oinx < maxopen2; oinx++) {
for (ninx = 0; ninx < MAXNOWAIT; ninx++) {
tfilenum = filenumc2[oinx];
if (verbose)
printf("client awaitio2, fnum=%d, linx=%d, oinx=%d, ninx=%d, rd=%d\n",
tfilenum, linx, oinx, ninx, rd);
disable = msg_test_assert_disable();
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
msg_test_assert_enable(disable);
msg_ok[rinx] = _xstatus_eq(cc);
if (msg_ok[rinx]) {
send_buffer2[oinx][ninx][count_xferred] = 0;
printf("%s\n", send_buffer2[oinx][ninx]);
} else if (verbose)
printf("client awaitio2-err\n");
rinx++;
rd++;
if (rd >= (recvdepth + RDOVER))
break;
}
}
//
// re-link any failures
//
rd = recvdepth;
rinx = 0;
for (oinx = 0; oinx < maxopen2; oinx++) {
for (ninx = 0; ninx < MAXNOWAIT; ninx++) {
if (msg_ok[rinx++])
continue;
tfilenum = filenumc2[oinx];
if (verbose)
printf("client wr3, fnum=%d, linx=%d, oinx=%d, ninx=%d, rd=%d\n",
filenumc2[oinx], linx, oinx, ninx, rd);
sprintf(send_buffer2[oinx][ninx], "hello3, greetings from %s, oinx=%d, ninx=%d, rd=%d",
my_name, oinx, ninx, rd);
cc = XWRITEREADX(tfilenum,
send_buffer2[oinx][ninx],
(short) (strlen(send_buffer2[oinx][ninx]) + 1),
BUFSIZ,
&count_read,
rd);
TEST_CHK_CCEQ(cc);
if (verbose)
printf("client awaitio3, fnum=%d, linx=%d, oinx=%d, ninx=%d, rd=%d\n",
tfilenum, linx, oinx, ninx, rd);
cc = XAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
send_buffer2[oinx][ninx][count_xferred] = 0;
printf("%s\n", send_buffer2[oinx][ninx]);
rd++;
if (rd >= (recvdepth + RDOVER))
break;
}
}
}
} else {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum,
0, 0, 0,
(short) recvdepth, 1, // no sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (linx = 0; linx < loop; linx++) {
for (rinx = 0; rinx < recvdepth; rinx++) {
if (verbose)
printf("server ru rinx=%d, rd=%d\n", rinx, rinx);
cc = XREADUPDATEX(filenum,
recv_buffer[rinx],
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
}
sleep(1); // force NOLCB
for (rinx = 0; rinx < recvdepth; rinx++) {
if (verbose)
printf("server reply rinx=%d, rd=%d\n", rinx, rinx);
strcat(recv_buffer[rinx], "- reply from ");
strcat(recv_buffer[rinx], my_name);
count_read = (unsigned short) (strlen(recv_buffer[rinx]) + 1); // cast
cc = XREPLYX(recv_buffer[rinx],
count_read,
&count_written,
(short) rinx,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
sleep(1); // delay
rd = recvdepth;
for (rinx = 0; rinx < RDOVER; rinx++) {
if (verbose)
printf("server ru (over) rinx=%d, rd=%d\n", rinx, rd);
cc = XREADUPDATEX(filenum,
recv_buffer[rinx],
BUFSIZ,
&count_read,
0);
TEST_CHK_CCEQ(cc);
if (verbose)
printf("server reply (over) rinx=%d, rd=%d\n", rinx, rd);
strcat(recv_buffer[rinx], "- reply from ");
strcat(recv_buffer[rinx], my_name);
count_read = (unsigned short) (strlen(recv_buffer[rinx]) + 1); // cast
cc = XREPLYX(recv_buffer[rinx],
count_read,
&count_written,
(short) 0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
rd++;
}
}
ferr = XFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEIGNORE(ferr);
util_test_finish(client);
return 0;
}
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;
}
