public FtpUtil(string host, string username, string password) { _host = new FtpDirectory(); Host = host; Username = username; Password = password; }
public void CreateFolderTest() { var root = new FtpDirectory(FTP_BASE_URL, credential); var dir = root.GetDirectory("YC.FTP"); dir.CreateSubdirectory("test"); }
public void MoveFile() { var dir = new FtpDirectory($"{FTP_BASE_URL}/YC.FTP", credential); var items = dir?.GetFiles() .FirstOrDefault() ?.MoveTo("/YC.FTP/FILE2"); }
public void GetItemsTest() { var dir = new FtpDirectory($"{FTP_BASE_URL}localhost/YC.FTP", credential); var items = dir?.GetItems() .Select(p => p.FullName); Console.WriteLine(string.Join(",", items)); }
public void TestCreation1() { var ftpDirectory = FtpDirectory.Create("/foo/"); var directoryName = ftpDirectory.DirectoryName; Assert.AreEqual("foo", directoryName); }
public void DeleteFolderTest() { var dir = new FtpDirectory($"{FTP_BASE_URL}/YC.FTP/test", credential); if (dir?.Exists == true) { dir.Delete(true); } }
public void TestCreation5() { var ftpDirectory = FtpDirectory.Create("/foo1/foo2/foo3"); var parentFtpDirectory = ftpDirectory.GetParentFtpDirectory(); var parentDirectoryName = parentFtpDirectory.DirectoryName; Assert.AreEqual("foo2", parentDirectoryName); }
public void TestCreation4() { var rootFtpDirectory = FtpDirectory.Root; var ftpDirectory = FtpDirectory.Create(rootFtpDirectory, "test2"); var directoryName = ftpDirectory.DirectoryName; Assert.AreEqual("test2", directoryName); }
public void DeleteFileTest() { var root = new FtpDirectory(FTP_BASE_URL, credential); var dir = root.GetDirectory("YC.FTP"); var file = dir.GetFile("FILE"); if (file?.Exists == true) { file.Delete(); } }
public void AppendFileTest() { var root = new FtpDirectory(FTP_BASE_URL, credential); var dir = root.GetDirectory("YC.FTP"); var file = dir.GetFile("FILE") ?? dir.CreateFile("FILE"); var stream = file.OpenAppend(); var writer = new StreamWriter(stream); writer.WriteLine("Hello World, " + DateTime.Now.ToString()); writer.WriteLine(string.Join("", Enumerable.Repeat(" ", 2048))); writer.Flush(); writer.Close(); }
public void TestDirectoryChanges3() { var sourceFtpDirectory = FtpDirectory.Create("/foo/foo1"); var targetFtpDirectory = FtpDirectory.Create("/foo/foo2/foo3"); var directoryChanges = FtpClientHelper.DirectoryChanges(sourceFtpDirectory, targetFtpDirectory); var joinedDirectoryChanges = string.Join(",", directoryChanges); Assert.AreEqual("..,foo2,foo3", joinedDirectoryChanges); }
public async Task Should_delete_deep_structure() { await ResourceHelpers.CreateFileWithContentAsync($"folder1/folder2/folder3/{Guid.NewGuid()}.txt", "stuff", Logger); using (var ftpClient = ResourceHelpers.GetLocalFtpClient(Logger)) { ftpClient.Logger = Logger; var sut = new FtpDirectory(ftpClient, "folder1"); await sut.DeleteAsync(); var folders = await sut.GetDirectoriesAsync(); folders.Any(x => x.Name == "folder1").Should().BeFalse(); } }
/// <summary> /// Build the URI to use for the FTP request. /// </summary> /// <param name="fileName"> /// The name of the file to transfer, if any. Defaults to null. /// </param> /// <returns> /// The URI to use for the FTP request. /// </returns> private Uri BuildFtpRequestUri(string fileName = null) { // Build the fully qualified URI string, ensuring proper number of slashes after each segment. StringBuilder stringBuilder = new StringBuilder("ftp://"); stringBuilder.Append(AddressAuthority.Trim('/')); //TODO: Need double slash after port? stringBuilder.Append("/"); stringBuilder.Append(FtpDirectory.Trim('/')); if (String.IsNullOrWhiteSpace(fileName) == false) { stringBuilder.Append("/"); stringBuilder.Append(fileName.Trim('/')); } return(new Uri(stringBuilder.ToString())); }
public static IEnumerable <string> GetHierarchy(this FtpDirectory ftpDirectory) { if (ftpDirectory == null) { return(Enumerable.Empty <string>()); } var fullName = ftpDirectory.FullName; if (string.IsNullOrEmpty(fullName)) { return(Enumerable.Empty <string>()); } var directories = fullName.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }, StringSplitOptions.RemoveEmptyEntries); return(directories); }
internal FtpFileTransferer(FtpDirectory transferStarter, string localFile, string remoteFile, long totalBytes, TransferDirection dir) { m_transferStarter = transferStarter; m_transferDirection = dir; m_session = transferStarter.Session; m_localFile = localFile; m_remoteFile = remoteFile; m_totalBytes = totalBytes; if (dir == TransferDirection.Upload) { m_streamCopyRoutine = LocalToRemote; m_ftpFileCommandRoutine = m_session.ControlChannel.STOR; m_localFileOpenMode = FileMode.Open; } else { m_streamCopyRoutine = RemoteToLocal; m_ftpFileCommandRoutine = m_session.ControlChannel.RETR; m_localFileOpenMode = FileMode.Create; } }
public FileFilter CopyFromFtp(FtpDirectory ftpDir, string destinationDirectory) { using (FtpConnection ftpConnection = new FtpConnection(ftpDir.Host, ftpDir.Port, ftpDir.Username, ftpDir.Password)) { ftpConnection.Open(); ftpConnection.Login(); foreach (string ftpPath in GetFtpFilesAndFolders(ftpDir.BaseDirectory, ftpConnection)) { if (ftpConnection.DirectoryExists(ftpPath)) { var combinedPath = Path.Combine(destinationDirectory, PathWithoutBaseDirectory(ftpPath, ftpDir.BaseDirectory).TrimStart('/')); if (!Directory.Exists(combinedPath)) { Directory.CreateDirectory(combinedPath); } } else { if (!Directory.Exists(destinationDirectory)) { Directory.CreateDirectory(destinationDirectory); } var combinedPath = Path.Combine(destinationDirectory, PathWithoutBaseDirectory(ftpPath, ftpDir.BaseDirectory).TrimStart('/')); var newPath = Path.GetDirectoryName(combinedPath); if (!Directory.Exists(newPath)) { Directory.CreateDirectory(newPath); } ftpConnection.GetFile(ftpPath, combinedPath, false); } } ftpConnection.Close(); } return this; }
public IEnumerable <FtpItem> GetDirectoryContents() { // Intitialize File Transfer this.LIST(); // Read Bytes from Stream, save them to disk var result = new StreamReader(Data.Stream).ReadToEnd(); foreach (string line in result.Split(new [] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries)) { if (line.StartsWith("d")) { yield return(FtpDirectory.Parse(line)); } else { yield return(FtpFile.Parse(line)); } } // Wait for Confirmation on File Transfer. Stream will be closed by the Server! MessageHandler.WaitOne(); }
public FtpFile(FtpDirectory directory, string path) { if (null == directory) { throw new ArgumentNullException("directory"); } if (null == path) { throw new ArgumentNullException("path"); } if (path.Trim().IsEmpty()) { throw new ArgumentOutOfRangeException("path"); } Trace.WriteLineIf(Tracing.Is.TraceVerbose, "[FTP] directory={0} path={1}".FormatWith(directory.Location, path)); Directory = directory; Path = path; }
public static IFile ParseResponseLine(string line) { var listDirectoryLine = new ListDirectoryLine(line); IFile file; switch (listDirectoryLine.Type) { case ListDirectoryLine.ItemType.Directory: file = new FtpDirectory(); break; case ListDirectoryLine.ItemType.File: file = new FtpFile { Size = listDirectoryLine.Size }; break; case ListDirectoryLine.ItemType.FakeDirectory: return NullDirectory.Instance; default: throw new ArgumentException(); } file.Name = listDirectoryLine.Name; return file; }
public FileFilter CopyToFtp(string sourceDirectory, FtpDirectory ftpDir) { using (FtpConnection ftpConnection = new FtpConnection(ftpDir.Host, ftpDir.Port, ftpDir.Username, ftpDir.Password)) { ftpConnection.Open(); ftpConnection.Login(); foreach (WrappedFileSystemInfo fileSystemInfo in GetFilesAndFolders(sourceDirectory)) { if (fileSystemInfo is WrappedDirectoryInfo) { var combinedPath = Path.Combine(ftpDir.BaseDirectory, fileSystemInfo.PathWithoutBaseDirectory); if (!ftpConnection.DirectoryExists(combinedPath)) ftpConnection.CreateDirectory(combinedPath); } else { if (!ftpConnection.DirectoryExists(ftpDir.BaseDirectory)) { ftpConnection.CreateDirectory(ftpDir.BaseDirectory); } var combinedPath = Path.Combine(ftpDir.BaseDirectory, fileSystemInfo.PathWithoutBaseDirectory); var newPath = Path.GetDirectoryName(combinedPath); if (!ftpConnection.DirectoryExists(newPath)) { ftpConnection.CreateDirectory(newPath); } ftpConnection.SetCurrentDirectory(newPath); ftpConnection.PutFile(fileSystemInfo.FullName); } } } return this; }
internal void InitRootDirectory() { m_root = new FtpDirectory(this, m_caseInsensitive, m_ctrlChannel.PWD()); m_current = m_root; }
// Construction #region C'tors public FtpUtil() { _host = new FtpDirectory(); }
public FcChangeDirectory(FtpDirectory CurrentDir, FtpDirectory TargetDir) { this.CurrentDir = TargetDir; this.TargetDir = TargetDir; }
/// <summary> /// Releases the unmanaged resources used by the <see cref="FtpSessionConnected"/> object and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { if (!m_disposed) { try { // This will be done regardless of whether the object is finalized or disposed. if (disposing) { m_host = null; m_root = null; m_current = null; if ((object)m_ctrlChannel != null) m_ctrlChannel.Close(); m_ctrlChannel = null; if ((object)m_dataStream != null) m_dataStream.Dispose(); m_dataStream = null; } } finally { m_disposed = true; // Prevent duplicate dispose. } } }
/// <summary> /// Creates a new <see cref="FtpFile"/>. /// </summary> /// <param name="parent">Parent directory of file.</param> protected FtpFile(FtpDirectory parent) { Parent = parent; }
public void DeleteFromFtp(FtpDirectory ftpDir) { using (FtpConnection ftpConnection = new FtpConnection(ftpDir.Host, ftpDir.Port, ftpDir.Username, ftpDir.Password)) { ftpConnection.Open(); ftpConnection.Login(); var paths = GetFtpFilesAndFolders(ftpDir.BaseDirectory, ftpConnection); paths.Reverse(); foreach (var path in paths) { var fullPath = ftpDir.BaseDirectory + path; if (ftpConnection.DirectoryExists(fullPath)) RemoveDirectoryEvenIfNotEmpty(ftpConnection, fullPath); else { ftpConnection.RemoveFile(fullPath); } } ftpConnection.Close(); } }
internal NativeFtpFile(FtpDirectory parent, Ftp.FtpFile file) : base(parent) { m_file = file; }