RMQServiceBusInterface( ServiceBusClient dispatcher, TraceSource tracer )
{
if (dispatcher == null)
throw new ArgumentNullException("entity");
Process = dispatcher;
this.Tracer = tracer;
}
RMQServiceBusInterface(ServiceBusClient process, string exchange, string binding, TraceSource tracer)
{
if (process == null)
throw new ArgumentNullException("service bus client");
this.Process = process;
this.Exchange = exchange;
this.Binding = binding;
this.Tracer = tracer;
}
/// <summary>
/// Create consumer that consumes on provided queue. The queue must exist and be bound to an exchange.
/// It can be used to feed on fixed queues, I mean those that exists no matter if a consumer is attached to or not.
/// By doing this we should expect a stream of events flowing to the dispatcher, which is process.
/// </summary>
/// <param name="process"></param>
/// <param name="binding"></param>
public static bool CreateConsumer( ServiceBusClient process, string queueName, string consumerTag )
{
//bind to external bus
RMQServiceBusInterface busClient = (RMQServiceBusInterface)RMQBus.GetClient(process.Address);
if (busClient != null)
{
if (!busClient.CreateConsumer(queueName, consumerTag))
{
#warning handle this error properly
return false;
}
}
Tracer.TraceEvent ( TraceEventType.Verbose,0, "[{0}] internal queue bound {1} ", process, queueName );
return true;
}
/// <summary>
///
/// </summary>
public static RMQServiceBusInterface CreateProcess(ServiceBusClient process, string binding, TraceSource tracer)
{
return new RMQServiceBusInterface(process, "amq.topic", binding, tracer);
}
/// <summary>
///
/// </summary>
public static RMQServiceBusInterface CreateProcess(ServiceBusClient process, TraceSource tracer)
{
return new RMQServiceBusInterface(process, "amq.topic", process.Address, tracer);
}
/// <summary>
/// Unbind exchange from the queue. By doing this we stop the message flow from both ipc and inproc channels.
/// </summary>
/// <param name="process"></param>
/// <param name="binding"></param>
public static void DestroyConsumer(ServiceBusClient process, string binding, string consumerTag)
{
//unbind from external bus
RMQServiceBusInterface busProc = RMQBus.GetClient(process.Address);
//if RMQ enabled then unbind from it
if (busProc != null)
busProc.DestroyConsumer ( consumerTag );
Tracer.TraceEvent ( TraceEventType.Verbose, 0, "[{0}] internal queue unbound {1} ", process, binding );
}
public static void UnregisterProcess(ServiceBusClient process, string reason)
{
//bind to external bus
RMQBus.UnregisterClient(process.Address, (ushort)RMQServiceBusInterface.ServiceBusCustomReasonCode.Dispose, reason);
}
/// <summary>
/// TaskContinuationSources are kept in Broker. This function is called by DipatchMessage() to eventually finalize RPC request.
/// <para>All rpc continuations are directed to processes/queues.</para>
/// </summary>
/// <param name="op"></param>
/// <param name="correlationID"></param>
/// <param name="result"></param>
/// <returns></returns>
public static bool TryHandleAsRPCResponse( ServiceBusClient process, RequestData request )
{
if (request.Op == "rpc_response" || request.Op == "offer_accepted" || request.Op == "transfer_ack")
{
if (request.CorrelationId == null)
{
//error
request.Ack(true, false);
Tracer.TraceEvent(TraceEventType.Error, 0, "[{0}] missing rpc task continuation cid, message dropped {1}", process, request.ToString());
return true;
}
TaskCompletionSource<object> tcs;
//tracer...
if (RPCTaskCompletions.TryRemove(request.CorrelationId, out tcs))
{
try
{
tcs.TrySetResult(request.Response);
Tracer.TraceEvent(TraceEventType.Verbose, 0, "[{0}] rpc response op {1} cid {2} response {3}", process, request.Op, request.CorrelationId, request.Response);
}
catch (Exception ex)
{
Tracer.TraceEvent(TraceEventType.Error, 0, "[{0}] rpc response op {1} cid {2} response {3} failed dute to {4}", process, request.Op, request.CorrelationId, request.Response, ex.Message);
}
request.Ack(true, false);
return true;
}
else
{
//probably result was already set, how did it happen that there are two responses to one request? are they different? possibly not but they could come because of network failue
//preserving at-least-once semantics; we ack and drop, making use of indemptodency
request.Ack(true, false);
Tracer.TraceEvent(TraceEventType.Error, 0, "[{0}] missing rpc task continuation for rpc response {1}, message dropped ", process, request.ToString());
return true;
}
}
return false;
}
/// <summary>
/// Register queue with different topic than the name of the process.
/// </summary>
/// <param name="process"></param>
/// <param name="binding"></param>
public static bool RegisterProcess(ServiceBusClient process, string binding)
{
//bind to external bus
bool b = RMQBus.RegisterClient(process.Address, RMQServiceBusInterface.CreateProcess(process, binding, RMQBus.Tracer));
if (b)
Tracer.TraceEvent(TraceEventType.Information, 0, "New process: '{0}', RMQ topic {1}, registered, ", process.Address, binding);
else
Tracer.TraceEvent(TraceEventType.Information, 0, "New process: '{0}', RMQ topic {1} registeration failed", process.Address, binding);
return b;
}
public static bool RegisterProcess( ServiceBusClient process)
{
//bind to external bus
return RegisterProcess(process, process.Address);
}