Add SPA middleware APIs to support new templates

Author: SteveSandersonMS

src/Microsoft.AspNetCore.SpaServices/AngularCli/AngularCliBuilder.cs

@@ -0,0 +1,43 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+usingMicrosoft.AspNetCore.SpaServices.Prerendering;
+usingSystem;
+usingSystem.Linq;
+usingSystem.Threading.Tasks;
+
+namespaceMicrosoft.AspNetCore.SpaServices.AngularCli
+{
+/// <summary>
+/// Provides an implementation of <see cref="ISpaPrerendererBuilder"/> that can build
+/// an Angular application by invoking the Angular CLI.
+/// </summary>
+publicclassAngularCliBuilder:ISpaPrerendererBuilder
+{
+privatereadonlystring_cliAppName;
+
+/// <summary>
+/// Constructs an instance of <see cref="AngularCliBuilder"/>.
+/// </summary>
+/// <param name="cliAppName">The name of the application to be built. This must match an entry in your <c>.angular-cli.json</c> file.</param>
+publicAngularCliBuilder(stringcliAppName)
+{
+_cliAppName=cliAppName;
+}
+
+/// <inheritdoc />
+publicTaskBuild(ISpaBuilderspaBuilder)
+{
+// Locate the AngularCliMiddleware within the provided ISpaBuilder
+varangularCliMiddleware=spaBuilder
+.Properties.Keys.OfType<AngularCliMiddleware>().FirstOrDefault();
+if(angularCliMiddleware==null)
+{
+thrownewException(
+$"Cannot use {nameof(AngularCliBuilder)} unless you are also using {nameof(AngularCliMiddleware)}.");
+}
+
+returnangularCliMiddleware.StartAngularCliBuilderAsync(_cliAppName);
+}
+}
+}

src/Microsoft.AspNetCore.SpaServices/AngularCli/AngularCliMiddleware.cs

@@ -0,0 +1,123 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+usingSystem;
+usingSystem.IO;
+usingMicrosoft.AspNetCore.NodeServices;
+usingSystem.Threading.Tasks;
+usingMicrosoft.AspNetCore.Builder;
+usingMicrosoft.AspNetCore.Hosting;
+usingSystem.Threading;
+usingMicrosoft.AspNetCore.SpaServices.Proxy;
+
+namespaceMicrosoft.AspNetCore.SpaServices.AngularCli
+{
+internalclassAngularCliMiddleware
+{
+privateconststring_middlewareResourceName="/Content/Node/angular-cli-middleware.js";
+
+privatereadonlyINodeServices_nodeServices;
+privatereadonlystring_middlewareScriptPath;
+
+publicAngularCliMiddleware(ISpaBuilderspaBuilder,stringsourcePath)
+{
+if(string.IsNullOrEmpty(sourcePath))
+{
+thrownewArgumentException("Cannot be null or empty",nameof(sourcePath));
+}
+
+// Prepare to make calls into Node
+varappBuilder=spaBuilder.AppBuilder;
+_nodeServices=CreateNodeServicesInstance(appBuilder,sourcePath);
+_middlewareScriptPath=GetAngularCliMiddlewareScriptPath(appBuilder);
+
+// Start Angular CLI and attach to middleware pipeline
+varangularCliServerInfoTask=StartAngularCliServerAsync();
+spaBuilder.AddStartupTask(angularCliServerInfoTask);
+
+// 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).
+UseProxyToLocalAngularCliMiddleware(appBuilder,spaBuilder.PublicPath,
+angularCliServerInfoTask,TimeSpan.FromSeconds(100));
+
+// Advertise the availability of this feature to other SPA middleware
+spaBuilder.Properties.Add(this,null);
+}
+
+publicTaskStartAngularCliBuilderAsync(stringcliAppName)
+{
+return_nodeServices.InvokeExportAsync<AngularCliServerInfo>(
+_middlewareScriptPath,
+"startAngularCliBuilder",
+cliAppName);
+}
+
+privatestaticINodeServicesCreateNodeServicesInstance(
+IApplicationBuilderappBuilder,stringsourcePath)
+{
+// Unlike other consumers of NodeServices, AngularCliMiddleware dosen't share Node instances, nor does it
+// use your DI configuration. It's important for AngularCliMiddleware to have its own private Node instance
+// because it must *not* restart when files change (it's designed to watch for changes and rebuild).
+varnodeServicesOptions=newNodeServicesOptions(appBuilder.ApplicationServices)
+{
+WatchFileExtensions=newstring[]{},// Don't watch anything
+ProjectPath=Path.Combine(Directory.GetCurrentDirectory(),sourcePath),
+};
+
+returnNodeServicesFactory.CreateNodeServices(nodeServicesOptions);
+}
+
+privatestaticstringGetAngularCliMiddlewareScriptPath(IApplicationBuilderappBuilder)
+{
+varscript=EmbeddedResourceReader.Read(typeof(AngularCliMiddleware),_middlewareResourceName);
+varnodeScript=newStringAsTempFile(script,GetStoppingToken(appBuilder));
+returnnodeScript.FileName;
+}
+
+privatestaticCancellationTokenGetStoppingToken(IApplicationBuilderappBuilder)
+{
+varapplicationLifetime=appBuilder
+.ApplicationServices
+.GetService(typeof(IApplicationLifetime));
+return((IApplicationLifetime)applicationLifetime).ApplicationStopping;
+}
+
+privateasyncTask<AngularCliServerInfo>StartAngularCliServerAsync()
+{
+// Tell Node to start the server hosting the Angular CLI
+varangularCliServerInfo=await_nodeServices.InvokeExportAsync<AngularCliServerInfo>(
+_middlewareScriptPath,
+"startAngularCliServer");
+
+// Even after the Angular CLI claims to be listening for requests, there's a short
+// period where it will give an error if you make a request too quickly. Give it
+// a moment to finish starting up.
+awaitTask.Delay(500);
+
+returnangularCliServerInfo;
+}
+
+privatestaticvoidUseProxyToLocalAngularCliMiddleware(
+IApplicationBuilderappBuilder,stringpublicPath,
+Task<AngularCliServerInfo>serverInfoTask,TimeSpanrequestTimeout)
+{
+// This is hardcoded to use http://localhost because:
+// - the requests are always from the local machine (we're not accepting remote
+// requests that go directly to the Angular CLI middleware server)
+// - given that, there's no reason to use https, and we couldn't even if we
+// wanted to, because in general the Angular CLI server has no certificate
+varproxyOptionsTask=serverInfoTask.ContinueWith(
+ task =>newConditionalProxyMiddlewareTarget(
+"http","localhost",task.Result.Port.ToString()));
+appBuilder.UseMiddleware<ConditionalProxyMiddleware>(publicPath,requestTimeout,proxyOptionsTask);
+}
+
+#pragma warning disable CS0649
+classAngularCliServerInfo
+{
+publicintPort{get;set;}
+}
+}
+#pragma warning restore CS0649
+}

src/Microsoft.AspNetCore.SpaServices/AngularCli/AngularCliMiddlewareExtensions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespaceMicrosoft.AspNetCore.SpaServices.AngularCli
+{
+/// <summary>
+/// Extension methods for enabling Angular CLI middleware support.
+/// </summary>
+publicstaticclassAngularCliMiddlewareExtensions
+{
+/// <summary>
+/// Enables Angular CLI middleware support. This hosts an instance of the Angular CLI in memory in
+/// your application so that you can always serve up-to-date CLI-built resources without having
+/// to run CLI server manually.
+///
+/// Incoming requests that match Angular CLI-built files will be handled by returning the CLI server
+/// output directly.
+///
+/// This feature should only be used in development. For production deployments, be sure not to
+/// enable Angular CLI middleware.
+/// </summary>
+/// <param name="spaBuilder">The <see cref="ISpaBuilder"/>.</param>
+/// <param name="sourcePath">The path, relative to the application root, of the directory containing the SPA source files.</param>
+publicstaticvoidUseAngularCliMiddleware(
+thisISpaBuilderspaBuilder,
+stringsourcePath)
+{
+newAngularCliMiddleware(spaBuilder,sourcePath);
+}
+}
+}

src/Microsoft.AspNetCore.SpaServices/Content/Node/angular-cli-middleware.js

@@ -0,0 +1,77 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+varchildProcess=require('child_process');
+varnet=require('net');
+varreadline=require('readline');
+varurl=require('url');
+
+module.exports={
+startAngularCliBuilder: functionstartAngularCliBuilder(callback,appName){
+varproc=executeAngularCli([
+'build',
+'-app',appName,
+'--watch'
+]);
+proc.stdout.pipe(process.stdout);
+waitForLine(proc.stdout,/chunk/).then(function(){
+callback();
+});
+},
+
+startAngularCliServer: functionstartAngularCliServer(callback,options){
+getOSAssignedPortNumber().then(function(portNumber){
+// Start @angular/cli dev server on private port, and pipe its output
+// back to the ASP.NET host process.
+// TODO: Support streaming arbitrary chunks to host process's stdout
+// rather than just full lines, so we can see progress being logged
+vardevServerProc=executeAngularCli([
+'serve',
+'--port',portNumber.toString(),
+'--deploy-url','/dist/',// Value should come from .angular-cli.json, but https://github.com/angular/angular-cli/issues/7347
+'--extract-css'
+]);
+devServerProc.stdout.pipe(process.stdout);
+
+// Wait until the CLI dev server is listening before letting ASP.NET start the app
+console.log('Waiting for @angular/cli service to start...');
+waitForLine(devServerProc.stdout,/openyourbrowseron(http\S+)/).then(function(matches){
+vardevServerUrl=url.parse(matches[1]);
+console.log('@angular/cli service has started on internal port '+devServerUrl.port);
+callback(null,{
+Port: parseInt(devServerUrl.port)
+});
+});
+});
+}
+};
+
+functionwaitForLine(stream,regex){
+returnnewPromise(function(resolve,reject){
+varlineReader=readline.createInterface({input: stream});
+lineReader.on('line',function(line){
+varmatches=regex.exec(line);
+if(matches){
+lineReader.close();
+resolve(matches);
+}
+});
+});
+}
+
+functionexecuteAngularCli(args){
+varangularCliBin=require.resolve('@angular/cli/bin/ng');
+returnchildProcess.fork(angularCliBin,args,{
+stdio: [/* stdin */'ignore',/* stdout */'pipe',/* stderr */'inherit','ipc']
+});
+}
+
+functiongetOSAssignedPortNumber(){
+returnnewPromise(function(resolve,reject){
+varserver=net.createServer();
+server.listen(0,'localhost',function(){
+varportNumber=server.address().port;
+server.close(function(){resolve(portNumber);});
+});
+});
+}

src/Microsoft.AspNetCore.SpaServices/DefaultSpaBuilder.cs

@@ -0,0 +1,37 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+usingMicrosoft.AspNetCore.Builder;
+usingMicrosoft.AspNetCore.Http;
+usingSystem.Collections.Generic;
+usingSystem.Threading.Tasks;
+
+namespaceMicrosoft.AspNetCore.SpaServices
+{
+internalclassDefaultSpaBuilder:ISpaBuilder
+{
+privatereadonlyobject_startupTasksLock=newobject();
+
+publicDefaultSpaBuilder(IApplicationBuilderappBuilder,stringpublicPath,PathStringdefaultFilePath)
+{
+AppBuilder=appBuilder;
+DefaultFilePath=defaultFilePath;
+Properties=newDictionary<object,object>();
+PublicPath=publicPath;
+}
+
+publicIApplicationBuilderAppBuilder{get;}
+publicPathStringDefaultFilePath{get;}
+publicIDictionary<object,object>Properties{get;}
+publicstringPublicPath{get;}
+publicTaskStartupTasks{get;privateset;}=Task.CompletedTask;
+
+publicvoidAddStartupTask(Tasktask)
+{
+lock(_startupTasksLock)
+{
+StartupTasks=Task.WhenAll(StartupTasks,task);
+}
+}
+}
+}

src/Microsoft.AspNetCore.SpaServices/ISpaBuilder.cs

@@ -0,0 +1,57 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+usingMicrosoft.AspNetCore.Builder;
+usingMicrosoft.AspNetCore.Http;
+usingSystem.Collections.Generic;
+usingSystem.Threading.Tasks;
+
+namespaceMicrosoft.AspNetCore.SpaServices
+{
+/// <summary>
+/// Defines a class that provides mechanisms to configure a Single Page Application
+/// being hosted by an ASP.NET server.
+/// </summary>
+publicinterfaceISpaBuilder
+{
+/// <summary>
+/// Gets the <see cref="IApplicationBuilder"/> for the host application.
+/// </summary>
+IApplicationBuilderAppBuilder{get;}
+
+/// <summary>
+/// Gets the path to the SPA's default file. By default, this is the file
+/// index.html within the <see cref="PublicPath"/>.
+/// </summary>
+PathStringDefaultFilePath{get;}
+
+/// <summary>
+/// Gets the URL path, relative to the application's <c>PathBase</c>, from which
+/// the SPA files are served.
+///</summary>
+///<example>
+/// If the SPA files are located in <c>wwwroot/dist</c>, then the value would
+/// usually be <c>"dist"</c>, because that is the URL prefix from which clients
+/// can request those files.
+///</example>
+stringPublicPath{get;}
+
+/// <summary>
+/// Gets a key/value collection that can be used to share data between SPA middleware.
+/// </summary>
+IDictionary<object,object>Properties{get;}
+
+/// <summary>
+/// Gets a <see cref="Task"/> that represents the completion of all registered
+/// SPA startup tasks.
+/// </summary>
+TaskStartupTasks{get;}
+
+/// <summary>
+/// Registers a task that represents part of SPA startup process. Middleware
+/// may choose to wait for these tasks to complete before taking some action.
+/// </summary>
+/// <param name="task">The <see cref="Task"/>.</param>
+voidAddStartupTask(Tasktask);
+}
+}

src/Microsoft.AspNetCore.SpaServices/Microsoft.AspNetCore.SpaServices.csproj

@@ -17,6 +17,7 @@
  <ItemGroup>
  <PackageReferenceInclude="Microsoft.AspNetCore.Mvc.TagHelpers" />
  <PackageReferenceInclude="Microsoft.AspNetCore.Mvc.ViewFeatures" />
+ <PackageReferenceInclude="Microsoft.AspNetCore.StaticFiles" />
  </ItemGroup>
 
  <TargetName="PrepublishScript"BeforeTargets="PrepareForPublish"Condition=" '$(IsCrossTargetingBuild)' != 'true' ">