public TransportSetup(IRequestRouter requestRouter, IReceiverCache receiverCache, ITopicRouter topicRouter, IPublisherCache publisherCache)
{
this.topicRouter = topicRouter ?? throw new ArgumentNullException(nameof(topicRouter));
this.receiverCache = receiverCache ?? throw new ArgumentNullException(nameof(receiverCache));
this.requestRouter = requestRouter ?? throw new ArgumentNullException(nameof(requestRouter));
this.publisherCache = publisherCache ?? throw new ArgumentNullException(nameof(publisherCache));
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler onUnhandledException,
TimeSpan requestTimeout,
bool supportContentModified,
int concurrency,
IScheduler scheduler,
CreateResponseExceptionHandler?getException = null
) : this(
input,
outputHandler,
receiver,
requestRouter,
responseRouter,
new DefaultRequestInvoker(
requestRouter,
outputHandler,
requestProcessIdentifier,
new RequestInvokerOptions(
requestTimeout,
supportContentModified,
concurrency),
loggerFactory,
scheduler),
loggerFactory,
onUnhandledException,
getException)
{
}
public void Setup()
{
requestRouter = mockRequestRouter.Object;
monitorCache = mockMonitorCache.Object;
factory = mockFactory.Object;
senderMonitor = mockSenderMonitor.Object;
sender = mockSender.Object;
address = mockAddress.Object;
senderRouting = SenderRouting.For <ISender>(address);
mockFactory
.SetupGet(m => m.SenderType)
.Returns(typeof(ISender));
mockFactory
.SetupGet(m => m.SenderMonitor)
.Returns(senderMonitor);
mockRequestRouter
.Setup(m => m.RoutingFor <object>(out senderRouting))
.Returns(true);
mockFactory
.Setup(m => m.CreateSender(It.IsAny <IAddress>()))
.Returns(sender);
mockFactory
.SetupGet(m => m.SenderMonitor)
.Returns(senderMonitor);
}
public InputHandler(
Stream input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
ISerializer serializer
)
{
if (!input.CanRead)
{
throw new ArgumentException($"must provide a readable stream for {nameof(input)}", nameof(input));
}
_input = input;
_outputHandler = outputHandler;
_receiver = receiver;
_requestProcessIdentifier = requestProcessIdentifier;
_requestRouter = requestRouter;
_responseRouter = responseRouter;
_serializer = serializer;
_logger = loggerFactory.CreateLogger <InputHandler>();
_scheduler = new ProcessScheduler(loggerFactory);
_inputThread = new Thread(ProcessInputStream)
{
IsBackground = true, Name = "ProcessInputStream"
};
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
Action <Exception> onUnhandledException,
Func <ServerError, string, Exception> getException,
TimeSpan requestTimeout,
bool supportContentModified,
int?concurrency)
{
_inputHandler = new InputHandler(
input,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
onUnhandledException,
getException,
requestTimeout,
supportContentModified,
concurrency
);
}
public void Setup()
{
Reset();
_dataProviderDependenciesFactory = SetupMock <IDataProviderDependenciesFactory>();
_nameManager = SetupMock <INameManager>();
_dataCatalog = SetupMock <IDataCatalog>();
_dataSupplierFactory = SetupMock <IDataSupplierFactory>();
_dataDependencyFactory = SetupMock <IDataDependencyFactory>();
_requestRouter = SetupMock <IRequestRouter>();
_frameworkConfiguration = SetupMock <IFrameworkConfiguration>();
_elementConfiguror = new ElementConfiguror(
_dataSupplierFactory,
_dataDependencyFactory,
_nameManager,
_requestRouter);
_fluentBuilder = new FluentBuilder(
_nameManager,
_dataCatalog,
_dataProviderDependenciesFactory.DataDependencyFactory,
_dataProviderDependenciesFactory.DataSupplierFactory,
_frameworkConfiguration);
_fluentBuilder.DataProviderBuilder = new DataProviderBuilder(
_dataProviderDependenciesFactory,
_elementConfiguror,
_nameManager,
_fluentBuilder);
}
private static InputHandler NewHandler(
Stream inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
Action <CancellationTokenSource> action)
{
var cts = new CancellationTokenSource();
if (!System.Diagnostics.Debugger.IsAttached)
{
cts.CancelAfter(TimeSpan.FromSeconds(5));
}
action(cts);
var handler = new InputHandler(
inputStream,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
Substitute.For <ILoggerFactory>(),
new DapSerializer(),
null);
handler.Start();
cts.Wait();
Task.Delay(10).Wait();
return(handler);
}
private InputHandler NewHandler(
PipeReader inputStream,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor?> requestRouter,
ILoggerFactory loggerFactory,
IResponseRouter responseRouter,
IScheduler?scheduler = null
) =>
new InputHandler(
inputStream,
outputHandler,
receiver,
requestProcessIdentifier,
requestRouter,
responseRouter,
loggerFactory,
_unhandledException,
null,
TimeSpan.FromSeconds(30),
true,
null,
scheduler ?? TaskPoolScheduler.Default
);
/// <summary>
/// Add a new router
/// </summary>
/// <param name="router">Router</param>
public void Add(IRequestRouter router)
{
if (router == null)
{
throw new ArgumentNullException("router");
}
_routers.Add(router);
}
public void Setup()
{
factory = mockFactory.Object;
requestRouter = mockRequestRouter.Object;
topicRouter = mockTopicRouter.Object;
receiverCache = mockReceiverCache.Object;
publisherCache = mockPublisherCache.Object;
}
/// <summary>
/// Initializes a new instance of <see cref="NetMQTransport"/>
/// </summary>
/// <param name="factory"></param>
/// <param name="requestRouter"></param>
/// <param name="receiverCache"></param>
/// <param name="topicRouter"></param>
/// <param name="publisherCache"></param>
/// <returns></returns>
public static NetMQTransport Create(
INetMQFactory factory,
IRequestRouter requestRouter,
IReceiverCache receiverCache,
ITopicRouter topicRouter,
IPublisherCache publisherCache
)
=> new NetMQTransport(factory, requestRouter, receiverCache, topicRouter, publisherCache);
public PiccoloEngine(PiccoloConfiguration configuration, IEventDispatcher eventDispatcher, IRequestRouter requestRouter, IRequestHandlerInvoker requestHandlerInvoker)
{
_configuration = configuration;
_eventDispatcher = eventDispatcher;
_requestRouter = requestRouter;
_payloadDeserialiser = new PayloadDeserialiser(configuration.JsonDeserialiser);
_payloadValidatorInvoker = new PayloadValidatorInvoker(configuration.ObjectFactory);
_requestHandlerInvoker = requestHandlerInvoker;
}
/// <summary>
/// Initializes a new instance of <see cref="NetMQTransport"/>
/// </summary>
/// <param name="factory"></param>
/// <param name="requestRouter"></param>
/// <param name="receiverCache"></param>
/// <param name="topicRouter"></param>
/// <param name="publisherCache"></param>
private NetMQTransport(
INetMQFactory factory,
IRequestRouter requestRouter,
IReceiverCache receiverCache,
ITopicRouter topicRouter,
IPublisherCache publisherCache)
{
this.factory = factory ?? throw new ArgumentNullException(nameof(factory));
Configurer = new TransportSetup <INetMQSender, INetMQReceiver, INetMQPublisher, INetMQSubscriber>(requestRouter, receiverCache, topicRouter, publisherCache);
}
public DebugInfoMiddleware(
IRequestRouter requestRouter,
IHtmlWriterFactory htmlWriterFactory,
IRenderContextFactory renderContextFactory)
{
_requestRouter = requestRouter;
_htmlWriterFactory = htmlWriterFactory;
_renderContextFactory = renderContextFactory;
this.RunFirst();
}
/// <summary>
/// Constructor for IoC dependency injection
/// </summary>
public PagesMiddleware(
IRequestRouter requestRouter)
{
_requestRouter = requestRouter;
this.RunAfter <IOutputCache>(null, false);
this.RunAfter <IRequestRewriter>(null, false);
this.RunAfter <IResponseRewriter>(null, false);
this.RunAfter <IAuthorization>(null, false);
}
public ElementConfiguror(
IDataSupplierFactory dataSupplierFactory,
IDataDependencyFactory dataDependencyFactory,
INameManager nameManager,
IRequestRouter requestRouter)
{
_dataSupplierFactory = dataSupplierFactory;
_dataDependencyFactory = dataDependencyFactory;
_nameManager = nameManager;
_requestRouter = requestRouter;
}
public HttpRequestListener(string uriPrefix, IRequestRouter xmlRequestRouter)
{
this.xmlRequestRouter = xmlRequestRouter;
this.httpListener = new HttpListener();
this.httpListener.Prefixes.Add(uriPrefix);
this.httpListener.Start();
this.httpListener.BeginGetContext(this.GetContextCallback, null);
}
protected given_piccolo_engine()
{
var piccoloConfiguration = Bootstrapper.ApplyConfiguration(Assembly.GetCallingAssembly(), false);
EventDispatcher = Substitute.For <IEventDispatcher>();
RequestRouter = Substitute.For <IRequestRouter>();
RequestHandlerInvoker = Substitute.For <IRequestHandlerInvoker>();
HttpContextBase = Substitute.For <HttpContextBase>();
Engine = new PiccoloEngine(piccoloConfiguration, EventDispatcher, RequestRouter, RequestHandlerInvoker);
}
public HttpRequestListener(string uriPrefix, IRequestRouter xmlRequestRouter)
{
this.xmlRequestRouter = xmlRequestRouter;
this.httpListener = new HttpListener();
this.httpListener.Prefixes.Add(uriPrefix);
this.httpListener.Start();
this.httpListener.BeginGetContext(this.GetContextCallback, null);
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IResponseRouter responseRouter,
RequestInvoker requestInvoker,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler onUnhandledException,
CreateResponseExceptionHandler?getException = null
) =>
/// <summary>
/// Constructor for IoC dependency injection
/// </summary>
public PagesMiddleware(
IRequestRouter requestRouter,
ISegmentTestingFramework segmentTestingFramework)
{
_requestRouter = requestRouter;
_segmentTestingFramework = segmentTestingFramework;
this.RunAfter <IOutputCache>(null, false);
this.RunAfter <IRequestRewriter>(null, false);
this.RunAfter <IResponseRewriter>(null, false);
this.RunAfter <IAuthorization>(null, false);
}
public AssetManager(
IRequestRouter requestRouter,
IFrameworkConfiguration frameworkConfiguration,
ICssWriterFactory cssWriterFactory,
IJavascriptWriterFactory javascriptWriterFactory,
IStringBuilderFactory stringBuilderFactory,
IDictionaryFactory dictionaryFactory)
{
_frameworkConfiguration = frameworkConfiguration;
_cssWriterFactory = cssWriterFactory;
_javascriptWriterFactory = javascriptWriterFactory;
_stringBuilderFactory = stringBuilderFactory;
_elementsAddedToWebsite = new HashSet <string>();
_elementsAddedToModule = dictionaryFactory.Create <string, HashSet <string> >();
_elementsAddedToPage = dictionaryFactory.Create <string, HashSet <string> >();
_moduleStyles = dictionaryFactory.Create <string, string>();
_moduleFunctions = dictionaryFactory.Create <string, string>();
_pageStyles = dictionaryFactory.Create <string, string>();
_pageFunctions = dictionaryFactory.Create <string, string>();
_websiteStylesBuilder = stringBuilderFactory.Create();
_websiteFunctionsBuilder = stringBuilderFactory.Create();
_moduleStyleBuilders = dictionaryFactory.Create <string, IStringBuilder>();
_moduleFunctionBuilders = dictionaryFactory.Create <string, IStringBuilder>();
_pageStyleBuilders = dictionaryFactory.Create <string, IStringBuilder>();
_pageFunctionBuilders = dictionaryFactory.Create <string, IStringBuilder>();
frameworkConfiguration.Subscribe(config =>
{
var rootPath = config.AssetRootPath;
if (rootPath.EndsWith("/") && rootPath.Length > 1)
{
rootPath = rootPath.Substring(0, rootPath.Length - 1);
}
_rootPath = new PathString(rootPath);
var priorRegistration = _runableRegistration;
_runableRegistration = requestRouter.Register(this,
new FilterAllFilters(
new FilterByMethod(Method.Get),
new FilterByPath(_rootPath.Value + "/**")), -10);
if (priorRegistration != null)
{
priorRegistration.Dispose();
}
});
}
public ServiceBuilder(
IServiceDependenciesFactory serviceDependenciesFactory,
IElementConfiguror elementConfiguror,
IFluentBuilder fluentBuilder,
IRequestRouter requestRouter,
INameManager nameManager)
{
_serviceDependenciesFactory = serviceDependenciesFactory;
_elementConfiguror = elementConfiguror;
_fluentBuilder = fluentBuilder;
_requestRouter = requestRouter;
_nameManager = nameManager;
}
public Connection(
PipeReader input,
IOutputHandler outputHandler,
IReceiver receiver,
IRequestProcessIdentifier requestProcessIdentifier,
IRequestRouter <IHandlerDescriptor> requestRouter,
IResponseRouter responseRouter,
ILoggerFactory loggerFactory,
OnUnhandledExceptionHandler onUnhandledException,
TimeSpan requestTimeout,
bool supportContentModified,
int concurrency,
CreateResponseExceptionHandler getException = null
) =>
private void Register(ServiceEndpoint endpoint, Method[] methods, bool relativePath, string scenarioName)
{
var requestRouter = _serviceDependenciesFactory.RequestRouter;
if (relativePath)
{
if (_router == null)
{
if (Methods == null || Methods.Length == 0)
{
_router = _serviceDependenciesFactory.RequestRouter.Add(
new FilterByPath(BasePath + "**"),
RoutingPriority);
}
else
{
_router = _serviceDependenciesFactory.RequestRouter.Add(
new FilterAllFilters(
new FilterByMethod(Methods),
new FilterByPath(BasePath + "**")),
RoutingPriority);
}
}
requestRouter = _router;
}
var pathFilter = _paramRegex.Replace(endpoint.Path, "*");
if (methods == null || methods.Length == 0)
{
requestRouter.Register(
endpoint,
new FilterByPath(pathFilter),
RoutingPriority,
endpoint.MethodInfo,
scenarioName);
}
else
{
requestRouter.Register(
endpoint,
new FilterAllFilters(
new FilterByMethod(methods),
new FilterByPath(pathFilter)),
RoutingPriority,
endpoint.MethodInfo,
scenarioName);
}
}
public RazorOmniSharpRequestInvoker(
RequestInvokerOptions options,
IOutputHandler outputHandler,
IRequestRouter <IHandlerDescriptor?> requestRouter,
IRequestProcessIdentifier requestProcessIdentifier,
ILoggerFactory loggerFactory)
{
_requestTimeout = options.RequestTimeout;
_outputHandler = outputHandler;
_requestRouter = requestRouter;
_requestProcessIdentifier = requestProcessIdentifier;
_requestScheduler = new JsonRpcRequestScheduler(loggerFactory);
_logger = loggerFactory.CreateLogger <RazorOmniSharpRequestInvoker>();
}
IDisposable IRequestRouter.Register(
IRequestRouter router,
IRequestFilter filter,
int priority,
string scenarioName)
{
return(Add(new Registration
{
Priority = priority,
Filter = filter,
TestScenarioName = string.IsNullOrWhiteSpace(scenarioName) ? null : scenarioName,
Router = router
}));
}
public CryptowatchApiClient(
IRequestRouter router,
IAssetsClient assetsClient,
IPairsClient pairsClient,
IExchangesClient exchangesClient,
IMarketsClient marketsClient,
IAggregatesClient aggregatesClient)
{
_router = router;
Assets = assetsClient;
Pairs = pairsClient;
Exchanges = exchangesClient;
Markets = marketsClient;
Aggregates = aggregatesClient;
}
public PageBuilder(
IRequestRouter requestRouter,
INameManager nameManager,
IPageDependenciesFactory pageDependenciesFactory,
IComponentDependenciesFactory componentDependenciesFactory,
IElementConfiguror elementConfiguror,
IFluentBuilder fluentBuilder)
{
_requestRouter = requestRouter;
_nameManager = nameManager;
_pageDependenciesFactory = pageDependenciesFactory;
_componentDependenciesFactory = componentDependenciesFactory;
_elementConfiguror = elementConfiguror;
_fluentBuilder = fluentBuilder;
}
public DefaultRequestInvoker(
IRequestRouter <IHandlerDescriptor?> requestRouter,
IOutputHandler outputHandler,
IRequestProcessIdentifier requestProcessIdentifier,
RequestInvokerOptions options,
ILoggerFactory loggerFactory,
IScheduler scheduler)
{
_requestRouter = requestRouter;
_outputHandler = outputHandler;
_requestProcessIdentifier = requestProcessIdentifier;
_options = options;
_processScheduler = new ProcessScheduler(loggerFactory, _options.SupportContentModified, _options.Concurrency, scheduler);
_logger = loggerFactory.CreateLogger <DefaultRequestInvoker>();
}
public OrchestratorImplementation(
ILogger <OrchestratorImplementation> logger,
IRequestRouter requestRouter,
IWorkflowRegistry registry,
IWorkTracker workTracker,
IOrchestrationQueue orchestrationQueue,
IConfiguration configuration)
{
_logger = logger;
_requestRouter = requestRouter;
_registry = registry;
_workTracker = workTracker;
_orchestrationQueue = orchestrationQueue;
_configuration = configuration;
}
/// <summary>
/// Add a new router
/// </summary>
/// <param name="router">Router</param>
public void Add(IRequestRouter router)
{
if (router == null) throw new ArgumentNullException("router");
_routers.Add(router);
}
