public static IApplicationBuilder UseMirrorSharp([NotNull] this IApplicationBuilder app, [CanBeNull] MirrorSharpOptions options = null)
{
Argument.NotNull(nameof(app), app);
app.UseMiddleware <Middleware>(options ?? new MirrorSharpOptions());
return(app);
}
internal MiddlewareBase([NotNull] LanguageManager languageManager, [NotNull] MirrorSharpOptions options)
{
_options = options;
_languageManager = languageManager;
_handlers = CreateHandlersIndexedByCommandId();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory, IHostApplicationLifetime applicationLifetime)
{
//app.UseDeveloperExceptionPage();
// force instantiation on singletons
{
var pmInst = app.ApplicationServices.GetService <PluginLoader>();
CommonNotificationThread.Instance = app.ApplicationServices.GetService <CommonNotificationThread>();
BackgroundThreadPluginManager.Instance = app.ApplicationServices.GetService <BackgroundThreadPluginManager>();
WorkerMonitor.Instance = app.ApplicationServices.GetService <WorkerMonitor>();
RealtimeMonitor.Instance = app.ApplicationServices.GetService <RealtimeMonitor>();
BackgroundTaskMonitor.Instance = app.ApplicationServices.GetService <BackgroundTaskMonitor>();
ConnectionStringSecurity.Instance = app.ApplicationServices.GetService <ConnectionStringSecurity>();
DotNetCoreCounterListener.Instance = app.ApplicationServices.GetService <DotNetCoreCounterListener>();
DotNetCoreCounterListener.Instance.Start();
{// More app startup stuff...but have a dependency on the singleton objects above. Can we move this somewhere else?
Log.Information("Initialising project object model");
// we can only initialise the Project structure once ConnectionStringSecurity exists
Settings.SettingsInstance.Instance.ProjectList.ForEach(p => p.AfterDeserializationInit());
Log.Information("Initialising plugin loader");
PluginLoader.Instance = pmInst;
PluginLoader.Instance.InitAsync().GetAwaiter().GetResult();
ServerMethodManager.RebuildCacheForAllApps();
Log.Information("Starting work spawner.");
WorkSpawner.Start();
}
}
applicationLifetime.ApplicationStopped.Register(() =>
{
Log.Information("Application stopped");
});
applicationLifetime.ApplicationStopping.Register(() =>
{
Log.Information("Application is shutting down");
});
// app.Use(async (httpContext, next) =>
// {
// //if (httpContext.Request.Path.Value.Contains("api/") && httpContext.Request.Method == "OPTIONS")
// if (httpContext.Request.Method.Equals("OPTIONS", StringComparison.OrdinalIgnoreCase))
// {
// httpContext.Response.Headers.Add("Access-Control-Max-Age", "600");
// // return;
// }
// await next();
// });
var webSocketOptions = new WebSocketOptions()
{
KeepAliveInterval = TimeSpan.FromSeconds(120),
ReceiveBufferSize = 4 * 1024,
};
app.UseWebSockets(webSocketOptions);
app.UseCors("CorsPolicy");
// SPA (angular) route fallback
app.Use(async(context, next) =>
{
await next();
if (context.Response.StatusCode == 404 &&
!Path.HasExtension(context.Request.Path.Value) &&
!(context.Request.Path.Value?.ToLower().StartsWith("/api/") ?? false))
{
context.Request.Path = "/index.html";
context.Response.StatusCode = 200;
await next();
}
});
/*****
* var mirrorSharpOptions = new MirrorSharpOptions()
* {
* SelfDebugEnabled = true,
* IncludeExceptionDetails = true,
* //SetOptionsFromClient = SetOptionsFromClientExtension()
* // CSharp = {
* // MetadataReferences = ImmutableList.Create<MetadataReference>(all),
* // CompilationOptions = compilationOptions
* // },
* ExceptionLogger = new MirrorSharpExceptionLogger()
* }.SetupCSharp(cs =>
* {
* //cs.MetadataReferences = cs.MetadataReferences.Clear();
* //cs.AddMetadataReferencesFromFiles(all);
* cs.MetadataReferences = ImmutableList.Create<MetadataReference>(all);
* cs.CompilationOptions = compilationOptions;
*
* });
*
*
* app.UseMirrorSharp(mirrorSharpOptions);
*/
app.UseDefaultFiles();
app.UseStaticFiles();
// TODO: This outputs full request detail into log. Perhaps consider outputting this to a different detailed log
//app.UseSerilogRequestLogging();
app.UseSerilogRequestLogging(options =>
{
options.GetType().GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
// Customize the message template
//HTTP {RequestMethod} {RequestPath} responded {StatusCode} in {Elapsed:0.0000} ms
options.MessageTemplate = "Req/Res: {ReqLen,7} {ResLen,7} {StatusCode} {Elapsed,7:0} ms {RequestMethod,4} {RequestPath}";
//options.GetLevel = (httpContext, elapsed, ex) => Serilog.Events.LogEventLevel.Warning;
// Attach additional properties to the request completion event
options.EnrichDiagnosticContext = (diagnosticContext, httpContext) =>
{
diagnosticContext.Set("ResLen", httpContext.Response.ContentLength ?? 0);
diagnosticContext.Set("ReqLen", httpContext.Request.ContentLength ?? 0);
};
});
app.UseRouting();
MetadataReference[] allMetadataReferences = null;
try
{
allMetadataReferences = CSharpCompilerHelper.GetCommonMetadataReferences();
var jsDALBasePluginPath = Path.GetFullPath("./plugins/jsdal-plugin.dll");
if (File.Exists("./plugins/jsdal-plugin.dll"))
{
Array.Resize(ref allMetadataReferences, allMetadataReferences.Length + 1);
allMetadataReferences[allMetadataReferences.Length - 1] = Microsoft.CodeAnalysis.MetadataReference.CreateFromFile(jsDALBasePluginPath);
}
else
{
Log.Error($"Failed to find base plugin assembly at {jsDALBasePluginPath}");
SessionLog.Error($"Failed to find base plugin assembly at {jsDALBasePluginPath}");
}
}
catch (Exception mex)
{
Log.Error(mex, "Failed to compile collection of metadata references");
}
app.UseEndpoints(endpoints =>
{
endpoints.MapHub <Hubs.HomeDashboardHub>("/main-stats");
endpoints.MapHub <Hubs.WorkerDashboardHub>("/worker-hub");
endpoints.MapHub <Hubs.Performance.RealtimeHub>("/performance-realtime-hub");
endpoints.MapHub <Hubs.HeartBeat.HeartBeatHub>("/heartbeat");
endpoints.MapHub <Hubs.BackgroundTaskHub>("/bgtasks-hub");
endpoints.MapHub <Hubs.BackgroundPluginHub>("/bgplugin-hub");
endpoints.MapHub <Hubs.ExecHub>("/exec-hub");
if (allMetadataReferences?.Length > 0)
{
var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary,
// generalDiagnosticOption: ReportDiagnostic.Suppress
specificDiagnosticOptions: new Dictionary <string, ReportDiagnostic>
{
{ "CS1701", ReportDiagnostic.Suppress }, // Binding redirects
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress }
}
);
var mirrorSharpOptions = new MirrorSharpOptions()
{
SelfDebugEnabled = true,
IncludeExceptionDetails = true
//SetOptionsFromClient = SetOptionsFromClientExtension()
// CSharp = {
// MetadataReferences = ImmutableList.Create<MetadataReference>(all),
// CompilationOptions = compilationOptions
// },
// ExceptionLogger = new MirrorSharpExceptionLogger()
}.SetupCSharp(cs =>
{
//cs.MetadataReferences = cs.MetadataReferences.Clear();
//cs.AddMetadataReferencesFromFiles(all);
cs.MetadataReferences = ImmutableList.Create <MetadataReference>(allMetadataReferences);
cs.CompilationOptions = compilationOptions;
});
endpoints.MapMirrorSharp("/mirrorsharp", mirrorSharpOptions);
}
else
{
Log.Warning("Mirrorsharp not started because of errors builiding up metadata references");
}
});
app.UseAuthentication();
app.UseWebSockets();
app.UseCookiePolicy();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
// unhandled exceptions
app.UseExceptionHandler(errorApp =>
{
errorApp.Run(async context =>
{
try
{
var exceptionHandlerPathFeature = context.Features.Get <IExceptionHandlerPathFeature>();
var id = ExceptionLogger.LogException(exceptionHandlerPathFeature.Error, exceptionHandlerPathFeature.Path, "jsdal-server", null);
context.Response.StatusCode = 500;
context.Response.ContentType = "text/plain";
await context.Response.WriteAsync($"Server error. Ref: {id}");
await context.Response.WriteAsync(new string(' ', 512)); // IE padding
}
catch (Exception ex)
{
Log.Error(ex, $"Failed to log unhandled exception because of:\r\n {ex.ToString()}");
}
});
});
}
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
protected MiddlewareBase([NotNull] MirrorSharpOptions options)
: this(new LanguageManager(Argument.NotNull(nameof(options), options)), options)
{
}