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;
}
