initial non-working dap

TylerLeonhardt · TylerLeonhardt · commit 8b8a44537475 · 2019-09-03T20:31:37.000-07:00
diff --git a/NuGet.Config b/NuGet.Config
@@ -4,6 +4,7 @@
     <add key="disableSourceControlIntegration" value="true" />
   </solution>
   <packageSources>
+    <add key="local" value="/Users/tyler/Code/CSharp/csharp-language-server-protocol/artifacts/nuget" />
     <add key="omnisharp" value="https://www.myget.org/F/omnisharp/api/v3/index.json" protocolVersion="3" />
     <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
   </packageSources>
diff --git a/PowerShellEditorServices.build.ps1 b/PowerShellEditorServices.build.ps1
@@ -64,6 +64,8 @@ $script:RequiredBuildAssets = @{
             'publish/OmniSharp.Extensions.JsonRpc.dll',
             'publish/OmniSharp.Extensions.LanguageProtocol.dll',
             'publish/OmniSharp.Extensions.LanguageServer.dll',
+            'publish/OmniSharp.Extensions.DebugAdapter.dll',
+            'publish/OmniSharp.Extensions.DebugAdapter.Server.dll',
             'publish/runtimes/linux-64/native/libdisablekeyecho.so',
             'publish/runtimes/osx-64/native/libdisablekeyecho.dylib',
             'publish/Serilog.dll',
diff --git a/src/PowerShellEditorServices.Engine/Hosting/EditorServicesHost.cs b/src/PowerShellEditorServices.Engine/Hosting/EditorServicesHost.cs
@@ -6,11 +6,14 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO.Pipes;
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Host;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Security.AccessControl;
+using System.Security.Principal;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -58,6 +61,15 @@ public class EditorServicesHost
     {
         #region Private Fields
 
+        // This int will be casted to a PipeOptions enum that only exists in .NET Core 2.1 and up which is why it's not available to us in .NET Standard.
+        private const int CurrentUserOnly = 0x20000000;
+
+        // In .NET Framework, NamedPipeServerStream has a constructor that takes in a PipeSecurity object. We will use reflection to call the constructor,
+        // since .NET Framework doesn't have the `CurrentUserOnly` PipeOption.
+        // doc: https://docs.microsoft.com/en-us/dotnet/api/system.io.pipes.namedpipeserverstream.-ctor?view=netframework-4.7.2#System_IO_Pipes_NamedPipeServerStream__ctor_System_String_System_IO_Pipes_PipeDirection_System_Int32_System_IO_Pipes_PipeTransmissionMode_System_IO_Pipes_PipeOptions_System_Int32_System_Int32_System_IO_Pipes_PipeSecurity_
+        private static readonly ConstructorInfo s_netFrameworkPipeServerConstructor =
+            typeof(NamedPipeServerStream).GetConstructor(new[] { typeof(string), typeof(PipeDirection), typeof(int), typeof(PipeTransmissionMode), typeof(PipeOptions), typeof(int), typeof(int), typeof(PipeSecurity) });
+
         private readonly HostDetails _hostDetails;
 
         private readonly PSHost _internalHost;
@@ -69,6 +81,7 @@ public class EditorServicesHost
         private readonly string[] _additionalModules;
 
         private PsesLanguageServer _languageServer;
+        private PsesDebugServer _debugServer;
 
         private Microsoft.Extensions.Logging.ILogger _logger;
 
@@ -229,8 +242,6 @@ public void StartLanguageService(
 
             _logger.LogInformation($"LSP NamedPipe: {config.InOutPipeName}\nLSP OutPipe: {config.OutPipeName}");
 
-            
-
             switch (config.TransportType)
             {
                 case EditorServiceTransportType.NamedPipe:
@@ -280,17 +291,42 @@ public void StartDebugService(
             ProfilePaths profilePaths,
             bool useExistingSession)
         {
-            /*
-            this.debugServiceListener = CreateServiceListener(MessageProtocolType.DebugAdapter, config);
-            this.debugServiceListener.ClientConnect += OnDebugServiceClientConnect;
-            this.debugServiceListener.Start();
+            while (!System.Diagnostics.Debugger.IsAttached)
+            {
+                System.Console.WriteLine($"{Process.GetCurrentProcess().Id}");
+                Thread.Sleep(2000);
+            }
 
-            this.logger.Write(
-                LogLevel.Normal,
-                string.Format(
-                    "Debug service started, type = {0}, endpoint = {1}",
-                    config.TransportType, config.Endpoint));
-            */
+            _logger.LogInformation($"Debug NamedPipe: {config.InOutPipeName}\nDebug OutPipe: {config.OutPipeName}");
+
+            switch (config.TransportType)
+            {
+                case EditorServiceTransportType.NamedPipe:
+                    NamedPipeServerStream inNamedPipe = CreateNamedPipe(
+                        config.InOutPipeName ?? config.InPipeName,
+                        config.OutPipeName,
+                        out NamedPipeServerStream outNamedPipe);
+
+                    _debugServer = new PsesDebugServer(
+                        _factory,
+                        inNamedPipe,
+                        outNamedPipe ?? inNamedPipe);
+
+                    Task[] tasks = outNamedPipe != null
+                        ? new[] { inNamedPipe.WaitForConnectionAsync(), outNamedPipe.WaitForConnectionAsync() }
+                        : new[] { inNamedPipe.WaitForConnectionAsync() };
+                    Task.WhenAll(tasks)
+                        .ContinueWith(async task => {
+                            _logger.LogInformation("Starting debug server");
+                            await _debugServer.StartAsync();
+                            _logger.LogInformation(
+                                $"Debug service started, type = {config.TransportType}, endpoint = {config.Endpoint}");
+                        });
+                    break;
+
+                default:
+                    throw new NotSupportedException("not supported");
+            }
         }
 
         /// <summary>
@@ -350,6 +386,81 @@ private void CurrentDomain_UnhandledException(
             _logger.LogError($"FATAL UNHANDLED EXCEPTION: {e.ExceptionObject}");
         }
 
+        private static NamedPipeServerStream CreateNamedPipe(
+            string inOutPipeName,
+            string outPipeName,
+            out NamedPipeServerStream outPipe)
+        {
+            // .NET Core implementation is simplest so try that first
+            if (VersionUtils.IsNetCore)
+            {
+                outPipe = outPipeName == null
+                    ? null
+                    : new NamedPipeServerStream(
+                        pipeName: outPipeName,
+                        direction: PipeDirection.Out,
+                        maxNumberOfServerInstances: 1,
+                        transmissionMode: PipeTransmissionMode.Byte,
+                        options: (PipeOptions)CurrentUserOnly);
+
+                return new NamedPipeServerStream(
+                    pipeName: inOutPipeName,
+                    direction: PipeDirection.InOut,
+                    maxNumberOfServerInstances: 1,
+                    transmissionMode: PipeTransmissionMode.Byte,
+                    options: PipeOptions.Asynchronous | (PipeOptions)CurrentUserOnly);
+            }
+
+            // Now deal with Windows PowerShell
+            // We need to use reflection to get a nice constructor
+
+            var pipeSecurity = new PipeSecurity();
+
+            WindowsIdentity identity = WindowsIdentity.GetCurrent();
+            WindowsPrincipal principal = new WindowsPrincipal(identity);
+
+            if (principal.IsInRole(WindowsBuiltInRole.Administrator))
+            {
+                // Allow the Administrators group full access to the pipe.
+                pipeSecurity.AddAccessRule(new PipeAccessRule(
+                    new SecurityIdentifier(WellKnownSidType.BuiltinAdministratorsSid, null).Translate(typeof(NTAccount)),
+                    PipeAccessRights.FullControl, AccessControlType.Allow));
+            }
+            else
+            {
+                // Allow the current user read/write access to the pipe.
+                pipeSecurity.AddAccessRule(new PipeAccessRule(
+                    WindowsIdentity.GetCurrent().User,
+                    PipeAccessRights.ReadWrite, AccessControlType.Allow));
+            }
+
+            outPipe = outPipeName == null
+                ? null
+                : (NamedPipeServerStream)s_netFrameworkPipeServerConstructor.Invoke(
+                    new object[] {
+                        outPipeName,
+                        PipeDirection.InOut,
+                        1, // maxNumberOfServerInstances
+                        PipeTransmissionMode.Byte,
+                        PipeOptions.Asynchronous,
+                        1024, // inBufferSize
+                        1024, // outBufferSize
+                        pipeSecurity
+                    });
+
+            return (NamedPipeServerStream)s_netFrameworkPipeServerConstructor.Invoke(
+                new object[] {
+                    inOutPipeName,
+                    PipeDirection.InOut,
+                    1, // maxNumberOfServerInstances
+                    PipeTransmissionMode.Byte,
+                    PipeOptions.Asynchronous,
+                    1024, // inBufferSize
+                    1024, // outBufferSize
+                    pipeSecurity
+                });
+        }
+
         #endregion
     }
 }
diff --git a/src/PowerShellEditorServices.Engine/PowerShellEditorServices.Engine.csproj b/src/PowerShellEditorServices.Engine/PowerShellEditorServices.Engine.csproj
@@ -21,14 +21,15 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="2.2.0" />
-    <PackageReference Include="OmniSharp.Extensions.LanguageServer" Version="0.13.2-*" />
+    <PackageReference Include="OmniSharp.Extensions.LanguageServer" Version="1.0.0" />
     <PackageReference Include="PowerShellStandard.Library" Version="5.1.1" />
     <PackageReference Include="Serilog.Extensions.Logging" Version="2.0.4" />
     <PackageReference Include="Serilog.Sinks.File" Version="4.0.0" />
     <PackageReference Include="System.IO.Pipes.AccessControl" Version="4.5.1" />
     <PackageReference Include="System.Security.Principal" Version="4.3.0" />
     <PackageReference Include="System.Security.Principal.Windows" Version="4.5.1" />
     <PackageReference Include="UnixConsoleEcho" Version="0.1.0" />
+    <PackageReference Include="OmniSharp.Extensions.DebugAdapter.Server" Version="1.0.0" />
   </ItemGroup>
 
 </Project>
diff --git a/src/PowerShellEditorServices.Engine/Server/PsesDebugServer.cs b/src/PowerShellEditorServices.Engine/Server/PsesDebugServer.cs
@@ -0,0 +1,104 @@
+﻿//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+using System.IO;
+using System.Management.Automation;
+using System.Management.Automation.Host;
+using System.Management.Automation.Runspaces;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.PowerShell.EditorServices.Engine.Handlers;
+using Microsoft.PowerShell.EditorServices.Engine.Hosting;
+using Microsoft.PowerShell.EditorServices.Engine.Services;
+using Microsoft.PowerShell.EditorServices.Engine.Services.PowerShellContext;
+using OmniSharp.Extensions.DebugAdapter.Protocol.Serialization;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.LanguageServer.Server;
+
+namespace Microsoft.PowerShell.EditorServices.Engine.Server
+{
+    internal class PsesDebugServer
+    {
+        protected readonly ILoggerFactory _loggerFactory;
+        private readonly Stream _inputStream;
+        private readonly Stream _outputStream;
+        private readonly TaskCompletionSource<bool> _serverStart;
+        
+
+        private IJsonRpcServer _jsonRpcServer;
+
+        internal PsesDebugServer(
+            ILoggerFactory factory,
+            Stream inputStream,
+            Stream outputStream)
+        {
+            _loggerFactory = factory;
+            _inputStream = inputStream;
+            _outputStream = outputStream;
+            _serverStart = new TaskCompletionSource<bool>();
+
+        }
+
+        public async Task StartAsync()
+        {
+            _jsonRpcServer = await JsonRpcServer.From(options =>
+            {
+                options.Serializer = new DapProtocolSerializer();
+                options.Reciever = new DapReciever();
+                options.LoggerFactory = _loggerFactory;
+                ILogger logger = options.LoggerFactory.CreateLogger("DebugOptionsStartup");
+                options.AddHandler<PowershellInitializeHandler>();
+                // options.Services = new ServiceCollection()
+                //     .AddSingleton<WorkspaceService>()
+                //     .AddSingleton<SymbolsService>()
+                //     .AddSingleton<ConfigurationService>()
+                //     .AddSingleton<PowerShellContextService>(
+                //         (provider) =>
+                //             GetFullyInitializedPowerShellContext(
+                //                 provider.GetService<OmniSharp.Extensions.LanguageServer.Protocol.Server.ILanguageServer>(),
+                //                 _profilePaths))
+                //     .AddSingleton<TemplateService>()
+                //     .AddSingleton<EditorOperationsService>()
+                //     .AddSingleton<ExtensionService>(
+                //         (provider) =>
+                //         {
+                //             var extensionService = new ExtensionService(
+                //                 provider.GetService<PowerShellContextService>(),
+                //                 provider.GetService<OmniSharp.Extensions.LanguageServer.Protocol.Server.ILanguageServer>());
+                //             extensionService.InitializeAsync(
+                //                 serviceProvider: provider,
+                //                 editorOperations: provider.GetService<EditorOperationsService>())
+                //                 .Wait();
+                //             return extensionService;
+                //         })
+                //     .AddSingleton<AnalysisService>(
+                //         (provider) =>
+                //         {
+                //             return AnalysisService.Create(
+                //                 provider.GetService<ConfigurationService>(),
+                //                 provider.GetService<OmniSharp.Extensions.LanguageServer.Protocol.Server.ILanguageServer>(),
+                //                 options.LoggerFactory.CreateLogger<AnalysisService>());
+                //         });
+
+                options
+                    .WithInput(_inputStream)
+                    .WithOutput(_outputStream);
+
+                logger.LogInformation("Adding handlers");
+
+                logger.LogInformation("Handlers added");
+            });
+        }
+
+        public async Task WaitForShutdown()
+        {
+            await _serverStart.Task;
+            //await _languageServer.;
+        }
+    }
+}
diff --git a/src/PowerShellEditorServices.Engine/Services/DebugAdapter/InitializeHandler.cs b/src/PowerShellEditorServices.Engine/Services/DebugAdapter/InitializeHandler.cs
@@ -0,0 +1,28 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using OmniSharp.Extensions.DebugAdapter.Protocol.Requests;
+
+namespace Microsoft.PowerShell.EditorServices.Engine.Handlers
+{
+    internal class PowershellInitializeHandler : InitializeHandler
+    {
+        private readonly ILogger<PowershellInitializeHandler> _logger;
+
+        public PowershellInitializeHandler(ILoggerFactory factory)
+        {
+            _logger = factory.CreateLogger<PowershellInitializeHandler>();
+        }
+
+        public override Task<InitializeResponse> Handle(InitializeRequestArguments request, CancellationToken cancellationToken)
+        {
+            _logger.LogTrace("We did it.");
+            return Task.FromResult(new InitializeResponse());
+        }
+    }
+}
