Create new top-level DefaultNodeInstance concept that will soon hold the "connection draining" logic

SteveSandersonMS · SteveSandersonMS · commit 4fb3b18868fb · 2016-07-06T18:23:25.000+01:00
diff --git a/samples/misc/LatencyTest/Program.cs b/samples/misc/LatencyTest/Program.cs
@@ -12,21 +12,21 @@ namespace ConsoleApplication
     public class Program
     {
         public static void Main(string[] args) {
-            using (var nodeServices = CreateNodeServices(Configuration.DefaultNodeHostingModel)) {
+            using (var nodeServices = CreateNodeServices(NodeServicesOptions.DefaultNodeHostingModel)) {
                 MeasureLatency(nodeServices).Wait();
             }
         }
 
         private static async Task MeasureLatency(INodeServices nodeServices) {
             // Ensure the connection is open, so we can measure per-request timings below
-            var response = await nodeServices.Invoke<string>("latencyTest", "C#");
+            var response = await nodeServices.InvokeAsync<string>("latencyTest", "C#");
             Console.WriteLine(response);
 
             // Now perform a series of requests, capturing the time taken
             const int requestCount = 100;
             var watch = Stopwatch.StartNew();
             for (var i = 0; i < requestCount; i++) {
-                await nodeServices.Invoke<string>("latencyTest", "C#");
+                await nodeServices.InvokeAsync<string>("latencyTest", "C#");
             }
 
             // Display results
diff --git a/samples/misc/NodeServicesExamples/Controllers/ResizeImage.cs b/samples/misc/NodeServicesExamples/Controllers/ResizeImage.cs
@@ -46,7 +46,7 @@ public async Task<IActionResult> Index(string imagePath, int maxWidth, int maxHe
             }
 
             // Invoke Node and pipe the result to the response
-            var imageStream = await _nodeServices.Invoke<Stream>(
+            var imageStream = await _nodeServices.InvokeAsync<Stream>(
                 "./Node/resizeImage",
                 fileInfo.PhysicalPath,
                 mimeType,
diff --git a/samples/misc/NodeServicesExamples/Startup.cs b/samples/misc/NodeServicesExamples/Startup.cs
@@ -30,7 +30,7 @@ public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory, IHo
                 if (requestPath.StartsWith("/js/") && requestPath.EndsWith(".js")) {
                     var fileInfo = env.WebRootFileProvider.GetFileInfo(requestPath);
                     if (fileInfo.Exists) {
-                        var transpiled = await nodeServices.Invoke<string>("./Node/transpilation.js", fileInfo.PhysicalPath, requestPath);
+                        var transpiled = await nodeServices.InvokeAsync<string>("./Node/transpilation.js", fileInfo.PhysicalPath, requestPath);
                         await context.Response.WriteAsync(transpiled);
                         return;
                     }
diff --git a/src/Microsoft.AspNetCore.NodeServices/Configuration.cs b/src/Microsoft.AspNetCore.NodeServices/Configuration.cs
diff --git a/src/Microsoft.AspNetCore.NodeServices/Configuration/Configuration.cs b/src/Microsoft.AspNetCore.NodeServices/Configuration/Configuration.cs
@@ -0,0 +1,58 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.NodeServices.HostingModels;
+
+namespace Microsoft.AspNetCore.NodeServices
+{
+    public static class Configuration
+    {
+        public static void AddNodeServices(this IServiceCollection serviceCollection)
+            => AddNodeServices(serviceCollection, new NodeServicesOptions());
+
+        public static void AddNodeServices(this IServiceCollection serviceCollection, NodeServicesOptions options)
+        {
+            serviceCollection.AddSingleton(typeof(INodeServices), serviceProvider =>
+            {
+                // Since this instance is being created through DI, we can access the IHostingEnvironment
+                // to populate options.ProjectPath if it wasn't explicitly specified.
+                var hostEnv = serviceProvider.GetRequiredService<IHostingEnvironment>();
+                if (string.IsNullOrEmpty(options.ProjectPath))
+                {
+                    options.ProjectPath = hostEnv.ContentRootPath;
+                }
+
+                return new NodeServicesImpl(options, () => CreateNodeInstance(options));
+            });
+        }
+
+        public static INodeServices CreateNodeServices(NodeServicesOptions options)
+        {
+            return new NodeServicesImpl(options, () => CreateNodeInstance(options));
+        }
+
+        private static INodeInstance CreateNodeInstance(NodeServicesOptions options)
+        {
+            if (options.NodeInstanceFactory != null)
+            {
+                // If you've explicitly supplied an INodeInstance factory, we'll use that. This is useful for
+                // custom INodeInstance implementations.
+                return options.NodeInstanceFactory();
+            }
+            else
+            {
+                // Otherwise we'll construct the type of INodeInstance specified by the HostingModel property,
+                // which itself has a useful default value.
+                switch (options.HostingModel)
+                {
+                    case NodeHostingModel.Http:
+                        return new HttpNodeInstance(options.ProjectPath, /* port */ 0, options.WatchFileExtensions);
+                    case NodeHostingModel.Socket:
+                        return new SocketNodeInstance(options.ProjectPath, options.WatchFileExtensions);
+                    default:
+                        throw new ArgumentException("Unknown hosting model: " + options.HostingModel);
+                }
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.AspNetCore.NodeServices/Configuration/NodeHostingModel.cs b/src/Microsoft.AspNetCore.NodeServices/Configuration/NodeHostingModel.cs
diff --git a/src/Microsoft.AspNetCore.NodeServices/Configuration/NodeServicesOptions.cs b/src/Microsoft.AspNetCore.NodeServices/Configuration/NodeServicesOptions.cs
@@ -0,0 +1,23 @@
+using System;
+using Microsoft.AspNetCore.NodeServices.HostingModels;
+
+namespace Microsoft.AspNetCore.NodeServices
+{
+    public class NodeServicesOptions
+    {
+        public const NodeHostingModel DefaultNodeHostingModel = NodeHostingModel.Http;
+
+        private static readonly string[] DefaultWatchFileExtensions = { ".js", ".jsx", ".ts", ".tsx", ".json", ".html" };
+
+        public NodeServicesOptions()
+        {
+            HostingModel = DefaultNodeHostingModel;
+            WatchFileExtensions = (string[])DefaultWatchFileExtensions.Clone();
+        }
+
+        public NodeHostingModel HostingModel { get; set; }
+        public Func<INodeInstance> NodeInstanceFactory { get; set; }
+        public string ProjectPath { get; set; }
+        public string[] WatchFileExtensions { get; set; }
+    }
+}
diff --git a/src/Microsoft.AspNetCore.NodeServices/HostingModels/HttpNodeInstance.cs b/src/Microsoft.AspNetCore.NodeServices/HostingModels/HttpNodeInstance.cs
@@ -7,7 +7,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
-namespace Microsoft.AspNetCore.NodeServices
+namespace Microsoft.AspNetCore.NodeServices.HostingModels
 {
     internal class HttpNodeInstance : OutOfProcessNodeInstance
     {
@@ -45,7 +45,7 @@ private static string MakeCommandLineOptions(int port, string[] watchFileExtensi
             return result;
         }
 
-        public override async Task<T> Invoke<T>(NodeInvocationInfo invocationInfo)
+        protected override async Task<T> InvokeExportAsync<T>(NodeInvocationInfo invocationInfo)
         {
             await EnsureReady();
 
diff --git a/src/Microsoft.AspNetCore.NodeServices/HostingModels/INodeInstance.cs b/src/Microsoft.AspNetCore.NodeServices/HostingModels/INodeInstance.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.NodeServices.HostingModels
+{
+    public interface INodeInstance : IDisposable
+    {
+        Task<T> InvokeExportAsync<T>(string moduleName, string exportNameOrNull, params object[] args);
+    }
+}
diff --git a/src/Microsoft.AspNetCore.NodeServices/HostingModels/NodeInvocationException.cs b/src/Microsoft.AspNetCore.NodeServices/HostingModels/NodeInvocationException.cs
@@ -1,6 +1,6 @@
 using System;
 
-namespace Microsoft.AspNetCore.NodeServices
+namespace Microsoft.AspNetCore.NodeServices.HostingModels
 {
     public class NodeInvocationException : Exception
     {
diff --git a/src/Microsoft.AspNetCore.NodeServices/HostingModels/NodeInvocationInfo.cs b/src/Microsoft.AspNetCore.NodeServices/HostingModels/NodeInvocationInfo.cs
@@ -1,4 +1,4 @@
-namespace Microsoft.AspNetCore.NodeServices
+namespace Microsoft.AspNetCore.NodeServices.HostingModels
 {
     public class NodeInvocationInfo
     {
diff --git a/src/Microsoft.AspNetCore.NodeServices/HostingModels/OutOfProcessNodeInstance.cs b/src/Microsoft.AspNetCore.NodeServices/HostingModels/OutOfProcessNodeInstance.cs
@@ -3,14 +3,14 @@
 using System.IO;
 using System.Threading.Tasks;
 
-namespace Microsoft.AspNetCore.NodeServices
+namespace Microsoft.AspNetCore.NodeServices.HostingModels
 {
     /// <summary>
     /// Class responsible for launching the Node child process, determining when it is ready to accept invocations,
     /// and finally killing it when the parent process exits. Also it restarts the child process if it dies.
     /// </summary>
-    /// <seealso cref="Microsoft.AspNetCore.NodeServices.INodeServices" />
-    public abstract class OutOfProcessNodeInstance : INodeServices
+    /// <seealso cref="Microsoft.AspNetCore.NodeServices.INodeInstance" />
+    public abstract class OutOfProcessNodeInstance : INodeInstance
     {
         private readonly object _childProcessLauncherLock;
         private string _commandLineArguments;
@@ -34,15 +34,12 @@ public string CommandLineArguments
             set { _commandLineArguments = value; }
         }
 
-        public Task<T> Invoke<T>(string moduleName, params object[] args)
-            => InvokeExport<T>(moduleName, null, args);
-
-        public Task<T> InvokeExport<T>(string moduleName, string exportedFunctionName, params object[] args)
+        public Task<T> InvokeExportAsync<T>(string moduleName, string exportNameOrNull, params object[] args)
         {
-            return Invoke<T>(new NodeInvocationInfo
+            return InvokeExportAsync<T>(new NodeInvocationInfo
             {
                 ModuleName = moduleName,
-                ExportedFunctionName = exportedFunctionName,
+                ExportedFunctionName = exportNameOrNull,
                 Args = args
             });
         }
@@ -53,7 +50,7 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
-        public abstract Task<T> Invoke<T>(NodeInvocationInfo invocationInfo);
+        protected abstract Task<T> InvokeExportAsync<T>(NodeInvocationInfo invocationInfo);
 
         protected void ExitNodeProcess()
         {
diff --git a/src/Microsoft.AspNetCore.NodeServices/HostingModels/SocketNodeInstance.cs b/src/Microsoft.AspNetCore.NodeServices/HostingModels/SocketNodeInstance.cs
@@ -8,7 +8,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
-namespace Microsoft.AspNetCore.NodeServices
+namespace Microsoft.AspNetCore.NodeServices.HostingModels
 {
     internal class SocketNodeInstance : OutOfProcessNodeInstance
     {
@@ -32,7 +32,7 @@ public SocketNodeInstance(string projectPath, string[] watchFileExtensions = nul
             _watchFileExtensions = watchFileExtensions;
 		}
 
-        public override async Task<T> Invoke<T>(NodeInvocationInfo invocationInfo)
+        protected override async Task<T> InvokeExportAsync<T>(NodeInvocationInfo invocationInfo)
         {
             await EnsureReady();
             var virtualConnectionClient = await GetOrCreateVirtualConnectionClientAsync();
diff --git a/src/Microsoft.AspNetCore.NodeServices/INodeServices.cs b/src/Microsoft.AspNetCore.NodeServices/INodeServices.cs
@@ -5,8 +5,14 @@ namespace Microsoft.AspNetCore.NodeServices
 {
     public interface INodeServices : IDisposable
     {
+        Task<T> InvokeAsync<T>(string moduleName, params object[] args);
+
+        Task<T> InvokeExportAsync<T>(string moduleName, string exportedFunctionName, params object[] args);
+
+        [Obsolete("Use InvokeAsync instead")]
         Task<T> Invoke<T>(string moduleName, params object[] args);
 
+        [Obsolete("Use InvokeExportAsync instead")]
         Task<T> InvokeExport<T>(string moduleName, string exportedFunctionName, params object[] args);
     }
-}
+}
diff --git a/src/Microsoft.AspNetCore.NodeServices/NodeServicesImpl.cs b/src/Microsoft.AspNetCore.NodeServices/NodeServicesImpl.cs
@@ -0,0 +1,92 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.NodeServices.HostingModels;
+
+namespace Microsoft.AspNetCore.NodeServices
+{
+    /// <summary>
+    /// Default implementation of INodeServices. This is the primary API surface through which developers
+    /// make use of this package. It provides simple "InvokeAsync" methods that dispatch calls to the
+    /// correct Node instance, creating and destroying those instances as needed.
+    ///
+    /// If a Node instance dies (or none was yet created), this class takes care of creating a new one.
+    /// If a Node instance signals that it needs to be restarted (e.g., because a file changed), then this
+    /// class will create a new instance and dispatch future calls to it, while keeping the old instance
+    /// alive for a defined period so that any in-flight RPC calls can complete. This latter feature is
+    /// analogous to the "connection draining" feature implemented by HTTP load balancers.
+    ///
+    /// TODO: Implement everything in the preceding paragraph.
+    /// </summary>
+    /// <seealso cref="Microsoft.AspNetCore.NodeServices.INodeServices" />
+    internal class NodeServicesImpl : INodeServices
+    {
+        private NodeServicesOptions _options;
+        private Func<INodeInstance> _nodeInstanceFactory;
+        private INodeInstance _currentNodeInstance;
+        private object _currentNodeInstanceAccessLock = new object();
+
+        internal NodeServicesImpl(NodeServicesOptions options, Func<INodeInstance> nodeInstanceFactory)
+        {
+            _options = options;
+            _nodeInstanceFactory = nodeInstanceFactory;
+        }
+
+        public Task<T> InvokeAsync<T>(string moduleName, params object[] args)
+        {
+            return InvokeExportAsync<T>(moduleName, null, args);
+        }
+
+        public Task<T> InvokeExportAsync<T>(string moduleName, string exportedFunctionName, params object[] args)
+        {
+            var nodeInstance = GetOrCreateCurrentNodeInstance();
+            return nodeInstance.InvokeExportAsync<T>(moduleName, exportedFunctionName, args);
+        }
+
+        public void Dispose()
+        {
+            lock (_currentNodeInstanceAccessLock)
+            {
+                if (_currentNodeInstance != null)
+                {
+                    _currentNodeInstance.Dispose();
+                    _currentNodeInstance = null;
+                }
+            }
+        }
+
+        private INodeInstance GetOrCreateCurrentNodeInstance()
+        {
+            var instance = _currentNodeInstance;
+            if (instance == null)
+            {
+                lock (_currentNodeInstanceAccessLock)
+                {
+                    instance = _currentNodeInstance;
+                    if (instance == null)
+                    {
+                        instance = _currentNodeInstance = CreateNewNodeInstance();
+                    }
+                }
+            }
+
+            return instance;
+        }
+
+        private INodeInstance CreateNewNodeInstance()
+        {
+            return _nodeInstanceFactory();
+        }
+
+        // Obsolete method - will be removed soon
+        public Task<T> Invoke<T>(string moduleName, params object[] args)
+        {
+            return InvokeAsync<T>(moduleName, args);
+        }
+
+        // Obsolete method - will be removed soon
+        public Task<T> InvokeExport<T>(string moduleName, string exportedFunctionName, params object[] args)
+        {
+            return InvokeExportAsync<T>(moduleName, exportedFunctionName, args);
+        }
+    }
+}
diff --git a/src/Microsoft.AspNetCore.NodeServices/NodeServicesOptions.cs b/src/Microsoft.AspNetCore.NodeServices/NodeServicesOptions.cs
diff --git a/src/Microsoft.AspNetCore.SpaServices/Prerendering/PrerenderTagHelper.cs b/src/Microsoft.AspNetCore.SpaServices/Prerendering/PrerenderTagHelper.cs
diff --git a/src/Microsoft.AspNetCore.SpaServices/Prerendering/Prerenderer.cs b/src/Microsoft.AspNetCore.SpaServices/Prerendering/Prerenderer.cs
diff --git a/src/Microsoft.AspNetCore.SpaServices/Webpack/WebpackDevMiddleware.cs b/src/Microsoft.AspNetCore.SpaServices/Webpack/WebpackDevMiddleware.cs

Original file line number	Diff line number	Diff line change
`@@ -12,21 +12,21 @@ namespace ConsoleApplication`
`12`	`12`	`public class Program`
`13`	`13`	`{`
`14`	`14`	`public static void Main(string[] args) {`
`15`		`- using (var nodeServices = CreateNodeServices(Configuration.DefaultNodeHostingModel)) {`
	`15`	`+ using (var nodeServices = CreateNodeServices(NodeServicesOptions.DefaultNodeHostingModel)) {`
`16`	`16`	`MeasureLatency(nodeServices).Wait();`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`private static async Task MeasureLatency(INodeServices nodeServices) {`
`21`	`21`	`// Ensure the connection is open, so we can measure per-request timings below`
`22`		`- var response = await nodeServices.Invoke<string>("latencyTest", "C#");`
	`22`	`+ var response = await nodeServices.InvokeAsync<string>("latencyTest", "C#");`
`23`	`23`	`Console.WriteLine(response);`
`24`	`24`
`25`	`25`	`// Now perform a series of requests, capturing the time taken`
`26`	`26`	`const int requestCount = 100;`
`27`	`27`	`var watch = Stopwatch.StartNew();`
`28`	`28`	`for (var i = 0; i < requestCount; i++) {`
`29`		`- await nodeServices.Invoke<string>("latencyTest", "C#");`
	`29`	`+ await nodeServices.InvokeAsync<string>("latencyTest", "C#");`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`// Display results`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ public async Task<IActionResult> Index(string imagePath, int maxWidth, int maxHe`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`// Invoke Node and pipe the result to the response`
`49`		`- var imageStream = await _nodeServices.Invoke<Stream>(`
	`49`	`+ var imageStream = await _nodeServices.InvokeAsync<Stream>(`
`50`	`50`	`"./Node/resizeImage",`
`51`	`51`	`fileInfo.PhysicalPath,`
`52`	`52`	`mimeType,`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory, IHo`
`30`	`30`	`if (requestPath.StartsWith("/js/") && requestPath.EndsWith(".js")) {`
`31`	`31`	`var fileInfo = env.WebRootFileProvider.GetFileInfo(requestPath);`
`32`	`32`	`if (fileInfo.Exists) {`
`33`		`- var transpiled = await nodeServices.Invoke<string>("./Node/transpilation.js", fileInfo.PhysicalPath, requestPath);`
	`33`	`+ var transpiled = await nodeServices.InvokeAsync<string>("./Node/transpilation.js", fileInfo.PhysicalPath, requestPath);`
`34`	`34`	`await context.Response.WriteAsync(transpiled);`
`35`	`35`	`return;`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`using Newtonsoft.Json;`
`8`	`8`	`using Newtonsoft.Json.Serialization;`
`9`	`9`
`10`		`-namespace Microsoft.AspNetCore.NodeServices`
	`10`	`+namespace Microsoft.AspNetCore.NodeServices.HostingModels`
`11`	`11`	`{`
`12`	`12`	`internal class HttpNodeInstance : OutOfProcessNodeInstance`
`13`	`13`	`{`
`@@ -45,7 +45,7 @@ private static string MakeCommandLineOptions(int port, string[] watchFileExtensi`
`45`	`45`	`return result;`
`46`	`46`	`}`
`47`	`47`
`48`		`- public override async Task<T> Invoke<T>(NodeInvocationInfo invocationInfo)`
	`48`	`+ protected override async Task<T> InvokeExportAsync<T>(NodeInvocationInfo invocationInfo)`
`49`	`49`	`{`
`50`	`50`	`await EnsureReady();`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`
`3`		`-namespace Microsoft.AspNetCore.NodeServices`
	`3`	`+namespace Microsoft.AspNetCore.NodeServices.HostingModels`
`4`	`4`	`{`
`5`	`5`	`public class NodeInvocationException : Exception`
`6`	`6`	`{`