/// <summary> /// Calculate dignostics. this works differently than other ones such as todo comments or designer attribute scanner /// since in proc and out of proc runs quite differently due to concurrency and due to possible amount of data /// that needs to pass through between processes /// </summary> public Task CalculateDiagnosticsAsync(PinnedSolutionInfo solutionInfo, DiagnosticArguments arguments, string pipeName, CancellationToken cancellationToken) { return(RunServiceAsync(async() => { using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_CalculateDiagnosticsAsync, arguments.ProjectId.DebugName, cancellationToken)) using (arguments.IsHighPriority ? UserOperationBooster.Boost() : default) { var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false); var documentId = arguments.DocumentId; var projectId = arguments.ProjectId; var project = solution.GetProject(projectId); var documentSpan = arguments.DocumentSpan; var documentAnalysisKind = arguments.DocumentAnalysisKind; var diagnosticComputer = new DiagnosticComputer(documentId, project, documentSpan, documentAnalysisKind, _analyzerInfoCache); var result = await diagnosticComputer.GetDiagnosticsAsync( arguments.AnalyzerIds, reportSuppressedDiagnostics: arguments.ReportSuppressedDiagnostics, logPerformanceInfo: arguments.LogPerformanceInfo, getTelemetryInfo: arguments.GetTelemetryInfo, cancellationToken).ConfigureAwait(false); await RemoteEndPoint.WriteDataToNamedPipeAsync(pipeName, (result, documentAnalysisKind), (writer, data, cancellationToken) => { var(diagnostics, telemetry) = DiagnosticResultSerializer.WriteDiagnosticAnalysisResults(writer, data.documentAnalysisKind, data.result, cancellationToken); // save log for debugging Log(TraceEventType.Information, $"diagnostics: {diagnostics}, telemetry: {telemetry}"); return Task.CompletedTask; }, cancellationToken).ConfigureAwait(false); } }, cancellationToken)); }
/// <summary> /// Calculate dignostics. this works differently than other ones such as todo comments or designer attribute scanner /// since in proc and out of proc runs quite differently due to concurrency and due to possible amount of data /// that needs to pass through between processes /// </summary> public Task CalculateDiagnosticsAsync(DiagnosticArguments arguments, string pipeName, CancellationToken cancellationToken) { return(RunServiceAsync(async() => { // if this analysis is explicitly asked by user, boost priority of this request using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_CalculateDiagnosticsAsync, arguments.ProjectId.DebugName, cancellationToken)) using (arguments.ForcedAnalysis ? UserOperationBooster.Boost() : default) { // entry point for diagnostic service var solution = await GetSolutionAsync(cancellationToken).ConfigureAwait(false); var projectId = arguments.ProjectId; var analyzers = RoslynServices.AssetService.GetGlobalAssetsOfType <AnalyzerReference>(cancellationToken); var result = await new DiagnosticComputer(solution.GetProject(projectId)).GetDiagnosticsAsync( analyzers, arguments.AnalyzerIds, arguments.ReportSuppressedDiagnostics, arguments.LogAnalyzerExecutionTime, cancellationToken).ConfigureAwait(false); await RemoteEndPoint.WriteDataToNamedPipeAsync(pipeName, result, (writer, data, cancellationToken) => { var(diagnostics, telemetry, exceptions) = DiagnosticResultSerializer.WriteDiagnosticAnalysisResults(writer, data, cancellationToken); // save log for debugging Log(TraceEventType.Information, $"diagnostics: {diagnostics}, telemetry: {telemetry}, exceptions: {exceptions}"); return Task.CompletedTask; }, cancellationToken).ConfigureAwait(false); } }, cancellationToken)); }
public FindReferencesProgressCallback(Solution solution, RemoteEndPoint endPoint, CancellationToken cancellationToken) { _solution = solution; _endPoint = endPoint; _cancellationToken = cancellationToken; ProgressTracker = this; }
private ServiceHubRemoteHostClient( HostWorkspaceServices services, HubClient hubClient, HostGroup hostGroup, Stream stream) { _connectionPools = new ConnectionPools( connectionFactory: (serviceName, pool, cancellationToken) => CreateConnectionImplAsync(serviceName, callbackTarget: null, pool, cancellationToken), capacity: ConnectionPoolCapacity); // use the hub client logger for unexpected exceptions from devenv as well, so we have complete information in the log: services.GetService <IWorkspaceTelemetryService>()?.RegisterUnexpectedExceptionLogger(hubClient.Logger); _services = services; _hubClient = hubClient; _hostGroup = hostGroup; _endPoint = new RemoteEndPoint(stream, hubClient.Logger, incomingCallTarget: this); _endPoint.Disconnected += OnDisconnected; _endPoint.UnexpectedExceptionThrown += OnUnexpectedExceptionThrown; _endPoint.StartListening(); _assetStorage = services.GetRequiredService <ISolutionAssetStorageProvider>().AssetStorage; _serializer = services.GetRequiredService <ISerializerService>(); }
protected ServiceBase(IServiceProvider serviceProvider, Stream stream, IEnumerable <JsonConverter>?jsonConverters = null) { InstanceId = Interlocked.Add(ref s_instanceId, 1); // in unit test, service provider will return asset storage, otherwise, use the default one AssetStorage = (AssetStorage)serviceProvider.GetService(typeof(AssetStorage)) ?? AssetStorage.Default; Logger = (TraceSource)serviceProvider.GetService(typeof(TraceSource)); Log(TraceEventType.Information, "Service instance created"); // invoke all calls incoming over the stream on this service instance: EndPoint = new RemoteEndPoint(stream, Logger, incomingCallTarget: this, jsonConverters); }
public JsonRpcConnection( HostWorkspaceServices services, TraceSource logger, object?callbackTarget, Stream serviceStream, IPooledConnectionReclamation?poolReclamation) { _solutionAssetStorage = services.GetRequiredService <ISolutionAssetStorageProvider>().AssetStorage; _services = services; _serviceEndPoint = new RemoteEndPoint(serviceStream, logger, callbackTarget); _serviceEndPoint.UnexpectedExceptionThrown += UnexpectedExceptionThrown; _serviceEndPoint.StartListening(); _poolReclamation = poolReclamation; #if DEBUG _creationCallStack = Environment.StackTrace; #endif }
public RemoteDesignerAttributeIncrementalAnalyzerProvider(RemoteEndPoint endPoint) { _endPoint = endPoint; }
public FindReferencesProgressCallback(RemoteEndPoint endPoint, CancellationToken cancellationToken) { _endPoint = endPoint; _cancellationToken = cancellationToken; }
public SymbolSearchService(RemoteEndPoint endPoint) { _endPoint = endPoint; }
public RemoteTodoCommentsIncrementalAnalyzerProvider(RemoteEndPoint endPoint) { _endPoint = endPoint; }
public RemoteDesignerAttributeIncrementalAnalyzer(Workspace workspace, RemoteEndPoint endPoint) { _endPoint = endPoint; _storageService = workspace.Services.GetRequiredService <IPersistentStorageService>(); }
public FindLiteralReferencesProgressCallback(RemoteEndPoint endPoint, CancellationToken cancellationToken) { _endPoint = endPoint; _cancellationToken = cancellationToken; ProgressTracker = this; }
public RemoteProjectTelemetryIncrementalAnalyzer(RemoteEndPoint endPoint) => _endPoint = endPoint;
public RemoteDesignerAttributeIncrementalAnalyzer(Workspace workspace, RemoteEndPoint endPoint) : base(workspace) { _endPoint = endPoint; }