public async Task TestAssetSynchronization()
{
var code = @"class Test { void Method() { } }";
using var workspace = TestWorkspace.CreateCSharp(code);
var solution = workspace.CurrentSolution;
// build checksum
await solution.State.GetChecksumAsync(CancellationToken.None);
var map = await solution.GetAssetMapAsync(CancellationToken.None);
using var remoteWorkspace = CreateRemoteWorkspace();
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), map);
var service = new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>());
await service.SynchronizeAssetsAsync(new HashSet <Checksum>(map.Keys), CancellationToken.None);
foreach (var kv in map)
{
Assert.True(storage.TryGetAsset <object>(kv.Key, out _));
}
}
public async Task TestAssets()
{
var sessionId = 0;
var checksum = Checksum.Create(WellKnownSynchronizationKind.Null, ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray()));
var data = new object();
var storage = new AssetStorage();
_ = new SimpleAssetSource(storage, new Dictionary <Checksum, object>()
{
{ checksum, data }
});
var service = new AssetService(sessionId, storage, new RemoteWorkspace().Services.GetService <ISerializerService>());
var stored = await service.GetAssetAsync <object>(checksum, CancellationToken.None);
Assert.Equal(data, stored);
var stored2 = await service.GetAssetsAsync <object>(new[] { checksum }, CancellationToken.None);
Assert.Equal(1, stored2.Count);
Assert.Equal(checksum, stored2[0].Item1);
Assert.Equal(data, stored2[0].Item2);
}
private async Task TestAssetAsync(object data)
{
var sessionId = 0;
var checksum = Checksum.Create(WellKnownSynchronizationKind.Null, ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray()));
using var workspace = TestWorkspace.CreateCSharp(file: @"");
using var remoteWorkspace = CreateRemoteWorkspace();
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), new Dictionary <Checksum, object>()
{
{ checksum, data }
});
var provider = new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>());
var stored = await provider.GetAssetAsync <object>(checksum, CancellationToken.None);
Assert.Equal(data, stored);
var stored2 = await provider.GetAssetsAsync <object>(new[] { checksum }, CancellationToken.None);
Assert.Equal(1, stored2.Count);
Assert.Equal(checksum, stored2[0].Item1);
Assert.Equal(data, stored2[0].Item2);
}
public async Task TestSolutionSynchronization()
{
var code = @"class Test { void Method() { } }";
using var workspace = TestWorkspace.CreateCSharp(code);
var solution = workspace.CurrentSolution;
// build checksum
await solution.State.GetChecksumAsync(CancellationToken.None);
var map = await solution.GetAssetMapAsync(CancellationToken.None);
using var remoteWorkspace = CreateRemoteWorkspace();
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(
workspace.Services.GetService <ISerializerService>(),
map
);
var service = new AssetProvider(
sessionId,
storage,
assetSource,
remoteWorkspace.Services.GetService <ISerializerService>()
);
await service.SynchronizeSolutionAssetsAsync(
await solution.State.GetChecksumAsync(CancellationToken.None),
CancellationToken.None
);
TestUtils.VerifyAssetStorage(map, storage);
}
public void TestCreation()
{
var storage = new AssetStorage();
var source = new SimpleAssetSource(storage, new Dictionary <Checksum, object>());
var stored = storage.AssetSource;
Assert.Equal(source, stored);
}
public void TestCreation()
{
var storage = new AssetStorage();
var source = new SimpleAssetSource(new Dictionary <Checksum, object>());
storage.Initialize(source);
var stored = storage.GetAssetSource();
Assert.Equal(source, stored);
}
private async Task <Solution> LoadAsync(CancellationToken cancellationToken)
{
var adhocWorkspace = new AdhocWorkspace();
var serializer = adhocWorkspace.Services.GetService <ISerializerService>();
var solutionChecksum = default(Checksum);
var map = new Dictionary <Checksum, object>();
using (var stream = new FileStream(_fileName, FileMode.Open))
using (var compressed = new DeflateStream(stream, CompressionMode.Decompress))
using (var reader = ObjectReader.TryGetReader(compressed, cancellationToken))
{
// save root checksum and number of entries
solutionChecksum = Checksum.ReadFrom(reader);
// number of items in the package
var count = reader.ReadInt32();
for (var i = 0; i < count; i++)
{
var itemChecksum = Checksum.ReadFrom(reader);
var kind = (WellKnownSynchronizationKind)reader.ReadInt32();
// in service hub, cancellation means simply closed stream
var @object = serializer.Deserialize <object>(kind, reader, cancellationToken);
Debug.Assert(itemChecksum == serializer.CreateChecksum(@object, cancellationToken));
map.Add(itemChecksum, @object);
}
}
var assetSource = new SimpleAssetSource(AssetStorage.Default, map);
var assetService = new AssetService(scopeId: 0, AssetStorage.Default, serializer);
var solutionCreator = new SolutionCreator(assetService, _solution, cancellationToken);
// check whether solution is update to the given base solution
if (await solutionCreator.IsIncrementalUpdateAsync(solutionChecksum).ConfigureAwait(false))
{
// create updated solution off the baseSolution
return(await solutionCreator.CreateSolutionAsync(solutionChecksum).ConfigureAwait(false));
}
// get new solution info
var solutionInfo = await solutionCreator.CreateSolutionInfoAsync(solutionChecksum).ConfigureAwait(false);
// otherwise, just return new solution
return(adhocWorkspace.AddSolution(solutionInfo));
}
private static async Task <AssetProvider> GetAssetProviderAsync(Workspace workspace, Workspace remoteWorkspace, Solution solution, Dictionary <Checksum, object> map = null)
{
// make sure checksum is calculated
await solution.State.GetChecksumAsync(CancellationToken.None);
map ??= new Dictionary <Checksum, object>();
await solution.AppendAssetMapAsync(map, CancellationToken.None);
var sessionId = Checksum.Create(ImmutableArray.CreateRange(Guid.NewGuid().ToByteArray()));
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), map);
return(new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>()));
}
private static async Task <AssetProvider> GetAssetProviderAsync(Workspace workspace, Workspace remoteWorkspace, Solution solution, Dictionary <Checksum, object> map = null)
{
// make sure checksum is calculated
await solution.State.GetChecksumAsync(CancellationToken.None);
map ??= new Dictionary <Checksum, object>();
await solution.AppendAssetMapAsync(includeProjectCones : true, map, CancellationToken.None);
var sessionId = 0;
var storage = new SolutionAssetCache();
var assetSource = new SimpleAssetSource(workspace.Services.GetService <ISerializerService>(), map);
return(new AssetProvider(sessionId, storage, assetSource, remoteWorkspace.Services.GetService <ISerializerService>()));
}
private static async Task <SolutionService> GetSolutionServiceAsync(Solution solution, Dictionary <Checksum, object> map = null)
{
// make sure checksum is calculated
await solution.State.GetChecksumAsync(CancellationToken.None);
map ??= new Dictionary <Checksum, object>();
await solution.AppendAssetMapAsync(map, CancellationToken.None);
var sessionId = 0;
var storage = new AssetStorage();
_ = new SimpleAssetSource(storage, map);
var remoteWorkspace = new RemoteWorkspace(applyStartupOptions: false);
return(new SolutionService(new AssetProvider(sessionId, storage, remoteWorkspace.Services.GetService <ISerializerService>())));
}
public async Task TestProjectSynchronization()
{
var code = @"class Test { void Method() { } }";
using var workspace = TestWorkspace.CreateCSharp(code);
var project = workspace.CurrentSolution.Projects.First();
// build checksum
await project.State.GetChecksumAsync(CancellationToken.None);
var map = await project.GetAssetMapAsync(CancellationToken.None);
var sessionId = 0;
var storage = new AssetStorage();
var source = new SimpleAssetSource(storage, map);
var service = new AssetService(sessionId, storage, new RemoteWorkspace().Services.GetService <ISerializerService>());
await service.SynchronizeProjectAssetsAsync(SpecializedCollections.SingletonEnumerable(await project.State.GetChecksumAsync(CancellationToken.None)), CancellationToken.None);
TestUtils.VerifyAssetStorage(map, storage);
}
