Merge pull request #504 from aliquid/features/387-NoopInterval

robinrodricks · web-flow · commit f04a307c0559 · 2020-01-06T11:12:34.000+05:30
Support NOOP to keep control socket alive during long file transfers, add NoopInterval property
diff --git a/FluentFTP/Client/FtpClient_Connection.cs b/FluentFTP/Client/FtpClient_Connection.cs
@@ -172,6 +172,7 @@ protected FtpClient CloneConnection() {
 			conn.SocketPollInterval = SocketPollInterval;
 			conn.StaleDataCheck = StaleDataCheck;
 			conn.EnableThreadSafeDataConnections = EnableThreadSafeDataConnections;
+			conn.NoopInterval = NoopInterval;
 			conn.Encoding = Encoding;
 			conn.Host = Host;
 			conn.Port = Port;
diff --git a/FluentFTP/Client/FtpClient_HighLevelDownload.cs b/FluentFTP/Client/FtpClient_HighLevelDownload.cs
@@ -643,6 +643,9 @@ private bool DownloadFileInternal(string remotePath, Stream outStream, long rest
 
 				var transferStarted = DateTime.Now;
 				var sw = new Stopwatch();
+
+				var anyNoop = false;
+
 				while (offset < fileLen || readToEnd) {
 					try {
 						// read a chunk of bytes from the FTP stream
@@ -663,6 +666,11 @@ private bool DownloadFileInternal(string remotePath, Stream outStream, long rest
 								ReportProgress(progress, fileLen, offset, bytesProcessed, DateTime.Now - transferStarted);
 							}
 
+							// Fix #387: keep alive with NOOP as configured and needed
+							if (!m_threadSafeDataChannels) {
+								anyNoop = Noop() || anyNoop;
+							}
+
 							// honor the rate limit
 							var swTime = sw.ElapsedMilliseconds;
 							if (rateLimitBytes > 0) {
@@ -719,8 +727,15 @@ private bool DownloadFileInternal(string remotePath, Stream outStream, long rest
 
 				// FIX : if this is not added, there appears to be "stale data" on the socket
 				// listen for a success/failure reply
-				if (!m_threadSafeDataChannels) {
+				while (!m_threadSafeDataChannels) {
 					var status = GetReply();
+
+					// Fix #387: exhaust any NOOP responses (not guaranteed during file transfers)
+					if (anyNoop && status.Message != null && status.Message.Contains("NOOP")) {
+						continue;
+					}
+
+					break;
 				}
 
 				return true;
@@ -788,6 +803,8 @@ private bool DownloadFileInternal(string remotePath, Stream outStream, long rest
 				var transferStarted = DateTime.Now;
 				var sw = new Stopwatch();
 
+				var anyNoop = false;
+
 				while (offset < fileLen || readToEnd) {
 					try {
 						// read a chunk of bytes from the FTP stream
@@ -808,6 +825,11 @@ private bool DownloadFileInternal(string remotePath, Stream outStream, long rest
 								ReportProgress(progress, fileLen, offset, bytesProcessed, DateTime.Now - transferStarted);
 							}
 
+							// Fix #387: keep alive with NOOP as configured and needed
+							if (!m_threadSafeDataChannels) {
+								anyNoop = await NoopAsync(token) || anyNoop;
+							}
+
 							// honor the rate limit
 							var swTime = sw.ElapsedMilliseconds;
 							if (rateLimitBytes > 0) {
@@ -864,8 +886,15 @@ private bool DownloadFileInternal(string remotePath, Stream outStream, long rest
 
 				// FIX : if this is not added, there appears to be "stale data" on the socket
 				// listen for a success/failure reply
-				if (!m_threadSafeDataChannels) {
+				while (!m_threadSafeDataChannels) {
 					FtpReply status = await GetReplyAsync(token);
+
+					// Fix #387: exhaust any NOOP responses (not guaranteed during file transfers)
+					if (anyNoop && status.Message != null && status.Message.Contains("NOOP")) {
+						continue;
+					}
+
+					break;
 				}
 
 				return true;
diff --git a/FluentFTP/Client/FtpClient_HighLevelUpload.cs b/FluentFTP/Client/FtpClient_HighLevelUpload.cs
@@ -708,6 +708,8 @@ private bool UploadFileInternal(Stream fileData, string remotePath, bool createR
 					upStream.SetLength(fileLen);
 				}
 
+				var anyNoop = false;
+
 				while (offset < fileLen) {
 					try {
 						// read a chunk of bytes from the file
@@ -729,6 +731,11 @@ private bool UploadFileInternal(Stream fileData, string remotePath, bool createR
 								ReportProgress(progress, fileLen, offset, bytesProcessed, DateTime.Now - transferStarted);
 							}
 
+							// Fix #387: keep alive with NOOP as configured and needed
+							if (!m_threadSafeDataChannels) {
+								anyNoop = Noop() || anyNoop;
+							}
+
 							// honor the speed limit
 							var swTime = sw.ElapsedMilliseconds;
 							if (rateLimitBytes > 0) {
@@ -787,13 +794,20 @@ private bool UploadFileInternal(Stream fileData, string remotePath, bool createR
 
 				// FIX : if this is not added, there appears to be "stale data" on the socket
 				// listen for a success/failure reply
-				if (!EnableThreadSafeDataConnections) {
+				while (!m_threadSafeDataChannels) {
 					var status = GetReply();
 
+					// Fix #387: exhaust any NOOP responses (not guaranteed during file transfers)
+					if (anyNoop && status.Message != null && status.Message.Contains("NOOP")) {
+						continue;
+					}
+
 					// Fix #353: if server sends 550 the transfer was received but could not be confirmed by the server
 					if (status.Code != null && status.Code != "" && status.Code.StartsWith("5")) {
 						return false;
 					}
+
+					break;
 				}
 
 				return true;
@@ -928,6 +942,8 @@ private bool UploadFileInternal(Stream fileData, string remotePath, bool createR
 					upStream.SetLength(fileLen);
 				}
 
+				var anyNoop = false;
+
 				while (offset < fileLen) {
 					try {
 						// read a chunk of bytes from the file
@@ -949,6 +965,11 @@ private bool UploadFileInternal(Stream fileData, string remotePath, bool createR
 								ReportProgress(progress, fileLen, offset, bytesProcessed, DateTime.Now - transferStarted);
 							}
 
+							// Fix #387: keep alive with NOOP as configured and needed
+							if (!m_threadSafeDataChannels) {
+								anyNoop = await NoopAsync(token) || anyNoop;
+							}
+
 							// honor the rate limit
 							var swTime = sw.ElapsedMilliseconds;
 							if (rateLimitBytes > 0) {
@@ -1007,13 +1028,20 @@ private bool UploadFileInternal(Stream fileData, string remotePath, bool createR
 
 				// FIX : if this is not added, there appears to be "stale data" on the socket
 				// listen for a success/failure reply
-				if (!m_threadSafeDataChannels) {
+				while (!m_threadSafeDataChannels) {
 					FtpReply status = await GetReplyAsync(token);
 
+					// Fix #387: exhaust any NOOP responses (not guaranteed during file transfers)
+					if (anyNoop && status.Message != null && status.Message.Contains("NOOP")) {
+						continue;
+					}
+
 					// Fix #353: if server sends 550 the transfer was received but could not be confirmed by the server
 					if (status.Code != null && status.Code != "" && status.Code.StartsWith("5")) {
 						return false;
 					}
+
+					break;
 				}
 
 				return true;
diff --git a/FluentFTP/Client/FtpClient_LowLevel.cs b/FluentFTP/Client/FtpClient_LowLevel.cs
@@ -28,6 +28,12 @@ namespace FluentFTP {
 	public partial class FtpClient : IDisposable {
 		#region Execute Command
 
+		/// <summary>
+		/// When last command was sent (NOOP or other), for having <see cref="Noop"/>
+		/// respect the <see cref="NoopInterval"/>.
+		/// </summary>
+		private DateTime m_lastCommandUtc;
+
 		/// <summary>
 		/// Executes a command
 		/// </summary>
@@ -70,6 +76,7 @@ public FtpReply Execute(string command) {
 
 				// send command to FTP server
 				m_stream.WriteLine(m_textEncoding, command);
+				m_lastCommandUtc = DateTime.UtcNow;
 				reply = GetReply();
 #if !CORE14
 			}
@@ -156,12 +163,54 @@ public async Task<FtpReply> ExecuteAsync(string command, CancellationToken token
 
 			// send command to FTP server
 			await m_stream.WriteLineAsync(m_textEncoding, command, token);
+			m_lastCommandUtc = DateTime.UtcNow;
 			reply = await GetReplyAsync(token);
 
 			return reply;
 		}
 #endif
 
+		/// <summary>
+		/// Sends the NOOP command according to <see cref="NoopInterval"/> (effectively a no-op if 0).
+		/// Please call <see cref="GetReply"/> as needed to read the "OK" command sent by the server and prevent stale data on the socket.
+		/// Note that response is not guaranteed by all FTP servers when sent during file transfers.
+		/// </summary>
+		/// <returns>true if NOOP command was sent</returns>
+		public bool Noop() {
+			if (m_noopInterval > 0 && DateTime.UtcNow.Subtract(m_lastCommandUtc).TotalMilliseconds > m_noopInterval) {
+				LogLine(FtpTraceLevel.Verbose, "Command:  NOOP");
+
+				m_stream.WriteLine(m_textEncoding, "NOOP");
+				m_lastCommandUtc = DateTime.UtcNow;
+
+				return true;
+			}
+
+			return false;
+		}
+
+#if ASYNC
+		/// <summary>
+		/// Sends the NOOP command according to <see cref="NoopInterval"/> (effectively a no-op if 0).
+		/// Please call <see cref="GetReplyAsync"/> as needed to read the "OK" command sent by the server and prevent stale data on the socket.
+		/// Note that response is not guaranteed by all FTP servers when sent during file transfers.
+		/// </summary>
+		/// <param name="token"></param>
+		/// <returns>true if NOOP command was sent</returns>
+		private async Task<bool> NoopAsync(CancellationToken token) {
+			if (m_noopInterval > 0 && DateTime.UtcNow.Subtract(m_lastCommandUtc).TotalMilliseconds > m_noopInterval) {
+				LogLine(FtpTraceLevel.Verbose, "Command:  NOOP");
+
+				await m_stream.WriteLineAsync(m_textEncoding, "NOOP", token);
+				m_lastCommandUtc = DateTime.UtcNow;
+
+				return true;
+			}
+
+			return false;
+		}
+#endif
+
 		#endregion
 
 		#region Get Reply
diff --git a/FluentFTP/Client/FtpClient_Properties.cs b/FluentFTP/Client/FtpClient_Properties.cs
@@ -177,6 +177,21 @@ public bool EnableThreadSafeDataConnections {
 			set => m_threadSafeDataChannels = value;
 		}
 
+		private int m_noopInterval = 0;
+
+		/// <summary>
+		/// Gets or sets the length of time in milliseconds after last command
+		/// (NOOP or other) that a NOOP command is sent by <see cref="Noop"/>.
+		/// This is called during downloading/uploading if
+		/// <see cref="EnableThreadSafeDataConnections"/> is false. Setting this
+		/// interval to 0 disables <see cref="Noop"/> all together.
+		/// The default value is 0 (disabled).
+		/// </summary>
+		public int NoopInterval {
+			get => m_noopInterval;
+			set => m_noopInterval = value;
+		}
+
 		private bool m_checkCapabilities = true;
 
 		/// <summary>
diff --git a/FluentFTP/Client/IFtpClient.cs b/FluentFTP/Client/IFtpClient.cs
@@ -28,6 +28,7 @@ public interface IFtpClient : IDisposable {
 		bool StaleDataCheck { get; set; }
 		bool IsConnected { get; }
 		bool EnableThreadSafeDataConnections { get; set; }
+		int NoopInterval { get; set; }
 		Encoding Encoding { get; set; }
 		string Host { get; set; }
 		int Port { get; set; }
