From 79cd6c772da003ddc917eff362f9adaa99e28b49 Mon Sep 17 00:00:00 2001 From: Martin Ritchie Date: Thu, 28 Jun 2007 08:09:20 +0000 Subject: 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 --- .../Client/Protocol/AMQProtocolListener.cs | 18 ++++++--- .../Qpid.Client/Client/Protocol/DefaultTimeouts.cs | 47 ++++++++++++++++++++++ .../Listener/BlockingMethodFrameListener.cs | 5 ++- .../Qpid.Client/Client/Protocol/ProtocolWriter.cs | 34 ++++++++++++++-- 4 files changed, 94 insertions(+), 10 deletions(-) create mode 100644 dotnet/Qpid.Client/Client/Protocol/DefaultTimeouts.cs (limited to 'dotnet/Qpid.Client/Client/Protocol') 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 +{ + /// + /// Default timeout values for the protocol + /// + sealed class DefaultTimeouts + { + /// + /// Maximum number of milliseconds to wait for a state change + /// in the protocol's state machine + /// + public const int MaxWaitForState = 30* 1000; + /// + /// Maximum number of milliseconds to wait for a reply + /// frame when doing synchronous writer to the broker + /// + 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 /// /// This method is called by the thread that wants to wait for a frame. /// - public AMQMethodEvent BlockForFrame() + /// Set the number of milliseconds to wait + 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 { /// @@ -30,6 +32,9 @@ namespace Qpid.Client.Protocol /// public class ProtocolWriter { + + private ILog _logger = LogManager.GetLogger(typeof(ProtocolWriter)); + IProtocolWriter _protocolWriter; IProtocolListener _protocolListener; @@ -51,13 +56,15 @@ namespace Qpid.Client.Protocol /// /// the frame /// the blocking listener. Note the calling thread will block. - private AMQMethodEvent SyncWrite(AMQFrame frame, BlockingMethodFrameListener listener) + /// set the number of milliseconds to wait + 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 } + /// + /// 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. + /// + /// the frame + /// the type of method response 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); + } + + /// + /// 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. + /// + /// the frame + /// the type of method response + /// set the number of milliseconds to wait + /// set the number of milliseconds to wait + public AMQMethodEvent SyncWrite(AMQFrame frame, Type responseType, int timeout) + { + return SyncWrite(frame, new SpecificMethodFrameListener(frame.Channel, responseType), timeout); } } } -- cgit v1.2.1