private async Task <NetworkStatus> VerifyFile()
{
Status = NetworkStatus.Networking;
OnProgressChanged(0, 1);
if (cloudFile.Name != windowsFile.Name)
{
OnMessageAppended($"Name not consistent, Cloud: {cloudFile.Name}, Local: {windowsFile.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
var stream = await windowsFile.OpenStreamForReadAsync();
OnMessageAppended("Getting local MD5 checksum...");
var localCheckSum = await Libraries.GetSha256ForWindowsStorageFile(stream);
OnMessageAppended("Getting cloud MD5 checksum...");
var cloudCheckSum = await Libraries.GetSha256ForCloudFileById(cloudFile.Id);
if (localCheckSum != cloudCheckSum)
{
OnMessageAppended($"Content not consistent, Cloud: {cloudCheckSum}, Local: {localCheckSum}");
return(NetworkStatus.ErrorNeedRestart);
}
else
{
OnMessageAppended($"Verification succeeded, Name: {cloudFile.Name}, Local: {cloudCheckSum}");
OnProgressChanged(1, 1);
return(NetworkStatus.Completed);
}
}
private string GetSeperateString(byte[] data)
{
return(Libraries.GetNonsubstring_A_Z(data));
}
private async Task <NetworkStatus> VerifyFolder()
{
Status = NetworkStatus.Networking;
long currentProgress = 0, totalProgress = 1;
OnProgressChanged(currentProgress, totalProgress);
if (cloudFolder.Name != windowsFolder.Name)
{
OnMessageAppended($"Name not consistent, Cloud: {cloudFolder.Name}, Local: {windowsFolder.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
var folderVerifiers = new List <Tuple <CloudFile, Windows.Storage.StorageFolder> >();
{
if (!await GetCloudSubFolders())
{
return(NetworkStatus.ErrorNeedRestart);
}
Dictionary <string, Windows.Storage.StorageFolder> localSubFolders = new Dictionary <string, Windows.Storage.StorageFolder>();
foreach (var f in await windowsFolder.GetFoldersAsync())
{
if (!cloudSubFolders.ContainsKey(f.Name))
{
OnMessageAppended($"Cloud Folder doesn't exist: {f.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
localSubFolders.Add(f.Name, f);
}
foreach (var p in cloudSubFolders)
{
if (!localSubFolders.ContainsKey(p.Key))
{
OnMessageAppended($"Local Folder doesn't exist: {p.Key}");
return(NetworkStatus.ErrorNeedRestart);
}
folderVerifiers.Add(new Tuple <CloudFile, Windows.Storage.StorageFolder>(p.Value, localSubFolders[p.Key]));
localSubFolders.Remove(p.Key);
}
MyLogger.Assert(localSubFolders.Count == 0);
}
{
if (!await GetCloudSubFiles())
{
return(NetworkStatus.ErrorNeedRestart);
}
Dictionary <string, Windows.Storage.StorageFile> localSubFiles = new Dictionary <string, Windows.Storage.StorageFile>();
foreach (var f in await windowsFolder.GetFilesAsync())
{
if (!cloudSubFiles.ContainsKey(f.Name))
{
OnMessageAppended($"Cloud File doesn't exist: {f.Name}");
return(NetworkStatus.ErrorNeedRestart);
}
localSubFiles.Add(f.Name, f);
}
foreach (var p in cloudSubFiles)
{
if (!localSubFiles.ContainsKey(p.Key))
{
OnMessageAppended($"Local File doesn't exist: {p.Key}");
return(NetworkStatus.ErrorNeedRestart);
}
}
OnProgressChanged(++currentProgress, totalProgress += cloudSubFiles.Count);
CurrentProgressChanged?.Invoke(1);
TotalProgressChanged?.Invoke(cloudSubFiles.Count);
OnMessageAppended("Verifying subfiles...");
int filesVerified = 0;
foreach (var p in cloudSubFiles)
{
var localFile = localSubFiles[p.Key];
var stream = await localFile.OpenStreamForReadAsync();
var localMd5 = await Libraries.GetSha256ForWindowsStorageFile(stream);
stream.Dispose();
if (localMd5 != p.Value || p.Value == null)
{
OnMessageAppended($"{p.Key} content not consistent, Cloud: {p.Value}, Local: {localMd5}");
CurrentProgressChanged?.Invoke(-filesVerified - 1);
TotalProgressChanged?.Invoke(-cloudSubFiles.Count);
return(NetworkStatus.ErrorNeedRestart);
}
OnProgressChanged(++currentProgress, totalProgress);
CurrentProgressChanged?.Invoke(1);
++filesVerified;
localSubFiles.Remove(p.Key);
}
OnMessageAppended("Subfiles verified.");
MyLogger.Assert(localSubFiles.Count == 0);
}
OnProgressChanged(currentProgress, totalProgress += folderVerifiers.Count);
TotalProgressChanged?.Invoke(folderVerifiers.Count);
ReleaseSemaphoreSlim();
OnMessageAppended("Waiting for subfolders to be verified...");
try
{
await Task.WhenAll(folderVerifiers.Select(async(tuple) =>
{
var totalProgressChangedEventHandler = new TotalProgressChangedEventHandler((difference) =>
{
OnProgressChanged(currentProgress, totalProgress += difference);
TotalProgressChanged?.Invoke(difference);
});
var currentProgressChangedEventHandler = new TotalProgressChangedEventHandler((difference) =>
{
//MyLogger.Assert(difference == 1);
OnProgressChanged(currentProgress += difference, totalProgress);
CurrentProgressChanged?.Invoke(difference);
});
var verifier = new Verifiers.FolderVerifier(tuple.Item1, tuple.Item2);
verifier.TotalProgressChanged += totalProgressChangedEventHandler;
verifier.CurrentProgressChanged += currentProgressChangedEventHandler;
await verifier.StartUntilCompletedAsync();
verifier.TotalProgressChanged -= totalProgressChangedEventHandler;
verifier.CurrentProgressChanged -= currentProgressChangedEventHandler;
}));
return(NetworkStatus.Completed);
}
finally
{
await WaitSemaphoreSlimAsync();
}
}
