static ReactRenderer()
{
// Consider populating this lazily
var script = EmbeddedResourceReader.Read(typeof(ReactRenderer), "/Content/Node/react-rendering.js");
nodeScript = new StringAsTempFile(script); // Will be cleaned up on process exit
}
/// <summary>
/// Starts the webpack dev server. If the start fails for known reason, modifies the aspnet-webpack module to be compliant with webpack-dev-middleware 5.
/// For compatibility purposes as the change is rather samll it's easier to modify the existing module than to create new NPM package and enforce anyone to udpate.
/// </summary>
private static WebpackDevServerInfo StartWebpackDevServer(IDictionary <string, string> environmentVariables, string projectPath, WebpackDevServerArgs devServerArgs, bool fixAttempted)
{
// Unlike other consumers of NodeServices, WebpackDevMiddleware dosen't share Node instances, nor does it
// use your DI configuration. It's important for WebpackDevMiddleware to have its own private Node instance
// because it must *not* restart when files change (if it did, you'd lose all the benefits of Webpack
// middleware). And since this is a dev-time-only feature, it doesn't matter if the default transport isn't
// as fast as some theoretical future alternative.
// This should do it by using Jering.Javascript.NodeJS interop
var nodeJSService = NodeInteropFactory.BuildNewInstance(environmentVariables, projectPath);
try
{
return(nodeJSService.InvokeFromStringAsync <WebpackDevServerInfo>(
EmbeddedResourceReader.Read(typeof(WebpackDevMiddleware), "/Content/Node/webpack-dev-middleware.js"), //Embedded JS file
args: new object[] { JsonSerializer.Serialize(devServerArgs, jsonSerializerOptions) } //Options patched so that they work with aspnet-webpack package
).Result);
}
catch (Exception ex)
{
if (fixAttempted)
{
throw;
}
if (ex != null && ex.Message.Contains("Dev Middleware has been initialized using an options object that does not match the API schema."))
{
//Attempt to modify module file so that it doesn't contain arguments not recognized by the webpack-dev-middleware 5
try
{
const string SEARCH_PATTERN = "at validate (";
var startIndex = ex.Message.IndexOf(SEARCH_PATTERN);
if (startIndex > -1)
{
startIndex += SEARCH_PATTERN.Length;
var endIndex = ex.Message.IndexOf("webpack-dev-middleware", startIndex);
var modulesPath = ex.Message.Substring(startIndex, endIndex - startIndex);
if (Directory.Exists(modulesPath))
{
var modulePath = Path.Combine(modulesPath, @"aspnet-webpack\WebpackDevMiddleware.js");
if (File.Exists(modulePath))
{
var fileContent = File.ReadAllText(modulePath);
fileContent = fileContent.Replace("noInfo: true,", "");
fileContent = fileContent.Replace("watchOptions: webpackConfig.watchOptions", "");
File.WriteAllText(modulePath, fileContent);
nodeJSService.Dispose();
return(StartWebpackDevServer(environmentVariables, projectPath, devServerArgs, true));
}
}
}
}
catch (Exception)
{ }
}
throw;
}
}
static Prerenderer()
{
nodeScript = new Lazy <StringAsTempFile>(() => {
var script = EmbeddedResourceReader.Read(typeof(Prerenderer), "/Content/Node/prerenderer.js");
return(new StringAsTempFile(script)); // Will be cleaned up on process exit
});
}
protected override void OnWebKitInitialized()
{
CefRuntime.RegisterExtension(bindingExtensionName,
EmbeddedResourceReader.Read(typeof(MessageRenderProcessHandler), "/Renderer/Javascript/extension.js"),
handler);
base.OnWebKitInitialized();
}
private static string GetAngularCliMiddlewareScriptPath(IApplicationBuilder appBuilder)
{
var script = EmbeddedResourceReader.Read(typeof(AngularCliMiddleware), _middlewareResourceName);
var nodeScript = new StringAsTempFile(script, GetStoppingToken(appBuilder));
return(nodeScript.FileName);
}
public static async Task <NodeHost> Create(string handlerFile, string projectPath, CancellationToken applicationStopping, ILogger logger, IDictionary <string, string> environmentVars)
{
var hostScript = EmbeddedResourceReader.Read(typeof(NodeHost), "/Content/node-host.js");
var result = new NodeHost(hostScript, projectPath, "\"" + handlerFile + "\"", applicationStopping, logger, environmentVars);
await result.Start();
return(result);
}
private static string GetNodeScript(CancellationToken applicationStoppingToken)
{
lock (CreateNodeScriptLock)
{
if (NodeScript == null)
{
NodeScript = EmbeddedResourceReader.Read(typeof(Prerenderer), "/Content/Node/prerenderer.js");
}
}
return(NodeScript);
}
static INodeServices fallbackNodeServices; // Used only if no INodeServices was registered with DI
public static void UseWebpackDevMiddleware(this IApplicationBuilder appBuilder, WebpackDevMiddlewareOptions options = null)
{
// Validate options
if (options != null)
{
if (options.ReactHotModuleReplacement && !options.HotModuleReplacement)
{
throw new ArgumentException("To enable ReactHotModuleReplacement, you must also enable HotModuleReplacement.");
}
}
// Get the NodeServices instance from DI
var nodeServices = (INodeServices)appBuilder.ApplicationServices.GetService(typeof(INodeServices)) ?? fallbackNodeServices;
// Consider removing the following. Having it means you can get away with not putting app.AddNodeServices()
// in your startup file, but then again it might be confusing that you don't need to.
var appEnv = (IApplicationEnvironment)appBuilder.ApplicationServices.GetService(typeof(IApplicationEnvironment));
if (nodeServices == null)
{
nodeServices = fallbackNodeServices = Configuration.CreateNodeServices(NodeHostingModel.Http, appEnv.ApplicationBasePath);
}
// Get a filename matching the middleware Node script
var script = EmbeddedResourceReader.Read(typeof(WebpackDevMiddleware), "/Content/Node/webpack-dev-middleware.js");
var nodeScript = new StringAsTempFile(script); // Will be cleaned up on process exit
// Tell Node to start the server hosting webpack-dev-middleware
var devServerOptions = new {
webpackConfigPath = Path.Combine(appEnv.ApplicationBasePath, "webpack.config.js"),
suppliedOptions = options ?? new WebpackDevMiddlewareOptions()
};
var devServerInfo = nodeServices.InvokeExport <WebpackDevServerInfo>(nodeScript.FileName, "createWebpackDevServer", JsonConvert.SerializeObject(devServerOptions)).Result;
// Proxy the corresponding requests through ASP.NET and into the Node listener
appBuilder.Map(devServerInfo.PublicPath, builder => {
builder.RunProxy(new ProxyOptions {
Host = WebpackDevMiddlewareHostname,
Port = devServerInfo.Port.ToString()
});
});
// While it would be nice to proxy the /__webpack_hmr requests too, these return an EventStream,
// and the Microsoft.Aspnet.Proxy code doesn't handle that entirely - it throws an exception after
// a while. So, just serve a 302 for those.
appBuilder.Map(WebpackHotMiddlewareEndpoint, builder => {
builder.Use(next => async ctx => {
ctx.Response.Redirect($"http://localhost:{ devServerInfo.Port.ToString() }{ WebpackHotMiddlewareEndpoint }");
await Task.Yield();
});
});
}
public static void UseWebpackDevMiddleware(this IApplicationBuilder appBuilder, WebpackDevMiddlewareOptions options = null)
{
// Validate options
if (options != null)
{
if (options.ReactHotModuleReplacement && !options.HotModuleReplacement)
{
throw new ArgumentException("To enable ReactHotModuleReplacement, you must also enable HotModuleReplacement.");
}
}
// Unlike other consumers of NodeServices, WebpackDevMiddleware dosen't share Node instances, nor does it
// use your DI configuration. It's important for WebpackDevMiddleware to have its own private Node instance
// because it must *not* restart when files change (if it did, you'd lose all the benefits of Webpack
// middleware). And since this is a dev-time-only feature, it doesn't matter if the default transport isn't
// as fast as some theoretical future alternative.
var appEnv = (IApplicationEnvironment)appBuilder.ApplicationServices.GetService(typeof(IApplicationEnvironment));
var nodeServices = Configuration.CreateNodeServices(new NodeServicesOptions {
HostingModel = NodeHostingModel.Http,
ProjectPath = appEnv.ApplicationBasePath,
WatchFileExtensions = new string[] {} // Don't watch anything
});
// Get a filename matching the middleware Node script
var script = EmbeddedResourceReader.Read(typeof(WebpackDevMiddleware), "/Content/Node/webpack-dev-middleware.js");
var nodeScript = new StringAsTempFile(script); // Will be cleaned up on process exit
// Tell Node to start the server hosting webpack-dev-middleware
var devServerOptions = new {
webpackConfigPath = Path.Combine(appEnv.ApplicationBasePath, "webpack.config.js"),
suppliedOptions = options ?? new WebpackDevMiddlewareOptions()
};
var devServerInfo = nodeServices.InvokeExport <WebpackDevServerInfo>(nodeScript.FileName, "createWebpackDevServer", JsonConvert.SerializeObject(devServerOptions)).Result;
// Proxy the corresponding requests through ASP.NET and into the Node listener
appBuilder.Map(devServerInfo.PublicPath, builder => {
builder.RunProxy(new ProxyOptions {
Host = WebpackDevMiddlewareHostname,
Port = devServerInfo.Port.ToString()
});
});
// While it would be nice to proxy the /__webpack_hmr requests too, these return an EventStream,
// and the Microsoft.Aspnet.Proxy code doesn't handle that entirely - it throws an exception after
// a while. So, just serve a 302 for those.
appBuilder.Map(WebpackHotMiddlewareEndpoint, builder => {
builder.Use(next => async ctx => {
ctx.Response.Redirect($"http://localhost:{ devServerInfo.Port.ToString() }{ WebpackHotMiddlewareEndpoint }");
await Task.Yield();
});
});
}
private static string GetNodeScriptFilename(CancellationToken applicationStoppingToken)
{
lock (CreateNodeScriptLock)
{
if (NodeScript == null)
{
var script = EmbeddedResourceReader.Read(typeof(Renderer), "/Content/Node/prerenderer.js");
NodeScript = new StringAsTempFile(script, applicationStoppingToken); // Will be cleaned up on process exit
}
}
return(NodeScript.FileName);
}
private static string GetNodeScriptFilename(CancellationToken applicationStoppingToken)
{
lock (CreateNodeScriptLock)
{
if (nodeScript == null)
{
var script = EmbeddedResourceReader.Read(typeof(EmPageRenderer), RendererScriptPath);
nodeScript = new StringAsTempFile(script, applicationStoppingToken);
}
}
return(nodeScript.FileName);
}
public void ShouldReadFoldingWithSinglePanelCorrectly()
{
var singlePanel = new EmbeddedResource(typeof(TestsForXmlModelReader).Assembly, typeof(TestsForXmlModelReader).Namespace + ".SinglePanel.xml");
var xml = _embeddedResourceReader.Read(singlePanel);
var actualFolding = _sut.Read(xml);
var expectedFolding = new XmlModels.Folding {
Items = new[] {
new XmlModels.Item {
PanelId = new Guid("872201A9-2D6E-FD0C-E7E9-A24588D95B5E"),
PanelName = "Dummy Panel",
MinRot = 1,
MaxRot = 2,
InitialRot = 3,
StartRot = 4,
EndRot = 5,
HingeOffset = 6,
PanelWidth = 7,
PanelHeight = 8,
AttachedToSide = 9,
CreaseBottom = 10,
CreaseTop = 11,
CreaseLeft = 12,
CreaseRight = 13,
IgnoreCollisions = true,
MouseEnabled = true,
AttachedPanels = new XmlModels.Item[0]
}
}
};
actualFolding.Should().NotBeNull();
actualFolding.Items.Should().NotBeNull().And.NotBeEmpty();
actualFolding.Items[0].ShouldBeEquivalentTo(expectedFolding.Items[0]);
actualFolding.Items.Should().HaveCount(1);
}
public HttpNodeInstance(NodeServicesOptions options, int port = 0)
: base(
EmbeddedResourceReader.Read(typeof(OutOfProcessNodeInstance), "/Content/Node/entrypoint-http.js"),
options.ProjectPath,
options.WatchFileExtensions,
MakeCommandLineOptions(port),
options.ApplicationStoppingToken,
options.NodeInstanceOutputLogger,
options.EnvironmentVariables,
options.InvocationTimeoutMilliseconds,
options.LaunchWithDebugging,
options.DebuggingPort)
{
_client = new HttpClient();
_client.Timeout = TimeSpan.FromMilliseconds(options.InvocationTimeoutMilliseconds + 1000);
}
public SocketNodeInstance(NodeServicesOptions options, string socketAddress)
: base(
EmbeddedResourceReader.Read(
typeof(SocketNodeInstance),
"/Content/Node/entrypoint-socket.js"),
options.ProjectPath,
options.WatchFileExtensions,
MakeNewCommandLineOptions(socketAddress),
options.ApplicationStoppingToken,
options.NodeInstanceOutputLogger,
options.EnvironmentVariables,
options.InvocationTimeoutMilliseconds,
options.LaunchWithDebugging,
options.DebuggingPort)
{
_socketAddress = socketAddress;
}
public TempScriptDirectory()
{
var directory = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
while (Directory.Exists(directory))
{
directory = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
}
Directory.CreateDirectory(directory);
File.WriteAllText(Path.Combine(directory, "marked.js"),
EmbeddedResourceReader.Read(typeof(TempScriptDirectory), "/Content/Node/marked.js"));
File.WriteAllText(Path.Combine(directory, "markedHelper.js"),
EmbeddedResourceReader.Read(typeof(TempScriptDirectory), "/Content/Node/markedHelper.js"));
File.WriteAllText(Path.Combine(directory, "compile-markdown.js"),
EmbeddedResourceReader.Read(typeof(TempScriptDirectory), "/Content/Node/compile-markdown.js"));
TempDirectory = directory;
CompileScriptPath = Path.Combine(TempDirectory, "compile-markdown.js");
}
protected override void OnWebKitInitialized()
{
base.OnWebKitInitialized();
CefRuntime.RegisterExtension("test",
EmbeddedResourceReader.Read(typeof(Handler), "/Javascript/test_extension.js"), new TestHandler());
}
public static NodeHost Create(string handlerFile, string projectPath, ILogger logger)
{
var hostScript = EmbeddedResourceReader.Read(typeof(NodeHost), "/Content/node-host.js");
return(new NodeHost(hostScript, projectPath, logger, "\"" + handlerFile + "\""));
}
/// <summary>
/// Enables Parcel dev middleware support. This hosts an instance of Parcel in memory
/// in your application so that you can always serve up-to-date Parcel-built resources without having
/// to run it manually. Since Parcel is retained in memory, incremental
/// compilation is vastly faster that re-running it from scratch.
///
/// Incoming requests that match Parcel-built files will be handled by returning the Parcel
/// output directly, regardless of files on disk. If compilation is in progress when the request arrives,
/// the response will pause until updated compiler output is ready.
/// </summary>
/// <param name="appBuilder">The <see cref="IApplicationBuilder"/>.</param>
/// <param name="options">Options for configuring Parcel.</param>
public static void UseParcelDevMiddleware(
this IApplicationBuilder appBuilder,
ParcelBundlerOptions options = null)
{
// Prepare options
if (options == null)
{
options = new ParcelBundlerOptions();
}
// Unlike other consumers of NodeServices, ParcelDevMiddleware dosen't share Node instances, nor does it
// use your DI configuration. It's important for ParcelDevMiddleware to have its own private Node instance
// because it must *not* restart when files change (if it did, you'd lose all the benefits of Parcel
// middleware). And since this is a dev-time-only feature, it doesn't matter if the default transport isn't
// as fast as some theoretical future alternative.
var nodeServicesOptions = new NodeServicesOptions(appBuilder.ApplicationServices);
nodeServicesOptions.WatchFileExtensions = new string[] { }; // Don't watch anything
if (!string.IsNullOrEmpty(options.ProjectPath))
{
nodeServicesOptions.ProjectPath = options.ProjectPath;
}
if (options.EnvironmentVariables != null)
{
foreach (var kvp in options.EnvironmentVariables)
{
nodeServicesOptions.EnvironmentVariables[kvp.Key] = kvp.Value;
}
}
var nodeServices = NodeServicesFactory.CreateNodeServices(nodeServicesOptions);
// Get a filename matching the middleware Node script
//Actual resource name: RudiBech.AspNetCore.SpaServices.Parcel.parcel-dev-middleware.js
var script = EmbeddedResourceReader.Read(typeof(ParcelDevMiddelware), "/parcel-dev-middleware.js");
// Will be cleaned up on process exit
var nodeScript = new StringAsTempFile(script, nodeServicesOptions.ApplicationStoppingToken);
// Tell Node to start the server hosting webpack-dev-middleware
var parcelOptions = new
{
watch = options.Watch,
hmrPort = options.Port,
outDir = options.OutDir,
outFile = options.OutFile,
publicUrl = options.PublicUrl,
cache = options.Cache,
cacheDir = options.CacheDir,
minify = options.Minify,
target = options.Target,
logLevel = (int)options.LogLevel,
sourceMaps = options.SourceMaps,
detailedReport = options.DetailedReport,
entryPoint = options.EntryPoint
};
var devServerInfo =
nodeServices.InvokeExportAsync <ParcelDevServerInfo>(nodeScript.FileName, "createParcelDevServer",
JsonConvert.SerializeObject(parcelOptions, jsonSerializerSettings)).Result;
// Proxy the corresponding requests through ASP.NET and into the Node listener
// Anything under /<publicpath> (e.g., /dist) is proxied as a normal HTTP request with a typical timeout (100s is the default from HttpClient)
foreach (var publicPath in devServerInfo.PublicPaths)
{
appBuilder.UseProxyToLocalParcelDevMiddleware(publicPath, devServerInfo.Port, TimeSpan.FromSeconds(100));
}
}
private void InjectJavaScriptHelpers()
{
var script = _embeddedResourceReader.Read("ChromeChauffeur.Core.Scripts.ChromeChauffeur.js", GetType().Assembly);
Eval(script);
}
/// <summary>
/// Enables Webpack dev middleware support. This hosts an instance of the Webpack compiler in memory
/// in your application so that you can always serve up-to-date Webpack-built resources without having
/// to run the compiler manually. Since the Webpack compiler instance is retained in memory, incremental
/// compilation is vastly faster that re-running the compiler from scratch.
///
/// Incoming requests that match Webpack-built files will be handled by returning the Webpack compiler
/// output directly, regardless of files on disk. If compilation is in progress when the request arrives,
/// the response will pause until updated compiler output is ready.
/// </summary>
/// <param name="appBuilder">The <see cref="IApplicationBuilder"/>.</param>
/// <param name="options">Options for configuring the Webpack compiler instance.</param>
public static void UseWebpackDevMiddleware(
this IApplicationBuilder appBuilder,
WebpackDevMiddlewareOptions options = null)
{
// Prepare options
if (options == null)
{
options = new WebpackDevMiddlewareOptions();
}
// Validate options
if (options.ReactHotModuleReplacement && !options.HotModuleReplacement)
{
throw new ArgumentException(
"To enable ReactHotModuleReplacement, you must also enable HotModuleReplacement.");
}
// Unlike other consumers of NodeServices, WebpackDevMiddleware dosen't share Node instances, nor does it
// use your DI configuration. It's important for WebpackDevMiddleware to have its own private Node instance
// because it must *not* restart when files change (if it did, you'd lose all the benefits of Webpack
// middleware). And since this is a dev-time-only feature, it doesn't matter if the default transport isn't
// as fast as some theoretical future alternative.
var nodeServicesOptions = new NodeServicesOptions(appBuilder.ApplicationServices);
nodeServicesOptions.WatchFileExtensions = new string[] { }; // Don't watch anything
if (!string.IsNullOrEmpty(options.ProjectPath))
{
nodeServicesOptions.ProjectPath = options.ProjectPath;
}
if (options.EnvironmentVariables != null)
{
foreach (var kvp in options.EnvironmentVariables)
{
nodeServicesOptions.EnvironmentVariables[kvp.Key] = kvp.Value;
}
}
var nodeServices = NodeServicesFactory.CreateNodeServices(nodeServicesOptions);
// Get a filename matching the middleware Node script
var script = EmbeddedResourceReader.Read(typeof(WebpackDevMiddleware),
"/Content/Node/webpack-dev-middleware.js");
var nodeScript = new StringAsTempFile(script, nodeServicesOptions.ApplicationStoppingToken); // Will be cleaned up on process exit
// Ideally, this would be relative to the application's PathBase (so it could work in virtual directories)
// but it's not clear that such information exists during application startup, as opposed to within the context
// of a request.
var hmrEndpoint = !string.IsNullOrEmpty(options.HotModuleReplacementEndpoint)
? options.HotModuleReplacementEndpoint
: "/__webpack_hmr"; // Matches webpack's built-in default
// Tell Node to start the server hosting webpack-dev-middleware
var devServerOptions = new
{
webpackConfigPath = Path.Combine(nodeServicesOptions.ProjectPath, options.ConfigFile ?? DefaultConfigFile),
suppliedOptions = options,
understandsMultiplePublicPaths = true,
hotModuleReplacementEndpointUrl = hmrEndpoint
};
var devServerInfo =
nodeServices.InvokeExportAsync <WebpackDevServerInfo>(nodeScript.FileName, "createWebpackDevServer",
JsonConvert.SerializeObject(devServerOptions, jsonSerializerSettings)).Result;
// If we're talking to an older version of aspnet-webpack, it will return only a single PublicPath,
// not an array of PublicPaths. Handle that scenario.
if (devServerInfo.PublicPaths == null)
{
devServerInfo.PublicPaths = new[] { devServerInfo.PublicPath };
}
// Proxy the corresponding requests through ASP.NET and into the Node listener
// Anything under /<publicpath> (e.g., /dist) is proxied as a normal HTTP request with a typical timeout (100s is the default from HttpClient),
// plus /__webpack_hmr is proxied with infinite timeout, because it's an EventSource (long-lived request).
foreach (var publicPath in devServerInfo.PublicPaths)
{
appBuilder.UseProxyToLocalWebpackDevMiddleware(publicPath + hmrEndpoint, devServerInfo.Port, Timeout.InfiniteTimeSpan);
appBuilder.UseProxyToLocalWebpackDevMiddleware(publicPath, devServerInfo.Port, TimeSpan.FromSeconds(100));
}
}