public DocumentBuilder( IEnumerable<Assembly> assemblies, ImmutableArray<string> postProcessorNames, string templateHash, string intermediateFolder = null, string commitFromSHA = null, string commitToSHA = null) { Logger.LogVerbose("Loading plug-in..."); using (new LoggerPhaseScope("ImportPlugins", true)) { var assemblyList = assemblies?.ToList(); _container = GetContainer(assemblyList); _container.SatisfyImports(this); _currentBuildInfo.CommitFromSHA = commitFromSHA; _currentBuildInfo.CommitToSHA = commitToSHA; if (intermediateFolder != null) { _currentBuildInfo.PluginHash = ComputePluginHash(assemblyList); _currentBuildInfo.TemplateHash = templateHash; _currentBuildInfo.DirectoryName = IncrementalUtility.CreateRandomDirectory(intermediateFolder); } } Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } _postProcessors = GetPostProcessor(postProcessorNames); _intermediateFolder = intermediateFolder; _lastBuildInfo = LoadLastBuildInfo(); }
public DfmEngineBuilder(Options options, CompositionHost host = null) : base(options) { var inlineRules = InlineRules.ToList(); var index = inlineRules.FindLastIndex(s => s is MarkdownLinkInlineRule); if (index < 0) throw new ArgumentException("MarkdownLinkInlineRule should exist!"); inlineRules.Insert(index + 1, new DfmXrefInlineRule()); inlineRules.Insert(index + 1, new DfmEmailInlineRule()); inlineRules.Insert(index, new DfmIncludeInlineRule()); index = inlineRules.FindIndex(s => s is MarkdownTextInlineRule); inlineRules[index] = new DfmTextInlineRule(); var blockRules = BlockRules.ToList(); index = blockRules.FindLastIndex(s => s is MarkdownNewLineBlockRule); if (index < 0) throw new ArgumentException("MarkdownNewLineBlockRule should exist!"); blockRules.Insert(index + 1, new DfmIncludeBlockRule()); blockRules.Insert(index + 2, new DfmYamlHeaderBlockRule()); blockRules.Insert(index + 3, new DfmSectionBlockRule()); blockRules.Insert(index + 4, new DfmFencesBlockRule()); blockRules.Insert(index + 5, new DfmNoteBlockRule()); var gfmIndex = blockRules.FindIndex(item => item is GfmParagraphBlockRule); blockRules[gfmIndex] = new DfmParagraphBlockRule(); var markdownBlockQuoteIndex = blockRules.FindIndex(item => item is MarkdownBlockquoteBlockRule); blockRules[markdownBlockQuoteIndex] = new DfmBlockquoteBlockRule(); InlineRules = inlineRules.ToImmutableList(); BlockRules = blockRules.ToImmutableList(); Rewriter = InitMarkdownStyleCop(host); }
/// <summary> /// Injects the container. Use this for unit testing where you want to control the type reasolving. /// </summary> /// <param name="container">The container.</param> public static void InjectContainer(CompositionHost container) { lock (_syncRoot) { _container = container; } }
public MefDependencyResolver(AttributedModelProvider builder, IDependencyResolver resolver) { _container = new ContainerConfiguration() .WithAssemblies(AppDomain.CurrentDomain.GetAssemblies(), builder) .CreateContainer(); _resolver = resolver; }
protected void Compose() { // Create the container var config = new ContainerConfiguration(); ConfigureContainer(config); _container = config.CreateContainer(); // Compose the application _container.SatisfyImports(this); }
public override void Dispose() { // Allow the container and everything it references to be garbage collected. if (this.container == null) { return; } this.container.Dispose(); this.container = null; }
protected override void OnInitialize() { base.OnInitialize(); Context = UnitTestSynchronizationContext.Create(); var configuration = new ContainerConfiguration() .WithAssembly(typeof(ShellViewModel).GetTypeInfo().Assembly) .WithAssembly(typeof(ApplicationsTest).GetTypeInfo().Assembly); Container = configuration.CreateContainer(); }
public MefDependencyResolver(CompositionHost rootCompositionScope) : base(new Export<CompositionContext>(rootCompositionScope, rootCompositionScope.Dispose)) { if (rootCompositionScope == null) { throw new ArgumentNullException("rootCompositionScope"); } var factoryContract = new CompositionContract(typeof(ExportFactory<CompositionContext>), null, new Dictionary<string, object> { { "SharingBoundaryNames", new[] { "HttpRequest" } } }); this.RequestScopeFactory = (ExportFactory<CompositionContext>)rootCompositionScope.GetExport(factoryContract); }
public EndpointMiddleware(RequestDelegate next, CompositionHost host, ILoggerFactory loggerFactory) { _next = next; _host = host; _projectSystems = host.GetExports<IProjectSystem>(); _logger = loggerFactory.CreateLogger<EndpointMiddleware>(); var endpoints = _host.GetExports<Lazy<IRequest, EndpointDescriptor>>() .Select(x => x.Metadata); var handlers = _host.GetExports<Lazy<IRequestHandler, OmniSharpLanguage>>(); _endpoints = new HashSet<string>( endpoints .Select(x => x.EndpointName) .Distinct(), StringComparer.OrdinalIgnoreCase ); 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 = endpoints.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, _host, _logger, endpoint, handlers, updateEndpointHandler, Enumerable.Empty<Plugin>()); }), StringComparer.OrdinalIgnoreCase ); _endpointHandlers = new ReadOnlyDictionary<string, Lazy<EndpointHandler>>(endpointHandlers); }
public override void Prepare() { var config = new ContainerConfiguration(); RegisterBasic(config); RegisterPropertyInjection(config); RegisterMultiple(config); RegisterOpenGeneric(config); this.container = config.CreateContainer(); }
public override void Prepare() { var config = new ContainerConfiguration(); RegisterDummies(config); RegisterStandard(config); RegisterComplexObject(config); RegisterPropertyInjection(config); RegisterMultiple(config); RegisterOpenGeneric(config); this.container = config.CreateContainer(); }
/// <summary> /// Create the container. The value returned from this method provides /// the exports in the container, as well as a means to dispose the container. /// </summary> /// <returns>The container.</returns> public CompositionHost CreateContainer() { var providers = _addedSources.ToList(); foreach (var typeSet in _types) { var ac = typeSet.Item2 ?? _defaultAttributeContext ?? new DirectAttributeContext(); providers.Add(new TypedPartExportDescriptorProvider(typeSet.Item1, ac)); } return(CompositionHost.CreateCompositionHost(providers.ToArray())); }
private void EnsureContainer() { if (_container != null) { return; } #if COREFX var configuration = new ContainerConfiguration().WithAssembly(typeof(ElementDifferenceFactory).GetTypeInfo().Assembly); _container = configuration.CreateContainer(); #else _container = new CompositionContainer(new AssemblyCatalog(typeof(ElementDifferenceFactory).Assembly)); #endif }
private OmnisharpWorkspace CreateWorkspace( CompositionHost compositionHost, Dictionary<string, string> sourceFiles) { compositionHost = compositionHost ?? CreatePluginHost(typeof(CodeCheckService).GetTypeInfo().Assembly); var workspace = compositionHost.GetExport<OmnisharpWorkspace>(); AddProjectToWorkspace(workspace, "project.json", new[] { "dnx451", "dnxcore50" }, sourceFiles); // Logic is copied from TestHelper, no idea what's waiting for. Thread.Sleep(50); return workspace; }
public StandaloneDependencyResolver(CompositionHost rootCompositionScope) : base(new Export<CompositionContext>(rootCompositionScope, rootCompositionScope.Dispose)) { if (rootCompositionScope == null) { throw new ArgumentNullException(nameof(rootCompositionScope)); } var metadataConstraints = new Dictionary<string, object> { { "SharingBoundaryNames", new[] { "HttpRequest" } } }; var factoryContract = new CompositionContract(typeof(ExportFactory<CompositionContext>), contractName: null, metadataConstraints: metadataConstraints); this.requestScopeFactory = (ExportFactory<CompositionContext>)rootCompositionScope.GetExport(factoryContract); }
private static IMarkdownTokenRewriter InitMarkdownStyleCop(CompositionHost host) { try { if (File.Exists(MarkdownStyleCopFileName)) { var rules = JsonUtility.Deserialize<MarkdownTagValidationRule[]>(MarkdownStyleCopFileName); var builder = new MarkdownRewriterBuilder(host); builder.AddValidators(rules); return builder.Create(); } } catch (Exception ex) { Logger.LogWarning($"Fail to init markdown stylecop, details:{Environment.NewLine}{ex.ToString()}"); } return null; }
private static IMarkdownTokenRewriter InitMarkdownStyle(CompositionHost host) { try { if (File.Exists(MarkdownSytleConfig.MarkdownStyleFileName)) { var config = JsonUtility.Deserialize<MarkdownSytleConfig>(MarkdownSytleConfig.MarkdownStyleFileName); var builder = new MarkdownValidatorBuilder(host); builder.AddValidators(from r in config.Rules where !r.Disable select r.RuleName); builder.AddTagValidators(config.TagRules); return builder.Create(); } } catch (Exception ex) { Logger.LogWarning($"Fail to init markdown style, details:{Environment.NewLine}{ex.ToString()}"); } return null; }
public static Task<OmnisharpWorkspace> CreateSimpleWorkspace(CompositionHost host, string source, string fileName = "dummy.cs") { return CreateSimpleWorkspace(host, new Dictionary<string, string> { { fileName, source } }); }
public static void Initialize(IEnumerable<Assembly> assemblies) { if (assemblies == null) throw new ArgumentNullException(nameof(assemblies)); if (host != null) throw new InvalidOperationException(Resources.CompositionHostAlreadyInitialized); host = InitializeHost(assemblies); OnHostInitialized(); }
public static void Initialize(string path, string searchPattern) { if (path == null) throw new ArgumentNullException(nameof(path)); var assemblies = new List<Assembly>(); var directory = new DirectoryInfo(path); if (directory.Exists) foreach (var file in directory.EnumerateFiles(searchPattern)) assemblies.Add(Assembly.LoadFrom(file.FullName)); host = InitializeHost(assemblies); OnHostInitialized(); }
public ApplicationInitializedMessage(Frame rootFrame, CompositionHost container) { RootFrame = rootFrame; Container = container; }
public ElementDifferenceFactory(CompositionContainer container, Func <IDifferenceRuleMetadata, bool> ruleFilter = null) { Contract.Requires(container != null); _container = container; _ruleFilter = ruleFilter; }
public MarkdownRewriterBuilder(CompositionHost host) { CompositionHost = host; Validators = ImmutableList<MarkdownTagValidationRule>.Empty; }
private static IMarkdownTokenRewriter InitMarkdownStyle(CompositionHost host, string baseDir, string templateDir) { try { return MarkdownValidatorBuilder.Create(host, baseDir, templateDir).CreateRewriter(); } catch (Exception ex) { Logger.LogWarning($"Fail to init markdown style, details:{Environment.NewLine}{ex.ToString()}"); } return null; }
private async Task<RunCodeActionResponse> RunRefactoringsAsync(string source, string identifier, bool wantsChanges = false) { var request = CreateRunCodeActionRequest(source, identifier, wantsChanges); _host = _host ?? TestHelpers.CreatePluginHost(new[] { typeof(RoslynCodeActionProvider).GetTypeInfo().Assembly, typeof(NRefactoryCodeActionProvider).GetTypeInfo().Assembly, typeof(GetCodeActionsService).GetTypeInfo().Assembly }); _workspace = _workspace ?? await TestHelpers.CreateSimpleWorkspace(_host, request.Buffer, bufferPath); var controller = new RunCodeActionService(_workspace, new ICodeActionProvider[] { new RoslynCodeActionProvider(), new NRefactoryCodeActionProvider() }, new FakeLoggerFactory()); var response = await controller.Handle(request); return response; }
private async Task<IEnumerable<OmniSharpCodeAction>> FindRefactoringsAsync(string source) { var request = CreateGetCodeActionsRequest(source); _host = _host ?? TestHelpers.CreatePluginHost(new[] { typeof(RoslynCodeActionProvider).GetTypeInfo().Assembly, typeof(NRefactoryCodeActionProvider).GetTypeInfo().Assembly, typeof(GetCodeActionsService).GetTypeInfo().Assembly }); _workspace = _workspace ?? await TestHelpers.CreateSimpleWorkspace(_host, request.Buffer, bufferPath); var controller = new GetCodeActionsService(_workspace, new ICodeActionProvider[] { new RoslynCodeActionProvider(), new NRefactoryCodeActionProvider() }, new FakeLoggerFactory()); var response = await controller.Handle(request); return response.CodeActions; }
public async static Task<OmnisharpWorkspace> CreateSimpleWorkspace(CompositionHost _host, Dictionary<string, string> sourceFiles) { var host = _host ?? CreatePluginHost(new[] { typeof(CodeCheckService).GetTypeInfo().Assembly }); var workspace = host.GetExport<OmnisharpWorkspace>(); await AddProjectToWorkspace(workspace, "project.json", new[] { "dnx451", "dnxcore50" }, sourceFiles); await Task.Delay(50); return workspace; }
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 assemblies = DependencyContext.Default .RuntimeLibraries .Where(shouldLoad) .SelectMany(lib => lib.Assemblies) .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."); }
public MarkdownRewriterContext(CompositionHost host, ImmutableList<MarkdownTagValidationRule> validators) { CompositionHost = host; Validators = validators; }
public static void InitializeContainer(IEnumerable<string> appAssemblyNames) { var assemblies = appAssemblyNames.Select(p => Assembly.Load(new AssemblyName(p))); var configuration = new ContainerConfiguration().WithAssemblies(assemblies); _container = configuration.CreateContainer(); }
public static void InitializeContainer(IEnumerable<Assembly> appAssemblies) { var configuration = new ContainerConfiguration().WithAssemblies(appAssemblies); _container = configuration.CreateContainer(); }
void SetupMef() { MefContainer = new ContainerConfiguration() .WithAssembly(typeof(Program).Assembly) .WithAssemblies(Directory.EnumerateFiles(AppDirectory, typeof(Program).Assembly.GetName().Name + ".*.dll") .Select(Assembly.LoadFrom)) .CreateContainer(); }
public override void PrepareBasic() { var config = new ContainerConfiguration(); RegisterBasic(config); this.container = config.CreateContainer(); }