CancelReceive and CancelHandshakeReconnect

budgetpreneur · budgetpreneur · commit 189b2c420ef7 · 2023-06-02T19:50:13.000+05:30
diff --git a/src/Api/PubnubApi/EndPoint/PubSub/SubscribeOperation2.cs b/src/Api/PubnubApi/EndPoint/PubSub/SubscribeOperation2.cs
@@ -58,6 +58,7 @@ public SubscribeOperation2(PNConfiguration pubnubConfig, IJsonPluggableLibrary j
             handshakeReconnectEffectHandler.MaxRetries = config.ConnectionMaxRetries;
             handshakeReconnectEffectHandler.LogCallback = LogCallback;
             handshakeReconnectEffectHandler.HandshakeReconnectRequested += HandshakeReconnectEffect_HandshakeRequested;
+            handshakeReconnectEffectHandler.CancelHandshakeReconnectRequested += HandshakeReconnectEffect_CancelHandshakeRequested;
             handshakeReconnectEffectHandler.AnnounceStatus = Announce;
             
             var handshakeFailedEffectHandler = new HandshakeFailedEffectHandler(eventEmitter);
@@ -67,6 +68,7 @@ public SubscribeOperation2(PNConfiguration pubnubConfig, IJsonPluggableLibrary j
             receivingEffectHandler.ReconnectionPolicy = config.ReconnectionPolicy;
             receivingEffectHandler.LogCallback = LogCallback;
             receivingEffectHandler.ReceiveRequested += ReceivingEffect_ReceiveRequested;
+            receivingEffectHandler.CancelReceiveRequested += ReceivingEffect_CancelReceiveRequested;
             receivingEffectHandler.AnnounceStatus = Announce;
             receivingEffectHandler.AnnounceMessage = Announce;
 
@@ -129,6 +131,14 @@ private void HandshakeEffect_CancelHandshakeRequested(object sender, CancelHands
         {
             manager.HandshakeRequestCancellation();
         }
+        private void HandshakeReconnectEffect_CancelHandshakeRequested(object sender, CancelHandshakeReconnectRequestEventArgs e)
+        {
+            manager.HandshakeRequestCancellation();
+        }
+        private void ReceivingEffect_CancelReceiveRequested(object sender, CancelReceiveRequestEventArgs e)
+        {
+            manager.ReceiveRequestCancellation();
+        }
 
         private void JsonCallback(string json, bool zeroTimeTokenRequest, int messageCount)
         {
diff --git a/src/Api/PubnubApi/EventEngine/HandshakeEffectHandler.cs b/src/Api/PubnubApi/EventEngine/HandshakeEffectHandler.cs
@@ -50,8 +50,8 @@ public class HandshakeEffectHandler : IEffectInvocationHandler
 		public Action<PNStatus> AnnounceStatus { get; set; }
 		private PNStatus pnStatus { get; set; }
 
-		public event EventHandler<HandshakeRequestEventArgs>? HandshakeRequested;
-		public event EventHandler<CancelHandshakeRequestEventArgs>? CancelHandshakeRequested;
+		public event EventHandler<HandshakeRequestEventArgs> HandshakeRequested;
+		public event EventHandler<CancelHandshakeRequestEventArgs> CancelHandshakeRequested;
 		protected virtual void OnHandshakeRequested(HandshakeRequestEventArgs e)
         {
             EventHandler<HandshakeRequestEventArgs> handler = HandshakeRequested;
@@ -165,7 +165,6 @@ public void Cancel()
 			LogCallback?.Invoke($"HandshakeEffectHandler - invoking OnCancelHandshakeRequested.");
 			CancelHandshakeRequestEventArgs args = new CancelHandshakeRequestEventArgs();
 			OnCancelHandshakeRequested(args);				
-
 		}
         public void Run(ExtendedState context)
         {
diff --git a/src/Api/PubnubApi/EventEngine/HandshakeReconnectEffectHandler.cs b/src/Api/PubnubApi/EventEngine/HandshakeReconnectEffectHandler.cs
@@ -16,10 +16,12 @@ public class HandshakeReconnectRequestEventArgs : EventArgs
 		public ExtendedState ExtendedState { get; set; }
 		public Action<string> HandshakeReconnectResponseCallback { get; set; }
 	}
+	public class CancelHandshakeReconnectRequestEventArgs : EventArgs 
+	{ 
+	}
     public class HandshakeReconnectEffectHandler : IEffectInvocationHandler
     {
         EventEmitter emitter;
-		//public EffectInvocationType InvocationType { get; set; }
 		private ExtendedState extendedState { get; set;}
 		public Action<string> LogCallback { get; set; }
 		public Action<PNStatus> AnnounceStatus { get; set; }
@@ -31,18 +33,27 @@ public class HandshakeReconnectEffectHandler : IEffectInvocationHandler
 		const int MAXEXPONENTIALBACKOFF = 25;
 		const int INTERVAL = 3;
 
-		public event EventHandler<HandshakeReconnectRequestEventArgs>? HandshakeReconnectRequested;
+		public event EventHandler<HandshakeReconnectRequestEventArgs> HandshakeReconnectRequested;
+		public event EventHandler<CancelHandshakeReconnectRequestEventArgs> CancelHandshakeReconnectRequested;
 		System.Threading.Timer timer;
 		protected virtual void OnHandshakeReconnectRequested(HandshakeReconnectRequestEventArgs e)
         {
-            EventHandler<HandshakeReconnectRequestEventArgs>? handler = HandshakeReconnectRequested;
+            EventHandler<HandshakeReconnectRequestEventArgs> handler = HandshakeReconnectRequested;
+            if (handler != null)
+            {
+                handler(this, e);
+            }
+        }
+		protected virtual void OnCancelHandshakeReconnectRequested(CancelHandshakeReconnectRequestEventArgs e)
+        {
+            EventHandler<CancelHandshakeReconnectRequestEventArgs> handler = CancelHandshakeReconnectRequested;
             if (handler != null)
             {
                 handler(this, e);
             }
         }
 
-        CancellationTokenSource? cancellationTokenSource;
+        CancellationTokenSource cancellationTokenSource;
         public HandshakeReconnectEffectHandler(EventEmitter emitter)
 		{
 			this.emitter = emitter;
@@ -242,6 +253,9 @@ public void Cancel()
 				LogCallback?.Invoke($"HandshakeReconnectEffectHandler - cancellationTokenSource - cancellion attempted.");
 				cancellationTokenSource.Cancel();
 			}
+			LogCallback?.Invoke($"HandshakeReconnectEffectHandler - invoking OnCancelHandshakeReconnectRequested.");
+			CancelHandshakeReconnectRequestEventArgs args = new CancelHandshakeReconnectRequestEventArgs();
+			OnCancelHandshakeReconnectRequested(args);				
 		}
         public void Run(ExtendedState context)
         {
diff --git a/src/Api/PubnubApi/EventEngine/ReceivingEffectHandler.cs b/src/Api/PubnubApi/EventEngine/ReceivingEffectHandler.cs
@@ -9,7 +9,7 @@ namespace PubnubApi.PubnubEventEngine
 	public class ReceiveingResponse<T>
 	{
 		[JsonProperty("t")]
-		public Timetoken? Timetoken { get; set; }
+		public Timetoken Timetoken { get; set; }
 
 		[JsonProperty("m")]
 		public Message<T>[] Messages { get; set; }
@@ -45,6 +45,12 @@ public class ReceiveRequestEventArgs : EventArgs
 		public ExtendedState ExtendedState { get; set; }
 		public Action<string> ReceiveResponseCallback { get; set; }
 	}
+
+	public class CancelReceiveRequestEventArgs : EventArgs
+	{
+
+	}
+
 	public class ReceivingEffectHandler<T> : IEffectInvocationHandler, IReceiveMessageHandler<T>
 	{
 		EventEmitter emitter;
@@ -56,17 +62,27 @@ public class ReceivingEffectHandler<T> : IEffectInvocationHandler, IReceiveMessa
 		public Action<PNMessageResult<object>> AnnounceMessage { get; set; }
 		public PNReconnectionPolicy ReconnectionPolicy { get; set; }
 
-		public event EventHandler<ReceiveRequestEventArgs>? ReceiveRequested;
+		public event EventHandler<ReceiveRequestEventArgs> ReceiveRequested;
+		public event EventHandler<CancelReceiveRequestEventArgs> CancelReceiveRequested;
 		protected virtual void OnReceiveRequested(ReceiveRequestEventArgs e)
         {
-            EventHandler<ReceiveRequestEventArgs>? handler = ReceiveRequested;
+            EventHandler<ReceiveRequestEventArgs> handler = ReceiveRequested;
+            if (handler != null)
+            {
+                handler(this, e);
+            }
+        }
+
+		protected virtual void OnCancelReceiveRequested(CancelReceiveRequestEventArgs e)
+        {
+            EventHandler<CancelReceiveRequestEventArgs> handler = CancelReceiveRequested;
             if (handler != null)
             {
                 handler(this, e);
             }
         }
 
-		CancellationTokenSource? cancellationTokenSource;
+		CancellationTokenSource cancellationTokenSource;
 
         public ReceivingEffectHandler(EventEmitter emitter)
 		{
@@ -164,6 +180,9 @@ public void Cancel()
 				LogCallback?.Invoke($"ReceivingEffectHandler - Receiving request cancellion attempted.");
 				cancellationTokenSource.Cancel();
 			}
+			LogCallback?.Invoke($"ReceivingEffectHandler - invoking OnCancelReceiveRequested.");
+			CancelReceiveRequestEventArgs args = new CancelReceiveRequestEventArgs();
+			OnCancelReceiveRequested(args);				
 		}
         public void Run(ExtendedState context)
         {

Original file line number	Diff line number	Diff line change
`@@ -50,8 +50,8 @@ public class HandshakeEffectHandler : IEffectInvocationHandler`
`50`	`50`	`public Action<PNStatus> AnnounceStatus { get; set; }`
`51`	`51`	`private PNStatus pnStatus { get; set; }`
`52`	`52`
`53`		`- public event EventHandler<HandshakeRequestEventArgs>? HandshakeRequested;`
`54`		`- public event EventHandler<CancelHandshakeRequestEventArgs>? CancelHandshakeRequested;`
	`53`	`+ public event EventHandler<HandshakeRequestEventArgs> HandshakeRequested;`
	`54`	`+ public event EventHandler<CancelHandshakeRequestEventArgs> CancelHandshakeRequested;`
`55`	`55`	`protected virtual void OnHandshakeRequested(HandshakeRequestEventArgs e)`
`56`	`56`	`{`
`57`	`57`	`EventHandler<HandshakeRequestEventArgs> handler = HandshakeRequested;`
`@@ -165,7 +165,6 @@ public void Cancel()`
`165`	`165`	`LogCallback?.Invoke($"HandshakeEffectHandler - invoking OnCancelHandshakeRequested.");`
`166`	`166`	`CancelHandshakeRequestEventArgs args = new CancelHandshakeRequestEventArgs();`
`167`	`167`	`OnCancelHandshakeRequested(args);`
`168`		`-`
`169`	`168`	`}`
`170`	`169`	`public void Run(ExtendedState context)`
`171`	`170`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,12 @@ public class HandshakeReconnectRequestEventArgs : EventArgs`
`16`	`16`	`public ExtendedState ExtendedState { get; set; }`
`17`	`17`	`public Action<string> HandshakeReconnectResponseCallback { get; set; }`
`18`	`18`	`}`
	`19`	`+ public class CancelHandshakeReconnectRequestEventArgs : EventArgs`
	`20`	`+ {`
	`21`	`+ }`
`19`	`22`	`public class HandshakeReconnectEffectHandler : IEffectInvocationHandler`
`20`	`23`	`{`
`21`	`24`	`EventEmitter emitter;`
`22`		`- //public EffectInvocationType InvocationType { get; set; }`
`23`	`25`	`private ExtendedState extendedState { get; set;}`
`24`	`26`	`public Action<string> LogCallback { get; set; }`
`25`	`27`	`public Action<PNStatus> AnnounceStatus { get; set; }`
`@@ -31,18 +33,27 @@ public class HandshakeReconnectEffectHandler : IEffectInvocationHandler`
`31`	`33`	`const int MAXEXPONENTIALBACKOFF = 25;`
`32`	`34`	`const int INTERVAL = 3;`
`33`	`35`
`34`		`- public event EventHandler<HandshakeReconnectRequestEventArgs>? HandshakeReconnectRequested;`
	`36`	`+ public event EventHandler<HandshakeReconnectRequestEventArgs> HandshakeReconnectRequested;`
	`37`	`+ public event EventHandler<CancelHandshakeReconnectRequestEventArgs> CancelHandshakeReconnectRequested;`
`35`	`38`	`System.Threading.Timer timer;`
`36`	`39`	`protected virtual void OnHandshakeReconnectRequested(HandshakeReconnectRequestEventArgs e)`
`37`	`40`	`{`
`38`		`- EventHandler<HandshakeReconnectRequestEventArgs>? handler = HandshakeReconnectRequested;`
	`41`	`+ EventHandler<HandshakeReconnectRequestEventArgs> handler = HandshakeReconnectRequested;`
	`42`	`+ if (handler != null)`
	`43`	`+ {`
	`44`	`+ handler(this, e);`
	`45`	`+ }`
	`46`	`+ }`
	`47`	`+ protected virtual void OnCancelHandshakeReconnectRequested(CancelHandshakeReconnectRequestEventArgs e)`
	`48`	`+ {`
	`49`	`+ EventHandler<CancelHandshakeReconnectRequestEventArgs> handler = CancelHandshakeReconnectRequested;`
`39`	`50`	`if (handler != null)`
`40`	`51`	`{`
`41`	`52`	`handler(this, e);`
`42`	`53`	`}`
`43`	`54`	`}`
`44`	`55`
`45`		`- CancellationTokenSource? cancellationTokenSource;`
	`56`	`+ CancellationTokenSource cancellationTokenSource;`
`46`	`57`	`public HandshakeReconnectEffectHandler(EventEmitter emitter)`
`47`	`58`	`{`
`48`	`59`	`this.emitter = emitter;`
`@@ -242,6 +253,9 @@ public void Cancel()`
`242`	`253`	`LogCallback?.Invoke($"HandshakeReconnectEffectHandler - cancellationTokenSource - cancellion attempted.");`
`243`	`254`	`cancellationTokenSource.Cancel();`
`244`	`255`	`}`
	`256`	`+ LogCallback?.Invoke($"HandshakeReconnectEffectHandler - invoking OnCancelHandshakeReconnectRequested.");`
	`257`	`+ CancelHandshakeReconnectRequestEventArgs args = new CancelHandshakeReconnectRequestEventArgs();`
	`258`	`+ OnCancelHandshakeReconnectRequested(args);`
`245`	`259`	`}`
`246`	`260`	`public void Run(ExtendedState context)`
`247`	`261`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace PubnubApi.PubnubEventEngine`
`9`	`9`	`public class ReceiveingResponse<T>`
`10`	`10`	`{`
`11`	`11`	`[JsonProperty("t")]`
`12`		`- public Timetoken? Timetoken { get; set; }`
	`12`	`+ public Timetoken Timetoken { get; set; }`
`13`	`13`
`14`	`14`	`[JsonProperty("m")]`
`15`	`15`	`public Message<T>[] Messages { get; set; }`
`@@ -45,6 +45,12 @@ public class ReceiveRequestEventArgs : EventArgs`
`45`	`45`	`public ExtendedState ExtendedState { get; set; }`
`46`	`46`	`public Action<string> ReceiveResponseCallback { get; set; }`
`47`	`47`	`}`
	`48`	`+`
	`49`	`+ public class CancelReceiveRequestEventArgs : EventArgs`
	`50`	`+ {`
	`51`	`+`
	`52`	`+ }`
	`53`	`+`
`48`	`54`	`public class ReceivingEffectHandler<T> : IEffectInvocationHandler, IReceiveMessageHandler<T>`
`49`	`55`	`{`
`50`	`56`	`EventEmitter emitter;`
`@@ -56,17 +62,27 @@ public class ReceivingEffectHandler<T> : IEffectInvocationHandler, IReceiveMessa`
`56`	`62`	`public Action<PNMessageResult<object>> AnnounceMessage { get; set; }`
`57`	`63`	`public PNReconnectionPolicy ReconnectionPolicy { get; set; }`
`58`	`64`
`59`		`- public event EventHandler<ReceiveRequestEventArgs>? ReceiveRequested;`
	`65`	`+ public event EventHandler<ReceiveRequestEventArgs> ReceiveRequested;`
	`66`	`+ public event EventHandler<CancelReceiveRequestEventArgs> CancelReceiveRequested;`
`60`	`67`	`protected virtual void OnReceiveRequested(ReceiveRequestEventArgs e)`
`61`	`68`	`{`
`62`		`- EventHandler<ReceiveRequestEventArgs>? handler = ReceiveRequested;`
	`69`	`+ EventHandler<ReceiveRequestEventArgs> handler = ReceiveRequested;`
	`70`	`+ if (handler != null)`
	`71`	`+ {`
	`72`	`+ handler(this, e);`
	`73`	`+ }`
	`74`	`+ }`
	`75`	`+`
	`76`	`+ protected virtual void OnCancelReceiveRequested(CancelReceiveRequestEventArgs e)`
	`77`	`+ {`
	`78`	`+ EventHandler<CancelReceiveRequestEventArgs> handler = CancelReceiveRequested;`
`63`	`79`	`if (handler != null)`
`64`	`80`	`{`
`65`	`81`	`handler(this, e);`
`66`	`82`	`}`
`67`	`83`	`}`
`68`	`84`
`69`		`- CancellationTokenSource? cancellationTokenSource;`
	`85`	`+ CancellationTokenSource cancellationTokenSource;`
`70`	`86`
`71`	`87`	`public ReceivingEffectHandler(EventEmitter emitter)`
`72`	`88`	`{`
`@@ -164,6 +180,9 @@ public void Cancel()`
`164`	`180`	`LogCallback?.Invoke($"ReceivingEffectHandler - Receiving request cancellion attempted.");`
`165`	`181`	`cancellationTokenSource.Cancel();`
`166`	`182`	`}`
	`183`	`+ LogCallback?.Invoke($"ReceivingEffectHandler - invoking OnCancelReceiveRequested.");`
	`184`	`+ CancelReceiveRequestEventArgs args = new CancelReceiveRequestEventArgs();`
	`185`	`+ OnCancelReceiveRequested(args);`
`167`	`186`	`}`
`168`	`187`	`public void Run(ExtendedState context)`
`169`	`188`	`{`