// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\misc\t_svrstress.cpp

// This is a stress test for client server session connect and disconnect

//

#include <e32base.h>

#include <e32base_private.h>

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32svr.h>

#include "u32std.h"

#include <e32atomics.h>

#include <e32panic.h>

#include <e32def.h>

#include <e32def_private.h>

RTest test(_L("T_SVRSTRESS"));

RSemaphore SyncSemaphore;

TUint32 WaitABit;

TInt NumMessageSlots;

TInt UseGlobalMessagePool;

const TInt BigDesLength = 256 * 1024;

#if 1

#define TRACE(t) RDebug::RawPrint(_L8(t))

#else

#define TRACE(t)

#endif

//

// utility functions...

//

void WaitForRequest()

	{

	User::WaitForAnyRequest();

	RThread().RequestSignal(); // put request semaphore count back

	}

TInt WaitForRequest(TRequestStatus& aStatus,TTimeIntervalMicroSeconds32 aTimeout=2*1000000)

	{

	RTimer timer;

	test_Equal(KErrNone,timer.CreateLocal());

	TRequestStatus timeoutStatus;

	timer.After(timeoutStatus,aTimeout);

	User::WaitForRequest(aStatus,timeoutStatus);

	TInt r;

	if(aStatus.Int()==KRequestPending)

		{

		r = KErrTimedOut;

		}

	else

		{

		r = KErrNone;

		timer.Cancel();

		User::WaitForRequest(timeoutStatus);

		}

	CLOSE_AND_WAIT(timer);

	return r;

	}

//

// CMyServer

//

_LIT(KMyServerName,"StressSvr");

class CMyServer : public CServer2

	{

public:

	CMyServer(TInt aPriority);

	static CMyServer* New(TInt aPriority);

	virtual CSession2* NewSessionL(const TVersion&, const RMessage2&) const;

	};

class CMySession : public CSession2

	{

public:

	virtual void ServiceL(const RMessage2& aMessage);

	};

CMyServer* CMyServer::New(TInt aPriority)

	{

	return new CMyServer(aPriority);

	}

CMyServer::CMyServer(TInt aPriority)

	: CServer2(aPriority, ESharableSessions)

	{}

CSession2* CMyServer::NewSessionL(const TVersion&, const RMessage2&) const

	{

	TRACE("O");

	return new(ELeave) CMySession;

	}

TBool RestartServer;

TInt MyServerThread(TAny*)

	{

	CActiveScheduler* pR=new CActiveScheduler;

	if(!pR)

		return KErrNoMemory;

	CActiveScheduler::Install(pR);

	RestartServer = ETrue;

	while(RestartServer)

		{

		__UHEAP_MARK;

		CMyServer* pS=CMyServer::New(0);

		if(!pS)

			return KErrNoMemory;

		TInt r = pS->Start(KMyServerName);

		if(r!=KErrNone)

			return r;

		TRACE("S");

		RThread::Rendezvous(KErrNone);

		CActiveScheduler::Start();

		delete pS;

		__UHEAP_MARKEND;

		}

	delete pR;

	return KErrNone;

	}

//

// RMyServer

//

class RMyServer : public RSessionBase

	{

public:

	enum TFunction

		{

		EStop,

		ESync,

		EPing,

		EShutdown,

		ECompleteWhileCopying

		};

public:

	TInt Connect();

	inline TInt Send(TFunction aFunction) const

		{ return SendReceive(aFunction); }

	inline TInt Send(TFunction aFunction, const TIpcArgs& aArgs) const

		{ return SendReceive(aFunction, aArgs); }

	inline void Send(TFunction aFunction, TRequestStatus& aStatus) const

		{ SendReceive(aFunction, aStatus); }

	inline void Send(TFunction aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus) const

		{ SendReceive(aFunction, aArgs, aStatus); }

	};

TInt RMyServer::Connect()

	{

	RMyServer temp;

	TInt r = temp.CreateSession(KMyServerName, TVersion(), UseGlobalMessagePool ? -1 : NumMessageSlots);

	if(r!=KErrNone)

		return r;

	// turn handle into process owned...

	RMyServer temp2(temp);

	r = temp2.Duplicate(RThread());

	temp.Close();

	*this = temp2;

	return r;

	}

//

// CMySession

//

TInt CopierThread(TAny* aPtr)

	{

	RMessage2& msg = *(RMessage2*)aPtr;

	HBufC* bigdes = HBufC::NewMax(BigDesLength);

	if (bigdes == NULL)

		return KErrNoMemory;

	TPtr ptr = bigdes->Des();

	RThread().Rendezvous(KErrNone);

	RDebug::Print(_L("START\n"));

	TInt r = msg.Read(2, ptr);

	RDebug::Print(_L("DONE\n"));

	delete bigdes;

	return r;

	}

void CMySession::ServiceL(const RMessage2& aMessage)

	{

	RThread client;

	RThread copier;

	aMessage.Client(client);

	TRequestStatus* s;

	TRequestStatus* s2;

	TRequestStatus logon, rendez;

	TInt r;

	s = (TRequestStatus*)aMessage.Ptr0();

	switch(aMessage.Function())

		{

	case RMyServer::EStop:

		TRACE("E");

		CActiveScheduler::Stop();

		break;

	case RMyServer::ESync:

		TRACE("Y");

		client.RequestComplete(s,KErrNone);		// let client know we've received the message

		SyncSemaphore.Wait();					// wait for signal from client

		s = (TRequestStatus*)aMessage.Ptr1();	// use second status for later end signal

		aMessage.Complete(KErrNone);			// complete the message

		break;

	case RMyServer::EPing:

		TRACE("P");

		aMessage.Complete(KErrNone);

		break;

	case RMyServer::EShutdown:

		TRACE("D");

		RestartServer = EFalse;

		CActiveScheduler::Stop();

		break;

	case RMyServer::ECompleteWhileCopying:

		s2 = (TRequestStatus*)aMessage.Ptr1();

		r = copier.Create(_L("Copier"),CopierThread,KDefaultStackSize,&User::Allocator(),(TAny*)&aMessage);

		if (r == KErrNone)

			{

			copier.Logon(logon);

			copier.Rendezvous(rendez);

			copier.SetPriority(EPriorityLess);

			copier.Resume();

			User::WaitForRequest(rendez);

			User::AfterHighRes(5000); // 5ms delay to let copy actually start

			RDebug::Print(_L("COMPLETING\n"));

			aMessage.Complete(KErrNone);

			User::WaitForRequest(logon);

			copier.Close();

			}

		client.RequestComplete(s,r);

		s = s2;

		break;

	default:

		TRACE("?");

		aMessage.Complete(KErrNotSupported);

		break;

		}

	// let client know we've completed the message...

	TRACE("X");

	client.RequestComplete(s,KErrNone);

	client.Close();

	}

//

// RStressThread

//

class RStressThread

	{

public:

	RStressThread(TThreadFunction aThreadFunction, const char* aName, TInt aDelay=-1);

	~RStressThread();

	void Start();

	void Restart();

	void Stop();

	// for use by thread...

	static RStressThread& Begin(TAny* aInfo);

	TBool Loop();

private:

	TThreadFunction iThreadFunction;

	const char* iName;

	RThread iThread;

	TRequestStatus iLogon;

	TUint iCount;

	TBool iStop;

	TInt iDelay;

private:

	static TInt iInstanceCounter;

	};

TInt RStressThread::iInstanceCounter = 0;

RStressThread::RStressThread(TThreadFunction aThreadFunction, const char* aName, TInt aDelay)

	: iThreadFunction(aThreadFunction), iName(aName), iLogon(KErrNone), iDelay(aDelay)

	{

	iThread.SetHandle(0);

	}

RStressThread::~RStressThread()

	{

	Stop();

	}

void RStressThread::Start()

	{

	iStop = false;

	iCount = 0;

	TBuf<KMaxKernelName> name;

	name.Copy(TPtrC8((const TUint8*)iName));

	name.Append((TText)'-');

	name.AppendNum(iInstanceCounter++);

	test_Equal(KErrNone,iThread.Create(name,iThreadFunction,KDefaultStackSize,&User::Allocator(),this));

	iThread.Logon(iLogon);

	test_Equal(KRequestPending,iLogon.Int());

	TRequestStatus rendezvous;

	iThread.Rendezvous(rendezvous);

	iThread.Resume();

	User::WaitForRequest(rendezvous);

	test_Equal(KErrNone,rendezvous.Int());

	}

void RStressThread::Stop()

	{

	if(!iThread.Handle())

		return; // thread not running

	iStop = true;

	RDebug::Printf("RStressThread::Stop %s (count=%d)",iName,iCount);

	if(WaitForRequest(iLogon,10*1000000)!=KErrNone)

		test(0);

	CLOSE_AND_WAIT(iThread);

	}

void RStressThread::Restart()

	{

	if(iThread.Handle())

		{

		if(iLogon==KRequestPending)

			return; // thread still running

		User::WaitForRequest(iLogon);

		CLOSE_AND_WAIT(iThread);

		}

	Start();

	}

TBool RStressThread::Loop()

	{

	if(iDelay>=0)

		User::AfterHighRes(iDelay);

	++iCount;

	return !iStop;

	}

RStressThread& RStressThread::Begin(TAny* aInfo)

	{

	RStressThread& t = *(RStressThread*)aInfo;

	if(t.iDelay>=0)

		RThread().SetPriority(EPriorityMore); // so this preempts threads after delay

	RThread::Rendezvous(KErrNone);

	return t;

	}

//

//

//

RMyServer Session;

RThread ServerThread;

void NewSession()

	{

	RMyServer newSession;

	TRACE("o");

	test_Equal(KErrNone,newSession.Connect());

	RMyServer oldSession(Session);

	Session = newSession;

	TRACE("c");

	if(oldSession.Handle())

		CLOSE_AND_WAIT(oldSession);

	}

TInt SessionCloserThread(TAny* aInfo)

	{

	RStressThread& t = RStressThread::Begin(aInfo);

	do

		{

		NewSession();

		}

	while(t.Loop());

	return KErrNone;

	}

TInt ServerStopperThread(TAny* aInfo)

	{

	RStressThread& t = RStressThread::Begin(aInfo);

	do

		{

		TRACE("s");

		TRequestStatus rendezvous;

		ServerThread.Rendezvous(rendezvous);

		TRequestStatus s1 = KRequestPending;

		TRequestStatus s2;

		Session.Send(RMyServer::EStop,TIpcArgs(&s1),s2);

		User::WaitForRequest(s1,s2);

		if(s2!=KRequestPending)

			{

			test_Equal(KErrServerTerminated,s2.Int());

			User::WaitForRequest(s1);

			}

		User::WaitForRequest(rendezvous);

		NewSession();

		}

	while(t.Loop());

	return KErrNone;

	}

TInt SessionPingerThread(TAny* aInfo)

	{

	RStressThread& t = RStressThread::Begin(aInfo);

	do

		{

		TRACE("p");

		TRequestStatus s1 = KRequestPending;

		TRequestStatus s2;

		Session.Send(RMyServer::EPing,TIpcArgs(&s1),s2);

		User::WaitForRequest(s1,s2);

		if(s2.Int()==KErrNone)

			{

			// message completed OK, wait for servers extra signal

			User::WaitForRequest(s1);

			}

		else if(s2.Int()==KErrServerTerminated)

			{

			// server died before message processed, there shouldn't be an extra signal

			test_Equal(KRequestPending,s1.Int());

			}

		else

			{

			// assume message was completed by server, but we didn't get signalled because session was closed

			test_Equal(KRequestPending,s2.Int());

			test_Equal(KErrNone,s1.Int());

			}

		}

	while(t.Loop());

	return KErrNone;

	}

void TestInit()

	{

	RThread().SetPriority(EPriorityMuchMore); // so this main thread is higher priority than workers

	test_Equal(KErrNone,SyncSemaphore.CreateLocal(0,EOwnerProcess));

	// calculate async cleanup timeout value...

	TInt factor = UserSvr::HalFunction(EHalGroupVariant, EVariantHalTimeoutExpansion, 0, 0);

	if (factor<=0)

		factor = 1;

	if (factor>1024)

		factor = 1024;

	WaitABit = 200000 * (TUint32)factor;

	}

void StartServer()

	{

	// start test server...

	test_Equal(KErrNone,ServerThread.Create(_L("Server"),MyServerThread,KDefaultStackSize,1<<12,1<<20,0));