protected abstract (IContentStore store, IStartupShutdown server) CreateStore(
Context context,
IRemoteFileCopier fileCopier,
DisposableDirectory testDirectory,
int index,
int iteration,
uint grpcPort);
internal DistributedCacheServiceArguments CreateDistributedCacheServiceArguments(
IRemoteFileCopier copier,
IContentCommunicationManager copyRequester,
DistributedContentSettings dcs,
HostInfo host,
string cacheName,
string cacheRootPath,
uint grpcPort,
int maxSizeQuotaMB,
string dataRootPath,
CancellationToken ct,
int?bufferSizeForGrpcCopies,
int?gzipBarrierSizeForGrpcCopies,
LoggingSettings loggingSettings,
ITelemetryFieldsProvider telemetryFieldsProvider)
{
var distributedCacheServiceHost = new EnvironmentVariableHost();
var localCasSettings = LocalCasSettings.Default(
maxSizeQuotaMB: maxSizeQuotaMB,
cacheRootPath: cacheRootPath,
cacheName: cacheName,
grpcPort: grpcPort,
grpcPortFileName: _scenario);
localCasSettings.PreferredCacheDrive = new AbsolutePath(cacheRootPath).GetPathRoot();
localCasSettings.ServiceSettings = new LocalCasServiceSettings(60, scenarioName: _scenario, grpcPort: grpcPort, grpcPortFileName: _scenario, bufferSizeForGrpcCopies: bufferSizeForGrpcCopies, gzipBarrierSizeForGrpcCopies: gzipBarrierSizeForGrpcCopies);
var config = new DistributedCacheServiceConfiguration(localCasSettings, dcs, loggingSettings);
return(new DistributedCacheServiceArguments(_logger, copier, copyRequester, distributedCacheServiceHost, host, ct, dataRootPath, config, null)
{
TelemetryFieldsProvider = telemetryFieldsProvider,
});
}
public DistributedContentCopier(
DistributedContentStoreSettings settings,
IAbsFileSystem fileSystem,
IRemoteFileCopier fileCopier,
IContentCommunicationManager copyRequester,
IClock clock,
ILogger logger)
{
Contract.Requires(settings != null);
Contract.Requires(settings.ParallelHashingFileSizeBoundary >= -1);
_settings = settings;
_remoteFileCopier = fileCopier;
_copyRequester = copyRequester;
FileSystem = fileSystem;
_clock = clock;
var context = new Context(logger);
_copyScheduler = settings.CopyScheduler.Create(context);
if (_copyRequester is StartupShutdownSlimBase slimBase)
{
slimBase.StartupAsync(context).Result.ThrowIfFailure();
}
_retryIntervals = settings.RetryIntervalForCopies;
_maxRetryCount = settings.MaxRetryCount;
}
public DistributedContentCopier(
DistributedContentStoreSettings settings,
IAbsFileSystem fileSystem,
IRemoteFileCopier <T> fileCopier,
IFileExistenceChecker <T> fileExistenceChecker,
IContentCommunicationManager copyRequester,
IPathTransformer <T> pathTransformer,
IClock clock)
{
Contract.Requires(settings != null);
Contract.Requires(settings.ParallelHashingFileSizeBoundary >= -1);
_settings = settings;
_remoteFileCopier = fileCopier;
_remoteFileExistenceChecker = fileExistenceChecker;
_copyRequester = copyRequester;
_pathTransformer = pathTransformer;
FileSystem = fileSystem;
_clock = clock;
_ioGate = new SemaphoreSlim(_settings.MaxConcurrentCopyOperations);
_proactiveCopyIoGate = new SemaphoreSlim(_settings.MaxConcurrentProactiveCopyOperations);
_retryIntervals = settings.RetryIntervalForCopies;
_maxRetryCount = settings.MaxRetryCount;
_timeoutForProactiveCopies = settings.TimeoutForProactiveCopies;
}
protected abstract TestServerProvider CreateStore(
Context context,
IRemoteFileCopier fileCopier,
DisposableDirectory testDirectory,
int index,
int iteration,
uint grpcPort);
public TestDistributedContentCopier(
AbsolutePath workingDirectory,
DistributedContentStoreSettings settings,
IAbsFileSystem fileSystem,
IRemoteFileCopier fileCopier,
IContentCommunicationManager copyRequester)
: base(settings, fileSystem, fileCopier, copyRequester, TestSystemClock.Instance, TestGlobal.Logger)
{
Settings = settings;
WorkingFolder = workingDirectory;
}
protected override async Task <CopyFileResult> CopyFileAsync(
OperationContext context,
IRemoteFileCopier copier,
ContentLocation sourcePath,
AbsolutePath destinationPath,
long expectedContentSize,
bool overwrite,
CopyOptions options,
CancellationToken cancellationToken)
{
// TODO: why the destination str
using var destinationStream = FileSystem.OpenForWrite(destinationPath, sourcePath.Size, FileMode.Create, FileShare.None, FileOptions.None, 1024);
return(await copier.CopyToAsync(context, sourcePath, destinationStream, options));
}
public TestDistributedContentCopier(
AbsolutePath workingDirectory,
DistributedContentStoreSettings settings,
IAbsFileSystem fileSystem,
IRemoteFileCopier <AbsolutePath> fileCopier,
IFileExistenceChecker <AbsolutePath> fileExistenceChecker,
IContentCommunicationManager copyRequester,
IPathTransformer <AbsolutePath> pathTransformer)
: base(settings, fileSystem, fileCopier, fileExistenceChecker, copyRequester, pathTransformer, TestSystemClock.Instance)
{
Settings = settings;
WorkingFolder = workingDirectory;
PathTransformer = pathTransformer as NoOpPathTransformer;
}
public DistributedContentCopier(
DistributedContentStoreSettings settings,
IAbsFileSystem fileSystem,
IRemoteFileCopier fileCopier,
IContentCommunicationManager copyRequester,
IClock clock,
ILogger logger)
{
Contract.Requires(settings.ParallelHashingFileSizeBoundary >= -1);
_settings = settings;
_remoteFileCopier = fileCopier;
CommunicationManager = copyRequester;
FileSystem = fileSystem;
_clock = clock;
Context = new Context(logger);
_copyScheduler = settings.CopyScheduler.Create(Context);
_retryIntervals = settings.RetryIntervalForCopies;
_maxRetryCount = settings.MaxRetryCount;
}
public TestContext(
DistributedContentTests <TStore, TSession> testInstance,
Context context,
IRemoteFileCopier fileCopier,
IList <DisposableDirectory> directories,
IReadOnlyList <TestServerProvider> serverProviders,
int iteration,
int[] ports,
bool traceStoreStatistics = false)
{
_testInstance = testInstance;
_traceStoreStatistics = traceStoreStatistics;
Context = context;
StoreContexts = serverProviders.Select((s, index) => new OperationContext(CreateContext(index, iteration))).ToArray();
TestFileCopier = fileCopier as TestFileCopier;
FileCopier = fileCopier;
Directories = directories;
ServerProviders = serverProviders;
Stores = serverProviders.SelectList(s => s.Store);
Servers = serverProviders.Select(s => s.Server).ToList();
Iteration = iteration;
Ports = ports;
}
public DistributedContentCopier(
DistributedContentStoreSettings settings,
IAbsFileSystem fileSystem,
IRemoteFileCopier fileCopier,
IContentCommunicationManager copyRequester,
IClock clock,
ILogger logger)
{
Contract.Requires(settings != null);
Contract.Requires(settings.ParallelHashingFileSizeBoundary >= -1);
_settings = settings;
_remoteFileCopier = fileCopier;
_copyRequester = copyRequester;
FileSystem = fileSystem;
_clock = clock;
_ioGate = new OrderedSemaphore(_settings.MaxConcurrentCopyOperations, _settings.OrderForCopies, new Context(logger));
_proactiveCopyIoGate = new OrderedSemaphore(_settings.MaxConcurrentProactiveCopyOperations, _settings.OrderForProactiveCopies, new Context(logger));
_retryIntervals = settings.RetryIntervalForCopies;
_maxRetryCount = settings.MaxRetryCount;
_ioGateTimeoutForProactiveCopies = settings.ProactiveCopyIOGateTimeout;
}
public TestContext(
Context context,
IRemoteFileCopier fileCopier,
IList <DisposableDirectory> directories,
IList <(IContentStore store, IStartupShutdown server)> stores,
public static Task <CopyFileResult> CopyToAsync <T>(this IRemoteFileCopier <T> remoteFileCopier, OperationContext context, T sourcePath, Stream destinationStream, long expectedContentSize)
where T : PathBase
{
return(remoteFileCopier.CopyToAsync(context, sourcePath, destinationStream, expectedContentSize, options: default));
}
