Esempio n. 1
0
        private void DoBackupFile(BackupFile file, BackupedFiles backupedFiles)
        {
            try
            {
                if (cancelToken.IsCanceled ||
                    IsHidden(file.Info) ||
                    ExcludePath(file.Info.FullName))
                {
                    return;
                }

                string backupFileName;
                string fileHash = BackupUtils.GetHash(file.Info.FullName);

                if (cancelToken.IsCanceled)
                {
                    return;
                }
                if (backupedFiles.Add(fileHash, file.Info.Extension, out backupFileName))
                {
                    string destPath = Path.Combine(FilesDestFolderPath, backupFileName);

                    do
                    {
                        File.Copy(file.Info.FullName, destPath, true);
                    } while (fileHash != BackupUtils.GetHash(file.Info.FullName));

                    addedFiles.Add(destPath);
                }

                lock (addedToDbFoldersFiles)
                {
                    (DbFile? dbFile, DbFolderFile folderFile) = db.AddFile(file.Info.Name, fileHash, backupFileName, file.FolderId);

                    if (dbFile.HasValue)
                    {
                        addedToDbFiles.Add(dbFile.Value);
                    }
                    addedToDbFoldersFiles.Add(folderFile);
                }
            }
            catch { }
            finally
            {
                IncreaseProgressLocked();
            }
        }
Esempio n. 2
0
        public void LoadFiles()
        {
            Queue <BackupFolder> folderQueue = new Queue <BackupFolder>();

            folderQueue.Enqueue(new BackupFolder(Name, Folder));

            while (folderQueue.Count > 0)
            {
                BackupFolder currentFolder = folderQueue.Dequeue();
                if (IsHidden(currentFolder.Directory) ||
                    ExcludePath(currentFolder.Directory.FullName + "\\"))
                {
                    continue;
                }

                DbFolder dbFolder = db.AddFolder(currentFolder.Name, currentFolder.ParentId);
                addedToDbFolders.Add(dbFolder);

                IEnumerable <BackupFolder> folders;
                IEnumerable <BackupFile>   files;
                try
                {
                    switch (currentFolder.SubType)
                    {
                    case SubfolderType.No:
                        folders = new BackupFolder[0];
                        files   = new BackupFile[0];
                        break;

                    case SubfolderType.This:
                        folders = new BackupFolder[0];
                        files   = currentFolder.Directory.GetFiles().Select(f => new BackupFile(dbFolder.ID, f));
                        break;

                    case SubfolderType.All:
                        folders = currentFolder.Directory.GetDirectories()
                                  .Select(d => new BackupFolder(dbFolder.ID, d, SubfolderType.All));
                        files = currentFolder.Directory.GetFiles().Select(f => new BackupFile(dbFolder.ID, f));
                        break;

                    default:
                        throw new ArgumentOutOfRangeException(nameof(currentFolder.SubType), currentFolder.SubType, null);
                    }
                }
                catch
                {
                    folders = new BackupFolder[0];
                    files   = new BackupFile[0];
                }

                foreach (BackupFolder subFolder in folders)
                {
                    folderQueue.Enqueue(subFolder);
                }

                foreach (BackupFile file in files)
                {
                    allFiles.Add(file);
                }
            }
        }