diff -r 95243422089a -r 491b3ed49290 filemanager/src/fmbkupengine/src/CMMCScBkupStateArchiveOpActiveData.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filemanager/src/fmbkupengine/src/CMMCScBkupStateArchiveOpActiveData.cpp Tue Aug 31 15:06:05 2010 +0300 @@ -0,0 +1,467 @@ +/* +* Copyright (c) 2005 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: CMMCScBkupStateArchiveOpActiveData implementation +* +* +*/ + +#include "CMMCScBkupStateArchiveOpActiveData.h" + +// User includes +#include "MMCScBkupLogger.h" +#include "CMMCScBkupDataOwnerCollection.h" +#include "CMMCScBkupDataOwnerInfo.h" +#include "MMCScBkupSBEUtils.h" +#include "CMMCScBkupArchive.h" +#include "CMMCScBkupArchiveFooter.h" +#include "CMMCScBkupIndexWithIdentifier.h" +#include "MMMCScBkupArchiveDataInterface.h" + +// Constants +const TInt KMMCScBkupActiveDataOwnerDelayBeforeRetry = 2 * 1000000; // 2 seconds +const TInt KMMCScBkupNumberOfAttemptsToAllowADOToBecomeReady = 4; // corresponds to 8 seconds of waiting + + + +// ========================= MEMBER FUNCTIONS ================================ + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::CMMCScBkupStateArchiveOpActiveData() +// +// C++ constructor. +// --------------------------------------------------------------------------- +CMMCScBkupStateArchiveOpActiveData::CMMCScBkupStateArchiveOpActiveData( MMMCScBkupDriver& aDriver ) +: CMMCScBkupStateOpAware( aDriver ), iIndexValueCurrent( -1 ) + { + __LOG1("CMMCScBkupStateArchiveOpActiveData::CMMCScBkupStateArchiveOpActiveData() - 0x%08x", StateId().iUid ); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::~CMMCScBkupStateArchiveOpActiveData() +// +// Destructor. +// --------------------------------------------------------------------------- +CMMCScBkupStateArchiveOpActiveData::~CMMCScBkupStateArchiveOpActiveData() + { + Cancel(); + // + iTimer.Close(); + // + delete iBackupTransferObject; + delete iRestoreTransferObject; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::NewL() +// +// +// --------------------------------------------------------------------------- +CMMCScBkupStateArchiveOpActiveData* CMMCScBkupStateArchiveOpActiveData::NewL( MMMCScBkupDriver& aDriver ) + { + CMMCScBkupStateArchiveOpActiveData* self = new(ELeave) CMMCScBkupStateArchiveOpActiveData( aDriver ); + return self; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::StateId() +// +// +// --------------------------------------------------------------------------- +TMMCScBkupStateId CMMCScBkupStateArchiveOpActiveData::StateId() const + { + return KMMCScBkupStateIdArchiveOpActiveData; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::NextStateBackupId() +// +// +// --------------------------------------------------------------------------- +TMMCScBkupStateId CMMCScBkupStateArchiveOpActiveData::NextStateBackupId( TBool /*aPartial*/ ) const + { + // If we still have unprocessed active data owners remaining, then + // we must + // + // a) check their status again - to see if they are ready, then + // b) process them once again via this method + // + // The 'get data owner statuses' object will trigger us again + // when it has performed an update of all statuses + + // By default, we want to move onto the passive data... + TMMCScBkupStateId nextState = KMMCScBkupStateIdArchiveOpPassiveData; + if (AllDataOwnersHandled() == EFalse) + { + // ... but we've still got at least one data owner who's not yet + // finished preparing their data... so we have to retry + nextState = KMMCScBkupStateIdGetDataOwnerStatuses; + } + // + return nextState; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::NextStateRestoreId() +// +// +// --------------------------------------------------------------------------- +TMMCScBkupStateId CMMCScBkupStateArchiveOpActiveData::NextStateRestoreId( TBool /*aPartial*/ ) const + { + // If we still have unprocessed active data owners remaining, then + // we must + // + // a) check their status again - to see if they are ready, then + // b) process them once again via this method + // + // The 'get data owner statuses' object will trigger us again + // when it has performed an update of all statuses + + // By default, we want to move onto the passive data... + TMMCScBkupStateId nextState = KMMCScBkupStateIdArchiveOpPublicDataFiles; + if (AllDataOwnersHandled() == EFalse) + { + // ... but we've still got at least one data owner who's not yet + // finished preparing their data... so we have to retry + nextState = KMMCScBkupStateIdGetDataOwnerStatuses; + } + // + return nextState; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformStateInitBackupL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::PerformStateInitBackupL( TBool /*aPartial*/ ) + { + __DEBUG_TESTING_SKIP_BACKUP_ACT_DATA; + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformStateInitBackupL() - START"); + + iBackupTransferObject = CMMCScBkupWriteDataTransferRequest< TTransferDataType >::NewL( + Driver(), + *this, + EMMCScBkupOwnerDataTypeActiveData, + ESIDTransferDerivedType, + Driver().DrvParamsBase().ActiveTransferType() + ); + CompleteSelf(); + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformStateInitBackupL() - END"); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformStateInitRestoreL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::PerformStateInitRestoreL( TBool /*aPartial*/ ) + { + __DEBUG_TESTING_SKIP_RESTORE_ACT_DATA; + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformStateInitRestoreL() - START"); + + iRestoreTransferObject = CMMCScBkupReadDataTransferRequest< TTransferDataType >::NewL( + Driver(), + EMMCScBkupOwnerDataTypeActiveData, + Driver().DrvParamsBase().ActiveTransferType() + ); + + CompleteSelf(); + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformStateInitRestoreL() - END"); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL( TBool /*aPartial*/ ) + { + CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); + const TInt count = dataOwners.Count(); + __LOG2("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - START - iIndexValueCurrent: %d/%d", iIndexValueCurrent, count); + // + while ( ++iIndexValueCurrent < count ) + { + CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner(iIndexValueCurrent); + + // Has this data owner been processed? + // Is the data owner even ready? + const TBool activeDataAlreadyProcessed = owner.CompletionStatus( EMMCScBkupOwnerDataTypeActiveData ); + const TBool dataOwnerIsReady = ( owner.Status() == EDataOwnerReady || + owner.Status() == EDataOwnerReadyNoImpl ); + const TBool dataHasRealActiveData = ( owner.Status() == EDataOwnerReady ); + // + __LOG5("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - DO: 0x%08x has status: %d, alreadyProcessed: %d, isReady: %d, dataHasRealActiveData: %d", owner.SecureId().iId, owner.Status(), activeDataAlreadyProcessed, dataOwnerIsReady, dataHasRealActiveData); + // + if (!activeDataAlreadyProcessed) + { + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - active data has not already been processed..."); + + if (dataOwnerIsReady) + { + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - data owner is ready..."); + + if ( dataHasRealActiveData ) + { + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - data owner has real active data..."); + + // Try and obtain the active data for this client + __ASSERT_ALWAYS(iBackupTransferObject->IsActive() == EFalse, User::Invariant()); + // + iBackupTransferObject->RequestL( owner, + iStatus, + Driver().DrvParamsBase().DriveAndOperations() ); + SetActive(); + break; // while loop + } + else + { + // The data owner is a hybrid - we shouldn't request data for a data owner that + // doesn't provide an active data interface callback implementation. + __LOG("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - DO is a hybrid - set completion status to ETrue"); + owner.SetCompletionStatus( EMMCScBkupOwnerDataTypeActiveData, ETrue ); + } + } + else + { + // Retry a number of times, but eventually we'll give up + const TInt attemptsSoFar = owner.ActiveDataRetryCount(); + owner.SetActiveDataRetryCount( attemptsSoFar + 1 ); + + if ( attemptsSoFar >= KMMCScBkupNumberOfAttemptsToAllowADOToBecomeReady ) + { + // Give up, this DO is taking too long + owner.SetCompletionStatus( EMMCScBkupOwnerDataTypeActiveData, ETrue ); + __LOG1("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - ADO with SID: 0x%08x has taken too long to prepare, skipping", owner.SecureId().iId); + } + else + { + // DO is not yet ready, we're going to have to check its + // status again in a while... + __LOG1("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepBackupL() - attemptsSoFar %d", attemptsSoFar); + iAtLeastOneDataOwnerIsNotYetReady = ETrue; + } + } + } + } + // + CheckNeedToStartRetryTimerL(); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepRestoreL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepRestoreL( TBool /*aPartial*/ ) + { + CMMCScBkupIndexBase& indexBase = Driver().DrvArchive().Footer().IndexByType( EMMCScBkupOwnerDataTypeActiveData ); + CMMCScBkupIndexWithIdentifier< TSecureId >& index = static_cast< CMMCScBkupIndexWithIdentifier< TSecureId >& >( indexBase ); + const TInt count = index.Count(); + // + // + while ( ++iIndexValueCurrent < count ) + { + // Get the associated data owner + const CMMCScBkupIndexEntry& entry = index.At( iIndexValueCurrent ); + CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); + CMMCScBkupDataOwnerInfo& owner = dataOwners.OwnerL( entry.Identifier() ); + + // Has this data owner been processed? + // Is the data owner even ready? + const TBool activeDataAlreadyProcessed = owner.CompletionStatus(EMMCScBkupOwnerDataTypeActiveData); + const TBool dataOwnerIsReady = ( owner.Status() == EDataOwnerReady || + owner.Status() == EDataOwnerReadyNoImpl ); + // + if (!activeDataAlreadyProcessed) + { + if (dataOwnerIsReady) + { + __ASSERT_ALWAYS(iRestoreTransferObject->IsActive() == EFalse, User::Invariant()); + // + const RArray& subEntries = entry.Entries(); + iRestoreTransferObject->RequestL( owner, + iStatus, + subEntries ); + __LOG1("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepRestoreL() - trying to restore ACTIVE DATA for SID: 0x%08x", owner.SecureId().iId ); + // + SetActive(); + break; // while loop + } + else + { + // Retry a number of times, but eventually we'll give up + const TInt attemptsSoFar = owner.ActiveDataRetryCount(); + owner.SetActiveDataRetryCount( attemptsSoFar + 1 ); + + if ( attemptsSoFar >= KMMCScBkupNumberOfAttemptsToAllowADOToBecomeReady ) + { + // Give up, this DO is taking too long + owner.SetCompletionStatus( EMMCScBkupOwnerDataTypeActiveData, ETrue ); + __LOG1("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousStateStepRestoreL() - ADO with SID: 0x%08x has taken too long to prepare, skipping", owner.SecureId().iId); + } + else + { + // DO is not yet ready, we're going to have to check its + // status again in a while... + iAtLeastOneDataOwnerIsNotYetReady = ETrue; + } + } + } + } + // + CheckNeedToStartRetryTimerL(); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupBackup() +// +// +// --------------------------------------------------------------------------- +TBool CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupBackup( TBool /*aPartial*/, TInt aError ) + { + (void) aError; + __LOG1("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupBackup() - **** - error: %d", aError ); + + // Reset state and move to next item. Treat the current (badly behaving) item + // as completed/processed. + CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); + if ( iIndexValueCurrent < dataOwners.Count() ) + { + CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( iIndexValueCurrent ); + owner.SetCompletionStatus( EMMCScBkupOwnerDataTypeActiveData, ETrue ); + + __LOGFILE2("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupBackup() - **** - error: %d, SID: 0x%08x - ACTIVE data skipped for DO", aError, owner.SecureId().iId ); + } + + CompleteSelf(); + return ETrue; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupRestore() +// +// +// --------------------------------------------------------------------------- +TBool CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupRestore( TBool /*aPartial*/, TInt aError ) + { + (void) aError; + __LOGFILE1("CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousErrorCleanupRestore() - **** - error: %d", aError ); + + CompleteSelf(); + return ETrue; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousCancellation() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::PerformAsynchronousCancellation() + { + if (iTimer.Handle() != KNullHandle ) + { + iTimer.Cancel(); + } + if (iBackupTransferObject) + { + iBackupTransferObject->Cancel(); + } + if (iRestoreTransferObject) + { + iRestoreTransferObject->Cancel(); + } + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::PerformLastRightsBackupL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::PerformLastRightsBackupL( TBool /*aPartial*/ ) + { + __LOG1("CMMCScBkupStateArchiveOpActiveData::PerformLastRightsBackupL() - iAtLeastOneDataOwnerIsNotYetReady %d", iAtLeastOneDataOwnerIsNotYetReady ); + + if ( AllDataOwnersHandled() ) + { + // Only write the index if we've handled all the active data owners + CMMCScBkupIndexBase& index = Driver().DrvArchive().Footer().IndexByType( EMMCScBkupOwnerDataTypeActiveData ); + index.StoreL(Driver()); + } + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::AddIndexRecordL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::AddIndexRecordL( CMMCScBkupArchiveFooter& aFooter, CMMCScBkupDataOwnerInfo& aDataOwner, const TMMCScBkupArchiveVector& aInfo, TDriveNumber aDrive ) + { + CMMCScBkupIndexBase& indexBase = aFooter.IndexByType( EMMCScBkupOwnerDataTypeActiveData ); + CMMCScBkupIndexWithIdentifier< TSecureId>& index = static_cast< CMMCScBkupIndexWithIdentifier< TSecureId>& >( indexBase ); + // + index.AddIndexRecordL( aInfo, aDrive, aDataOwner.SecureId() ); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateArchiveOpActiveData::CheckNeedToStartRetryTimerL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateArchiveOpActiveData::CheckNeedToStartRetryTimerL() + { + // We need to delay until the remaining active data owners are ready + const TBool processingDataHandler = IsActive(); + if ( !processingDataHandler && !AllDataOwnersHandled() && iTimer.Handle() == KNullHandle ) + { + // Implicitly, we have at least one DO that's not yet ready, and + // we have processed as many of the ready DO's as is possible on this + // cycle. Let's wait a few seconds to give the DO's a time to finish + // preparing and then try again. See NextStateId() for how this works. + User::LeaveIfError( iTimer.CreateLocal() ); + + __LOG("CMMCScBkupStateArchiveOpActiveData::CheckNeedToStartRetryTimerL() - SetActive"); + SetActive(); + const TTimeIntervalMicroSeconds32 delay(KMMCScBkupActiveDataOwnerDelayBeforeRetry); + iTimer.After( iStatus, delay ); + } + } + + + + + + + + + + + + +