/// <summary> /// Copy the contents of a stored file into a physical file /// </summary> /// <param name="_zfe">Entry information of file to extract</param> /// <param name="_filename">Name of file to store uncompressed data</param> /// <returns>True if success, false if not.</returns> /// <remarks>Unique compression methods are Store and Deflate</remarks> public bool ExtractFile(ZipFileEntry _zfe, string _filename) { // Make sure the parent directory exist string path = LongDirectory.GetDirectoryName(_filename); if (!LongDirectory.Exists(path)) { LongDirectory.CreateDirectory(path); } // Check it is directory. If so, do nothing if (LongDirectory.Exists(_filename)) { return(true); } Stream output = new FileStream(_filename, FileMode.Create, FileAccess.Write); bool result = ExtractFile(_zfe, output); if (result) { output.Close(); } LongFile.SetCreationTime(_filename, _zfe.ModifyTime); LongFile.SetLastWriteTime(_filename, _zfe.ModifyTime); return(result); }
public static State GetCurrentState(string path, Connection share) { if (share.isChanged == false && share.CurrentState.Files.Count > 0 && share.CurrentState.Folders.Count > 0) { return(share.CurrentState); } DateTime dt = FastDateTime.Now; State state = new State(); foreach (var f in LongDirectory.GetDirectories(path, "*.*", SearchOption.AllDirectories)) { string p = f.Replace(path, "") .Replace("/", "\\"); // for unix systems if (share.Allowed(p)) { state.Folders.Add(p); } } if (Global.isWindows == false) { foreach (var f in Directory.EnumerateFiles(path, "*.*", SearchOption.AllDirectories)) { var fi = new FileInfo(f); string fn = fi.FullName.Replace(path, "") .Replace("/", "\\"); // for unix systems if (share.Allowed(fi.FullName)) { state.Files.Add(new SyncFile { F = fn, D = fi.LastWriteTime, S = fi.Length }); } } } else { foreach (var f in FastDirectoryEnumerator.EnumerateFiles(path, "*.*", SearchOption.AllDirectories)) { string fn = f.Path.Replace(path, "") .Replace("/", "\\"); // for unix systems if (share.Allowed(f.Path)) { state.Files.Add(new SyncFile { F = fn, D = f.LastWriteTime, S = f.Size }); } } } _log.Info("GetCurrentState total secs = " + FastDateTime.Now.Subtract(dt).TotalSeconds); share.CurrentState = state; return(state); }
public static string[] GetFiles(string path, string searchPattern, System.IO.SearchOption searchOption) { if (TorpedoSync.Global.isWindows == false) { return(System.IO.Directory.GetFiles(path.Replace("\\", "/"), searchPattern, searchOption)); } searchPattern = searchPattern ?? "*"; var files = new List <string>(); var dirs = new List <string> { path }; if (searchOption == SearchOption.AllDirectories) { //Add all the subpaths dirs.AddRange(LongDirectory.GetDirectories(path, null, SearchOption.AllDirectories)); } foreach (var dir in dirs) { NativeMethods.WIN32_FIND_DATA findData; IntPtr findHandle = NativeMethods.FindFirstFile(System.IO.Path.Combine(GetWin32LongPath(dir), searchPattern), out findData); try { if (findHandle != new IntPtr(-1)) { do { if ((findData.dwFileAttributes & System.IO.FileAttributes.Directory) == 0) { string filename = System.IO.Path.Combine(dir, findData.cFileName); files.Add(GetCleanPath(filename)); } } while (NativeMethods.FindNextFile(findHandle, out findData)); NativeMethods.FindClose(findHandle); } } catch (Exception) { NativeMethods.FindClose(findHandle); throw; } } return(files.ToArray()); }
private static void docompressdirectory(ZipStorer zip, string dir, string prefix, bool recursive, Action <string> log) { if (recursive) { foreach (var d in LongDirectory.GetDirectories(dir)) { docompressdirectory(zip, d, prefix, recursive, log); } } foreach (string path in LongDirectory.GetFiles(dir)) { var fn = path.Replace(prefix, ""); zip.AddFile(ZipStorer.Compression.Deflate, path, fn, ""); log?.Invoke(fn); } }
public void Delete(Parameters parameters) { if (LongDirectory.Exists(Path)) { string[] paths = LongDirectory.GetFiles(Path); foreach (string filePath in paths) { if (parameters.Verbose) { Console.Out.WriteLine("{0}", filePath); } LongFile.Delete(filePath); } if (parameters.Recursive) { string[] subDirs = LongDirectory.GetDirectories(Path); foreach (string subDir in subDirs) { PFolder pFolder = new PFolder(subDir); pFolder.Delete(parameters); } } if (parameters.Verbose) { Console.Out.WriteLine("{0}", Path); } LongDirectory.Delete(Path); } else if (LongFile.Exists(Path)) { if (parameters.Verbose) { Console.Out.WriteLine("{0}", Path); } LongFile.Delete(Path); } if (Path == parameters.Path) { if (parameters.RequireEnterToExit) { Console.Out.WriteLine("Press enter to exit"); Console.In.ReadLine(); } } }
private static void DeleteDirectories(string[] directories) { foreach (string directory in directories) { string[] files = LongDirectory.GetFiles(directory, null, System.IO.SearchOption.TopDirectoryOnly); foreach (string file in files) { LongFile.Delete(file); } directories = LongDirectory.GetDirectories(directory, null, System.IO.SearchOption.TopDirectoryOnly); DeleteDirectories(directories); bool ok = NativeMethods.RemoveDirectory(GetWin32LongPath(directory)); if (!ok) { ThrowWin32Exception(); } } }
private void ProcessFile(SyncFile file) { string fn = _conn.Path + file.F; //_log.Info("create dir : " + LongDirectory.GetDirectoryName(fn)); LongDirectory.CreateDirectory(LongDirectory.GetDirectoryName(fn)); if (LongFile.Exists(fn)) { // kludge : for seconds resolution var fi = new LongFileInfo(fn); var d1 = fi.LastWriteTime.Ticks / _tickfilter; var d2 = file.D.Ticks / _tickfilter; if (d1 >= d2) // skip if already copied or newer { return; } } _connInfo.LastFileNameDownloaded = fn; fn += ".!torpedosync"; // FEATURE : resume semi downloaded file // remove old semi downloaded file LongFile.Delete(fn); if (TorpedoSync.Global.isWindows == false) { fn = fn.Replace("\\", "/"); } _downloading = true; if (downloadfile(file, fn, ClientCommands.Download)) { MoveExistingFileToArchive(file.F); // rename downloaded file LongFile.Move(fn, _conn.Path + file.F); LongFile.SetLastWriteTime(_conn.Path + file.F, file.D); } _downloading = false; }
private void AnalyseFolder(string folder1, string folder2) { string[] files1 = !LongDirectory.Exists(folder1) ? new string[] { } : LongDirectory.GetFiles(folder1).Select(f => LongFile.GetName(f)).ToArray(); string[] files2 = !LongDirectory.Exists(folder2) ? new string[] { } : LongDirectory.GetFiles(folder2).Select(f => LongFile.GetName(f)).ToArray(); foreach (string file1 in files1) { SyncItems.Add(new SyncItem(LongFile.Combine(folder1, file1), LongFile.Combine(folder2, file1), SyncItemType.File)); } foreach (string file2 in files2) { if (files1.FirstOrDefault(f => f == file2) == null) { SyncItems.Add(new SyncItem(LongFile.Combine(folder1, file2), LongFile.Combine(folder2, file2), SyncItemType.File)); } } string[] subs1 = !LongDirectory.Exists(folder1) ? new string[] { } : LongDirectory.GetDirectories(folder1).Select(f => LongDirectory.GetName(f)).ToArray(); string[] subs2 = !LongDirectory.Exists(folder2) ? new string[] { } : LongDirectory.GetDirectories(folder2).Select(f => LongDirectory.GetName(f)).ToArray(); foreach (string sub1 in subs1) { string fullSub1 = LongDirectory.Combine(folder1, sub1); string fullSub2 = LongDirectory.Combine(folder2, sub1); SyncItems.Add(new SyncItem(fullSub1, fullSub2, SyncItemType.Folder)); AnalyseFolder(fullSub1, fullSub2); } foreach (string sub2 in subs2) { if (subs1.FirstOrDefault(f => f == sub2) == null) { string fullSub1 = LongDirectory.Combine(folder1, sub2); string fullSub2 = LongDirectory.Combine(folder2, sub2); SyncItems.Add(new SyncItem(fullSub1, fullSub2, SyncItemType.Folder)); AnalyseFolder(fullSub1, fullSub2); } } }
public void DoAction() { try { if (ItemType == SyncItemType.Folder) { SyncedFile past1 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path1); SyncedFile past2 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path2); if (Action == SyncActions.CopyFrom1To2) { if (!LongDirectory.Exists(Path2)) { LongDirectory.CreateDirectory(Path2); } if (past1 == null) { MainDbContext.DB.SyncedFiles.Add(new SyncedFile() { LastModified = DateTime.MinValue, Path = Path1 }); } if (past2 == null) { MainDbContext.DB.SyncedFiles.Add(new SyncedFile() { LastModified = DateTime.MinValue, Path = Path2 }); } Status = SyncItemStatus.ActionOK; } else if (Action == SyncActions.CopyFrom2To1) { if (!LongDirectory.Exists(Path1)) { LongDirectory.CreateDirectory(Path1); } if (past1 == null) { MainDbContext.DB.SyncedFiles.Add(new SyncedFile() { LastModified = DateTime.MinValue, Path = Path1 }); } if (past2 == null) { MainDbContext.DB.SyncedFiles.Add(new SyncedFile() { LastModified = DateTime.MinValue, Path = Path2 }); } Status = SyncItemStatus.ActionOK; } else if (Action == SyncActions.Delete1 || Action == SyncActions.Delete2 || Action == SyncActions.DeleteBoth) { if (LongDirectory.Exists(Path1)) { LongDirectory.Delete(Path1, true); } if (LongDirectory.Exists(Path2)) { LongDirectory.Delete(Path2, true); } if (past1 != null) { MainDbContext.DB.SyncedFiles.Remove(past1); } if (past2 != null) { MainDbContext.DB.SyncedFiles.Remove(past2); } Status = SyncItemStatus.ActionOK; } } else if (ItemType == SyncItemType.File) { SyncedFile past1 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path1); SyncedFile past2 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path2); if (Action == SyncActions.CopyFrom1To2) { LongFile.Copy(Path1, Path2); DateTime lastModified = LongFile.GetLastWriteTime(Path1); if (past1 == null) { past1 = new SyncedFile() { LastModified = lastModified, Path = Path1 }; MainDbContext.DB.SyncedFiles.Add(past1); } else if (!lastModified.Equals(past1.LastModified)) { past1.LastModified = lastModified; } if (past2 == null) { past2 = new SyncedFile() { LastModified = lastModified, Path = Path2 }; MainDbContext.DB.SyncedFiles.Add(past2); } else if (!lastModified.Equals(past2.LastModified)) { past2.LastModified = lastModified; } Status = SyncItemStatus.ActionOK; } else if (Action == SyncActions.CopyFrom2To1) { LongFile.Copy(Path2, Path1); DateTime lastModified = LongFile.GetLastWriteTime(Path2); if (past1 == null) { past1 = new SyncedFile() { LastModified = lastModified, Path = Path1 }; MainDbContext.DB.SyncedFiles.Add(past1); } else if (!lastModified.Equals(past1.LastModified)) { past1.LastModified = lastModified; } if (past2 == null) { past2 = new SyncedFile() { LastModified = lastModified, Path = Path2 }; MainDbContext.DB.SyncedFiles.Add(past2); } else if (!lastModified.Equals(past2.LastModified)) { past2.LastModified = lastModified; } Status = SyncItemStatus.ActionOK; } else if (Action == SyncActions.Delete1) { if (LongFile.Exists(Path1)) { LongFile.Delete(Path1); } if (past1 != null) { MainDbContext.DB.SyncedFiles.Remove(past1); } if (past2 != null) { MainDbContext.DB.SyncedFiles.Remove(past2); } Status = SyncItemStatus.ActionOK; } else if (Action == SyncActions.Delete2) { if (LongFile.Exists(Path2)) { LongFile.Delete(Path2); } if (past1 != null) { MainDbContext.DB.SyncedFiles.Remove(past1); } if (past2 != null) { MainDbContext.DB.SyncedFiles.Remove(past2); } Status = SyncItemStatus.ActionOK; } else if (Action == SyncActions.DeleteBoth) { if (LongFile.Exists(Path1)) { LongFile.Delete(Path1); } if (LongFile.Exists(Path2)) { LongFile.Delete(Path2); } if (past1 != null) { MainDbContext.DB.SyncedFiles.Remove(past1); } if (past2 != null) { MainDbContext.DB.SyncedFiles.Remove(past2); } Status = SyncItemStatus.ActionOK; } } MainDbContext.DB.SaveChanges(); } catch (Exception ex) { //TODO What to do when a copy/delete doesnt work? } }
private bool downloadfile(SyncFile file, string saveto, Func <Connection, SyncFile, long, int, DFile> func) { long left = file.S; int retry = 0; int mb = Global.DownloadBlockSizeMB * Global.MB; //Stopwatch sw = new Stopwatch(); //sw.Start(); while (left > 0) { long len = left; long start = file.S - left; if (len > mb) { len = mb; } //sw.Reset(); DFile df = func(_conn, file, start, (int)len); //_connInfo.Mbs = (len / sw.ElapsedTicks) / (1000*TimeSpan.TicksPerSecond) ; if (df == null) { retry++; Thread.Sleep(new Random((int)FastDateTime.Now.Ticks).Next(2000) + 500); if (retry > 10) { _log.Info(" null "); _que.Enqueue(file); //if (LongFile.Exists(saveto)) LongFile.Delete(saveto); return(false); } } else if (df.err == DownloadError.OK) { retry = 0; string ifn = saveto; if (TorpedoSync.Global.isWindows == false) { ifn = saveto.Replace("\\", "/"); } _log.Info("len = " + len + " , " + saveto.Replace(".!torpedosync", "")); left -= len; LongDirectory.CreateDirectory(LongDirectory.GetDirectoryName(ifn)); // save to disk var fs = new FileStream(ifn, FileMode.OpenOrCreate); fs.Seek(0L, SeekOrigin.End); fs.Write(df.data, 0, df.data.Length); fs.Close(); if (left == 0) { var fi = new LongFileInfo(saveto); if (fi.Length != file.S) { // FEATURE : file length don't match _log.Info("file length don't match."); return(false); } } } else if (df.err == DownloadError.OLDER || df.err == DownloadError.LOCKED) { _ErrorQue.Enqueue(file); _connInfo.LastFileNameDownloaded = ""; _log.Info("Locked/Older : " + saveto); return(false); } else if (df.err == DownloadError.NOTFOUND) { _log.Info("Not Found : " + saveto); _connInfo.LastFileNameDownloaded = ""; _ErrorQue.Enqueue(file); LongFile.Delete(saveto); return(false); } } return(true); }
private void DownloadAsZipFile() { SyncFile file = null; if (Global.BatchZip) { int size = 0; int mb = Global.BatchZipFilesUnderMB * Global.MB; List <SyncFile> ziplist = new List <SyncFile>(); while (_que.Count > 10) { if (_que.TryPeek(out file)) { if (file.S + size < mb && file.S < Global.SmallFileSize) // small files { _que.TryDequeue(out file); ziplist.Add(file); } else { break; } } } if (ziplist.Count > 0) { try { _downloading = true; var sf = ClientCommands.CreateZip(_conn, ziplist); if (sf != null) { string path = _conn.Path + ".ts" + _S + "Temp" + _S; LongDirectory.CreateDirectory(path); if (downloadfile(sf, path + sf.F, ClientCommands.DownloadZip)) { string zfn = path + sf.F; string fn = sf.F; if (TorpedoSync.Global.isWindows == false) { zfn = zfn.Replace("\\", "/"); } var zf = ZipStorer.Open(zfn, FileAccess.Read); foreach (var z in zf.ReadCentralDir()) { if (TorpedoSync.Global.isWindows) { fn = z.FilenameInZip.Replace("/", "\\"); } else { fn = z.FilenameInZip; } MoveExistingFileToArchive(fn); LongDirectory.CreateDirectory(LongDirectory.GetDirectoryName(_conn.Path + fn)); try { _log.Info("unzip : " + fn); //_log.Debug("unzip : " + fn); using (var fs = new FileStream(_conn.Path + fn, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)) { _connInfo.LastFileNameDownloaded = fn; zf.ExtractFile(z, fs); fs.Close(); } var dt = z.ModifyTime; if (z.Comment != "") { //_log.Info($"date {z.Comment}"); if (DateTime.TryParse(z.Comment, out dt) == false) { dt = z.ModifyTime; } } var dtt = dt; if (TorpedoSync.Global.isWindows) { dtt = dt.ToUniversalTime(); } LongFile.SetLastWriteTime(_conn.Path + fn, dtt); } catch (Exception ex) { _log.Error(ex); } } zf.Close(); ClientCommands.DeleteZip(_conn, sf); _log.Info("Decompress zip done : " + sf.F); LongFile.Delete(zfn); } } _downloading = false; } catch (Exception ex) { _log.Error(ex); } } } }
internal void QueueDelta(Delta d) { string archivefolder = _conn.Path + ".ts" + _S + "old" + _S; Directory.CreateDirectory(archivefolder); if (d != null) { // empty old error queue _ErrorQue = new ConcurrentQueue <SyncFile>(); d.FilesDeleted.ForEach(x => { try { if (LongFile.Exists(_conn.Path + x)) { _log.Info("Deleting file : " + _conn.Path + x); string fn = archivefolder + x; LongFile.Move(_conn.Path + x, fn); } } catch (Exception ex) { _log.Error(ex); } }); d.FoldersDeleted.ForEach(x => { _log.Info("Deleting folder : " + _conn.Path + x); if (LongDirectory.Exists(_conn.Path + x)) { try { LongDirectory.Move(_conn.Path + x, archivefolder + x); } catch { } try { var f = LongDirectory.GetFiles(_conn.Path + x, "*.*", SearchOption.AllDirectories); if (f.Length == 0) { LongDirectory.Delete(_conn.Path + x, true); } } catch (Exception ex) { _log.Error(ex); } } }); d.FilesAdded.ForEach(x => { _que.Enqueue(x); }); d.FilesChanged.ForEach(x => { _que.Enqueue(x); }); _log.Info("delfolders = " + d.FoldersDeleted.Count); _log.Info("delfiles = " + d.FilesDeleted.Count); _log.Info("files added = " + d.FilesAdded.Count); _log.Info("files changed = " + d.FilesChanged.Count); _log.Info("que count = " + _que.Count); SaveQueue(); } }
public void Backup() { bool backupRequired = false; try { DateTime currentFileTimestamp = LongFile.GetLastWriteTime(Path).ToLocalTime(); BackupFile backupFile = BackupDbContext.DB.BackupFiles .Where(f => f.Path == Path) .OrderByDescending(f => f.BackupTimestamp) .FirstOrDefault(f => true); if (backupFile == null) { backupRequired = true; } else if (backupFile.LastModified.CompareTo(currentFileTimestamp) != 0) { backupRequired = true; } else if (backupFile.Size != LongFile.GetFileSize(Path)) { backupRequired = true; } if (backupRequired) { backupFile = new BackupFile { Path = Path, BackupFileType = BackupFileType.File, LastModified = currentFileTimestamp, Size = LongFile.GetFileSize(Path), BackupTimestamp = DateTime.Now, BackupLocation = GetBackupLocation(), Parent = LongFile.GetParent(Path), Name = LongFile.GetName(Path), }; string destPath = LongFile.Combine(BackupDbContext.Destination, LongFile.Combine("Files", backupFile.BackupLocation)); string destFolder = LongFile.GetParent(destPath); if (!LongDirectory.Exists(destFolder)) { LongDirectory.CreateDirectory(destFolder); } LongFile.Copy(Path, destPath, true); LongFile.SetAttributes(destPath, LongFile.GetAttributes(destPath) & ~System.IO.FileAttributes.ReadOnly & ~System.IO.FileAttributes.Hidden); BackupDbContext.DB.BackupFiles.Add(backupFile); BackupDbContext.DB.SaveChanges(); if (FileBackupFinished != null) { FileBackupFinished(this, new FileEventArgs() { Path = Path, Cancelled = false, Success = true }); } } } catch (Exception ex) { } }
public SyncActions GetAction() { if (ItemType == SyncItemType.File) { bool exists1 = LongFile.Exists(Path1); bool exists2 = LongFile.Exists(Path2); LastModified1 = exists1 ? LongFile.GetLastWriteTime(Path1) : DateTime.MinValue; LastModified2 = exists2 ? LongFile.GetLastWriteTime(Path2) : DateTime.MinValue; SyncedFile past1 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path1); SyncedFile past2 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path2); if (!exists1 && !exists2) { return(SyncActions.None); } else if (exists1 && !exists2) { if (past1 != null && past2 != null) { // File 2 has been deleted Status = SyncItemStatus.ActionPending; return(SyncActions.Delete1); } else { // File 1 is new Status = SyncItemStatus.ActionPending; return(SyncActions.CopyFrom1To2); } } else if (!exists1 && exists2) { if (past1 != null && past2 != null) { // File 1 has been deleted Status = SyncItemStatus.ActionPending; return(SyncActions.Delete2); } else { // File 2 is new Status = SyncItemStatus.ActionPending; return(SyncActions.CopyFrom2To1); } } else if (exists1 && exists2) { int comp = LastModified1.CompareTo(LastModified2); int newest = comp > 0 ? 1 : comp < 0 ? 2 : 0; bool changed1 = past1 == null || !LastModified1.Equals(past1.LastModified); bool changed2 = past2 == null || !LastModified2.Equals(past2.LastModified); if (changed1 && changed2) { if (newest == 1) { return(SyncActions.CopyFrom1To2); } if (newest == 2) { return(SyncActions.CopyFrom2To1); } return(SyncActions.None); } else if (changed1 && !changed2) { Status = SyncItemStatus.ActionPending; return(SyncActions.CopyFrom1To2); } else if (!changed1 && changed2) { Status = SyncItemStatus.ActionPending; return(SyncActions.CopyFrom2To1); } else if (!changed1 && !changed2) { return(SyncActions.None); } } } else if (ItemType == SyncItemType.Folder) { bool exists1 = LongDirectory.Exists(Path1); bool exists2 = LongDirectory.Exists(Path2); SyncedFile past1 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path1); SyncedFile past2 = MainDbContext.DB.SyncedFiles.FirstOrDefault(f => f.Path == Path2); if (!exists1 && !exists2) { if (past1 != null || past2 != null) { return(SyncActions.None); } else { return(SyncActions.None); } } else if (exists1 && exists2) { return(SyncActions.None); } else if (exists1 && !exists2) { if (past2 != null) { Status = SyncItemStatus.ActionPending; return(SyncActions.Delete1); } else { Status = SyncItemStatus.ActionPending; return(SyncActions.CopyFrom1To2); } } else if (!exists1 && exists2) { if (past1 != null) { Status = SyncItemStatus.ActionPending; return(SyncActions.Delete2); } else { Status = SyncItemStatus.ActionPending; return(SyncActions.CopyFrom2To1); } } } return(SyncActions.None); }
public void Backup() { if (FolderBackupStarted != null) { FolderBackupStarted(this, new FolderEventArgs() { Path = Path }); } try { if (Excludes == null) { Excludes = MainDbContext.DB.ExcludePaths.ToArray(); } foreach (string filename in LongDirectory.GetFiles(Path).OrderBy(f => f)) { if (ExcludePath(filename)) { continue; } FFile ffile = new FFile(filename); ffile.Excludes = Excludes; ffile.FileBackupStarted += FileBackupStarted; ffile.FileBackupFinished += FileBackupFinished; ffile.Backup(); if (BackgroundWorker != null && BackgroundWorker.CancellationPending) { return; } } foreach (string folder in LongDirectory.GetDirectories(Path).OrderBy(f => f)) { if (ExcludePath(folder)) { continue; } FFolder ffolder = new FFolder(folder); ffolder.Excludes = Excludes; ffolder.BackgroundWorker = BackgroundWorker; ffolder.FolderBackupStarted += new FolderBackupStartedHandler(FolderBackupStarted); ffolder.FolderBackupFinished += new FFolder.FolderBackupFinishedHandler(FolderBackupFinished); ffolder.FileBackupStarted += new FFile.FileBackupStartedHandler(FileBackupStarted); ffolder.FileBackupFinished += new FFile.FileBackupFinishedHandler(FileBackupFinished); ffolder.Backup(); if (BackgroundWorker != null && BackgroundWorker.CancellationPending) { return; } } } catch (Exception ex) { } if (FolderBackupFinished != null) { FolderBackupFinished(this, new FolderEventArgs() { Path = Path, Success = true }); } }
public void Copy(Parameters parameters) { if (!LongDirectory.Exists(DestPath)) { LongDirectory.CreateDirectory(DestPath); } if (parameters.Verbose) { Console.Out.WriteLine("{0}", SourcePath); } string[] sourceFilePaths = LongDirectory.GetFiles(SourcePath); string[] destFilePaths = LongDirectory.GetFiles(DestPath); foreach (string sourceFilePath in sourceFilePaths) { string copyFileComment = string.Empty; bool copyFile = false; string sourceFilename = LongFile.GetName(sourceFilePath); string destFilePath = LongFile.Combine(DestPath, sourceFilename); if (destFilePaths.FirstOrDefault(f => f.Equals(destFilePath, StringComparison.CurrentCultureIgnoreCase)) == null) { copyFile = true; copyFileComment = "new "; } else { DateTime sourceModified = LongFile.GetLastWriteTime(sourceFilePath); DateTime destModified = LongFile.GetLastWriteTime(destFilePath); int modComp = sourceModified.CompareTo(destModified); if (modComp > 0) { copyFile = true; copyFileComment = "newer "; } else if (modComp < 0) { copyFile = true; copyFileComment = "older "; } else { copyFileComment = "same "; } } if (copyFile) { if (parameters.Verbose) { Console.Out.WriteLine(" {0} : {1} ", copyFileComment, sourceFilename); } try { LongFile.Copy(sourceFilePath, destFilePath, true); } catch (Exception ex) { Console.Out.WriteLine("{0}", ex.Message); } } } if (parameters.Recursive) { string[] sourceDirs = LongDirectory.GetDirectories(SourcePath); foreach (string sourceDir in sourceDirs) { string sourceName = LongFile.GetName(sourceDir); string destDir = LongFile.Combine(DestPath, sourceName); if (!LongDirectory.Exists(destDir)) { LongDirectory.CreateDirectory(destDir); } PFolder pFolder = new PFolder(sourceDir, destDir); pFolder.Copy(parameters); } } if (SourcePath == parameters.SourceDirectory) { if (parameters.RequireEnterToExit) { Console.Out.WriteLine("Press enter to exit"); Console.In.ReadLine(); } } }
private static void CreateDir(string filename) { LongDirectory.CreateDirectory(LongDirectory.GetDirectoryName(filename)); }