private static IRpcClient GetRpcClient(
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer sessionTracer,
ServiceClientContentStoreConfiguration configuration)
{
return(new GrpcCacheClient(sessionTracer, fileSystem, configuration.RpcConfiguration, configuration.Scenario));
}
private async Task LongCallCanceledOnShutdownAsync <T>(
string scenario, bool respectsCancellationToken, Func <OperationContext, AbsolutePath, IRpcClient, Task <T> > unresponsiveFunc)
{
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);
// Use a store which gets stuck forever on the session operations (pin/place/put/open) unless canceled,
// and configurably ignoring the cancellation token to simulate long operations that might not check
// the token quickly enough.
var unresponsivenessHasStartedSemaphore = new SemaphoreSlim(0, 1);
Func <AbsolutePath, IContentStore> contentStoreFactory =
path => new TestHangingContentStore(respectsCancellationToken, unresponsivenessHasStartedSemaphore);
IRpcClient rpcClient;
Task <T> unresponsiveTask;
using (var server = new LocalContentServer(FileSystem, Logger, scenario, contentStoreFactory, new LocalServerConfiguration(configuration)))
{
var tracer = new ServiceClientContentSessionTracer("TestTracerForRpcClient");
await server.StartupAsync(context).ShouldBeSuccess();
var port = new MemoryMappedFilePortReader(grpcPortFileName, Logger).ReadPort();
rpcClient = new GrpcContentClient(tracer, FileSystem, new ServiceClientRpcConfiguration(grpcPort), scenario);
await rpcClient.CreateSessionAsync(
context, SessionName, CacheName, ImplicitPin.None).ShouldBeSuccess();
// Start the task which we expect to become unresponsive
unresponsiveTask = unresponsiveFunc(context, directory.CreateRandomFileName(), rpcClient);
// Synchronize with the store's unresponsiveness.
await unresponsivenessHasStartedSemaphore.WaitAsync();
await server.ShutdownAsync(context).ShouldBeSuccess();
}
// Make sure that the client gets a retryable exception
Func <Task> awaitUnresponsiveTaskFunc = async() => await unresponsiveTask;
awaitUnresponsiveTaskFunc.Should().Throw <ClientCanRetryException>();
(await rpcClient.ShutdownAsync(context)).ShouldBeSuccess();
rpcClient.Dispose();
}
}
/// <nodoc />
public GrpcCacheClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
ServiceClientRpcConfiguration configuration,
string scenario)
: base(tracer, fileSystem, configuration, scenario, Capabilities.All)
{
}
/// <nodoc />
public GrpcContentClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
ServiceClientRpcConfiguration configuration,
string?scenario)
: this(tracer, fileSystem, configuration, scenario, Capabilities.ContentOnly)
{
}
private static IRpcClient GetRpcClient(
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer sessionTracer,
ServiceClientContentStoreConfiguration configuration)
{
var rpcConfiguration = configuration.RpcConfiguration;
return(new GrpcCacheClient(sessionTracer, fileSystem, rpcConfiguration.GrpcPort, configuration.Scenario, rpcConfiguration.HeartbeatInterval));
}
/// <nodoc />
public GrpcCacheClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
int grpcPort,
string scenario,
TimeSpan?heartbeatInterval = null)
: base(tracer, fileSystem, grpcPort, scenario, heartbeatInterval, Capabilities.All)
{
}
/// <nodoc />
protected GrpcContentClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
ServiceClientRpcConfiguration configuration,
string?scenario,
Capabilities capabilities = Capabilities.ContentOnly)
: base(fileSystem, tracer, configuration, scenario, capabilities)
{
Client = new ContentServer.ContentServerClient(Channel);
}
/// <nodoc />
public GrpcContentClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
ServiceClientRpcConfiguration configuration,
string scenario,
Capabilities capabilities = Capabilities.ContentOnly)
: base(fileSystem, tracer, configuration, scenario, capabilities)
{
GrpcEnvironment.InitializeIfNeeded();
Client = new ContentServer.ContentServerClient(Channel);
}
/// <summary>
/// Initializes a new instance of the <see cref="GrpcClient" /> class.
/// </summary>
public GrpcClient(ServiceClientContentSessionTracer tracer, IAbsFileSystem fileSystem, uint grpcPort, string scenario, TimeSpan?heartbeatInterval = null)
{
_tracer = tracer;
_fileSystem = fileSystem;
_grpcPort = grpcPort;
_scenario = scenario;
GrpcEnvironment.InitializeIfNeeded();
_channel = new Channel(GrpcEnvironment.Localhost, (int)grpcPort, ChannelCredentials.Insecure);
_client = new ContentServer.ContentServerClient(_channel);
_clientCapabilities = DefaultClientCapabilities;
_heartbeatInterval = heartbeatInterval ?? TimeSpan.FromMinutes(DefaultHeartbeatIntervalMinutes);
}
/// <nodoc />
public GrpcContentClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
int grpcPort,
string scenario,
TimeSpan?heartbeatInterval = null,
Capabilities capabilities = Capabilities.ContentOnly)
: base(fileSystem, tracer, grpcPort, scenario, capabilities, heartbeatInterval)
{
GrpcEnvironment.InitializeIfNeeded();
_client = new ContentServer.ContentServerClient(Channel);
}
/// <nodoc />
public GrpcPublishingCacheClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
ServiceClientRpcConfiguration configuration,
string scenario,
PublishingCacheConfiguration publishingConfig,
string pat)
: base(tracer, fileSystem, configuration, scenario, Capabilities.All)
{
_serializedPublishingConfig = DynamicJson.Serialize(publishingConfig);
_pat = pat;
}
/// <nodoc />
public GrpcContentClient(
ServiceClientContentSessionTracer tracer,
IAbsFileSystem fileSystem,
int grpcPort,
string scenario,
TimeSpan?heartbeatInterval = null,
Capabilities capabilities = Capabilities.ContentOnly)
: this(tracer, fileSystem, new ServiceClientRpcConfiguration(grpcPort, heartbeatInterval), scenario, capabilities)
{
GrpcEnvironment.InitializeIfNeeded();
Client = new ContentServer.ContentServerClient(Channel);
}
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();
}
}
/// <nodoc />
public ServiceClientCacheSession(
string name,
ImplicitPin implicitPin,
ILogger logger,
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer sessionTracer,
ServiceClientContentStoreConfiguration configuration)
: base(name, implicitPin, logger, fileSystem, sessionTracer, configuration, () => GetRpcClient(fileSystem, sessionTracer, configuration))
{
// RpcClient is created by the base class constructor, but we know that this is the result of GetPrcClient call
// that actually returns GrpcCacheClient instance.
_rpcCacheClient = (GrpcCacheClient)RpcClient;
}
private static IRpcClient CreateRpcClient(
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer sessionTracer,
ServiceClientContentStoreConfiguration configuration,
PublishingCacheConfiguration publishingConfig,
string pat)
=> new GrpcPublishingCacheClient(
sessionTracer,
fileSystem,
configuration.RpcConfiguration,
configuration.Scenario,
publishingConfig,
pat);
public async Task PutStreamRetriesWhenTempFileDisappears()
{
string scenario = nameof(PutStreamRetriesWhenTempFileDisappears);
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 TestTempFileDeletingContentStore(FileSystem);
using (var server = new LocalContentServer(FileSystem, Logger, scenario, contentStoreFactory, new LocalServerConfiguration(configuration)))
{
var tracer = new ServiceClientContentSessionTracer("TestTracerForRpcClient");
await server.StartupAsync(context).ShouldBeSuccess();
var port = new MemoryMappedFilePortReader(grpcPortFileName, Logger).ReadPort();
using (IRpcClient rpcClient = new GrpcContentClient(tracer, FileSystem, new ServiceClientRpcConfiguration(grpcPort), scenario))
{
await rpcClient.CreateSessionAsync(
context, SessionName, CacheName, ImplicitPin.None).ShouldBeSuccess();
using (var stream = new MemoryStream())
{
Func <Task <PutResult> > putFunc = () => rpcClient.PutStreamAsync(context, HashType.Vso0, stream, createDirectory: false);
putFunc.Should().Throw <ClientCanRetryException>();
}
(await rpcClient.ShutdownAsync(context)).ShouldBeSuccess();
}
await server.ShutdownAsync(context).ShouldBeSuccess();
}
}
}
protected GrpcClientBase(
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer tracer,
ServiceClientRpcConfiguration configuration,
string?scenario,
Capabilities clientCapabilities)
{
FileSystem = fileSystem;
ServiceClientTracer = tracer;
Configuration = configuration;
Scenario = scenario;
_clientCapabilities = clientCapabilities;
GrpcEnvironment.WaitUntilInitialized();
Channel = new Channel(configuration.GrpcHost, configuration.GrpcPort, ChannelCredentials.Insecure, GrpcEnvironment.GetClientOptions(configuration.GrpcCoreClientOptions));
}
public TestServiceClientContentSession(
string name,
ImplicitPin implicitPin,
RetryPolicy retryPolicy,
AbsolutePath rootPath,
string cacheName,
ILogger logger,
IAbsFileSystem fileSystem,
string scenario,
ITestServiceClientContentStore store,
ServiceClientContentSessionTracer sessionTracer,
ServiceClientRpcConfiguration rpcConfiguration)
: base(name, implicitPin, logger, fileSystem, sessionTracer, new ServiceClientContentStoreConfiguration(cacheName, rpcConfiguration, scenario, retryPolicy))
{
_rootPath = rootPath;
Store = store;
}
/// <nodoc />
protected GrpcClientBase(
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer tracer,
ServiceClientRpcConfiguration configuration,
string scenario,
Capabilities clientCapabilities,
TimeSpan?heartbeatInterval = null)
{
FileSystem = fileSystem;
ServiceClientTracer = tracer;
_configuration = configuration;
Scenario = scenario;
GrpcEnvironment.InitializeIfNeeded();
Channel = new Channel(configuration.GrpcHost ?? GrpcEnvironment.Localhost, configuration.GrpcPort, ChannelCredentials.Insecure, GrpcEnvironment.DefaultConfiguration);
_clientCapabilities = clientCapabilities;
_heartbeatInterval = _configuration.HeartbeatInterval ?? TimeSpan.FromMinutes(DefaultHeartbeatIntervalMinutes);
}
/// <nodoc />
protected GrpcClientBase(
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer tracer,
int grpcPort,
string scenario,
Capabilities clientCapabilities,
TimeSpan?heartbeatInterval = null)
{
FileSystem = fileSystem;
ServiceClientTracer = tracer;
_grpcPort = grpcPort;
Scenario = scenario;
GrpcEnvironment.InitializeIfNeeded();
Channel = new Channel(GrpcEnvironment.Localhost, (int)grpcPort, ChannelCredentials.Insecure);
_clientCapabilities = clientCapabilities;
_heartbeatInterval = heartbeatInterval ?? TimeSpan.FromMinutes(DefaultHeartbeatIntervalMinutes);
}
/// <nodoc />
public ServiceClientPublishingCacheSession(
string name,
ImplicitPin implicitPin,
ILogger logger,
IAbsFileSystem fileSystem,
ServiceClientContentSessionTracer sessionTracer,
ServiceClientContentStoreConfiguration configuration,
PublishingCacheConfiguration publishingConfig,
string pat)
: base(
name,
implicitPin,
logger,
fileSystem,
sessionTracer,
configuration,
() => CreateRpcClient(fileSystem, sessionTracer, configuration, publishingConfig, pat))
{
}
public async Task DoesNotRespectFileReplacementMode(FileReplacementMode requestedReplacementMode)
{
string scenario = nameof(DoesNotRespectFileReplacementMode) + requestedReplacementMode;
var context = new Context(Logger);
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("1MB"))));
using (var server = new LocalContentServer(FileSystem, Logger, scenario, contentStoreFactory, new LocalServerConfiguration(configuration)))
{
var tracer = new ServiceClientContentSessionTracer("TestTracerForRpcClient");
await server.StartupAsync(context).ShouldBeSuccess();
var port = new MemoryMappedFilePortReader(grpcPortFileName, Logger).ReadPort();
IRpcClient rpcClient = new GrpcContentClient(tracer, FileSystem, port, scenario);
await rpcClient.CreateSessionAsync(
context, SessionName, CacheName, ImplicitPin.None).ShouldBeSuccess();
ContentHash contentHash;
using (var stream = new MemoryStream())
{
PutResult putResult = await rpcClient.PutStreamAsync(context, HashType.Vso0, stream, createDirectory : false);
putResult.ShouldBeSuccess();
putResult.ContentSize.Should().Be(0);
contentHash = putResult.ContentHash;
}
var tempPath = directory.CreateRandomFileName();
FileSystem.WriteAllBytes(tempPath, new byte[] {});
var placeResult = await rpcClient.PlaceFileAsync(
context, contentHash, tempPath, FileAccessMode.ReadOnly, requestedReplacementMode, FileRealizationMode.Any);
placeResult.Succeeded.Should().BeTrue();
(await rpcClient.ShutdownAsync(context)).ShouldBeSuccess();
rpcClient.Dispose();
await server.ShutdownAsync(context).ShouldBeSuccess();
}
}
}
