/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "CStressWorker.h"

#include "RSearchServerSession.h"

#include "CCPixIndexer.h"

#include "CCPixSearcher.h"

#include "CSearchDocument.h"

#include <e32math.h>

#include "CLog.h"

#include "MCPixSearcherObserver.h"

#include "robustnesstest.pan"

#include "CWorker.h"

#include "CIndexingWorker.h"

#include "CSearchingWorker.h"

#define KLockWaitSeconds 5 // wait for some good time 

#define KLockWaitMicroSeconds KLockWaitSeconds * 1000 * 1000 // wait for some good time 

#define KWaitAfterCancellingSeconds 10 // wait for some good time 

#define KWaitFinishSeconds 10 // wait for some good time 

#define KWaitFinishMicroSeconds KWaitFinishSeconds * 1000 * 1000 // wait for some good time 

CStressWorker::CStressWorker( MLog& aLog,

							  TInt aPreIndex, 

							  TInt aIndexAverageItems,

							  TBool aIndexingEnabled,

							  TBool aDeletesEnabled,

						      TBool aSearchersEnabled, 

						      TBool aCancellingEnabled,

						      TInt aIndexerSleep, 

						      TInt aSearcherSleep )

:   iLog( aLog ),

    iWorkers(),

    iIsActive( EFalse ),

	iPreIndex         ( aPreIndex ),		

	iIndexAverageItems( aIndexAverageItems ), 

	iIndexingEnabled  ( aIndexingEnabled ),

	iDeletesEnabled	  ( aDeletesEnabled ),

	iSearchersEnabled ( aSearchersEnabled ),

	iCancellingEnabled( aCancellingEnabled ),

	iIndexerSleep	  ( aIndexerSleep), 

	iSearcherSleep    (	aSearcherSleep )

	{

	}

CStressWorker::~CStressWorker()

	{

	iWorkers.ResetAndDestroy();

	iWorkers.Close(); 

	}

void CStressWorker::ConstructL()

	{

	}

void CStressWorker::StartWorkersL() 

	{

	// 

	// Indexers

	// 

	if ( iIndexingEnabled ) 

		{

		// Indexer working with normal index

		iWorkers.Append( CIndexingWorker::NewL( KNormalVolume, iDeletesEnabled, iIndexAverageItems, iIndexerSleep ) );

		// 3 indexers working with busy index

		iWorkers.Append( CIndexingWorker::NewL( KBusyVolume, iDeletesEnabled, iIndexAverageItems, iIndexerSleep ) );

		iWorkers.Append( CIndexingWorker::NewL( KBusyVolume, iDeletesEnabled, iIndexAverageItems, iIndexerSleep ) );

		iWorkers.Append( CIndexingWorker::NewL( KBusyVolume, iDeletesEnabled, iIndexAverageItems, iIndexerSleep ) );

		// = 4 indexers in total 

		}

	if ( iSearchersEnabled ) 

		{

		// 

		// Searchers

		// 

		// Multisearcher

		iWorkers.Append( CSearchingWorker::NewL( KTestBaseAppClass, iSearcherSleep ) );

		// Search normal index 

		iWorkers.Append( CSearchingWorker::NewL( KNormalVolume, iSearcherSleep, iCancellingEnabled ) );

		// Search big the busy index

		iWorkers.Append( CSearchingWorker::NewL( KBusyVolume, iSearcherSleep ) );

		iWorkers.Append( CSearchingWorker::NewL( KBusyVolume, iSearcherSleep, EFalse, iCancellingEnabled ) );

		iWorkers.Append( CSearchingWorker::NewL( KBusyBaseAppClass, iSearcherSleep  ) );

		// = 5 searchers in total

		}

	for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

		{

		iWorkers[i]->StartL();

		}

	}

void CStressWorker::PrepareIndexL()

	{

	RSearchServerSession session;

	User::LeaveIfError( session.Connect() ); 

	CleanupClosePushL( session ); 

	// First database has one reader and one or two searchers, what 

	// is something that can be expected in the actual device

	User::LeaveIfError

		(

		session.DefineVolume( KNormalVolume, 

							  KNormalIndexDirectory )

		); 

	// Second database has a number of searchers and indexers. 

	User::LeaveIfError

		(

		session.DefineVolume( KBusyVolume,

							  KBusyIndexDirectory )

		);

	if ( iPreIndex ) iLog.LogL( _L( "preparing index") ); 

	CCPixIndexer* indexer = CCPixIndexer::NewLC( session );

	indexer->OpenDatabaseL( KNormalVolume );

	indexer->ResetL();

	HBufC* buf = HBufC::NewLC( 4 * 1024 ); 

	TPtr pbuf( buf->Des() ); 

	for ( TInt i = 0; i < iPreIndex; i++ ) 

		{

		indexer->AddL( *GenerateDocumentLC( iIndexAverageItems, 

										    KNormalBaseAppClass, 

										    pbuf ) );

		CleanupStack::PopAndDestroy(); 

		}

	indexer->FlushL();

	indexer->OpenDatabaseL( KBusyVolume );

	indexer->ResetL(); 

	for ( TInt i = 0; i < iPreIndex; i++ ) 

		{

		indexer->AddL( *GenerateDocumentLC( iIndexAverageItems, 

										    KBusyBaseAppClass, 

										    pbuf ) );

		CleanupStack::PopAndDestroy(); 

		}

	CleanupStack::PopAndDestroy( buf );

	indexer->FlushL();

	CleanupStack::PopAndDestroy( indexer ); 

	CleanupStack::PopAndDestroy(); // session 

	}

void CStressWorker::StartL()

	{

	PrepareIndexL(); 

	TRAPD( err, StartWorkersL() ); 

	if ( err != KErrNone )

		{

		iWorkers.ResetAndDestroy();

		User::Leave( err ); 

		}

	else 

		{

		iIsActive = ETrue; 

		}

	}

void CStressWorker::DoFinishL()

	{

	for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

		{

		iWorkers[i]->Cancel();

		}

	User::After( KWaitAfterCancellingSeconds * 1000 * 1000 );

	int running = iWorkers.Count();

	TInt round = 0;

	for (; round < 3 && running ; round++ ) 

		{

		switch (round) 

			{

			case 1: 

			case 2: 

				iLog.LogL( _L( "Retrying to stop workers." ) );

				break;

			}

		for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

			{

			if ( iWorkers[i]->IsActive() )

				{

				if ( iWorkers[i]->TryJoin( KWaitFinishMicroSeconds ) == KErrNone )

					{

					running--;

					if ( round > 0 )

						{

						iLog.LogL( _L( "worker '%S' finished" ),

								   &iWorkers[i]->Name() );

						}

					}

				else 

					{

					iLog.LogL( _L( "worker '%S' failed to exit within %d s" ),

							   &iWorkers[i]->Name(),

							   KWaitFinishSeconds  );

					}

				}

			}

		}

	if ( running ) 

		{  

		iLog.LogL( _L( "Deadlock? %d worker(s) failed to exit." ),

				   running );

		iLog.LogL( _L( "Terminating workers forcefully (may cause leaks)" ) );

		for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

			{

			if ( iWorkers[i]->IsActive() )

				{

				iWorkers[i]->Terminate();

				iWorkers[i]->Unlock(); // So that we can check the records. 

				iLog.LogL( _L( "terminated worker '%S'." ),

						   &iWorkers[i]->Name() ); 

				}

			}

		}

	else if (round > 1) 

		{

		iLog.LogL( _L( "All workers finished successfully." ) ); 

		}

	ReportL();

	}

TBool CStressWorker::ReportL()

	{

	TBool error = EFalse; 

	for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

		{

		if ( iWorkers[i]->Error() != KErrNone && 

			 iWorkers[i]->IsReported() == EFalse )

			{

			TDateTime time = iWorkers[i]->ExitTime().DateTime();

			TBuf<64> buf; 

			buf.AppendNumFixedWidth( (TUint)time.Hour(), EDecimal, 2 );

			buf.Append(_L(":"));

			buf.AppendNumFixedWidth( (TUint)time.Minute(), EDecimal, 2 );

			buf.Append(_L(":"));

			buf.AppendNumFixedWidth( (TUint)time.Second(), EDecimal, 2 );

			buf.Append(_L("."));

			buf.AppendNumFixedWidth( (TUint)time.MicroSecond(), EDecimal, 3 );

			iLog.LogL( _L( "worker '%S' failed with %d at %S" ),

					   &iWorkers[i]->Name(),

					   iWorkers[i]->Error(),

					   &buf  );

			iWorkers[i]->SetReported();

			error = ETrue; 

			}

		}

	return error;

	}

void CStressWorker::AppendOpStatsL( RPointerArray<HBufC8>& aStats, TInt aOperations, TInt64 aOperationsMicroSeconds ) 

	{

	HBufC8* buf = HBufC8::NewL( 64 ); 

	buf->Des().AppendNum( aOperations ); 

	aStats.Append( buf );

	buf = HBufC8::NewL( 64 ); 

	if ( aOperations > 0 ) 

		{

		buf->Des().AppendNum( (aOperationsMicroSeconds / 1000) / aOperations ); 

		}

	else 

		{

		buf->Des().Append( _L8( "NaN") ); 

		}

	aStats.Append( buf );

	}

void CStressWorker::AppendOpStatsL( RPointerArray<HBufC8>& aStats, TInt aOperations, TInt64 aOperationsMicroSeconds, TInt64 aOperationsPeakMicroSeconds ) 

	{

	HBufC8* buf = HBufC8::NewL( 64 ); 

	AppendOpStatsL( aStats, aOperations, aOperationsMicroSeconds );

	if ( aOperations > 0 )

		{

		buf->Des().AppendNum( aOperationsPeakMicroSeconds / 1000 ); 

		}

	else 

		{

		buf->Des().Append( _L8( "NaN") ); 

		}

	aStats.Append( buf );

	}

TInt CStressWorker::DirectorySizeL( const TDesC& aDirectory )

	{

	RFs fs; 

	User::LeaveIfError( fs.Connect() ); 

	CleanupClosePushL( fs ); 

	TBuf<256> buf; 

	buf.Append( aDirectory ); 

	buf.Append( _L( "\\*" ) );  

	// Make sure, that the index is not under merging or optimization operations

	CDir* dir; 

	TInt err = fs.GetDir( buf,        

				          KEntryAttMaskSupported,

						  ESortByName,

						  dir );

	TInt size = 0; 

	if ( err == KErrNone ) 

		{

		for (TInt i=0;i<dir->Count();i++)

			{

			size += (*dir)[i].iSize;

			}

		delete dir;

		}

	else 

		{

		// It is ok, if directory was not found.

		}

	CleanupStack::PopAndDestroy(); // fs

	return size;

	}

_LIT( KIndexZero, "\\_0" ); 

_LIT( KIndexOne, "\\_1" ); 

TInt CStressWorker::IndexSizeL( const TDesC& aDirectory )

	{

	TInt size = 0; 

	TBuf<256> buf;

	buf.Append( aDirectory ); 

	buf.Append( KIndexZero ); 

	size += DirectorySizeL( buf ); 

	buf.Zero();

	buf.Append( aDirectory ); 

	buf.Append( KIndexOne ); 

	size += DirectorySizeL( buf ); 

	return size;

	}

void CStressWorker::AppendStatsLabelsL( RPointerArray<HBufC8>& aStats )

	{

	aStats.Append( _L8( "norm sz").AllocL() ); 

	aStats.Append( _L8( "busy sz").AllocL() );

	if ( iIndexingEnabled )

		{

		aStats.Append( _L8( "adds").AllocL() ); 

		aStats.Append( _L8( "ms/op").AllocL() ); 

		aStats.Append( _L8( "deletes").AllocL() ); 

		aStats.Append( _L8( "ms/op").AllocL() );

		}

	if ( iSearchersEnabled ) 

		{

		aStats.Append( _L8( "searches").AllocL() ); 

		aStats.Append( _L8( "ms/op").AllocL() ); 

		aStats.Append( _L8( "peak").AllocL() ); 

		aStats.Append( _L8( "getdocs").AllocL() ); 

		aStats.Append( _L8( "ms/op").AllocL() ); 

		aStats.Append( _L8( "peak").AllocL() ); 

		aStats.Append( _L8( "terms").AllocL() ); 

		aStats.Append( _L8( "ms/op").AllocL() ); 

		aStats.Append( _L8( "peak").AllocL() ); 

		aStats.Append( _L8( "getterms").AllocL() ); 

		aStats.Append( _L8( "ms/op").AllocL() ); 

		aStats.Append( _L8( "peak").AllocL() ); 

		}

	}

void CStressWorker::AppendStatsInsideLocksL( RPointerArray<HBufC8>& aStats, const RArray<TBool>& aLocked ) 

	{

	TInt additions = 0; 

	TInt64 additionsMicroSeconds = 0;

	TInt deletes = 0; 

	TInt64 deletesMicroSeconds = 0; 

	TInt searches = 0; 

	TInt64 searchesMicroSeconds = 0; 

	TInt64 searchesPeakMicroSeconds = 0; 

	TInt termSearches = 0; 

	TInt64 termSearchesMicroSeconds = 0; 

	TInt64 termSearchesPeakMicroSeconds = 0; 

	TInt docs = 0; 

	TInt64 docsMicroSeconds = 0; 

	TInt64 docsPeakMicroSeconds = 0; 

	TInt terms = 0; 

	TInt64 termsMicroSeconds = 0; 

	TInt64 termsPeakMicroSeconds = 0; 

	for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

		{

		if ( aLocked[i] )

			{

			// Extract statistics only, if worker was successfully locked. 

			if ( dynamic_cast<CIndexingWorker*>( iWorkers[i] ) ) 

				{

				CIndexingWorker* worker = dynamic_cast<CIndexingWorker*>( iWorkers[i] ); 

				additions 				+= worker->ConsumeAdditions(); 

				additionsMicroSeconds 	+= worker->ConsumeAdditionsMicroSeconds(); 

				deletes					+= worker->ConsumeDeletes(); 

				deletesMicroSeconds 	+= worker->ConsumeDeletesMicroSecond(); 

				}

			if ( dynamic_cast<CSearchingWorker*>( iWorkers[i] ) ) 

				{

				CSearchingWorker* worker = dynamic_cast<CSearchingWorker*>( iWorkers[i] );

				searches 					+= worker->ConsumeSearches(); 

				searchesMicroSeconds 		+= worker->ConsumeSearchesMicroSeconds(); 

				searchesPeakMicroSeconds 	+= worker->ConsumeSearchesPeakMicroSeconds();

				termSearches 				+= worker->ConsumeTermSearches(); 

				termSearchesMicroSeconds	+= worker->ConsumeTermSearchesMicroSeconds(); 

				termSearchesPeakMicroSeconds+= worker->ConsumeTermSearchesPeakMicroSeconds(); 

				docs 						+= worker->ConsumeDocs(); 

				docsMicroSeconds			+= worker->ConsumeDocsMicroSeconds(); 

				docsPeakMicroSeconds		+= worker->ConsumeDocsPeakMicroSeconds(); 

				terms 						+= worker->ConsumeTerms(); 

				termsMicroSeconds			+= worker->ConsumeTermsMicroSeconds(); 

				termsPeakMicroSeconds		+= worker->ConsumeTermsPeakMicroSeconds(); 

				}

			}

		}

	HBufC8* buf = HBufC8::NewL( 64 ); 

	buf->Des().AppendNum( IndexSizeL( KNormalIndexDirectory ) ); 

	aStats.Append( buf );

	buf = HBufC8::NewL( 64 ); 

	buf->Des().AppendNum( IndexSizeL( KBusyIndexDirectory ) ); 

	aStats.Append( buf );

	if ( iIndexingEnabled )

		{

		AppendOpStatsL( aStats, additions, additionsMicroSeconds ); 

		AppendOpStatsL( aStats, deletes, deletesMicroSeconds );

		}

	if ( iSearchersEnabled ) 

		{

		AppendOpStatsL( aStats, searches, searchesMicroSeconds, searchesPeakMicroSeconds ); 

		AppendOpStatsL( aStats, docs, docsMicroSeconds, docsPeakMicroSeconds ); 

		AppendOpStatsL( aStats, termSearches, termSearchesMicroSeconds, termSearchesPeakMicroSeconds );

		AppendOpStatsL( aStats, terms, termsMicroSeconds, termsPeakMicroSeconds ); 

		}

	}

void CStressWorker::AppendStatsL( RPointerArray<HBufC8>& aStats )

	{

	RArray<TBool> locked;

	CleanupClosePushL( locked ); 

	// First of first: lock all workers that can be locked and request

	// their entries

	for ( TInt i = 0; i < iWorkers.Count(); i++ ) 

		{

		if ( iWorkers[i]->TryLock( KLockWaitMicroSeconds ) == KErrNone )

			{

			locked.Append( ETrue ); 

			}

		else 

			{

			TRAP_IGNORE

				( 

				iLog.LogL( _L( "worker '%S' failed to respond within %d s" ),

						   &iWorkers[i]->Name(),

						   KLockWaitSeconds );

				)

			locked.Append( EFalse ); 

			}

		}