/*

* Copyright (c) 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: Monitoring application for servers restarting & IAD

*

*/

#include "mdscommoninternal.h"

#include "watchdog.h"

_LIT( KHarvesterServerProcess, "HarvesterServer*" );

_LIT( KHarvesterServerExe, "harvesterserver.exe" );

// Print macro

#ifdef _DEBUG

#include <e32svr.h>

#define PRINT(x) RDebug::Print x

#else

#define PRINT(x)

#endif

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// Constructor.

// ---------------------------------------------------------------------------

//

CWatchdog* CWatchdog::NewL()

    {

    PRINT(_L("CWatchdog::NewL()"));

    CWatchdog* self = new ( ELeave ) CWatchdog();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// C++ constructor.

// ---------------------------------------------------------------------------

//

CWatchdog::CWatchdog() : 

    CActive( CActive::EPriorityStandard ), iState(EIdle)

    {

    // Add to active scheduler.

    CActiveScheduler::Add( this );

    }

// ---------------------------------------------------------------------------

// 2nd phase constructor.

// ---------------------------------------------------------------------------

//

void CWatchdog::ConstructL()

    {

    PRINT(_L("CWatchdog::ConstructL()"));

    TFullName name;

    // find Harvester Server

    TFindProcess findProcess( KHarvesterServerProcess );

    if ( findProcess.Next(name) == KErrNone )

        {                

        PRINT(_L("CWatchdog::ConstructL() - found server, start listening"));

        User::LeaveIfError( iProcess.Open(name) );

        iState = ERunning;

        // logon to get termination signal

        iProcess.Logon(iStatus);        

        SetActive();

        }        

    else

        {               

        PRINT(_L("CWatchdog::ConstructL() - start Harvester server"));

        // start new Harvester            

        Start();

        }

    PRINT(_L("CWatchdog::ConstructL() - create observer"));

    iShutdownObserver = CWDShutdownObserver::NewL( *this );        

    iSelfShutdownObserver = CWDSelfShutdownObserver::NewL( *this ); 

    }

void CWatchdog::Start()

    {  

    PRINT(_L("CWatchdog::Start()"));

    // Double check that harvester server is not already running

    TFullName name;

    TInt res( KErrNone );

    // find really Harvester Server, using TFindServer to avoid logon a dead process

    TFindServer findServer( KHarvesterServerProcess );

    if ( findServer.Next(name) == KErrNone )

        {

        TFindProcess findProcess( KHarvesterServerProcess );

        if ( findProcess.Next(name) == KErrNone )

            {

            PRINT(_L("CWatchdog::Start() - server already running, start listening"));

            iProcess.Close();

            res = iProcess.Open(name);

            if ( res != KErrNone )

                {

                PRINT(_L("CWatchdog::Start() - error in starting listening "));

                return;

                }

            iState = EWaitingRendezvous;

            SetActive();

            return;

            }

        }  

    // close the panic process

    TFindProcess findProcess( KHarvesterServerProcess );

    if ( findProcess.Next(name) == KErrNone )

        {                

        iProcess.Close();

        }

    // Create the server process

    // KNullDesC param causes server's E32Main() to be run

    res = iProcess.Create( KHarvesterServerExe, KNullDesC );

    if ( res != KErrNone )

        {

        PRINT(_L("CWatchdog::ConstructL() - error in server creation"));

        return;

        }

    // start process and wait until it is constructed                

    iProcess.Rendezvous(iStatus);                                         

    if( iStatus != KRequestPending )

        {

        iProcess.Kill( 0 );   // abort startup

        }

    else

        {

        iProcess.Resume();    // logon OK - start the server   

        iState = EWaitingRendezvous;

        SetActive();

        }

    PRINT(_L("CWatchdog::ConstructL() - Start end"));

    }    

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CWatchdog::~CWatchdog()

    {

    delete iSelfShutdownObserver;

    Cancel();

    }

// ---------------------------------------------------------------------------

// Active object's request handling.

// ---------------------------------------------------------------------------

//

void CWatchdog::RunL()

    {

    PRINT(_L("CWatchdog::RunL"));

    	switch (iState)

    	{

          case EIdle:

              {

              PRINT(_L("CWatchdog::RunL() - EIdle"));

              break;

              }

          case EWaitingRendezvous:          

              {

              PRINT(_L("CWatchdog::RunL() - EWaitingRendezvous"));

              iState = ERunning;              

              // logon to get termination signal

              iProcess.Logon(iStatus);        

              SetActive();

              break;

              }             

          case ERunning:

              {

              PRINT(_L("CWatchdog::RunL() - server died"));

              // server died unexpectedly, start it    

              Start();

              break;

              }

          case EShuttingDown:

              {

              PRINT(_L("CWatchdog::RunL() - IAD shutdown"));

              // Do nothing              

              break;

              }

          case ERestarting:

              {

              PRINT(_L("CWatchdog::RunL() - IAD restart"));

              Start();

              break;

              }

          default:

              break; 

    	}

    }

// ---------------------------------------------------------------------------

// Active object's request error handling.

// ---------------------------------------------------------------------------

//

TInt CWatchdog::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Cancel the request.

// ---------------------------------------------------------------------------

//

void CWatchdog::DoCancel()

    {

    PRINT(_L("CWatchdog::DoCancel()"));

    iProcess.LogonCancel(iStatus);

    iProcess.Close();

    }

// -----------------------------------------------------------------------------

// CWatchdog::ShutdownNotification

// -----------------------------------------------------------------------------

//

void CWatchdog::ShutdownNotification()

    {

    iState = EShuttingDown;

    PRINT((_L("CWatchdog::ShutdownNotification() IsActive() = %d"), IsActive() ));

    }

// -----------------------------------------------------------------------------

// CWatchdog::ShutdownNotification

// -----------------------------------------------------------------------------

//

void CWatchdog::RestartNotification()

    {

    PRINT(_L("CWatchdog::RestartNotification()"));

    if (!IsActive())

        SetActive();

    iState = ERestarting;    

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

    }

void CWatchdog::SelfShutdownNotification()

    {

    PRINT(_L("CWatchdog::SelfShutdownNotification()"));

    CActiveScheduler::Stop();

    }

void MainL()

    {

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

    CActiveScheduler::Install( scheduler );

    CleanupStack::PushL( scheduler );

    CWatchdog* w = CWatchdog::NewL();

    CleanupStack::PushL( w );

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( 2, scheduler );

    }

TInt E32Main()

    {

    TInt err = KErrNoMemory;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if ( cleanupStack )

        {

        TRAP( err, MainL() );

        }

    delete cleanupStack;

    return err;

    }