Merged revisions 539783-539788 via svnmerge from

https://svn.apache.org/repos/asf/incubator/qpid/branches/M2

........
  r539783 | tomasr | 2007-05-19 18:40:32 +0100 (Sat, 19 May 2007) | 8 lines
  
  * QPID-495 (Contributed by Carlos Medina) Implement default timeouts for AttainState and SyncWrite
  * Fix method signatures
  * Remove SSL test with client-side certificates (requires extra setup)
  * Add locks AMSQtateManager and AMQProtocolListener to prevent modification of listener collections while processing notifications
  * Add library/runtime information to ConnectionStartMethodHandler
  * Fix some compiler warnings
  * Added XML documentation for some api interfaces
........
  r539788 | tomasr | 2007-05-19 19:55:33 +0100 (Sat, 19 May 2007) | 1 line
  
  * Excluded failover tests from nant builds and SSL tests on mono
........


git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk/qpid@551497 13f79535-47bb-0310-9956-ffa450edef68

4 files changed, 94 insertions, 10 deletions

diff --git a/dotnet/Qpid.Client/Client/Protocol/AMQProtocolListener.cs b/dotnet/Qpid.Client/Client/Protocol/AMQProtocolListener.cs
index 2b6f239127..2bf9f9a4c1 100644
--- a/dotnet/Qpid.Client/Client/Protocol/AMQProtocolListener.cs
+++ b/dotnet/Qpid.Client/Client/Protocol/AMQProtocolListener.cs
@@ -234,16 +234,21 @@ namespace Qpid.Client.Protocol
         {
             // FIXME: not sure if required as StateManager is in _frameListeners. Probably something to do with fail-over.
             _stateManager.Error(e);
-
-            foreach (IAMQMethodListener listener in _frameListeners)
+            lock ( _lock )
             {
-                listener.Error(e);
+               foreach ( IAMQMethodListener listener in _frameListeners )
+               {
+                  listener.Error(e);
+               }
             }
         }
 
         public void AddFrameListener(IAMQMethodListener listener)
         {
-            _frameListeners.Add(listener);
+           lock ( _lock )
+           {
+              _frameListeners.Add(listener);
+           }
         }
 
         public void RemoveFrameListener(IAMQMethodListener listener)
@@ -252,7 +257,10 @@ namespace Qpid.Client.Protocol
             {
                 _log.Debug("Removing frame listener: " + listener.ToString());
             }
-            _frameListeners.Remove(listener);
+            lock ( _lock )
+            {
+               _frameListeners.Remove(listener);
+            }
         }
 
         public void BlockUntilNotFailingOver()
diff --git a/dotnet/Qpid.Client/Client/Protocol/DefaultTimeouts.cs b/dotnet/Qpid.Client/Client/Protocol/DefaultTimeouts.cs
new file mode 100644
index 0000000000..0638bf0704
--- /dev/null
+++ b/dotnet/Qpid.Client/Client/Protocol/DefaultTimeouts.cs
@@ -0,0 +1,47 @@
+/*

+ *

+ * Licensed to the Apache Software Foundation (ASF) under one

+ * or more contributor license agreements.  See the NOTICE file

+ * distributed with this work for additional information

+ * regarding copyright ownership.  The ASF licenses this file

+ * to you under the Apache License, Version 2.0 (the

+ * "License"); you may not use this file except in compliance

+ * with the License.  You may obtain a copy of the License at

+ * 

+ *   http://www.apache.org/licenses/LICENSE-2.0

+ * 

+ * Unless required by applicable law or agreed to in writing,

+ * software distributed under the License is distributed on an

+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+ * KIND, either express or implied.  See the License for the

+ * specific language governing permissions and limitations

+ * under the License.

+ *

+ */

+

+using System;

+using System.Text;

+

+namespace Qpid.Client.Protocol

+{

+   /// <summary>

+   /// Default timeout values for the protocol

+   /// </summary>

+   sealed class DefaultTimeouts

+   {

+      /// <summary>

+      /// Maximum number of milliseconds to wait for a state change

+      /// in the protocol's state machine

+      /// </summary>

+      public const int MaxWaitForState = 30* 1000;

+      /// <summary>

+      /// Maximum number of milliseconds to wait for a reply

+      /// frame when doing synchronous writer to the broker

+      /// </summary>

+      public const int MaxWaitForSyncWriter = 30 * 1000;

+

+      private DefaultTimeouts()

+      {

+      }

+   }

+}

diff --git a/dotnet/Qpid.Client/Client/Protocol/Listener/BlockingMethodFrameListener.cs b/dotnet/Qpid.Client/Client/Protocol/Listener/BlockingMethodFrameListener.cs
index 99643fe59f..a020efbf21 100644
--- a/dotnet/Qpid.Client/Client/Protocol/Listener/BlockingMethodFrameListener.cs
+++ b/dotnet/Qpid.Client/Client/Protocol/Listener/BlockingMethodFrameListener.cs
@@ -80,9 +80,10 @@ namespace Qpid.Client.Protocol.Listener
         /// <summary>
         /// This method is called by the thread that wants to wait for a frame.
         /// </summary>
-        public AMQMethodEvent BlockForFrame()
+        /// <param name="timeout">Set the number of milliseconds to wait</param>
+        public AMQMethodEvent BlockForFrame(int timeout)
         {
-            _resetEvent.WaitOne();
+            _resetEvent.WaitOne(timeout, true);
             //at this point the event will have been signalled. The error field might or might not be set
             // depending on whether an error occurred
             if (_error != null)
diff --git a/dotnet/Qpid.Client/Client/Protocol/ProtocolWriter.cs b/dotnet/Qpid.Client/Client/Protocol/ProtocolWriter.cs
index 32847f9b9b..0ef337501e 100644
--- a/dotnet/Qpid.Client/Client/Protocol/ProtocolWriter.cs
+++ b/dotnet/Qpid.Client/Client/Protocol/ProtocolWriter.cs
@@ -23,6 +23,8 @@ using Qpid.Client.Protocol.Listener;
 using Qpid.Client.Transport;
 using Qpid.Framing;
 
+using log4net;
+
 namespace Qpid.Client.Protocol
 {
     /// <summary>
@@ -30,6 +32,9 @@ namespace Qpid.Client.Protocol
     /// </summary>
     public class ProtocolWriter
     {
+
+        private ILog _logger = LogManager.GetLogger(typeof(ProtocolWriter));
+
         IProtocolWriter _protocolWriter;
         IProtocolListener _protocolListener;
         
@@ -51,13 +56,15 @@ namespace Qpid.Client.Protocol
         /// </summary>
         /// <param name="frame">the frame</param>
         /// <param name="listener">the blocking listener. Note the calling thread will block.</param>         
-        private AMQMethodEvent SyncWrite(AMQFrame frame, BlockingMethodFrameListener listener)            
+        /// <param name="timeout">set the number of milliseconds to wait</param>
+        private AMQMethodEvent SyncWrite(AMQFrame frame, BlockingMethodFrameListener listener, int timeout)
         {
             try
             {
                 _protocolListener.AddFrameListener(listener);
                 _protocolWriter.Write(frame);
-                return listener.BlockForFrame();                
+                
+                return listener.BlockForFrame(timeout);
             }
             finally
             {
@@ -67,11 +74,32 @@ namespace Qpid.Client.Protocol
             // that matches the criteria defined in the blocking listener
         }
 
+        /// <summary>
+        /// Convenience method that writes a frame to the protocol session and waits for
+        /// a particular response. Equivalent to calling getProtocolSession().write() then
+        /// waiting for the response.
+        /// </summary>
+        /// <param name="frame">the frame</param>
+        /// <param name="responseType">the type of method response</param>
         public AMQMethodEvent SyncWrite(AMQFrame frame, Type responseType)
         {
             // TODO: If each frame knew it's response type, then the responseType argument would
             // TODO: not be neccesary.
-            return SyncWrite(frame, new SpecificMethodFrameListener(frame.Channel, responseType));
+            return SyncWrite(frame, responseType, DefaultTimeouts.MaxWaitForSyncWriter);
+        }
+
+        /// <summary>
+        /// Convenience method that writes a frame to the protocol session and waits for
+        /// a particular response. Equivalent to calling getProtocolSession().write() then
+        /// waiting for the response.
+        /// </summary>
+        /// <param name="frame">the frame</param>
+        /// <param name="responseType">the type of method response</param>
+        /// <param name="timeout">set the number of milliseconds to wait</param>
+        /// <returns>set the number of milliseconds to wait</returns>
+        public AMQMethodEvent SyncWrite(AMQFrame frame, Type responseType, int timeout)
+        {
+            return SyncWrite(frame, new SpecificMethodFrameListener(frame.Channel, responseType), timeout);
         }
     }
 }