core/sqf/monitor/test/childExitCtrl.cxx - trafodion - Git at Google

 ///////////////////////////////////////////////////////////////////////////////
 //
 // @@@ START COPYRIGHT @@@
 //
 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 //
 // @@@ END COPYRIGHT @@@
 //
 ///////////////////////////////////////////////////////////////////////////////

 // controller:
 //    create process A on node 0
 //    after children created
 //    kill process A
 //    verify that process A killed and children killed

     // get process status, verify the parent was created ok
     // (no need to register death notification since we are parent)
     // done: childExitParent sends us a message for each process created
     // done: register for each child death notification
     // done: kill process
     // done: verify death notification for childExitParent
     // done: verify death notification for each child process

 // testing:
 //  test failure in parent process creation
 //  test other failure scenarios, make sure test reports failure


 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 //#include <thread>
 #include "clio.h"
 #include "sqevlog/evl_sqlog_writer.h"
 #include "montestutil.h"
 #include "xmpi.h"

 MonTestUtil util;

 long trace_settings = 0;
 FILE *shell_locio_trace_file = NULL;
 bool tracing = false;

 const char *MyName;
 int gv_ms_su_nid = -1;          // Local IO nid to make compatible w/ Seabed
 SB_Verif_Type  gv_ms_su_verif = -1;
 char ga_ms_su_c_port[MPI_MAX_PORT_NAME] = {0}; // connect


 class CreatedProcess
 {
 public:
     CreatedProcess(const char * name, int nid, int pid, Verifier_t verifier);
     ~CreatedProcess(){}
     const char * getName() { return name_.c_str(); }
     int getNid() { return nid_; }
     int getPid() { return pid_; }
     int getVerifier() { return verifier_; }
     void setDeathNotice() { deathNotice_ = true; }
     bool getDeathNotice() { return deathNotice_; }

 private:
     string name_;
     int nid_;
     int pid_;
     Verifier_t verifier_;
     bool deathNotice_;
 };

 CreatedProcess::CreatedProcess( const char *name
                               , int nid
                               , int pid
                               , Verifier_t verifier)
                : name_(name)
                , nid_(nid)
                , pid_(pid)
                , verifier_(verifier)
                , deathNotice_ (false)
 {
 }

 CreatedProcess* childDeathParent;
 CreatedProcess* procList[10];
 int procListCount = 0;
 int deathNoticeCount = 0;


 // Routine for handling notices:
 //   NodeDown, NodeUp, ProcessDeath, Shutdown, TmSyncAbort, TmSyncCommit
 void recv_notice_msg(struct message_def *recv_msg, int )
 {
     if ( recv_msg->type == MsgType_ProcessDeath )
     {
         printf("[%s] Process death notice received for %s (%d, %d:%d)\n",
                MyName,
                recv_msg->u.request.u.death.process_name,
                recv_msg->u.request.u.death.nid,
                recv_msg->u.request.u.death.pid,
                recv_msg->u.request.u.death.verifier);

         bool found = false;
         for (int i=0; i<procListCount; i++)
         {
             if (procList[i]->getNid() == recv_msg->u.request.u.death.nid
              && procList[i]->getPid() == recv_msg->u.request.u.death.pid
              && procList[i]->getVerifier() == recv_msg->u.request.u.death.verifier)
             {
                 procList[i]->setDeathNotice();
                 ++deathNoticeCount;
                 found = true;
                 break;
             }
         }
         if (!found)
         {
             printf("[%s] Could not find procList object for (%d, %d)\n",
                    MyName, recv_msg->u.request.u.death.nid,
                    recv_msg->u.request.u.death.pid);
         }
     }
     else
     {
         printf("[%s] unexpected notice, type=%s\n", MyName,
                MessageTypeString( recv_msg->type));
     }
 }

 // Get messages from "childExitParent" which give the process
 // names of child processes it has created.
 bool getProcesses ( )
 {
     MPI_Comm CtrlComm = MPI_COMM_NULL;
     int rc;
     char recvbuf[25];
     MPI_Status status;
     bool done = false;
     int nid;
     int pid;
     Verifier_t verifier;
     _TM_Txid_External transid = {{0LL, 0LL, 0LL, 0LL}};

     rc = XMPI_Comm_accept( util.getPort(), MPI_INFO_NULL, 0, MPI_COMM_SELF,
                           &CtrlComm);
     if (rc == MPI_SUCCESS)
     {
         XMPI_Comm_set_errhandler (CtrlComm, MPI_ERRORS_RETURN);
         if ( tracing )
             printf ("[%s] Connected to childExitParent\n", MyName);
     }
     else
     {
         printf ("[%s] XMPI_Comm_accept failed, rc=%d\n", MyName, rc);
         return false;
     }

     do
     {
         rc = XMPI_Recv (recvbuf, 25, MPI_CHAR, MPI_ANY_SOURCE, MPI_ANY_TAG,
                        CtrlComm, &status);
         if (rc == MPI_SUCCESS)
         {
             if ( strcmp("FINIS", recvbuf) == 0 )
             {
                 done = true;
             }
             else
             {   // Got a process name, keep track of it
                 for (int i=0; i<3; i++)
                 {
                     if (util.requestProcInfo ( recvbuf, nid, pid, verifier ))
                     {
                         printf ("[%s] registering process %s (%d, %d:%d)\n",
                                 MyName, recvbuf, nid, pid, verifier);

                         procList[procListCount]
                             = new CreatedProcess( recvbuf, nid, pid, verifier );
                         ++procListCount;
                         util.requestNotice ( nid, pid, verifier, "", false, transid );
                         break;
                     }
                     // Allow more time for process startup
                     sleep(1);
                 }
             }
         }
         else
         {
             printf ("[%s] XMPI_Recv failed, rc=%d\n", MyName, rc);
             return false;
         }

     }
     while (!done);

     return true;
 }

 void cleanup ()
 {
     // tell monitor we are exiting
     util.requestExit ( );

     if ( tracing ) printf ("[%s] calling Finalize!\n", MyName);

     XMPI_Close_port( util.getPort() );
     if ( gp_local_mon_io )
     {
         delete gp_local_mon_io;
     }
 }

 int main (int argc, char *argv[])
 {
     bool testSuccess = true;

     util.processArgs (argc, argv);
     MyName = util.getProcName();
     tracing = util.getTrace();

     util.InitLocalIO( );
     assert (gp_local_mon_io);

     // Set local io callback function for "notices"
     gp_local_mon_io->set_cb(recv_notice_msg, "notice");

     util.requestStartup ();

     printf ("[%s] tracing=%d\n", MyName, tracing);

     // Start process "childExitParent" that will start several child processes
     int nid;
     int pid;
     Verifier_t verifier;
     char *childArgs[1] = {(char *) "-t"};
     char procName[25];
     childDeathParent = NULL;
     if (util.requestNewProcess ( 1
                                , ProcessType_Generic
                                , false     // nowait
                                , (char *) "$PROCA"
                                , "childExitParent"
                                , ""        // inFile
                                , ""        // outFile
                                , ((tracing) ? 1: 0)
                                , childArgs
                                , nid
                                , pid
                                , verifier
                                , procName))
     {
         procList[0] = new CreatedProcess ( "$PROCA", nid, pid, verifier );
         ++procListCount;
     }
     else
     {
         printf ("[%s] error starting childExitParent process\n", MyName);
         printf ("[%s] test failed\n", MyName);

         printf("[%s] Test FAILED\n", MyName);

         cleanup();
         return 1;
     }

     // Get created process info from "childExitParent"
     if (!getProcesses ( ))
     {
         printf ("[%s] could not get process info from childExitParent\n",
                 MyName);

         printf("[%s] Test FAILED\n", MyName);

         cleanup();
         return 1;
     }

     // Kill "childExitParent"
     util.requestKill ( "$PROCA", verifier );

     // Wait for all death notices
     sleep(5);

     // Verify that got all death notices
     for (int i=0; i<procListCount; i++)
     {
         if (!procList[i]->getDeathNotice())
         {
             printf("[%s] No death notice received for process %s (%d, %d)\n",
                    MyName, procList[i]->getName(), procList[i]->getNid(),
                    procList[i]->getPid());

             testSuccess = false;
         }
     }

     printf("Child Exit Test:\t\t%s\n", (testSuccess) ? "PASSED" : "FAILED");

     cleanup();
     exit (0);
 }
	///////////////////////////////////////////////////////////////////////////////
	//
	// @@@ START COPYRIGHT @@@
	//
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	//
	// @@@ END COPYRIGHT @@@
	//
	///////////////////////////////////////////////////////////////////////////////

	// controller:
	// create process A on node 0
	// after children created
	// kill process A
	// verify that process A killed and children killed

	// get process status, verify the parent was created ok
	// (no need to register death notification since we are parent)
	// done: childExitParent sends us a message for each process created
	// done: register for each child death notification
	// done: kill process
	// done: verify death notification for childExitParent
	// done: verify death notification for each child process

	// testing:
	// test failure in parent process creation
	// test other failure scenarios, make sure test reports failure


	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>
	//#include <thread>
	#include "clio.h"
	#include "sqevlog/evl_sqlog_writer.h"
	#include "montestutil.h"
	#include "xmpi.h"

	MonTestUtil util;

	long trace_settings = 0;
	FILE *shell_locio_trace_file = NULL;
	bool tracing = false;

	const char *MyName;
	int gv_ms_su_nid = -1; // Local IO nid to make compatible w/ Seabed
	SB_Verif_Type gv_ms_su_verif = -1;
	char ga_ms_su_c_port[MPI_MAX_PORT_NAME] = {0}; // connect


	class CreatedProcess
	{
	public:
	CreatedProcess(const char * name, int nid, int pid, Verifier_t verifier);
	~CreatedProcess(){}
	const char * getName() { return name_.c_str(); }
	int getNid() { return nid_; }
	int getPid() { return pid_; }
	int getVerifier() { return verifier_; }
	void setDeathNotice() { deathNotice_ = true; }
	bool getDeathNotice() { return deathNotice_; }

	private:
	string name_;
	int nid_;
	int pid_;
	Verifier_t verifier_;
	bool deathNotice_;
	};

	CreatedProcess::CreatedProcess( const char *name
	, int nid
	, int pid
	, Verifier_t verifier)
	: name_(name)
	, nid_(nid)
	, pid_(pid)
	, verifier_(verifier)
	, deathNotice_ (false)
	{
	}

	CreatedProcess* childDeathParent;
	CreatedProcess* procList[10];
	int procListCount = 0;
	int deathNoticeCount = 0;


	// Routine for handling notices:
	// NodeDown, NodeUp, ProcessDeath, Shutdown, TmSyncAbort, TmSyncCommit
	void recv_notice_msg(struct message_def *recv_msg, int )
	{
	if ( recv_msg->type == MsgType_ProcessDeath )
	{
	printf("[%s] Process death notice received for %s (%d, %d:%d)\n",
	MyName,
	recv_msg->u.request.u.death.process_name,
	recv_msg->u.request.u.death.nid,
	recv_msg->u.request.u.death.pid,
	recv_msg->u.request.u.death.verifier);

	bool found = false;
	for (int i=0; i<procListCount; i++)
	{
	if (procList[i]->getNid() == recv_msg->u.request.u.death.nid
	&& procList[i]->getPid() == recv_msg->u.request.u.death.pid
	&& procList[i]->getVerifier() == recv_msg->u.request.u.death.verifier)
	{
	procList[i]->setDeathNotice();
	++deathNoticeCount;
	found = true;
	break;
	}
	}
	if (!found)
	{
	printf("[%s] Could not find procList object for (%d, %d)\n",
	MyName, recv_msg->u.request.u.death.nid,
	recv_msg->u.request.u.death.pid);
	}
	}
	else
	{
	printf("[%s] unexpected notice, type=%s\n", MyName,
	MessageTypeString( recv_msg->type));
	}
	}

	// Get messages from "childExitParent" which give the process
	// names of child processes it has created.
	bool getProcesses ( )
	{
	MPI_Comm CtrlComm = MPI_COMM_NULL;
	int rc;
	char recvbuf[25];
	MPI_Status status;
	bool done = false;
	int nid;
	int pid;
	Verifier_t verifier;
	_TM_Txid_External transid = {{0LL, 0LL, 0LL, 0LL}};

	rc = XMPI_Comm_accept( util.getPort(), MPI_INFO_NULL, 0, MPI_COMM_SELF,
	&CtrlComm);
	if (rc == MPI_SUCCESS)
	{
	XMPI_Comm_set_errhandler (CtrlComm, MPI_ERRORS_RETURN);
	if ( tracing )
	printf ("[%s] Connected to childExitParent\n", MyName);
	}
	else
	{
	printf ("[%s] XMPI_Comm_accept failed, rc=%d\n", MyName, rc);
	return false;
	}

	do
	{
	rc = XMPI_Recv (recvbuf, 25, MPI_CHAR, MPI_ANY_SOURCE, MPI_ANY_TAG,
	CtrlComm, &status);
	if (rc == MPI_SUCCESS)
	{
	if ( strcmp("FINIS", recvbuf) == 0 )
	{
	done = true;
	}
	else
	{ // Got a process name, keep track of it
	for (int i=0; i<3; i++)
	{
	if (util.requestProcInfo ( recvbuf, nid, pid, verifier ))
	{
	printf ("[%s] registering process %s (%d, %d:%d)\n",
	MyName, recvbuf, nid, pid, verifier);

	procList[procListCount]
	= new CreatedProcess( recvbuf, nid, pid, verifier );
	++procListCount;
	util.requestNotice ( nid, pid, verifier, "", false, transid );
	break;
	}
	// Allow more time for process startup
	sleep(1);
	}
	}
	}
	else
	{
	printf ("[%s] XMPI_Recv failed, rc=%d\n", MyName, rc);
	return false;
	}

	}
	while (!done);

	return true;
	}

	void cleanup ()
	{
	// tell monitor we are exiting
	util.requestExit ( );

	if ( tracing ) printf ("[%s] calling Finalize!\n", MyName);

	XMPI_Close_port( util.getPort() );
	if ( gp_local_mon_io )
	{
	delete gp_local_mon_io;
	}
	}

	int main (int argc, char *argv[])
	{
	bool testSuccess = true;

	util.processArgs (argc, argv);
	MyName = util.getProcName();
	tracing = util.getTrace();

	util.InitLocalIO( );
	assert (gp_local_mon_io);

	// Set local io callback function for "notices"
	gp_local_mon_io->set_cb(recv_notice_msg, "notice");

	util.requestStartup ();

	printf ("[%s] tracing=%d\n", MyName, tracing);

	// Start process "childExitParent" that will start several child processes
	int nid;
	int pid;
	Verifier_t verifier;
	char childArgs[1] = {(char ) "-t"};
	char procName[25];
	childDeathParent = NULL;
	if (util.requestNewProcess ( 1
	, ProcessType_Generic
	, false // nowait
	, (char *) "$PROCA"
	, "childExitParent"
	, "" // inFile
	, "" // outFile
	, ((tracing) ? 1: 0)
	, childArgs
	, nid
	, pid
	, verifier
	, procName))
	{
	procList[0] = new CreatedProcess ( "$PROCA", nid, pid, verifier );
	++procListCount;
	}
	else
	{
	printf ("[%s] error starting childExitParent process\n", MyName);
	printf ("[%s] test failed\n", MyName);

	printf("[%s] Test FAILED\n", MyName);

	cleanup();
	return 1;
	}

	// Get created process info from "childExitParent"
	if (!getProcesses ( ))
	{
	printf ("[%s] could not get process info from childExitParent\n",
	MyName);

	printf("[%s] Test FAILED\n", MyName);

	cleanup();
	return 1;
	}

	// Kill "childExitParent"
	util.requestKill ( "$PROCA", verifier );

	// Wait for all death notices
	sleep(5);

	// Verify that got all death notices
	for (int i=0; i<procListCount; i++)
	{
	if (!procList[i]->getDeathNotice())
	{
	printf("[%s] No death notice received for process %s (%d, %d)\n",
	MyName, procList[i]->getName(), procList[i]->getNid(),
	procList[i]->getPid());

	testSuccess = false;
	}
	}

	printf("Child Exit Test:\t\t%s\n", (testSuccess) ? "PASSED" : "FAILED");

	cleanup();
	exit (0);
	}