Initial state

Microsoft.AspNet.NodeServices/.gitignore

@@ -0,0 +1 @@
+/bin/

Microsoft.AspNet.NodeServices/Content/Node/entrypoint-http.js

@@ -0,0 +1,62 @@
+var path = require('path');
+var express = require('express');
+var bodyParser = require('body-parser')
+var requestedPortOrZero = parseInt(process.argv[2]) || 0; // 0 means 'let the OS decide'
+
+autoQuitOnFileChange(process.cwd(), ['.js', '.json', '.html']);
+
+var app = express();
+app.use(bodyParser.json());
+
+app.all('/', function (req, res) {
+    var resolvedPath = path.resolve(process.cwd(), req.body.moduleName);
+    var invokedModule = require(resolvedPath);
+    var func = req.body.exportedFunctionName ? invokedModule[req.body.exportedFunctionName] : invokedModule;
+    if (!func) {
+        throw new Error('The module "' + resolvedPath + '" has no export named "' + req.body.exportedFunctionName + '"');
+    }
+    
+    var hasSentResult = false;
+    var callback = function(errorValue, successValue) {
+        if (!hasSentResult) {
+            hasSentResult = true;
+            if (errorValue) {
+                res.status(500).send(errorValue);
+            } else {
+                sendResult(res, successValue);
+            }
+        }
+    };
+    
+    func.apply(null, [callback].concat(req.body.args));
+});
+
+var listener = app.listen(requestedPortOrZero, 'localhost', function () {
+    // Signal to HttpNodeHost which port it should make its HTTP connections on
+    console.log('[Microsoft.AspNet.NodeServices.HttpNodeHost:Listening on port ' + listener.address().port + '\]');
+    
+    // Signal to the NodeServices base class that we're ready to accept invocations
+    console.log('[Microsoft.AspNet.NodeServices:Listening]');
+});
+
+function sendResult(response, result) {
+    if (typeof result === 'object') {
+        response.json(result);
+    } else {
+        response.send(result);
+    }
+}
+
+function autoQuitOnFileChange(rootDir, extensions) {
+    // Note: This will only work on Windows/OS X, because the 'recursive' option isn't supported on Linux.
+    // Consider using a different watch mechanism (though ideally without forcing further NPM dependencies).
+    var fs = require('fs');
+    var path = require('path');
+    fs.watch(rootDir, { persistent: false, recursive: true }, function(event, filename) {
+        var ext = path.extname(filename);
+        if (extensions.indexOf(ext) >= 0) {
+            console.log('Restarting due to file change: ' + filename);
+            process.exit(0);
+        }
+    });
+}

Microsoft.AspNet.NodeServices/Content/Node/entrypoint-stream.js

@@ -0,0 +1,23 @@
+var path = require('path');
+var readline = require('readline');
+var invocationPrefix = 'invoke:';
+
+function invocationCallback(errorValue, successValue) {
+    if (errorValue) {
+        throw new Error('InputOutputStreamHost doesn\'t support errors. Got error: ' + errorValue.toString());
+    } else {
+        var serializedResult = typeof successValue === 'object' ? JSON.stringify(successValue) : successValue;
+        console.log(serializedResult);
+    }
+}
+
+readline.createInterface({ input: process.stdin }).on('line', function (message) {
+  if (message && message.substring(0, invocationPrefix.length) === invocationPrefix) {  
+    var invocation = JSON.parse(message.substring(invocationPrefix.length));
+    var invokedModule = require(path.resolve(process.cwd(), invocation.moduleName));
+    var func = invocation.exportedFunctionName ? invokedModule[invocation.exportedFunctionName] : invokedModule;
+    func.apply(null, [invocationCallback].concat(invocation.args));
+  }
+});
+
+console.log('[Microsoft.AspNet.NodeServices:Listening]'); // The .NET app waits for this signal before sending any invocations

Microsoft.AspNet.NodeServices/HostingModels/EmbeddedResourceReader.cs

@@ -0,0 +1,17 @@
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace Microsoft.AspNet.NodeServices {
+    public static class EmbeddedResourceReader {
+        public static string Read(Type assemblyContainingType, string path) {        
+            var asm = assemblyContainingType.GetTypeInfo().Assembly;
+            var embeddedResourceName = asm.GetName().Name + path.Replace("/", ".");
+    
+            using (var stream = asm.GetManifestResourceStream(embeddedResourceName))
+            using (var sr = new StreamReader(stream)) {
+                return sr.ReadToEnd();
+            }
+        }
+    }
+}

Microsoft.AspNet.NodeServices/HostingModels/HttpNodeHost.cs

@@ -0,0 +1,50 @@
+using System.Net.Http;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace Microsoft.AspNet.NodeServices {
+	internal class HttpNodeHost : OutOfProcessNodeRunner {
+        private readonly static Regex PortMessageRegex = new Regex(@"^\[Microsoft.AspNet.NodeServices.HttpNodeHost:Listening on port (\d+)\]$");
+        
+		private readonly static JsonSerializerSettings jsonSerializerSettings =  new JsonSerializerSettings { 
+            ContractResolver = new CamelCasePropertyNamesContractResolver() 
+        };
+        
+        private int _portNumber;
+		
+		public HttpNodeHost(int port = 0)
+            : base(EmbeddedResourceReader.Read(typeof(HttpNodeHost), "/Content/Node/entrypoint-http.js"), port.ToString())
+        {
+		}
+        
+        public override async Task<string> Invoke(NodeInvocationInfo invocationInfo) {
+            await this.EnsureReady();
+            
+            using (var client = new HttpClient()) {
+                // TODO: Use System.Net.Http.Formatting (PostAsJsonAsync etc.)
+                var payloadJson = JsonConvert.SerializeObject(invocationInfo, jsonSerializerSettings);
+                var payload = new StringContent(payloadJson, Encoding.UTF8, "application/json");
+                var response = await client.PostAsync("http://localhost:" + this._portNumber, payload);
+                var responseString = await response.Content.ReadAsStringAsync();
+                return responseString;
+            }
+        }
+        
+        protected override void OnOutputDataReceived(string outputData) {
+            var match = this._portNumber != 0 ? null : PortMessageRegex.Match(outputData);
+            if (match != null && match.Success) {
+                this._portNumber = int.Parse(match.Groups[1].Captures[0].Value);
+            } else {
+                base.OnOutputDataReceived(outputData);
+            }
+        }
+        
+        protected override void OnBeforeLaunchProcess() {
+            // Prepare to receive a new port number
+            this._portNumber = 0;
+        }
+    }
+}

Microsoft.AspNet.NodeServices/HostingModels/InputOutputStreamNodeHost.cs

@@ -0,0 +1,57 @@
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace Microsoft.AspNet.NodeServices {
+    // This is just to demonstrate that other transports are possible. This implementation is extremely
+    // dubious - if the Node-side code fails to conform to the expected protocol in any way (e.g., has an
+    // error), then it will just hang forever. So don't use this.
+    //
+    // But it's fast - the communication round-trip time is about 0.2ms (tested on OS X on a recent machine),
+    // versus 2-3ms for the HTTP transport.
+    //
+    // Instead of directly using stdin/stdout, we could use either regular sockets (TCP) or use named pipes
+    // on Windows and domain sockets on Linux / OS X, but either way would need a system for framing the
+    // requests, associating them with responses, and scheduling use of the comms channel.
+    internal class InputOutputStreamNodeHost : OutOfProcessNodeRunner
+    {
+        private SemaphoreSlim _invocationSemaphore = new SemaphoreSlim(1);
+        private TaskCompletionSource<string> _currentInvocationResult;
+        
+        private readonly static JsonSerializerSettings jsonSerializerSettings =  new JsonSerializerSettings { 
+            ContractResolver = new CamelCasePropertyNamesContractResolver() 
+        };
+		
+		public InputOutputStreamNodeHost()
+            : base(EmbeddedResourceReader.Read(typeof(InputOutputStreamNodeHost), "/Content/Node/entrypoint-stream.js"))
+        {
+		}
+        
+        public override async Task<string> Invoke(NodeInvocationInfo invocationInfo) {
+            await this._invocationSemaphore.WaitAsync();
+            try {
+                await this.EnsureReady();
+                
+                var payloadJson = JsonConvert.SerializeObject(invocationInfo, jsonSerializerSettings);
+                var nodeProcess = this.NodeProcess;
+                this._currentInvocationResult = new TaskCompletionSource<string>();
+                nodeProcess.StandardInput.Write("\ninvoke:");
+                nodeProcess.StandardInput.WriteLine(payloadJson); // WriteLineAsync isn't supported cross-platform
+                return await this._currentInvocationResult.Task;
+            } finally {
+                this._invocationSemaphore.Release();
+                this._currentInvocationResult = null;
+            }
+        }
+        
+        protected override void OnOutputDataReceived(string outputData) {
+            if (this._currentInvocationResult != null) {
+                this._currentInvocationResult.SetResult(outputData);
+            } else {
+                base.OnOutputDataReceived(outputData);
+            }
+        }
+    }
+}

Microsoft.AspNet.NodeServices/HostingModels/NodeHost.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNet.NodeServices {
+    public abstract class NodeHost : System.IDisposable
+    {
+        public abstract Task<string> Invoke(NodeInvocationInfo invocationInfo);
+        
+        public abstract void Dispose();
+    }
+}

Microsoft.AspNet.NodeServices/HostingModels/NodeInvocationInfo.cs

@@ -0,0 +1,8 @@
+namespace Microsoft.AspNet.NodeServices {
+    public class NodeInvocationInfo
+    {
+        public string ModuleName;
+        public string ExportedFunctionName;
+        public object[] Args;
+    }
+}

Microsoft.AspNet.NodeServices/HostingModels/OutOfProcessNodeRunner.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNet.NodeServices {
+    /**
+     * 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.
+     */
+    internal abstract class OutOfProcessNodeRunner : NodeHost {
+        private object _childProcessLauncherLock;
+        private bool disposed;
+        private StringAsTempFile _entryPointScript;
+        private string _commandLineArguments;
+        private Process _nodeProcess;
+        private TaskCompletionSource<bool> _nodeProcessIsReadySource;
+        
+        protected Process NodeProcess {
+            get {
+                // This is only exposed to support the UnreliableStreamNodeHost, which is just to verify that
+                // other hosting/transport mechanisms are possible. This shouldn't really be exposed.
+                return this._nodeProcess;
+            }
+        }
+        
+        public OutOfProcessNodeRunner(string entryPointScript, string commandLineArguments = null)
+        {
+            this._childProcessLauncherLock = new object();
+            this._entryPointScript = new StringAsTempFile(entryPointScript);
+            this._commandLineArguments = commandLineArguments ?? string.Empty;
+        }
+        
+        protected async Task EnsureReady() {
+            lock (this._childProcessLauncherLock) {
+                if (this._nodeProcess == null || this._nodeProcess.HasExited) {
+                    var startInfo = new ProcessStartInfo("node") {
+                        Arguments = this._entryPointScript.FileName + " " + this._commandLineArguments,
+                        UseShellExecute = false,
+                        RedirectStandardInput = true,
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true
+                    };
+                    
+                    // Append current directory to NODE_PATH so it can locate node_modules
+                    var existingNodePath = Environment.GetEnvironmentVariable("NODE_PATH") ?? string.Empty;
+                    if (existingNodePath != string.Empty) {
+                        existingNodePath += ":";
+                    }
+                    
+                    var nodePathValue = existingNodePath + Path.Combine(Directory.GetCurrentDirectory(), "node_modules");
+                    #if DNX451
+                    startInfo.EnvironmentVariables.Add("NODE_PATH", nodePathValue);
+                    #else
+                    startInfo.Environment.Add("NODE_PATH", nodePathValue);
+                    #endif
+                    
+                    this.OnBeforeLaunchProcess();
+                    this._nodeProcess = Process.Start(startInfo);
+                    this.ConnectToInputOutputStreams();
+                }
+            }
+            
+            var initializationSucceeded = await this._nodeProcessIsReadySource.Task;
+            if (!initializationSucceeded) {
+                throw new InvalidOperationException("The Node.js process failed to initialize");
+            }
+        }
+        
+        private void ConnectToInputOutputStreams() {
+            var initializationIsCompleted = false; // TODO: Make this thread-safe? (Interlocked.Exchange etc.)
+            this._nodeProcessIsReadySource = new TaskCompletionSource<bool>();
+            
+            this._nodeProcess.OutputDataReceived += (sender, evt) => {
+                if (evt.Data == "[Microsoft.AspNet.NodeServices:Listening]" && !initializationIsCompleted) {
+                    this._nodeProcessIsReadySource.SetResult(true);
+                    initializationIsCompleted = true;
+                } else if (evt.Data != null) {
+                    this.OnOutputDataReceived(evt.Data);
+                }
+            };
+
+            this._nodeProcess.ErrorDataReceived += (sender, evt) => {
+                if (evt.Data != null) {
+                    this.OnErrorDataReceived(evt.Data);
+                    if (!initializationIsCompleted) {
+                        this._nodeProcessIsReadySource.SetResult(false);
+                        initializationIsCompleted = true;
+                    }
+                }
+            };
+                                
+            this._nodeProcess.BeginOutputReadLine();
+            this._nodeProcess.BeginErrorReadLine();            
+        }
+        
+        protected virtual void OnBeforeLaunchProcess() {
+        }
+
+        protected virtual void OnOutputDataReceived(string outputData) {
+            Console.WriteLine("[Node] " + outputData);
+        }
+        
+        protected virtual void OnErrorDataReceived(string errorData) {
+            Console.WriteLine("[Node] " + errorData);
+        }
+        
+        public override void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+    
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposed) {
+                if (disposing) {
+                    this._entryPointScript.Dispose();
+                }
+                
+                if (this._nodeProcess != null && !this._nodeProcess.HasExited) {
+                    this._nodeProcess.Kill(); // TODO: Is there a more graceful way to end it? Or does this still let it perform any cleanup?                    System.Console.WriteLine("Killed");
+                }
+                
+                disposed = true;
+            }
+        }
+    
+        ~OutOfProcessNodeRunner() {
+            Dispose (false);
+        }
+    }
+}

Microsoft.AspNet.NodeServices/NodeHostingModel.cs

@@ -0,0 +1,6 @@
+namespace Microsoft.AspNet.NodeServices {
+    public enum NodeHostingModel {
+        Http,
+        InputOutputStream,
+    }
+}

Microsoft.AspNet.NodeServices/NodeInstance.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNet.NodeServices {
+    public class NodeInstance : IDisposable {
+        private readonly NodeHost _nodeHost;
+    
+        public NodeInstance(NodeHostingModel hostingModel = NodeHostingModel.Http) {
+            switch (hostingModel) {
+                case NodeHostingModel.Http:
+                    this._nodeHost = new HttpNodeHost();
+                    break;
+                case NodeHostingModel.InputOutputStream:
+                    this._nodeHost = new InputOutputStreamNodeHost();
+                    break;
+                default:
+                    throw new ArgumentException("Unknown hosting model: " + hostingModel.ToString());
+            }
+        }
+    
+        public Task<string> Invoke(string moduleName, params object[] args) {
+            return this.InvokeExport(moduleName, null, args);
+        }
+    
+        public async Task<string> InvokeExport(string moduleName, string exportedFunctionName, params object[] args) {
+            return await this._nodeHost.Invoke(new NodeInvocationInfo {
+                ModuleName = moduleName,
+                ExportedFunctionName = exportedFunctionName,
+                Args = args
+            });
+        }
+    
+        public void Dispose()
+        {
+            this._nodeHost.Dispose();
+        }
+    }
+}

Microsoft.AspNet.NodeServices/StringAsTempFile.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+
+namespace Microsoft.AspNet.NodeServices {
+    // Makes it easier to pass script files to Node in a way that's sure to clean up after the process exits
+    public sealed class StringAsTempFile : IDisposable {
+        public string FileName { get; private set; }
+
+        private bool _disposedValue;
+        
+        public StringAsTempFile(string content) {
+            this.FileName = Path.GetTempFileName();
+            File.WriteAllText(this.FileName, content);
+        }
+
+        private void DisposeImpl(bool disposing)
+        {
+            if (!_disposedValue) {
+                if (disposing) {
+                    // TODO: dispose managed state (managed objects).
+                }
+
+                File.Delete(this.FileName);
+
+                _disposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            DisposeImpl(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~StringAsTempFile() {
+           DisposeImpl(false);
+        }
+    }
+}

Microsoft.AspNet.NodeServices/project.json

@@ -0,0 +1,34 @@
+{
+  "version": "1.0.0-alpha1",
+  "description": "Microsoft.AspNet.NodeServices",
+  "authors": [ "Microsoft" ],
+  "tags": [""],
+  "projectUrl": "",
+  "licenseUrl": "",
+
+  "dependencies": {
+      "System.Net.Http": "4.0.1-beta-23409",
+      "Newtonsoft.Json": "8.0.1-beta1"
+  },
+
+  "frameworks": {
+    "dnx451": { },
+    "dnxcore50": {
+      "dependencies": {
+        "Microsoft.CSharp": "4.0.1-beta-23217",
+        "System.Collections": "4.0.11-beta-23217",
+        "System.Linq": "4.0.1-beta-23217",
+        "System.Runtime": "4.0.21-beta-23217",
+        "System.Threading": "4.0.11-beta-23217",
+        "System.Text.RegularExpressions": "4.0.11-beta-23409",
+        "System.Diagnostics.Process": "4.1.0-beta-23409",
+        "System.IO.FileSystem": "4.0.1-beta-23409",
+        "System.Console": "4.0.0-beta-23409"
+      }
+    }
+  },
+  
+  "resource": [
+      "Content/**/*"
+  ]
+}