private static Task <SymbolTreeInfo> CreateMetadataSymbolTreeInfoAsync( Workspace workspace, SolutionKey solutionKey, Checksum checksum, PortableExecutableReference reference) { var creator = new MetadataInfoCreator(workspace, solutionKey, checksum, reference); return(Task.FromResult(creator.Create())); }
private async Task <bool> SaveAsync( Document document, CancellationToken cancellationToken) { var solution = document.Project.Solution; var persistentStorageService = solution.Workspace.Services.GetPersistentStorageService(solution.Options); try { var storage = await persistentStorageService.GetStorageAsync(SolutionKey.ToSolutionKey(solution), cancellationToken).ConfigureAwait(false); await using var _ = storage.ConfigureAwait(false); using var stream = SerializableBytes.CreateWritableStream(); using (var writer = new ObjectWriter(stream, leaveOpen: true, cancellationToken)) { WriteTo(writer); } stream.Position = 0; return(await storage.WriteStreamAsync(document, PersistenceName, stream, this.Checksum, cancellationToken).ConfigureAwait(false)); } catch (Exception e) when(IOUtilities.IsNormalIOException(e)) { // Storage APIs can throw arbitrary exceptions. } return(false); }
public void GlobalSetup() { _useExportProviderAttribute.Before(null); if (_workspace != null) { throw new InvalidOperationException(); } _workspace = TestWorkspace.Create( @"<Workspace> <Project Language=""NoCompilation"" CommonReferences=""false""> <Document> // a no-compilation document </Document> </Project> </Workspace>"); var connectionPoolService = _workspace.ExportProvider.GetExportedValue <SQLiteConnectionPoolService>(); var asyncListener = _workspace.ExportProvider.GetExportedValue <IAsynchronousOperationListenerProvider>().GetListener(FeatureAttribute.PersistentStorage); _storageService = new SQLitePersistentStorageService(connectionPoolService, new StorageConfiguration(), asyncListener); var solution = _workspace.CurrentSolution; _storage = _storageService.GetStorageWorkerAsync(SolutionKey.ToSolutionKey(solution), CancellationToken.None).AsTask().GetAwaiter().GetResult(); Console.WriteLine("Storage type: " + _storage.GetType()); _document = _workspace.CurrentSolution.Projects.Single().Documents.Single(); _random = new Random(0); }
private static async Task <SymbolTreeInfo> GetInfoForMetadataReferenceSlowAsync( Workspace workspace, SolutionKey solutionKey, PortableExecutableReference reference, Checksum checksum, Metadata metadata, CancellationToken cancellationToken ) { cancellationToken.ThrowIfCancellationRequested(); // Important: this captured async lazy may live a long time *without* computing the final results. As such, // it is important that it note capture any large state. For example, it should not hold onto a Solution // instance. var asyncLazy = s_metadataIdToInfo.GetValue( metadata.Id, id => new AsyncLazy <SymbolTreeInfo>( c => TryCreateMetadataSymbolTreeInfoAsync( workspace, solutionKey, reference, checksum, c ), cacheResult: true ) ); return(await asyncLazy.GetValueAsync(cancellationToken).ConfigureAwait(false)); }
private static Task <SpellChecker> LoadOrCreateSpellCheckerAsync( Workspace workspace, SolutionKey solutionKey, Checksum checksum, string filePath, ImmutableArray <Node> sortedNodes ) { var result = TryLoadOrCreateAsync( workspace, solutionKey, checksum, loadOnly: false, createAsync: () => CreateSpellCheckerAsync(checksum, sortedNodes), keySuffix: "_SpellChecker_" + filePath, tryReadObject: SpellChecker.TryReadFrom, cancellationToken: CancellationToken.None ); Contract.ThrowIfNull( result, "Result should never be null as we passed 'loadOnly: false'." ); return(result); }
private static async Task <bool> PrecalculatedAsync( Document document, Checksum checksum, CancellationToken cancellationToken) { var solution = document.Project.Solution; var persistentStorageService = solution.Workspace.Services.GetPersistentStorageService(solution.Options); // check whether we already have info for this document try { var storage = await persistentStorageService.GetStorageAsync(SolutionKey.ToSolutionKey(solution), cancellationToken).ConfigureAwait(false); await using var _ = storage.ConfigureAwait(false); // Check if we've already stored a checksum and it matches the checksum we // expect. If so, we're already precalculated and don't have to recompute // this index. Otherwise if we don't have a checksum, or the checksums don't // match, go ahead and recompute it. return(await storage.ChecksumMatchesAsync(document, PersistenceName, checksum, cancellationToken).ConfigureAwait(false)); } catch (Exception e) when(IOUtilities.IsNormalIOException(e)) { // Storage APIs can throw arbitrary exceptions. } return(false); }
public void CreateIndexer() { TestUtils.InitializeDefaultExtensionPoints(); _indexerPath = Path.GetTempPath() + "luceneindexer"; Directory.CreateDirectory(_indexerPath); _solutionKey = new SolutionKey(Guid.NewGuid(), "C:/SolutionPath"); ServiceLocator.RegisterInstance(_solutionKey); ServiceLocator.RegisterInstance <Analyzer>(new SimpleAnalyzer()); _indexer = new DocumentIndexer(TimeSpan.FromSeconds(1)); ServiceLocator.RegisterInstance(_indexer); ClassElement classElement = SampleProgramElementFactory.GetSampleClassElement( accessLevel: AccessLevel.Public, definitionLineNumber: 11, extendedClasses: "SimpleClassBase", fullFilePath: "C:/Projects/SimpleClass.cs", implementedInterfaces: "IDisposable", name: "SimpleName", namespaceName: "Sanod.Indexer.UnitTests" ); SandoDocument sandoDocument = DocumentFactory.Create(classElement); _indexer.AddDocument(sandoDocument); MethodElement methodElement = SampleProgramElementFactory.GetSampleMethodElement( accessLevel: AccessLevel.Protected, name: "SimpleName", returnType: "Void", fullFilePath: "C:/stuff" ); sandoDocument = DocumentFactory.Create(methodElement); _indexer.AddDocument(sandoDocument); }
public static void InitializeDefaultExtensionPoints() { FileLogger.SetupDefaultFileLogger(Path.GetTempPath()); ExtensionPointsRepository extensionPointsRepository = ExtensionPointsRepository.Instance; PathManager.Create(Path.GetTempPath()); var generator = new ABB.SrcML.SrcMLGenerator(SrcMLDirectory); extensionPointsRepository.RegisterParserImplementation(new List <string>() { ".cs" }, new SrcMLCSharpParser(generator)); extensionPointsRepository.RegisterParserImplementation(new List <string>() { ".h", ".cpp", ".cxx" }, new SrcMLCppParser(generator)); extensionPointsRepository.RegisterWordSplitterImplementation(new WordSplitter()); extensionPointsRepository.RegisterResultsReordererImplementation(new SortByScoreResultsReorderer()); extensionPointsRepository.RegisterQueryWeightsSupplierImplementation(new QueryWeightsSupplier()); extensionPointsRepository.RegisterQueryRewriterImplementation(new DefaultQueryRewriter()); var solutionKey = new SolutionKey(Guid.NewGuid(), Path.GetTempPath()); ServiceLocator.RegisterInstance(solutionKey); extensionPointsRepository.RegisterIndexFilterManagerImplementation(new IndexFilterManager()); }
public void GlobalSetup() { _useExportProviderAttribute.Before(null); if (_workspace != null) { throw new InvalidOperationException(); } _workspace = TestWorkspace.Create( @"<Workspace> <Project Language=""NoCompilation"" CommonReferences=""false""> <Document> // a no-compilation document </Document> </Project> </Workspace>" ); // Explicitly choose the sqlite db to test. _workspace.TryApplyChanges( _workspace.CurrentSolution.WithOptions( _workspace.Options.WithChangedOption( StorageOptions.Database, StorageDatabase.SQLite ) ) ); var connectionPoolService = _workspace.ExportProvider.GetExportedValue <SQLiteConnectionPoolService>(); _storageService = new SQLitePersistentStorageService( connectionPoolService, new LocationService() ); var solution = _workspace.CurrentSolution; _storage = _storageService .GetStorageWorkerAsync( _workspace, SolutionKey.ToSolutionKey(solution), solution, CancellationToken.None ) .AsTask() .GetAwaiter() .GetResult(); if (_storage == NoOpPersistentStorage.Instance) { throw new InvalidOperationException( "We didn't properly get the sqlite storage instance." ); } Console.WriteLine("Storage type: " + _storage.GetType()); _document = _workspace.CurrentSolution.Projects.Single().Documents.Single(); _random = new Random(0); }
public MetadataInfoCreator( Workspace workspace, SolutionKey solutionKey, Checksum checksum, PortableExecutableReference reference ) { _workspace = workspace; _solutionKey = solutionKey; _checksum = checksum; _reference = reference; _metadataReader = null; _allTypeDefinitions = new List <MetadataDefinition>(); _containsExtensionsMethod = false; _inheritanceMap = OrderPreservingMultiDictionary <string, string> .GetInstance(); _parentToChildren = OrderPreservingMultiDictionary < MetadataNode, MetadataNode > .GetInstance(); _extensionMethodToParameterTypeInfo = new MultiDictionary <MetadataNode, ParameterTypeInfo>(); _rootNode = MetadataNode.Allocate(name: ""); }
private static Task <SymbolTreeInfo> TryCreateMetadataSymbolTreeInfoAsync( Workspace workspace, SolutionKey solutionKey, PortableExecutableReference reference, Checksum checksum, CancellationToken cancellationToken ) { var filePath = reference.FilePath; var result = TryLoadOrCreateAsync( workspace, solutionKey, checksum, loadOnly: false, createAsync: () => CreateMetadataSymbolTreeInfoAsync(workspace, solutionKey, checksum, reference), keySuffix: "_Metadata_" + filePath, tryReadObject: reader => TryReadSymbolTreeInfo( reader, checksum, nodes => GetSpellCheckerAsync(workspace, solutionKey, checksum, filePath, nodes) ), cancellationToken: cancellationToken ); Contract.ThrowIfNull(result != null); return(result); }
private static Task <SymbolTreeInfo> CreateMetadataSymbolTreeInfoAsync( HostWorkspaceServices services, SolutionKey solutionKey, Checksum checksum, StorageDatabase database, PortableExecutableReference reference) { var creator = new MetadataInfoCreator(services, solutionKey, checksum, database, reference); return(Task.FromResult(creator.Create())); }
public string?TryGetStorageLocation(SolutionKey _) { var location = Path.Combine(Path.GetTempPath(), "RoslynTests", "AnalyzerRunner", "temp-db"); Directory.CreateDirectory(location); return(location); }
public string TryGetStorageLocation(SolutionKey _) { // Store the db in a different random temp dir. var tempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); Console.WriteLine("Creating: " + tempDir); Directory.CreateDirectory(tempDir); return(tempDir); }
public void SetUp() { TestUtils.InitializeDefaultExtensionPoints(); var solutionKey = ServiceLocator.Resolve <SolutionKey>(); var newSolutionKey = new SolutionKey(solutionKey.GetSolutionId(), solutionKey.GetSolutionPath()); ServiceLocator.RegisterInstance(newSolutionKey); ServiceLocator.RegisterType <Analyzer, SimpleAnalyzer>(); }
public void CacheDirectoryShouldNotBeAtRoot() { var workspace = new AdhocWorkspace(FeaturesTestCompositions.Features.GetHostServices()); workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), new VersionStamp(), @"D:\git\PCLCrypto\PCLCrypto.sln")); var configuration = workspace.Services.GetRequiredService <IPersistentStorageConfiguration>(); var location = configuration.TryGetStorageLocation(SolutionKey.ToSolutionKey(workspace.CurrentSolution)); Assert.False(location?.StartsWith("/") ?? false); }
private async Task LoadSolutionAsync() { var roslynRoot = Environment.GetEnvironmentVariable(Program.RoslynRootPathEnvVariableName); _solutionPath = Path.Combine(roslynRoot, @"Roslyn.sln"); if (!File.Exists(_solutionPath)) { throw new ArgumentException("Couldn't find Roslyn.sln"); } Console.WriteLine("Found Roslyn.sln: " + Process.GetCurrentProcess().Id); var assemblies = MSBuildMefHostServices.DefaultAssemblies .Add(typeof(AnalyzerRunnerHelper).Assembly) .Add(typeof(FindReferencesBenchmarks).Assembly); var services = MefHostServices.Create(assemblies); _workspace = MSBuildWorkspace.Create(new Dictionary <string, string> { // Use the latest language version to force the full set of available analyzers to run on the project. { "LangVersion", "9.0" }, }, services); if (_workspace == null) { throw new ArgumentException("Couldn't create workspace"); } _workspace.TryApplyChanges(_workspace.CurrentSolution.WithOptions(_workspace.Options .WithChangedOption(StorageOptions.Database, StorageDatabase.SQLite))); Console.WriteLine("Opening roslyn. Attach to: " + Process.GetCurrentProcess().Id); var start = DateTime.Now; var solution = _workspace.OpenSolutionAsync(_solutionPath, progress: null, CancellationToken.None).Result; Console.WriteLine("Finished opening roslyn: " + (DateTime.Now - start)); // Force a storage instance to be created. This makes it simple to go examine it prior to any operations we // perform, including seeing how big the initial string table is. var storageService = _workspace.Services.GetPersistentStorageService(_workspace.CurrentSolution.Options); if (storageService == null) { throw new ArgumentException("Couldn't get storage service"); } using (var storage = await storageService.GetStorageAsync(SolutionKey.ToSolutionKey(_workspace.CurrentSolution), CancellationToken.None)) { Console.WriteLine("Sucessfully got persistent storage instance"); } }
public async Task TestPreviewServices() { using var previewWorkspace = new PreviewWorkspace(EditorTestCompositions.EditorFeatures.GetHostServices()); var service = previewWorkspace.Services.GetService <ISolutionCrawlerRegistrationService>(); Assert.IsType <PreviewSolutionCrawlerRegistrationServiceFactory.Service>(service); var persistentService = previewWorkspace.Services.GetPersistentStorageService(previewWorkspace.CurrentSolution.Options); await using var storage = await persistentService.GetStorageAsync(SolutionKey.ToSolutionKey(previewWorkspace.CurrentSolution), CancellationToken.None); Assert.IsType <NoOpPersistentStorage>(storage); }
public static DocumentKey GetDocumentKeyForCaching(Document document) { var project = document.Project; // We very intentionally persist this information against using a null 'parseOptionsChecksum'. This way the // results will be valid and something we can lookup regardless of the project configuration. In other // words, if we've cached the information when in the DEBUG state of the project, but we lookup when in the // RELEASE state, we'll still find the entry. The data may be inaccurate, but that's ok as this is just for // temporary classifying until the real classifier takes over when the solution fully loads. var projectKey = new ProjectKey(SolutionKey.ToSolutionKey(project.Solution), project.Id, project.FilePath, project.Name, Checksum.Null); return(new DocumentKey(projectKey, document.Id, document.FilePath, document.Name)); }
public static async ValueTask <SymbolTreeInfo> GetInfoForMetadataReferenceAsync( Solution solution, PortableExecutableReference reference, Checksum checksum, bool loadOnly, CancellationToken cancellationToken ) { var metadataId = GetMetadataIdNoThrow(reference); if (metadataId == null) { return(CreateEmpty(checksum)); } if (s_metadataIdToInfo.TryGetValue(metadataId, out var infoTask)) { var info = await infoTask.GetValueAsync(cancellationToken).ConfigureAwait(false); if (info.Checksum == checksum) { return(info); } } var metadata = GetMetadataNoThrow(reference); if (metadata == null) { return(CreateEmpty(checksum)); } // If the data isn't in the table, and the client only wants the data if already loaded, then bail out as we // have no results to give. The data will eventually populate in memory due to // SymbolTreeInfoIncrementalAnalyzer eventually getting around to loading it. if (loadOnly) { return(null); } return(await GetInfoForMetadataReferenceSlowAsync( solution.Workspace, SolutionKey.ToSolutionKey(solution), reference, checksum, metadata, cancellationToken ) .ConfigureAwait(false)); }
public string?TryGetStorageLocation(SolutionKey solutionKey) { if (string.IsNullOrWhiteSpace(solutionKey.FilePath)) { return(null); } // Ensure that each unique workspace kind for any given solution has a unique // folder to store their data in. return(Path.Combine( s_cacheDirectory, s_moduleFileName, SafeName(solutionKey.FilePath))); }
protected sealed override async ValueTask <IChecksummedPersistentStorage?> TryOpenDatabaseAsync( SolutionKey solutionKey, string workingFolderPath, string databaseFilePath, CancellationToken cancellationToken) { var cacheService = await this.CreateCacheServiceAsync(cancellationToken).ConfigureAwait(false); var relativePathBase = await cacheService.GetRelativePathBaseAsync(cancellationToken).ConfigureAwait(false); if (string.IsNullOrEmpty(relativePathBase)) { return(null); } return(new CloudCachePersistentStorage( cacheService, solutionKey, workingFolderPath, relativePathBase, databaseFilePath, this.DisposeCacheService)); }
protected override ValueTask <IChecksummedPersistentStorage?> TryOpenDatabaseAsync( SolutionKey solutionKey, string workingFolderPath, string databaseFilePath) { if (!TryInitializeLibraries()) { // SQLite is not supported on the current platform return(new((IChecksummedPersistentStorage?)null)); } return(new(SQLitePersistentStorage.TryCreate( _connectionPoolService, workingFolderPath, solutionKey.FilePath, databaseFilePath, _faultInjector))); }
protected override IChecksummedPersistentStorage?TryOpenDatabase( SolutionKey solutionKey, Solution?bulkLoadSnapshot, string workingFolderPath, string databaseFilePath) { if (!TryInitializeLibraries()) { // SQLite is not supported on the current platform return(null); } return(SQLitePersistentStorage.TryCreate( _connectionPoolService, bulkLoadSnapshot, workingFolderPath, solutionKey.FilePath, databaseFilePath, _faultInjector)); }
public async Task TestOpenWithSolutionReadWithDocument_WriteWithSolutionKey() { var solution = CreateOrOpenSolution(); var document = solution.Projects.Single().Documents.Single(); var streamName1 = "stream"; using (var storage = await GetStorageFromKeyAsync(solution.Workspace, SolutionKey.ToSolutionKey(solution))) { await storage.WriteStreamAsync(document, streamName1, EncodeString(GetData1(Size.Small)), checksum : s_checksum1); } using (var storage = await GetStorageAsync(solution)) { Assert.True(await storage.ChecksumMatchesAsync(document, streamName1, s_checksum1)); Assert.Equal(GetData1(Size.Small), ReadStringToEnd(await storage.ReadStreamAsync(document, streamName1))); } }
internal IChecksummedPersistentStorage GetStorageFromKey( Workspace workspace, SolutionKey solutionKey, IPersistentStorageFaultInjector faultInjectorOpt = null) { // If we handed out one for a previous test, we need to shut that down first _storageService?.GetTestAccessor().Shutdown(); var locationService = new MockPersistentStorageLocationService(solutionKey.Id, _persistentFolder.Path); _storageService = GetStorageService(locationService, faultInjectorOpt); var storage = _storageService.GetStorage(workspace, solutionKey, checkBranchId: true); // If we're injecting faults, we expect things to be strange if (faultInjectorOpt == null) { Assert.NotEqual(NoOpPersistentStorage.Instance, storage); } return(storage); }
internal async Task <IChecksummedPersistentStorage> GetStorageFromKeyAsync( HostWorkspaceServices services, SolutionKey solutionKey, IPersistentStorageFaultInjector?faultInjector = null) { // If we handed out one for a previous test, we need to shut that down first _storageService?.GetTestAccessor().Shutdown(); var configuration = new MockPersistentStorageConfiguration(solutionKey.Id, _persistentFolder.Path, throwOnFailure: true); _storageService = GetStorageService((IMefHostExportProvider)services.HostServices, configuration, faultInjector, _persistentFolder.Path); var storage = await _storageService.GetStorageAsync(solutionKey, CancellationToken.None); // If we're injecting faults, we expect things to be strange if (faultInjector == null) { Assert.NotEqual(NoOpPersistentStorage.TestAccessor.StorageInstance, storage); } return(storage); }
internal async Task <IChecksummedPersistentStorage> GetStorageFromKeyAsync( Workspace workspace, SolutionKey solutionKey, IPersistentStorageFaultInjector?faultInjector = null) { // If we handed out one for a previous test, we need to shut that down first _storageService?.GetTestAccessor().Shutdown(); var locationService = new MockPersistentStorageLocationService(solutionKey.Id, _persistentFolder.Path); _storageService = GetStorageService((IMefHostExportProvider)workspace.Services.HostServices, locationService, faultInjector); var storage = await _storageService.GetStorageAsync(workspace, solutionKey, checkBranchId : true, CancellationToken.None); // If we're injecting faults, we expect things to be strange if (faultInjector == null) { Assert.NotEqual(NoOpPersistentStorage.Instance, storage); } return(storage); }
protected override IChecksummedPersistentStorage?TryOpenDatabase( SolutionKey solutionKey, Solution?bulkLoadSnapshot, string workingFolderPath, string databaseFilePath) { if (!TryInitializeLibraries()) { // SQLite is not supported on the current platform return(null); } // try to get db ownership lock. if someone else already has the lock. it will throw var dbOwnershipLock = TryGetDatabaseOwnership(databaseFilePath); if (dbOwnershipLock == null) { return(null); } SQLitePersistentStorage?sqlStorage = null; try { sqlStorage = new SQLitePersistentStorage( workingFolderPath, solutionKey.FilePath, databaseFilePath, dbOwnershipLock, _faultInjector); sqlStorage.Initialize(bulkLoadSnapshot); return(sqlStorage); } catch (Exception) { if (sqlStorage != null) { // Dispose of the storage, releasing the ownership lock. sqlStorage.Dispose(); } else { // The storage was not created so nothing owns the lock. // Dispose the lock to allow reuse. dbOwnershipLock.Dispose(); } throw; } }
public string?TryGetStorageLocation(SolutionKey solutionKey) { if (solutionKey.WorkspaceKind is not(WorkspaceKind.RemoteWorkspace or WorkspaceKind.RemoteTemporaryWorkspace or WorkspaceKind.Host)) { return(null); } if (string.IsNullOrWhiteSpace(solutionKey.FilePath)) { return(null); } // Ensure that each unique workspace kind for any given solution has a unique // folder to store their data in. var cacheDirectory = GetCacheDirectory(); var kind = StripInvalidPathChars(solutionKey.WorkspaceKind); var hash = StripInvalidPathChars(Checksum.Create(solutionKey.FilePath).ToString()); return(Path.Combine(cacheDirectory, kind, hash));
private SolutionKey SetupSolutionKey() { //TODO if solution is reopen - the guid should be read from file - future change var solutionId = Guid.NewGuid(); var openSolution = ServiceLocator.Resolve<DTE2>().Solution; var solutionPath = openSolution.FileName; var key = new SolutionKey(solutionId, solutionPath); ServiceLocator.RegisterInstance(key); return key; }