Exemplo n.º 1
0
 public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
 {
     return(new OOPTagHelperResolver(
                workspaceServices.GetRequiredService <ProjectSnapshotProjectEngineFactory>(),
                workspaceServices.GetRequiredService <ErrorReporter>(),
                workspaceServices.Workspace));
 }
        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>();
        }
        private ServiceHubRemoteHostClient(
            HostWorkspaceServices services,
            IServiceBroker serviceBroker,
            ServiceBrokerClient serviceBrokerClient,
            HubClient hubClient,
            Stream stream,
            IRemoteServiceCallbackDispatcherProvider callbackDispatcherProvider)
        {
            _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;
            _serviceBroker                       = serviceBroker;
            _serviceBrokerClient                 = serviceBrokerClient;
            _hubClient                           = hubClient;
            _callbackDispatcherProvider          = callbackDispatcherProvider;
            _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>();
            _errorReportingService       = services.GetService <IErrorReportingService>();
            _shutdownCancellationService = services.GetService <IRemoteHostClientShutdownCancellationService>();
            _isRemoteHostServerGC        = RemoteHostOptions.IsServiceHubProcessServerGC(services);
            _isRemoteHostCoreClr         = RemoteHostOptions.IsServiceHubProcessCoreClr(services);
        }
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            var errorReportingService = workspaceServices.GetRequiredService <IErrorReportingService>();
            var errorLoggerService    = workspaceServices.GetRequiredService <IErrorLoggerService>();

            return(new ExtensionManager(_optionService, errorReportingService, errorLoggerService, _errorHandlers));
        }
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            var solutionCrawlerRegistrationService = workspaceServices.GetRequiredService <ISolutionCrawlerRegistrationService>();
            var solutionCrawlerService             = workspaceServices.GetRequiredService <ISolutionCrawlerService>();

            return(new UnitTestingSolutionCrawlerServiceAccessor(solutionCrawlerRegistrationService, solutionCrawlerService));
        }
Exemplo n.º 6
0
        private protected SerializerService(HostWorkspaceServices workspaceServices)
        {
            _workspaceServices = workspaceServices;

            _storageService         = workspaceServices.GetRequiredService <ITemporaryStorageService>();
            _textService            = workspaceServices.GetRequiredService <ITextFactoryService>();
            _analyzerLoaderProvider = workspaceServices.GetRequiredService <IAnalyzerAssemblyLoaderProvider>();
            _documentationService   = workspaceServices.GetService <IDocumentationProviderService>();

            _lazyLanguageSerializationService = new ConcurrentDictionary <string, IOptionsSerializationService>(concurrencyLevel: 2, capacity: _workspaceServices.SupportedLanguages.Count());
        }
Exemplo n.º 7
0
            public OptionService(
                IGlobalOptionService globalOptionService,
                HostWorkspaceServices workspaceServices)
            {
                _globalOptionService = globalOptionService;

                var schedulerProvider = workspaceServices.GetRequiredService <ITaskSchedulerProvider>();
                var listenerProvider  = workspaceServices.GetRequiredService <IWorkspaceAsynchronousOperationListenerProvider>();

                _taskQueue = new TaskQueue(listenerProvider.GetListener(), schedulerProvider.CurrentContextScheduler);

                _globalOptionService.OptionChanged += OnGlobalOptionServiceOptionChanged;
            }
Exemplo n.º 8
0
        public ValueTask GetAssetsAsync(Stream outputStream, int scopeId, Checksum[] checksums, CancellationToken cancellationToken)
        {
            // Complete RPC right away so the client can start reading from the stream.
            // The fire-and forget task starts writing to the output stream and the client will read it until it reads all expected data.
            _ = Task.Run(async() =>
            {
                using var writer = new ObjectWriter(outputStream, leaveOpen: false, cancellationToken);

                var assetStorage = _services.GetRequiredService <ISolutionAssetStorageProvider>().AssetStorage;
                var serializer   = _services.GetRequiredService <ISerializerService>();
                await RemoteHostAssetSerialization.WriteDataAsync(writer, assetStorage, serializer, scopeId, checksums, cancellationToken).ConfigureAwait(false);
            }, cancellationToken);

            return(default);
Exemplo n.º 9
0
        private ServiceHubRemoteHostClient(
            HostWorkspaceServices services,
            HubClient hubClient,
            HostGroup hostGroup,
            Stream stream)
            : base(services)
        {
            var optionService = services.GetRequiredService <IOptionService>();

            if (optionService.GetOption(RemoteHostOptions.EnableConnectionPool))
            {
                int maxPoolConnection = optionService.GetOption(RemoteHostOptions.MaxPoolConnection);

                _connectionPool = new ConnectionPool(
                    connectionFactory: (serviceName, cancellationToken) => CreateConnectionAsync(serviceName, callbackTarget: null, cancellationToken),
                    maxPoolConnection);
            }

            _hubClient = hubClient;
            _hostGroup = hostGroup;

            _endPoint = new RemoteEndPoint(stream, hubClient.Logger, incomingCallTarget: this);
            _endPoint.Disconnected += OnDisconnected;
            _endPoint.UnexpectedExceptionThrown += OnUnexpectedExceptionThrown;
            _endPoint.StartListening();
        }
Exemplo n.º 10
0
        public static SyntaxFormattingOptions Create(OptionSet options, HostWorkspaceServices services, string language)
        {
            var formattingService = services.GetRequiredLanguageService <ISyntaxFormattingService>(language);
            var configOptions     = options.AsAnalyzerConfigOptions(services.GetRequiredService <IOptionService>(), language);

            return(formattingService.GetFormattingOptions(configOptions));
        }
        public static void ShowInfoBar(HostWorkspaceServices services, Exception?exception = null)
        {
            if (s_infoBarReported)
            {
                return;
            }

            s_infoBarReported = true;

            // use info bar to show warning to users
            var infoBarUIs = new List <InfoBarUI>();

            infoBarUIs.Add(
                new InfoBarUI(ServicesVSResources.Learn_more, InfoBarUI.UIKind.HyperLink, () =>
                              BrowserHelper.StartBrowser(new Uri(OOPKilledMoreInfoLink)), closeAfterAction: false));

            var errorReportingService = services.GetRequiredService <IErrorReportingService>();

            if (exception != null)
            {
                infoBarUIs.Add(
                    new InfoBarUI(WorkspacesResources.Show_Stack_Trace, InfoBarUI.UIKind.HyperLink, () =>
                                  errorReportingService.ShowDetailedErrorInfo(exception), closeAfterAction: true));
            }

            errorReportingService.ShowGlobalErrorInfo(
                ServicesVSResources.Unfortunately_a_process_used_by_Visual_Studio_has_encountered_an_unrecoverable_error_We_recommend_saving_your_work_and_then_closing_and_restarting_Visual_Studio,
                infoBarUIs.ToArray());
        }
 public Service(HostWorkspaceServices workspaceServices)
 {
     // We will defer creation of this reference manager until we have to to avoid it being constructed too
     // early and potentially causing deadlocks.
     _manager = new Lazy <MonoDevelopMetadataReferenceManager> (
         () => workspaceServices.GetRequiredService <MonoDevelopMetadataReferenceManager> ());
 }
Exemplo n.º 13
0
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            var optionService = workspaceServices.GetRequiredService <IOptionService>();
            var database      = optionService.GetOption(StorageOptions.Database);

            switch (database)
            {
            case StorageDatabase.SQLite:
                if (!SQLitePersistentStorageService.TryInitializeLibraries())
                {
                    break;
                }

                var locationService = workspaceServices.GetService <IPersistentStorageLocationService>();

                if (locationService != null)
                {
                    return(new SQLitePersistentStorageService(optionService, locationService, _solutionSizeTracker));
                }

                break;
            }

            return(NoOpPersistentStorageService.Instance);
        }
Exemplo n.º 14
0
        internal static IEnumerable <ClassifiedSpan> GetClassifiedSpans(
            HostWorkspaceServices workspaceServices,
            SemanticModel semanticModel,
            TextSpan textSpan,
            ClassificationOptions options,
            CancellationToken cancellationToken)
        {
            var service = workspaceServices.GetLanguageServices(semanticModel.Language).GetRequiredService <ISyntaxClassificationService>();

            var syntaxClassifiers = service.GetDefaultSyntaxClassifiers();

            var extensionManager    = workspaceServices.GetRequiredService <IExtensionManager>();
            var getNodeClassifiers  = extensionManager.CreateNodeExtensionGetter(syntaxClassifiers, c => c.SyntaxNodeTypes);
            var getTokenClassifiers = extensionManager.CreateTokenExtensionGetter(syntaxClassifiers, c => c.SyntaxTokenKinds);

            using var _1 = ArrayBuilder <ClassifiedSpan> .GetInstance(out var syntacticClassifications);

            using var _2 = ArrayBuilder <ClassifiedSpan> .GetInstance(out var semanticClassifications);

            var root = semanticModel.SyntaxTree.GetRoot(cancellationToken);

            service.AddSyntacticClassifications(root, textSpan, syntacticClassifications, cancellationToken);
            service.AddSemanticClassifications(semanticModel, textSpan, getNodeClassifiers, getTokenClassifiers, semanticClassifications, options, cancellationToken);

            var allClassifications = new List <ClassifiedSpan>(semanticClassifications.Where(s => s.TextSpan.OverlapsWith(textSpan)));
            var semanticSet        = semanticClassifications.Select(s => s.TextSpan).ToSet();

            allClassifications.AddRange(syntacticClassifications.Where(
                                            s => s.TextSpan.OverlapsWith(textSpan) && !semanticSet.Contains(s.TextSpan)));
            allClassifications.Sort((s1, s2) => s1.TextSpan.Start - s2.TextSpan.Start);

            return(allClassifications);
        }
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
#if !DOTNET_BUILD_FROM_SOURCE
            var optionService = workspaceServices.GetRequiredService <IOptionService>();
            var database      = optionService.GetOption(StorageOptions.Database);
            switch (database)
            {
            case StorageDatabase.SQLite:
                var locationService = workspaceServices.GetService <IPersistentStorageLocationService>();
                if (locationService != null)
                {
                    if (UseInMemoryWriteCache(workspaceServices))
                    {
                        return(new SQLite.v2.SQLitePersistentStorageService(locationService));
                    }
                    else
                    {
                        return(new SQLite.v1.SQLitePersistentStorageService(locationService));
                    }
                }

                break;
            }
#endif

            return(NoOpPersistentStorageService.Instance);
        }
 public Service(HostWorkspaceServices workspaceServices)
 {
     // We will defer creation of this reference manager until we have to to avoid it being constructed too
     // early and potentially causing deadlocks. We do initialize it on the UI thread in the
     // VisualStudioWorkspaceImpl.DeferredState constructor to ensure it gets created there.
     _manager = new Lazy <VisualStudioMetadataReferenceManager>(
         () => workspaceServices.GetRequiredService <VisualStudioMetadataReferenceManager>());
 }
Exemplo n.º 17
0
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (_singleton == null)
            {
                _singleton = new VisualStudioErrorReportingService(workspaceServices.GetRequiredService <IInfoBarService>());
            }

            return(_singleton);
        }
Exemplo n.º 18
0
        public static bool IsServiceHubProcessServerGC(HostWorkspaceServices services)
        {
            if (!IsServiceHubProcess64Bit(services))
            {
                return(false);
            }

            return(services.GetRequiredService <IOptionService>().GetOption(OOPServerGC) ||
                   services.GetService <IExperimentationService>()?.IsExperimentEnabled(WellKnownExperimentNames.OOPServerGC) == true);
        }
Exemplo n.º 19
0
        private async Task PopulateWorkspaceFromDeferredProjectInfoAsync(
            CancellationToken cancellationToken)
        {
            // NOTE: We need to check cancellationToken after each await, in case the user has
            // already closed the solution.
            AssertIsForeground();

            var componentModel = _serviceProvider.GetService(typeof(SComponentModel)) as IComponentModel;
            var workspaceProjectContextFactory = componentModel.GetService <IWorkspaceProjectContextFactory>();

            var dte            = _serviceProvider.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
            var solutionConfig = (EnvDTE80.SolutionConfiguration2)dte.Solution.SolutionBuild.ActiveConfiguration;

            OutputToOutputWindow($"Getting project information - start");
            var start = DateTimeOffset.UtcNow;

            var projectInfos = SpecializedCollections.EmptyReadOnlyDictionary <string, DeferredProjectInformation>();

            // Note that `solutionConfig` may be null. For example: if the solution doesn't actually
            // contain any projects.
            if (solutionConfig != null)
            {
                // Capture the context so that we come back on the UI thread, and do the actual project creation there.
                var deferredProjectWorkspaceService = _workspaceServices.GetService <IDeferredProjectWorkspaceService>();
                projectInfos = await deferredProjectWorkspaceService.GetDeferredProjectInfoForConfigurationAsync(
                    $"{solutionConfig.Name}|{solutionConfig.PlatformName}",
                    cancellationToken).ConfigureAwait(true);
            }

            AssertIsForeground();
            cancellationToken.ThrowIfCancellationRequested();
            OutputToOutputWindow($"Getting project information - done (took {DateTimeOffset.UtcNow - start})");

            OutputToOutputWindow($"Creating projects - start");
            start = DateTimeOffset.UtcNow;
            var targetPathsToProjectPaths = BuildTargetPathMap(projectInfos);
            var analyzerAssemblyLoader    = _workspaceServices.GetRequiredService <IAnalyzerService>().GetLoader();

            foreach (var projectFilename in projectInfos.Keys)
            {
                cancellationToken.ThrowIfCancellationRequested();
                GetOrCreateProjectFromArgumentsAndReferences(
                    workspaceProjectContextFactory,
                    analyzerAssemblyLoader,
                    projectFilename,
                    projectInfos,
                    targetPathsToProjectPaths);
            }
            OutputToOutputWindow($"Creating projects - done (took {DateTimeOffset.UtcNow - start})");

            OutputToOutputWindow($"Pushing to workspace - start");
            start = DateTimeOffset.UtcNow;
            FinishLoad();
            OutputToOutputWindow($"Pushing to workspace - done (took {DateTimeOffset.UtcNow - start})");
        }
Exemplo n.º 20
0
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (workspaceServices == null)
            {
                throw new ArgumentNullException(nameof(workspaceServices));
            }

            var errorReporter = workspaceServices.GetRequiredService <ErrorReporter>();

            return(new VisualStudioFileChangeTrackerFactory(_foregroundDispatcher, errorReporter, _fileChangeService));
        }
Exemplo n.º 21
0
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (workspaceServices is null)
            {
                throw new ArgumentNullException(nameof(workspaceServices));
            }

            var errorReporter = workspaceServices.GetRequiredService <ErrorReporter>();

            return(new VisualStudioFileChangeTrackerFactory(errorReporter, _fileChangeService, _projectSnapshotManagerDispatcher, _joinableTaskContext));
        }
Exemplo n.º 22
0
        public Task <RemoteHostClient> CreateAsync(HostWorkspaceServices services, CancellationToken cancellationToken)
        {
            var optionService = services.GetRequiredService <IOptionService>();

            if (optionService.GetOption(RemoteHostOptions.RemoteHostTest))
            {
                return(InProcRemoteHostClient.CreateAsync(services, runCacheCleanup: false));
            }

            return(SpecializedTasks.Null <RemoteHostClient>());
        }
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (workspaceServices == null)
            {
                throw new ArgumentNullException(nameof(workspaceServices));
            }

            var runningDocumentTable     = (IVsRunningDocumentTable)_serviceProvider.GetService(typeof(SVsRunningDocumentTable));
            var fileChangeTrackerFactory = workspaceServices.GetRequiredService <FileChangeTrackerFactory>();

            return(new VisualStudioEditorDocumentManager(_foregroundDispatcher, fileChangeTrackerFactory, runningDocumentTable, _editorAdaptersFactory));
        }
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (workspaceServices is null)
            {
                throw new ArgumentNullException(nameof(workspaceServices));
            }

            var fileChangeTrackerFactory = workspaceServices.GetRequiredService <FileChangeTrackerFactory>();
            var editorDocumentManager    = new VisualStudioMacEditorDocumentManager(_projectSnapshotManagerDispatcher, _joinableTaskContext, fileChangeTrackerFactory);

            return(editorDocumentManager);
        }
Exemplo n.º 25
0
        protected Workspace(HostServices host)
        {
            _services = host.CreateWorkspaceServices(this);

            // queue used for sending events
            var workspaceTaskSchedulerFactory = _services.GetRequiredService <IWorkspaceTaskSchedulerFactory>();

            _taskQueue = workspaceTaskSchedulerFactory.CreateEventingTaskQueue();

            // initialize with empty document set
            _latestDocuments = new WorkspaceDocuments(ImmutableDictionary <DocumentId, Document> .Empty);
        }
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (workspaceServices == null)
            {
                throw new ArgumentNullException(nameof(workspaceServices));
            }

            var fileChangeTrackerFactory = workspaceServices.GetRequiredService <FileChangeTrackerFactory>();
            var editorDocumentManager    = new VisualStudioMacEditorDocumentManager(_foregroundDispatcher, fileChangeTrackerFactory);

            return(editorDocumentManager);
        }
Exemplo n.º 27
0
            public OptionService(
                IGlobalOptionService globalOptionService,
                HostWorkspaceServices workspaceServices)
            {
                _globalOptionService = globalOptionService;

                var workspaceTaskSchedulerFactory = workspaceServices.GetRequiredService <IWorkspaceTaskSchedulerFactory>();

                _taskQueue = workspaceTaskSchedulerFactory.CreateEventingTaskQueue();

                _globalOptionService.OptionChanged += OnGlobalOptionServiceOptionChanged;
            }
Exemplo n.º 28
0
        public static bool IsUsingServiceHubOutOfProcess(HostWorkspaceServices services)
        {
            var optionService = services.GetRequiredService <IOptionService>();

            if (Environment.Is64BitOperatingSystem && optionService.GetOption(OOP64Bit))
            {
                // OOP64Bit is set and supported
                return(true);
            }

            return(false);
        }
        private static StorageDatabase GetDatabase(HostWorkspaceServices workspaceServices)
        {
            var experimentationService = workspaceServices.GetService <IExperimentationService>();

            if (experimentationService?.IsExperimentEnabled(WellKnownExperimentNames.CloudCache) == true)
            {
                return(StorageDatabase.CloudCache);
            }

            var optionService = workspaceServices.GetRequiredService <IOptionService>();

            return(optionService.GetOption(StorageOptions.Database));
        }
Exemplo n.º 30
0
        public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
        {
            if (_singleton == null)
            {
                _singleton = new VisualStudioErrorReportingService(
                    _threadingContext,
                    _listenerProvider,
                    workspaceServices.GetRequiredService <IInfoBarService>(),
                    _serviceProvider);
            }

            return(_singleton);
        }