コード例 #1
0
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            var configuration   = new ConfigurationBuilder(_environment).Build();
            var serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(_environment, configuration, _eventEmitter, services,
                                                                                      configureLogging: builder =>
            {
                builder.AddConsole();

                var workspaceInformationServiceName = typeof(WorkspaceInformationService).FullName;
                var projectEventForwarder           = typeof(ProjectEventForwarder).FullName;
                var exceptionHandlerMiddlewareName  = typeof(ExceptionHandlerMiddleware).FullName;

                builder.AddFilter(
                    (category, logLevel) =>
                    category.Equals(exceptionHandlerMiddlewareName, StringComparison.OrdinalIgnoreCase) ||
                    (_environment.LogLevel <= logLevel &&
                     category.StartsWith("OmniSharp", StringComparison.OrdinalIgnoreCase) &&
                     !category.Equals(workspaceInformationServiceName, StringComparison.OrdinalIgnoreCase) &&
                     !category.Equals(projectEventForwarder, StringComparison.OrdinalIgnoreCase)));
            });

            var options = serviceProvider.GetRequiredService <IOptionsMonitor <OmniSharpOptions> >();
            var plugins = _commandLinePlugins.AssemblyNames.Concat(options.CurrentValue.Plugins.GetNormalizedLocationPaths(_environment));

            var loggerFactory  = serviceProvider.GetRequiredService <ILoggerFactory>();
            var logger         = loggerFactory.CreateLogger <Startup>();
            var assemblyLoader = serviceProvider.GetRequiredService <IAssemblyLoader>();

            _compositionHost = new CompositionHostBuilder(serviceProvider)
                               .WithOmniSharpAssemblies()
                               .WithAssemblies(assemblyLoader.LoadByAssemblyNameOrPath(logger, plugins).ToArray())
                               .Build();

            return(serviceProvider);
        }
コード例 #2
0
ファイル: Startup.cs プロジェクト: yourina/omnisharp-roslyn
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            var configuration   = new ConfigurationBuilder(_environment).Build();
            var serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(_environment, configuration, _eventEmitter, services,
                                                                                      configureLogging: builder =>
            {
                builder.AddConsole();

                var workspaceInformationServiceName = typeof(WorkspaceInformationService).FullName;
                var projectEventForwarder           = typeof(ProjectEventForwarder).FullName;
                var exceptionHandlerMiddlewareName  = typeof(ExceptionHandlerMiddleware).FullName;

                builder.AddFilter(
                    (category, logLevel) =>
                    category.Equals(exceptionHandlerMiddlewareName, StringComparison.OrdinalIgnoreCase) ||
                    (_environment.LogLevel <= logLevel &&
                     category.StartsWith("OmniSharp", StringComparison.OrdinalIgnoreCase) &&
                     !category.Equals(workspaceInformationServiceName, StringComparison.OrdinalIgnoreCase) &&
                     !category.Equals(projectEventForwarder, StringComparison.OrdinalIgnoreCase)));
            });

            _compositionHost = new CompositionHostBuilder(serviceProvider)
                               .WithOmniSharpAssemblies()
                               .Build();

            return(serviceProvider);
        }
コード例 #3
0
        static int Main(string[] args) => HostHelpers.Start(() =>
        {
            var application = new StdioCommandLineApplication();
            application.OnExecute(() =>
            {
                // If an encoding was specified, be sure to set the Console with it before we access the input/output streams.
                // Otherwise, the streams will be created with the default encoding.
                if (application.Encoding != null)
                {
                    var encoding           = Encoding.GetEncoding(application.Encoding);
                    Console.InputEncoding  = encoding;
                    Console.OutputEncoding = encoding;
                }

                var cancellation = new CancellationTokenSource();

                if (application.Lsp)
                {
                    Configuration.ZeroBasedIndices = true;
                    using (var host = new LanguageServerHost(
                               Console.OpenStandardInput(),
                               Console.OpenStandardOutput(),
                               application,
                               cancellation))
                    {
                        host.Start().Wait();
                        cancellation.Token.WaitHandle.WaitOne();
                    }
                }
                else
                {
                    var input  = Console.In;
                    var output = Console.Out;

                    var environment = application.CreateEnvironment();
                    Configuration.ZeroBasedIndices = application.ZeroBasedIndices;
                    var configuration   = new ConfigurationBuilder(environment).Build();
                    var writer          = new SharedTextWriter(output);
                    var serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(environment, configuration, new StdioEventEmitter(writer));
                    var loggerFactory   = serviceProvider.GetRequiredService <ILoggerFactory>();
                    var plugins         = application.CreatePluginAssemblies();


                    var assemblyLoader         = serviceProvider.GetRequiredService <IAssemblyLoader>();
                    var compositionHostBuilder = new CompositionHostBuilder(serviceProvider)
                                                 .WithOmniSharpAssemblies()
                                                 .WithAssemblies(assemblyLoader.LoadByAssemblyNameOrPath(plugins.AssemblyNames).ToArray());

                    using (var host = new Host(input, writer, environment, configuration, serviceProvider, compositionHostBuilder, loggerFactory, cancellation))
                    {
                        host.Start();
                        cancellation.Token.WaitHandle.WaitOne();
                    }
                }

                return(0);
            });

            return(application.Execute(args));
        });
コード例 #4
0
        private PlugInHost CreatePlugInHost(params Assembly[] assemblies)
        {
            var serviceProvider = TestServiceProvider.Create(this.TestOutput, new OmniSharpEnvironment());
            var compositionHost = new CompositionHostBuilder(serviceProvider)
                                  .WithAssemblies(assemblies)
                                  .Build();

            return(new PlugInHost(serviceProvider, compositionHost));
        }
コード例 #5
0
        public static OmniSharpTestHost Create(
            string path = null,
            ITestOutputHelper testOutput = null,
            IEnumerable <KeyValuePair <string, string> > configurationData = null,
            DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current,
            IEnumerable <ExportDescriptorProvider> additionalExports = null)
        {
            var environment      = new OmniSharpEnvironment(path, logLevel: LogLevel.Trace);
            var loggerFactory    = new LoggerFactory().AddXunit(testOutput);
            var logger           = loggerFactory.CreateLogger <OmniSharpTestHost>();
            var sharedTextWriter = new TestSharedTextWriter(testOutput);

            var dotNetCliService = CreateTestDotNetCliService(dotNetCliVersion, loggerFactory);

            var info = dotNetCliService.GetInfo();

            logger.LogInformation($"Using .NET CLI: {info.Version}");

            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            builder.AddInMemoryCollection(configurationData);

            // We need to set the "UseLegacySdkResolver" for tests because
            // MSBuild's SDK resolver will not be able to locate the .NET Core SDKs
            // that we install locally in the ".dotnet" and ".dotnet-legacy" directories.
            // This property will cause the MSBuild project loader to set the
            // MSBuildSDKsPath environment variable to the correct path "Sdks" folder
            // within the appropriate .NET Core SDK.
            var msbuildProperties = new Dictionary <string, string>()
            {
                [$"MSBuild:{nameof(MSBuildOptions.UseLegacySdkResolver)}"] = "true",
                [$"MSBuild:{nameof(MSBuildOptions.MSBuildSDKsPath)}"]      = Path.Combine(info.BasePath, "Sdks")
            };

            builder.AddInMemoryCollection(msbuildProperties);

            var configuration = builder.Build();

            var serviceProvider = new TestServiceProvider(environment, loggerFactory, sharedTextWriter, configuration, NullEventEmitter.Instance, dotNetCliService);

            var compositionHost = new CompositionHostBuilder(serviceProvider, s_lazyAssemblies.Value, additionalExports)
                                  .Build();

            var workspace = compositionHost.GetExport <OmniSharpWorkspace>();

            WorkspaceInitializer.Initialize(serviceProvider, compositionHost, configuration, logger);

            var host = new OmniSharpTestHost(serviceProvider, loggerFactory, workspace, compositionHost);

            // Force workspace to be updated
            var service = host.GetWorkspaceInformationService();

            service.Handle(new WorkspaceInformationRequest()).Wait();

            return(host);
        }
コード例 #6
0
ファイル: Startup.cs プロジェクト: rchande/omnisharp-roslyn
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            var serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(_configuration, services);

            _compositionHost = new CompositionHostBuilder(serviceProvider, _environment, _writer, _eventEmitter)
                               .WithOmniSharpAssemblies()
                               .Build();

            return(serviceProvider);
        }
コード例 #7
0
        public static OmniSharpTestHost Create(string path = null, ITestOutputHelper testOutput = null, IEnumerable <KeyValuePair <string, string> > configurationData = null, DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current)
        {
            var dotNetPath = Path.Combine(
                TestAssets.Instance.RootFolder,
                GetDotNetCliFolderName(dotNetCliVersion),
                "dotnet");

            if (!File.Exists(dotNetPath))
            {
                dotNetPath = Path.ChangeExtension(dotNetPath, ".exe");
            }

            if (!File.Exists(dotNetPath))
            {
                throw new InvalidOperationException($"Local .NET CLI path does not exist. Did you run build.(ps1|sh) from the command line?");
            }

            var builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder();

            builder.AddInMemoryCollection(configurationData);
            var configuration = builder.Build();

            var environment      = new OmniSharpEnvironment(path, logLevel: LogLevel.Trace);
            var loggerFactory    = new LoggerFactory().AddXunit(testOutput);
            var sharedTextWriter = new TestSharedTextWriter(testOutput);

            var serviceProvider = new TestServiceProvider(environment, loggerFactory, sharedTextWriter, configuration);

            var compositionHost = new CompositionHostBuilder(serviceProvider, environment, NullEventEmitter.Instance)
                                  .WithAssemblies(s_lazyAssemblies.Value)
                                  .Build();

            var workspace = compositionHost.GetExport <OmniSharpWorkspace>();
            var logger    = loggerFactory.CreateLogger <OmniSharpTestHost>();

            var dotNetCli = compositionHost.GetExport <DotNetCliService>();

            dotNetCli.SetDotNetPath(dotNetPath);
            var version = dotNetCli.GetVersion();

            logger.LogInformation($"Using .NET CLI: {version}");

            var oldMSBuildSdksPath = SetMSBuildSdksPath(dotNetCli);

            WorkspaceInitializer.Initialize(serviceProvider, compositionHost, configuration, logger);

            var host = new OmniSharpTestHost(serviceProvider, loggerFactory, workspace, compositionHost, oldMSBuildSdksPath);

            // Force workspace to be updated
            var service = host.GetWorkspaceInformationService();

            service.Handle(new WorkspaceInformationRequest()).Wait();

            return(host);
        }
コード例 #8
0
        private PlugInHost CreatePlugInHost(params Assembly[] assemblies)
        {
            var environment      = new OmniSharpEnvironment();
            var sharedTextWriter = new TestSharedTextWriter(this.TestOutput);
            var serviceProvider  = new TestServiceProvider(environment, this.LoggerFactory, sharedTextWriter, new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build());
            var compositionHost  = new CompositionHostBuilder(serviceProvider, environment, sharedTextWriter, NullEventEmitter.Instance)
                                   .WithAssemblies(assemblies)
                                   .Build();

            return(new PlugInHost(serviceProvider, compositionHost));
        }
コード例 #9
0
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            var configuration   = new ConfigurationBuilder(_environment).Build();
            var serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(_environment, configuration, _eventEmitter, services,
                                                                                      configureLogging: builder =>
            {
                builder.AddConsole();
            });

            _compositionHost = new CompositionHostBuilder(serviceProvider)
                               .WithOmniSharpAssemblies()
                               .Build();

            return(serviceProvider);
        }
コード例 #10
0
        private static (IServiceProvider serviceProvider, CompositionHost compositionHost) CreateCompositionHost(
            ILanguageServer server,
            InitializeParams initializeParams,
            CommandLineApplication application,
            IServiceCollection services,
            Action <ILoggingBuilder> configureLogging)
        {
            var logLevel    = GetLogLevel(initializeParams.Trace);
            var environment = new OmniSharpEnvironment(
                // TODO: Support solution selection from the server side in the future
                // For now selection can be done by passing -s to the server
                !string.IsNullOrEmpty(application.ApplicationRoot) ? application.ApplicationRoot : Helpers.FromUri(initializeParams.RootUri),
                Convert.ToInt32(initializeParams.ProcessId ?? application.HostPid),
                application.LogLevel < logLevel ? application.LogLevel : logLevel,
                application.OtherArgs.ToArray());

            var configurationRoot = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                    .AddConfiguration(new ConfigurationBuilder(environment).Build())
                                    .AddConfiguration(server.Configuration.GetSection("csharp"))
                                    .AddConfiguration(server.Configuration.GetSection("omnisharp"))
                                    .Build()
            ;

            var eventEmitter = new LanguageServerEventEmitter(server);

            services.AddSingleton(server)
            .AddSingleton <ILanguageServerFacade>(server);

            var serviceProvider =
                CompositionHostBuilder.CreateDefaultServiceProvider(environment, configurationRoot, eventEmitter,
                                                                    services, GetLogBuilderAction(configureLogging, environment.LogLevel));

            var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
            var logger        = loggerFactory.CreateLogger <LanguageServerHost>();

            var options = serviceProvider.GetRequiredService <IOptionsMonitor <OmniSharpOptions> >();
            var plugins = application.CreatePluginAssemblies(options.CurrentValue, environment);

            var assemblyLoader         = serviceProvider.GetRequiredService <IAssemblyLoader>();
            var compositionHostBuilder = new CompositionHostBuilder(serviceProvider)
                                         .WithOmniSharpAssemblies()
                                         .WithAssemblies(typeof(LanguageServerHost).Assembly)
                                         .WithAssemblies(assemblyLoader.LoadByAssemblyNameOrPath(logger, plugins.AssemblyNames).ToArray());

            return(serviceProvider, compositionHostBuilder.Build(environment.TargetDirectory));
        }
コード例 #11
0
        public static OmniSharpTestHost Create(
            IServiceProvider serviceProvider,
            IEnumerable <ExportDescriptorProvider> additionalExports = null)
        {
            var compositionHost = new CompositionHostBuilder(serviceProvider, s_lazyAssemblies.Value, additionalExports)
                                  .Build();

            WorkspaceInitializer.Initialize(serviceProvider, compositionHost);

            var host = new OmniSharpTestHost(serviceProvider, compositionHost);

            // Force workspace to be updated
            var service = host.GetWorkspaceInformationService();

            service.Handle(new WorkspaceInformationRequest()).Wait();

            return(host);
        }
コード例 #12
0
        public Host(
            TextReader input, ISharedTextWriter writer, IOmniSharpEnvironment environment, IConfiguration configuration,
            IServiceProvider serviceProvider, CompositionHostBuilder compositionHostBuilder, ILoggerFactory loggerFactory, CancellationTokenSource cancellationTokenSource)
        {
            _cancellationTokenSource = cancellationTokenSource;
            _input           = input;
            _writer          = writer;
            _environment     = environment;
            _configuration   = configuration;
            _serviceProvider = serviceProvider;
            _loggerFactory   = loggerFactory.AddStdio(_writer, (category, level) => HostHelpers.LogFilter(category, level, _environment));

            _compositionHost     = compositionHostBuilder.Build();
            _cachedStringBuilder = new CachedStringBuilder();

            var handlers = Initialize();

            _endpointHandlers = handlers;
        }
コード例 #13
0
        private Host BuildTestServerAndStart(TextReader reader, ISharedTextWriter writer, Action <Host> programDelegate = null)
        {
            var configuration          = new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build();
            var environment            = new OmniSharpEnvironment();
            var serviceProvider        = CompositionHostBuilder.CreateDefaultServiceProvider(environment, configuration, NullEventEmitter.Instance);
            var cancelationTokenSource = new CancellationTokenSource();
            var host = new Host(reader, writer,
                                environment,
                                serviceProvider,
                                new CompositionHostBuilder(serviceProvider),
                                serviceProvider.GetRequiredService <ILoggerFactory>(),
                                cancelationTokenSource);

            programDelegate?.Invoke(host);

            host.Start();

            return(host);
        }
コード例 #14
0
        private static (IServiceProvider serviceProvider, CompositionHost compositionHost) CreateCompositionHost(
            ILanguageServer server,
            InitializeParams initializeParams,
            CommandLineApplication application,
            IServiceCollection services
            )
        {
            var logLevel    = GetLogLevel(initializeParams.Trace);
            var environment = new OmniSharpEnvironment(
                Helpers.FromUri(initializeParams.RootUri),
                Convert.ToInt32(initializeParams.ProcessId ?? -1L),
                application.LogLevel < logLevel ? application.LogLevel : logLevel,
                application.OtherArgs.ToArray());

            var configurationRoot = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
                                    .AddConfiguration(new ConfigurationBuilder(environment).Build())
                                    .AddConfiguration(server.Configuration.GetSection("csharp"))
                                    .AddConfiguration(server.Configuration.GetSection("omnisharp"))
                                    .Build()
            ;

            var eventEmitter = new LanguageServerEventEmitter(server);

            services.AddSingleton(server);
            var serviceProvider =
                CompositionHostBuilder.CreateDefaultServiceProvider(environment, configurationRoot, eventEmitter,
                                                                    services);

            var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
            var logger        = loggerFactory.CreateLogger <LanguageServerHost>();

            var options = serviceProvider.GetRequiredService <IOptionsMonitor <OmniSharpOptions> >();
            var plugins = application.CreatePluginAssemblies(options.CurrentValue, environment);

            var assemblyLoader         = serviceProvider.GetRequiredService <IAssemblyLoader>();
            var compositionHostBuilder = new CompositionHostBuilder(serviceProvider)
                                         .WithOmniSharpAssemblies()
                                         .WithAssemblies(typeof(LanguageServerHost).Assembly)
                                         .WithAssemblies(assemblyLoader.LoadByAssemblyNameOrPath(logger, plugins.AssemblyNames).ToArray());

            return(serviceProvider, compositionHostBuilder.Build());
        }
コード例 #15
0
        public static OmniSharpTestHost Create(
            IServiceProvider serviceProvider,
            IEnumerable <ExportDescriptorProvider> additionalExports = null,
            [CallerMemberName] string callerName = "")
        {
            var environment     = serviceProvider.GetRequiredService <IOmniSharpEnvironment>();
            var compositionHost = new CompositionHostBuilder(serviceProvider, s_lazyAssemblies.Value, additionalExports)
                                  .Build(environment.TargetDirectory);

            WorkspaceInitializer.Initialize(serviceProvider, compositionHost);

            var host = new OmniSharpTestHost(serviceProvider, compositionHost, callerName);

            // Force workspace to be updated
            var service = host.GetWorkspaceInformationService();

            service.Handle(new WorkspaceInformationRequest()).Wait();

            return(host);
        }
コード例 #16
0
        public Host(
            TextReader input, ISharedTextWriter writer, IOmniSharpEnvironment environment,
            IServiceProvider serviceProvider, CompositionHostBuilder compositionHostBuilder, ILoggerFactory loggerFactory, CancellationTokenSource cancellationTokenSource)
        {
            _cancellationTokenSource = cancellationTokenSource;
            _input           = input;
            _writer          = writer;
            _environment     = environment;
            _serviceProvider = serviceProvider;
            _logger          = loggerFactory.CreateLogger <Host>();

            _logger.LogInformation($"Starting OmniSharp on {Platform.Current}");

            _compositionHost     = compositionHostBuilder.Build(_environment.TargetDirectory);
            _cachedStringBuilder = new CachedStringBuilder();

            var handlers = Initialize();

            _endpointHandlers = handlers;
        }
コード例 #17
0
        private void CreateCompositionHost(InitializeParams initializeParams)
        {
            _environment = new OmniSharpEnvironment(
                Helpers.FromUri(initializeParams.RootUri),
                Convert.ToInt32(initializeParams.ProcessId ?? -1L),
                GetLogLevel(initializeParams.Trace),
                _application.OtherArgs.ToArray());

            // TODO: Make this work with logger factory differently
            // Maybe create a child logger factory?
            _loggerFactory.AddProvider(_server, _environment);
            _logger = _loggerFactory.CreateLogger <LanguageServerHost>();

            var configurationRoot = new ConfigurationBuilder(_environment).Build();
            var eventEmitter      = new LanguageServerEventEmitter(_server);

            _serviceProvider = CompositionHostBuilder.CreateDefaultServiceProvider(_environment, configurationRoot, eventEmitter, _services);

            var plugins = _application.CreatePluginAssemblies();

            var assemblyLoader         = _serviceProvider.GetRequiredService <IAssemblyLoader>();
            var compositionHostBuilder = new CompositionHostBuilder(_serviceProvider)
                                         .WithOmniSharpAssemblies()
                                         .WithAssemblies(typeof(LanguageServerHost).Assembly)
                                         .WithAssemblies(assemblyLoader.LoadByAssemblyNameOrPath(plugins.AssemblyNames).ToArray());

            _compositionHost = compositionHostBuilder.Build();

            var projectSystems = _compositionHost.GetExports <IProjectSystem>();

            var documentSelectors = projectSystems
                                    .GroupBy(x => x.Language)
                                    .Select(x => (
                                                language: x.Key,
                                                selector: new DocumentSelector(x
                                                                               .SelectMany(z => z.Extensions)
                                                                               .Distinct()
                                                                               .Select(z => new DocumentFilter()
            {
                Pattern = $"**/*{z}"
            }))
                                                ));

            _logger.LogTrace(
                "Configured Document Selectors {@DocumentSelectors}",
                documentSelectors.Select(x => new { x.language, x.selector })
                );

            // TODO: Get these with metadata so we can attach languages
            // This will thne let us build up a better document filter, and add handles foreach type of handler
            // This will mean that we will have a strategy to create handlers from the interface type
            _handlers = new RequestHandlers(
                _compositionHost.GetExports <Lazy <IRequestHandler, OmniSharpRequestHandlerMetadata> >(),
                documentSelectors
                );

            _logger.LogTrace("--- Handler Definitions ---");
            foreach (var handlerCollection in _handlers)
            {
                foreach (var handler in handlerCollection)
                {
                    _logger.LogTrace(
                        "Handler: {Language}:{DocumentSelector}:{Handler}",
                        handlerCollection.Language,
                        handlerCollection.DocumentSelector.ToString(),
                        handler.GetType().FullName
                        );
                }
            }
            _logger.LogTrace("--- Handler Definitions ---");
        }