internal static void ProjectStateEqual(IRemotableDataService service, ProjectStateChecksums projectObjects1, ProjectStateChecksums projectObjects2)
{
ChecksumWithChildrenEqual(projectObjects1, projectObjects2);
ChecksumWithChildrenEqual(projectObjects1.Documents.ToDocumentObjects(service), projectObjects2.Documents.ToDocumentObjects(service));
ChecksumWithChildrenEqual(projectObjects1.AdditionalDocuments.ToDocumentObjects(service), projectObjects2.AdditionalDocuments.ToDocumentObjects(service));
}
public static async Task WriteDataAsync(ObjectWriter writer, IRemotableDataService remotableDataService, int scopeId, Checksum[] checksums, CancellationToken cancellationToken)
{
writer.WriteInt32(scopeId);
// special case
if (checksums.Length == 0)
{
writer.WriteInt32(0);
return;
}
if (checksums.Length == 1)
{
var checksum = checksums[0];
var remotableData = (await remotableDataService.GetRemotableDataAsync(scopeId, checksum, cancellationToken).ConfigureAwait(false)) ?? RemotableData.Null;
writer.WriteInt32(1);
await WriteRemotableData(writer, checksum, remotableData, cancellationToken).ConfigureAwait(false);
return;
}
var remotableDataMap = await remotableDataService.GetRemotableDataAsync(scopeId, checksums, cancellationToken).ConfigureAwait(false);
writer.WriteInt32(remotableDataMap.Count);
foreach (var(checksum, remotableData) in remotableDataMap)
{
await WriteRemotableData(writer, checksum, remotableData, cancellationToken).ConfigureAwait(false);
}
internal static async Task<T> RunRemoteAsync<T>(Connection connection, IRemotableDataService remoteDataService, string targetName, Solution? solution, IReadOnlyList<object?> arguments, Func<Stream, CancellationToken, Task<T>>? dataReader, CancellationToken cancellationToken)
{
if (solution != null)
{
using var scope = await remoteDataService.CreatePinnedRemotableDataScopeAsync(solution, cancellationToken).ConfigureAwait(false);
using var _ = ArrayBuilder<object?>.GetInstance(arguments.Count + 1, out var argumentsBuilder);
argumentsBuilder.Add(scope.SolutionInfo);
argumentsBuilder.AddRange(arguments);
if (dataReader != null)
{
return await connection.InvokeAsync(targetName, argumentsBuilder, dataReader, cancellationToken).ConfigureAwait(false);
}
else
{
return await connection.InvokeAsync<T>(targetName, argumentsBuilder, cancellationToken).ConfigureAwait(false);
}
}
else if (dataReader != null)
{
return await connection.InvokeAsync(targetName, arguments, dataReader, cancellationToken).ConfigureAwait(false);
}
else
{
return await connection.InvokeAsync<T>(targetName, arguments, cancellationToken).ConfigureAwait(false);
}
}
private async Task <Solution> GetSolutionAsync(IRemotableDataService service, PinnedRemotableDataScope syncScope)
{
var(solutionInfo, _) = await SolutionInfoCreator.CreateSolutionInfoAndOptionsAsync(new AssetProvider(service), syncScope.SolutionChecksum, CancellationToken.None).ConfigureAwait(false);
var workspace = new AdhocWorkspace();
return(workspace.AddSolution(solutionInfo));
}
internal static async Task VerifySolutionStateSerializationAsync(IRemotableDataService service, Solution solution, Checksum solutionChecksum)
{
var solutionObjectFromSyncObject = await service.GetValueAsync <SolutionStateChecksums>(solutionChecksum);
Assert.True(solution.State.TryGetStateChecksums(out var solutionObjectFromSolution));
SolutionStateEqual(service, solutionObjectFromSolution, solutionObjectFromSyncObject);
}
internal static void VerifyChecksumInService(IRemotableDataService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind)
{
Assert.NotNull(checksum);
var service = (RemotableDataServiceFactory.Service)snapshotService;
var otherObject = service.GetRemotableData_TestOnly(checksum, CancellationToken.None);
ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind);
}
internal static async Task VerifyChecksumInServiceAsync(IRemotableDataService snapshotService, Checksum checksum, WellKnownSynchronizationKind kind)
{
Assert.NotNull(checksum);
var service = (RemotableDataServiceFactory.Service)snapshotService;
var otherObject = (await service.TestOnly_GetRemotableDataAsync(checksum, CancellationToken.None).ConfigureAwait(false)) !;
ChecksumEqual(checksum, kind, otherObject.Checksum, otherObject.Kind);
}
public RemotableDataJsonRpc(Microsoft.CodeAnalysis.Workspace workspace, Stream stream)
: base(stream, callbackTarget: null, useThisAsCallback: true)
{
_remotableDataService = workspace.Services.GetService <IRemotableDataService>();
_shutdownCancellationSource = new CancellationTokenSource();
StartListening();
}
public RemotableDataJsonRpc(Workspace workspace, TraceSource logger, Stream stream)
: base(workspace, logger, stream, callbackTarget: null, useThisAsCallback: true)
{
_remotableDataService = workspace.Services.GetService <IRemotableDataService>();
_shutdownCancellationSource = new CancellationTokenSource();
StartListening();
}
internal static async Task VerifyAssetAsync(IRemotableDataService service, DocumentStateChecksums documentObject)
{
var info = await VerifyAssetSerializationAsync <DocumentInfo.DocumentAttributes>(
service, documentObject.Info, WellKnownSynchronizationKind.DocumentAttributes,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
await VerifyAssetSerializationAsync <SourceText>(
service, documentObject.Text, WellKnownSynchronizationKind.SourceText,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s));
}
internal static void VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumObjectCollection <DocumentStateChecksums> documents, int expectedCount)
{
VerifySynchronizationObjectInService(snapshotService, documents);
Assert.Equal(documents.Count, expectedCount);
foreach (var documentId in documents)
{
VerifySnapshotInService(snapshotService, documentId);
}
}
internal static void VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumCollection checksums, int expectedCount, WellKnownSynchronizationKind expectedItemKind)
{
VerifyChecksumInService(snapshotService, checksums.Checksum, checksums.GetWellKnownSynchronizationKind());
Assert.Equal(checksums.Count, expectedCount);
foreach (var checksum in checksums)
{
VerifyChecksumInService(snapshotService, checksum, expectedItemKind);
}
}
internal static async Task VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumCollection checksums, int expectedCount, WellKnownSynchronizationKind expectedItemKind)
{
await VerifyChecksumInServiceAsync(snapshotService, checksums.Checksum, checksums.GetWellKnownSynchronizationKind()).ConfigureAwait(false);
Assert.Equal(checksums.Count, expectedCount);
foreach (var checksum in checksums)
{
await VerifyChecksumInServiceAsync(snapshotService, checksum, expectedItemKind).ConfigureAwait(false);
}
}
internal static void ProjectStatesEqual(IRemotableDataService service, ChecksumObjectCollection <ProjectStateChecksums> projectObjects1, ChecksumObjectCollection <ProjectStateChecksums> projectObjects2)
{
SynchronizationObjectEqual(projectObjects1, projectObjects2);
Assert.Equal(projectObjects1.Count, projectObjects2.Count);
for (var i = 0; i < projectObjects1.Count; i++)
{
ProjectStateEqual(service, projectObjects1[i], projectObjects2[i]);
}
}
internal static async Task VerifyCollectionInService(IRemotableDataService snapshotService, ChecksumObjectCollection <DocumentStateChecksums> documents, int expectedCount)
{
await VerifySynchronizationObjectInServiceAsync(snapshotService, documents).ConfigureAwait(false);
Assert.Equal(documents.Count, expectedCount);
foreach (var documentId in documents)
{
await VerifySnapshotInServiceAsync(snapshotService, documentId).ConfigureAwait(false);
}
}
public RemotableDataJsonRpc(Workspace workspace, TraceSource logger, Stream snapshotServiceStream)
{
_workspace = workspace;
_remotableDataService = workspace.Services.GetRequiredService <IRemotableDataService>();
_shutdownCancellationSource = new CancellationTokenSource();
_endPoint = new RemoteEndPoint(snapshotServiceStream, logger, incomingCallTarget: this);
_endPoint.UnexpectedExceptionThrown += UnexpectedExceptionThrown;
_endPoint.Disconnected += OnDisconnected;
_endPoint.StartListening();
}
internal static async Task VerifyAssetAsync(IRemotableDataService service, SolutionStateChecksums solutionObject)
{
await VerifyAssetSerializationAsync <SolutionInfo.SolutionAttributes>(
service, solutionObject.Info, WellKnownSynchronizationKind.SolutionAttributes,
(v, k, s) => SolutionAsset.Create(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
foreach (var projectChecksum in solutionObject.Projects)
{
var projectObject = await service.GetValueAsync <ProjectStateChecksums>(projectChecksum).ConfigureAwait(false);
await VerifyAssetAsync(service, projectObject).ConfigureAwait(false);
}
}
internal static async Task VerifyAssetAsync(IRemotableDataService service, ProjectStateChecksums projectObject)
{
var info = await VerifyAssetSerializationAsync <ProjectInfo.ProjectAttributes>(
service, projectObject.Info, WellKnownSynchronizationKind.ProjectAttributes,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s)).ConfigureAwait(false);
await VerifyAssetSerializationAsync <CompilationOptions>(
service, projectObject.CompilationOptions, WellKnownSynchronizationKind.CompilationOptions,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
await VerifyAssetSerializationAsync <ParseOptions>(
service, projectObject.ParseOptions, WellKnownSynchronizationKind.ParseOptions,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
foreach (var checksum in projectObject.Documents)
{
var documentObject = await service.GetValueAsync <DocumentStateChecksums>(checksum).ConfigureAwait(false);
await VerifyAssetAsync(service, documentObject).ConfigureAwait(false);
}
foreach (var checksum in projectObject.ProjectReferences)
{
await VerifyAssetSerializationAsync <ProjectReference>(
service, checksum, WellKnownSynchronizationKind.ProjectReference,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.MetadataReferences)
{
await VerifyAssetSerializationAsync <MetadataReference>(
service, checksum, WellKnownSynchronizationKind.MetadataReference,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.AnalyzerReferences)
{
await VerifyAssetSerializationAsync <AnalyzerReference>(
service, checksum, WellKnownSynchronizationKind.AnalyzerReference,
(v, k, s) => new SolutionAsset(s.CreateChecksum(v, CancellationToken.None), v, s));
}
foreach (var checksum in projectObject.AdditionalDocuments)
{
var documentObject = await service.GetValueAsync <DocumentStateChecksums>(checksum).ConfigureAwait(false);
await VerifyAssetAsync(service, documentObject).ConfigureAwait(false);
}
foreach (var checksum in projectObject.AnalyzerConfigDocuments)
{
var documentObject = await service.GetValueAsync <DocumentStateChecksums>(checksum).ConfigureAwait(false);
await VerifyAssetAsync(service, documentObject).ConfigureAwait(false);
}
}
public KeepAliveSession(RemoteHostClient client, RemoteHostClient.Connection connection, string serviceName, object?callbackTarget)
{
_gate = new object();
Initialize(client, connection);
_remoteHostClientService = client.Workspace.Services.GetRequiredService <IRemoteHostClientService>();
_remotableDataService = client.Workspace.Services.GetRequiredService <IRemotableDataService>();
_serviceName = serviceName;
_callbackTarget = callbackTarget;
}
public JsonRpcConnection(
HostWorkspaceServices services,
TraceSource logger,
object?callbackTarget,
Stream serviceStream,
IPooledConnectionReclamation?poolReclamation)
{
_remotableDataService = services.GetRequiredService <IRemotableDataService>();
_services = services;
_serviceEndPoint = new RemoteEndPoint(serviceStream, logger, callbackTarget);
_serviceEndPoint.UnexpectedExceptionThrown += UnexpectedExceptionThrown;
_serviceEndPoint.StartListening();
_poolReclamation = poolReclamation;
#if DEBUG
_creationCallStack = Environment.StackTrace;
#endif
}
public static async Task <T> GetValueAsync <T>(this IRemotableDataService service, Checksum checksum)
{
var syncService = (RemotableDataServiceFactory.Service)service;
var syncObject = (await syncService.TestOnly_GetRemotableDataAsync(checksum, CancellationToken.None).ConfigureAwait(false)) !;
using var stream = SerializableBytes.CreateWritableStream();
using (var writer = new ObjectWriter(stream, leaveOpen: true))
{
await syncObject.WriteObjectToAsync(writer, CancellationToken.None).ConfigureAwait(false);
}
stream.Position = 0;
using var reader = ObjectReader.TryGetReader(stream);
// deserialize bits to object
var serializer = syncService.Serializer_TestOnly;
return(serializer.Deserialize <T>(syncObject.Kind, reader, CancellationToken.None));
}
internal static async Task <T> VerifyAssetSerializationAsync <T>(
IRemotableDataService service,
Checksum checksum,
WellKnownSynchronizationKind kind,
Func <T, WellKnownSynchronizationKind, ISerializerService, RemotableData> assetGetter)
{
// re-create asset from object
var syncService = (RemotableDataServiceFactory.Service)service;
var syncObject = syncService.GetRemotableData_TestOnly(checksum, CancellationToken.None);
var recoveredValue = await service.GetValueAsync <T>(checksum);
var recreatedSyncObject = assetGetter(recoveredValue, kind, syncService.Serializer_TestOnly);
// make sure original object and re-created object are same.
SynchronizationObjectEqual(syncObject, recreatedSyncObject);
return(recoveredValue);
}
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);
_services = services;
_hubClient = hubClient;
_hostGroup = hostGroup;
_endPoint = new RemoteEndPoint(stream, hubClient.Logger, incomingCallTarget: this);
_endPoint.Disconnected += OnDisconnected;
_endPoint.UnexpectedExceptionThrown += OnUnexpectedExceptionThrown;
_endPoint.StartListening();
_remotableDataService = services.GetRequiredService <IRemotableDataService>();
}
internal static void VerifySnapshotInService(
IRemotableDataService snapshotService,
ProjectStateChecksums projectObject,
int expectedDocumentCount,
int expectedProjectReferenceCount,
int expectedMetadataReferenceCount,
int expectedAnalyzerReferenceCount,
int expectedAdditionalDocumentCount)
{
VerifyChecksumInService(snapshotService, projectObject.Checksum, projectObject.GetWellKnownSynchronizationKind());
VerifyChecksumInService(snapshotService, projectObject.Info, WellKnownSynchronizationKind.ProjectAttributes);
VerifyChecksumInService(snapshotService, projectObject.CompilationOptions, WellKnownSynchronizationKind.CompilationOptions);
VerifyChecksumInService(snapshotService, projectObject.ParseOptions, WellKnownSynchronizationKind.ParseOptions);
VerifyCollectionInService(snapshotService, projectObject.Documents.ToDocumentObjects(snapshotService), expectedDocumentCount);
VerifyCollectionInService(snapshotService, projectObject.ProjectReferences, expectedProjectReferenceCount, WellKnownSynchronizationKind.ProjectReference);
VerifyCollectionInService(snapshotService, projectObject.MetadataReferences, expectedMetadataReferenceCount, WellKnownSynchronizationKind.MetadataReference);
VerifyCollectionInService(snapshotService, projectObject.AnalyzerReferences, expectedAnalyzerReferenceCount, WellKnownSynchronizationKind.AnalyzerReference);
VerifyCollectionInService(snapshotService, projectObject.AdditionalDocuments.ToDocumentObjects(snapshotService), expectedAdditionalDocumentCount);
}
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();
_remotableDataService = services.GetRequiredService <IRemotableDataService>();
}
private async Task <Solution> GetSolutionAsync(IRemotableDataService service, PinnedRemotableDataScope syncScope)
{
var workspace = new AdhocWorkspace();
var solutionObject = await service.GetValueAsync <SolutionStateChecksums>(syncScope.SolutionChecksum);
var solutionInfo = await service.GetValueAsync <SolutionInfo.SolutionAttributes>(solutionObject.Info).ConfigureAwait(false);
var projects = new List <ProjectInfo>();
foreach (var projectObject in solutionObject.Projects.ToProjectObjects(service))
{
var projectInfo = await service.GetValueAsync <ProjectInfo.ProjectAttributes>(projectObject.Info).ConfigureAwait(false);
if (!workspace.Services.IsSupported(projectInfo.Language))
{
continue;
}
var documents = new List <DocumentInfo>();
foreach (var documentObject in projectObject.Documents.ToDocumentObjects(service))
{
var documentInfo = await service.GetValueAsync <DocumentInfo.DocumentAttributes>(documentObject.Info).ConfigureAwait(false);
var text = await service.GetValueAsync <SourceText>(documentObject.Text).ConfigureAwait(false);
// TODO: do we need version?
documents.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())),
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var p2p = new List <ProjectReference>();
foreach (var checksum in projectObject.ProjectReferences)
{
var reference = await service.GetValueAsync <ProjectReference>(checksum).ConfigureAwait(false);
p2p.Add(reference);
}
var metadata = new List <MetadataReference>();
foreach (var checksum in projectObject.MetadataReferences)
{
var reference = await service.GetValueAsync <MetadataReference>(checksum).ConfigureAwait(false);
metadata.Add(reference);
}
var analyzers = new List <AnalyzerReference>();
foreach (var checksum in projectObject.AnalyzerReferences)
{
var reference = await service.GetValueAsync <AnalyzerReference>(checksum).ConfigureAwait(false);
analyzers.Add(reference);
}
var additionals = new List <DocumentInfo>();
foreach (var documentObject in projectObject.AdditionalDocuments.ToDocumentObjects(service))
{
var documentInfo = await service.GetValueAsync <DocumentInfo.DocumentAttributes>(documentObject.Info).ConfigureAwait(false);
var text = await service.GetValueAsync <SourceText>(documentObject.Text).ConfigureAwait(false);
// TODO: do we need version?
additionals.Add(
DocumentInfo.Create(
documentInfo.Id,
documentInfo.Name,
documentInfo.Folders,
documentInfo.SourceCodeKind,
TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())),
documentInfo.FilePath,
documentInfo.IsGenerated));
}
var compilationOptions = await service.GetValueAsync <CompilationOptions>(projectObject.CompilationOptions).ConfigureAwait(false);
var parseOptions = await service.GetValueAsync <ParseOptions>(projectObject.ParseOptions).ConfigureAwait(false);
projects.Add(
ProjectInfo.Create(
projectInfo.Id, projectInfo.Version, projectInfo.Name, projectInfo.AssemblyName,
projectInfo.Language, projectInfo.FilePath, projectInfo.OutputFilePath,
compilationOptions, parseOptions,
documents, p2p, metadata, analyzers, additionals, projectInfo.IsSubmission));
}
return(workspace.AddSolution(SolutionInfo.Create(solutionInfo.Id, solutionInfo.Version, solutionInfo.FilePath, projects)));
}
internal static void VerifySynchronizationObjectInService <T>(IRemotableDataService snapshotService, T syncObject) where T : RemotableData
{
VerifyChecksumInService(snapshotService, syncObject.Checksum, syncObject.Kind);
}
internal static void VerifySnapshotInService(IRemotableDataService snapshotService, DocumentStateChecksums documentObject)
{
VerifyChecksumInService(snapshotService, documentObject.Checksum, documentObject.GetWellKnownSynchronizationKind());
VerifyChecksumInService(snapshotService, documentObject.Info, WellKnownSynchronizationKind.DocumentAttributes);
VerifyChecksumInService(snapshotService, documentObject.Text, WellKnownSynchronizationKind.SourceText);
}
internal static async Task VerifySynchronizationObjectInServiceAsync(IRemotableDataService snapshotService, RemotableData syncObject) => await VerifyChecksumInServiceAsync(snapshotService, syncObject.Checksum, syncObject.Kind).ConfigureAwait(false);
internal static void SolutionStateEqual(IRemotableDataService service, SolutionStateChecksums solutionObject1, SolutionStateChecksums solutionObject2)
{
ChecksumWithChildrenEqual(solutionObject1, solutionObject2);
ProjectStatesEqual(service, solutionObject1.Projects.ToProjectObjects(service), solutionObject2.Projects.ToProjectObjects(service));
}
