/*
* 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 "servermonitor.h"

_LIT(KStar , "*");
_LIT(KExtension, ".exe");
_LIT(KSemaphore, "Semaphore");

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// Constructor.
// ---------------------------------------------------------------------------
//
CServerMonitor* CServerMonitor::NewL( TDesC& aServerName , TUid aServerUid )
    {   
    CServerMonitor* self = new ( ELeave ) CServerMonitor();
    CleanupStack::PushL( self );
    self->ConstructL( aServerName , aServerUid );
    CleanupStack::Pop( self );

    return self;
    }

// ---------------------------------------------------------------------------
// C++ constructor.
// ---------------------------------------------------------------------------
//
CServerMonitor::CServerMonitor() : 
    CActive( CActive::EPriorityStandard ), iState(EIdle)
    {
    // Add to active scheduler.
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------------------------
// 2nd phase constructor.
// ---------------------------------------------------------------------------
//
void CServerMonitor::ConstructL( TDesC& aServerName , TUid aServerUid )
    {
        
    TFullName name;
    //Update the member variables
    iServerName = HBufC::NewL( aServerName.Length() );
    TPtr servernameptr = iServerName->Des();
    servernameptr.Copy( aServerName );
    
    iServerUid.iUid = aServerUid.iUid;
    // find Harvester Server
    // Append * to the server name for the findprocess
    HBufC* servername = HBufC::NewL( iServerName->Length() + 1 );
    TPtr nameptr = servername->Des();
    nameptr.Copy( aServerName );
    nameptr.Append( KStar );
    
    TFindProcess findProcess( *servername );
    if ( findProcess.Next(name) == KErrNone )
        {              
        User::LeaveIfError( iProcess.Open(name) );
        iState = ERunning;
        // logon to get termination signal
        iProcess.Logon(iStatus);        
        SetActive();
        }        
    else
        { 
        // start new Harvester            
        StartL();
        }
    
    delete servername;
    
    }

void CServerMonitor::StartL()
    {  

    // Double check that harvester server is not already running
    TFullName name;
    TInt res( KErrNone );
    // Append * to the server name for the findprocess
    HBufC* servername = HBufC::NewL( iServerName->Length() + 1 );
    TPtr servernameptr = servername->Des();
    servernameptr.Copy( *iServerName );
    servernameptr.Append( KStar );
    // find really Harvester Server, using TFindServer to avoid logon a dead process
    TFindServer findServer( *servername );
    
    if ( findServer.Next(name) == KErrNone )
        {
        TFindProcess findProcess( *servername );
        if ( findProcess.Next(name) == KErrNone )
            {            
            iProcess.Close();
            res = iProcess.Open(name);
            if ( res != KErrNone )
                {
                delete servername;
                return;
                }
            iState = EWaitingRendezvous;
            SetActive();
            delete servername;
            return;
            }
        }  
    
    // close the panic process
    TFindProcess findProcess( *servername );
    if ( findProcess.Next(name) == KErrNone )
        {                
        iProcess.Close();
        }
    delete servername;
    servername = NULL;
    // Create the server process
    StartServerProcessL(); 
    }    

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CServerMonitor::~CServerMonitor()
    {
    delete iServerName;
    Cancel();
    }

// ---------------------------------------------------------------------------
// Active object's request handling.
// ---------------------------------------------------------------------------
//
void CServerMonitor::RunL()
    {    	
    	switch (iState)
    	{
          case EIdle:
              {
              break;
              }
              
          case EWaitingRendezvous:          
              {
              iState = ERunning;              
              // logon to get termination signal
              TRAPD(err,iProcess.Logon(iStatus));
              if ( err == KErrNone )
                 SetActive();
              break;
              }             
              
          case ERunning:
              {
              // server died unexpectedly, start it    
              StartL();
              break;
              }            
          default:
              break; 
          
    	}
    
    }

// ---------------------------------------------------------------------------
// Active object's request error handling.
// ---------------------------------------------------------------------------
//
TInt CServerMonitor::RunError( TInt /*aError*/ )
    {
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Cancel the request.
// ---------------------------------------------------------------------------
//
void CServerMonitor::DoCancel()
    {
    iProcess.LogonCancel(iStatus);
    iProcess.Close();
    }

// ---------------------------------------------------------------------------
// StartServerProcess
// ---------------------------------------------------------------------------
//
void CServerMonitor::StartServerProcessL()
    {
    RSemaphore semaphore;
    HBufC* semaphorename = HBufC::NewL( iServerName->Length() + 10 );
    TPtr semptr = semaphorename->Des();
    semptr.Copy( *iServerName );
    semptr.Append( KSemaphore );
    
    TInt result = semaphore.CreateGlobal( *semaphorename, 0 );
    if (result != KErrNone)
        {
        delete semaphorename;
        return ;
        }

    TRAP(result, CreateServerProcess());
    if (result != KErrNone)
        {
        return ;
        }

    semaphore.Wait();
    semaphore.Close();
    delete semaphorename;
    return ;
    }
        
// ---------------------------------------------------------------------------
// CreateServerProcess
// ---------------------------------------------------------------------------
//
void CServerMonitor::CreateServerProcess()
    {
    TInt result;

    const TUidType serverUid( KNullUid, KNullUid, iServerUid);
    
    HBufC* servernameext = HBufC::NewL( iServerName->Length() + 4 );
    TPtr ptr = servernameext->Des();
    ptr.Copy( *iServerName );
    ptr.Append( KExtension );
    //result = iProcess.Create( *iServerName, KNullDesC, serverUid);
    result = iProcess.Create( *iServerName, KNullDesC);
    if (result != KErrNone)
        {
        delete servernameext;
        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();
        
        }
    delete servernameext;
    return ;
    }

// ---------------------------------------------------------------------------
// CreateServerProcess
// ---------------------------------------------------------------------------
//
void CServerMonitor::ShutdownServer()
    {
    HBufC* servername = HBufC16::NewLC( iServerName->Length() + 5 );
    TPtr servernameptr = servername->Des();
    servernameptr.Copy( *iServerName );
    servernameptr.Append( KExtension );
    servernameptr.Append( KStar );
    TFindProcess processFinder( *servername );
    TFullName result;
    RProcess processHandle;
    while ( processFinder.Next(result) == KErrNone) 
    {
       User::LeaveIfError(processHandle.Open ( processFinder, EOwnerThread));
       processHandle.Kill(KErrNone);
       processHandle.Close();
    }
    CleanupStack::PopAndDestroy( servername );
    }