Implement SocketNodeInstance

Author: SteveSandersonMS

src/Microsoft.AspNetCore.NodeServices/.gitignore

@@ -1 +1,2 @@
 /bin/
+/node_modules/

src/Microsoft.AspNetCore.NodeServices/Configuration.cs

@@ -39,6 +39,8 @@ public static INodeServices CreateNodeServices(NodeServicesOptions options)
             {
                 case NodeHostingModel.Http:
                     return new HttpNodeInstance(options.ProjectPath, /* port */ 0, watchFileExtensions);
+                case NodeHostingModel.Socket:
+                    return new SocketNodeInstance(options.ProjectPath, watchFileExtensions);
                 case NodeHostingModel.InputOutputStream:
                     return new InputOutputStreamNodeInstance(options.ProjectPath);
                 default:

src/Microsoft.AspNetCore.NodeServices/Content/Node/entrypoint-socket.js

@@ -0,0 +1,12 @@
+using System;
+
+namespace Microsoft.AspNetCore.NodeServices
+{
+    public class NodeInvocationException : Exception
+    {
+        public NodeInvocationException(string message, string details)
+            : base(message + Environment.NewLine + details)
+        {
+        }
+    }
+}

src/Microsoft.AspNetCore.NodeServices/HostingModels/NodeInvocationException.cs

@@ -13,7 +13,7 @@ namespace Microsoft.AspNetCore.NodeServices
     public abstract class OutOfProcessNodeInstance : INodeServices
     {
         private readonly object _childProcessLauncherLock;
-        private readonly string _commandLineArguments;
+        private string _commandLineArguments;
         private readonly StringAsTempFile _entryPointScript;
         private Process _nodeProcess;
         private TaskCompletionSource<bool> _nodeProcessIsReadySource;
@@ -27,6 +27,12 @@ public OutOfProcessNodeInstance(string entryPointScript, string projectPath, str
             _projectPath = projectPath;
             _commandLineArguments = commandLineArguments ?? string.Empty;
         }
+        
+        public string CommandLineArguments
+        {
+            get { return _commandLineArguments; }
+            set { _commandLineArguments = value; }
+        }
 
         protected Process NodeProcess
         {
@@ -59,12 +65,23 @@ public void Dispose()
 
         public abstract Task<T> Invoke<T>(NodeInvocationInfo invocationInfo);
 
+        protected void ExitNodeProcess()
+        {
+            if (_nodeProcess != null && !_nodeProcess.HasExited)
+            {
+                // TODO: Is there a more graceful way to end it? Or does this still let it perform any cleanup?
+                _nodeProcess.Kill();
+            }
+        }
+
         protected async Task EnsureReady()
         {
             lock (_childProcessLauncherLock)
             {
                 if (_nodeProcess == null || _nodeProcess.HasExited)
                 {
+                    this.OnBeforeLaunchProcess();
+
                     var startInfo = new ProcessStartInfo("node")
                     {
                         Arguments = "\"" + _entryPointScript.FileName + "\" " + _commandLineArguments,
@@ -89,7 +106,6 @@ protected async Task EnsureReady()
                     startInfo.Environment.Add("NODE_PATH", nodePathValue);
 #endif
 
-                    OnBeforeLaunchProcess();
                     _nodeProcess = Process.Start(startInfo);
                     ConnectToInputOutputStreams();
                 }
@@ -162,11 +178,7 @@ protected virtual void Dispose(bool disposing)
                     _entryPointScript.Dispose();
                 }
 
-                if (_nodeProcess != null && !_nodeProcess.HasExited)
-                {
-                    _nodeProcess.Kill();
-                    // TODO: Is there a more graceful way to end it? Or does this still let it perform any cleanup?
-                }
+                ExitNodeProcess();
 
                 _disposed = true;
             }

src/Microsoft.AspNetCore.NodeServices/HostingModels/OutOfProcessNodeInstance.cs

@@ -0,0 +1,32 @@
+using System.IO;
+using System.IO.Pipes;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.NodeServices.HostingModels.PhysicalConnections
+{
+    internal class NamedPipeConnection : StreamConnection
+    {
+        private bool _disposedValue = false;
+        private NamedPipeClientStream _namedPipeClientStream;
+
+        public override async Task<Stream> Open(string address)
+        {
+            _namedPipeClientStream = new NamedPipeClientStream(".", address, PipeDirection.InOut);
+            await _namedPipeClientStream.ConnectAsync().ConfigureAwait(false);
+            return _namedPipeClientStream;
+        }
+
+        public override void Dispose()
+        {
+            if (!_disposedValue)
+            {
+                if (_namedPipeClientStream != null)
+                {
+                    _namedPipeClientStream.Dispose();
+                }
+
+                _disposedValue = true;
+            }
+        }
+    }
+}

src/Microsoft.AspNetCore.NodeServices/HostingModels/PhysicalConnections/NamedPipeConnection.cs

@@ -0,0 +1,26 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.NodeServices.HostingModels.PhysicalConnections
+{
+    internal abstract class StreamConnection : IDisposable
+    {
+        public abstract Task<Stream> Open(string address);
+        public abstract void Dispose();
+
+        public static StreamConnection Create()
+        {
+            var useNamedPipes = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+            if (useNamedPipes)
+            {
+                return new NamedPipeConnection();
+            }
+            else
+            {
+                return new UnixDomainSocketConnection();
+            }
+        }
+    }
+}

src/Microsoft.AspNetCore.NodeServices/HostingModels/PhysicalConnections/StreamConnection.cs

@@ -0,0 +1,40 @@
+using System.IO;
+using System.Net.Sockets;
+using System.Threading.Tasks;
+
+namespace Microsoft.AspNetCore.NodeServices.HostingModels.PhysicalConnections
+{
+    internal class UnixDomainSocketConnection : StreamConnection
+    {
+        private bool _disposedValue = false;
+        private NetworkStream _networkStream;
+        private Socket _socket;
+
+        public override async Task<Stream> Open(string address)
+        {
+            var endPoint = new UnixDomainSocketEndPoint("/tmp/" + address);
+            _socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Unspecified);
+            await _socket.ConnectAsync(endPoint).ConfigureAwait(false);
+            _networkStream = new NetworkStream(_socket);
+            return _networkStream;
+        }
+
+        public override void Dispose()
+        {
+            if (!_disposedValue)
+            {
+                if (_networkStream != null)
+                {
+                    _networkStream.Dispose();
+                }
+
+                if (_socket != null)
+                {
+                    _socket.Dispose();
+                }
+
+                _disposedValue = true;
+            }
+        }
+    }
+}

src/Microsoft.AspNetCore.NodeServices/HostingModels/PhysicalConnections/UnixDomainSocketConnection.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+namespace Microsoft.AspNetCore.NodeServices.HostingModels.PhysicalConnections
+{
+    // From System.IO.Pipes/src/System/Net/Sockets/UnixDomainSocketEndPoint.cs (an internal class in System.IO.Pipes)
+    internal sealed class UnixDomainSocketEndPoint : EndPoint
+    {
+        private const AddressFamily EndPointAddressFamily = AddressFamily.Unix;
+
+        private static readonly Encoding s_pathEncoding = Encoding.UTF8;
+        private static readonly int s_nativePathOffset = 2; // = offsetof(struct sockaddr_un, sun_path). It's the same on Linux and OSX
+        private static readonly int s_nativePathLength = 91; // sockaddr_un.sun_path at http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_un.h.html, -1 for terminator
+        private static readonly int s_nativeAddressSize = s_nativePathOffset + s_nativePathLength;
+
+        private readonly string _path;
+        private readonly byte[] _encodedPath;
+
+        public UnixDomainSocketEndPoint(string path)
+        {
+            if (path == null)
+            {
+                throw new ArgumentNullException(nameof(path));
+            }
+
+            _path = path;
+            _encodedPath = s_pathEncoding.GetBytes(_path);
+
+            if (path.Length == 0 || _encodedPath.Length > s_nativePathLength)
+            {
+                throw new ArgumentOutOfRangeException(nameof(path));
+            }
+        }
+
+        internal UnixDomainSocketEndPoint(SocketAddress socketAddress)
+        {
+            if (socketAddress == null)
+            {
+                throw new ArgumentNullException(nameof(socketAddress));
+            }
+
+            if (socketAddress.Family != EndPointAddressFamily ||
+                socketAddress.Size > s_nativeAddressSize)
+            {
+                throw new ArgumentOutOfRangeException(nameof(socketAddress));
+            }
+
+            if (socketAddress.Size > s_nativePathOffset)
+            {
+                _encodedPath = new byte[socketAddress.Size - s_nativePathOffset];
+                for (int i = 0; i < _encodedPath.Length; i++)
+                {
+                    _encodedPath[i] = socketAddress[s_nativePathOffset + i];
+                }
+
+                _path = s_pathEncoding.GetString(_encodedPath, 0, _encodedPath.Length);
+            }
+            else
+            {
+                _encodedPath = Array.Empty<byte>();
+                _path = string.Empty;
+            }
+        }
+
+        public override SocketAddress Serialize()
+        {
+            var result = new SocketAddress(AddressFamily.Unix, s_nativeAddressSize);
+
+            for (int index = 0; index < _encodedPath.Length; index++)
+            {
+                result[s_nativePathOffset + index] = _encodedPath[index];
+            }
+            result[s_nativePathOffset + _encodedPath.Length] = 0; // path must be null-terminated
+
+            return result;
+        }
+
+        public override EndPoint Create(SocketAddress socketAddress) => new UnixDomainSocketEndPoint(socketAddress);
+
+        public override AddressFamily AddressFamily => EndPointAddressFamily;
+
+        public override string ToString() => _path;
+    }
+}