public void Use_Invalid_Handler_Type()
{
var builder = new ExceptionHandlerBuilder(new ServiceCollection().BuildServiceProvider());
Assert.Throws <ArgumentException>(() => builder.Use(typeof(InvalidHandler)));
Assert.Throws <ArgumentException>(() => builder.Use <InvalidHandler>());
}
private void BuildErrorHandler()
{
errorLog = new ErrorLog(new DefaultLogFormatter());
ILogFactory logFactory = new DefaultLogFactory()
.AddSerializer(errorLog)
#if DEBUG
.AddConsole()
#endif
;
log = logFactory.Scope("Root");
ExceptionHandlerBuilder builder = new ExceptionHandlerBuilder();
builder
.Filter <UnauthorizedAccessException>()
.Handler(new UnauthorizedAccessExceptionHandler(Settings.Default, this, () => { mainWindow?.Close(); mainFactory.ClearService(); }));
builder
.Filter(e => !(e is UnauthorizedAccessException))
.Handler(new LogExceptionHandler(log))
.Handler(new MessageBoxExceptionHandler(this));
exceptionHandler = builder;
}
public void BuilderWithFilter()
{
ContextExceptionHandler <Exception> handler1 = new ContextExceptionHandler <Exception>(false);
ContextExceptionHandler <Exception> handler2 = new ContextExceptionHandler <Exception>(false);
ContextExceptionHandler <Exception> handler3 = new ContextExceptionHandler <Exception>(false);
ContextExceptionHandler <Exception> handler4 = new ContextExceptionHandler <Exception>(false);
ContextExceptionHandler <ArgumentException> handler5 = new ContextExceptionHandler <ArgumentException>(true);
ContextExceptionHandler <ArgumentException> handler6 = new ContextExceptionHandler <ArgumentException>(false);
ExceptionHandlerBuilder builder = new ExceptionHandlerBuilder();
builder
.Handler(handler1)
.Handler(handler2)
.Filter <Exception>()
.Handler(handler3)
.Handler(handler4)
.Filter <ArgumentException>()
.Handler(handler5)
.Handler(handler6);
IExceptionHandler handler = builder;
handler.Handle(new Exception());
handler.Handle(new ArgumentException());
Assert.AreEqual(2, handler1.Count);
Assert.AreEqual(2, handler2.Count);
Assert.AreEqual(2, handler3.Count);
Assert.AreEqual(2, handler4.Count);
Assert.AreEqual(1, handler5.Count);
Assert.AreEqual(0, handler6.Count);
}
private void InitializeErrorHandler()
{
executorFactory = new FileLogBatchFactory(TimeSpan.FromSeconds(30));
logService = new IsolatedLogService();
logFactory = new DefaultLogFactory()
.AddSerializer(AddDisposable(new FileLogSerializer(new DefaultLogFormatter(), () => settings.LogLevel, executorFactory)))
.AddSerializer(AddDisposable(new ErrorLogSerializer(new DefaultLogFormatter(), executorFactory)))
#if DEBUG
.AddConsole()
#endif
;
ILog rootLog = logFactory.Scope("Root");
ExceptionHandlerBuilder builder = new ExceptionHandlerBuilder();
builder
.Filter <UnauthorizedAccessException>()
.Handler(new UnauthorizedAccessExceptionHandler(settings, this, () => { mainWindow?.Close(); mainFactory.ClearService(); }));
builder
.Filter(e => !(e is UnauthorizedAccessException))
.Handler(new LogExceptionHandler(rootLog))
.Handler(new MessageBoxExceptionHandler(this));
exceptionHandler = builder;
}
public void Rethrow()
{
IExceptionHandler handler = new ExceptionHandlerBuilder()
.Handler(new ReThrowExceptionHandler());
string message1 = null;
string message2 = null;
try
{
try
{
Level1();
}
catch (Exception e1)
{
message1 = e1.ToString();
Assert.IsTrue(message1.Contains("Level3"));
handler.Handle(e1);
}
}
catch (Exception e2)
{
message2 = e2.ToString();
Assert.IsTrue(message1.Contains("Level3"));
Assert.IsTrue(message2.StartsWith(message1));
}
}
public async void Use()
{
var serviceProvider = new ServiceCollection()
.AddScoped <IFoo, Foo>()
.AddScoped <IBaz, Baz>()
.BuildServiceProvider();
var handler = new ExceptionHandlerBuilder(serviceProvider)
.Use(typeof(ValidHandler), new Bar())
.Build();
await handler(new ExceptionContext(new Exception()));
Assert.NotNull(_foo);
Assert.NotNull(_bar);
Assert.NotNull(_baz);
_foo = null;
_bar = null;
_baz = null;
handler = new ExceptionHandlerBuilder(serviceProvider)
.Use <ValidHandler>(new Bar())
.Build();
await handler(new ExceptionContext(new Exception()));
Assert.NotNull(_foo);
Assert.NotNull(_bar);
Assert.NotNull(_baz);
}
protected override void OnInitialized()
{
Log.Debug("Initialize VersionSupport");
base.OnInitialized();
ExceptionHandlerBuilder.Handler <NotSupportedApiVersionException>(this);
ClientVersion = typeof(VersionChecker).Assembly.GetName().Version;
NewIssueTitle = $"Client '{Converts.To<Version, string>(ClientVersion)}' is too old";
}
public static IServiceCollection AddExceptions(this IServiceCollection services)
{
Ensure.NotNull(services, "services");
ExceptionHandlerBuilder handlerBuilder = new ExceptionHandlerBuilder();
return(services
.AddSingleton(handlerBuilder)
.AddSingleton <IExceptionHandler>(handlerBuilder)
.AddTransient <TaskFaultHandler>());
}
public ServerConnectionState(NetworkState network, IApiHubState hub, ExceptionHandlerBuilder exceptionHandlers, ILogFactory logFactory)
{
Ensure.NotNull(network, "network");
Ensure.NotNull(hub, "hub");
Ensure.NotNull(exceptionHandlers, "exceptionHandlers");
Ensure.NotNull(logFactory, "logFactory");
this.network = network;
this.hub = hub;
this.log = logFactory.Scope("ServerConnectionState");
network.StatusChanged += OnNetworkChanged;
hub.Changed += OnServerStateChanged;
exceptionHandlers.Handler <ServerNotRespondingException>(OnServerNotRespondingException);
}
public void Ignore()
{
ExceptionHandlerBuilder builder = new ExceptionHandlerBuilder();
ArgumentExceptionHandler handler = new ArgumentExceptionHandler();
builder.Ignore();
builder.Handler(handler);
IExceptionHandlerCollection collection = new DefaultExceptionHandlerCollection()
.Add(builder);
collection.Handle(new ArgumentException("X"));
Assert.AreEqual(0, handler.CallCount);
}
public async void Use_And_Build()
{
var builder = new ExceptionHandlerBuilder(new ServiceCollection().BuildServiceProvider());
builder.Use(_ => { _flag = ""; return(Task.CompletedTask); });
builder.Use(_ => { _flag += "1"; return(Task.CompletedTask); });
builder.Use(_ => { _flag += "2"; return(Task.CompletedTask); });
builder.Use(_ => { _.Properties.Add("flag", _flag); return(Task.CompletedTask); });
var handler = builder.Build();
var context = new ExceptionContext(new Exception());
await handler(context);
Assert.Equal("12", context.Properties["flag"]);
}
public void Builder()
{
ContextExceptionHandler <Exception> handler1 = new ContextExceptionHandler <Exception>(false);
ContextExceptionHandler <Exception> handler2 = new ContextExceptionHandler <Exception>(true);
ContextExceptionHandler <Exception> handler3 = new ContextExceptionHandler <Exception>(false);
IExceptionHandler handler = new ExceptionHandlerBuilder()
.Handler(handler1)
.Handler(handler2)
.Handler(handler3);
handler.Handle(new Exception());
Assert.AreEqual(1, handler1.Count);
Assert.AreEqual(1, handler2.Count);
Assert.AreEqual(0, handler3.Count);
}
private void BuildExceptionHandler()
{
var exceptionBuilder = new ExceptionHandlerBuilder();
exceptionBuilder
.Handler(new LogExceptionHandler(LogFactory.Scope("Exception")));
var unauthorized = new UnauthorizedExceptionHandler(ProcessService);
exceptionBuilder
.Filter <UnauthorizedAccessException>()
.Handler(unauthorized);
exceptionBuilder
.Filter <PackagesConfigWriterException>()
.Filter(e => e.InnerException is FileNotFoundException)
.Handler(unauthorized);
exceptionBuilder
.Filter <NuGetConfigurationException>()
.Filter(e => e.InnerException is UnauthorizedAccessException)
.Handler(unauthorized);
exceptionBuilder
.Filter <FatalProtocolException>()
.Handler(new NuGetFatalProtocolExceptionHandler(Navigator));
var packageContent = new PackageInstallExceptionHandler(Navigator);
exceptionBuilder
.Handler <PackageFileExtractionException>(packageContent)
.Handler <PackageFileRemovalException>(packageContent);
exceptionBuilder
.Handler(new RestartAsAdministratorCancelledExceptionHandler(Navigator, this));
exceptionBuilder
.Handler(new MessageExceptionHandler(Navigator))
.Handler(new ShutdownExceptionHandler(this));
ExceptionHandler = exceptionBuilder;
}
public void Base()
{
ExceptionHandlerBuilder builder = new ExceptionHandlerBuilder();
ArgumentExceptionHandler handler1 = new ArgumentExceptionHandler();
InnerExceptionIsNullHandler handler2 = new InnerExceptionIsNullHandler();
MessageLongerThanTenHandler handler3 = new MessageLongerThanTenHandler();
MessageLongerThanTenHandler handler4 = new MessageLongerThanTenHandler();
builder
.Handler(handler1);
builder
.Filter(a => a.InnerException == null)
.Handler(handler2)
.Filter(a => a.Message.Length > 10)
.Handler(handler3);
builder
.Filter(a => a.Message.Length > 10)
.Handler(handler4);
IExceptionHandlerCollection collection = new DefaultExceptionHandlerCollection()
.Add(builder);
collection.Handle(new Exception("<= 10ch"));
collection.Handle(new Exception("Long message > 10ch", new Exception()));
collection.Handle(new Exception("===== 10ch"));
collection.Handle(new ArgumentException("<= 10ch"));
collection.Handle(new ArgumentException("Long message > 10ch"));
collection.Handle(new ArgumentException("===== 10ch", new Exception()));
Assert.AreEqual(3, handler1.CallCount);
Assert.AreEqual(4, handler2.CallCount);
Assert.AreEqual(1, handler3.CallCount);
Assert.AreEqual(2, handler4.CallCount);
}
public void Initialize()
{
logFactory = new DefaultLogFactory("Root").AddSerializer(new ConsoleSerializer());
errorLog = logFactory.Scope("Error");
readModelContextFactory = Factory.Getter(() => new ReadModelContext(connectionStrings.ReadModel));
eventSourcingContextFactory = Factory.Getter(() => new EventSourcingContext(connectionStrings.EventSourcing));
CreateReadModelContext();
CreateEventSourcingContext();
exceptionHandlerBuilder = new ExceptionHandlerBuilder();
services
.AddSingleton(readModelContextFactory)
.AddSingleton(eventSourcingContextFactory)
.AddSingleton(exceptionHandlerBuilder)
.AddSingleton <IExceptionHandler>(exceptionHandlerBuilder);
Domain();
priceCalculator = new PriceCalculator(eventDispatcher.Handlers, queryDispatcher);
services
.AddSingleton(priceCalculator)
.AddSingleton(new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter));
ReadModels();
services
.AddSingleton <IEventHandlerCollection>(eventDispatcher.Handlers)
.AddScoped <ICommandDispatcher>(provider => new UserCommandDispatcher(commandDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext, provider.GetService <ApiHub>()))
.AddScoped <IQueryDispatcher>(provider => new UserQueryDispatcher(queryDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext));
CurrencyCache currencyCache = new CurrencyCache(eventDispatcher.Handlers, queryDispatcher, queryDispatcher);
services
.AddSingleton(currencyCache);
}
public void Initialize()
{
Logging();
exceptionHandlerBuilder = new ExceptionHandlerBuilder();
exceptionHandlerBuilder.Handler(Handle);
services
.AddDbContextWithSchema <ReadModelContext>(connectionStrings.GetSection("ReadModel"), pathResolver)
.AddDbContextWithSchema <EventSourcingContext>(connectionStrings.GetSection("EventSourcing"), pathResolver)
.AddSingleton(exceptionHandlerBuilder)
.AddSingleton <IExceptionHandler>(exceptionHandlerBuilder);
var provider = services.BuildServiceProvider();
Domain(provider);
priceCalculator = new PriceCalculator(eventDispatcher.Handlers, queryDispatcher);
services
.AddSingleton(priceCalculator)
.AddSingleton(new FormatterContainer(commandFormatter, eventFormatter, queryFormatter, exceptionFormatter));
CreateReadModelContext(provider);
CreateEventSourcingContext(provider);
ReadModels(provider);
services
.AddSingleton <IEventHandlerCollection>(eventDispatcher.Handlers)
.AddScoped <ICommandDispatcher>(provider => new UserCommandDispatcher(commandDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext, provider.GetService <ApiHub>()))
.AddScoped <IQueryDispatcher>(provider => new UserQueryDispatcher(queryDispatcher, provider.GetService <IHttpContextAccessor>().HttpContext));
CurrencyCache currencyCache = new CurrencyCache(eventDispatcher.Handlers, queryDispatcher, queryDispatcher);
services
.AddSingleton(currencyCache);
}
public ApiHub(IEventHandlerCollection eventHandlers, FormatterContainer formatters, ExceptionHandlerBuilder exceptionHandlerBuilder)
{
Ensure.NotNull(eventHandlers, "eventHandlers");
Ensure.NotNull(formatters, "formatters");
this.formatters = formatters;
eventHandlers.AddAll(this);
exceptionHandlerBuilder.Filter <AggregateRootException>().Handler(this);
}
protected override Task OnInitializedAsync()
{
ExceptionHandlerBuilder.Handler(this);
FreeLimitsNotifier.OnShow += OnFreeLimitsNotifierShow;
return(base.OnInitializedAsync());
}
