diff -r 000000000000 -r dfb7c4ff071f commsfwsupport/commselements/serverden/inc/sd_msgs.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsfwsupport/commselements/serverden/inc/sd_msgs.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,504 @@ +// Copyright (c) 2004-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: +// + +/** + @file + @internalComponent +*/ + +#ifndef SYMBIAN_DEN_MSGS_H +#define SYMBIAN_DEN_MSGS_H + +#include +#include +#include + + +#ifdef _DEBUG +// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module +// (if it could happen through user error then you should give it an explicit, documented, category + code) +_LIT(KSpecAssert_ElemSvrDenMsgH, "ElemSvrDenMsgH"); +#endif + +namespace Den +{ + +/** Messages from Main Thread to Worker Threads (with Resp messages being responses +sent back from Worker) +*/ +class TWorkerMsg : public CommsFW::TCFMessage + { +public: + enum + { + /** Number of messages reserved for ESock internal usage. Currently bigger than the actual + number of messages to provide space for more in the future. + @see TWorkerMsg::TCode::ELastWorkerMsgCode + */ + KWorkerMessageCodeReserveSize = 15 + }; + + enum TCode + { + /** This is the first message sent on a binding by any worker thread. It identifies the basics + about the worker + */ + EWorkerIntroduction = CommsFW::TCFCommsMessage::ECodePrivateFlag, + + /** This is the second message sent on a binding by a worker. It identifies a standard set of + cookies. In the future it's expected that the legacy transport will only be used for the above + initial intro message which will carry a boot-strapping cookie and all other cookies will + be identified directly to that one + */ + EWorkerCookies, + + /** This is sent from the main thread to all workers when a significant configuration event + happens, as indicated in the message (eg the boot of modules) + */ + EConfigurationComplete, + + /** This requests that the tier mappings are loaded from CommsDat. A worker can send it to the + PitBoss and the PitBoss can send it to the tier resolver. In the latter case the tier resolver + responds with TWorkerTierMappingsLoaded + */ + ELoadTierMappings, + + /** The tier resolver reports through this that the previously requested load of the tier mappings + is complete + */ + ETierMappingsLoaded, + + /** This is sent from the PitBoss to a worker thread to notify that another worker has + died and the receiver is expected to clean up any data structures/states related to that + dead worker (if any). + The receiver is expected to respond with a ECleanupDeadPeerResp message. + @see TWorkerMsg::ECleanupDeadPeerResp + */ + ECleanupDeadPeer, + + /** Response from worker to main thread that cleanup after dead peer has been completed. + @see TWorkerMsg::ECleanupDeadPeer + */ + ECleanupDeadPeerResp, + + /** Notification that a player role management responsibility has ended (eg a Player data + flows signals the Player hosting subconnections when it unbinds, which can only happen when + all flows have ceased dependency upon the sub-connections + @see TWorkerMsg::TPlaneUnboundMsg + */ + EPlaneUnbound, + + /** Carries data that did not fit into EWorkerIntroduction + */ + EWorkerIntroduction2, + + /** Introduction message from main thread to workers to prompt objects to join their broker in the main thread + */ + EFactoryContainerIntroduction, + + /** Introduces a factory container object broker in the main thread to a worker thread + */ + EBrokerIntroduction, + + /** Dummy trailer code to give reference point for starting a following sequence of message codes. */ + ELastWorkerMsgCode = CommsFW::TCFCommsMessage::ECodePrivateFlag + KWorkerMessageCodeReserveSize + }; + + inline TWorkerMsg(TInt aCode) + { + Code(aCode); + } + }; + +/** +class TWorkerIntroductionMsg +*/ +class TWorkerIntroductionMsg : public TWorkerMsg + { +public: + enum {KCode = TWorkerMsg::EWorkerIntroduction};//< Message code + enum {KMaxIntroductionInfoSize = sizeof(Messages::TNodeId)}; + + inline TWorkerIntroductionMsg(const TWorkerThreadPublicInfo& aWorkerInfo) + : TWorkerMsg(KCode) + { + TParams* params=reinterpret_cast(ParamBlock()); + params->iWorkerInfo = aWorkerInfo; + params->iDebugMsgIntercept = NULL; + params->iFailType = RAllocator::ENone; + params->iFailRate = 0; + params->iIntroductionInfo[0] = 0; //To mark as empty + } + + inline const TWorkerThreadPublicInfo& WorkerInfo() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iWorkerInfo; + } + + inline void IntroductionInfo(TDes8& aIntroductionInfo) const + { + TInt size = aIntroductionInfo.MaxSize() - aIntroductionInfo.Size(); + __ASSERT_DEBUG(size <= KMaxIntroductionInfoSize, User::Panic(KSpecAssert_ElemSvrDenMsgH, 1)); + const TParams* params=reinterpret_cast(ParamBlock()); + aIntroductionInfo.Copy(¶ms->iIntroductionInfo[0], KMaxIntroductionInfoSize); + } + + inline void SetIntroductionInfo(const TDesC8& aIntroductionInfo) + { + __ASSERT_DEBUG(aIntroductionInfo.Size() <= KMaxIntroductionInfoSize, User::Panic(KSpecAssert_ElemSvrDenMsgH, 2)); + + TParams* params=reinterpret_cast(ParamBlock()); + __ASSERT_DEBUG(params->iIntroductionInfo[0] == 0, User::Panic(KSpecAssert_ElemSvrDenMsgH, 3)); + Mem::Copy(params->iIntroductionInfo, aIntroductionInfo.Ptr(), aIntroductionInfo.Size()); + } + +#ifdef _DEBUG + inline void SetFailType(RAllocator::TAllocFail aFailType) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iFailType = aFailType; + } + inline RAllocator::TAllocFail FailType() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iFailType; + } + inline void SetFailRate(TInt aFailRate) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iFailRate = aFailRate; + } + inline TInt FailRate() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iFailType; + } +#endif + +#if defined (__ELEMENTS_MESSAGE_INTERCEPT_ACTIVE) + inline void SetMessageInterceptGlobal(CMessageInterceptRegister* aMsgInterceptRegister) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iDebugMsgIntercept = reinterpret_cast(aMsgInterceptRegister); + } + inline CMessageInterceptRegister* MsgInterceptRegister() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return reinterpret_cast(params->iDebugMsgIntercept); + } +#endif // __ELEMENTS_MESSAGE_INTERCEPT_ACTIVE + +private: + struct TParams /** Message parameters */ + { + TWorkerThreadPublicInfo iWorkerInfo; //< Crucial information about the worker thread/server + // Pointer to the process wide singleton created by the main thread + TAny* iDebugMsgIntercept; + RAllocator::TAllocFail iFailType; + TInt iFailRate; + TUint8 iIntroductionInfo[KMaxIntroductionInfoSize]; + }; + __ASSERT_COMPILE(sizeof(TParams) <= CommsFW::KCFMessageParamBlockSize); + }; + +/** +class TWorkerConfigurationComplete +@see TWorkerMsg::EConfigurationComplete +*/ +class TWorkerConfigurationComplete : public TWorkerMsg + { +public: + enum {KCode = TWorkerMsg::EConfigurationComplete};/**Message code*/ + inline TWorkerConfigurationComplete(TConfigurationCompletionType aType) + : TWorkerMsg(KCode) + { + TParams* params=reinterpret_cast(ParamBlock()); + params->iType = aType; + } + inline TConfigurationCompletionType Type() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iType; + } +private: + struct TParams /** Message parameters */ + { + TConfigurationCompletionType iType; + }; + }; + +/** +class TWorkerCleanupDeadPeerMsg +@see TWorkerMsg::ECleanupDeadPeer +*/ +class TWorkerCleanupDeadPeerMsg : public TWorkerMsg + { +public: + enum {KCode = TWorkerMsg::ECleanupDeadPeer};//< Message code + inline TWorkerCleanupDeadPeerMsg(CommsFW::TWorkerId aWorkerId) + : TWorkerMsg(KCode) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iWorkerId = aWorkerId; + } + inline CommsFW::TWorkerId WorkerId() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iWorkerId; + } +private: + struct TParams /** Message parameters */ + { + CommsFW::TWorkerId iWorkerId; //< Identifying which dead peer to cleanup + }; + }; + +/** +class TWorkerCleanupDeadPeerRespMsg +@see TWorkerMsg::ECleanupDeadPeerResp +*/ +class TWorkerCleanupDeadPeerRespMsg : public TWorkerMsg + { +public: + enum {KCode = TWorkerMsg::ECleanupDeadPeerResp};//< Message code + inline TWorkerCleanupDeadPeerRespMsg(CommsFW::TWorkerId aWorkerId) + : TWorkerMsg(KCode) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iWorkerId = aWorkerId; + } + inline CommsFW::TWorkerId WorkerId() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iWorkerId; + } +private: + struct TParams /** Message parameters */ + { + CommsFW::TWorkerId iWorkerId; //< Identifying which dead peer the cleanup was related to. + }; + }; + +class TPlaneUnboundMsg : public TWorkerMsg + { +public: + enum {KCode = TWorkerMsg::EPlaneUnbound};//< Message code + inline TPlaneUnboundMsg(TPlayerRole aPlayerRole) + : Den::TWorkerMsg(KCode) + { + TParams* params=reinterpret_cast(ParamBlock()); + params->iPlayerRole = aPlayerRole; + } + + inline const TPlayerRole& PlayerRole() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iPlayerRole; + } +private: + struct TParams /** Message parameters */ + { + TPlayerRole iPlayerRole; + }; + }; + +/** +class TPlayerMsg +Messages from a Dealer to a Player in another thread +*/ +class TPlayerMsg : public CommsFW::TCFMessage + { +public: + enum TCode + { + /** This is the most common message. It is used to forward IPC requests + from a Dealer to a Player. */ + EForwardRequest = TWorkerMsg::ELastWorkerMsgCode + 1, + + /** When a session is closed by a client the Dealer will send this message to all Players + that might have relations (sub-sessions) to this session. + @note The receiver is expected to response with a ESessionCloseResp message. + @see TPlayerMsg::ESessionCloseResp + */ + ESessionClose, + + /** Notify the Dealer that cleanup related to the ESessionClose message is completed. + @see TPlayerMsg::ESessionClose + */ + ESessionCloseResp, + }; + + inline TPlayerMsg(TInt aCode) + { + Code(aCode); + } + }; + +/** +class TPlayerForwardRequestMsg +@see TPlayerMsg::EForwardRequest +*/ +class TPlayerForwardRequestMsg : public TPlayerMsg + { +public: + enum {KCode = TPlayerMsg::EForwardRequest};//< Message code + inline TPlayerForwardRequestMsg(const RMessage2& aMsg, CWorkerSubSession* aSubSession):TPlayerMsg(KCode) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iMsg.Adopt(static_cast(const_cast(aMsg))); + params->iSubSession=aSubSession; + } + /* Create requests have no meaningful subsession pointer (it gets created through the request) but can need + to communicate additional status. This is carried through these magic subsession consts + */ + inline static CWorkerSubSession* UnusedParam() + { + return reinterpret_cast(NULL); + } + inline static CWorkerSubSession* NormalCreationFlag() + { + return reinterpret_cast(NULL); + } + inline static CWorkerSubSession* AbnormalCreationFlag() + { + return reinterpret_cast(-1); + } + inline const RSafeMessage& SafeMessage() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iMsg; + } + inline CWorkerSubSession* SubSession() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iSubSession; + } +private: + struct TParams /** Message parameters */ + { + /** The IPC message to process. The Player must complete this itself when ready. + When sent to a Player the Dealer will have forgotten completely about it and left + the responsibility to the Player. + */ + RSafeMessage iMsg; + CWorkerSubSession* iSubSession; + }; + + __ASSERT_COMPILE(sizeof(TParams) <= CommsFW::KCFMessageParamBlockSize); + }; + +/** +class TPlayerSessionCloseMsg +@see TPlayerMsg::ESessionClose +*/ +class TPlayerSessionCloseMsg : public TPlayerMsg + { +public: + enum {KCode = TPlayerMsg::ESessionClose};//< Message code + inline TPlayerSessionCloseMsg(CWorkerSession* aSession):TPlayerMsg(KCode) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iSession=aSession; + } + + inline CWorkerSession* Session() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iSession; + } +private: + struct TParams /** Message parameters */ + { + CWorkerSession* iSession; //< The session that is being closed. + }; + }; + +/** +class TPlayerSessionCloseRespMsg +@see TPlayerMsg::ESessionCloseResp +*/ +class TPlayerSessionCloseRespMsg : public TPlayerMsg + { +public: + enum {KCode = TPlayerMsg::ESessionCloseResp};//< Message code + inline TPlayerSessionCloseRespMsg(CommsFW::TWorkerId aPlayerId, CWorkerSession* aSession) + : TPlayerMsg(KCode) + { + TParams* params = reinterpret_cast(ParamBlock()); + params->iSession=aSession; + params->iPlayerId=aPlayerId; + } + inline CWorkerSession* Session() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iSession; + } + inline const CommsFW::TWorkerId WorkerId() const + { + const TParams* params = reinterpret_cast(ParamBlock()); + return params->iPlayerId; + } +private: + struct TParams /** Message parameters */ + { + CWorkerSession* iSession; //< The session which was closed + CommsFW::TWorkerId iPlayerId; //< Id of the sending worker thread + }; + }; + +class TWorkerTransportMsg : public CommsFW::TCFMessage + { +public: + inline TWorkerTransportMsg(TInt aCode) + { + Code(aCode); + TWorkerTransportParams* params = reinterpret_cast(ParamBlock()); + params->iStatus = NULL; + } + inline TWorkerTransportMsg(TInt aCode, TRequestStatus& aStatus) + { + Code(aCode); + TWorkerTransportParams* params = reinterpret_cast(ParamBlock()); + params->iStatus = &aStatus; + } + inline TRequestStatus& Status() const + { + const TWorkerTransportParams* params = reinterpret_cast(ParamBlock()); + return *params->iStatus; + } + inline TRequestStatus* GetStatusPtr() const + { + const TWorkerTransportParams* params = reinterpret_cast(ParamBlock()); + return params->iStatus; + } + inline void SetStatusPtr(TRequestStatus* aStatus) + { + TWorkerTransportParams* params = reinterpret_cast(ParamBlock()); + params->iStatus = aStatus; + } +protected: + struct TWorkerTransportParams /** Message parameters */ + { + TRequestStatus* iStatus; //< Pointer to request status to set when the request is complete. + }; + }; + +} //namespace Den + +#endif +//SYMBIAN_DEN_MSGS_H + +