private void RecordInvocation(string name, ExceptionMode exceptionMode = ExceptionMode.DontThrow)
{
_invocationList.Add(name);
if (exceptionMode != ExceptionMode.DontThrow)
{
throw new MonkeyWrench();
}
}
public DeliveryHandler(
AcknowledgeMode acknowledgeMode,
ExceptionMode exceptionMode,
IMessageHandler <RabbitMQDelivery> handler,
AsyncContextAccessor asyncContextAccessor)
{
this.acknowledgeMode = acknowledgeMode;
this.exceptionMode = exceptionMode;
this.handler = handler;
this.asyncContextAccessor = asyncContextAccessor;
}
public QueueConsumerSubscriber(
string queue,
AcknowledgeMode acknowledgeMode,
ExceptionMode exceptionMode,
IMessageHandler <RabbitMQDelivery> handler,
AsyncContextAccessor asyncContextAccessor)
{
this.queue = queue;
this.acknowledgeMode = acknowledgeMode;
deliveryHandler = new DeliveryHandler(acknowledgeMode, exceptionMode, handler, asyncContextAccessor);
}
public ExchangeBindingSubscriber(
string exchange,
string routingKey,
AcknowledgeMode acknowledgeMode,
ExceptionMode exceptionMode,
IMessageHandler <RabbitMQDelivery> handler,
AsyncContextAccessor asyncContextAccessor)
{
this.exchange = exchange ?? string.Empty;
this.routingKey = routingKey ?? string.Empty;
this.acknowledgeMode = acknowledgeMode;
this.exceptionMode = exceptionMode;
deliveryHandler = new DeliveryHandler(acknowledgeMode, exceptionMode, handler, asyncContextAccessor);
}
private IBusinessClass GetBusinessClass(ExceptionMode mode)
{
//register the types
var builder = new ContainerBuilder();
builder.RegisterInstance(_actionInterceptor).As <ActionInterceptor>();
builder.RegisterInstance(_businessClasses[mode]).As <IBusinessClass>()
.EnableInterfaceInterceptors()
.InterceptedBy(typeof(ActionInterceptor));
//build the container and resolve the intercepted business class
var container = builder.Build();
var businessClass = container.Resolve <IBusinessClass>();
return(businessClass);
}
private async Task <object> RecordInvocationAsync(string name, ExceptionMode exceptionMode = ExceptionMode.DontThrow, object returnValue = null)
{
_invocationList.Add(name);
switch (exceptionMode)
{
case ExceptionMode.Throw:
case ExceptionMode.ThrowBeforeAwait:
throw new MonkeyWrench();
case ExceptionMode.ThrowAfterAwait:
await Task.CompletedTask;
throw new MonkeyWrench();
}
return(returnValue);
}
private void TestException(
PythonDebugger debugger,
string filename,
bool resumeProcess,
ExceptionMode defaultExceptionMode,
ICollection<KeyValuePair<string, ExceptionMode>> exceptionModes,
PythonDebugOptions debugOptions,
params ExceptionInfo[] exceptions
) {
Console.WriteLine();
Console.WriteLine("Testing {0}", filename);
bool loaded = false;
var process = DebugProcess(debugger, filename, (processObj, threadObj) => {
loaded = true;
processObj.SetExceptionInfo(
(int)defaultExceptionMode,
exceptionModes == null ?
Enumerable.Empty<KeyValuePair<string, int>>() :
exceptionModes.Select(m => new KeyValuePair<string, int>(m.Key, (int)m.Value))
);
}, debugOptions: debugOptions);
var raised = new List<Tuple<string, string>>();
process.ExceptionRaised += (sender, args) => {
if (loaded) {
raised.Add(Tuple.Create(args.Exception.TypeName, TryGetStack(args.Thread)));
}
if (resumeProcess) {
process.Resume();
} else {
args.Thread.Resume();
}
};
StartAndWaitForExit(process);
if (Version.Version == PythonLanguageVersion.V30 && raised.Count > exceptions.Length) {
// Python 3.0 raises an exception as the process shuts down.
raised.RemoveAt(raised.Count - 1);
}
if (GetType() == typeof(DebuggerTestsIpy) && raised.Count == exceptions.Length + 1) {
// IronPython over-reports exceptions
raised.RemoveAt(raised.Count - 1);
}
foreach (var t in raised) {
Console.WriteLine("Received {0} at{1}{2}", t.Item1, Environment.NewLine, t.Item2);
}
AssertUtil.AreEqual(
raised.Select(t => t.Item1),
exceptions.Select(e => e.TypeName).ToArray()
);
}
private void TestException(
PythonDebugger debugger,
string filename,
bool resumeProcess,
ExceptionMode defaultExceptionMode,
ICollection<KeyValuePair<string, ExceptionMode>> exceptionModes,
params ExceptionInfo[] exceptions
) {
TestException(debugger, filename, resumeProcess, defaultExceptionMode, exceptionModes, PythonDebugOptions.RedirectOutput, exceptions);
}
protected void RecordExceptions() => _exceptionMode = ExceptionMode.Record;
public ExceptionModeAttribute(ExceptionMode mode)
{
this.mode = mode;
}
protected void RecordAnyExceptionsThrown()
{
_exceptionMode = ExceptionMode.Record;
}
public static RabbitMQChannelOptionsBuilder AddRequestReply(this RabbitMQChannelOptionsBuilder builder, AcknowledgeMode acknowledgeMode, ExceptionMode exceptionMode)
{
RequestReplyController controller = null;
builder
.DeclareQueue(queueBuilder => queueBuilder
.OnDeclare(queue => Task.Run(() => controller = new RequestReplyController(queue.Name)))
.Subscribe(acknowledgeMode, exceptionMode, delivery => controller.OnDelivery(delivery))
)
.Map <RequestReplyModel>(model => {
var context = controller.Request(model.SourceContent);
model.Context = context;
return(context.RequestContent);
});
return(builder);
}
public static RabbitMQQueueOptionsBuilder Subscribe(this RabbitMQQueueOptionsBuilder builder, AcknowledgeMode acknowledgeMode, ExceptionMode exceptionMode, Func <RabbitMQDelivery, Task> handler)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
builder.OnDeclaredActions.Add((services) => Task.Run(() =>
{
var(contextAccessor, channel, queue) = services.GetContext();
var startup = services.GetService <LifecycleController>();
startup.On(
LifecycleState.SubscribeQueues,
() => channel.Subscribe(new QueueConsumerSubscriber(queue.Name, acknowledgeMode, exceptionMode, new LambdaMessageHandler(handler), contextAccessor))
);
}));
return(builder);
}
