testexecfw/stf/stfext/testmodules/teftestmod/testexecmdw/filelogger/src/server.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/testexecfw/stf/stfext/testmodules/teftestmod/testexecmdw/filelogger/src/server.cpp Fri Apr 09 10:46:28 2010 +0800
@@ -0,0 +1,552 @@
+/*
+* Copyright (c) 2005-2009 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:
+* Main log server engine.
+* Process log requests from multiple clients simultaneously.
+*
+*/
+
+
+
+/**
+ @file server.cpp
+*/
+#include "server.h"
+
+CLogServer* CLogServer::NewL()
+/**
+ * @return - Instance of the log server
+ */
+ {
+ CLogServer * server = new (ELeave) CLogServer();
+ CleanupStack::PushL(server);
+ server->ConstructL();
+ // CServer base class call
+ server->StartL(KFileLogrerServerName);
+ CleanupStack::Pop(server);
+ return server;
+ }
+
+void CLogServer::ConstructL()
+/**
+ * Second phase construction
+ */
+ {
+ User::LeaveIfError(Fs().Connect());
+ }
+
+
+CLogServer::CLogServer() : CServer2(EPriorityStandard,ESharableSessions)
+/**
+ * Constructor
+ */
+ {
+ }
+
+CLogServer::~CLogServer()
+/**
+ * Destructor
+ */
+ {
+ // Close the array of control structures
+ LogControl().Close();
+ Fs().Close();
+ }
+
+
+CSession2* CLogServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const
+/**
+ * @param RMessage - RMessage for the session open
+ */
+ {
+ // Just create the session
+ CLogSession* session = new (ELeave) CLogSession();
+ return session;
+ }
+
+void CLogServer::ControlComplete(CLogFileControl& aControl)
+/**
+ * @param aControl - Logfile control class reference
+ *
+ * Checks to see if this control session can be removed
+ */
+ {
+ // Check session count and the data buffers on the queue
+ if(aControl.SessionCount() || !aControl.QueueEmpty())
+ return;
+
+ // There are no subsessions mapped to the logfile control class and
+ // no data buffers on its write queue
+ // Loop through the server's control array and remove it then delete it
+ TInt i;
+ for(i=0;i<LogControl().Count();i++)
+ {
+ if(&aControl == LogControl()[i])
+ {
+ // Done
+ LogControl().Remove(i);
+ delete &aControl;
+ break;
+ }
+ }
+ // If it's the last one then exit the server
+ if(!LogControl().Count())
+ CActiveScheduler::Stop();
+ }
+
+
+///////
+
+CLogSession::CLogSession()
+/**
+ * Constructor
+ */
+ {
+ }
+
+CLogSession::~CLogSession()
+/**
+ * Destructor
+ */
+ {
+ // Check for null
+ // Session close without a createlog call leaves iControl null
+ if(!iControl)
+ return;
+ // A logfile control structure can have multiple server sessions
+ // decrement its server session count
+ iControl->RemoveSession();
+ CLogServer* p=(CLogServer*) Server();
+ // Shuts Down the server if this is the last open session
+ p->ControlComplete(*iControl);
+ }
+
+void CLogSession::ServiceL(const RMessage2& aMessage)
+/**
+ * @param aMessage - Function and data for the session
+ */
+ {
+ switch(aMessage.Function())
+ {
+ // API CreateLog() call
+ case RFileFlogger::ECreateLog :
+ {
+ // Sanity check to make sure it's not been called multiple times
+ if(iControl)
+ {
+ aMessage.Complete(KErrInUse);
+ break;
+ }
+ // Get the filepath
+ // size policed on the client side
+ TBuf<KMaxLoggerFilePath> logFilePath;
+ // Read it
+ aMessage.ReadL(0,logFilePath);
+ // Get the log mode in the second argument
+ RFileFlogger::TLogMode logMode;
+ logMode = (RFileFlogger::TLogMode)aMessage.Int1();
+ // Get a pointer to the parent server
+ CLogServer* server=(CLogServer*) Server();
+ // For compare's convert the whole path to lower case
+ logFilePath.LowerCase();
+ // Get rid of leading and trailing spaces.
+ logFilePath.Trim();
+
+ // Loop the through the server's logfile control class list
+ // to see if there's a match.
+ TInt i;
+ for(i=0;i<server->LogControl().Count();i++)
+ {
+ if(server->LogControl()[i]->LogFile() == logFilePath)
+ // This file's already in open so we don't have to open it
+ break;
+ }
+ TInt err = KErrNone;
+ // Check the count
+ if(i < server->LogControl().Count())
+ // Map this session to an existing logfile control class in the list
+ iControl = server->LogControl()[i];
+ else
+ {
+ // Create a new logfile control class
+ // creates/opens the logfile
+ TRAP(err,iControl = CLogFileControl::NewL(*server,logFilePath,logMode));
+ if(!err)
+ { // nancy
+ // find out the type of output format and assign to this new created control
+ TInt error = logFilePath.Find(_L(".xml"));
+ if(error==KErrNotFound) iControl->SetLogType(CLogFileControl::ETxt);
+ else iControl->SetLogType(CLogFileControl::EXml);
+ // end nancy
+ // Append it to the logfile control class list
+ server->LogControl().Append(iControl);
+ }
+ }
+ if(!err)
+ // Increment its session count
+ iControl->AddSession();
+ aMessage.Complete(err);
+ }
+ break;
+ // One of the API write calls
+ case RFileFlogger::EWriteLog :
+ {
+ // Sanity check
+ if(!iControl)
+ {
+ aMessage.Complete(KErrNotFound);
+ break;
+ }
+ // Data can be any size
+ // Get the length from second argument
+ TInt bufferLength = aMessage.Int1();
+ // Get a heap buffer of the right size
+ HBufC8* buffer = HBufC8::NewLC(bufferLength);
+ TPtr8 ptr(buffer->Des());
+ // read the data
+ aMessage.ReadL(0,ptr);
+ // Get a buffer control class contructed with the heap data
+ // takes ownership
+ CLogBuffer* logBuffer = new (ELeave) CLogBuffer(*buffer);
+ CleanupStack::Pop(buffer);
+ // Add it to the logfile control class buffer queue
+ iControl->AddLogBuffer(*logBuffer);
+ if(!iControl->IsActive())
+ // AO is idle, kick into life
+ iControl->Kick();
+ aMessage.Complete(KErrNone);
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+///////
+
+CLogFileControl* CLogFileControl::NewL(CLogServer& aParent, const TDesC& aLogFilePath,RFileFlogger::TLogMode aMode)
+/**
+ * @param aParent - Server reference for callback
+ * @param aLogFilePath - Full path and filename of the logfile
+ * @param aMode - Overwrite or Append
+ *
+ * First phase construction for logfile control class
+ */
+ {
+ CLogFileControl* self = new (ELeave) CLogFileControl(aParent,aLogFilePath);
+ CleanupStack::PushL(self);
+ self->ConstructL(aMode);
+ CleanupStack::Pop();
+ return self;
+ }
+
+CLogFileControl::CLogFileControl(CLogServer& aParent,const TDesC& aLogFilePath) :
+ iParent(aParent),
+ iLogFileName(aLogFilePath),
+ iTransmitted(EFalse)
+/**
+ * @param aParent - Server reference for callback
+ * @param aLogFilePath - Full path and filename of the logfile
+ *
+ * Constructor - Safe initialisation
+ */
+ {
+ iQueue.SetOffset(CLogBuffer::LinkOffset());
+ }
+
+void CLogFileControl::ConstructL(RFileFlogger::TLogMode aMode)
+/**
+ * @param aMode - Overwrite or Append
+ *
+ * Second phase construction - Create or open the logfile
+ */
+ {
+ if(aMode == RFileFlogger::ELogModeOverWrite)
+ // In overwrite mode replace
+ User::LeaveIfError(iLogFile.Replace(iParent.Fs(),iLogFileName,EFileWrite));
+ else
+ {
+ // For append try open then replace
+ TInt err = iLogFile.Open(iParent.Fs(),iLogFileName,EFileWrite);
+ if(err != KErrNone)
+ // Bomb out if replace fails
+ User::LeaveIfError(iLogFile.Replace(iParent.Fs(),iLogFileName,EFileWrite));
+ else
+ {
+ // Open worked. Position at EOF
+ TInt pos;
+ iLogFile.Size(pos);
+ User::LeaveIfError(iLogFile.Seek(ESeekEnd,pos));
+ }
+ }
+ }
+
+CLogFileControl::~CLogFileControl()
+/**
+ * Destructor
+ * The server maintains a list of these classes and will not destruct one if there
+ * is data on its queue
+ * Destructor just closes the file handle.
+ */
+ {
+ iLogFile.Close();
+ }
+
+void CLogFileControl::RunL()
+/**
+ * Main File writing pump
+ * Called on write completion or Kick() by the session that accepts the data
+ */
+ {
+#if (defined _DEBUG)
+ _LIT(KPanic,"LogEng RunL()");
+#endif
+ __ASSERT_DEBUG(iStatus.Int() == KErrNone,User::Panic(KPanic,iStatus.Int()));
+ // Check to see if this is the result of write completion
+ if(iTransmitted)
+ {
+ // Write completed
+ // Remove the buffer at the head of the queue and free it
+ CLogBuffer* buffer = iQueue.First();
+ iQueue.Remove(*buffer);
+ delete buffer;
+ }
+ // Check to see if there's more on the queue
+ if(!iQueue.IsEmpty())
+ {
+ // There is so write the head of the queue
+ CLogBuffer* buffer = iQueue.First();
+ SetActive();
+ // Set the flag to say we've transmitted
+ iTransmitted = ETrue;
+
+// ------------------------------------
+ if(iLogFormat==ETxt) WriteTxt(buffer->Buf());
+ else WriteXml(buffer->Buf());
+ }
+ else
+ {
+ // Nothing on the queue
+ iTransmitted = EFalse;
+ // Call into the server to check if this resource can be freed
+ iParent.ControlComplete(*this);
+ }
+ }
+
+void CLogFileControl::WriteXml(const TDesC8 &aDes)
+/**
+ * @param aDes - send a aDes string in xml format to a log file
+ */
+ {
+/*--------- Maintaince Warning: -----------------------------------
+******* the fomat of below is sensible from client original format.
+******* Any change should match actual string formated from client.
+******* Double check the code on client side
+
+* The current assumtion of format:
+* First string values are seperated by sign " - " and extra pair of fields are
+* seperated from main log message by long unusual string "LogFieldsRequiredBeingAddedToAboveLogMessage"
+* The \t used to seperate field name and field value and \r\n used to seperate
+* each other from those pairs of field
+* \t\t\t\t\t\t is used to end of whole string
+--------------------------------------------------------------------------------*/
+ _LIT8(KxmlHeader,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\r\n<LOGFILE>");
+ //The order of variables:
+ // time - aTime
+ // Severity - aSeverity
+ // Thread - aThread
+ // Filename - aFilename
+ // Linenumber - aLinenumber
+ // Text - aText
+
+ // Start of string retrive/deformating
+ HBufC8* pBuf1 = HBufC8::NewL(KMaxLoggerLineLength*2); //(aDes.Length()+200);
+ if(!pBuf1)
+ {
+ return; // no memory
+ }
+ TPtr8 aPtr(pBuf1->Des()); // used for searching
+ TPtr8 alogbuf(pBuf1->Des()); //used for final log
+ aPtr.Append(aDes);
+ TPtrC8 SearchBuf;
+ TInt aCount[8];
+ aCount[0]=0;
+ TInt posI(0);
+
+// retrive log message:
+ // Retrive common part of log message:
+ for(TInt i = 1; i<6; i++)
+ {
+ SearchBuf.Set(aPtr.Mid(posI));
+ aCount[i]=SearchBuf.Find(KSeperation8)+posI;
+ posI=aCount[i]+3;
+ if(aCount[i]<aCount[i-1]) return; // wrong format string from client
+ }
+ // seperating common log message and extra log fields will be easy for future maintaince.
+ TLogField8* alogField = new TLogField8[6]; // the common part of log message for both
+ // with and without extra log fields
+ if(!alogField) return; // no memory
+
+ TLogField8* extralogField=NULL; // only applied to extra log fields
+
+ TInt alength=0; // a length of array of extra log fields
+
+ alogField[0].iLogTag8.Copy(_L8("TIME"));
+ alogField[1].iLogTag8.Copy(_L8("SEVERITY"));
+ alogField[2].iLogTag8.Copy(_L8("THREAD"));
+ alogField[3].iLogTag8.Copy(_L8("FILENAME"));
+ alogField[4].iLogTag8.Copy(_L8("LINENUMBER"));
+ alogField[5].iLogTag8.Copy(_L8("TEXT"));
+
+ alogField[0].iLogValue8.Copy(aPtr.Mid(aCount[0],aCount[1]-aCount[0]));
+ for(TInt i=1; i<5; i++)
+ {
+ alogField[i].iLogValue8.Copy(aPtr.Mid(aCount[i]+3,aCount[i+1]-aCount[i]-3));
+ }
+
+ SearchBuf.Set(aPtr.Mid(posI));
+ aCount[6]=SearchBuf.Find(_L8("LogFieldsRequiredBeingAddedToAboveLogMessage"))+posI;
+ if(aCount[6]<posI) // no addtional fields. Find return value is KErrNotFound or >0
+ {
+ TInt currentLength = alogField[5].iLogValue8.Length() ;
+ //this sentence will append the log info without buffer limit.
+ TInt newAppendLength = aDes.Length()-aCount[5]-5;
+ //The max length for log buff in this
+ TInt bufferLeft = alogField[5].iLogValue8.MaxLength() - currentLength;
+ // get the smaller one between the two
+ TInt enabledLength = bufferLeft > newAppendLength ? newAppendLength : bufferLeft ;
+ alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,enabledLength));
+ //alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,aDes.Length()-aCount[5]-5));
+ }
+ else
+ {
+ alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,aCount[6]-aCount[5]-5));
+ posI=aCount[6]+45; //45 is from the length of long string and a tab
+ SearchBuf.Set(aPtr.Mid(posI));
+ aCount[7]=SearchBuf.Find(_L8("\r\n"))+posI;
+ TLex8 lex(aPtr.Mid(posI,aCount[7]-posI)); // get the length
+ TInt err=lex.Val(alength);
+ if (err) alength=0; // ignor the extra log fields. Let the log go
+
+ // Retrive the extra log fields
+ extralogField = new TLogField8[alength];
+ if(!extralogField) return; // no memory
+ for(TInt i=0; i<alength; i++)
+ {
+ aCount[6]=aCount[7]+2;
+ SearchBuf.Set(aPtr.Mid(aCount[6]));
+ aCount[7]=SearchBuf.Find(_L8("\t"))+aCount[6];
+ extralogField[i].iLogTag8.Copy(aPtr.Mid(aCount[6],aCount[7]-aCount[6]));
+ aCount[6]=aCount[7]+1;
+ SearchBuf.Set(aPtr.Mid(aCount[6]));
+ aCount[7]=SearchBuf.Find(_L8("\r\n"))+aCount[6];
+ extralogField[i].iLogValue8.Copy(aPtr.Mid(aCount[6],aCount[7]-aCount[6]));
+ }
+ }
+
+ // Start to organize an XML format:
+ TInt afileSize;
+ _LIT(KLogMutex, "LoggingServerMutex");
+ RMutex mutex;
+ TInt r = mutex.CreateGlobal(KLogMutex);
+ if(r==KErrAlreadyExists)
+ r = mutex.OpenGlobal(KLogMutex);
+
+ if(!r) mutex.Wait(); // if still failed, let logging go
+ //without bother the mutex
+
+ iLogFile.Size(afileSize);
+ if(afileSize<12) // 12 is from charters of "\r\n</LOGFILE>"
+ //It shoud happened once at the beginning of the file
+ // such as overwrite mode
+ {
+ afileSize=12; // used for lock position
+ alogbuf.Copy(KxmlHeader);
+ }
+ alogbuf.Append(_L8("\r\n<MESSAGE>\r\n"));
+ for(TInt i=0; i<6; i++)
+ {
+ alogbuf.Append(_L8(" <"));
+ alogbuf.Append(alogField[i].iLogTag8);
+ alogbuf.Append(_L8(">"));
+ alogbuf.Append(alogField[i].iLogValue8);
+ alogbuf.Append(_L8("</"));
+ alogbuf.Append(alogField[i].iLogTag8);
+ alogbuf.Append(_L8(">\r\n"));
+ }
+ for(TInt i=0; i<alength; i++)
+ {
+ alogbuf.Append(_L8(" <"));
+ alogbuf.Append(extralogField[i].iLogTag8);
+ alogbuf.Append(_L8(">"));
+ alogbuf.Append(extralogField[i].iLogValue8);
+ alogbuf.Append(_L8("</"));
+ alogbuf.Append(extralogField[i].iLogTag8);
+ alogbuf.Append(_L8(">\r\n"));
+ }
+
+ alogbuf.Append(_L8("</MESSAGE>"));
+ alogbuf.Append(_L8("\r\n</LOGFILE>"));
+
+ iLogFile.Write(afileSize-12,alogbuf,iStatus);
+ iLogFile.Flush();
+
+ if(!r)
+ {
+ mutex.Signal();
+ mutex.Close();
+ }
+
+ if(extralogField) delete[] extralogField;
+ delete[] alogField;
+ delete pBuf1;
+
+ }
+
+void CLogFileControl::WriteTxt(const TDesC8 &aDes)
+/**
+ * @param aDes - send a aDes string in xml format to a log file
+ */
+ {
+/*--------- Maintaince Warning for aLogBuffer -----------------------------------
+******* the fomat of below is sensible from client original format.
+******* Any change should match actual string formated from client.
+******* Double check the code on client side
+
+* The current assumtion of format:
+* First string values are seperated by sign " - " and extra pair of fields are
+* seperated from main log message by long unusual string "LogFieldsRequiredBeingAddedToAboveLogMessage"
+* The \t used to seperate field name and field value and \r\n used to seperate
+* each other from those pairs of field
+--------------------------------------------------------------------------------*/
+ iLogFile.Write(aDes,iStatus);
+ }
+///////
+CLogBuffer::CLogBuffer(HBufC8& aLogBuffer) : iLogBuffer(aLogBuffer)
+/**
+ * @param aLogBuffer - Heap descriptor. This class takes ownership
+ * Constructor
+ */
+ {
+ }
+
+CLogBuffer::~CLogBuffer()
+/**
+ * Destructor
+ * This class owns a heap buffer so just free it
+ */
+ {
+ delete &iLogBuffer;
+ }