Bug 36858768 - [36731283->14.1.1.0.19] .NET: deadlock on service start with the EventDispatcher thread (main.net cl 110131 --> 14.1.1.0)

[git-p4: depot-paths = "//dev/release.net/coherence-net-v14.1.1.0/": change = 110135]

Author: fryp

src/Coherence/Net/Impl/RemoteService.cs

@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 using System;
 using System.Diagnostics;
@@ -798,19 +798,6 @@ protected virtual QueueProcessor EnsureEventDispatcher()
             return channel.ConnectionManager.EnsureEventDispatcher();
         }
 
-        /// <summary>
-        /// Block the calling thread until the EventDispatcher Queue is empty
-        /// and all outstanding tasks have been executed.
-        /// </summary>
-        public virtual void DrainEvents()
-        {
-            IConnectionInitiator initiator = Initiator;
-            if (initiator is Initiator)
-            {
-                ((Initiator) initiator).DrainEvents();
-            }
-        }
-
         /// <summary>
         /// Create and dispatch a new local <see cref="MemberEventArgs"/>
         /// with the given type to the registered event handlers.

src/Coherence/Net/Impl/SafeCacheService.cs

@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 using System;
 using System.Collections;
@@ -44,7 +44,7 @@ public virtual ICollection CacheNames
         /// </value>
         public virtual ICacheService RunningCacheService
         {
-            get { return EnsureRunningCacheService(true); }
+            get { return EnsureRunningCacheService(); }
         }
 
         /// <summary>
@@ -273,18 +273,12 @@ protected override void Cleanup()
         /// running and has not been explicitly stopped, the
         /// <b>ICacheService</b> is restarted.
         /// </remarks>
-        /// <param name="drain">
-        /// If true and the wrapped <b>ICacheService</b> is restarted, the
-        /// calling thread will be blocked until the wrapped
-        /// <b>ICacheService</b> event dispatcher queue is empty and all
-        /// outstanding tasks have been executed.
-        /// </param>
         /// <returns>
         /// The running wrapped <b>ICacheService</b>.
         /// </returns>
-        public virtual ICacheService EnsureRunningCacheService(bool drain)
+        public virtual ICacheService EnsureRunningCacheService()
         {
-            return (ICacheService) EnsureRunningService(drain);
+            return (ICacheService) EnsureRunningService();
         }
 
         /// <summary>

src/Coherence/Net/Impl/SafeInvocationService.cs

@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 using System.Collections;
 
@@ -25,7 +25,7 @@ public class SafeInvocationService : SafeService, IInvocationService
         /// </value>
         public virtual IInvocationService RunningInvocationService
         {
-            get { return EnsureRunningInvocationService(true); }
+            get { return EnsureRunningInvocationService(); }
         }
 
         #endregion
@@ -112,20 +112,14 @@ public IDictionary Query(IInvocable task, ICollection col)
         /// not running and has not been explicitly stopped, the
         /// <b>IInvocationService</b> is restarted.
         /// </remarks>
-        /// <param name="drain">
-        /// If true and the wrapped <b>IInvocationService</b> is restarted,
-        /// the calling thread will be blocked until the wrapped
-        /// <b>IInvocationService</b> event dispatcher queue is empty and all
-        /// outstanding tasks have been executed.
-        /// </param>
         /// <returns>
         /// The running wrapped <b>IInvocationService</b>.
         /// </returns>
-        public virtual IInvocationService EnsureRunningInvocationService(bool drain)
+        public virtual IInvocationService EnsureRunningInvocationService()
         {
-            return (IInvocationService) EnsureRunningService(drain);
+            return (IInvocationService) EnsureRunningService();
         }
 
         #endregion
     }
-}
+}

src/Coherence/Net/Impl/SafeNamedCache.cs

@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 using System;
 using System.Collections;
@@ -197,8 +197,6 @@ public virtual INamedCache RunningNamedCache
                             }
                         }
                     }
-
-                    safeservice.DrainEvents();
                 }
                 return cache;
             }
@@ -1517,8 +1515,7 @@ protected virtual INamedCache RestartNamedCache()
             INamedCache cache;
             try
             {
-                cache = SafeCacheService.EnsureRunningCacheService(false)
-                        .EnsureCache(CacheName);
+                cache = SafeCacheService.EnsureRunningCacheService().EnsureCache(CacheName);
             }
             finally
             {

src/Coherence/Net/Impl/SafeService.cs

@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 using System;
 using System.Runtime.CompilerServices;
@@ -82,7 +82,7 @@ public virtual IOperationalContext OperationalContext
         /// </value>
         public virtual Util.IService RunningService
         {
-            get { return EnsureRunningService(true); }
+            get { return EnsureRunningService(); }
         }
 
         /// <summary>
@@ -626,16 +626,14 @@ public virtual void Start()
 
                 try
                 {
-                    EnsureRunningService(false);
+                    EnsureRunningService();
                 }
                 finally
                 {
                     // ServiceState.Started indicates that "start" was called
                     SafeServiceState = ServiceState.Started;
                 }
             }
-
-            DrainEvents();
         }
 
         /// <summary>
@@ -829,16 +827,10 @@ public virtual void OnServiceStopped(object sender, ServiceEventArgs evt)
         /// before returning it. If the <b>IService</b> is not running and has
         /// not been explicitly stopped, the <b>IService</b> is restarted.
         /// </remarks>
-        /// <param name="drain">
-        /// If true and the wrapped <b>IService</b> is restarted, the calling
-        /// thread will be blocked until the wrapped <b>IService</b> event
-        /// dispatcher queue is empty and all outstanding tasks have been
-        /// executed.
-        /// </param>
         /// <returns>
         /// The running wrapped <b>IService</b>.
         /// </returns>
-        public virtual Util.IService EnsureRunningService(bool drain)
+        public virtual Util.IService EnsureRunningService()
         {
             Util.IService service = Service;
             if (service == null || !service.IsRunning)
@@ -881,34 +873,11 @@ public virtual Util.IService EnsureRunningService(bool drain)
                         }
                     }
                 }
-
-                if (drain)
-                {
-                    DrainEvents();
-                }
             }
 
             return service;
         }
 
-        /// <summary>
-        /// Block the calling thread until the wrapped <b>IService</b> event
-        /// dispatcher queue is empty and all outstanding tasks have been
-        /// executed.
-        /// </summary>
-        public virtual void DrainEvents()
-        {
-            Util.IService service = Service;
-            if (service is Service)
-            {
-                ((Service) service).DrainEvents();
-            }
-            else if (service is RemoteService)
-            {
-                ((RemoteService) service).DrainEvents();
-            }
-        }
-
         /// <summary>
         /// Cleanup used resources.
         /// </summary>

src/Coherence/Util/Daemon/QueueProcessor/Service/Service.cs

@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2000, 2020, Oracle and/or its affiliates.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates.
  *
  * Licensed under the Universal Permissive License v 1.0 as shown at
- * http://oss.oracle.com/licenses/upl.
+ * https://oss.oracle.com/licenses/upl.
  */
 using System;
 using System.Diagnostics;
@@ -989,22 +989,6 @@ private void InvokeServiceEvent(ServiceEventHandler handler, ServiceEventArgs ev
             }
         }
 
-        /// <summary>
-        /// Block the calling thread until the EventDispatcher Queue is empty
-        /// and all outstanding tasks have been executed.
-        /// </summary>
-        /// <remarks>
-        /// This method is mostly called on client threads.
-        /// </remarks>
-        public virtual void DrainEvents()
-        {
-            EventDispatcher daemon = Dispatcher;
-            if (daemon != null)
-            {
-                daemon.DrainQueue();
-            }
-        }
-
         /// <summary>
         /// Return a running <see cref="Dispatcher"/>.
         /// </summary>