/*
* Copyright (c) 2008 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:  start the server
*
*/


#include "imcacheprocessstarter.h"
// logs
#include "imcachedebugtrace.h"
// system includes
#include <e32std.h>
#include <f32file.h>


// CONSTANTS
_LIT( KEka2ExeDir,"\\sys\\bin\\");
_LIT( KEka2LaunchMutexExt, "[lMtx]" );
const TInt KEka2SrvConnTries = 7;
const TInt KEka2SrvConnInitialRetryWait = 500; //MicroSeconds => 0.0005s


// ==============================================================
// ====================== HELPER CLASS ==========================
// ==============================================================

/**
 * RSessionBase accessor to give to the ProcessStarter
 * access to RSessionBase::CreateSession().
 */
class REka2SessionBaseAccessor : public RSessionBase
    {
    public: // Constructor
        inline REka2SessionBaseAccessor()
            {
            }

    public: // New functions

        /**
         * Public access to RSessionBase::CreateSession().
         */
        inline TInt CreateSession( const TDesC& aServer,
                                   const TVersion& aVersion,
                                   TInt aAsyncMessageSlots )
            {
            return RSessionBase::CreateSession( aServer,
                                                aVersion,
                                                aAsyncMessageSlots );
            }
    };


// ==============================================================
// ====================== PROCESSSTARTER ========================
// ==============================================================

// --------------------------------------------------------------
// IMCacheProcessStarter::FullExePathForClientLocation()
// --------------------------------------------------------------
//
void IMCacheProcessStarter::FullExePathForClientLocation(
    const TDesC& aExeName,
    TFileName& aFullExePath )
    {
	TRACE( T_LIT("IMCacheProcessStarter::FullExePathForClientLocation begin") );
    //Get drive (C:) where this client code is installed
        {
        TFileName tmp;
        Dll::FileName( tmp );
        aFullExePath.Copy( TParsePtrC( tmp ).Drive() );
        }

    //Build the rest from the exe path
    aFullExePath.Append( KEka2ExeDir );
    aFullExePath.Append( aExeName );
    TRACE( T_LIT("IMCacheProcessStarter::FullExePathForClientLocation end") );
    }

// --------------------------------------------------------------
// IMCacheProcessStarter::StartInstance()
// --------------------------------------------------------------
//
TInt IMCacheProcessStarter::StartInstance(
    const TDesC& aFullExePath,
    const TDesC& aCommand )
    {
    TRACE( T_LIT("IMCacheProcessStarter::StartInstance begin") );
    RMutex launchMutex;
    TInt error = KErrNotFound;

        {
        // Dynamic mutex name used to allow code share
        TName launchMutexName( TParsePtrC( aFullExePath ).Name() );
        launchMutexName.Append( KEka2LaunchMutexExt );

        // Open or Create mutex to serialize to access to server startup code.
        // (race condition safe way)
        while( error == KErrNotFound )
            {
            error = launchMutex.CreateGlobal( launchMutexName );
            if( error != KErrAlreadyExists )
                {
                break;
                }
            error = launchMutex.OpenGlobal( launchMutexName );
            }

        if( error != KErrNone )
            {
            TRACE( T_LIT("IMCacheProcessStarter::StartInstance end") );
            return error;
            }
        }


    launchMutex.Wait();

    //Serialized access
    error = IMCacheProcessStarter::DoStartInstance( aFullExePath,
                                             aCommand );

    launchMutex.Signal();
    launchMutex.Close();
	TRACE( T_LIT("IMCacheProcessStarter::StartInstance end") );
    return error;
    }

// --------------------------------------------------------------
// IMCacheProcessStarter::ConnectToServer()
// --------------------------------------------------------------
//
TInt IMCacheProcessStarter::ConnectToServer(
    const TDesC& aFullExePath,
    const TDesC& aCommand,
    RSessionBase& aSessionToConnect,
    const TDesC& aServerName,
    const TVersion& aClientVersion,
    TInt aAsyncMessageSlots )
    {
    TRACE( T_LIT("IMCacheProcessStarter::ConnectToServer begin") );
    if( aSessionToConnect.Handle() != KNullHandle )
        {
        return KErrInUse;
        }

    TInt err = KErrNone;
    TInt startupWait = KEka2SrvConnInitialRetryWait;

    //Server connect and launch loop
    for( TInt trie = 0 ; trie < KEka2SrvConnTries ; trie++ )
        {
        REka2SessionBaseAccessor acc;
        err = acc.CreateSession( aServerName,
                                 aClientVersion,
                                 aAsyncMessageSlots );

        if( err == KErrNone )
            {
            //session ownership is now on client
            aSessionToConnect = acc;
            return KErrNone;
            }

        else if( ( err == KErrNotFound ) ||
                 ( err == KErrServerTerminated ) )
            {
            //Server missing or died when connecting
            //Start a new server
            err = IMCacheProcessStarter::StartInstance( aFullExePath,
                                                 aCommand );

            //If process exist already, then all is fine
            //(some other process started it between the origical connect and launch trie)
            if( err == KErrAlreadyExists )
                {
                err = KErrNone;
                }

            //If server process start failed, bail out.
            if( err != KErrNone )
                {
                return err;
                }

            //If this is 2nd or subsequent try,
            //give some time for server to startup
            if( trie > 0 )
                {
                // Code scanner warning : Use of User::After (id:92)
                // it is required to be used here
                User::After( startupWait ); // CSI: 92 # See above
                startupWait = 2 * startupWait;
                }
            }

        else
            {
            //Server process start failed. Bail out.
            return err;
            }
        }
	TRACE( T_LIT("IMCacheProcessStarter::ConnectToServer end") );
    return err;
    }

// --------------------------------------------------------------
// IMCacheProcessStarter::DoStartServerInstance()
// --------------------------------------------------------------
//
TInt IMCacheProcessStarter::DoStartInstance(
    const TDesC& aFullExePath,
    const TDesC& aCommand )
    {
    TRACE( T_LIT("IMCacheProcessStarter::DoStartInstance begin") );
    TInt error = KErrNone;

    //Create process
    RProcess process;
    error = process.Create( aFullExePath, aCommand );

    if( error == KErrNone )
        {
       
            TRequestStatus rendezvousStatus;
            process.Rendezvous( rendezvousStatus );

            process.Resume();
            // Codescanner warning: user of User::WaitForRequest (Id:94)
            // it is required to use at server startup
            User::WaitForRequest( rendezvousStatus ); // CSI: 94 # See above
            error = rendezvousStatus.Int();

            if( process.ExitType() != EExitPending )
                {
                //Something failed in server startup
                //Force the error code to be always something
                //else than KErrNone
                if( error == KErrNone )
                    {
                    error = KErrServerTerminated;
                    }
                }
           
        }

    process.Close();
	TRACE( T_LIT("IMCacheProcessStarter::DoStartInstance end") );
    return error;
    }

// END OF FILE