Move unused forked code to external directory (#1192)

* Move unused forked code to external directory

* Fix SLN build errors

* Add back resource provider core since it's referenced by main resource provider project

* Update PackageProjects step of pipeline

external/Microsoft.SqlTools.Hosting.v2/Extensibility/IHostedService.cs

@@ -0,0 +1,107 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.Hosting.Utility;
+
+namespace Microsoft.SqlTools.Hosting.Extensibility
+{
+    /// <summary>
+    /// Defines a hosted service that communicates with external processes via
+    /// messages passed over the <see cref="ServiceHost"/>. The service defines
+    /// a standard initialization method where it can hook up to the host.
+    /// </summary>
+    public interface IHostedService 
+    {
+        /// <summary>
+        /// Callback to initialize this service
+        /// </summary>
+        /// <param name="serviceHost"><see cref="IServiceHost"/> which supports registering
+        /// event handlers and other callbacks for messages passed to external callers</param>
+        void InitializeService(IServiceHost serviceHost);
+
+        /// <summary>
+        /// What is the service type that you wish to register?
+        /// </summary>
+        Type ServiceType { get; }
+    }
+
+    /// <summary>
+    /// Base class for <see cref="IHostedService"/> implementations that handles defining the <see cref="ServiceType"/>
+    /// being registered. This simplifies service registration. This also implements <see cref="IComposableService"/> which
+    /// allows injection of the service provider for lookup of other services.
+    /// 
+    /// Extending classes should implement per below code example
+    /// <code>
+    /// [Export(typeof(IHostedService)]
+    /// MyService : HostedService&lt;MyService&gt;
+    /// {
+    ///     public override void InitializeService(IServiceHost serviceHost)
+    ///     {
+    ///         serviceHost.SetRequestHandler(MyRequest.Type, HandleMyRequest);
+    ///     }
+    /// }
+    /// </code>
+    /// </summary>
+    /// <typeparam name="T">Type to be registered for lookup in the service provider</typeparam>
+    public abstract class HostedService<T> : IHostedService, IComposableService
+    {
+        protected IMultiServiceProvider ServiceProvider { get; private set; }
+
+        public virtual void SetServiceProvider(IMultiServiceProvider provider)
+        {
+            ServiceProvider = provider;
+        }
+
+        public Type ServiceType => typeof(T);
+
+        protected async Task<THandler> HandleRequestAsync<THandler>(
+            Func<Task<THandler>> handler, 
+            RequestContext<THandler> requestContext, 
+            string requestType)
+        {
+            Logger.Write(TraceEventType.Verbose, requestType);
+
+            try
+            {
+                THandler result = await handler();
+                requestContext.SendResult(result);
+                return result;
+            }
+            catch (Exception ex)
+            {
+                requestContext.SendError(ex.ToString());
+            }
+            return default(THandler);
+        }
+        protected async Task<THandler> HandleSyncRequestAsAsync<THandler>(
+            Func<THandler> handler, 
+            RequestContext<THandler> requestContext, 
+            string requestType)
+        {
+            Logger.Write(TraceEventType.Verbose, requestType);
+            return await Task.Factory.StartNew(() => {
+                try
+                {
+                    THandler result = handler();
+                    requestContext.SendResult(result);
+                    return result;
+                }
+                catch (Exception ex)
+                {
+                    requestContext.SendError(ex.ToString());
+                }
+                return default(THandler);
+            });
+        }
+
+
+        public abstract void InitializeService(IServiceHost serviceHost);
+
+    }
+}