summaryrefslogtreecommitdiff
path: root/src/tests/xb_test_lock.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/tests/xb_test_lock.cpp')
-rwxr-xr-xsrc/tests/xb_test_lock.cpp1066
1 files changed, 1066 insertions, 0 deletions
diff --git a/src/tests/xb_test_lock.cpp b/src/tests/xb_test_lock.cpp
new file mode 100755
index 0000000..2df71a8
--- /dev/null
+++ b/src/tests/xb_test_lock.cpp
@@ -0,0 +1,1066 @@
+/* xb_test_lock.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+ XDB-devel@lists.sourceforge.net
+ XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the locking functions of xbase
+// usage: xb_test_lock QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/****************************************************************/
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iRc2;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ xbInt16 iErrorStop = 0;
+ xbString sLockFile;
+ xbString sLockFile2;
+ xbString sLockCmd;
+ xbString sResult;
+
+ xbXBase x;
+ xbDbf * MyFile;
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbSchema MyRecord[] =
+ {
+ { "LOCKTEST", XB_CHAR_FLD, 5, 0 },
+ #ifdef XB_MEMO_SUPPORT
+ { "MEMOTEST", XB_MEMO_FLD, 10, 0 },
+ #endif
+ { "",0,0,0 }
+ };
+
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.SetLogDirectory( PROJECT_LOG_DIR );
+ x.EnableMsgLogging();
+ if( po > 0 ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ InitTime();
+ #ifdef XB_DBF4_SUPPORT
+ MyFile = new xbDbf4( &x ); // version 4 dbf file
+ #else
+ MyFile = new xbDbf3( &x ); // version 3 dbf file
+ #endif
+
+ iRc2 = MyFile->CreateTable( "LockTest.DBF", "LockTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( po, "CreateTable()", iRc2, XB_NO_ERROR );
+
+ #ifdef XB_MDX_SUPPORT
+ xbIx *ixPtr;
+ void *pTag;
+ iRc2 = MyFile->CreateTag( "MDX", "LockTag", "LOCKTEST", "", 0, 0, XB_OVERLAY, &ixPtr, &pTag );
+ iRc += TestMethod( po, "CreateTag()", iRc2, XB_NO_ERROR );
+ #endif // XB_MDX_SUPPORT
+
+
+ iRc += TestMethod( po, "PutField()", MyFile->PutField( "LOCKTEST", "TEST" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+
+ sLockFile.Sprintf( "%slocktest.txt", PROJECT_DATA_DIR );
+ // std::cout << "xb_test_lock - lockfile = [ " << sLockFile.Str() << "]\n";
+
+ remove( sLockFile.Str() );
+
+ #if defined (HAVE_FORK_F)
+ pid_t pid;
+ if(( pid = fork()) < 0 ){
+ std::cout << "fork error\n";
+ exit(1);
+ }
+
+ if( pid == 0 ){
+ // child task
+ xbDbf * MyFileChld;
+ xbInt16 iRcChld = 0;
+ xbBool bTblOpenChld = xbFalse;
+ xbInt32 iChildLoop = 0;
+ xbBool bDone = xbFalse;
+ xbString sLastLockCmd;
+
+ #ifdef XB_DBF4_SUPPORT
+ MyFileChld = new xbDbf4( &x ); // version 4 dbf file
+ #else
+ MyFileChld = new xbDbf3( &x ); // version 3 dbf file
+ #endif
+
+ x.xbSleep( 250 );
+
+ while( !bDone ){
+
+ iRc2 = GetCmd( x, sLockFile, sLockCmd, 'C', po );
+
+ if( sLockCmd == sLastLockCmd )
+ iChildLoop++;
+ else
+ sLastLockCmd = sLockCmd;
+
+ #ifdef XB_LOGGING_SUPPORT
+ if( sLockCmd != "OK" && sLockCmd != "FAIL" ){
+ sMsg.Sprintf( "Program [%s] Child task retrieved command=[%s] RC=[%d]", av[0], sLockCmd.Str(), iRc2 );
+ x.WriteLogMessage( sMsg );
+ }
+ #endif
+
+ if( iRc2 == 0 ){
+
+ if( sLockCmd == "OK" || sLockCmd == "FAIL" )
+ x.xbSleep( 250 );
+
+ else if( sLockCmd == "EXIT" ){
+ bDone = xbTrue;
+
+ } else if( sLockCmd == "START" && bTblOpenChld ){
+ // came back before the parent task could process the result
+ x.xbSleep( 250 );
+
+ } else {
+ if( sLockCmd == "START" ){
+ // begin the process
+ iRcChld = MyFileChld->Open( "LockTest.DBF" );
+ if( iRcChld != XB_NO_ERROR ){
+ sResult = "FAIL";
+ } else {
+ sResult = "OK";
+ bTblOpenChld = xbTrue;
+ }
+
+ } else if( sLockCmd == "TL" ){
+ // table lock
+ if(( iRcChld = MyFileChld->LockTable( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "TU" ){
+ // table unlock
+ if(( iRcChld = MyFileChld->LockTable( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "RL" ){
+ // record lock
+ if(( iRcChld = MyFileChld->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "RU" ){
+ // record unlock
+ if(( iRcChld = MyFileChld->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "ML" ){
+ // memo lock
+ #ifdef XB_MEMO_SUPPORT
+ if(( iRcChld = MyFileChld->LockMemo( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif
+
+ } else if( sLockCmd == "MU" ){
+ // memo unlock
+ #ifdef XB_MEMO_SUPPORT
+ if(( iRcChld = MyFileChld->LockMemo( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif
+
+ } else if( sLockCmd == "IL" ){
+ // index lock
+ #ifdef XB_MDX_SUPPORT
+ if(( iRcChld = MyFileChld->LockIndices( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif // XB_MDX_SUPPORT
+
+ } else if( sLockCmd == "IU" ){
+ // index unlock
+ #ifdef XB_MDX_SUPPORT
+ if(( iRcChld = MyFileChld->LockIndices( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif // XB_MDX_SUPPORT
+ }
+
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Child task [%s] Result [%s] RC = [%d]", av[0], sLockCmd.Str(), sResult.Str(), iRcChld );
+ x.WriteLogMessage( sMsg );
+ #endif
+ SetCmd( x, sLockFile, sResult, 'C', po );
+ if( sResult == "FAIL" ){
+ bDone = xbTrue;
+ MyFileChld->Close();
+ delete MyFileChld;
+ }
+ }
+ } else {
+ iRc = iRc2;
+ bDone = xbTrue;
+ }
+ //std::cout << "clc [" << iChildLoop++ << "][" << bDone << "][" << sLockCmd.Str() << "]\n";
+ x.xbSleep( 250 );
+ if( iChildLoop > 15 )
+ bDone = xbTrue;
+ }
+ MyFileChld->Close();
+ delete MyFile;
+ delete MyFileChld;
+
+ remove( sLockFile );
+
+ if( po > 0 )
+ std::cout << "Exiting child\n";
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Child task terminating", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+
+ } else {
+
+ // parent logic
+ xbInt16 iLoopCtr = 0;
+
+ try{
+ // start
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing START command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "START";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 100;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ // table lock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 110;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ // attempt to lock table, should fail
+ if(( iRc2 = MyFile->Open( "LockTest.DBF" )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc2;
+ }
+
+ if( po > 0 )
+ std::cout << "[PASS] LockTable Test 1\n";
+
+ // table unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 140;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockTable Test 2\n";
+
+ if(( iRc2 = MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc2;
+ }
+
+ // record lock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 170;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) == XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockRecord Test 1\n";
+
+ // record unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 190;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockRecord Test 2\n";
+ if(( iRc2 = MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc2;
+ }
+
+
+ // memo lock
+ #ifdef XB_MEMO_SUPPORT
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing ML command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ sLockCmd = "ML";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ if( sResult != "OK" ){
+ iErrorStop = 220;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 230;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockMemo Test 1\n";
+
+ // memo unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing MU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ sLockCmd = "MU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ if( sResult != "OK" ){
+ iErrorStop = 240;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 250;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockMemo Test 2\n";
+ if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 260;
+ throw iRc2;
+ }
+ #endif // XB_MEMO_SUPPORT
+
+ // index lock
+ #ifdef XB_MDX_SUPPORT
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing IL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ sLockCmd = "IL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ if( sResult != "OK" ){
+ iErrorStop = 270;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockIndices( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 280;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockIndex Test 1\n";
+
+ // memo unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing IU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ sLockCmd = "IU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif // XB_LOGGING_SUPPORT
+
+ if( sResult != "OK" ){
+ iErrorStop = 290;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockIndices( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockIndex Test 2\n";
+ if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 310;
+ throw iRc2;
+ }
+ #endif // XB_MDX_SUPPORT
+
+
+
+ // exit
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+
+
+
+ } catch (xbInt16 iRc3 ){
+ iRc = iRc3;
+ if( po > 0 )
+ std::cout << "Parent lock task exiting on failure [" << sLockCmd.Str() << "][" << iErrorStop << "]\n";
+
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task terminating with errors [%s][%d][%d][%d]...", av[0], sLockCmd.Str(), iErrorStop, iLoopCtr, iRc3 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task terminating", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( po > 0 )
+ std::cout << "Exiting parent\n";
+
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ MyFile->Close();
+ delete MyFile;
+
+ }
+ #elif defined (HAVE_CREATEPROCESSW_F)
+
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+ ZeroMemory( &si, sizeof( si ));
+ si.cb = sizeof( si );
+ ZeroMemory( &pi, sizeof( pi ));
+
+ xbString strCmdLine = "xb_test_lock2";
+ if( argCnt > 1 ){
+ strCmdLine += " ";
+ strCmdLine += av[1];
+ }
+
+ char sCmdLineBuf[25];
+ memset( sCmdLineBuf, 0x00, 25 );
+ for( xbUInt32 i = 0; i < strCmdLine.Len(); i++ )
+ sCmdLineBuf[i] = strCmdLine[i+1];
+
+ if( !CreateProcess( NULL, sCmdLineBuf, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi )){
+ sMsg.Sprintf( "Program [%s] error in CreateProcess call. Processing aborted" );
+ #ifdef XB_LOGGING_SUPPORT
+ x.WriteLogMessage( sMsg );
+ #endif
+ std::cout << sMsg.Str() << "\n";
+ iRc -=1;
+ } else {
+
+ xbInt16 iLoopCtr = 0;
+
+ try{
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing START command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+
+ sLockCmd = "START";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 300 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ // table lock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 310 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 320;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ // attempt to lock table, should fail
+ if(( iRc2 = MyFile->Open( "LockTest.DBF" )) != XB_NO_ERROR ){
+ iErrorStop = 330;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 340;
+ throw iRc2;
+ }
+
+ if( po > 0 ){
+ std::cout << "[PASS] LockTable Test 1\n";
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task LockTable Test 1 Success.", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+ }
+
+ // table unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 350;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 360;
+ throw iRc2;
+ }
+ if( po > 0 ){
+ std::cout << "[PASS] LockTable Test 2\n";
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task LockTable Test 1 Success.", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 370;
+ throw iRc2;
+ }
+
+ // record lock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 380 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 390;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) == XB_NO_ERROR ){
+ iErrorStop = 400;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockRecord Test 1\n";
+
+ // record unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 410;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 420;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockRecord Test 2\n";
+ if(( iRc2 = MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 430;
+ throw iRc2;
+ }
+
+ // memo lock
+ #ifdef XB_MEMO_SUPPORT
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing ML command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "ML";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 440;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 450;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockMemo Test 1\n";
+
+ // memo unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing MU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "MU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 460;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 470;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockMemo Test 2\n";
+ if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 480;
+ throw iRc2;
+ }
+ #endif
+
+ // index lock
+ #ifdef XB_MDX_SUPPORT
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing IL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "IL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 490 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 500;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockIndices( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 510;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockIndex Test 1\n";
+
+ // index unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing IU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "IU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 520;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockIndices( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 530;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockIndex Test 2\n";
+ if(( iRc2 = MyFile->LockIndices( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 540;
+ throw iRc2;
+ }
+ #endif
+
+ // exit
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+
+
+ } catch (xbInt16 iRc3 ){
+ if( po > 0 )
+ std::cout << "Parent lock task exiting on failure [" << sLockCmd.Str() << "][" << iErrorStop << "]\n";
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task terminating with errors [%s][%d][%d][%d]...", av[0], sLockCmd.Str(), iErrorStop, iLoopCtr, iRc3 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ MyFile->Close();
+ delete MyFile;
+ }
+ }
+
+ #else
+
+ iRc--;
+ sMsg.Sprintf( "Program [%s] not executed. Library does not support 'fork' or 'CreateProcess' function call", av[0] );
+ #ifdef XB_LOGGING_SUPPORT
+ x.WriteLogMessage( sMsg );
+ #endif
+ if( po > 0 )
+ std::cout << sMsg.Str() << "\n";
+ #endif
+
+ if( po > 0 || iRc < 0 )
+ fprintf( stdout, "[%s] Total Errors = %d\n", av[0], iRc * -1 );
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ return iRc;
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-14 05:52:00 +0000