private List <FtpResult> GetSubDirectoriesToTransfer(string sourceFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, string[] dirListing) { var dirsToTransfer = new List <FtpResult>(); foreach (var sourceFile in dirListing) { // calculate the local path var relativePath = sourceFile.Replace(sourceFolder, "").EnsurePostfix("/"); var remoteFile = remoteFolder + relativePath; // create the result object var result = new FtpResult { Type = FtpFileSystemObjectType.Directory, Size = 0, Name = sourceFile.GetFtpDirectoryName(), RemotePath = remoteFile, LocalPath = sourceFile, IsDownload = false, }; // record the folder results.Add(result); // skip transfering the file if it does not pass all the rules if (!FilePassesRules(result, rules, true)) { continue; } dirsToTransfer.Add(result); } return(dirsToTransfer); }
/// <summary> /// Check if the local file can be deleted, based on the DownloadDirectoryDeleteExcluded property /// </summary> private bool CanDeleteLocalFile(List <FtpRule> rules, string existingLocalFile) { // if we should not delete excluded files if (!DownloadDirectoryDeleteExcluded && !rules.IsBlank()) { // create the result object to validate rules to ensure that file from excluded // directories are not deleted on the local filesystem var result = new FtpResult() { Type = FtpFileSystemObjectType.File, Size = 0, Name = Path.GetFileName(existingLocalFile), LocalPath = existingLocalFile, IsDownload = false, }; // check if the file passes the rules if (FilePassesRules(result, rules, true)) { // delete the file because it is included return(true); } else { // do not delete the file because it is excluded return(false); } } // always delete the file whether its included or excluded by the rules return(true); }
/// <summary> /// Get a list of all the sub directories that need to be created within the main directory /// </summary> private List <FtpResult> GetSubDirectoriesToUpload(string localFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, string[] dirListing) { var dirsToUpload = new List <FtpResult>(); foreach (var localFile in dirListing) { // calculate the local path var relativePath = localFile.Replace(localFolder, "").EnsurePostfix(Path.DirectorySeparatorChar.ToString()); var remoteFile = remoteFolder + relativePath.Replace('\\', '/'); // create the result object var result = new FtpResult() { Type = FtpFileSystemObjectType.Directory, Size = 0, Name = Path.GetDirectoryName(localFile), RemotePath = remoteFile, LocalPath = localFile, IsDownload = false, }; // record the folder results.Add(result); // skip uploading the file if it does not pass all the rules if (!FilePassesRules(result, rules, true)) { continue; } dirsToUpload.Add(result); } return(dirsToUpload); }
/// <summary> /// Check if the remote file can be deleted, based on the UploadDirectoryDeleteExcluded property /// </summary> private bool CanDeleteRemoteFile(List <FtpRule> rules, FtpListItem existingServerFile) { // if we should not delete excluded files if (!UploadDirectoryDeleteExcluded && !rules.IsBlank()) { // create the result object to validate rules to ensure that file from excluded // directories are not deleted on the FTP remote server var result = new FtpResult() { Type = existingServerFile.Type, Size = existingServerFile.Size, Name = Path.GetFileName(existingServerFile.FullName), RemotePath = existingServerFile.FullName, IsDownload = false, }; // check if the file passes the rules if (FilePassesRules(result, rules, false)) { // delete the file because it is included return(true); } else { // do not delete the file because it is excluded return(false); } } // always delete the file whether its included or excluded by the rules return(true); }
/// <summary> /// Get a list of all the files and folders that need to be downloaded /// </summary> private List <FtpResult> GetFilesToDownload(string localFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, FtpListItem[] listing, Dictionary <string, bool> shouldExist) { var toDownload = new List <FtpResult>(); foreach (var remoteFile in listing) { // calculate the local path var relativePath = remoteFile.FullName.Replace(remoteFolder, "").Replace('/', Path.DirectorySeparatorChar); var localFile = localFolder.CombineLocalPath(relativePath); // create the result object var result = new FtpResult() { Type = remoteFile.Type, Size = remoteFile.Size, Name = remoteFile.Name, RemotePath = remoteFile.FullName, LocalPath = localFile, IsDownload = true, }; // only files and folders are processed if (remoteFile.Type == FtpFileSystemObjectType.File || remoteFile.Type == FtpFileSystemObjectType.Directory) { // record the file results.Add(result); // if the file passes all rules if (rules != null && rules.Count > 0) { var passes = FtpRule.IsAllAllowed(rules, remoteFile); if (!passes) { LogStatus(FtpTraceLevel.Info, "Skipped file due to rule: " + result.RemotePath); // mark that the file was skipped due to a rule result.IsSkipped = true; result.IsSkippedByRule = true; // skip downloading the file continue; } } // record that this file/folder should exist shouldExist.Add(localFile.ToLower(), true); // only files are processed toDownload.Add(result); } } return(toDownload); }
/// <summary> /// Get a list of all the files and folders that need to be downloaded /// </summary> private List <FtpResult> GetFilesToDownload(string localFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, FtpListItem[] listing, Dictionary <string, bool> shouldExist) { var toDownload = new List <FtpResult>(); foreach (var remoteFile in listing) { // calculate the local path var relativePath = remoteFile.FullName.EnsurePrefix("/").RemovePrefix(remoteFolder).Replace('/', Path.DirectorySeparatorChar); var localFile = localFolder.CombineLocalPath(relativePath); // create the result object var result = new FtpResult() { Type = remoteFile.Type, Size = remoteFile.Size, Name = remoteFile.Name, RemotePath = remoteFile.FullName, LocalPath = localFile, IsDownload = true, }; // only files and folders are processed if (remoteFile.Type == FtpFileSystemObjectType.File || remoteFile.Type == FtpFileSystemObjectType.Directory) { // record the file results.Add(result); // skip downloading the file if it does not pass all the rules if (!FilePassesRules(result, rules, false, remoteFile)) { // record that this file/folder should exist // if we don't want to delete excluded files if (!DownloadDirectoryDeleteExcluded) { shouldExist.Add(localFile.ToLower(), true); } continue; } // record that this file/folder should exist shouldExist.Add(localFile.ToLower(), true); // only files are processed toDownload.Add(result); } } return(toDownload); }
/// <summary> /// Get a list of all the files that need to be uploaded within the main directory /// </summary> private List <FtpResult> GetFilesToUpload(string localFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, Dictionary <string, bool> shouldExist, string[] fileListing) { var filesToUpload = new List <FtpResult>(); foreach (var localFile in fileListing) { // calculate the local path var relativePath = localFile.Replace(localFolder, "").Replace(Path.DirectorySeparatorChar, '/'); var remoteFile = remoteFolder + relativePath.Replace('\\', '/'); // create the result object var result = new FtpResult() { Type = FtpFileSystemObjectType.File, Size = new FileInfo(localFile).Length, Name = Path.GetFileName(localFile), RemotePath = remoteFile, LocalPath = localFile }; // record the file results.Add(result); // if the file passes all rules if (rules != null && rules.Count > 0) { var passes = FtpRule.IsAllAllowed(rules, result.ToListItem(true)); if (!passes) { LogStatus(FtpTraceLevel.Info, "Skipped file due to rule: " + result.LocalPath); // mark that the file was skipped due to a rule result.IsSkipped = true; result.IsSkippedByRule = true; // skip uploading the file continue; } } // record that this file should exist shouldExist.Add(remoteFile.ToLower(), true); // absorb errors filesToUpload.Add(result); } return(filesToUpload); }
/// <summary> /// Get a list of all the sub directories that need to be created within the main directory /// </summary> private List <FtpResult> GetSubDirectoriesToUpload(string localFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, string[] dirListing) { var dirsToUpload = new List <FtpResult>(); foreach (var localFile in dirListing) { // calculate the local path var relativePath = localFile.Replace(localFolder, "").EnsurePostfix(Path.DirectorySeparatorChar.ToString()); var remoteFile = remoteFolder + relativePath.Replace('\\', '/'); // create the result object var result = new FtpResult() { Type = FtpFileSystemObjectType.Directory, Size = 0, Name = Path.GetDirectoryName(localFile), RemotePath = remoteFile, LocalPath = localFile, IsDownload = false, }; // record the folder results.Add(result); // if the folder passes all rules if (rules != null && rules.Count > 0) { var passes = FtpRule.IsAllAllowed(rules, result.ToListItem(true)); if (!passes) { // mark that the file was skipped due to a rule result.IsSkipped = true; result.IsSkippedByRule = true; // skip uploading the file continue; } } // absorb errors dirsToUpload.Add(result); } return(dirsToUpload); }
/// <summary> /// Get a list of all the files that need to be uploaded within the main directory /// </summary> private List <FtpResult> GetFilesToUpload(string localFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, Dictionary <string, bool> shouldExist, string[] fileListing) { var filesToUpload = new List <FtpResult>(); foreach (var localFile in fileListing) { // calculate the local path var relativePath = localFile.Replace(localFolder, "").Replace(Path.DirectorySeparatorChar, '/'); var remoteFile = remoteFolder + relativePath.Replace('\\', '/'); // create the result object var result = new FtpResult() { Type = FtpFileSystemObjectType.File, Size = new FileInfo(localFile).Length, Name = Path.GetFileName(localFile), RemotePath = remoteFile, LocalPath = localFile }; // record the file results.Add(result); // skip uploading the file if it does not pass all the rules if (!FilePassesRules(result, rules, true)) { // record that this file/folder should exist // if we don't want to delete excluded files if (!UploadDirectoryDeleteExcluded) { shouldExist.Add(remoteFile.ToLower(), true); } continue; } // record that this file should exist shouldExist.Add(remoteFile.ToLower(), true); // absorb errors filesToUpload.Add(result); } return(filesToUpload); }
/// <summary> /// Returns true if the file passes all the rules /// </summary> private bool FilePassesRules(FtpResult result, List <FtpRule> rules, bool useLocalPath, FtpListItem item = null) { if (rules != null && rules.Count > 0) { var passes = FtpRule.IsAllAllowed(rules, item ?? result.ToListItem(useLocalPath)); if (!passes) { LogStatus(FtpTraceLevel.Info, "Skipped file due to rule: " + (useLocalPath ? result.LocalPath : result.RemotePath)); // mark that the file was skipped due to a rule result.IsSkipped = true; result.IsSkippedByRule = true; // skip uploading the file return(false); } } return(true); }
/// <summary> /// Check if the file is cleared to be uploaded, taking its existance/filesize and existsMode options into account. /// </summary> private bool CanUploadFile(FtpResult result, FtpListItem[] remoteListing, FtpRemoteExists existsMode, out FtpRemoteExists existsModeToUse) { // check if the file already exists on the server existsModeToUse = existsMode; var fileExists = FtpExtensions.FileExistsInListing(remoteListing, result.RemotePath); // if we want to skip uploaded files and the file already exists, mark its skipped if (existsMode == FtpRemoteExists.Skip && fileExists) { LogStatus(FtpTraceLevel.Info, "Skipped file that already exists: " + result.LocalPath); result.IsSuccess = true; result.IsSkipped = true; return(false); } // in any mode if the file does not exist, mark that exists check is not required if (!fileExists) { existsModeToUse = existsMode == FtpRemoteExists.Append ? FtpRemoteExists.AppendNoCheck : FtpRemoteExists.NoCheck; } return(true); }
private List <FtpResult> GetFilesToTransfer(string sourceFolder, string remoteFolder, List <FtpRule> rules, List <FtpResult> results, Dictionary <string, bool> shouldExist, string[] fileListing) { var filesToTransfer = new List <FtpResult>(); foreach (var sourceFile in fileListing) { // calculate the local path var relativePath = sourceFile.Replace(sourceFolder, ""); var remoteFile = remoteFolder + relativePath; // create the result object var result = new FtpResult { Type = FtpFileSystemObjectType.File, Size = GetFileSize(sourceFile), Name = sourceFile.GetFtpFileName(), RemotePath = remoteFile, LocalPath = sourceFile }; // record the file results.Add(result); // skip transfering the file if it does not pass all the rules if (!FilePassesRules(result, rules, true)) { continue; } // record that this file should exist shouldExist.Add(remoteFile.ToLowerInvariant(), true); // absorb errors filesToTransfer.Add(result); } return(filesToTransfer); }
/// <summary> /// Uploads the specified directory onto the server. /// In Mirror mode, we will upload missing files, and delete any extra files from the server that are not present on disk. This is very useful when publishing an exact copy of a local folder onto an FTP server. /// In Update mode, we will only upload missing files and preserve any extra files on the server. This is useful when you want to simply upload missing files to a server. /// Only uploads the files and folders matching all the rules provided, if any. /// All exceptions during uploading are caught, and the exception is stored in the related FtpResult object. /// </summary> /// <param name="localFolder">The full path of the local folder on disk that you want to upload. If it does not exist, an empty result list is returned.</param> /// <param name="remoteFolder">The full path of the remote FTP folder to upload into. It is created if it does not exist.</param> /// <param name="mode">Mirror or Update mode, as explained above</param> /// <param name="existsMode">If the file exists on disk, should we skip it, resume the upload or restart the upload?</param> /// <param name="verifyOptions">Sets if checksum verification is required for a successful upload and what to do if it fails verification (See Remarks)</param> /// <param name="rules">Only files and folders that pass all these rules are downloaded, and the files that don't pass are skipped. In the Mirror mode, the files that fail the rules are also deleted from the local folder.</param> /// <param name="progress">Provide a callback to track upload progress.</param> /// <remarks> /// If verification is enabled (All options other than <see cref="FtpVerify.None"/>) the hash will be checked against the server. If the server does not support /// any hash algorithm, then verification is ignored. If only <see cref="FtpVerify.OnlyChecksum"/> is set then the return of this method depends on both a successful /// upload & verification. Additionally, if any verify option is set and a retry is attempted then overwrite will automatically switch to true for subsequent attempts. /// If <see cref="FtpVerify.Throw"/> is set and <see cref="FtpError.Throw"/> is <i>not set</i>, then individual verification errors will not cause an exception /// to propagate from this method. /// </remarks> /// <returns> /// Returns a listing of all the remote files, indicating if they were downloaded, skipped or overwritten. /// Returns a blank list if nothing was transfered. Never returns null. /// </returns> public List <FtpResult> UploadDirectory(string localFolder, string remoteFolder, FtpFolderSyncMode mode = FtpFolderSyncMode.Update, FtpRemoteExists existsMode = FtpRemoteExists.Skip, FtpVerify verifyOptions = FtpVerify.None, List <FtpRule> rules = null, Action <FtpProgress> progress = null) { if (localFolder.IsBlank()) { throw new ArgumentException("Required parameter is null or blank.", "localFolder"); } if (remoteFolder.IsBlank()) { throw new ArgumentException("Required parameter is null or blank.", "remoteFolder"); } LogFunc("UploadDirectory", new object[] { localFolder, remoteFolder, mode, existsMode, verifyOptions, (rules.IsBlank() ? null : rules.Count + " rules") }); var results = new List <FtpResult>(); // ensure the local path ends with slash localFolder = localFolder.EnsurePostfix(Path.DirectorySeparatorChar.ToString()); // cleanup the remote path remoteFolder = remoteFolder.GetFtpPath().EnsurePostfix("/"); // if the dir does not exist, fail fast if (!Directory.Exists(localFolder)) { return(results); } // ensure the remote dir exists if (!DirectoryExists(remoteFolder)) { CreateDirectory(remoteFolder); } // collect paths of the files that should exist (lowercase for CI checks) var shouldExist = new Dictionary <string, bool>(); // get all the folders in the local directory var dirListing = Directory.GetDirectories(localFolder, "*.*", SearchOption.AllDirectories); // loop thru each folder and ensure it exists foreach (var localFile in dirListing) { // calculate the local path var relativePath = localFile.Replace(localFolder, "").EnsurePostfix(Path.DirectorySeparatorChar.ToString()); var remoteFile = remoteFolder + relativePath.Replace('\\', '/'); // create the result object var result = new FtpResult() { Type = FtpFileSystemObjectType.Directory, Size = 0, Name = Path.GetDirectoryName(localFile), RemotePath = remoteFile, LocalPath = localFile }; // record the folder results.Add(result); // if the folder passes all rules if (rules != null && rules.Count > 0) { var passes = FtpRule.IsAllAllowed(rules, result.ToListItem(true)); if (!passes) { // mark that the file was skipped due to a rule result.IsSkipped = true; result.IsSkippedByRule = true; // skip uploading the file continue; } } // absorb errors try { // create directory on the server // to ensure we upload the blank remote dirs as well if (!DirectoryExists(remoteFile)) { CreateDirectory(remoteFile); result.IsSuccess = true; result.IsSkipped = false; } else { result.IsSkipped = true; } } catch (Exception ex) { // mark that the folder failed to upload result.IsFailed = true; result.Exception = ex; } } // get all the files in the local directory var fileListing = Directory.GetFiles(localFolder, "*.*", SearchOption.AllDirectories); // loop thru each file and transfer it foreach (var localFile in fileListing) { // calculate the local path var relativePath = localFile.Replace(localFolder, ""); var remoteFile = remoteFolder + relativePath.Replace('\\', '/'); // create the result object var result = new FtpResult() { Type = FtpFileSystemObjectType.File, Size = new FileInfo(localFile).Length, Name = Path.GetFileName(localFile), RemotePath = remoteFile, LocalPath = localFile }; // record the file results.Add(result); // if the file passes all rules if (rules != null && rules.Count > 0) { var passes = FtpRule.IsAllAllowed(rules, result.ToListItem(true)); if (!passes) { // mark that the file was skipped due to a rule result.IsSkipped = true; result.IsSkippedByRule = true; // skip uploading the file continue; } } // record that this file should exist shouldExist.Add(remoteFile.ToLower(), true); // absorb errors try { // upload the file var transferred = this.UploadFile(result.LocalPath, result.RemotePath, existsMode, false, verifyOptions, progress); result.IsSuccess = true; result.IsSkipped = !transferred; } catch (Exception ex) { // mark that the file failed to upload result.IsFailed = true; result.Exception = ex; } } // delete the extra remote files if in mirror mode if (mode == FtpFolderSyncMode.Mirror) { // get all the files on the server var remoteListing = GetListing(remoteFolder, FtpListOption.Recursive); // delete files that are not in listed in shouldExist foreach (var existingServerFile in remoteListing) { if (existingServerFile.Type == FtpFileSystemObjectType.File) { if (!shouldExist.ContainsKey(existingServerFile.FullName.ToLower())) { // delete the file from the server try { DeleteFile(existingServerFile.FullName); } catch (Exception ex) { } } } } } return(results); }