internal static bool InitPlugins() { string pluginsPath = Path.Combine(SharedInfo.HomeDirectory, SharedInfo.PluginsDirectory); if (!Directory.Exists(pluginsPath)) { ASF.ArchiLogger.LogGenericTrace(Strings.NothingFound); return(true); } HashSet <Assembly> assemblies = new HashSet <Assembly>(); try { foreach (string assemblyPath in Directory.EnumerateFiles(pluginsPath, "*.dll", SearchOption.AllDirectories)) { Assembly assembly; try { assembly = Assembly.LoadFrom(assemblyPath); } catch (Exception e) { ASF.ArchiLogger.LogGenericError(string.Format(Strings.ErrorIsInvalid, assemblyPath)); ASF.ArchiLogger.LogGenericWarningException(e); continue; } assemblies.Add(assembly); } } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); return(false); } if (assemblies.Count == 0) { ASF.ArchiLogger.LogGenericTrace(Strings.NothingFound); return(true); } ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.Initializing, nameof(Plugins))); ConventionBuilder conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IPlugin>().Export <IPlugin>(); ContainerConfiguration configuration = new ContainerConfiguration().WithAssemblies(assemblies, conventions); HashSet <IPlugin> activePlugins; try { using (CompositionHost container = configuration.CreateContainer()) { activePlugins = container.GetExports <IPlugin>().ToHashSet(); } } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); return(false); } if (activePlugins.Count == 0) { return(true); } HashSet <IPlugin> invalidPlugins = new HashSet <IPlugin>(); foreach (IPlugin plugin in activePlugins) { try { string pluginName = plugin.Name; ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.PluginLoading, pluginName, plugin.Version)); plugin.OnLoaded(); ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.PluginLoaded, pluginName)); } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); invalidPlugins.Add(plugin); } } if (invalidPlugins.Count > 0) { activePlugins.ExceptWith(invalidPlugins); if (activePlugins.Count == 0) { return(false); } } ActivePlugins = activePlugins.ToImmutableHashSet(); ASF.ArchiLogger.LogGenericInfo(Strings.PluginsWarning); return(invalidPlugins.Count == 0); }
private IDictionary <string, Lazy <EndpointHandler> > Initialize() { var workspace = _compositionHost.GetExport <OmniSharpWorkspace>(); var projectSystems = _compositionHost.GetExports <IProjectSystem>(); var endpointMetadatas = _compositionHost.GetExports <Lazy <IRequest, OmniSharpEndpointMetadata> >() .Select(x => x.Metadata) .ToArray(); var handlers = _compositionHost.GetExports <Lazy <IRequestHandler, OmniSharpRequestHandlerMetadata> >(); var updateBufferEndpointHandler = new Lazy <EndpointHandler <UpdateBufferRequest, object> >( () => (EndpointHandler <UpdateBufferRequest, object>)_endpointHandlers[OmniSharpEndpoints.UpdateBuffer].Value); var languagePredicateHandler = new LanguagePredicateHandler(projectSystems); var projectSystemPredicateHandler = new StaticLanguagePredicateHandler("Projects"); var nugetPredicateHandler = new StaticLanguagePredicateHandler("NuGet"); var endpointHandlers = endpointMetadatas.ToDictionary( x => x.EndpointName, endpoint => new Lazy <EndpointHandler>(() => { IPredicateHandler handler; // Projects are a special case, this allows us to select the correct "Projects" language for them if (endpoint.EndpointName == OmniSharpEndpoints.ProjectInformation || endpoint.EndpointName == OmniSharpEndpoints.WorkspaceInformation) { handler = projectSystemPredicateHandler; } else if (endpoint.EndpointName == OmniSharpEndpoints.PackageSearch || endpoint.EndpointName == OmniSharpEndpoints.PackageSource || endpoint.EndpointName == OmniSharpEndpoints.PackageVersion) { handler = nugetPredicateHandler; } else { handler = languagePredicateHandler; } // This lets any endpoint, that contains a Request object, invoke update buffer. // The language will be same language as the caller, this means any language service // must implement update buffer. var updateEndpointHandler = updateBufferEndpointHandler; if (endpoint.EndpointName == OmniSharpEndpoints.UpdateBuffer) { // We don't want to call update buffer on update buffer. updateEndpointHandler = new Lazy <EndpointHandler <UpdateBufferRequest, object> >(() => null); } return(EndpointHandler.Factory(handler, _compositionHost, _logger, endpoint, handlers, updateEndpointHandler, Enumerable.Empty <Plugin>())); }), StringComparer.OrdinalIgnoreCase ); // Handled as alternative middleware in http endpointHandlers.Add( OmniSharpEndpoints.CheckAliveStatus, new Lazy <EndpointHandler>( () => new GenericEndpointHandler(x => Task.FromResult <object>(true))) ); endpointHandlers.Add( OmniSharpEndpoints.CheckReadyStatus, new Lazy <EndpointHandler>( () => new GenericEndpointHandler(x => Task.FromResult <object>(workspace.Initialized))) ); endpointHandlers.Add( OmniSharpEndpoints.StopServer, new Lazy <EndpointHandler>( () => new GenericEndpointHandler(x => { _cancellationTokenSource.Cancel(); return(Task.FromResult <object>(null)); })) ); return(endpointHandlers); }
public static int Main(string[] args) { var app = new CommandLineApplication { Name = "ApiCompat", FullName = "A command line tool to verify that two sets of APIs are compatible.", ResponseFileHandling = ResponseFileHandling.ParseArgsAsSpaceSeparated }; app.HelpOption("-?|-h|--help"); app.VersionOption("-v|--version", GetAssemblyVersion()); CommandArgument contracts = app.Argument("contracts", "Comma delimited list of assemblies or directories of assemblies for all the contract assemblies."); contracts.IsRequired(); CommandOption implDirs = app.Option("-i|--impl-dirs", "Comma delimited list of directories to find the implementation assemblies for each contract assembly.", CommandOptionType.SingleValue); implDirs.IsRequired(allowEmptyStrings: true); CommandOption baseline = app.Option("-b|--baseline", "Baseline file to skip known diffs.", CommandOptionType.SingleValue); CommandOption mdil = app.Option("-m|--mdil", "Enforce MDIL servicing rules in addition to IL rules.", CommandOptionType.NoValue); CommandOption outFilePath = app.Option("-o|--out", "Output file path. Default is the console.", CommandOptionType.SingleValue); CommandOption leftOperand = app.Option("-l|--left-operand", "Name for left operand in comparison, default is 'contract'.", CommandOptionType.SingleValue); CommandOption rightOperand = app.Option("-r|--right-operand", "Name for right operand in comparison, default is 'implementation'.", CommandOptionType.SingleValue); CommandOption listRules = app.Option("--list-rules", "Outputs all the rules. If this options is supplied all other options are ignored.", CommandOptionType.NoValue); CommandOption remapFile = app.Option("--remap-file", "File with a list of type and/or namespace remappings to consider apply to names while diffing.", CommandOptionType.SingleValue); CommandOption skipGroupByAssembly = app.Option("--skip-group-by-assembly", "Skip grouping the differences by assembly instead of flattening the namespaces.", CommandOptionType.NoValue); CommandOption skipUnifyToLibPath = app.Option("--skip-unify-to-lib-path", "Skip unifying the assembly references to the loaded assemblies and the assemblies found in the given directories (contractDepends and implDirs).", CommandOptionType.NoValue); CommandOption resolveFx = app.Option("--resolve-fx", "If a contract or implementation dependency cannot be found in the given directories, fallback to try to resolve against the framework directory on the machine.", CommandOptionType.NoValue); CommandOption contractDepends = app.Option("--contract-depends", "Comma delimited list of directories used to resolve the dependencies of the contract assemblies.", CommandOptionType.SingleValue); CommandOption contractCoreAssembly = app.Option("--contract-core-assembly", "Simple name for the core assembly to use.", CommandOptionType.SingleValue); CommandOption ignoreDesignTimeFacades = app.Option("--ignore-design-time-facades", "Ignore design time facades in the contract set while analyzing.", CommandOptionType.NoValue); CommandOption warnOnIncorrectVersion = app.Option("--warn-on-incorrect-version", "Warn if the contract version number doesn't match the found implementation version number.", CommandOptionType.NoValue); CommandOption warnOnMissingAssemblies = app.Option("--warn-on-missing-assemblies", "Warn if the contract assembly cannot be found in the implementation directories. Default is to error and not do analysis.", CommandOptionType.NoValue); CommandOption excludeNonBrowsable = app.Option("--exclude-non-browsable", "When MDIL servicing rules are not being enforced, exclude validation on types that are marked with EditorBrowsable(EditorBrowsableState.Never).", CommandOptionType.NoValue); CommandOption excludeAttributes = app.Option("--exclude-attributes", "Specify a api list in the DocId format of which attributes to exclude.", CommandOptionType.SingleValue); CommandOption enforceOptionalRules = app.Option("--enforce-optional-rules", "Enforce optional rules, in addition to the mandatory set of rules.", CommandOptionType.NoValue); CommandOption allowDefaultInterfaceMethods = app.Option("--allow-default-interface-methods", "Allow default interface methods additions to not be considered breaks. This flag should only be used if you know your consumers support DIM", CommandOptionType.NoValue); app.OnExecute(() => { string leftOperandValue = leftOperand.HasValue() ? leftOperand.Value() : "contract"; string rightOperandValue = rightOperand.HasValue() ? rightOperand.Value() : "implementation"; if (listRules.HasValue()) { CompositionHost c = GetCompositionHost(); ExportCciSettings.StaticSettings = CciComparers.Default.GetEqualityComparer <ITypeReference>(); var rules = c.GetExports <IDifferenceRule>(); foreach (var rule in rules.OrderBy(r => r.GetType().Name, StringComparer.OrdinalIgnoreCase)) { string ruleName = rule.GetType().Name; if (IsOptionalRule(rule)) { ruleName += " (optional)"; } Console.WriteLine(ruleName); } return(0); } using (TextWriter output = GetOutput(outFilePath.Value())) { if (DifferenceWriter.ExitCode != 0) { return(0); } if (output != Console.Out) { Trace.Listeners.Add(new TextWriterTraceListener(output) { Filter = new EventTypeFilter(SourceLevels.Error | SourceLevels.Warning) }); } try { BaselineDifferenceFilter filter = GetBaselineDifferenceFilter(baseline.Value()); NameTable sharedNameTable = new NameTable(); HostEnvironment contractHost = new HostEnvironment(sharedNameTable); contractHost.UnableToResolve += (sender, e) => Trace.TraceError($"Unable to resolve assembly '{e.Unresolved}' referenced by the {leftOperandValue} assembly '{e.Referrer}'."); contractHost.ResolveAgainstRunningFramework = resolveFx.HasValue(); contractHost.UnifyToLibPath = !skipUnifyToLibPath.HasValue(); contractHost.AddLibPaths(HostEnvironment.SplitPaths(contractDepends.Value())); IEnumerable <IAssembly> contractAssemblies = contractHost.LoadAssemblies(contracts.Value, contractCoreAssembly.Value()); if (ignoreDesignTimeFacades.HasValue()) { contractAssemblies = contractAssemblies.Where(a => !a.IsFacade()); } HostEnvironment implHost = new HostEnvironment(sharedNameTable); implHost.UnableToResolve += (sender, e) => Trace.TraceError($"Unable to resolve assembly '{e.Unresolved}' referenced by the {rightOperandValue} assembly '{e.Referrer}'."); implHost.ResolveAgainstRunningFramework = resolveFx.HasValue(); implHost.UnifyToLibPath = !skipUnifyToLibPath.HasValue(); implHost.AddLibPaths(HostEnvironment.SplitPaths(implDirs.Value())); if (warnOnMissingAssemblies.HasValue()) { implHost.LoadErrorTreatment = ErrorTreatment.TreatAsWarning; } // The list of contractAssemblies already has the core assembly as the first one (if _contractCoreAssembly was specified). IEnumerable <IAssembly> implAssemblies = implHost.LoadAssemblies(contractAssemblies.Select(a => a.AssemblyIdentity), warnOnIncorrectVersion.HasValue()); // Exit after loading if the code is set to non-zero if (DifferenceWriter.ExitCode != 0) { return(0); } ICciDifferenceWriter writer = GetDifferenceWriter(output, filter, enforceOptionalRules.HasValue(), mdil.HasValue(), excludeNonBrowsable.HasValue(), remapFile.Value(), !skipGroupByAssembly.HasValue(), leftOperandValue, rightOperandValue, excludeAttributes.Value(), allowDefaultInterfaceMethods.HasValue()); writer.Write(implDirs.Value(), implAssemblies, contracts.Value, contractAssemblies); return(0); } catch (FileNotFoundException) { // FileNotFoundException will be thrown by GetBaselineDifferenceFilter if it doesn't find the baseline file // OR if GetComparers doesn't find the remap file. return(2); } } }); return(app.Execute(args)); }
public static ImmutableArray <T> GetExports <T>(IEnumerable <Assembly> assemblies) { CompositionHost container = CreateCompositionContainer <T>(assemblies); return(container.GetExports <T>().ToImmutableArray()); }
private IEnumerable <IServiceRegistrar> GetDerivedRegistrars(CompositionHost container) { return(container .GetExports <IServiceRegistrar>() .Where(b => b.GetType() != typeof(RegistrarLoader))); }
public static IEnumerable <T> GetInstances <T>() { return(s_compositionHost.GetExports <T>()); }
public static int Main(string[] args) { ParseCommandLine(args); CommandLineTraceHandler.Enable(); if (s_listRules) { CompositionHost c = GetCompositionHost(); ExportCciSettings.StaticSettings = CciComparers.Default.GetEqualityComparer <ITypeReference>(); var rules = c.GetExports <IDifferenceRule>(); foreach (var rule in rules.Select(r => r.GetType().Name).OrderBy(r => r, StringComparer.OrdinalIgnoreCase)) { Console.WriteLine(rule); } return(0); } using (TextWriter output = GetOutput()) { if (DifferenceWriter.ExitCode != 0) { return(0); } if (output != Console.Out) { Trace.Listeners.Add(new TextWriterTraceListener(output) { Filter = new EventTypeFilter(SourceLevels.Error | SourceLevels.Warning) }); } try { BaselineDifferenceFilter filter = GetBaselineDifferenceFilter(); NameTable sharedNameTable = new NameTable(); HostEnvironment contractHost = new HostEnvironment(sharedNameTable); contractHost.UnableToResolve += new EventHandler <UnresolvedReference <IUnit, AssemblyIdentity> >(contractHost_UnableToResolve); contractHost.ResolveAgainstRunningFramework = s_resolveFx; contractHost.UnifyToLibPath = s_unifyToLibPaths; contractHost.AddLibPaths(HostEnvironment.SplitPaths(s_contractLibDirs)); IEnumerable <IAssembly> contractAssemblies = contractHost.LoadAssemblies(s_contractSet, s_contractCoreAssembly); if (s_ignoreDesignTimeFacades) { contractAssemblies = contractAssemblies.Where(a => !a.IsFacade()); } HostEnvironment implHost = new HostEnvironment(sharedNameTable); implHost.UnableToResolve += new EventHandler <UnresolvedReference <IUnit, AssemblyIdentity> >(implHost_UnableToResolve); implHost.ResolveAgainstRunningFramework = s_resolveFx; implHost.UnifyToLibPath = s_unifyToLibPaths; implHost.AddLibPaths(HostEnvironment.SplitPaths(s_implDirs)); if (s_warnOnMissingAssemblies) { implHost.LoadErrorTreatment = ErrorTreatment.TreatAsWarning; } // The list of contractAssemblies already has the core assembly as the first one (if _contractCoreAssembly was specified). IEnumerable <IAssembly> implAssemblies = implHost.LoadAssemblies(contractAssemblies.Select(a => a.AssemblyIdentity), s_warnOnIncorrectVersion); // Exit after loading if the code is set to non-zero if (DifferenceWriter.ExitCode != 0) { return(0); } ICciDifferenceWriter writer = GetDifferenceWriter(output, filter); writer.Write(s_implDirs, implAssemblies, s_contractSet, contractAssemblies); return(0); } catch (FileNotFoundException) { // FileNotFoundException will be thrown by GetBaselineDifferenceFilter if it doesn't find the baseline file // OR if GetComparers doesn't find the remap file. return(2); } } }
public void Configure(IApplicationBuilder app, IServiceProvider serviceProvider, IOmnisharpEnvironment env, ILoggerFactory loggerFactory, ISharedTextWriter writer, IOmnisharpAssemblyLoader loader, IOptions <OmniSharpOptions> optionsAccessor) { Func <RuntimeLibrary, bool> shouldLoad = lib => lib.Dependencies.Any(dep => dep.Name == "OmniSharp.Abstractions" || dep.Name == "OmniSharp.Roslyn"); var dependencyContext = DependencyContext.Default; var assemblies = dependencyContext.RuntimeLibraries .Where(shouldLoad) .SelectMany(lib => lib.GetDefaultAssemblyNames(dependencyContext)) .Select(each => loader.Load(each.Name)) .ToList(); PluginHost = ConfigureMef(serviceProvider, optionsAccessor.Value, assemblies); Workspace = PluginHost.GetExport <OmnisharpWorkspace>(); if (env.TransportType == TransportType.Stdio) { loggerFactory.AddStdio(writer, (category, level) => LogFilter(category, level, env)); } else { loggerFactory.AddConsole((category, level) => LogFilter(category, level, env)); } var logger = loggerFactory.CreateLogger <Startup>(); foreach (var assembly in assemblies) { logger.LogDebug($"Loaded {assembly.FullName}"); } app.UseRequestLogging(); app.UseExceptionHandler("/error"); app.UseMiddleware <EndpointMiddleware>(); app.UseMiddleware <StatusMiddleware>(); app.UseMiddleware <StopServerMiddleware>(); if (env.TransportType == TransportType.Stdio) { logger.LogInformation($"Omnisharp server running using {nameof(TransportType.Stdio)} at location '{env.Path}' on host {env.HostPID}."); } else { logger.LogInformation($"Omnisharp server running on port '{env.Port}' at location '{env.Path}' on host {env.HostPID}."); } // ProjectEventForwarder register event to OmnisharpWorkspace during instantiation PluginHost.GetExport <ProjectEventForwarder>(); // Initialize all the project systems foreach (var projectSystem in PluginHost.GetExports <IProjectSystem>()) { try { projectSystem.Initalize(Configuration.GetSection(projectSystem.Key)); } catch (Exception e) { var message = $"The project system '{projectSystem.GetType().Name}' threw exception during initialization.\n{e.Message}\n{e.StackTrace}"; // if a project system throws an unhandled exception it should not crash the entire server logger.LogError(message); } } // Mark the workspace as initialized Workspace.Initialized = true; logger.LogInformation("Configuration finished."); }
internal static RequestHandlers ConfigureCompositionHost(ILanguageServer server, CompositionHost compositionHost) { 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() .SelectMany(z => { if (x.Key == LanguageNames.CSharp && z == ".cs") { return(new[] { new DocumentFilter() { Pattern = $"**/*{z}" }, new DocumentFilter() { Scheme = "csharp" } }); } return(new[] { new DocumentFilter() { Pattern = $"**/*{z}" }, }); }) ) )) .ToArray(); var logger = compositionHost.GetExport <ILoggerFactory>().CreateLogger <LanguageServerHost>(); logger.LogTrace( "Configured Document Selectors {@DocumentSelectors}", documentSelectors.Select(x => new { x.language, x.selector }) ); var omnisharpRequestHandlers = compositionHost.GetExports <Lazy <IRequestHandler, OmniSharpRequestHandlerMetadata> >(); // TODO: Get these with metadata so we can attach languages // This will then 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 var handlers = new RequestHandlers(omnisharpRequestHandlers, 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 ); } } // the goal here is add interoperability between omnisharp and LSP // This way an existing client (say vscode) that is using the custom omnisharp protocol can migrate to the new one // and not loose any functionality. server.Register(r => { var defaultOptions = new JsonRpcHandlerOptions() { RequestProcessType = RequestProcessType.Parallel }; var interop = InitializeInterop(compositionHost); foreach (var osHandler in interop) { var method = $"o#/{osHandler.Key.Trim('/').ToLowerInvariant()}"; r.OnJsonRequest(method, CreateInteropHandler(osHandler.Value), defaultOptions); logger.LogTrace("O# Handler: {Method}", method); }
protected override IEnumerable <object> GetAllInstances(Type serviceType) { return(_compositionHost.GetExports(serviceType)); }
public void Configure(IApplicationBuilder app, IServiceProvider serviceProvider, IOmnisharpEnvironment env, ILoggerFactory loggerFactory, ISharedTextWriter writer, IOptions <OmniSharpOptions> optionsAccessor) { var assemblies = DnxPlatformServices.Default.LibraryManager.GetReferencingLibraries("OmniSharp.Abstractions") .SelectMany(libraryInformation => libraryInformation.Assemblies) .Concat( DnxPlatformServices.Default.LibraryManager.GetReferencingLibraries("OmniSharp.Roslyn") .SelectMany(libraryInformation => libraryInformation.Assemblies) ) .Select(assemblyName => Assembly.Load(assemblyName)); PluginHost = ConfigureMef(serviceProvider, optionsAccessor.Value, assemblies); Workspace = PluginHost.GetExport <OmnisharpWorkspace>(); if (env.TransportType == TransportType.Stdio) { loggerFactory.AddStdio(writer, (category, level) => LogFilter(category, level, env)); } else { loggerFactory.AddConsole((category, level) => LogFilter(category, level, env)); } var logger = loggerFactory.CreateLogger <Startup>(); app.UseRequestLogging(); app.UseExceptionHandler("/error"); app.UseMiddleware <EndpointMiddleware>(); app.UseMiddleware <StatusMiddleware>(); app.UseMiddleware <StopServerMiddleware>(); if (env.TransportType == TransportType.Stdio) { logger.LogInformation($"Omnisharp server running using stdio at location '{env.Path}' on host {env.HostPID}."); } else { logger.LogInformation($"Omnisharp server running on port '{env.Port}' at location '{env.Path}' on host {env.HostPID}."); } // Forward workspace events PluginHost.GetExport <ProjectEventForwarder>(); foreach (var projectSystem in PluginHost.GetExports <IProjectSystem>()) { try { projectSystem.Initalize(Configuration.GetSection(projectSystem.Key)); } catch (Exception e) { //if a project system throws an unhandled exception //it should not crash the entire server logger.LogError($"The project system '{projectSystem.GetType().Name}' threw an exception.", e); } } // Mark the workspace as initialized Workspace.Initialized = true; logger.LogInformation("Solution has finished loading"); }
public IEsotericInterpreter InterpreterFor(string language) { return(Container.GetExports <IEsotericInterpreter>().FirstOrDefault(interp => interp.Language == language)); }
/// <summary>Enumerates plugin providers exported from assemblies in the current executable folder.</summary> public static IEnumerable <IWpPluginProvider> GetProviders(CompositionHost host) => host.GetExports <IWpPluginProvider>();
/// <summary> /// Finds all the extensions from the given base type. /// </summary> /// <returns>The extensions.</returns> /// <typeparam name="T">Type of the extension point.</typeparam> public IEnumerable <T> FindExtensions <T>() { return(container.GetExports <T>()); }
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 ---"); }
public IEnumerable <T> GetServices <T>() { return(_container.GetExports <T>()); }
internal static bool InitPlugins() { HashSet <Assembly> assemblies = LoadAssemblies(); if ((assemblies == null) || (assemblies.Count == 0)) { ASF.ArchiLogger.LogGenericTrace(Strings.NothingFound); return(true); } ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.Initializing, nameof(Plugins))); ConventionBuilder conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IPlugin>().Export <IPlugin>(); ContainerConfiguration configuration = new ContainerConfiguration().WithAssemblies(assemblies, conventions); HashSet <IPlugin> activePlugins; try { using (CompositionHost container = configuration.CreateContainer()) { activePlugins = container.GetExports <IPlugin>().ToHashSet(); } } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); return(false); } if (activePlugins.Count == 0) { return(true); } HashSet <IPlugin> invalidPlugins = new HashSet <IPlugin>(); foreach (IPlugin plugin in activePlugins) { try { string pluginName = plugin.Name; ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.PluginLoading, pluginName, plugin.Version)); plugin.OnLoaded(); ASF.ArchiLogger.LogGenericInfo(string.Format(Strings.PluginLoaded, pluginName)); } catch (Exception e) { ASF.ArchiLogger.LogGenericException(e); invalidPlugins.Add(plugin); } } if (invalidPlugins.Count > 0) { activePlugins.ExceptWith(invalidPlugins); if (activePlugins.Count == 0) { return(false); } } ActivePlugins = activePlugins.ToImmutableHashSet(); ASF.ArchiLogger.LogGenericInfo(Strings.PluginsWarning); return(invalidPlugins.Count == 0); }
/// <summary> /// The core part of ApiCompat which accepts a given set of arguments and /// performs api compatibility checks. /// </summary> public static int Run(bool usesMSBuildLog, bool disableAssemblyResolveTraceListener, IEnumerable <string> contracts, IEnumerable <string> implementationDirectories, TextWriter output, string rightOperand = "implementation", string leftOperand = "contract", bool listRules = false, IEnumerable <string> baselineFileNames = null, bool validateBaseline = false, bool resolveFramework = false, bool skipUnifyToLibPath = false, IEnumerable <string> contractDependsFileNames = null, string contractCoreAssembly = null, bool ignoreDesignTimeFacades = false, bool warnOnMissingAssemblies = false, bool respectInternals = false, bool warnOnIncorrectVersion = false, bool enforceOptionalRules = false, bool mdil = false, bool excludeNonBrowsable = false, bool excludeCompilerGenerated = false, string remapFile = null, bool skipGroupByAssembly = false, IEnumerable <string> excludeAttributes = null, bool allowDefaultInterfaceMethods = false) { // Clear exit code from previous runs on the same domain given this is a static property. DifferenceWriter.ExitCode = 0; if (listRules) { CompositionHost c = GetCompositionHost(); ExportCciSettings.StaticSettings = CciComparers.Default.GetEqualityComparer <ITypeReference>(); IEnumerable <IDifferenceRule> rules = c.GetExports <IDifferenceRule>(); foreach (IDifferenceRule rule in rules.OrderBy(r => r.GetType().Name, StringComparer.OrdinalIgnoreCase)) { string ruleName = rule.GetType().Name; if (IsOptionalRule(rule)) { ruleName += " (optional)"; } output.WriteLine(ruleName); } return(0); } using (output) { if (DifferenceWriter.ExitCode != 0) { return(0); } if (!disableAssemblyResolveTraceListener) { Trace.Listeners.Add(new TextWriterTraceListener(output) { Filter = new EventTypeFilter(SourceLevels.Error | SourceLevels.Warning) }); } try { BaselineDifferenceFilter filter = GetBaselineDifferenceFilter(baselineFileNames, validateBaseline); NameTable sharedNameTable = new(); HostEnvironment contractHost = new(sharedNameTable); contractHost.UnableToResolve += (sender, e) => Trace.TraceError($"Unable to resolve assembly '{e.Unresolved}' referenced by the {leftOperand} assembly '{e.Referrer}'."); contractHost.ResolveAgainstRunningFramework = resolveFramework; contractHost.UnifyToLibPath = !skipUnifyToLibPath; contractHost.AddLibPaths(contractDependsFileNames); IEnumerable <IAssembly> contractAssemblies = contractHost.LoadAssemblies(contracts, contractCoreAssembly); if (ignoreDesignTimeFacades) { contractAssemblies = contractAssemblies.Where(a => !a.IsFacade()); } HostEnvironment implHost = new(sharedNameTable); implHost.UnableToResolve += (sender, e) => Trace.TraceError($"Unable to resolve assembly '{e.Unresolved}' referenced by the {rightOperand} assembly '{e.Referrer}'."); implHost.ResolveAgainstRunningFramework = resolveFramework; implHost.UnifyToLibPath = !skipUnifyToLibPath; implHost.AddLibPaths(implementationDirectories); if (warnOnMissingAssemblies) { implHost.LoadErrorTreatment = ErrorTreatment.TreatAsWarning; } // The list of contractAssemblies already has the core assembly as the first one (if _contractCoreAssembly was specified). IEnumerable <IAssembly> implAssemblies = implHost.LoadAssemblies(contractAssemblies.Select(a => a.AssemblyIdentity), warnOnIncorrectVersion); // Exit after loading if the code is set to non-zero if (DifferenceWriter.ExitCode != 0) { return(0); } bool includeInternals = respectInternals && contractAssemblies.Any(assembly => assembly.Attributes.HasAttributeOfType( "System.Runtime.CompilerServices.InternalsVisibleToAttribute")); ICciDifferenceWriter writer = GetDifferenceWriter( output, filter, enforceOptionalRules, mdil, excludeNonBrowsable, includeInternals, excludeCompilerGenerated, remapFile, !skipGroupByAssembly, leftOperand, rightOperand, excludeAttributes, allowDefaultInterfaceMethods, usesMSBuildLog); writer.Write(string.Join(",", implementationDirectories), implAssemblies, string.Join(",", contracts), contractAssemblies); return(0); } catch (FileNotFoundException) { // FileNotFoundException will be thrown by GetBaselineDifferenceFilter if it doesn't find the baseline file // OR if GetComparers doesn't find the remap file. return(2); } } }