// client_command.cpp
// 
// Copyright (c) 2009 - 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//

#include <fshell/ioutils.h>
#include <fshell/ltkutils.h>
#include "command_base.h"

namespace IoUtils
	{

_LIT(KNewLine, "\r\n");
_LIT(KOutgoingMarker, ">");
_LIT(KIncomingMarker, "<");


//
// CServerWatcher.
//

NONSHARABLE_CLASS(CServerWatcher) : public CActive
	{
public:
	static CServerWatcher* NewL(const TDesC& aServerExeName, CClientBase& aClient);
	~CServerWatcher();
	void Kill(TInt aReason);
private:
	CServerWatcher(CClientBase& aClient);
	void ConstructL(const TDesC& aServerExeName);
private: // From CActive.
	virtual void RunL();
	virtual void DoCancel();
private:
	CClientBase& iClient;
	RProcess iServerProcess;
	};

CServerWatcher* CServerWatcher::NewL(const TDesC& aServerExeName, CClientBase& aClient)
	{
	CServerWatcher* self = new(ELeave) CServerWatcher(aClient);
	CleanupStack::PushL(self);
	self->ConstructL(aServerExeName);
	CleanupStack::Pop(self);
	return self;
	}

CServerWatcher::~CServerWatcher()
	{
	Cancel();
	iServerProcess.Close();
	}

void CServerWatcher::Kill(TInt aReason)
	{
	Cancel();
	iServerProcess.Kill(aReason);
	}

CServerWatcher::CServerWatcher(CClientBase& aClient)
	: CActive(CActive::EPriorityStandard), iClient(aClient)
	{
	CActiveScheduler::Add(this);
	}

void CServerWatcher::ConstructL(const TDesC& aServerExeName)
	{
	_LIT(KWildCard, "*");
	TName processName(aServerExeName);
	processName.Append(KWildCard);
	TFindProcess findProcess(processName);
	TFullName name;
	StaticLeaveIfErr(findProcess.Next(name), _L("Unable to find server process '%S'"), &aServerExeName);
	StaticLeaveIfErr(iServerProcess.Open(findProcess), _L("Unable to open server process '%S'"), &aServerExeName);
	if (findProcess.Next(name) != KErrNotFound)
		{
		StaticLeaveIfErr(KErrArgument, _L("Found more than one instance of '%S'"), &aServerExeName);
		}
	iServerProcess.Logon(iStatus);
	if (iStatus != KRequestPending)
		{
		User::WaitForRequest(iStatus);
		StaticLeaveIfErr(KErrGeneral, _L("Failed to logon to '%S' - %d"), &aServerExeName, iStatus.Int());
		}
	SetActive();
	}

void CServerWatcher::RunL()
	{
	TExitCategoryName exitCategory(iServerProcess.ExitCategory());
	iClient.HandleServerDeath(iServerProcess.ExitType(), iServerProcess.ExitReason(), exitCategory);
	}

void CServerWatcher::DoCancel()
	{
	iServerProcess.LogonCancel(iStatus);
	}


//
// CServerReader.
//

NONSHARABLE_CLASS(CServerReader) : public CActive
	{
public:
	static CServerReader* NewL(RIoReadHandle& aReadHandle, CClientBase& aClient);
	~CServerReader();
private:
	CServerReader(RIoReadHandle& aReadHandle, CClientBase& aClient);
	void ConstructL();
	void Queue();
private: // From CActive.
	virtual void RunL();
	virtual void DoCancel();
private:
	RIoReadHandle& iReadHandle;
	CClientBase& iClient;
	TBuf<0x200> iLine;
	};

CServerReader* CServerReader::NewL(RIoReadHandle& aReadHandle, CClientBase& aClient)
	{
	CServerReader* self = new(ELeave) CServerReader(aReadHandle, aClient);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CServerReader::~CServerReader()
	{
	Cancel();
	}

CServerReader::CServerReader(RIoReadHandle& aReadHandle, CClientBase& aClient)
	: CActive(CActive::EPriorityStandard), iReadHandle(aReadHandle), iClient(aClient)
	{
	CActiveScheduler::Add(this);
	}

void CServerReader::Queue()
	{
	iLine.Zero();
	iReadHandle.Read(iLine, iStatus);
	SetActive();
	}

void CServerReader::ConstructL()
	{
	iReadHandle.SetReadModeL(RIoReadHandle::ELine);
	iReadHandle.SetLineSeparatorL(KNewLine());
	Queue();
	}

void CServerReader::RunL()
	{
	TInt err = iStatus.Int();
	if (err == KErrEof)
		{
		iClient.HandleServerReadComplete(KErrServerTerminated, iLine);
		}
	else
		{
		iClient.HandleServerReadComplete(err, iLine);
		}
	Queue();
	}

void CServerReader::DoCancel()
	{
	iReadHandle.ReadCancel();
	}


//
// CServerWriter.
//

NONSHARABLE_CLASS(CServerWriter) : public CActive
	{
public:
	static CServerWriter* NewL(RIoWriteHandle& aWriteHandle, CClientBase& aClient);
	~CServerWriter();
	void Write(const TDesC& aLine);
private:
	CServerWriter(RIoWriteHandle& aWriteHandle, CClientBase& aClient);
private: // From CActive.
	virtual void RunL();
	virtual void DoCancel();
private:
	RIoWriteHandle& iWriteHandle;
	CClientBase& iClient;
	HBufC* iBuf;
	};

CServerWriter* CServerWriter::NewL(RIoWriteHandle& aWriteHandle, CClientBase& aClient)
	{
	return new(ELeave) CServerWriter(aWriteHandle, aClient);
	}

CServerWriter::~CServerWriter()
	{
	Cancel();
	delete iBuf;
	}

CServerWriter::CServerWriter(RIoWriteHandle& aWriteHandle, CClientBase& aClient)
	: CActive(CActive::EPriorityStandard), iWriteHandle(aWriteHandle), iClient(aClient)
	{
	CActiveScheduler::Add(this);
	}

void CServerWriter::Write(const TDesC& aLine)
	{
	ASSERT(!IsActive());
	TInt bufferRequired = aLine.Length();
	TBool newLineRequired(EFalse);
	if ((aLine.Length() < KNewLine().Length()) || (aLine.Right(KNewLine().Length()) != KNewLine))
		{
		newLineRequired = ETrue;
		bufferRequired += KNewLine().Length();
		}
	if (iBuf && (iBuf->Des().MaxLength() < bufferRequired))
		{
		iBuf = iBuf->ReAllocL(bufferRequired);
		}
	else
		{
		iBuf = HBufC::NewL(bufferRequired);
		}
	TPtr ptr(iBuf->Des());
	ptr.Copy(aLine);
	if (newLineRequired)
		{
		ptr.Append(KNewLine);
		}
	iWriteHandle.Write(*iBuf, iStatus);
	SetActive();
	}

void CServerWriter::RunL()
	{
	iClient.HandleServerWriteComplete(iStatus.Int());
	}

void CServerWriter::DoCancel()
	{
	iWriteHandle.WriteCancel();
	}


EXPORT_C CClientBase::CClientBase(TUint aFlags, const TDesC& aServerExeName, const TDesC& aPersistentConsoleName, const TDesC& aServerPrompt)
	: CCommandBase(EManualComplete | aFlags), iServerExeName(aServerExeName), iPersistentConsoleName(aPersistentConsoleName), iServerPrompt(aServerPrompt)
	{
	}

EXPORT_C CClientBase::~CClientBase()
	{
	delete iCommand;
	delete iServerReader;
	delete iServerWriter;
	delete iServerWatcher;
	iServerWritePipe.Close();
	iServerWriteHandle.Close();
	iServerReadPipe.Close();
	iServerReadHandle.Close();
	iPcons.Close();
	iServerProcess.Close();
	iLines.ResetAndDestroy();
	}
	
_LIT(KWritePipeNameFmt, "%S client->server pipe");
_LIT(KWriterNameFmt, "%S server writer");
_LIT(KReadPipeNameFmt, "%S server->client pipe");
_LIT(KReaderNameFmt, "%S server reader");

EXPORT_C void CClientBase::DoRunL()
	{
	TInt err = iPcons.OpenByName(IoSession(), iPersistentConsoleName);
	if (err==KErrNotFound)
		{
		if (iVerbose)
			{
			Printf(_L("'%S' not found, creating...\r\n"), &iPersistentConsoleName);
			}
		LeaveIfErr(iPcons.Create(IoSession(), iPersistentConsoleName, iPersistentConsoleName), _L("Couldn't create persistent console '%S'"), &iPersistentConsoleName);
		TRAPL(iServerProcess.CreateL(iServerExeName, KNullDesC(), IoSession(), iPcons, &Env()), _L("Couldn't create server process"));
		}
	else
		{
		LeaveIfErr(err, _L("Cannot open persistent console '%S'"), &iPersistentConsoleName);
		}

	iServerWatcher = CServerWatcher::NewL(iServerExeName, *this);
		
	TName objName;		

	iServerWritePipe.CreateL(IoSession());
	objName.AppendFormat(KWritePipeNameFmt, &Name());
	IoSession().SetObjectNameL(iServerWritePipe.SubSessionHandle(), objName);

	iServerWriteHandle.CreateL(IoSession());
	objName.Zero();
	objName.AppendFormat(KWriterNameFmt, &Name());
	IoSession().SetObjectNameL(iServerWriteHandle.SubSessionHandle(), objName);
	iServerWriteHandle.SetModeL(RIoWriteHandle::EText);
	iServerWritePipe.AttachL(iServerWriteHandle);
	// attach the pcons reader to the other end of our server write pipe
	LeaveIfErr(iPcons.AttachReader(iServerWritePipe, RIoPersistentConsole::EDetachOnHandleClose), _L("Cannot connect reader to persistent console %S"), &iPersistentConsoleName);
	iServerWriter = CServerWriter::NewL(iServerWriteHandle, *this);

	iServerReadPipe.CreateL(IoSession());
	objName.Zero();
	objName.AppendFormat(KReadPipeNameFmt, &Name());
	IoSession().SetObjectNameL(iServerReadPipe.SubSessionHandle(), objName);
	
	iServerReadHandle.CreateL(IoSession());
	objName.Zero();
	objName.AppendFormat(KReaderNameFmt, &Name());
	IoSession().SetObjectNameL(iServerReadHandle.SubSessionHandle(), objName);
	iServerReadPipe.AttachL(iServerReadHandle, RIoEndPoint::EForeground);
	// attach the pcons writer to the other end of our server read pipe
	LeaveIfErr(iPcons.AttachWriter(iServerReadPipe, RIoPersistentConsole::EDetachOnHandleClose), _L("Cannot connect writer to persistent console %S"), &iPersistentConsoleName);
	iServerReader = CServerReader::NewL(iServerReadHandle, *this);
	
	if (iServerProcess.Process().Handle() != KNullHandle && iServerProcess.Process().Handle() != RProcess().Handle())
		{
		// We created a new server process, but it's not yet been resumed.
		iServerProcess.Detach(); // Note, iServerWatch has already logged onto the process so there's no need to use RChildProcess::Run.
		iWaitingForServerPrompt = ETrue;
		}
	else
		{
		// The server was already running - no need to wait for a prompt, go ahead and write the command.
		SendCommand();
		}
	}

EXPORT_C void CClientBase::ArgumentsL(RCommandArgumentList& aArguments)
	{
	_LIT(KCommand, "command");

	if (UsingCif()) // Test this dynamically for the time being because not all sub-classes have been migrated to CIFs.
		{
		aArguments.AppendStringL(iCommand, KCommand);
		}
	else
		{
		_LIT(KCommandDescription, "The command to run.");
		aArguments.AppendStringL(iCommand, KCommand, KCommandDescription, KValueTypeFlagLast);
		}
	}

EXPORT_C void CClientBase::HandleLeave(TInt aError)
	{
	CCommandBase::HandleLeave(aError);
	}

void CClientBase::HandleServerReadComplete(TInt aError, TDes& aLine)
	{
	if (aError == KErrEof)
		{
		Complete(KErrNone);
		}
	else if (aError)
		{
		iServerWatcher->Kill(KErrAbort);
		Complete(aError, _L("Failed to read server response"));
		}
	else if (aLine == iServerPrompt)
		{
		if (iWaitingForServerPrompt)
			{
			iWaitingForServerPrompt = EFalse;
			SendCommand();
			}
		else
			{
			TRAPD(err, HandleServerResponseL(iLines));
			Complete(err);
			}
		}
	else
		{
		if (iVerbose)
			{
			Write(KIncomingMarker);
			Write(aLine);
			}
		if (!iWaitingForServerPrompt)
			{
			aLine.TrimRight();
			HBufC* buf = aLine.AllocLC();
			iLines.AppendL(buf);
			CleanupStack::Pop(buf);
			}
		}
	}

void CClientBase::HandleServerWriteComplete(TInt aError)
	{
	if (aError)
		{
		iServerWatcher->Kill(KErrAbort);
		Complete(aError, _L("Failed to write command to server"));
		}
	}

void CClientBase::HandleServerDeath(TExitType aExitType, TInt aExitReason, const TDesC& aExitCategory)
	{
	if (aExitType == EExitPanic)
		{
		Complete(KErrServerTerminated, _L("Server '%S' PANIC - %S %d"), &iServerExeName, &aExitCategory, aExitReason);
		}
	else if (aExitReason)
		{
		Complete(aExitReason, _L("Server '%S' exitied abnormally"), &iServerExeName);
		}
	else
		{
		Complete();
		}
	}

void CClientBase::SendCommand()
	{
	if (iVerbose)
		{
		Write(KOutgoingMarker);
		Write(*iCommand);
		Write(KNewLine);
		}
	iServerWriter->Write(*iCommand);
	}

	} // namespace IoUtils