public void CopyFrom(IndexVolumeReader rd, Func<string, string> filename_mapping) { foreach(var n in rd.Volumes) { this.StartVolume(filename_mapping(n.Filename)); foreach(var x in n.Blocks) this.AddBlock(x.Key, x.Value); this.FinishVolume(n.Hash, n.Length); } foreach(var b in rd.BlockLists) using(var s = b.Data) this.WriteBlocklist(b.Hash, s); }
public void RunRepairRemote() { if (!System.IO.File.Exists(m_options.Dbpath)) { throw new UserInformationException(string.Format("Database file does not exist: {0}", m_options.Dbpath), "RepairDatabaseFileDoesNotExist"); } m_result.OperationProgressUpdater.UpdateProgress(0); using (var db = new LocalRepairDatabase(m_options.Dbpath)) using (var backend = new BackendManager(m_backendurl, m_options, m_result.BackendWriter, db)) { m_result.SetDatabase(db); Utility.UpdateOptionsFromDb(db, m_options); Utility.VerifyParameters(db, m_options); if (db.PartiallyRecreated) { throw new UserInformationException("The database was only partially recreated. This database may be incomplete and the repair process is not allowed to alter remote files as that could result in data loss.", "DatabaseIsPartiallyRecreated"); } if (db.RepairInProgress) { throw new UserInformationException("The database was attempted repaired, but the repair did not complete. This database may be incomplete and the repair process is not allowed to alter remote files as that could result in data loss.", "DatabaseIsInRepairState"); } var tp = FilelistProcessor.RemoteListAnalysis(backend, m_options, db, m_result.BackendWriter, null); var buffer = new byte[m_options.Blocksize]; var blockhasher = Library.Utility.HashAlgorithmHelper.Create(m_options.BlockHashAlgorithm); var hashsize = blockhasher.HashSize / 8; if (blockhasher == null) { throw new UserInformationException(Strings.Common.InvalidHashAlgorithm(m_options.BlockHashAlgorithm), "BlockHashAlgorithmNotSupported"); } if (!blockhasher.CanReuseTransform) { throw new UserInformationException(Strings.Common.InvalidCryptoSystem(m_options.BlockHashAlgorithm), "BlockHashAlgorithmNotSupported"); } var progress = 0; var targetProgess = tp.ExtraVolumes.Count() + tp.MissingVolumes.Count() + tp.VerificationRequiredVolumes.Count(); if (m_options.Dryrun) { if (tp.ParsedVolumes.Count() == 0 && tp.OtherVolumes.Count() > 0) { if (tp.BackupPrefixes.Length == 1) { throw new UserInformationException(string.Format("Found no backup files with prefix {0}, but files with prefix {1}, did you forget to set the backup prefix?", m_options.Prefix, tp.BackupPrefixes[0]), "RemoteFolderEmptyWithPrefix"); } else { throw new UserInformationException(string.Format("Found no backup files with prefix {0}, but files with prefixes {1}, did you forget to set the backup prefix?", m_options.Prefix, string.Join(", ", tp.BackupPrefixes)), "RemoteFolderEmptyWithPrefix"); } } else if (tp.ParsedVolumes.Count() == 0 && tp.ExtraVolumes.Count() > 0) { throw new UserInformationException(string.Format("No files were missing, but {0} remote files were, found, did you mean to run recreate-database?", tp.ExtraVolumes.Count()), "NoRemoteFilesMissing"); } } if (tp.ExtraVolumes.Count() > 0 || tp.MissingVolumes.Count() > 0 || tp.VerificationRequiredVolumes.Count() > 0) { if (tp.VerificationRequiredVolumes.Any()) { using (var testdb = new LocalTestDatabase(db)) { foreach (var n in tp.VerificationRequiredVolumes) { try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(db, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((float)progress / targetProgess); long size; string hash; KeyValuePair <string, IEnumerable <KeyValuePair <Duplicati.Library.Interface.TestEntryStatus, string> > > res; using (var tf = backend.GetWithInfo(n.Name, out size, out hash)) res = TestHandler.TestVolumeInternals(testdb, n, tf, m_options, 1); if (res.Value.Any()) { throw new Exception(string.Format("Remote verification failure: {0}", res.Value.First())); } if (!m_options.Dryrun) { Logging.Log.WriteInformationMessage(LOGTAG, "CapturedRemoteFileHash", "Sucessfully captured hash for {0}, updating database", n.Name); db.UpdateRemoteVolume(n.Name, RemoteVolumeState.Verified, size, hash); } } catch (Exception ex) { Logging.Log.WriteErrorMessage(LOGTAG, "RemoteFileVerificationError", ex, "Failed to perform verification for file: {0}, please run verify; message: {1}", n.Name, ex.Message); if (ex is System.Threading.ThreadAbortException) { throw; } } } } } // TODO: It is actually possible to use the extra files if we parse them foreach (var n in tp.ExtraVolumes) { try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(db, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((float)progress / targetProgess); // If this is a new index file, we can accept it if it matches our local data // This makes it possible to augment the remote store with new index data if (n.FileType == RemoteVolumeType.Index && m_options.IndexfilePolicy != Options.IndexFileStrategy.None) { try { string hash; long size; using (var tf = backend.GetWithInfo(n.File.Name, out size, out hash)) using (var ifr = new IndexVolumeReader(n.CompressionModule, tf, m_options, m_options.BlockhashSize)) { foreach (var rv in ifr.Volumes) { var entry = db.GetRemoteVolume(rv.Filename); if (entry.ID < 0) { throw new Exception(string.Format("Unknown remote file {0} detected", rv.Filename)); } if (!new [] { RemoteVolumeState.Uploading, RemoteVolumeState.Uploaded, RemoteVolumeState.Verified }.Contains(entry.State)) { throw new Exception(string.Format("Volume {0} has local state {1}", rv.Filename, entry.State)); } if (entry.Hash != rv.Hash || entry.Size != rv.Length || !new [] { RemoteVolumeState.Uploading, RemoteVolumeState.Uploaded, RemoteVolumeState.Verified }.Contains(entry.State)) { throw new Exception(string.Format("Volume {0} hash/size mismatch ({1} - {2}) vs ({3} - {4})", rv.Filename, entry.Hash, entry.Size, rv.Hash, rv.Length)); } db.CheckAllBlocksAreInVolume(rv.Filename, rv.Blocks); } var blocksize = m_options.Blocksize; foreach (var ixb in ifr.BlockLists) { db.CheckBlocklistCorrect(ixb.Hash, ixb.Length, ixb.Blocklist, blocksize, hashsize); } var selfid = db.GetRemoteVolumeID(n.File.Name); foreach (var rv in ifr.Volumes) { db.AddIndexBlockLink(selfid, db.GetRemoteVolumeID(rv.Filename), null); } } // All checks fine, we accept the new index file Logging.Log.WriteInformationMessage(LOGTAG, "AcceptNewIndexFile", "Accepting new index file {0}", n.File.Name); db.RegisterRemoteVolume(n.File.Name, RemoteVolumeType.Index, size, RemoteVolumeState.Uploading); db.UpdateRemoteVolume(n.File.Name, RemoteVolumeState.Verified, size, hash); continue; } catch (Exception rex) { Logging.Log.WriteErrorMessage(LOGTAG, "FailedNewIndexFile", rex, "Failed to accept new index file: {0}, message: {1}", n.File.Name, rex.Message); } } if (!m_options.Dryrun) { db.RegisterRemoteVolume(n.File.Name, n.FileType, n.File.Size, RemoteVolumeState.Deleting); backend.Delete(n.File.Name, n.File.Size); } else { Logging.Log.WriteDryrunMessage(LOGTAG, "WouldDeleteFile", "would delete file {0}", n.File.Name); } } catch (Exception ex) { Logging.Log.WriteErrorMessage(LOGTAG, "FailedExtraFileCleanup", ex, "Failed to perform cleanup for extra file: {0}, message: {1}", n.File.Name, ex.Message); if (ex is System.Threading.ThreadAbortException) { throw; } } } if (!m_options.RebuildMissingDblockFiles) { var missingDblocks = tp.MissingVolumes.Where(x => x.Type == RemoteVolumeType.Blocks).ToArray(); if (missingDblocks.Length > 0) { throw new UserInformationException($"The backup storage destination is missing data files. You can either enable `--rebuild-missing-dblock-files` or run the purge command to remove these files. The following files are missing: {string.Join(", ", missingDblocks.Select(x => x.Name))}", "MissingDblockFiles"); } } foreach (var n in tp.MissingVolumes) { IDisposable newEntry = null; try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(db, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((float)progress / targetProgess); if (n.Type == RemoteVolumeType.Files) { var filesetId = db.GetFilesetIdFromRemotename(n.Name); var w = new FilesetVolumeWriter(m_options, DateTime.UtcNow); newEntry = w; w.SetRemoteFilename(n.Name); db.WriteFileset(w, filesetId, null); w.Close(); if (m_options.Dryrun) { Logging.Log.WriteDryrunMessage(LOGTAG, "WouldReUploadFileset", "would re-upload fileset {0}, with size {1}, previous size {2}", n.Name, Library.Utility.Utility.FormatSizeString(new System.IO.FileInfo(w.LocalFilename).Length), Library.Utility.Utility.FormatSizeString(n.Size)); } else { db.UpdateRemoteVolume(w.RemoteFilename, RemoteVolumeState.Uploading, -1, null, null); backend.Put(w); } } else if (n.Type == RemoteVolumeType.Index) { var w = new IndexVolumeWriter(m_options); newEntry = w; w.SetRemoteFilename(n.Name); var h = Library.Utility.HashAlgorithmHelper.Create(m_options.BlockHashAlgorithm); foreach (var blockvolume in db.GetBlockVolumesFromIndexName(n.Name)) { w.StartVolume(blockvolume.Name); var volumeid = db.GetRemoteVolumeID(blockvolume.Name); foreach (var b in db.GetBlocks(volumeid)) { w.AddBlock(b.Hash, b.Size); } w.FinishVolume(blockvolume.Hash, blockvolume.Size); if (m_options.IndexfilePolicy == Options.IndexFileStrategy.Full) { foreach (var b in db.GetBlocklists(volumeid, m_options.Blocksize, hashsize)) { var bh = Convert.ToBase64String(h.ComputeHash(b.Item2, 0, b.Item3)); if (bh != b.Item1) { throw new Exception(string.Format("Internal consistency check failed, generated index block has wrong hash, {0} vs {1}", bh, b.Item1)); } w.WriteBlocklist(b.Item1, b.Item2, 0, b.Item3); } } } w.Close(); if (m_options.Dryrun) { Logging.Log.WriteDryrunMessage(LOGTAG, "WouldReUploadIndexFile", "would re-upload index file {0}, with size {1}, previous size {2}", n.Name, Library.Utility.Utility.FormatSizeString(new System.IO.FileInfo(w.LocalFilename).Length), Library.Utility.Utility.FormatSizeString(n.Size)); } else { db.UpdateRemoteVolume(w.RemoteFilename, RemoteVolumeState.Uploading, -1, null, null); backend.Put(w); } } else if (n.Type == RemoteVolumeType.Blocks) { var w = new BlockVolumeWriter(m_options); newEntry = w; w.SetRemoteFilename(n.Name); using (var mbl = db.CreateBlockList(n.Name)) { //First we grab all known blocks from local files foreach (var block in mbl.GetSourceFilesWithBlocks(m_options.Blocksize)) { var hash = block.Hash; var size = (int)block.Size; foreach (var source in block.Sources) { var file = source.File; var offset = source.Offset; try { if (System.IO.File.Exists(file)) { using (var f = System.IO.File.OpenRead(file)) { f.Position = offset; if (size == Library.Utility.Utility.ForceStreamRead(f, buffer, size)) { var newhash = Convert.ToBase64String(blockhasher.ComputeHash(buffer, 0, size)); if (newhash == hash) { if (mbl.SetBlockRestored(hash, size)) { w.AddBlock(hash, buffer, 0, size, Duplicati.Library.Interface.CompressionHint.Default); } break; } } } } } catch (Exception ex) { Logging.Log.WriteErrorMessage(LOGTAG, "FileAccessError", ex, "Failed to access file: {0}", file); } } } //Then we grab all remote volumes that have the missing blocks foreach (var vol in new AsyncDownloader(mbl.GetMissingBlockSources().ToList(), backend)) { try { using (var tmpfile = vol.TempFile) using (var f = new BlockVolumeReader(RestoreHandler.GetCompressionModule(vol.Name), tmpfile, m_options)) foreach (var b in f.Blocks) { if (mbl.SetBlockRestored(b.Key, b.Value)) { if (f.ReadBlock(b.Key, buffer) == b.Value) { w.AddBlock(b.Key, buffer, 0, (int)b.Value, Duplicati.Library.Interface.CompressionHint.Default); } } } } catch (Exception ex) { Logging.Log.WriteErrorMessage(LOGTAG, "RemoteFileAccessError", ex, "Failed to access remote file: {0}", vol.Name); } } // If we managed to recover all blocks, NICE! var missingBlocks = mbl.GetMissingBlocks().Count(); if (missingBlocks > 0) { Logging.Log.WriteInformationMessage(LOGTAG, "RepairMissingBlocks", "Repair cannot acquire {0} required blocks for volume {1}, which are required by the following filesets: ", missingBlocks, n.Name); foreach (var f in mbl.GetFilesetsUsingMissingBlocks()) { Logging.Log.WriteInformationMessage(LOGTAG, "AffectedFilesetName", f.Name); } var recoverymsg = string.Format("If you want to continue working with the database, you can use the \"{0}\" and \"{1}\" commands to purge the missing data from the database and the remote storage.", "list-broken-files", "purge-broken-files"); if (!m_options.Dryrun) { Logging.Log.WriteInformationMessage(LOGTAG, "RecoverySuggestion", "This may be fixed by deleting the filesets and running repair again"); throw new UserInformationException(string.Format("Repair not possible, missing {0} blocks.\n" + recoverymsg, missingBlocks), "RepairIsNotPossible"); } else { Logging.Log.WriteInformationMessage(LOGTAG, "RecoverySuggestion", recoverymsg); } } else { if (m_options.Dryrun) { Logging.Log.WriteDryrunMessage(LOGTAG, "WouldReUploadBlockFile", "would re-upload block file {0}, with size {1}, previous size {2}", n.Name, Library.Utility.Utility.FormatSizeString(new System.IO.FileInfo(w.LocalFilename).Length), Library.Utility.Utility.FormatSizeString(n.Size)); } else { db.UpdateRemoteVolume(w.RemoteFilename, RemoteVolumeState.Uploading, -1, null, null); backend.Put(w); } } } } } catch (Exception ex) { if (newEntry != null) { try { newEntry.Dispose(); } catch { } finally { newEntry = null; } } Logging.Log.WriteErrorMessage(LOGTAG, "CleanupMissingFileError", ex, "Failed to perform cleanup for missing file: {0}, message: {1}", n.Name, ex.Message); if (ex is System.Threading.ThreadAbortException) { throw; } } } } else { Logging.Log.WriteInformationMessage(LOGTAG, "DatabaseIsSynchronized", "Destination and database are synchronized, not making any changes"); } m_result.OperationProgressUpdater.UpdateProgress(1); backend.WaitForComplete(db, null); db.WriteResults(); } }
/// <summary> /// Run the recreate procedure /// </summary> /// <param name="dbparent">The database to restore into</param> /// <param name="updating">True if this is an update call, false otherwise</param> /// <param name="filter">A filter that can be used to disregard certain remote files, intended to be used to select a certain filelist</param> /// <param name="filelistfilter">Filters the files in a filelist to prevent downloading unwanted data</param> /// <param name="blockprocessor">A callback hook that can be used to work with downloaded block volumes, intended to be use to recover data blocks while processing blocklists</param> internal void DoRun(LocalDatabase dbparent, bool updating, Library.Utility.IFilter filter = null, NumberedFilterFilelistDelegate filelistfilter = null, BlockVolumePostProcessor blockprocessor = null) { m_result.OperationProgressUpdater.UpdatePhase(OperationPhase.Recreate_Running); //We build a local database in steps. using (var restoredb = new LocalRecreateDatabase(dbparent, m_options)) using (var backend = new BackendManager(m_backendurl, m_options, m_result.BackendWriter, restoredb)) { restoredb.RepairInProgress = true; var volumeIds = new Dictionary <string, long>(); var rawlist = backend.List(); //First step is to examine the remote storage to see what // kind of data we can find var remotefiles = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null && n.Prefix == m_options.Prefix select n).ToArray(); //ToArray() ensures that we do not remote-request it multiple times if (remotefiles.Length == 0) { if (rawlist.Count == 0) { throw new UserInformationException("No files were found at the remote location, perhaps the target url is incorrect?", "EmptyRemoteLocation"); } else { var tmp = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null select n.Prefix).ToArray(); var types = tmp.Distinct().ToArray(); if (tmp.Length == 0) { throw new UserInformationException(string.Format("Found {0} files at the remote storage, but none that could be parsed", rawlist.Count), "EmptyRemoteLocation"); } else if (types.Length == 1) { throw new UserInformationException(string.Format("Found {0} parse-able files with the prefix {1}, did you forget to set the backup prefix?", tmp.Length, types[0]), "EmptyRemoteLocationWithPrefix"); } else { throw new UserInformationException(string.Format("Found {0} parse-able files (of {1} files) with different prefixes: {2}, did you forget to set the backup prefix?", tmp.Length, rawlist.Count, string.Join(", ", types)), "EmptyRemoteLocationWithPrefix"); } } } //Then we select the filelist we should work with, // and create the filelist table to fit IEnumerable <IParsedVolume> filelists = from n in remotefiles where n.FileType == RemoteVolumeType.Files orderby n.Time descending select n; if (filelists.Count() <= 0) { throw new UserInformationException(string.Format("No filelists found on the remote destination"), "EmptyRemoteLocation"); } if (filelistfilter != null) { filelists = filelistfilter(filelists).Select(x => x.Value).ToArray(); } if (filelists.Count() <= 0) { throw new UserInformationException(string.Format("No filelists"), "NoMatchingRemoteFilelists"); } // If we are updating, all files should be accounted for foreach (var fl in remotefiles) { volumeIds[fl.File.Name] = updating ? restoredb.GetRemoteVolumeID(fl.File.Name) : restoredb.RegisterRemoteVolume(fl.File.Name, fl.FileType, fl.File.Size, RemoteVolumeState.Uploaded); } var hasUpdatedOptions = false; if (updating) { Utility.UpdateOptionsFromDb(restoredb, m_options); Utility.VerifyParameters(restoredb, m_options); } //Record all blocksets and files needed using (var tr = restoredb.BeginTransaction()) { var filelistWork = (from n in filelists orderby n.Time select new RemoteVolume(n.File) as IRemoteVolume).ToList(); Logging.Log.WriteInformationMessage(LOGTAG, "RebuildStarted", "Rebuild database started, downloading {0} filelists", filelistWork.Count); var progress = 0; // Register the files we are working with, if not already updated if (updating) { foreach (var n in filelists) { if (volumeIds[n.File.Name] == -1) { volumeIds[n.File.Name] = restoredb.RegisterRemoteVolume(n.File.Name, n.FileType, RemoteVolumeState.Uploaded, n.File.Size, new TimeSpan(0), tr); } } } var isFirstFilelist = true; var blocksize = m_options.Blocksize; var hashes_pr_block = blocksize / m_options.BlockhashSize; foreach (var entry in new AsyncDownloader(filelistWork, backend)) { try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); m_result.EndTime = DateTime.UtcNow; return; } progress++; if (filelistWork.Count == 1 && m_options.RepairOnlyPaths) { m_result.OperationProgressUpdater.UpdateProgress(0.5f); } else { m_result.OperationProgressUpdater.UpdateProgress(((float)progress / filelistWork.Count()) * (m_options.RepairOnlyPaths ? 1f : 0.2f)); } using (var tmpfile = entry.TempFile) { isFirstFilelist = false; if (entry.Hash != null && entry.Size > 0) { restoredb.UpdateRemoteVolume(entry.Name, RemoteVolumeState.Verified, entry.Size, entry.Hash, tr); } var parsed = VolumeBase.ParseFilename(entry.Name); if (!hasUpdatedOptions && !updating) { VolumeReaderBase.UpdateOptionsFromManifest(parsed.CompressionModule, tmpfile, m_options); hasUpdatedOptions = true; // Recompute the cached sizes blocksize = m_options.Blocksize; hashes_pr_block = blocksize / m_options.BlockhashSize; } // Create timestamped operations based on the file timestamp var filesetid = restoredb.CreateFileset(volumeIds[entry.Name], parsed.Time, tr); using (var filelistreader = new FilesetVolumeReader(parsed.CompressionModule, tmpfile, m_options)) foreach (var fe in filelistreader.Files.Where(x => Library.Utility.FilterExpression.Matches(filter, x.Path))) { try { var expectedmetablocks = (fe.Metasize + blocksize - 1) / blocksize; var expectedmetablocklisthashes = (expectedmetablocks + hashes_pr_block - 1) / hashes_pr_block; if (expectedmetablocks <= 1) { expectedmetablocklisthashes = 0; } var metadataid = long.MinValue; switch (fe.Type) { case FilelistEntryType.Folder: metadataid = restoredb.AddMetadataset(fe.Metahash, fe.Metasize, fe.MetaBlocklistHashes, expectedmetablocklisthashes, tr); restoredb.AddDirectoryEntry(filesetid, fe.Path, fe.Time, metadataid, tr); break; case FilelistEntryType.File: var expectedblocks = (fe.Size + blocksize - 1) / blocksize; var expectedblocklisthashes = (expectedblocks + hashes_pr_block - 1) / hashes_pr_block; if (expectedblocks <= 1) { expectedblocklisthashes = 0; } var blocksetid = restoredb.AddBlockset(fe.Hash, fe.Size, fe.BlocklistHashes, expectedblocklisthashes, tr); metadataid = restoredb.AddMetadataset(fe.Metahash, fe.Metasize, fe.MetaBlocklistHashes, expectedmetablocklisthashes, tr); restoredb.AddFileEntry(filesetid, fe.Path, fe.Time, blocksetid, metadataid, tr); if (fe.Size <= blocksize) { if (!string.IsNullOrWhiteSpace(fe.Blockhash)) { restoredb.AddSmallBlocksetLink(fe.Hash, fe.Blockhash, fe.Blocksize, tr); } else if (m_options.BlockHashAlgorithm == m_options.FileHashAlgorithm) { restoredb.AddSmallBlocksetLink(fe.Hash, fe.Hash, fe.Size, tr); } else { Logging.Log.WriteWarningMessage(LOGTAG, "MissingBlockHash", null, "No block hash found for file: {0}", fe.Path); } } break; case FilelistEntryType.Symlink: metadataid = restoredb.AddMetadataset(fe.Metahash, fe.Metasize, fe.MetaBlocklistHashes, expectedmetablocklisthashes, tr); restoredb.AddSymlinkEntry(filesetid, fe.Path, fe.Time, metadataid, tr); break; default: Logging.Log.WriteWarningMessage(LOGTAG, "SkippingUnknownFileEntry", null, "Skipping file-entry with unknown type {0}: {1} ", fe.Type, fe.Path); break; } if (fe.Metasize <= blocksize && (fe.Type == FilelistEntryType.Folder || fe.Type == FilelistEntryType.File || fe.Type == FilelistEntryType.Symlink)) { if (!string.IsNullOrWhiteSpace(fe.Metablockhash)) { restoredb.AddSmallBlocksetLink(fe.Metahash, fe.Metablockhash, fe.Metasize, tr); } else if (m_options.BlockHashAlgorithm == m_options.FileHashAlgorithm) { restoredb.AddSmallBlocksetLink(fe.Metahash, fe.Metahash, fe.Metasize, tr); } else { Logging.Log.WriteWarningMessage(LOGTAG, "MissingMetadataBlockHash", null, "No block hash found for file metadata: {0}", fe.Path); } } } catch (Exception ex) { Logging.Log.WriteWarningMessage(LOGTAG, "FileEntryProcessingFailed", ex, "Failed to process file-entry: {0}", fe.Path); } } } } catch (Exception ex) { Logging.Log.WriteWarningMessage(LOGTAG, "FileProcessingFailed", ex, "Failed to process file: {0}", entry.Name); if (ex is System.Threading.ThreadAbortException) { m_result.EndTime = DateTime.UtcNow; throw; } if (isFirstFilelist && ex is System.Security.Cryptography.CryptographicException) { m_result.EndTime = DateTime.UtcNow; throw; } } } //Make sure we write the config if (!updating) { Utility.VerifyParameters(restoredb, m_options, tr); } using (new Logging.Timer(LOGTAG, "CommitUpdateFilesetFromRemote", "CommitUpdateFilesetFromRemote")) tr.Commit(); } if (!m_options.RepairOnlyPaths) { var hashalg = Library.Utility.HashAlgorithmHelper.Create(m_options.BlockHashAlgorithm); if (hashalg == null) { throw new UserInformationException(Strings.Common.InvalidHashAlgorithm(m_options.BlockHashAlgorithm), "BlockHashAlgorithmNotSupported"); } var hashsize = hashalg.HashSize / 8; //Grab all index files, and update the block table using (var tr = restoredb.BeginTransaction()) { var indexfiles = ( from n in remotefiles where n.FileType == RemoteVolumeType.Index select new RemoteVolume(n.File) as IRemoteVolume).ToList(); Logging.Log.WriteInformationMessage(LOGTAG, "FilelistsRestored", "Filelists restored, downloading {0} index files", indexfiles.Count); var progress = 0; foreach (var sf in new AsyncDownloader(indexfiles, backend)) { try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); m_result.EndTime = DateTime.UtcNow; return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((((float)progress / indexfiles.Count) * 0.5f) + 0.2f); using (var tmpfile = sf.TempFile) { if (sf.Hash != null && sf.Size > 0) { restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Verified, sf.Size, sf.Hash, tr); } using (var svr = new IndexVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options, hashsize)) { foreach (var a in svr.Volumes) { var filename = a.Filename; var volumeID = restoredb.GetRemoteVolumeID(filename); // No such file if (volumeID < 0) { volumeID = ProbeForMatchingFilename(ref filename, restoredb); } // Still broken, register a missing item if (volumeID < 0) { var p = VolumeBase.ParseFilename(filename); if (p == null) { throw new Exception(string.Format("Unable to parse filename: {0}", filename)); } Logging.Log.WriteErrorMessage(LOGTAG, "MissingFileDetected", null, "Remote file referenced as {0}, but not found in list, registering a missing remote file", filename); volumeID = restoredb.RegisterRemoteVolume(filename, p.FileType, RemoteVolumeState.Verified, tr); } //Add all block/volume mappings foreach (var b in a.Blocks) { restoredb.UpdateBlock(b.Key, b.Value, volumeID, tr); } restoredb.UpdateRemoteVolume(filename, RemoteVolumeState.Verified, a.Length, a.Hash, tr); restoredb.AddIndexBlockLink(restoredb.GetRemoteVolumeID(sf.Name), volumeID, tr); } //If there are blocklists in the index file, update the blocklists foreach (var b in svr.BlockLists) { restoredb.UpdateBlockset(b.Hash, b.Blocklist, tr); } } } } catch (Exception ex) { //Not fatal Logging.Log.WriteErrorMessage(LOGTAG, "IndexFileProcessingFailed", ex, "Failed to process index file: {0}", sf.Name); if (ex is System.Threading.ThreadAbortException) { m_result.EndTime = DateTime.UtcNow; throw; } } } using (new Logging.Timer(LOGTAG, "CommitRecreateDb", "CommitRecreatedDb")) tr.Commit(); // TODO: In some cases, we can avoid downloading all index files, // if we are lucky and pick the right ones } // We have now grabbed as much information as possible, // if we are still missing data, we must now fetch block files restoredb.FindMissingBlocklistHashes(hashsize, m_options.Blocksize, null); //We do this in three passes for (var i = 0; i < 3; i++) { // Grab the list matching the pass type var lst = restoredb.GetMissingBlockListVolumes(i, m_options.Blocksize, hashsize).ToList(); if (lst.Count > 0) { var fullist = ": " + string.Join(", ", lst.Select(x => x.Name)); switch (i) { case 0: Logging.Log.WriteVerboseMessage(LOGTAG, "ProcessingRequiredBlocklistVolumes", "Processing required {0} blocklist volumes{1}", lst.Count, fullist); Logging.Log.WriteInformationMessage(LOGTAG, "ProcessingRequiredBlocklistVolumes", "Processing required {0} blocklist volumes{1}", lst.Count, m_options.FullResult ? fullist : string.Empty); break; case 1: Logging.Log.WriteVerboseMessage(LOGTAG, "ProbingCandicateBlocklistVolumes", "Probing {0} candidate blocklist volumes{1}", lst.Count, fullist); Logging.Log.WriteInformationMessage(LOGTAG, "ProbingCandicateBlocklistVolumes", "Probing {0} candidate blocklist volumes{1}", lst.Count, m_options.FullResult ? fullist : string.Empty); break; default: Logging.Log.WriteVerboseMessage(LOGTAG, "ProcessingAllBlocklistVolumes", "Processing all of the {0} volumes for blocklists{1}", lst.Count, fullist); Logging.Log.WriteVerboseMessage(LOGTAG, "ProcessingAllBlocklistVolumes", "Processing all of the {0} volumes for blocklists{1}", lst.Count, m_options.FullResult ? fullist : string.Empty); break; } } var progress = 0; foreach (var sf in new AsyncDownloader(lst, backend)) { using (var tmpfile = sf.TempFile) using (var rd = new BlockVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options)) using (var tr = restoredb.BeginTransaction()) { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); m_result.EndTime = DateTime.UtcNow; return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((((float)progress / lst.Count) * 0.1f) + 0.7f + (i * 0.1f)); var volumeid = restoredb.GetRemoteVolumeID(sf.Name); restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Uploaded, sf.Size, sf.Hash, tr); // Update the block table so we know about the block/volume map foreach (var h in rd.Blocks) { restoredb.UpdateBlock(h.Key, h.Value, volumeid, tr); } // Grab all known blocklists from the volume foreach (var blocklisthash in restoredb.GetBlockLists(volumeid)) { restoredb.UpdateBlockset(blocklisthash, rd.ReadBlocklist(blocklisthash, hashsize), tr); } // Update tables so we know if we are done restoredb.FindMissingBlocklistHashes(hashsize, m_options.Blocksize, tr); using (new Logging.Timer(LOGTAG, "CommitRestoredBlocklist", "CommitRestoredBlocklist")) tr.Commit(); //At this point we can patch files with data from the block volume if (blockprocessor != null) { blockprocessor(sf.Name, rd); } } } } } backend.WaitForComplete(restoredb, null); if (m_options.RepairOnlyPaths) { Logging.Log.WriteInformationMessage(LOGTAG, "RecreateOrUpdateOnly", "Recreate/path-update completed, not running consistency checks"); } else { Logging.Log.WriteInformationMessage(LOGTAG, "RecreateCompletedCheckingDatabase", "Recreate completed, verifying the database consistency"); //All done, we must verify that we have all blocklist fully intact // if this fails, the db will not be deleted, so it can be used, // except to continue a backup m_result.EndTime = DateTime.UtcNow; using (var lbfdb = new LocalListBrokenFilesDatabase(restoredb)) { var broken = lbfdb.GetBrokenFilesets(new DateTime(0), null, null).Count(); if (broken != 0) { throw new UserInformationException(string.Format("Recreated database has missing blocks and {0} broken filelists. Consider using \"{1}\" and \"{2}\" to purge broken data from the remote store and the database.", broken, "list-broken-files", "purge-broken-files"), "DatabaseIsBrokenConsiderPurge"); } } restoredb.VerifyConsistency(m_options.Blocksize, m_options.BlockhashSize, true, null); Logging.Log.WriteInformationMessage(LOGTAG, "RecreateCompleted", "Recreate completed, and consistency checks completed, marking database as complete"); restoredb.RepairInProgress = false; } m_result.EndTime = DateTime.UtcNow; } }
/// <summary> /// Run the recreate procedure /// </summary> /// <param name="path">Path to the database that will be created</param> /// <param name="filelistfilter">A filter that can be used to disregard certain remote files, intended to be used to select a certain filelist</param> /// <param name="filenamefilter">Filters the files in a filelist to prevent downloading unwanted data</param> /// <param name="blockprocessor">A callback hook that can be used to work with downloaded block volumes, intended to be use to recover data blocks while processing blocklists</param> internal void DoRun(LocalDatabase dbparent, Library.Utility.IFilter filter = null, NumberedFilterFilelistDelegate filelistfilter = null, BlockVolumePostProcessor blockprocessor = null) { var hashalg = System.Security.Cryptography.HashAlgorithm.Create(m_options.BlockHashAlgorithm); if (hashalg == null) throw new Exception(string.Format(Strings.Foresthash.InvalidHashAlgorithm, m_options.BlockHashAlgorithm)); var hashsize = hashalg.HashSize / 8; //We build a local database in steps. using(var restoredb = new LocalRecreateDatabase(dbparent, m_options)) using(var backend = new BackendManager(m_backendurl, m_options, m_result.BackendWriter, restoredb)) { var volumeIds = new Dictionary<string, long>(); var rawlist = backend.List(); //First step is to examine the remote storage to see what // kind of data we can find var remotefiles = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null && n.Prefix == m_options.Prefix select n).ToArray(); //ToArray() ensures that we do not remote-request it multiple times if (remotefiles.Length == 0) { if (rawlist.Count == 0) throw new Exception("No files were found at the remote location, perhaps the target url is incorrect?"); else { var tmp = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null select n.Prefix).ToArray(); var types = tmp.Distinct().ToArray(); if (tmp.Length == 0) throw new Exception(string.Format("Found {0} files at the remote storage, but none that could be parsed", rawlist.Count)); else if (types.Length == 1) throw new Exception(string.Format("Found {0} parse-able files with the prefix {1}, did you forget to set the backup-prefix?", tmp.Length, types[0])); else throw new Exception(string.Format("Found {0} parse-able files (of {1} files) with different prefixes: {2}, did you forget to set the backup-prefix?", tmp.Length, rawlist.Count, string.Join(", ", types))); } } //Then we select the filelist we should work with, // and create the filelist table to fit IEnumerable<IParsedVolume> filelists = from n in remotefiles where n.FileType == RemoteVolumeType.Files orderby n.Time descending select n; if (filelistfilter != null) filelists = filelistfilter(filelists).Select(x => x.Value).ToArray(); foreach(var fl in remotefiles) volumeIds[fl.File.Name] = restoredb.RegisterRemoteVolume(fl.File.Name, fl.FileType, RemoteVolumeState.Uploaded); //Record all blocksets and files needed using(var tr = restoredb.BeginTransaction()) { var filelistWork = (from n in filelists orderby n.Time select new RemoteVolume(n.File) as IRemoteVolume).ToList(); foreach(var entry in new AsyncDownloader(filelistWork, backend)) try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } using(var tmpfile = entry.TempFile) { if (entry.Hash != null && entry.Size > 0) restoredb.UpdateRemoteVolume(entry.Name, RemoteVolumeState.Verified, entry.Size, entry.Hash, tr); var parsed = VolumeBase.ParseFilename(entry.Name); // Create timestamped operations based on the file timestamp var filesetid = restoredb.CreateFileset(volumeIds[entry.Name], parsed.Time, tr); using(var filelistreader = new FilesetVolumeReader(parsed.CompressionModule, tmpfile, m_options)) foreach(var fe in filelistreader.Files.Where(x => Library.Utility.FilterExpression.Matches(filter, x.Path))) { try { if (fe.Type == FilelistEntryType.Folder) { restoredb.AddDirectoryEntry(filesetid, fe.Path, fe.Time, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else if (fe.Type == FilelistEntryType.File) { var blocksetid = restoredb.AddBlockset(fe.Hash, fe.Size, fe.BlocklistHashes, tr); restoredb.AddFileEntry(filesetid, fe.Path, fe.Time, blocksetid, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else if (fe.Type == FilelistEntryType.Symlink) { restoredb.AddSymlinkEntry(filesetid, fe.Path, fe.Time, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else { m_result.AddWarning(string.Format("Skipping file-entry with unknown type {0}: {1} ", fe.Type, fe.Path), null); } } catch (Exception ex) { m_result.AddWarning(string.Format("Failed to process file-entry: {0}", fe.Path), ex); } } } } catch (Exception ex) { m_result.AddWarning(string.Format("Failed to process file: {0}", entry.Name), ex); if (ex is System.Threading.ThreadAbortException) throw; } using(new Logging.Timer("CommitUpdateFilesetFromRemote")) tr.Commit(); } //Grab all index files, and update the block table using(var tr = restoredb.BeginTransaction()) { var indexfiles = from n in remotefiles where n.FileType == RemoteVolumeType.Index select new RemoteVolume(n.File) as IRemoteVolume; foreach(var sf in new AsyncDownloader(indexfiles.ToList(), backend)) try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } using(var tmpfile = sf.TempFile) { if (sf.Hash != null && sf.Size > 0) restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Verified, sf.Size, sf.Hash, tr); using(var svr = new IndexVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options, hashsize)) { Utility.VerifyParameters(restoredb, m_options); foreach(var a in svr.Volumes) { var volumeID = restoredb.GetRemoteVolumeID(a.Filename); //Add all block/volume mappings foreach(var b in a.Blocks) restoredb.UpdateBlock(b.Key, b.Value, volumeID, tr); restoredb.UpdateRemoteVolume(a.Filename, RemoteVolumeState.Verified, a.Length, a.Hash, tr); restoredb.AddIndexBlockLink(restoredb.GetRemoteVolumeID(sf.Name), volumeID, tr); } //If there are blocklists in the index file, update the blocklists foreach(var b in svr.BlockLists) restoredb.UpdateBlockset(b.Hash, b.Blocklist, tr); } } } catch (Exception ex) { //Not fatal m_result.AddWarning(string.Format("Failed to process index file: {0}", sf.Name), ex); if (ex is System.Threading.ThreadAbortException) throw; } using(new Logging.Timer("CommitRecreatedDb")) tr.Commit(); // TODO: In some cases, we can avoid downloading all index files, // if we are lucky and pick the right ones } // We have now grabbed as much information as possible, // if we are still missing data, we must now fetch block files restoredb.FindMissingBlocklistHashes(hashsize, null); //We do this in three passes for(var i = 0; i < 3; i++) { // Grab the list matching the pass type var lst = restoredb.GetMissingBlockListVolumes(i).ToList(); foreach (var sf in new AsyncDownloader(lst, backend)) using (var tmpfile = sf.TempFile) using (var rd = new BlockVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options)) using (var tr = restoredb.BeginTransaction()) { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } var volumeid = restoredb.GetRemoteVolumeID(sf.Name); // Update the block table so we know about the block/volume map foreach(var h in rd.Blocks) restoredb.UpdateBlock(h.Key, h.Value, volumeid, tr); // Grab all known blocklists from the volume foreach (var blocklisthash in restoredb.GetBlockLists(volumeid)) restoredb.UpdateBlockset(blocklisthash, rd.ReadBlocklist(blocklisthash, hashsize), tr); // Update tables so we know if we are done restoredb.FindMissingBlocklistHashes(hashsize, tr); using(new Logging.Timer("CommitRestoredBlocklist")) tr.Commit(); //At this point we can patch files with data from the block volume if (blockprocessor != null) blockprocessor(sf.Name, rd); } } backend.WaitForComplete(restoredb, null); //All done, we must verify that we have all blocklist fully intact // if this fails, the db will not be deleted, so it can be used, // except to continue a backup restoredb.VerifyConsistency(null); } }
/// <summary> /// Run the recreate procedure /// </summary> /// <param name="path">Path to the database that will be created</param> /// <param name="filelistfilter">A filter that can be used to disregard certain remote files, intended to be used to select a certain filelist</param> /// <param name="filenamefilter">Filters the files in a filelist to prevent downloading unwanted data</param> /// <param name="blockprocessor">A callback hook that can be used to work with downloaded block volumes, intended to be use to recover data blocks while processing blocklists</param> internal void DoRun(LocalDatabase dbparent, Library.Utility.IFilter filter = null, NumberedFilterFilelistDelegate filelistfilter = null, BlockVolumePostProcessor blockprocessor = null) { var hashalg = System.Security.Cryptography.HashAlgorithm.Create(m_options.BlockHashAlgorithm); if (hashalg == null) { throw new Exception(Strings.Foresthash.InvalidHashAlgorithm(m_options.BlockHashAlgorithm)); } var hashsize = hashalg.HashSize / 8; m_result.OperationProgressUpdater.UpdatePhase(OperationPhase.Recreate_Running); //We build a local database in steps. using (var restoredb = new LocalRecreateDatabase(dbparent, m_options)) using (var backend = new BackendManager(m_backendurl, m_options, m_result.BackendWriter, restoredb)) { var volumeIds = new Dictionary <string, long>(); var rawlist = backend.List(); //First step is to examine the remote storage to see what // kind of data we can find var remotefiles = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null && n.Prefix == m_options.Prefix select n).ToArray(); //ToArray() ensures that we do not remote-request it multiple times if (remotefiles.Length == 0) { if (rawlist.Count == 0) { throw new Exception("No files were found at the remote location, perhaps the target url is incorrect?"); } else { var tmp = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null select n.Prefix).ToArray(); var types = tmp.Distinct().ToArray(); if (tmp.Length == 0) { throw new Exception(string.Format("Found {0} files at the remote storage, but none that could be parsed", rawlist.Count)); } else if (types.Length == 1) { throw new Exception(string.Format("Found {0} parse-able files with the prefix {1}, did you forget to set the backup-prefix?", tmp.Length, types[0])); } else { throw new Exception(string.Format("Found {0} parse-able files (of {1} files) with different prefixes: {2}, did you forget to set the backup-prefix?", tmp.Length, rawlist.Count, string.Join(", ", types))); } } } //Then we select the filelist we should work with, // and create the filelist table to fit IEnumerable <IParsedVolume> filelists = from n in remotefiles where n.FileType == RemoteVolumeType.Files orderby n.Time descending select n; if (filelistfilter != null) { filelists = filelistfilter(filelists).Select(x => x.Value).ToArray(); } foreach (var fl in remotefiles) { volumeIds[fl.File.Name] = restoredb.RegisterRemoteVolume(fl.File.Name, fl.FileType, RemoteVolumeState.Uploaded); } //Record all blocksets and files needed using (var tr = restoredb.BeginTransaction()) { var filelistWork = (from n in filelists orderby n.Time select new RemoteVolume(n.File) as IRemoteVolume).ToList(); var progress = 0; foreach (var entry in new AsyncDownloader(filelistWork, backend)) { try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress(((float)progress / filelistWork.Count()) * 0.2f); using (var tmpfile = entry.TempFile) { if (entry.Hash != null && entry.Size > 0) { restoredb.UpdateRemoteVolume(entry.Name, RemoteVolumeState.Verified, entry.Size, entry.Hash, tr); } var parsed = VolumeBase.ParseFilename(entry.Name); // Create timestamped operations based on the file timestamp var filesetid = restoredb.CreateFileset(volumeIds[entry.Name], parsed.Time, tr); using (var filelistreader = new FilesetVolumeReader(parsed.CompressionModule, tmpfile, m_options)) foreach (var fe in filelistreader.Files.Where(x => Library.Utility.FilterExpression.Matches(filter, x.Path))) { try { if (fe.Type == FilelistEntryType.Folder) { restoredb.AddDirectoryEntry(filesetid, fe.Path, fe.Time, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else if (fe.Type == FilelistEntryType.File) { var blocksetid = restoredb.AddBlockset(fe.Hash, fe.Size, fe.BlocklistHashes, tr); restoredb.AddFileEntry(filesetid, fe.Path, fe.Time, blocksetid, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else if (fe.Type == FilelistEntryType.Symlink) { restoredb.AddSymlinkEntry(filesetid, fe.Path, fe.Time, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else { m_result.AddWarning(string.Format("Skipping file-entry with unknown type {0}: {1} ", fe.Type, fe.Path), null); } } catch (Exception ex) { m_result.AddWarning(string.Format("Failed to process file-entry: {0}", fe.Path), ex); } } } } catch (Exception ex) { m_result.AddWarning(string.Format("Failed to process file: {0}", entry.Name), ex); if (ex is System.Threading.ThreadAbortException) { throw; } } } using (new Logging.Timer("CommitUpdateFilesetFromRemote")) tr.Commit(); } //Grab all index files, and update the block table using (var tr = restoredb.BeginTransaction()) { var indexfiles = ( from n in remotefiles where n.FileType == RemoteVolumeType.Index select new RemoteVolume(n.File) as IRemoteVolume).ToList(); var progress = 0; foreach (var sf in new AsyncDownloader(indexfiles, backend)) { try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((((float)progress / indexfiles.Count) * 0.5f) + 0.2f); using (var tmpfile = sf.TempFile) { if (sf.Hash != null && sf.Size > 0) { restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Verified, sf.Size, sf.Hash, tr); } using (var svr = new IndexVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options, hashsize)) { Utility.VerifyParameters(restoredb, m_options); foreach (var a in svr.Volumes) { var volumeID = restoredb.GetRemoteVolumeID(a.Filename); //Add all block/volume mappings foreach (var b in a.Blocks) { restoredb.UpdateBlock(b.Key, b.Value, volumeID, tr); } restoredb.UpdateRemoteVolume(a.Filename, RemoteVolumeState.Verified, a.Length, a.Hash, tr); restoredb.AddIndexBlockLink(restoredb.GetRemoteVolumeID(sf.Name), volumeID, tr); } //If there are blocklists in the index file, update the blocklists foreach (var b in svr.BlockLists) { restoredb.UpdateBlockset(b.Hash, b.Blocklist, tr); } } } } catch (Exception ex) { //Not fatal m_result.AddWarning(string.Format("Failed to process index file: {0}", sf.Name), ex); if (ex is System.Threading.ThreadAbortException) { throw; } } } using (new Logging.Timer("CommitRecreatedDb")) tr.Commit(); // TODO: In some cases, we can avoid downloading all index files, // if we are lucky and pick the right ones } // We have now grabbed as much information as possible, // if we are still missing data, we must now fetch block files restoredb.FindMissingBlocklistHashes(hashsize, null); //We do this in three passes for (var i = 0; i < 3; i++) { // Grab the list matching the pass type var lst = restoredb.GetMissingBlockListVolumes(i).ToList(); if (lst.Count > 0) { switch (i) { case 0: if (m_options.Verbose) { m_result.AddVerboseMessage("Processing required {0} blocklist volumes: {1}", lst.Count, string.Join(", ", lst.Select(x => x.Name))); } else { m_result.AddMessage(string.Format("Processing required {0} blocklist volumes", lst.Count)); } break; case 1: if (m_options.Verbose) { m_result.AddVerboseMessage("Probing {0} candidate blocklist volumes: {1}", lst.Count, string.Join(", ", lst.Select(x => x.Name))); } else { m_result.AddMessage(string.Format("Probing {0} candidate blocklist volumes", lst.Count)); } break; default: if (m_options.Verbose) { m_result.AddVerboseMessage("Processing all of the {0} volumes for blocklists: {1}", lst.Count, string.Join(", ", lst.Select(x => x.Name))); } else { m_result.AddMessage(string.Format("Processing all of the {0} volumes for blocklists", lst.Count)); } break; } } var progress = 0; foreach (var sf in new AsyncDownloader(lst, backend)) { using (var tmpfile = sf.TempFile) using (var rd = new BlockVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options)) using (var tr = restoredb.BeginTransaction()) { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((((float)progress / lst.Count) * 0.1f) + 0.7f + (i * 0.1f)); var volumeid = restoredb.GetRemoteVolumeID(sf.Name); restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Uploaded, sf.Size, sf.Hash, tr); // Update the block table so we know about the block/volume map foreach (var h in rd.Blocks) { restoredb.UpdateBlock(h.Key, h.Value, volumeid, tr); } // Grab all known blocklists from the volume foreach (var blocklisthash in restoredb.GetBlockLists(volumeid)) { restoredb.UpdateBlockset(blocklisthash, rd.ReadBlocklist(blocklisthash, hashsize), tr); } // Update tables so we know if we are done restoredb.FindMissingBlocklistHashes(hashsize, tr); using (new Logging.Timer("CommitRestoredBlocklist")) tr.Commit(); //At this point we can patch files with data from the block volume if (blockprocessor != null) { blockprocessor(sf.Name, rd); } } } } backend.WaitForComplete(restoredb, null); //All done, we must verify that we have all blocklist fully intact // if this fails, the db will not be deleted, so it can be used, // except to continue a backup restoredb.VerifyConsistency(null, m_options.Blocksize, m_options.BlockhashSize); } }
private void RenameFileAfterError(FileEntryItem item) { var p = VolumeBase.ParseFilename(item.RemoteFilename); var guid = VolumeWriterBase.GenerateGuid(m_options); var time = p.Time.Ticks == 0 ? p.Time : p.Time.AddSeconds(1); var newname = VolumeBase.GenerateFilename(p.FileType, p.Prefix, guid, time, p.CompressionModule, p.EncryptionModule); var oldname = item.RemoteFilename; m_statwriter.SendEvent(item.BackendActionType, BackendEventType.Rename, oldname, item.Size); m_statwriter.SendEvent(item.BackendActionType, BackendEventType.Rename, newname, item.Size); m_statwriter.AddMessage(string.Format("Renaming \"{0}\" to \"{1}\"", oldname, newname)); m_db.LogDbRename(oldname, newname); item.RemoteFilename = newname; // If there is an index file attached to the block file, // it references the block filename, so we create a new index file // which is a copy of the current, but with the new name if (item.Indexfile != null) { if (!item.IndexfileUpdated) { item.Indexfile.Item1.FinishVolume(item.Hash, item.Size); item.Indexfile.Item1.Close(); item.IndexfileUpdated = true; } IndexVolumeWriter wr = null; try { var hashsize = System.Security.Cryptography.HashAlgorithm.Create(m_options.BlockHashAlgorithm).HashSize / 8; wr = new IndexVolumeWriter(m_options); using(var rd = new IndexVolumeReader(p.CompressionModule, item.Indexfile.Item2.LocalFilename, m_options, hashsize)) wr.CopyFrom(rd, x => x == oldname ? newname : x); item.Indexfile.Item1.Dispose(); item.Indexfile = new Tuple<IndexVolumeWriter, FileEntryItem>(wr, item.Indexfile.Item2); item.Indexfile.Item2.LocalTempfile.Dispose(); item.Indexfile.Item2.LocalTempfile = wr.TempFile; wr.Close(); } catch { if (wr != null) try { wr.Dispose(); } catch { } finally { wr = null; } throw; } } }
/// <summary> /// Run the recreate procedure /// </summary> /// <param name="dbparent">The database to restore into</param> /// <param name="updating">True if this is an update call, false otherwise</param> /// <param name="filter">A filter that can be used to disregard certain remote files, intended to be used to select a certain filelist</param> /// <param name="filenamefilter">Filters the files in a filelist to prevent downloading unwanted data</param> /// <param name="blockprocessor">A callback hook that can be used to work with downloaded block volumes, intended to be use to recover data blocks while processing blocklists</param> internal void DoRun(LocalDatabase dbparent, bool updating, Library.Utility.IFilter filter = null, NumberedFilterFilelistDelegate filelistfilter = null, BlockVolumePostProcessor blockprocessor = null) { m_result.OperationProgressUpdater.UpdatePhase(OperationPhase.Recreate_Running); //We build a local database in steps. using(var restoredb = new LocalRecreateDatabase(dbparent, m_options)) using(var backend = new BackendManager(m_backendurl, m_options, m_result.BackendWriter, restoredb)) { restoredb.RepairInProgress = true; var volumeIds = new Dictionary<string, long>(); var rawlist = backend.List(); //First step is to examine the remote storage to see what // kind of data we can find var remotefiles = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null && n.Prefix == m_options.Prefix select n).ToArray(); //ToArray() ensures that we do not remote-request it multiple times if (remotefiles.Length == 0) { if (rawlist.Count == 0) throw new Exception("No files were found at the remote location, perhaps the target url is incorrect?"); else { var tmp = (from x in rawlist let n = VolumeBase.ParseFilename(x) where n != null select n.Prefix).ToArray(); var types = tmp.Distinct().ToArray(); if (tmp.Length == 0) throw new Exception(string.Format("Found {0} files at the remote storage, but none that could be parsed", rawlist.Count)); else if (types.Length == 1) throw new Exception(string.Format("Found {0} parse-able files with the prefix {1}, did you forget to set the backup-prefix?", tmp.Length, types[0])); else throw new Exception(string.Format("Found {0} parse-able files (of {1} files) with different prefixes: {2}, did you forget to set the backup-prefix?", tmp.Length, rawlist.Count, string.Join(", ", types))); } } //Then we select the filelist we should work with, // and create the filelist table to fit IEnumerable<IParsedVolume> filelists = from n in remotefiles where n.FileType == RemoteVolumeType.Files orderby n.Time descending select n; if (filelists.Count() <= 0) throw new Exception(string.Format("No filelists found on the remote destination")); if (filelistfilter != null) filelists = filelistfilter(filelists).Select(x => x.Value).ToArray(); if (filelists.Count() <= 0) throw new Exception(string.Format("No filelists")); // If we are updating, all files should be accounted for foreach(var fl in remotefiles) volumeIds[fl.File.Name] = updating ? restoredb.GetRemoteVolumeID(fl.File.Name) : restoredb.RegisterRemoteVolume(fl.File.Name, fl.FileType, fl.File.Size, RemoteVolumeState.Uploaded); var hasUpdatedOptions = false; if (updating) { Utility.UpdateOptionsFromDb(restoredb, m_options); Utility.VerifyParameters(restoredb, m_options); } //Record all blocksets and files needed using(var tr = restoredb.BeginTransaction()) { var filelistWork = (from n in filelists orderby n.Time select new RemoteVolume(n.File) as IRemoteVolume).ToList(); m_result.AddMessage(string.Format("Rebuild database started, downloading {0} filelists", filelistWork.Count)); var progress = 0; // Register the files we are working with, if not already updated if (updating) { foreach(var n in filelists) if (volumeIds[n.File.Name] == -1) volumeIds[n.File.Name] = restoredb.RegisterRemoteVolume(n.File.Name, n.FileType, RemoteVolumeState.Uploaded, n.File.Size, new TimeSpan(0), tr); } var isFirstFilelist = true; var blocksize = m_options.Blocksize; var hashes_pr_block = blocksize / m_options.BlockhashSize; foreach(var entry in new AsyncDownloader(filelistWork, backend)) try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } progress++; if (filelistWork.Count == 1 && m_options.RepairOnlyPaths) m_result.OperationProgressUpdater.UpdateProgress(0.5f); else m_result.OperationProgressUpdater.UpdateProgress(((float)progress / filelistWork.Count()) * (m_options.RepairOnlyPaths ? 1f : 0.2f)); using(var tmpfile = entry.TempFile) { isFirstFilelist = false; if (entry.Hash != null && entry.Size > 0) restoredb.UpdateRemoteVolume(entry.Name, RemoteVolumeState.Verified, entry.Size, entry.Hash, tr); var parsed = VolumeBase.ParseFilename(entry.Name); if (!hasUpdatedOptions && !updating) { VolumeReaderBase.UpdateOptionsFromManifest(parsed.CompressionModule, tmpfile, m_options); hasUpdatedOptions = true; // Recompute the cached sizes blocksize = m_options.Blocksize; hashes_pr_block = blocksize / m_options.BlockhashSize; } // Create timestamped operations based on the file timestamp var filesetid = restoredb.CreateFileset(volumeIds[entry.Name], parsed.Time, tr); using(var filelistreader = new FilesetVolumeReader(parsed.CompressionModule, tmpfile, m_options)) foreach(var fe in filelistreader.Files.Where(x => Library.Utility.FilterExpression.Matches(filter, x.Path))) { try { if (fe.Type == FilelistEntryType.Folder) { restoredb.AddDirectoryEntry(filesetid, fe.Path, fe.Time, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else if (fe.Type == FilelistEntryType.File) { var expectedblocks = (fe.Size + blocksize - 1) / blocksize; var expectedblocklisthashes = (expectedblocks + hashes_pr_block - 1) / hashes_pr_block; if (expectedblocks <= 1) expectedblocklisthashes = 0; var blocksetid = restoredb.AddBlockset(fe.Hash, fe.Size, fe.BlocklistHashes, expectedblocklisthashes, tr); restoredb.AddFileEntry(filesetid, fe.Path, fe.Time, blocksetid, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else if (fe.Type == FilelistEntryType.Symlink) { restoredb.AddSymlinkEntry(filesetid, fe.Path, fe.Time, fe.Metahash, fe.Metahash == null ? -1 : fe.Metasize, tr); } else { m_result.AddWarning(string.Format("Skipping file-entry with unknown type {0}: {1} ", fe.Type, fe.Path), null); } } catch (Exception ex) { m_result.AddWarning(string.Format("Failed to process file-entry: {0}", fe.Path), ex); } } } } catch (Exception ex) { m_result.AddWarning(string.Format("Failed to process file: {0}", entry.Name), ex); if (ex is System.Threading.ThreadAbortException) throw; if (isFirstFilelist && ex is System.Security.Cryptography.CryptographicException) throw; } //Make sure we write the config if (!updating) Utility.VerifyParameters(restoredb, m_options, tr); using(new Logging.Timer("CommitUpdateFilesetFromRemote")) tr.Commit(); } if (!m_options.RepairOnlyPaths) { var hashalg = System.Security.Cryptography.HashAlgorithm.Create(m_options.BlockHashAlgorithm); if (hashalg == null) throw new Exception(Strings.Common.InvalidHashAlgorithm(m_options.BlockHashAlgorithm)); var hashsize = hashalg.HashSize / 8; //Grab all index files, and update the block table using(var tr = restoredb.BeginTransaction()) { var indexfiles = ( from n in remotefiles where n.FileType == RemoteVolumeType.Index select new RemoteVolume(n.File) as IRemoteVolume).ToList(); m_result.AddMessage(string.Format("Filelists restored, downloading {0} index files", indexfiles.Count)); var progress = 0; foreach(var sf in new AsyncDownloader(indexfiles, backend)) try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((((float)progress / indexfiles.Count) * 0.5f) + 0.2f); using(var tmpfile = sf.TempFile) { if (sf.Hash != null && sf.Size > 0) restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Verified, sf.Size, sf.Hash, tr); using(var svr = new IndexVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options, hashsize)) { foreach(var a in svr.Volumes) { var filename = a.Filename; var volumeID = restoredb.GetRemoteVolumeID(filename); // No such file if (volumeID < 0) volumeID = ProbeForMatchingFilename(ref filename, restoredb); // Still broken, register a missing item if (volumeID < 0) { var p = VolumeBase.ParseFilename(filename); if (p == null) throw new Exception(string.Format("Unable to parse filename: {0}", filename)); m_result.AddError(string.Format("Remote file referenced as {0}, but not found in list, registering a missing remote file", filename), null); volumeID = restoredb.RegisterRemoteVolume(filename, p.FileType, RemoteVolumeState.Verified, tr); } //Add all block/volume mappings foreach(var b in a.Blocks) restoredb.UpdateBlock(b.Key, b.Value, volumeID, tr); restoredb.UpdateRemoteVolume(filename, RemoteVolumeState.Verified, a.Length, a.Hash, tr); restoredb.AddIndexBlockLink(restoredb.GetRemoteVolumeID(sf.Name), volumeID, tr); } //If there are blocklists in the index file, update the blocklists foreach(var b in svr.BlockLists) restoredb.UpdateBlockset(b.Hash, b.Blocklist, tr); } } } catch (Exception ex) { //Not fatal m_result.AddWarning(string.Format("Failed to process index file: {0}", sf.Name), ex); if (ex is System.Threading.ThreadAbortException) throw; } using(new Logging.Timer("CommitRecreatedDb")) tr.Commit(); // TODO: In some cases, we can avoid downloading all index files, // if we are lucky and pick the right ones } // We have now grabbed as much information as possible, // if we are still missing data, we must now fetch block files restoredb.FindMissingBlocklistHashes(hashsize, m_options.Blocksize, null); //We do this in three passes for(var i = 0; i < 3; i++) { // Grab the list matching the pass type var lst = restoredb.GetMissingBlockListVolumes(i, m_options.Blocksize, hashsize).ToList(); if (lst.Count > 0) { switch (i) { case 0: if (m_options.Verbose) m_result.AddVerboseMessage("Processing required {0} blocklist volumes: {1}", lst.Count, string.Join(", ", lst.Select(x => x.Name))); else m_result.AddMessage(string.Format("Processing required {0} blocklist volumes", lst.Count)); break; case 1: if (m_options.Verbose) m_result.AddVerboseMessage("Probing {0} candidate blocklist volumes: {1}", lst.Count, string.Join(", ", lst.Select(x => x.Name))); else m_result.AddMessage(string.Format("Probing {0} candidate blocklist volumes", lst.Count)); break; default: if (m_options.Verbose) m_result.AddVerboseMessage("Processing all of the {0} volumes for blocklists: {1}", lst.Count, string.Join(", ", lst.Select(x => x.Name))); else m_result.AddMessage(string.Format("Processing all of the {0} volumes for blocklists", lst.Count)); break; } } var progress = 0; foreach(var sf in new AsyncDownloader(lst, backend)) using(var tmpfile = sf.TempFile) using(var rd = new BlockVolumeReader(RestoreHandler.GetCompressionModule(sf.Name), tmpfile, m_options)) using(var tr = restoredb.BeginTransaction()) { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(restoredb, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((((float)progress / lst.Count) * 0.1f) + 0.7f + (i * 0.1f)); var volumeid = restoredb.GetRemoteVolumeID(sf.Name); restoredb.UpdateRemoteVolume(sf.Name, RemoteVolumeState.Uploaded, sf.Size, sf.Hash, tr); // Update the block table so we know about the block/volume map foreach(var h in rd.Blocks) restoredb.UpdateBlock(h.Key, h.Value, volumeid, tr); // Grab all known blocklists from the volume foreach(var blocklisthash in restoredb.GetBlockLists(volumeid)) restoredb.UpdateBlockset(blocklisthash, rd.ReadBlocklist(blocklisthash, hashsize), tr); // Update tables so we know if we are done restoredb.FindMissingBlocklistHashes(hashsize, m_options.Blocksize, tr); using(new Logging.Timer("CommitRestoredBlocklist")) tr.Commit(); //At this point we can patch files with data from the block volume if (blockprocessor != null) blockprocessor(sf.Name, rd); } } } backend.WaitForComplete(restoredb, null); m_result.AddMessage("Recreate completed, verifying the database consistency"); //All done, we must verify that we have all blocklist fully intact // if this fails, the db will not be deleted, so it can be used, // except to continue a backup restoredb.VerifyConsistency(null, m_options.Blocksize, m_options.BlockhashSize); m_result.AddMessage("Recreate completed, and consistency checks completed, marking database as complete"); restoredb.RepairInProgress = false; } }
public void RunRepairRemote() { if (!System.IO.File.Exists(m_options.Dbpath)) throw new Exception(string.Format("Database file does not exist: {0}", m_options.Dbpath)); m_result.OperationProgressUpdater.UpdateProgress(0); using(var db = new LocalRepairDatabase(m_options.Dbpath)) using(var backend = new BackendManager(m_backendurl, m_options, m_result.BackendWriter, db)) { m_result.SetDatabase(db); Utility.UpdateOptionsFromDb(db, m_options); Utility.VerifyParameters(db, m_options); if (db.RepairInProgress) throw new Exception("The database was attempted repaired, but the repair did not complete. This database may be incomplete and the repair process is not allowed to alter remote files as that could result in data loss."); var tp = FilelistProcessor.RemoteListAnalysis(backend, m_options, db, m_result.BackendWriter); var buffer = new byte[m_options.Blocksize]; var blockhasher = System.Security.Cryptography.HashAlgorithm.Create(m_options.BlockHashAlgorithm); var hashsize = blockhasher.HashSize / 8; if (blockhasher == null) throw new Exception(Strings.Common.InvalidHashAlgorithm(m_options.BlockHashAlgorithm)); if (!blockhasher.CanReuseTransform) throw new Exception(Strings.Common.InvalidCryptoSystem(m_options.BlockHashAlgorithm)); var progress = 0; var targetProgess = tp.ExtraVolumes.Count() + tp.MissingVolumes.Count() + tp.VerificationRequiredVolumes.Count(); if (m_options.Dryrun) { if (tp.ParsedVolumes.Count() == 0 && tp.OtherVolumes.Count() > 0) { if (tp.BackupPrefixes.Length == 1) throw new Exception(string.Format("Found no backup files with prefix {0}, but files with prefix {1}, did you forget to set the backup-prefix?", m_options.Prefix, tp.BackupPrefixes[0])); else throw new Exception(string.Format("Found no backup files with prefix {0}, but files with prefixes {1}, did you forget to set the backup-prefix?", m_options.Prefix, string.Join(", ", tp.BackupPrefixes))); } else if (tp.ParsedVolumes.Count() == 0 && tp.ExtraVolumes.Count() > 0) { throw new Exception(string.Format("No files were missing, but {0} remote files were, found, did you mean to run recreate-database?", tp.ExtraVolumes.Count())); } } if (tp.ExtraVolumes.Count() > 0 || tp.MissingVolumes.Count() > 0 || tp.VerificationRequiredVolumes.Count() > 0) { if (tp.VerificationRequiredVolumes.Any()) { using(var testdb = new LocalTestDatabase(db)) { foreach(var n in tp.VerificationRequiredVolumes) try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(db, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((float)progress / targetProgess); long size; string hash; KeyValuePair<string, IEnumerable<KeyValuePair<Duplicati.Library.Interface.TestEntryStatus, string>>> res; using (var tf = backend.GetWithInfo(n.Name, out size, out hash)) res = TestHandler.TestVolumeInternals(testdb, n, tf, m_options, m_result, 1); if (res.Value.Any()) throw new Exception(string.Format("Remote verification failure: {0}", res.Value.First())); if (!m_options.Dryrun) { m_result.AddMessage(string.Format("Sucessfully captured hash for {0}, updating database", n.Name)); db.UpdateRemoteVolume(n.Name, RemoteVolumeState.Verified, size, hash); } } catch (Exception ex) { m_result.AddError(string.Format("Failed to perform verification for file: {0}, please run verify; message: {1}", n.Name, ex.Message), ex); if (ex is System.Threading.ThreadAbortException) throw; } } } // TODO: It is actually possible to use the extra files if we parse them foreach(var n in tp.ExtraVolumes) try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(db, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((float)progress / targetProgess); // If this is a new index file, we can accept it if it matches our local data // This makes it possible to augment the remote store with new index data if (n.FileType == RemoteVolumeType.Index && m_options.IndexfilePolicy != Options.IndexFileStrategy.None) { try { string hash; long size; using(var tf = backend.GetWithInfo(n.File.Name, out size, out hash)) using(var ifr = new IndexVolumeReader(n.CompressionModule, tf, m_options, m_options.BlockhashSize)) { foreach(var rv in ifr.Volumes) { string cmphash; long cmpsize; RemoteVolumeType cmptype; RemoteVolumeState cmpstate; if (!db.GetRemoteVolume(rv.Filename, out cmphash, out cmpsize, out cmptype, out cmpstate)) throw new Exception(string.Format("Unknown remote file {0} detected", rv.Filename)); if (!new [] { RemoteVolumeState.Uploading, RemoteVolumeState.Uploaded, RemoteVolumeState.Verified }.Contains(cmpstate)) throw new Exception(string.Format("Volume {0} has local state {1}", rv.Filename, cmpstate)); if (cmphash != rv.Hash || cmpsize != rv.Length || ! new [] { RemoteVolumeState.Uploading, RemoteVolumeState.Uploaded, RemoteVolumeState.Verified }.Contains(cmpstate)) throw new Exception(string.Format("Volume {0} hash/size mismatch ({1} - {2}) vs ({3} - {4})", rv.Filename, cmphash, cmpsize, rv.Hash, rv.Length)); db.CheckAllBlocksAreInVolume(rv.Filename, rv.Blocks); } var blocksize = m_options.Blocksize; foreach(var ixb in ifr.BlockLists) db.CheckBlocklistCorrect(ixb.Hash, ixb.Length, ixb.Blocklist, blocksize, hashsize); var selfid = db.GetRemoteVolumeID(n.File.Name); foreach(var rv in ifr.Volumes) db.AddIndexBlockLink(selfid, db.GetRemoteVolumeID(rv.Filename), null); } // All checks fine, we accept the new index file m_result.AddMessage(string.Format("Accepting new index file {0}", n.File.Name)); db.RegisterRemoteVolume(n.File.Name, RemoteVolumeType.Index, size, RemoteVolumeState.Uploading); db.UpdateRemoteVolume(n.File.Name, RemoteVolumeState.Verified, size, hash); continue; } catch (Exception rex) { m_result.AddError(string.Format("Failed to accept new index file: {0}, message: {1}", n.File.Name, rex.Message), rex); } } if (!m_options.Dryrun) { db.RegisterRemoteVolume(n.File.Name, n.FileType, n.File.Size, RemoteVolumeState.Deleting); backend.Delete(n.File.Name, n.File.Size); } else m_result.AddDryrunMessage(string.Format("would delete file {0}", n.File.Name)); } catch (Exception ex) { m_result.AddError(string.Format("Failed to perform cleanup for extra file: {0}, message: {1}", n.File.Name, ex.Message), ex); if (ex is System.Threading.ThreadAbortException) throw; } foreach(var n in tp.MissingVolumes) { IDisposable newEntry = null; try { if (m_result.TaskControlRendevouz() == TaskControlState.Stop) { backend.WaitForComplete(db, null); return; } progress++; m_result.OperationProgressUpdater.UpdateProgress((float)progress / targetProgess); if (n.Type == RemoteVolumeType.Files) { var filesetId = db.GetFilesetIdFromRemotename(n.Name); var w = new FilesetVolumeWriter(m_options, DateTime.UtcNow); newEntry = w; w.SetRemoteFilename(n.Name); db.WriteFileset(w, null, filesetId); w.Close(); if (m_options.Dryrun) m_result.AddDryrunMessage(string.Format("would re-upload fileset {0}, with size {1}, previous size {2}", n.Name, Library.Utility.Utility.FormatSizeString(new System.IO.FileInfo(w.LocalFilename).Length), Library.Utility.Utility.FormatSizeString(n.Size))); else { db.UpdateRemoteVolume(w.RemoteFilename, RemoteVolumeState.Uploading, -1, null, null); backend.Put(w); } } else if (n.Type == RemoteVolumeType.Index) { var w = new IndexVolumeWriter(m_options); newEntry = w; w.SetRemoteFilename(n.Name); var h = System.Security.Cryptography.HashAlgorithm.Create(m_options.BlockHashAlgorithm); foreach(var blockvolume in db.GetBlockVolumesFromIndexName(n.Name)) { w.StartVolume(blockvolume.Name); var volumeid = db.GetRemoteVolumeID(blockvolume.Name); foreach(var b in db.GetBlocks(volumeid)) w.AddBlock(b.Hash, b.Size); w.FinishVolume(blockvolume.Hash, blockvolume.Size); if (m_options.IndexfilePolicy == Options.IndexFileStrategy.Full) foreach(var b in db.GetBlocklists(volumeid, m_options.Blocksize, hashsize)) { var bh = Convert.ToBase64String(h.ComputeHash(b.Item2, 0, b.Item3)); if (bh != b.Item1) throw new Exception(string.Format("Internal consistency check failed, generated index block has wrong hash, {0} vs {1}", bh, b.Item1)); w.WriteBlocklist(b.Item1, b.Item2, 0, b.Item3); } } w.Close(); if (m_options.Dryrun) m_result.AddDryrunMessage(string.Format("would re-upload index file {0}, with size {1}, previous size {2}", n.Name, Library.Utility.Utility.FormatSizeString(new System.IO.FileInfo(w.LocalFilename).Length), Library.Utility.Utility.FormatSizeString(n.Size))); else { db.UpdateRemoteVolume(w.RemoteFilename, RemoteVolumeState.Uploading, -1, null, null); backend.Put(w); } } else if (n.Type == RemoteVolumeType.Blocks) { var w = new BlockVolumeWriter(m_options); newEntry = w; w.SetRemoteFilename(n.Name); using(var mbl = db.CreateBlockList(n.Name)) { //First we grab all known blocks from local files foreach(var block in mbl.GetSourceFilesWithBlocks(m_options.Blocksize)) { var hash = block.Hash; var size = (int)block.Size; foreach(var source in block.Sources) { var file = source.File; var offset = source.Offset; try { if (System.IO.File.Exists(file)) using(var f = System.IO.File.OpenRead(file)) { f.Position = offset; if (size == Library.Utility.Utility.ForceStreamRead(f, buffer, size)) { var newhash = Convert.ToBase64String(blockhasher.ComputeHash(buffer, 0, size)); if (newhash == hash) { if (mbl.SetBlockRestored(hash, size)) w.AddBlock(hash, buffer, 0, size, Duplicati.Library.Interface.CompressionHint.Default); break; } } } } catch (Exception ex) { m_result.AddError(string.Format("Failed to access file: {0}", file), ex); } } } //Then we grab all remote volumes that have the missing blocks foreach(var vol in new AsyncDownloader(mbl.GetMissingBlockSources().ToList(), backend)) { try { using(var tmpfile = vol.TempFile) using(var f = new BlockVolumeReader(RestoreHandler.GetCompressionModule(vol.Name), tmpfile, m_options)) foreach(var b in f.Blocks) if (mbl.SetBlockRestored(b.Key, b.Value)) if (f.ReadBlock(b.Key, buffer) == b.Value) w.AddBlock(b.Key, buffer, 0, (int)b.Value, Duplicati.Library.Interface.CompressionHint.Default); } catch (Exception ex) { m_result.AddError(string.Format("Failed to access remote file: {0}", vol.Name), ex); } } // If we managed to recover all blocks, NICE! var missingBlocks = mbl.GetMissingBlocks().Count(); if (missingBlocks > 0) { //TODO: How do we handle this situation? m_result.AddMessage(string.Format("Repair cannot acquire {0} required blocks for volume {1}, which are required by the following filesets: ", missingBlocks, n.Name)); foreach(var f in mbl.GetFilesetsUsingMissingBlocks()) m_result.AddMessage(f.Name); if (!m_options.Dryrun) { m_result.AddMessage("This may be fixed by deleting the filesets and running repair again"); throw new Exception(string.Format("Repair not possible, missing {0} blocks!!!", missingBlocks)); } } else { if (m_options.Dryrun) m_result.AddDryrunMessage(string.Format("would re-upload block file {0}, with size {1}, previous size {2}", n.Name, Library.Utility.Utility.FormatSizeString(new System.IO.FileInfo(w.LocalFilename).Length), Library.Utility.Utility.FormatSizeString(n.Size))); else { db.UpdateRemoteVolume(w.RemoteFilename, RemoteVolumeState.Uploading, -1, null, null); backend.Put(w); } } } } } catch (Exception ex) { if (newEntry != null) try { newEntry.Dispose(); } catch { } finally { newEntry = null; } m_result.AddError(string.Format("Failed to perform cleanup for missing file: {0}, message: {1}", n.Name, ex.Message), ex); if (ex is System.Threading.ThreadAbortException) throw; } } } else { m_result.AddMessage("Destination and database are synchronized, not making any changes"); } m_result.OperationProgressUpdater.UpdateProgress(1); backend.WaitForComplete(db, null); db.WriteResults(); } }