private async Task RunServerTestAsync(Context context, string scenario, Func <Context, ServiceConfiguration, IRpcClient, Task> funcAsync)
{
using (var directory = new DisposableDirectory(FileSystem))
{
var storeConfig = new ContentStoreConfiguration(new MaxSizeQuota($"{1 * 1024 * 1024}"));
await storeConfig.Write(FileSystem, directory.Path).ConfigureAwait(false);
var serviceConfig =
new ServiceConfiguration(
new Dictionary <string, AbsolutePath> {
{ CacheName, directory.Path }
},
directory.Path,
ServiceConfiguration.DefaultMaxConnections,
ServiceConfiguration.DefaultGracefulShutdownSeconds,
PortExtensions.GetNextAvailablePort(),
Guid.NewGuid().ToString())
{
TraceGrpcOperation = true
};
using (var server = new LocalContentServer(FileSystem, Logger, scenario, path => new FileSystemContentStore(FileSystem, SystemClock.Instance, path), new LocalServerConfiguration(serviceConfig)))
{
BoolResult r = await server.StartupAsync(context).ConfigureAwait(false);
r.ShouldBeSuccess();
var configuration = new ServiceClientRpcConfiguration()
{
GrpcPort = (int)serviceConfig.GrpcPort,
};
using (var rpcClient = new GrpcContentClient(new ServiceClientContentSessionTracer(scenario), FileSystem, configuration, scenario))
{
try
{
var createSessionResult = await rpcClient.CreateSessionAsync(new OperationContext(context), SessionName, CacheName, ImplicitPin.None);
createSessionResult.ShouldBeSuccess();
await funcAsync(context, serviceConfig, rpcClient);
}
finally
{
(await rpcClient.ShutdownAsync(context)).ShouldBeSuccess();
}
}
r = await server.ShutdownAsync(context);
r.ShouldBeSuccess();
}
}
}
public async Task CreateSessionThrowsClientCanRetryExceptionWhenServiceOffline()
{
string scenario = nameof(CreateSessionThrowsClientCanRetryExceptionWhenServiceOffline);
var tracingContext = new Context(Logger);
var context = new OperationContext(tracingContext);
using (var directory = new DisposableDirectory(FileSystem))
{
var rootPath = directory.Path;
var namedCacheRoots = new Dictionary <string, AbsolutePath> {
{ CacheName, rootPath }
};
var grpcPort = PortExtensions.GetNextAvailablePort();
var grpcPortFileName = Guid.NewGuid().ToString();
var configuration = new ServiceConfiguration(
namedCacheRoots,
rootPath,
MaxConnections,
ServiceConfiguration.DefaultGracefulShutdownSeconds,
grpcPort,
grpcPortFileName);
Func <AbsolutePath, IContentStore> contentStoreFactory =
path =>
new FileSystemContentStore(
FileSystem,
SystemClock.Instance,
rootPath,
new ConfigurationModel(new ContentStoreConfiguration(new MaxSizeQuota("1KB"))));
IRpcClient rpcClient;
using (var server = new LocalContentServer(FileSystem, Logger, scenario, contentStoreFactory, new LocalServerConfiguration(configuration)))
{
var tracer = new ServiceClientContentSessionTracer("TestTracerForRpcClient");
BoolResult r = await server.StartupAsync(context).ConfigureAwait(false);
r.ShouldBeSuccess();
var port = new MemoryMappedFilePortReader(grpcPortFileName, Logger).ReadPort();
rpcClient = new GrpcContentClient(tracer, FileSystem, new ServiceClientRpcConfiguration(grpcPort), scenario);
r = await server.ShutdownAsync(context);
r.ShouldBeSuccess();
}
Func <Task <BoolResult> > createSessionFunc = () => rpcClient.CreateSessionAsync(context, SessionName, CacheName, ImplicitPin.None);
createSessionFunc.Should().Throw <ClientCanRetryException>();
rpcClient.Dispose();
}
}
public async Task StartupWithSpecificDatabaseName()
{
var context = new Context(Logger);
using (var testDirectory = new DisposableDirectory(FileSystem))
{
// Constructing with a full database name instead of just a root directory
using (var store = CreateSQLiteMemoizationStore(testDirectory.Path / SQLiteMemoizationStore.DefaultDatabaseFileName))
{
BoolResult result = await store.StartupAsync(context);
result.ShouldBeSuccess();
result = await store.ShutdownAsync(context);
result.ShouldBeSuccess();
}
}
}
private async Task RunServerTestAsync(Context context, Func <Context, ServiceConfiguration, Task> funcAsync)
{
using (var directory = new DisposableDirectory(FileSystem))
{
var storeConfig = CreateStoreConfiguration();
await storeConfig.Write(FileSystem, directory.Path).ConfigureAwait(false);
var serviceConfig = CreateServiceConfiguration(directory.Path, PortExtensions.GetNextAvailablePort(), Guid.NewGuid().ToString());
using (var server = new ServiceProcess(serviceConfig, LocalContentServerConfiguration, Scenario, WaitForServerReadyTimeoutMs, WaitForExitTimeoutMs))
{
BoolResult r = await server.StartupAsync(context).ConfigureAwait(false);
r.ShouldBeSuccess();
await funcAsync(context, serviceConfig);
r = await server.ShutdownAsync(context);
r.ShouldBeSuccess();
}
}
}
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();
}
}
}
}
}