public void AddClient(IFrameHandler handler)
{
rwl.EnterWriteLock();
frameHandlers.Add(handler);
if (frameHandlers.Count == 1)
SendMessage("start");
rwl.ExitWriteLock();
if (handler is Clients.Client)
((Clients.Client)handler).Disconnected += OnClientDisconnect;
}
public void RemoveClient(IFrameHandler handler)
{
rwl.EnterWriteLock();
frameHandlers.Remove(handler);
if (frameHandlers.Count == 0)
SendMessage("stop");
rwl.ExitWriteLock();
if (handler is Clients.Client)
((Clients.Client)handler).Disconnected -= OnClientDisconnect;
}
private void Init(IFrameHandler fh)
{
_delegate = new Connection(_factory, false,
fh, ClientProvidedName);
_recoveryTask = Task.Run(MainRecoveryLoop);
EventHandler <ShutdownEventArgs> recoveryListener = (_, args) =>
{
if (ShouldTriggerConnectionRecovery(args))
{
_recoveryLoopCommandQueue.Enqueue(RecoveryCommand.BeginAutomaticRecovery);
_semaphore.Release();
}
};
lock (_eventLock)
{
ConnectionShutdown += recoveryListener;
_recordedShutdownEventHandlers += recoveryListener;
}
}
private void Init(IFrameHandler fh)
{
m_delegate = new Connection(m_factory, false,
fh, this.ClientProvidedName);
AutorecoveringConnection self = this;
EventHandler <ShutdownEventArgs> recoveryListener = (_, args) =>
{
lock (recoveryLockTarget)
{
if (ShouldTriggerConnectionRecovery(args))
{
try
{
self.BeginAutomaticRecovery();
}
catch (Exception e)
{
// TODO: logging
#if NETFX_CORE
System.Diagnostics.Debug.WriteLine(
#else
Console.WriteLine(
#endif
"BeginAutomaticRecovery() failed: {0}", e);
}
}
}
};
lock (m_eventLock)
{
ConnectionShutdown += recoveryListener;
if (!m_recordedShutdownEventHandlers.Contains(recoveryListener))
{
m_recordedShutdownEventHandlers.Add(recoveryListener);
}
}
}
private void Init(IFrameHandler fh)
{
_delegate = new Connection(
_factory,
fh, ClientProvidedName);
_recoveryTask = Task.Run(MainRecoveryLoop);
lock (_eventLock)
{
ConnectionShutdown += recoveryListener;
_recordedShutdownEventHandlers += recoveryListener;
}
void recoveryListener(object _, ShutdownEventArgs args)
{
if (ShouldTriggerConnectionRecovery(args))
{
_recoveryLoopCommandQueue.Enqueue(RecoveryCommand.BeginAutomaticRecovery);
}
}
}
public RetrieveResourceService(
IInstanceStore instanceStore,
IFileStore blobDataStore,
ITranscoder transcoder,
IFrameHandler frameHandler,
IRetrieveTransferSyntaxHandler retrieveTransferSyntaxHandler,
ILogger <RetrieveResourceService> logger)
{
EnsureArg.IsNotNull(instanceStore, nameof(instanceStore));
EnsureArg.IsNotNull(blobDataStore, nameof(blobDataStore));
EnsureArg.IsNotNull(transcoder, nameof(transcoder));
EnsureArg.IsNotNull(frameHandler, nameof(frameHandler));
EnsureArg.IsNotNull(retrieveTransferSyntaxHandler, nameof(retrieveTransferSyntaxHandler));
EnsureArg.IsNotNull(logger, nameof(logger));
_instanceStore = instanceStore;
_blobDataStore = blobDataStore;
_transcoder = transcoder;
_frameHandler = frameHandler;
_retrieveTransferSyntaxHandler = retrieveTransferSyntaxHandler;
_logger = logger;
}
public Connection(IConnectionFactory factory, bool insist, IFrameHandler frameHandler, string clientProvidedName = null)
{
ClientProvidedName = clientProvidedName;
KnownHosts = null;
FrameMax = 0;
_factory = factory;
_frameHandler = frameHandler;
ConsumerWorkService = factory.DispatchConsumersAsync
? new AsyncConsumerWorkService(factory.ConsumerDispatchConcurrency)
: new ConsumerWorkService(factory.ConsumerDispatchConcurrency);
_sessionManager = new SessionManager(this, 0);
_session0 = new MainSession(this)
{
Handler = NotifyReceivedCloseOk
};
_model0 = (ModelBase)Protocol.CreateModel(_session0);
StartMainLoop();
Open(insist);
}
public Connection(IConnectionFactory factory, IFrameHandler frameHandler, string clientProvidedName = null)
{
ClientProvidedName = clientProvidedName;
_factory = factory;
_frameHandler = frameHandler;
Action <Exception, string> onException = (exception, context) => OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_callbackExceptionWrapper = new EventingWrapper <CallbackExceptionEventArgs>(string.Empty, (exception, context) => { });
_connectionBlockedWrapper = new EventingWrapper <ConnectionBlockedEventArgs>("OnConnectionBlocked", onException);
_connectionUnblockedWrapper = new EventingWrapper <EventArgs>("OnConnectionUnblocked", onException);
_connectionShutdownWrapper = new EventingWrapper <ShutdownEventArgs>("OnShutdown", onException);
_sessionManager = new SessionManager(this, 0);
_session0 = new MainSession(this)
{
Handler = NotifyReceivedCloseOk
};
_model0 = (ModelBase)Protocol.CreateModel(factory, _session0);
StartMainLoop();
Open();
}
public void Init(IList <string> hostnames)
{
this.hostnames = hostnames;
string reachableHostname = null;
IFrameHandler fh = null;
Exception e = null;
foreach (var h in hostnames)
{
try
{
fh = m_factory.CreateFrameHandler(m_factory.Endpoint.CloneWithHostname(h));
reachableHostname = h;
} catch (Exception caught)
{
e = caught;
}
}
if (reachableHostname == null)
{
throw e;
}
this.Init(reachableHostname);
}
private void Init(IFrameHandler fh)
{
m_delegate = new Connection(m_factory, false,
fh, this.ClientProvidedName);
m_recoveryTask = Task.Run(MainRecoveryLoop);
EventHandler <ShutdownEventArgs> recoveryListener = (_, args) =>
{
if (ShouldTriggerConnectionRecovery(args))
{
if (!m_recoveryLoopCommandQueue.TryAdd(RecoveryCommand.BeginAutomaticRecovery))
{
ESLog.Warn("Failed to notify RecoveryLoop to BeginAutomaticRecovery.");
}
}
};
lock (m_eventLock)
{
ConnectionShutdown += recoveryListener;
m_recordedShutdownEventHandlers += recoveryListener;
}
}
public IConnection CreateConnection(ConnectionFactory factory,
IFrameHandler frameHandler,
bool automaticRecoveryEnabled,
string clientProvidedName)
{
var ac = new AutorecoveringConnection(factory, clientProvidedName);
ac.Init();
return ac;
}
public IConnection CreateConnection(ConnectionFactory factory,
IFrameHandler frameHandler,
bool automaticRecoveryEnabled)
{
var ac = new AutorecoveringConnection(factory, null);
ac.Init();
return ac;
}
public IConnection CreateConnection(IConnectionFactory factory,
bool insist,
IFrameHandler frameHandler,
string clientProvidedName)
{
return new Connection(factory, insist, frameHandler, clientProvidedName);
}
public IConnection CreateConnection(IConnectionFactory factory,
bool insist,
IFrameHandler frameHandler)
{
return new Connection(factory, insist, frameHandler, null);
}
public void AddClient(IFrameHandler handler)
{
_rwl.EnterWriteLock();
_frameHandlers.Add(handler);
_rwl.ExitWriteLock();
}
public ConnectionBase(ConnectionFactory factory,
bool insist,
IFrameHandler frameHandler)
{
m_factory = factory;
m_frameHandler = frameHandler;
m_sessionManager = new SessionManager(this, 0);
m_session0 = new MainSession(this);
m_session0.Handler = new MainSession.SessionCloseDelegate(NotifyReceivedCloseOk);
m_model0 = (ModelBase)Protocol.CreateModel(m_session0);
StartMainLoop();
Open(insist);
StartHeartbeatLoops();
AppDomain.CurrentDomain.DomainUnload += HandleDomainUnload;
}
public Connection(ConnectionFactory factory, bool insist, IFrameHandler frameHandler)
: base(factory, insist, frameHandler)
{
}
public abstract IConnection CreateConnection(ConnectionFactory factory,
bool insist,
IFrameHandler frameHandler);
public FrameHandlerTests()
{
_recyclableMemoryStreamManager = new RecyclableMemoryStreamManager();
_frameHandler = new FrameHandler(Substitute.For <ITranscoder>(), _recyclableMemoryStreamManager);
}
public Connection(IConnectionFactory factory, bool insist, IFrameHandler frameHandler)
{
KnownHosts = null;
FrameMax = 0;
m_factory = factory;
m_frameHandler = frameHandler;
this.ConsumerWorkService = new ConsumerWorkService(factory.TaskScheduler);
m_sessionManager = new SessionManager(this, 0);
m_session0 = new MainSession(this) { Handler = NotifyReceivedCloseOk };
m_model0 = (ModelBase)Protocol.CreateModel(m_session0);
StartMainLoop(factory.UseBackgroundThreadsForIO);
Open(insist);
#if NETFX_CORE
#pragma warning disable 0168
try
{
Windows.UI.Xaml.Application.Current.Suspending += this.HandleApplicationSuspend;
}
catch (Exception ex)
{
// If called from a desktop app (i.e. unit tests), then there is no current application
}
#pragma warning restore 0168
#else
AppDomain.CurrentDomain.DomainUnload += HandleDomainUnload;
#endif
}
public override IConnection CreateConnection(ConnectionParameters parameters,
bool insist,
IFrameHandler frameHandler)
{
return(new Connection(parameters, insist, frameHandler));
}
public override IConnection CreateConnection(ConnectionParameters parameters,
bool insist,
IFrameHandler frameHandler)
{
return new Connection(parameters, insist, frameHandler);
}
public Connection(ConnectionParameters parameters, bool insist, IFrameHandler frameHandler)
: base(parameters, insist, frameHandler) {}
public abstract IConnection CreateConnection(ConnectionParameters parameters,
bool insist,
IFrameHandler frameHandler);
public void RemoveClient(IFrameHandler handler)
{
_rwl.EnterWriteLock();
_frameHandlers.Remove(handler);
_rwl.ExitWriteLock();
}
protected virtual IConnection FollowRedirectChain
(int maxRedirects,
IDictionary connectionAttempts,
IDictionary connectionErrors,
ref AmqpTcpEndpoint[] mostRecentKnownHosts,
AmqpTcpEndpoint endpoint)
{
AmqpTcpEndpoint candidate = endpoint;
try
{
while (true)
{
int attemptCount =
connectionAttempts.Contains(candidate)
? (int)connectionAttempts[candidate]
: 0;
connectionAttempts[candidate] = attemptCount + 1;
bool insist = attemptCount >= maxRedirects;
try
{
IProtocol p = candidate.Protocol;
IFrameHandler fh = p.CreateFrameHandler(candidate);
// At this point, we may be able to create
// and fully open a successful connection,
// in which case we're done, and the
// connection should be returned.
return(p.CreateConnection(this, insist, fh));
}
catch (RedirectException re)
{
if (insist)
{
// We've been redirected, but we insisted that
// we shouldn't be redirected! Well-behaved
// brokers should never do this.
string message = string.Format("Server {0} ignored 'insist' flag, redirecting us to {1}",
candidate,
re.Host);
throw new ProtocolViolationException(message);
}
else
{
// We've been redirected. Follow this new link
// in the chain, by setting
// mostRecentKnownHosts (in case the chain
// runs out), and updating candidate for the
// next time round the loop.
connectionErrors[candidate] = re;
mostRecentKnownHosts = re.KnownHosts;
candidate = re.Host;
}
}
}
}
catch (Exception e)
{
connectionErrors[candidate] = e;
return(null);
}
}
public override IConnection CreateConnection(ConnectionFactory factory,
bool insist,
IFrameHandler frameHandler)
{
return(new Connection(factory, insist, frameHandler));
}
public override IConnection CreateConnection(ConnectionFactory factory,
bool insist,
IFrameHandler frameHandler)
{
return new Connection(factory, insist, frameHandler);
}
public Connection(ConnectionFactory factory, bool insist, IFrameHandler frameHandler)
: base(factory, insist, frameHandler)
{
}
private void Init(IFrameHandler fh)
{
m_delegate = new Connection(m_factory, false,
fh, this.ClientProvidedName);
AutorecoveringConnection self = this;
EventHandler<ShutdownEventArgs> recoveryListener = (_, args) =>
{
lock (recoveryLockTarget)
{
if (ShouldTriggerConnectionRecovery(args))
{
try
{
self.BeginAutomaticRecovery();
}
catch (Exception e)
{
ESLog.Error("BeginAutomaticRecovery() failed.", e);
}
}
}
};
lock (m_eventLock)
{
ConnectionShutdown += recoveryListener;
if (!m_recordedShutdownEventHandlers.Contains(recoveryListener))
{
m_recordedShutdownEventHandlers.Add(recoveryListener);
}
}
}
public ConnectionBase(ConnectionParameters parameters,
bool insist,
IFrameHandler frameHandler)
{
m_parameters = parameters;
m_frameHandler = frameHandler;
m_sessionManager = new SessionManager(this);
m_session0 = new MainSession(this);
m_session0.Handler = new MainSession.SessionCloseDelegate(NotifyReceivedCloseOk);
m_model0 = (ModelBase)Protocol.CreateModel(m_session0);
StartMainLoop();
Open(insist);
StartHeartbeatLoops();
}
public Connection(IConnectionFactory factory, bool insist, IFrameHandler frameHandler, string clientProvidedName = null)
{
ClientProvidedName = clientProvidedName;
KnownHosts = null;
FrameMax = 0;
m_factory = factory;
m_frameHandler = frameHandler;
ConsumerWorkService = new ConsumerWorkService();
m_sessionManager = new SessionManager(this, 0);
m_session0 = new MainSession(this) { Handler = NotifyReceivedCloseOk };
m_model0 = (ModelBase)Protocol.CreateModel(m_session0);
StartMainLoop(factory.UseBackgroundThreadsForIO);
Open(insist);
}
public Connection(ConnectionParameters parameters, bool insist, IFrameHandler frameHandler)
: base(parameters, insist, frameHandler)
{
}
public abstract IConnection CreateConnection(ConnectionParameters parameters,
bool insist,
IFrameHandler frameHandler);
public abstract IConnection CreateConnection(ConnectionFactory factory,
bool insist,
IFrameHandler frameHandler);
private IFrameHandler ConfigureFrameHandler(IFrameHandler fh)
{
// make sure socket timeouts are higher than heartbeat
fh.ReadTimeout = Math.Max(SocketReadTimeout, RequestedHeartbeat * 1000);
fh.WriteTimeout = Math.Max(SocketWriteTimeout, RequestedHeartbeat * 1000);
// TODO: add user-provided configurator, like in the Java client
return fh;
}
private static void ServerResponse(IFrameHandler frameHandler, string msg)
{
var bytesMsg = Encoding.UTF8.GetBytes(msg);
frameHandler.SendMessageAsync(bytesMsg);
}
public IConnection CreateConnection(IConnectionFactory factory,
bool insist,
IFrameHandler frameHandler)
{
return(new Connection(factory, insist, frameHandler, null));
}
public IConnection CreateConnection(IConnectionFactory factory,
IFrameHandler frameHandler,
string clientProvidedName)
{
return(new Connection(factory, frameHandler, clientProvidedName));
}
