internal static IContentStore CreateLocalContentStore( DistributedContentSettings settings, DistributedCacheServiceArguments arguments, ResolvedNamedCacheSettings resolvedSettings, IDistributedLocationStore distributedStore = null) { settings = settings ?? DistributedContentSettings.CreateDisabled(); var contentStoreSettings = FromDistributedSettings(settings); ConfigurationModel configurationModel = new ConfigurationModel(new ContentStoreConfiguration(new MaxSizeQuota(resolvedSettings.Settings.CacheSizeQuotaString))); var localStore = ContentStoreFactory.CreateContentStore(arguments.FileSystem, resolvedSettings.ResolvedCacheRootPath, contentStoreSettings: contentStoreSettings, distributedStore: distributedStore, configurationModel: configurationModel); if (settings.BackingGrpcPort != null) { var backingStore = new ServiceClientContentStore( arguments.Logger, arguments.FileSystem, resolvedSettings.Name, new ServiceClientRpcConfiguration(settings.BackingGrpcPort.Value), arguments.Configuration.LocalCasSettings.CasClientSettings.RetryIntervalSecondsOnFailServiceCalls, arguments.Configuration.LocalCasSettings.CasClientSettings.RetryCountOnFailServiceCalls, scenario: settings.BackingScenario); return(new MultiLevelContentStore(localStore, backingStore)); } return(localStore); }
public async Task RunAsync(VfsCasConfiguration configuration) { // Create VFS root using (var fileLog = new FileLog((configuration.RootPath / "Bvfs.log").Path)) using (var logger = new Logger(fileLog)) { var fileSystem = new PassThroughFileSystem(logger); var context = new OperationContext(new Context(logger)); // Map junctions into VFS root foreach (var mount in configuration.VirtualizationMounts) { CreateJunction(context, source: mount.Value, target: configuration.VfsMountRootPath / mount.Key); } var clientContentStore = new ServiceClientContentStore( logger, fileSystem, new ServiceClientContentStoreConfiguration( configuration.CacheName, new ServiceClientRpcConfiguration( configuration.BackingGrpcPort), scenario: configuration.Scenario)); // Client is startup/shutdown with wrapping VFS content store using (var server = new LocalContentServer( fileSystem, logger, scenario: "bvfs" + configuration.ServerGrpcPort, path => new VirtualizedContentStore(clientContentStore, logger, configuration), new LocalServerConfiguration( configuration.DataRootPath, new Dictionary <string, AbsolutePath>() { { configuration.CacheName, configuration.ServerRootPath } }, configuration.ServerGrpcPort, fileSystem))) { await server.StartupAsync(context).ThrowIfFailure(); await WaitForTerminationAsync(context); await server.ShutdownAsync(context).ThrowIfFailure(); } } }
public async Task MultipleCaches() { const string CacheName1 = "test1"; const string CacheName2 = "test2"; using (var testDirectory0 = new DisposableDirectory(FileSystem)) using (var testDirectory1 = new DisposableDirectory(FileSystem)) using (var testDirectory2 = new DisposableDirectory(FileSystem)) { var config = CreateStoreConfiguration(); var rootPath1 = testDirectory1.Path; config.Write(FileSystem, rootPath1); var rootPath2 = testDirectory2.Path; config.Write(FileSystem, rootPath2); var grpcPort = PortExtensions.GetNextAvailablePort(); var grpcPortFileName = Guid.NewGuid().ToString(); var serviceConfiguration = new ServiceConfiguration( new Dictionary <string, AbsolutePath> { { CacheName1, rootPath1 }, { CacheName2, rootPath2 } }, testDirectory0.Path, ServiceConfiguration.DefaultGracefulShutdownSeconds, grpcPort, grpcPortFileName); using (var server = CreateServer(serviceConfiguration)) { var factory = new MemoryMappedFileGrpcPortSharingFactory(Logger, grpcPortFileName); var reader = factory.GetPortReader(); var port = reader.ReadPort(); var rpcConfig = new ServiceClientRpcConfiguration(port); using (var store1 = new ServiceClientContentStore( Logger, FileSystem, new ServiceClientContentStoreConfiguration(CacheName1, rpcConfig, Scenario))) using (var store2 = new ServiceClientContentStore( Logger, FileSystem, new ServiceClientContentStoreConfiguration(CacheName2, rpcConfig, Scenario))) { try { var rs = await server.StartupAsync(_context); rs.ShouldBeSuccess(); var storeBoolResult1 = await store1.StartupAsync(_context); storeBoolResult1.ShouldBeSuccess(); var storeBoolResult2 = await store2.StartupAsync(_context); storeBoolResult2.ShouldBeSuccess(); IContentSession session1 = null; IContentSession session2 = null; try { var createSessionResult1 = store1.CreateSession(_context, "session1", ImplicitPin.None); createSessionResult1.ShouldBeSuccess(); var createSessionResult2 = store2.CreateSession(_context, "session2", ImplicitPin.None); createSessionResult2.ShouldBeSuccess(); using (createSessionResult1.Session) using (createSessionResult2.Session) { var r1 = await createSessionResult1.Session.StartupAsync(_context); r1.ShouldBeSuccess(); session1 = createSessionResult1.Session; var r2 = await createSessionResult2.Session.StartupAsync(_context); r2.ShouldBeSuccess(); session2 = createSessionResult2.Session; var r3 = await session1.PutRandomAsync( _context, ContentHashType, false, RandomContentByteCount, Token); var pinResult = await session1.PinAsync(_context, r3.ContentHash, Token); pinResult.ShouldBeSuccess(); r3 = await session2.PutRandomAsync( _context, ContentHashType, false, RandomContentByteCount, Token); pinResult = await session2.PinAsync(_context, r3.ContentHash, Token); pinResult.ShouldBeSuccess(); } } finally { if (session2 != null) { await session2.ShutdownAsync(_context).ShouldBeSuccess(); } if (session1 != null) { await session1.ShutdownAsync(_context).ShouldBeSuccess(); } } } finally { BoolResult r1 = null; BoolResult r2 = null; if (store1.StartupCompleted) { r1 = await store1.ShutdownAsync(_context); } if (store2.StartupCompleted) { r2 = await store2.ShutdownAsync(_context); } var r3 = await server.ShutdownAsync(_context); r1?.ShouldBeSuccess(); r2?.ShouldBeSuccess(); r3?.ShouldBeSuccess(); } } } } }
public async Task ServiceTestAsync() { using var fileSystem = new PassThroughFileSystem(Logger); using var dir = new DisposableDirectory(fileSystem); var cacheDir = dir.Path / "cache"; var dataPath = dir.Path / "data"; var args = new Dictionary <string, string> { ["paths"] = cacheDir.Path, ["names"] = "Default", ["grpcPort"] = "7090", ["LogSeverity"] = "Diagnostic", ["dataRootPath"] = dataPath.Path, ["Scenario"] = "AppTests", ["grpcPortFileName"] = "AppTestsMMF" }; var serviceProcess = RunService("Service", args, Logger); try { await RunAppAsync("ServiceRunning", new Dictionary <string, string> { { "waitSeconds", "5" }, { "Scenario", "AppTests" } }, Logger); var context = new Context(Logger); var config = new ServiceClientContentStoreConfiguration("Default", new ServiceClientRpcConfiguration { GrpcPort = 7090 }, scenario: "AppTests"); using var store = new ServiceClientContentStore(Logger, fileSystem, config); await store.StartupAsync(context).ShouldBeSuccess(); var sessionResult = store.CreateSession(context, "Default", ImplicitPin.None).ShouldBeSuccess(); using var session = sessionResult.Session; await session.StartupAsync(context).ShouldBeSuccess(); var source = dir.Path / "source.txt"; var contents = new byte[1024]; Random.NextBytes(contents); fileSystem.WriteAllBytes(source, contents); var putResult = await session.PutFileAsync(context, HashType.MD5, source, FileRealizationMode.Any, CancellationToken.None).ShouldBeSuccess(); var hash = putResult.ContentHash; await session.PinAsync(context, hash, CancellationToken.None).ShouldBeSuccess(); var destination = dir.Path / "destination.txt"; await session.PlaceFileAsync( context, hash, destination, FileAccessMode.ReadOnly, FileReplacementMode.FailIfExists, FileRealizationMode.Any, CancellationToken.None).ShouldBeSuccess(); fileSystem.ReadAllBytes(destination).Should().BeEquivalentTo(contents); } finally { if (!serviceProcess.HasExited) { serviceProcess.Kill(); #pragma warning disable AsyncFixer02 // WaitForExitAsync should be used instead serviceProcess.WaitForExit(); #pragma warning restore AsyncFixer02 } } }