// ------------------------------------------------------------------------------
// DECOMPOSE
// ------------------------------------------------------------------------------
// Encapsulates the PROCESSHANDLE_DECOMPOSE_ request for the different supported
// platforms - NSK, WINNT, and LINUX
//
// After decomposing phandle, various phandle components can be extracted
// using accessor methods provided.
//
// If an error occurs, return the appropriate file system error
// ------------------------------------------------------------------------------
short NAProcessHandle::decompose()
{
Int32 err = 0;
char processName[PhandleStringLen];
processName[0] = '\0';
short processNameLen = 0;
err = XPROCESSHANDLE_DECOMPOSE_((SB_Phandle_Type *)&(this->phandle_)
,&this->cpu_
,&this->pin_
,(Int32 *) &this->nodeNumber_
,this->nodeName_
,NodeNameLen
,&this->nodeNameLen_
,processName
,PhandleStringLen
,&processNameLen
,(SB_Int64_Type *)&this->seqNum_
);
processName[processNameLen] = '\0';
#ifdef SQ_PHANDLE_VERIFIER
this->phandleStringLen_ = sprintf(this->phandleString_, "%s:%ld",
processName, this->seqNum_);
#else
this->phandleStringLen_ = strlen(processName);
strcpy(this->phandleString_, processName);
this->phandleString_[this->phandleStringLen_] = '\0';
#endif
return err;
}
int main(int argc, char *argv[]) {
bool chook = false;
int client = false;
int dinx;
int disable;
int ferr;
int inx;
char lname[10];
bool mq = false;
int oid;
void *res;
bool rnd = false;
int sleept;
int snid;
int spid;
int status;
TAD zargs[] = {
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-dloop", TA_Int, MAX_OUT, &gdloop },
{ "-dsize", TA_Int, TA_NOMAX, &gdsize },
{ "-ksleep", TA_Int, TA_NOMAX, &gksleep },
{ "-loop", TA_Int, TA_NOMAX, &gloop },
{ "-maxc", TA_Int, MAX_THR, &gmaxc },
{ "-maxs", TA_Int, MAX_THR, &gmaxs },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-nodecycle", TA_Bool, TA_NOMAX, &gnodecycle },
{ "-rnd", TA_Bool, TA_NOMAX, &rnd },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &gverbose },
{ "-vpp", TA_Bool, TA_NOMAX, &gverbosepp },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
if (client && chook)
test_debug_hook("c", "c");
msfs_util_init(&argc, &argv, msg_debug_hook);
util_test_start(client);
if (!client)
setup_sig();
ferr = msg_mon_process_startup(true); // system messages
TEST_CHK_FEOK(ferr);
gargc = argc; // after msg_init - it removes args
gargp = argv;
sprintf(gprog, "%s/%s", getenv("PWD"), argv[0]);
gvirtual = (getenv("SQ_VIRTUAL_NODES") != NULL);
ferr = msg_mon_get_my_process_name(gname, sizeof(gname));
assert(ferr == XZFIL_ERR_OK);
if (client) {
msg_mon_enable_mon_messages(true); // get mon messages
ferr = msg_mon_get_process_info(NULL, &gcnid, NULL);
assert(ferr == XZFIL_ERR_OK);
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
(short) (gmaxc * gdloop));
assert(ferr == XZFIL_ERR_OK);
srand(1);
sleept = 1000;
start_server(argc, argv);
sleep(1);
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(gphandle),
&oid);
TEST_CHK_FEOK(ferr);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(gphandle), &snid, &spid);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < gloop; inx++) {
if (mq)
printf("client: inx=%d\n", inx);
for (dinx = 0; dinx < gmaxc; dinx++) {
sprintf(lname, "c%d", dinx);
gthrc[dinx] = new MyThread(client_thr, lname, dinx);
}
disable = msg_test_assert_disable();
for (dinx = 0; dinx < gmaxc; dinx++)
gthrc[dinx]->start();
if (rnd)
sleept = (int) ((float) gksleep * (rand_r(&gseed) / (RAND_MAX + 1.0)));
usleep(sleept);
for (dinx = 0; dinx < gmaxc; dinx++) {
status = gthrc[dinx]->join(&res);
TEST_CHK_STATUSOK(status);
if (gverbose)
printf("joined with client %d\n", dinx);
}
for (dinx = 0; dinx < gmaxc; dinx++)
delete gthrc[dinx];
msg_test_assert_enable(disable);
}
} else {
msg_mon_enable_mon_messages(true); // get mon messages
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
pp_init();
if (!gshutdown) {
for (dinx = 0; dinx < gmaxs; dinx++) {
char lname[10];
sprintf(lname, "s%d", dinx);
gthrs[dinx] = new SB_Thread::Thread(server_thr, lname);
}
for (dinx = 0; dinx < gmaxs; dinx++)
gthrs[dinx]->start();
for (dinx = 0; dinx < gmaxs; dinx++) {
status = gthrs[dinx]->join(&res);
TEST_CHK_STATUSOK(status);
if (gverbose)
printf("joined with server %d\n", dinx);
}
}
if (gverbosepp)
pp_printf("exit pid=%d\n", getpid());
}
if (client) {
sleep(1);
ferr = msg_mon_close_process(TPT_REF(gphandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
void pp_pairinfo(bool pri) {
TPT_DECL (bphandle);
short ferr;
static bool init = true;
int nid;
char pair[MS_MON_MAX_PROCESS_NAME+1];
short pair_length;
static TPT_DECL (phandle);
TPT_DECL (pphandle);
int pid;
if (init) {
ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(phandle));
myassert(ferr == XZFIL_ERR_OK);
init = false;
}
ferr = XPROCESS_GETPAIRINFO_(TPT_REF(phandle), // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
&pair_length,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
pair[pair_length] = 0;
myassert(strcmp(pair, "$SRV") == 0);
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESS_GETPAIRINFO_(TPT_REF(phandle), // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
NULL,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESS_GETPAIRINFO_(NULL, // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
NULL,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESS_GETPAIRINFO_(NULL, // phandle
pair,
MS_MON_MAX_PROCESS_NAME+1, // maxlen
&pair_length,
TPT_REF(pphandle), // primary_phandle
TPT_REF(bphandle)); // backup_phandle
if (pri)
myassert(ferr == XPROC_PRIMARY); // caller is primary
else
myassert(ferr == XPROC_BACKUP); // caller is backup
myassert(strcmp(pair, "$SRV") == 0);
myassert(XPROCESSHANDLE_COMPARE_(TPT_REF(pphandle),
TPT_REF(bphandle)) == 1);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(pphandle), &nid, &pid);
myassert(ferr == XZFIL_ERR_OK);
if (pri) {
myassert(nid == gnid);
myassert(pid == gpid);
} else {
myassert(nid == gpeer_nid);
myassert(pid == gpeer_pid);
}
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(bphandle), &nid, &pid);
myassert(ferr == XZFIL_ERR_OK);
if (pri) {
myassert(nid == gpeer_nid);
myassert(pid == gpeer_pid);
} else {
myassert(nid == gnid);
myassert(pid == gpid);
}
}
int main(int argc, char *argv[]) {
bool bidir = false;
bool bm = false;
void *buf;
double busy;
_xcc_status cc;
int count_read;
int count_written;
int count_xferred;
int dsize = 1024;
int ferr;
short filenum[MAX_SERVERS];
short filenumr;
int inx;
int loop = 10;
int max;
int maxsp = 1;
bool mq = false;
bool nocopy = false;
bool nowaitc = false;
bool nowaits = false;
int pinx;
struct rusage r_start;
struct rusage r_stop;
char *recv_buffer_ptr;
RI_Type ri;
short sender_len;
int sys_msg;
struct timeval t_elapsed_data;
struct timeval t_elapsed_open;
struct timeval t_elapsed_total;
struct timeval t_start_data;
struct timeval t_start_total;
struct timeval t_stop;
SB_Tag_Type tag;
short tfilenum;
int timeout = -1;
bool verbose = false;
TAD zargs[] = {
{ "-bidir", TA_Bool, TA_NOMAX, &bidir },
{ "-bm", TA_Bool, TA_NOMAX, &bm },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-dsize", TA_Int, MAX_DBUF, &dsize },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-maxcp", TA_Int, MAX_CLIENTS, &maxcp },
{ "-maxsp", TA_Int, MAX_SERVERS, &maxsp },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-nocopy", TA_Bool, TA_NOMAX, &nocopy },
{ "-nowaitc", TA_Bool, TA_NOMAX, &nowaitc },
{ "-nowaits", TA_Bool, TA_NOMAX, &nowaits },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "", TA_End, TA_NOMAX, NULL }
};
for (inx = 0; inx < MAX_CLIENTS; inx++)
account[inx] = 0;
signal(SIGUSR2, printaccount);
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);
if (maxcp < 0)
maxcp = 1;
if (maxsp < 0)
maxsp = 1;
util_test_start(client);
ferr = file_mon_process_startup(!client); // system messages?
TEST_CHK_FEOK(ferr);
if (nocopy) {
ferr = file_buf_register(buf_alloc, buf_free);
TEST_CHK_FEOK(ferr);
}
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);
if (client)
sleep(1);
util_time_timer_start(&t_start_total);
if (client) {
inx = atoi(&my_name[4]);
printf("dsize=%d, loop=%d\n", dsize, loop);
for (pinx = 0; pinx < maxsp; pinx++) {
sprintf(serv, "$srv%d", pinx);
ferr = BFILE_OPEN_(serv, (short) strlen(serv), &filenum[pinx],
0, 0, nowaitc ? (short) 1 : (short) 0,
0, 0, 0, 0, NULL);
TEST_CHK_FEOK(ferr);
}
util_time_timer_start(&t_start_data);
util_cpu_timer_start(&r_start);
util_time_elapsed(&t_start_total, &t_start_data, &t_elapsed_open);
max = loop;
for (inx = 0; inx < max; inx++) {
for (pinx = 0; pinx < maxsp; pinx++) {
if (pinx == 0) {
if (verbose)
printf("%s-count=%d\n", my_name, inx);
else if (mq && ((inx % 1000) == 0))
printf("%s-count=%d\n", my_name, inx);
}
cc = BWRITEREADX(filenum[pinx],
send_buffer,
(int) dsize, // cast
bidir ? dsize : 0,
&count_read,
0);
}
for (pinx = 0; pinx < maxsp; pinx++) {
if (nowaitc) {
TEST_CHK_CCEQ(cc);
tfilenum = filenum[pinx];
cc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
TEST_CHK_CCEQ(cc);
}
}
}
} else {
ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr,
0, 0, nowaits ? (short) 1 : (short) 0, // nowait
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
util_time_timer_start(&t_start_data);
util_cpu_timer_start(&r_start);
max = maxcp * loop;
for (inx = 0; inx < max; inx++) {
if (nocopy) {
cc = file_buf_readupdatex(filenumr,
&recv_buffer_ptr,
&count_read,
0);
buf_free(recv_buffer_ptr);
} else
cc = BREADUPDATEX(filenumr,
recv_buffer,
(int) dsize, // cast
&count_read,
0);
if (nowaits) {
tfilenum = -1;
cc = BAWAITIOX(&tfilenum,
&buf,
&count_xferred,
&tag,
timeout,
NULL);
// don't check cc - could be sys msg
sys_msg = _xstatus_ne(cc);
} else
sys_msg = _xstatus_ne(cc);
if (sys_msg)
inx--;
if (!sys_msg) {
getri(&ri);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(ri.sender),
NULL, // cpu
NULL, // pin
NULL, // nodenumber
NULL, // nodename
0, // nodename
NULL, // nodename_length
sender,
sizeof(sender),
&sender_len,
NULL); // sequence_number
TEST_CHK_FEOK(ferr);
sender[sender_len] = 0;
if (verbose)
printf("sender=%s\n", sender);
char *p = &sender[4]; // past $cli
int sender_inx = atoi(p);
account[sender_inx]++;
}
cc = BREPLYX(recv_buffer,
bidir ? dsize : 0,
&count_written,
0,
XZFIL_ERR_OK);
TEST_CHK_CCEQ(cc);
}
}
util_cpu_timer_stop(&r_stop);
util_time_timer_stop(&t_stop);
util_time_elapsed(&t_start_total, &t_stop, &t_elapsed_total);
util_time_elapsed(&t_start_data, &t_stop, &t_elapsed_data);
util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed_data, &busy);
if (client) {
if (!bm) {
print_elapsed("", &t_elapsed_total);
print_elapsed(" (data)", &t_elapsed_data);
print_elapsed(" (open)", &t_elapsed_open);
}
print_rate(bm, "", bidir ? 2 * loop : loop, dsize, &t_elapsed_data, busy);
} else
print_server_busy(bm, "", busy);
if (client) {
for (pinx = 0; pinx < maxsp; pinx++) {
ferr = BFILE_CLOSE_(filenum[pinx], 0);
TEST_CHK_FEOK(ferr);
}
} else {
ferr = BFILE_CLOSE_(filenumr, 0);
TEST_CHK_FEOK(ferr);
ferr = file_mon_process_close();
TEST_CHK_FEOK(ferr);
}
ferr = file_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
printaccount(0);
return 0;
}
int main(int argc, char *argv[]) {
_bcc_status bcc;
bool client = false;
int count_read;
int count_written;
int disable;
int err;
short error_reply;
int ferr;
short filenum;
int inx;
short lasterr;
int loop = 10;
int msgnum;
bool open = false;
short sender_len;
xzsys_ddl_smsg_def *sys_msg = (xzsys_ddl_smsg_def *) recv_buffer;
RI_Type ri;
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 }
};
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(true);
ferr = msg_mon_process_startup(!client); // system messages
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
TEST_CHK_FEOK(ferr);
ferr = msg_mon_get_process_info(NULL, &my_nid, &my_pid);
TEST_CHK_FEOK(ferr);
if (client) {
printf("client name=%s, nid=%d, pid=%d\n",
my_name, my_nid, my_pid);
start_server(argc, argv);
server_name_len = (short) strlen(server_name);
ferr = BFILE_OPEN_((char *) server_name, server_name_len, &filenum,
0, 0, 0, 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);
disable = msg_test_assert_disable();
bcc = BWRITEREADX(filenum,
send_buffer,
(int) (strlen(send_buffer) + 1), // cast
BUFSIZ,
&count_read,
0);
msg_test_assert_enable(disable);
if (_bstatus_eq(bcc))
printf("%s\n", send_buffer);
else {
ferr = XFILE_GETINFO_(-1, &lasterr, NULL, 0, NULL, NULL, NULL);
printf("WRITEREAD error=%d\n", lasterr);
}
kill(server_pid, SIGKILL);
for (;;) {
err = kill(server_pid, 0);
if ((err == -1) && (errno == ESRCH))
break;
usleep(10000);
}
start_server(argc, argv);
}
kill(server_pid, SIGKILL);
for (;;) {
err = kill(server_pid, 0);
if ((err == -1) && (errno == ESRCH))
break;
usleep(10000);
}
ferr = BFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
} else {
printf("server name=%s, nid=%d, pid=%d\n",
my_name, my_nid, my_pid);
ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenum,
0, 0, 0,
1, 0, // sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
bcc = BREADUPDATEX(filenum,
recv_buffer,
BUFSIZ,
&count_read,
0);
getri(&ri);
printri(&ri);
sender_len = 0;
sender_nid = -1;
sender_pid = -1;
disable = msg_test_assert_disable(); // errors are ok
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(ri.sender),
&sender_nid, // cpu
&sender_pid, // pin
NULL, // nodenumber
NULL, // nodename
0, // nodename
NULL, // nodename_length
sender,
sizeof(sender),
&sender_len,
NULL); // sequence_number
TEST_CHK_FEIGNORE(ferr);
msg_test_assert_enable(disable);
sender[sender_len] = 0;
printf("sender=%s, nid=%d, pid=%d\n",
sender, sender_nid, sender_pid);
error_reply = XZFIL_ERR_OK;
if (_bstatus_eq(bcc)) {
if (open) {
assert(sender_nid == open_sender_nid);
assert(sender_pid == open_sender_pid);
assert(strcmp(sender, open_sender) == 0);
assert(ri.file_number == open_sender_file_number);
strcat(recv_buffer, "- reply from ");
strcat(recv_buffer, my_name);
count_read = (int) (strlen(recv_buffer) + 1); // cast
} else {
printf("server not opened by client - returning WRONGID\n");
error_reply = XZFIL_ERR_WRONGID;
}
} else {
msgnum = sys_msg->u_z_msg.z_msgnumber[0];
switch (msgnum) {
case XZSYS_VAL_SMSG_OPEN:
printf("msgnum=%d (open)\n", msgnum);
assert(!open);
TPT_COPY_INT(TPT_REF(open_sender_phandle), ri.sender);
strcpy(open_sender, sender);
open_sender_nid = sender_nid;
open_sender_pid = sender_pid;
open_sender_file_number = ri.file_number;
open = true;
break;
case XZSYS_VAL_SMSG_CLOSE:
printf("msgnum=%d (close)\n", msgnum);
assert(open);
open = false;
break;
case XZSYS_VAL_SMSG_SHUTDOWN:
printf("msgnum=%d (shutdown)\n", msgnum);
inx = loop; // exit
break;
default:
printf("unexpected msgnum=%d\n", msgnum);
abort();
}
count_read = 0;
inx--;
}
bcc = BREPLYX(recv_buffer,
count_read,
&count_written,
0,
error_reply);
TEST_CHK_BCCEQ(bcc);
}
ferr = XFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(true);
printf("if there were no asserts, all is well\n");
return 0;
}
int main(int argc, char *argv[]) {
_xcc_status cc;
bool client = false;
unsigned short count_read;
int count_read_b;
unsigned short count_written;
TCPU_DECL (cpu);
int ferr;
short filenum;
int inx;
int loop = 10;
TPT_DECL (mphandle);
char *mphandlec = (char *) &mphandle;
TPT_DECL_INT (mphandlei);
int nid;
char nodename[20];
short nodename_length;
int nodenumber;
int pid;
TPIN_DECL (pin);
char procname[40];
short procname_length;
SB_Int64_Type sequence_number;
const char *sname = "$srv";
TAD zargs[] = {
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-loop", TA_Int, TA_NOMAX, &loop },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-sname", TA_Str, TA_NOMAX, &sname },
{ "", 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);
ferr = msg_mon_get_my_process_name(my_name, BUFSIZ);
util_check("msg_mon_get_my_process_name", ferr);
ferr = msg_mon_get_process_info(my_name, &nid, &pid);
TEST_CHK_FEOK(ferr);
ferr = XPROCESSHANDLE_GETMINE_(TPT_REF(mphandle));
util_check("XPROCESSHANDLE_GETMINE_", ferr);
TPT_COPY_INT(mphandlei, mphandle);
assert((mphandlei[0] & 0xf0) == 0x20); // named
assert(strncmp(my_name, &mphandlec[4], 32) == 0);
printf("phandle=%x.%x.%x.%x.%x, pname=%s\n",
mphandlei[0], mphandlei[1], mphandlei[2], mphandlei[3], mphandlei[4],
my_name);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(mphandle),
&cpu,
&pin,
&nodenumber,
nodename,
sizeof(nodename),
&nodename_length,
procname,
sizeof(procname),
&procname_length,
&sequence_number);
assert(cpu == nid);
assert(pin == pid);
assert(nodenumber == 0);
assert(nodename_length == 4);
nodename[nodename_length] = 0;
assert(strcmp(nodename, "\\NSK") == 0);
procname[procname_length] = 0;
assert(strcmp(procname, my_name) == 0);
#ifdef SQ_PHANDLE_VERIFIER
assert(sequence_number != 0);
#else
assert(sequence_number == 0);
#endif
if (client) {
ferr = XFILE_OPEN_((char *) sname, 4, &filenum,
0, 0, 0, 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);
if ((inx & 1) == 0)
cc = XWRITEREADX2(filenum,
send_buffer,
(unsigned short) (strlen(send_buffer) + 1), // cast
recv_buffer,
BUFSIZ,
&count_read,
0);
else
cc = BWRITEREADX2(filenum,
send_buffer,
(unsigned short) (strlen(send_buffer) + 1), // cast
recv_buffer,
BUFSIZ,
&count_read_b,
0);
TEST_CHK_CCEQ(cc);
printf("%s\n", recv_buffer);
}
ferr = XFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
} else {
ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenum,
0, 0, 0,
1, 1, // no sys msg
0, 0, NULL);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < loop; inx++) {
cc = XREADUPDATEX(filenum,
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);
}
ferr = XFILE_CLOSE_(filenum, 0);
TEST_CHK_FEOK(ferr);
}
ferr = file_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;
}
Int32 SQLMXLoggingArea::logSQLMXEventForError( ULng32 sqlcode,
const char* experienceLevel,
const char* severityLevel,
const char* eventTarget,
const char *msgTxt,
const char* sqlId,
const Lng32 Int0,
const Lng32 Int1,
const Lng32 Int2,
const Lng32 Int3,
const Lng32 Int4,
const char *String0,
const char * String1,
const char * String2,
const char * String3,
const char * String4,
const char * serverName,
const char * connectionName,
const char * constraintCatalog,
const char * constraintSchema,
const char * constraintName,
const char * triggerCatalog,
const char * triggerSchema,
const char *triggerName,
const char *catalogName,
const char *schemaName,
const char *tableName,
const char *columnName,
const Int64 currTransid,
const Lng32 rowNumber,
const Lng32 platformCode,
NABoolean isWarning
)
{
Int32 rc = 0;
// sealog logging of sql error events
// declare a event stack variable and populate
#ifndef SP_DIS
bool lockedMutex = lockMutex();
sql::error_event sql_error_event;
Int32 qpidNodePort = atoi(getenv("QPID_NODE_PORT"));
common::event_header * eventHeader = sql_error_event.mutable_header();
common::info_header * infoHeader = eventHeader->mutable_header();
if (!SQLMXLoggingArea::establishedAMQPConnection())
{
rc = createAMQPConnection(NULL,-1);
if (rc)
{
if (lockedMutex)
unlockMutex();
return rc;
}
establishedAMQPConnection_ = TRUE;
}
char eventidStr[10]=" ";
Lng32 eventidLen = 0;
str_sprintf(eventidStr,"10%d%06d",SQEVL_SQL,sqlcode);
str_strip_blanks(eventidStr,eventidLen);
Lng32 eventIdVal = (Lng32)str_atoi(eventidStr,eventidLen);
sql_error_event.mutable_header()->set_event_id(eventIdVal);
sql_error_event.mutable_header()->set_event_severity(sqlToSLSeverity(severityLevel, isWarning));
sql_error_event.set_sqlcode(sqlcode);
if (sqlId)
sql_error_event.set_sqlid(sqlId);
else
{
SB_Phandle_Type myphandle;
XPROCESSHANDLE_GETMINE_(&myphandle);
char charProcHandle[200];
char myprocname[30];
Int32 mycpu,mypin,mynodenumber=0;
short myproclength = 0;
XPROCESSHANDLE_DECOMPOSE_(&myphandle, &mycpu, &mypin, &mynodenumber,NULL,100, NULL, myprocname,100, &myproclength);
myprocname[myproclength] = '\0';
str_sprintf(charProcHandle,"%d,%d,%d,%s",mycpu,mypin,mynodenumber,myprocname);
sql_error_event.set_sqlid(charProcHandle);
}
sql_error_event.set_message_text(msgTxt);
sql_error_event.set_err_experience_level(experienceLevel);
sql_error_event.set_err_target(eventTarget);
sql_error_event.set_int0(Int0);
sql_error_event.set_int1(Int1);
sql_error_event.set_int2(Int2);
sql_error_event.set_int3(Int3);
sql_error_event.set_int4(Int4);
if (String0)
sql_error_event.set_string0(String0);
if (String1)
sql_error_event.set_string1(String1);
if (String2)
sql_error_event.set_string2(String2);
if (String3)
sql_error_event.set_string3(String3);
if (String4)
sql_error_event.set_string4(String4);
//LCOV_EXCL_START - unused members of diags are
if (serverName)
sql_error_event.set_server_name(serverName);
if (connectionName)
sql_error_event.set_connection_name(connectionName);
//LCOV_EXCL_STOP
if (constraintCatalog)
sql_error_event.set_constraint_catalog(constraintCatalog);
if (constraintSchema)
sql_error_event.set_constraint_schema(constraintSchema);
if (constraintName)
sql_error_event.set_constraint_name(constraintName);
if (triggerCatalog)
sql_error_event.set_trigger_catalog(triggerCatalog);
if (triggerSchema)
sql_error_event.set_trigger_schema(triggerSchema);
if (triggerName)
sql_error_event.set_trigger_name(triggerName);
if (catalogName)
sql_error_event.set_catalog_name(catalogName);
if (schemaName)
sql_error_event.set_schema_name(schemaName);
if (tableName)
sql_error_event.set_table_name(tableName);
if (columnName)
sql_error_event.set_column_name(columnName);
sql_error_event.set_current_transid(currTransid);
sql_error_event.set_row_number(rowNumber);
sql_error_event.set_platform_error_code(platformCode);
rc = initAMQPInfoHeader(infoHeader, SQEVL_SQL);
if (rc)
{
closeAMQPConnection();
establishedAMQPConnection_ = FALSE;
if (lockedMutex)
unlockMutex();
return rc;
}
AMQPRoutingKey routingKey(SP_EVENT, SP_SQLPACKAGE, SP_INSTANCE,
SP_PUBLIC, SP_GPBPROTOCOL, "error_event");
try {
rc = sendAMQPMessage(true, sql_error_event.SerializeAsString(),
SP_CONTENT_TYPE_APP, routingKey);
if (rc) throw 1;
} catch (...) {
closeAMQPConnection();
establishedAMQPConnection_ = FALSE;
if (!rc) rc = SP_SEND_FAILED;
if (lockedMutex)
unlockMutex();
return rc;
}
if (lockedMutex)
unlockMutex();
#else
rc = 0;
#endif
return rc;
}
