simplefilebackup.cpp

实时文件备份

		_T("E:\\Working\\Test\\SyncTest\\Copy of Test2\\TestFolder\\Sample2.txt"),
	};
*/
//	TCHAR tsDestinationPath[] = _T("E:\\Working\\Test\\SyncTest\\Backup Test");
	TCHAR tsDestinationPath[] = _T("F:\\Working\\Test\\SyncTest\\Backup Test");
//	TCHAR tsDestinationPath[] = _T("G:\\Backup Test\\Backup Test");
	TCHAR tsDatabaseName[] = _T("Backup.mdb");
	TCHAR tsDatabasePathname[MAX_PATH];
	DWORD dwMaxRevision = 3;
	DWORD dwRevisionInterval = 20 * 1000;
	int i;

	for ( i = 0; i < sizeof(arrayIncludeFileFilters) / sizeof(*arrayIncludeFileFilters); i++ )
		if ( arrayIncludeFileFilters[i].pdwFileAttributesMask )
			arrayIncludeFileFilters[i].pdwFileAttributesMask = &arrayIncludeFileFilters[i].dwFileAttributesMask;

	_tprintf(_T("Add include paths and file masks:\n"));
	for ( i = 0; i < sizeof(arrayIncludeFileFilters) / sizeof(*arrayIncludeFileFilters); i++ )
	{
		if ( !objFileFilter.AddIncludePath(arrayIncludeFileFilters[i].tsFileFilter, arrayIncludeFileFilters[i].tsFilenameMask, arrayIncludeFileFilters[i].fIncludeFilenameMask, arrayIncludeFileFilters[i].pdwFileAttributesMask, arrayIncludeFileFilters[i].fIncludeFileAttributesMask) )
			_tprintf(_T("  Failed in adding include path: %s\n"), arrayIncludeFileFilters[i].tsFileFilter);
		else
			_tprintf(_T("  %s, %s \"%s\" files\n"), arrayIncludeFileFilters[i].tsFileFilter, arrayIncludeFileFilters[i].fIncludeFilenameMask ? _T("include") : _T("exclude"), arrayIncludeFileFilters[i].tsFilenameMask);
	}
	_tprintf(_T("\n"));
	_tprintf(_T("Add exclude paths/files:\n"));
	for ( i = 0; i < sizeof(arrayExcludeFileFilters) / sizeof(*arrayExcludeFileFilters); i++ )
	{
		if ( !objFileFilter.AddExcludePath(arrayExcludeFileFilters[i].tsFileFilter) )
			_tprintf(_T("  Failed in adding exclude path: %s\n"), arrayExcludeFileFilters[i].tsFileFilter);
		else
			_tprintf(_T("  %s\n"), arrayExcludeFileFilters[i].tsFileFilter);
	}
	_tprintf(_T("\n"));
	_tprintf(_T("Backup & Revision config:\n"));
	_tprintf(_T("  Backup Path:       %s\n"), tsDestinationPath);
	_tprintf(_T("  Max Revisions:     %d\n"), dwMaxRevision);
	_tprintf(_T("  Revision Interval: %d seconds\n"), dwRevisionInterval / 1000);
	_tprintf(_T("  Backup Mode:       Increment Mode\n"));
	_tprintf(_T("\n"));
	_tprintf(_T("Console Commands:\n"));
	_tprintf(_T("  quit     - Exit\n"));
	_tprintf(_T("  backup   - Instant Backup\n"));
	_tprintf(_T("  start    - Start Real-time Monitor\n"));
	_tprintf(_T("  stop     - Stop Real-time Monitor\n"));
	_tprintf(_T("  log      - Enter Log Mode\n"));
	_tprintf(_T("  realtime - Enter Real-time Backup Mode\n"));
	_tprintf(_T("\n"));
/*
	for ( i = 0; i < sizeof(tsFilePathname) / sizeof(*tsFilePathname); i++ )
	{
		if ( objFileFilter.MatchFilePathname(tsFilePathname[i]) )
			_tprintf(_T("  Succeed: %s\n"), tsFilePathname[i]);
		else
			_tprintf(_T("  Fail:    %s\n"), tsFilePathname[i]);
	}
	{
		CString csBasePath;
		CString csTempPath;
		CSimpleFileBackup::CFileFilter::CParsedPathItem* pItem;
		CStringList clIncludePaths;
		POSITION pos;

		if ( !objFileFilter.GetDriveBasePath(_T('E'), csBasePath, pItem) )
			_tprintf(_T("Failed in GetDriveBasePath...\n"));
		else
		{
			_tprintf(_T("Get base path: %s\n"), (LPCTSTR)csBasePath);
			for ( i = 0; i < sizeof(tsFilePathname) / sizeof(*tsFilePathname); i++ )
			{
				if ( pItem->MatchFilePathname(tsFilePathname[i] + csBasePath.GetLength() + 1) )
					_tprintf(_T("  Succeed: %s\n"), tsFilePathname[i]);
				else
					_tprintf(_T("  Fail:    %s\n"), tsFilePathname[i]);
			}
		}
		pItem->GetIncludeItems(clIncludePaths);
		_tprintf(_T("Get include paths:\n"));
		pos = clIncludePaths.GetHeadPosition();
		while ( pos )
		{
			CString& csPath = clIncludePaths.GetNext(pos);

			_tprintf(_T("  %s\n"), (LPCTSTR)csPath);
		}
	}
*/
//	CSimpleFileBackup::CWinNTFileChangesHandlerThread objNTFileChangesHandlerThread;
	CSimpleFileBackup::CWin9xFileChangesHandlerThread objNTFileChangesHandlerThread;
	CSimpleFileBackup::CDatabaseInfo objDatabaseInfo;
	CSimpleFileBackup::CDatabaseAccessThread objDatabase(FALSE);
	CSimpleFileBackup::CRevisionInfo objRevisionInfo;
//	CSimpleFileBackup::CWinNTCopyFileThread objNTCopyFileThread;
	CSimpleFileBackup::CWin9xCopyFileThread objNTCopyFileThread;
//	CSimpleFileBackup::CWinNTFileEnumeratorThread objNTFileEnumeratorThread;
	CSimpleFileBackup::CWin9xFileEnumeratorThread objNTFileEnumeratorThread;
	CStringList objDummyStringList;
	TCHAR tsCommand[256];

	objRevisionInfo.SetRevisionInfo(tsDestinationPath, dwMaxRevision, dwRevisionInterval, objDummyStringList);

	_stprintf(tsDatabasePathname, _T("%s\\%s"), tsDestinationPath, tsDatabaseName);
	objDatabaseInfo.SetDatabaseInfo(tsDatabasePathname, 2 * 1000, 5 * 60 * 1000, FALSE);

	objNTCopyFileThread.CreateThread(SimpleFileBackupCallback, NULL);
	objNTCopyFileThread.StartRevisionControl(&objRevisionInfo);

	objNTFileEnumeratorThread.CreateThread(&objNTCopyFileThread);

	objDatabase.CreateThread(&objNTCopyFileThread);
	objDatabase.InitializeDatabase(&objDatabaseInfo);

	objNTFileChangesHandlerThread.CreateThread(&objDatabase, SimpleFileBackupCallback, NULL);

	while ( 1 )
	{
		_tscanf(_T("%s"), tsCommand);
		if ( _tcsicmp(_T("quit"), tsCommand) == 0 )
			break;
		else if ( _tcsicmp(_T("backup"), tsCommand) == 0 )
		{
			objNTFileEnumeratorThread.StartInstantBackup(&objFileFilter);
		}
		else if ( _tcsicmp(_T("start"), tsCommand) == 0 )
		{
			objNTFileChangesHandlerThread.StartLogging(&objFileFilter, INFINITE);
		}
		else if ( _tcsicmp(_T("stop"), tsCommand) == 0 )
		{
			objNTFileChangesHandlerThread.StopLogging(INFINITE);
		}
		else if ( _tcsicmp(_T("log"), tsCommand) == 0 )
		{
			objDatabase.SetLogMode(TRUE);
		}
		else if ( _tcsicmp(_T("realtime"), tsCommand) == 0 )
		{
			objDatabase.SetLogMode(FALSE);
		}
	}

	objNTFileChangesHandlerThread.StopLogging(INFINITE);
	Sleep(100);
	objNTFileChangesHandlerThread.TerminateThread(INFINITE);

	objDatabase.UninitializeDatabase();

	objDatabase.TerminateThread(INFINITE);

	objNTFileEnumeratorThread.TerminateThread(INFINITE);

	objNTCopyFileThread.TerminateThread(INFINITE);

#elif 0

	CSimpleFileBackup::CDatabaseInfo objDatabase;
	CSimpleFileBackup::CWinNTCopyFileThread objNTCopyFileThread;
	CSimpleFileBackup::CDatabaseAccessThread objDatabaseThread(FALSE);
	DWORD dwRet = ERROR_SUCCESS;

	PFILECHANGES_INFORMATION pInfo = (PFILECHANGES_INFORMATION)CSimpleFileBackup::AllocateBuffer();

/*
	if ( objDatabase.Initialize(_T("E:\\Working\\Test\\SyncTest\\Backup.mdb")) )
	{
		_tprintf(_T("Succeeded to initialize database!\n"));
		objDatabase.Uninitialize();
	}
	else
		_tprintf(_T("Failed in initializing database...\n"));
*/
	pInfo->m_fNew = FALSE;
	pInfo->m_nPathnameLength = _tcslen(_T("E:\\Working\\Test\\SyncTest\\Backup.mdb"));
	_tcscpy(pInfo->m_tsPathname, _T("E:\\Working\\Test\\SyncTest\\Backup.mdb"));
	::GetSystemTimeAsFileTime((LPFILETIME)&pInfo->m_tTime);
	pInfo->m_pNext = NULL;

	objDatabase.SetDatabaseInfo(_T("E:\\Working\\Test\\SyncTest\\Backup.mdb"));
	dwRet |= objDatabaseThread.CreateThread(&objNTCopyFileThread, SimpleFileBackupCallback, NULL);
	dwRet |= objDatabaseThread.InitializeDatabase(&objDatabase);
	dwRet |= objDatabaseThread.PostFileChanges(pInfo);
	Sleep(1000);
	dwRet |= objDatabaseThread.UninitializeDatabase(INFINITE);
	Sleep(100);
	dwRet |= objDatabaseThread.TerminateThread();
	if ( dwRet != ERROR_SUCCESS )
		_tprintf(_T("Error has occurred..\n"));

#elif 1
	_tprintf(_T("%s\n"), g_tsSQLUpdateChangedFile);
	_tprintf(_T("%s\n"), g_tsSQLGetWaitingRecords);
	_tprintf(_T("%s\n"), g_tsSQLGetMinWaitTime);
	_tprintf(_T("%s\n"), g_tsSQLStartCopying);
	_tprintf(_T("%s\n"), g_tsSQLFinishedCopying);
#endif

	return 0;
}

inline void GetSystemErrorString(DWORD dwErrorCode, LPTSTR ptsBuffer, DWORD dwSize)
{
	::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwErrorCode, 0, ptsBuffer, dwSize, NULL);
}

DWORD WINAPI SimpleFileBackupCallback(PFILEBACKUP_CALLBACK_PARAM lParam)
{
	TCHAR tsErrorString[256];

	switch ( lParam->m_dwCallbackType )
	{
	case LOAD_VXD_FAILED:
		_tprintf(_T("Failed in loading VxD driver (%s) to hook file system: 0x%08X\n"), lParam->m_pString, lParam->m_dwPercentageOrErrorCode);
		break;
	case CHANGESHANDLER_MESSAGE_QUEUE_SEMAPHORE_ABANDONED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("Message Queue Semaphore of File Changes Handler abandoned: %s\n"), tsErrorString);
		break;
	case CHANGESHANDLER_OVERLAPPED_EVENT_ABANDONED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("Overlapped Event of File Changes Handler abandoned: %s\n"), tsErrorString);
		break;
	case CHANGESHANDLER_WAITFORSINGLEOBJECT_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("WaitForSingleObject of File Changes Handler failed: %s\n"), tsErrorString);
		break;
	case CHANGESHANDLER_READDIRECTORYCHANGESW_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("ReadDirectoryChangesW(%s) failed: %s\n"), lParam->m_pString, tsErrorString);
		break;
	case CHANGESHANDLER_DEVICEIOCONTROL_READCHANGE_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("DeviceIoControl(ReadChange) failed: %s\n"), tsErrorString);
		break;
	case CHANGESHANDLER_MULTIBYTETOWIDECHAR_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("MultiByteToWideChar(%s) of File Changes Handler failed: %s\n"), lParam->m_pString, tsErrorString);
		break;
	case CHANGESHANDLER_WIDECHARTOMULTIBYTE_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
#ifdef UNICODE
		wprintf(L"WideCharToMultiByte(%s) of File Changes Handler failed: %s\n", lParam->m_pString, tsErrorString);
#else
		wprintf(L"WideCharToMultiByte(%s) of File Changes Handler failed: %S\n", lParam->m_pString, tsErrorString);
#endif
		break;
	case CHANGESHANDLER_GETLONGPATHNAMEW_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
#ifdef UNICODE
		wprintf(L"GetLongPathNameW(%s) of File Changes Handler failed: %s\n", lParam->m_pString, tsErrorString);
#else
		wprintf(L"GetLongPathNameW(%s) of File Changes Handler failed: %S\n", lParam->m_pString, tsErrorString);
#endif
		break;
	case CHANGESHANDLER_GETFILEATTRIBUTESW_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
#ifdef UNICODE
		wprintf(L"GetFileAttributesW(%s) of File Changes Handler failed: %s\n", lParam->m_pString, tsErrorString);
#else
		{
			char str[256];

			::WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)lParam->m_pString, -1, str, sizeof(str), NULL, NULL);
			printf("GetFileAttributesW(%s) of File Changes Handler failed: %s\n", str, tsErrorString);
		}
		//wprintf(L"GetFileAttributesW(%s) failed: %S\n", lParam->m_pString, tsErrorString);
#endif
		break;
	case CHANGESHANDLER_GETFILEATTRIBUTESA_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
#ifdef UNICODE
		printf("GetFileAttributesA(%s) of File Changes Handler Failed: %S\n", lParam->m_pString, tsErrorString);
#else
		printf("GetFileAttributesA(%s) of File Changes Handler Failed: %s\n", lParam->m_pString, tsErrorString);
#endif
		break;
	case CHANGESHANDLER_POSTFILECHANGES_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("PostFileChanges failed: %s\n"), tsErrorString);
		break;

	case COPYFILES_MESSAGE_QUEUE_SEMAPHORE_ABANDONED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("Message Queue Semaphore of Copy File Thread abandoned: %s\n"), tsErrorString);
		break;
	case COPYFILES_WAITFORSINGLEOBJECT_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("WaitForSingleObject of Copy File Thread failed: %s\n"), tsErrorString);
		break;
	case COPYFILES_TERMINATE_WHILE_MESSAGE_QUEUE_NOT_EMPTY:
		_tprintf(_T("Copy File Thread are terminated while message queue is not empty...\n"));
		break;
	case COPYFILES_READY_TO_COPY_FILE:
		_tprintf(_T("Ready to copy: %s\n"), lParam->m_pString);
		break;
	case COPYFILES_ONE_CHUNK_FINISHED_IN_COPYING_FILE:
//		_tprintf(_T("Copied: %d%%\n"), lParam->m_dwPercentageOrErrorCode);
		break;
	case COPYFILES_FINISHED_COPYING_FILE:
		_tprintf(_T("Finished copying: %s\n"), lParam->m_pString);
		break;
	case COPYFILES_MERGE_REVISION_SHFILEOPERATION_MOVE_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("Move File failed while merging earliest two revisions: %s\n"), tsErrorString);
		break;
	case COPYFILES_MERGE_REVISION_SHFILEOPERATION_RENAME_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("Rename directory failed while merging earliest two revisions: %s\n"), tsErrorString);
		break;
	case COPYFILES_MERGE_REVISION_SHFILEOPERATION_DELETE_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("Delete directory failed while merging earliest two revisions: %s\n"), tsErrorString);
		break;
	case COPYFILES_DESTINATION_PATHNAME_IS_OVER_MAXPATH:
		_tprintf(_T("Destination path is too long (over %d bytes)...\n"), MAX_PATH);
		break;
	case COPYFILES_COPYFILEEX_FAILED_RATHER_THAN_CANCELLED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("CopyFileEx failed: %s\n"), tsErrorString);
		break;
	case COPYFILES_MULTIBYTETOWIDECHAR_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("MultiByteToWideChar(%s) of Copy File Thread failed: %s\n"), lParam->m_pString, tsErrorString);
		break;
	case COPYFILES_WIDECHARTOMULTIBYTE_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
#ifdef UNICODE
		wprintf(L"WideCharToMultiByte(%s) of Copy File Thread failed: %s\n", lParam->m_pString, tsErrorString);
#else
		wprintf(L"WideCharToMultiByte(%s) of Copy File Thread failed: %S\n", lParam->m_pString, tsErrorString);
#endif
		break;
	case SHEDULEDCOPYFILES_FINDFIRSTFILEW_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
#ifdef UNICODE
		wprintf(L"FindFirstFileW(%s) of Copy File Thread failed: %s\n", lParam->m_pString, tsErrorString);
#else
		{
			char str[256];

			::WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)lParam->m_pString, -1, str, sizeof(str), NULL, NULL);
			printf("FindFirstFileW(%s) of Copy File Thread failed: %s\n", str, tsErrorString);
		}
#endif
		break;
	case SHEDULEDCOPYFILES_FINDFIRSTFILEA_FAILED:
		GetSystemErrorString(lParam->m_dwPercentageOrErrorCode, tsErrorString, sizeof(tsErrorString));
		_tprintf(_T("FindFirstFileA(%s) of Copy File Thread failed: %s\n"), lParam->m_pString, tsErrorString);
		break;
	default:
		_tprintf(_T("Error: 0x%08X\n"), lParam->m_dwCallbackType);
	}
	return PROGRESS_CONTINUE;
}