/*

* 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 the License "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: 

* CJournal implementation

*

*/

/**

 @file 

 @released

 @internalTechnology

*/

#include "journal.h"

#include "journalfile.h"

#include "operationfunctions.h"

#include "log.h"

#include <f32file.h>

using namespace Swi;

CJournal* CJournal::NewL(RFs& aFs, RLoader& aLoader, TInt64 aTransactionID, const TDesC& aPath)

	{

	CJournal* self = CJournal::NewLC(aFs, aLoader, aTransactionID, aPath);

	CleanupStack::Pop(self);

	return self;

	}

CJournal* CJournal::NewLC(RFs& aFs, RLoader& aLoader, TInt64 aTransactionID, const TDesC& aPath)

	{

	CJournal* self = new(ELeave) CJournal(aFs, aLoader);

	CleanupStack::PushL(self);

	self->ConstructL(aTransactionID, aPath);

	return self;

	}

CJournal::~CJournal()

	{

	iJournalDrives.Reset();

	iCompletedDrives.Reset();

	iAllDrives.Reset();

	iJournalFiles.ResetAndDestroy();

	}

CJournal::CJournal(RFs& aFs, RLoader& aLoader) : iFs(aFs), iLoader(aLoader)

	{

	}

void CJournal::ConstructL(TInt64 aTransactionID, const TDesC& aPath)

	{

	// construct the generic journal filename (does not include a drive)

	iJournalFileName = aPath;

	iJournalFileName.AppendNumUC(aTransactionID, EHex);

	iJournalFileName.Append(KExtDelimiter);

	iJournalFileName.Append(KJournalExt);

	// construct the filename for the drives journal (located on the system drive)

	TDriveUnit systemDrive(RFs::GetSystemDrive());

	iDriveArrayFileName = systemDrive.Name();

	iDriveArrayFileName.Append(aPath);

	iDriveArrayFileName.AppendNumUC(aTransactionID, EHex);

	iDriveArrayFileName.Append(KExtDelimiter);

	iDriveArrayFileName.Append(KDriveExt);

	InitJournalsL();

	}

void CJournal::InitJournalsL()

	{

	RefreshDrivesArrayL();

	// attempt to read the journals from all drives

	TInt drivesCount(iAllDrives.Count());

	RBuf journal;

	journal.CreateL(KMaxFileName);

	CleanupClosePushL(journal);

	for (TInt i = 0; i < drivesCount; ++i)

		{

		TDriveUnit drive(iAllDrives[i]);

		journal = drive.Name();

		journal.Append(iJournalFileName);

		// do not load completed drives

		if (iCompletedDrives.Find(drive) != KErrNotFound)

			{

			continue;

			}

		CJournalFile* journalFile = NULL;

		TRAPD(err, journalFile = CJournalFile::NewL(iFs, iLoader, journal, iAllDrives[i]));

		// ignore error'd drives. These will either not be rolled back,

		// or the user will find out later we can't write or commit to them.

		if (err == KErrNone)

			{

			CleanupStack::PushL(journalFile);

			iJournalFiles.AppendL(journalFile);

			CleanupStack::Pop(journalFile);

			iJournalDrives.AppendL(drive);

			}

		}

	CleanupStack::PopAndDestroy(&journal);

	}

void CJournal::DeleteJournalFilesL()

	{

	// close the journal files in preparation for delete

	iJournalFiles.ResetAndDestroy();

	// delete all journal files

	for(TInt drive = 0; drive < iJournalDrives.Count(); drive++)

		{

		DeleteJournalFileL(iJournalDrives[drive]);

		}

	// delete the drive array only after all journals have been completed

	// (committed or rolled back)

	if (iAllDrives.Count() == iCompletedDrives.Count())

		{

		DeleteDrivesFileL();

		}

	}

void CJournal::DeleteJournalFileL(TInt aDrive)

	{

	TDriveUnit journalDrive(aDrive);

	RBuf journal;

	journal.CreateL(journalDrive.Name(), KMaxFileName);

	CleanupClosePushL(journal);

	journal.Append(iJournalFileName);

	DEBUG_PRINTF2(_L("Integrity Services - deleting journal %S"), &journal);

	User::LeaveIfError(iLoader.Delete(journal));

	// record that we have completed this drive

	UpdateDrivesArrayL(aDrive);

	iCompletedDrives.InsertInOrder(aDrive);

	TInt err = iFs.RmDir(journal);

	if(err != KErrNone && err != KErrInUse && err != KErrAccessDenied && 

		err != KErrNotFound && err != KErrPathNotFound)

		{

		User::Leave(err);

		}	

	CleanupStack::PopAndDestroy(&journal);

	}

void CJournal::DeleteDrivesFileL()

	{

	iJournalDrives.Reset();

	iCompletedDrives.Reset();

	TInt err = KErrNone;

	DEBUG_PRINTF2(_L("Integrity Services - deleting drive array %S"), &iDriveArrayFileName);

	err = iLoader.Delete(iDriveArrayFileName);

	if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)

		{

		User::Leave(err);

		}

    // try removing the journal path

	TParse directory;

	User::LeaveIfError(directory.SetNoWild(iDriveArrayFileName, NULL, NULL));

	while(!directory.IsRoot())

		{

		// try to remove this directory

		TInt err = iFs.RmDir(directory.DriveAndPath());

		if(err != KErrNone)

			{

			if(err == KErrInUse || err == KErrAccessDenied || 

				err == KErrNotFound || err == KErrPathNotFound)

				{

				break;

				}

			else

				{

				User::Leave(err);

				}

			}

		User::LeaveIfError(directory.PopDir());

		}

	}

void CJournal::RefreshDrivesArrayL()

	{

	// clear existing journal drive arrays prior to reloading them from file

	iCompletedDrives.Reset();

	iAllDrives.Reset();

	RFileReadStream journalStream;

	TInt err = journalStream.Open(iFs, iDriveArrayFileName, EFileStream);

	if(err == KErrNone)

		{

		CleanupClosePushL(journalStream);

		while(err == KErrNone)

			{

			// read the next journal entry

			TInt drive = 0;

			TRAP(err, drive = journalStream.ReadInt32L());

			// Checks boundaries for Drive

			if( drive <  EDriveA || drive > EDriveZ )

				{

				User::Leave(KErrCorrupt);

				}

			if(err == KErrNone)

				{

				if(iAllDrives.Find(drive) == KErrNotFound)

					{

					// first instance indicates this drive was part of this

					// transaction

					iAllDrives.InsertInOrder(drive);

					}

				else

					{

					// second instance indicates this drive has been committed

					// or rolled back

					iCompletedDrives.InsertInOrder(drive);

					}

				}

			else if (err != KErrEof)

				{

				User::Leave(err);

				}

			}

		CleanupStack::PopAndDestroy(&journalStream);

		}

	else if(err != KErrNotFound && err != KErrPathNotFound)

		{

		User::Leave(err);

		}

	}

void CJournal::UpdateDrivesArrayL(TInt aDrive)

	{

	RFile file;

	CleanupClosePushL(file);

	// try opening the file if it already exists

	TInt err = file.Open(iFs, iDriveArrayFileName, EFileWrite);

	if (err != KErrNone)

		{

		if (err == KErrNotFound || err == KErrPathNotFound)

			{

			err = iFs.MkDirAll(iDriveArrayFileName);

			if(err != KErrNone && err != KErrAlreadyExists)

				{

				User::Leave(err);

				}

			// journal does not exist, try creating one

			User::LeaveIfError(file.Create(iFs, iDriveArrayFileName, EFileWrite));

			}

		else

			{

			User::Leave(err);

			}

		}

	TInt fileSize;

	User::LeaveIfError(file.Size(fileSize));

	// attach to end of file for writing

	RFileWriteStream stream;

	stream.Attach(file, fileSize);	

	CleanupStack::Pop(&file); // file ownership

	CleanupClosePushL(stream);// transfered to stream

	stream.WriteInt32L(aDrive);

	CleanupStack::PopAndDestroy(&stream);

	}

void CJournal::StartCommitL()

	{

	// To commit, all drives must exist. No exceptions.

	if (iJournalDrives.Count() != iAllDrives.Count())

		{

		User::Leave(KErrNotReady);

		}

	// none of the drives must yet be completed...

	if (iCompletedDrives.Count() != 0)

		{

		User::Leave(KErrNotSupported);

		}

	// synch up all the drives

	TInt drivesCount(iJournalDrives.Count());

	for (TInt i = 0; i < drivesCount; ++i)

		{

 		//Check if Journal drives are present.

 		TDriveInfo info;

 		if (iFs.Drive(info, iJournalDrives[i])!=KErrNone || info.iType==EMediaNotPresent)

 			{

 			User::Leave(KErrNotReady);	

 			}

		iJournalFiles[i]->SynchL();

		}		

	}

void CJournal::FinishCommitL()

	{

	DeleteJournalFilesL();

	// return the journal to a state where it can be used again,

	// in the insane event that someone wants to...

	// (I'm looking at you sisregistry)

	iCompletedDrives.Reset();

	iJournalDrives.Reset();

	iAllDrives.Reset();

	}

void CJournal::StartRollbackL(TInt aDrive)

	{

	TInt index = iJournalDrives.Find(aDrive);

	User::LeaveIfError(index);

	// check there is a Journal file

	if (index >= iJournalFiles.Count())

		{

		// This can happen when the journal file is missing due to OOM

		// So handle this as if OOM

		User::LeaveIfError( KErrNoMemory );

		}

	iJournalFiles[index]->SynchL();

	}

void CJournal::FinishRollbackL(TInt aDrive)

	{

	TInt index = iJournalDrives.Find(aDrive);

	User::LeaveIfError(index);

	iJournalFiles[index]->Close();

	DeleteJournalFileL(aDrive);

	if (iCompletedDrives.Count() == iAllDrives.Count())

		{

		DeleteDrivesFileL();

		}

	}

void CJournal::SynchL()

	{

	TInt drivesCount(iAllDrives.Count());

	RefreshDrivesArrayL();

	if (drivesCount != iAllDrives.Count())

		{

		// another process has added a drive. Read the log created.

		RBuf journal;

		journal.CreateL(KMaxFileName);

		CleanupClosePushL(journal);

		for (TInt i = 0; i < iAllDrives.Count(); ++i)

			{

			TChar drive = iAllDrives[i];

			if (iJournalDrives.Find(drive) == KErrNotFound &&

				iCompletedDrives.Find(drive) == KErrNotFound)

				{

				User::LeaveIfError(iJournalDrives.InsertInOrder(drive));

				TInt index = iJournalDrives.FindInOrder(drive);

				User::LeaveIfError(index);

				TDriveUnit driveUnit(drive);

				journal = driveUnit.Name();

 				journal.Append(iJournalFileName);

				CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, journal, drive);

				User::LeaveIfError(iJournalFiles.Insert(journalFile, index));

				CleanupStack::Pop(journalFile);

				}

			}

		CleanupStack::PopAndDestroy(&journal);

		}

	}

TInt CJournal::PrepareToWriteL(TInt aDrive)

	{

	SynchL();

	TInt index(0);

	TInt err = iJournalDrives.FindInOrder(aDrive);

	if (err >= 0)

		{

		// already exists, ensure it is in synch.

		index = err;

		iJournalFiles[index]->SynchL();

		}

	else if (err == KErrNotFound)

		{

		// Save the current count of our array's in case something goes wrong

  		TInt previousJournalDrivesCount = iJournalDrives.Count();

  		TInt previousAllDrivesCount = iAllDrives.Count();

 		// As there are multiple instances of calls which can leave

		// we need to provide a TRAP block to enable us to perform

 		// proper cleanup before propagating the leave up the call stack

  		TRAPD(err,

   			{

    		// create a new journal for this file.

			User::LeaveIfError(iJournalDrives.InsertInOrder(aDrive));

			User::LeaveIfError(iAllDrives.InsertInOrder(aDrive));

			index = iJournalDrives.FindInOrder(aDrive);

			User::LeaveIfError(index);

			UpdateDrivesArrayL(aDrive);

			TDriveUnit drive(aDrive);

			RBuf journal;

			journal.CreateL(drive.Name(), KMaxFileName);

			CleanupClosePushL(journal);

 			journal.Append(iJournalFileName);

			CJournalFile* journalFile = CJournalFile::NewLC(iFs, iLoader, journal, aDrive);

			User::LeaveIfError(iJournalFiles.Insert(journalFile, index));

			CleanupStack::Pop(journalFile);

			CleanupStack::PopAndDestroy(&journal);

   			}); // TRAPD 

		// If an error occurred at all in the preceding block we need

		// to ensure that the iJournalDrives and iJournalFiles arrays are

		// in sync before we leave.

		if( err != KErrNone )

			{

			// Check the iJournalDrives array first

    		if( iJournalDrives.Count() != previousJournalDrivesCount )

     			{

     			// We added aDrive to the array before leaving

     			index = iJournalDrives.FindInOrder( aDrive );

     			if( index >=0 && index < iJournalDrives.Count() )

      				{

      				iJournalDrives.Remove(index);

      				}

     			// Now check the iAllDrives array

     			if( iAllDrives.Count() != previousAllDrivesCount )

      				{

					index = iAllDrives.FindInOrder( aDrive );

					if( index >=0 && index < iAllDrives.Count() )

       					{

       					iAllDrives.Remove( index );

       					}

      				}

     			}

    		// We can now leave as nature intended.  We don't need to do anything

    		// with iJournalFiles as if this succeeded (and modified the array)

    		// then we wouldn't have left in the first place.

    		User::Leave( err );  	

			}

		}

	else

		{

		User::Leave(err);

		}

	return index;

	}

void CJournal::RestoreFilesL(TIntegrityServicesEvent aTypeFilter, CIntegrityServices& aIntegrityServices, CIntegrityServices::TFailType aFailType)

	{

	TInt journalsCount(iJournalFiles.Count());

	for (TInt i = 0; i < journalsCount; ++i)

		{

		iJournalFiles[i]->JournalOperationL(IntegrityRestoreFileL, aTypeFilter, aIntegrityServices,

			aFailType);

		}

	}

void CJournal::DeleteFilesL(TIntegrityServicesEvent aTypeFilter, CIntegrityServices& aIntegrityServices, CIntegrityServices::TFailType aFailType)

	{

	TInt journalsCount(iJournalFiles.Count());

	for (TInt i = 0; i < journalsCount; ++i)

		{

		iJournalFiles[i]->JournalOperationL(IntegrityDeleteFileL, aTypeFilter, aIntegrityServices,

			aFailType);

		}

	}

void CJournal::RestoreFilesL(TIntegrityServicesEvent aTypeFilter, TInt aDrive,

	CIntegrityServices& aIntegrityServices, CIntegrityServices::TFailType aFailType)

	{

	TInt index = iJournalDrives.Find(aDrive);

	User::LeaveIfError(index);

	iJournalFiles[index]->JournalOperationL(IntegrityRestoreFileL, aTypeFilter, aIntegrityServices,

		aFailType);

	}

void CJournal::DeleteFilesL(TIntegrityServicesEvent aTypeFilter, TInt aDrive,

	CIntegrityServices& aIntegrityServices, CIntegrityServices::TFailType aFailType)

	{

	TInt index = iJournalDrives.Find(aDrive);

	User::LeaveIfError(index);

	iJournalFiles[index]->JournalOperationL(IntegrityDeleteFileL, aTypeFilter, aIntegrityServices,

		aFailType);

	}

void CJournal::WriteJournalEventL(TIntegrityServicesEvent aEvent)

	{

	// write the event to each journal file

	for(TInt index = 0; index < iJournalFiles.Count(); index++)

		{

		iJournalFiles[index]->EventL(aEvent);

		}

	}

void CJournal::WriteJournalEventL(TIntegrityServicesEvent aEvent, TInt aDrive)

	{

	TInt index = iJournalDrives.Find(aDrive);

	User::LeaveIfError(index);