internal static BuildXL.Cache.MemoizationStore.Interfaces.Caches.ICache CreateBuildCacheCache <T>(T cacheConfig, ILogger logger, string pat = null) where T : BuildCacheCacheConfig
{
// TODO: Remove check when all clients are updated with unified Dedup flag
if ((ContentHashingUtilities.HashInfo.HashType.IsValidDedup()) ^ cacheConfig.UseDedupStore)
{
var store = cacheConfig.UseDedupStore ? "DedupStore" : "BlobStore";
throw new ArgumentException($"HashType {ContentHashingUtilities.HashInfo.HashType} cannot be used with {store}");
}
var credentialProviderHelper = new CredentialProviderHelper(m => logger.Debug(m));
if (credentialProviderHelper.IsCredentialProviderSpecified())
{
logger.Debug($"Credential providers path specified: '{credentialProviderHelper.CredentialHelperPath}'");
}
else
{
logger.Debug("Using current user's credentials for obtaining AAD token");
}
var credentialsFactory = new VssCredentialsFactory(pat, credentialProviderHelper, m => logger.Debug(m));
logger.Diagnostic("Creating BuildCacheCache factory");
var fileSystem = new PassThroughFileSystem(logger);
// TODO: Once write-behind is implemented send a contentstorefunc down to the create.
Func <IContentStore> writeThroughStore = null;
if (!string.IsNullOrWhiteSpace(cacheConfig.CacheName))
{
ServiceClientRpcConfiguration rpcConfiguration;
if (cacheConfig.GrpcPort != 0)
{
rpcConfiguration = new ServiceClientRpcConfiguration((int)cacheConfig.GrpcPort);
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
var port = portReader.ReadPort();
rpcConfiguration = new ServiceClientRpcConfiguration(port);
}
writeThroughStore = () =>
new ServiceClientContentStore(
logger,
fileSystem,
cacheConfig.CacheName,
rpcConfiguration,
cacheConfig.ConnectionRetryIntervalSeconds,
cacheConfig.ConnectionRetryCount,
scenario: cacheConfig.ScenarioName);
}
BuildCacheServiceConfiguration buildCacheServiceConfiguration = cacheConfig.AsBuildCacheServiceConfigurationFile();
return(BuildCacheCacheFactory.Create(fileSystem, logger, credentialsFactory, buildCacheServiceConfiguration, writeThroughStore));
}
public static int GetGrpcPortFromFile(ILogger logger, string grpcPortFileName)
{
Contract.Assert(!string.IsNullOrWhiteSpace(grpcPortFileName));
var portReaderFactory = new MemoryMappedFileGrpcPortSharingFactory(logger, grpcPortFileName);
var portReader = portReaderFactory.GetPortReader();
return(portReader.ReadPort());
}
// RPC config deferred until session creation because server has to be previously started.
private ServiceClientRpcConfiguration GetRpcConfig()
{
var portReaderFactory =
new MemoryMappedFileGrpcPortSharingFactory(_logger, _configuration.GrpcPortFileName);
var portReader = portReaderFactory.GetPortReader();
var grpcPort = portReader.ReadPort();
return(new ServiceClientRpcConfiguration(grpcPort, _heartbeatInterval));
}
private static MemoizationStoreAdapterCache CreateCache(Config cacheConfig, AbsolutePath logPath, ILogger logger)
{
ServiceClientRpcConfiguration rpcConfiguration;
if (cacheConfig.GrpcPort != 0)
{
rpcConfiguration = new ServiceClientRpcConfiguration((int)cacheConfig.GrpcPort);
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
var port = portReader.ReadPort();
rpcConfiguration = new ServiceClientRpcConfiguration(port);
}
var serviceClientConfiguration = new ServiceClientContentStoreConfiguration(cacheConfig.CacheName, rpcConfiguration, cacheConfig.ScenarioName)
{
RetryCount = cacheConfig.ConnectionRetryCount,
RetryIntervalSeconds = cacheConfig.ConnectionRetryIntervalSeconds,
TraceOperationStarted = cacheConfig.GrpcTraceOperationStarted,
};
MemoizationStore.Interfaces.Caches.ICache localCache;
if (cacheConfig.EnableMetadataServer)
{
localCache = LocalCache.CreateRpcCache(logger, serviceClientConfiguration);
}
else
{
var metadataRootPath = new AbsolutePath(cacheConfig.MetadataRootPath);
localCache = LocalCache.CreateRpcContentStoreInProcMemoizationStoreCache(logger,
metadataRootPath,
serviceClientConfiguration,
CreateInProcMemoizationStoreConfiguration(cacheConfig, metadataRootPath));
}
var statsFilePath = new AbsolutePath(logPath.Path + ".stats");
if (!string.IsNullOrEmpty(cacheConfig.VfsCasRoot))
{
logger.Debug($"Creating virtualized cache");
localCache = new VirtualizedContentCache(localCache, new ContentStore.Vfs.VfsCasConfiguration.Builder()
{
RootPath = new AbsolutePath(cacheConfig.VfsCasRoot),
UseSymlinks = cacheConfig.UseVfsSymlinks
}.Build());
}
var cache = new MemoizationStoreAdapterCache(cacheConfig.CacheId, localCache, logger, statsFilePath, cacheConfig.ReplaceExistingOnPlaceFile);
return(cache);
}
/// <nodoc />
protected LocalContentServerBase(
ILogger logger,
IAbsFileSystem fileSystem,
string scenario,
Func <AbsolutePath, TStore> contentStoreFactory,
LocalServerConfiguration localContentServerConfiguration,
IGrpcServiceEndpoint[]?additionalEndpoints)
{
Contract.Requires(logger != null);
Contract.Requires(fileSystem != null);
Contract.Requires(localContentServerConfiguration != null);
Contract.Requires(localContentServerConfiguration.GrpcPort > 0, "GrpcPort must be provided");
logger.Debug($"{Name} process id {Process.GetCurrentProcess().Id}");
logger.Debug($"{Name} constructing {nameof(ServiceConfiguration)}: {localContentServerConfiguration}");
GrpcEnvironment.Initialize(logger, localContentServerConfiguration.GrpcEnvironmentOptions, overwriteSafeOptions: true);
FileSystem = fileSystem;
Logger = logger;
Config = localContentServerConfiguration;
_additionalEndpoints = additionalEndpoints ?? Array.Empty <IGrpcServiceEndpoint>();
_serviceReadinessChecker = new ServiceReadinessChecker(logger, scenario);
_sessionHandles = new ConcurrentDictionary <int, ISessionHandle <TSession, TSessionData> >();
var storesByName = new Dictionary <string, TStore>();
foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
{
fileSystem.CreateDirectory(kvp.Value);
var store = contentStoreFactory(kvp.Value);
storesByName.Add(kvp.Key, store);
}
StoresByName = new ReadOnlyDictionary <string, TStore>(storesByName);
foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
{
_tempFolderForStreamsByCacheName[kvp.Key] = kvp.Value / "TempFolder";
}
if (!string.IsNullOrEmpty(localContentServerConfiguration.GrpcPortFileName))
{
var portSharingFactory = new MemoryMappedFileGrpcPortSharingFactory(logger, localContentServerConfiguration.GrpcPortFileName);
var portExposer = portSharingFactory.GetPortExposer();
_portDisposer = portExposer.Expose(localContentServerConfiguration.GrpcPort);
}
}
private static ServiceClientRpcConfiguration CreateGrpcClientConfiguration(Config cacheConfig, ILogger logger)
{
ServiceClientRpcConfiguration rpcConfiguration = new ServiceClientRpcConfiguration();
if (cacheConfig.GrpcPort > 0)
{
rpcConfiguration.GrpcPort = (int)cacheConfig.GrpcPort;
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
rpcConfiguration.GrpcPort = portReader.ReadPort();
}
rpcConfiguration.GrpcCoreClientOptions = cacheConfig.GrpcCoreClientOptions;
return(rpcConfiguration);
}
private static MemoizationStoreAdapterCache CreateCache(Config cacheConfig, AbsolutePath logPath, ILogger logger)
{
ServiceClientRpcConfiguration rpcConfiguration;
if (cacheConfig.GrpcPort != 0)
{
rpcConfiguration = new ServiceClientRpcConfiguration((int)cacheConfig.GrpcPort);
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
var port = portReader.ReadPort();
rpcConfiguration = new ServiceClientRpcConfiguration(port);
}
var serviceClientConfiguration = new ServiceClientContentStoreConfiguration(cacheConfig.CacheName, rpcConfiguration, cacheConfig.ScenarioName)
{
RetryCount = cacheConfig.ConnectionRetryCount,
RetryIntervalSeconds = cacheConfig.ConnectionRetryIntervalSeconds,
};
MemoizationStore.Interfaces.Caches.ICache localCache;
if (cacheConfig.EnableMetadataServer)
{
localCache = LocalCache.CreateRpcCache(logger, serviceClientConfiguration);
}
else
{
var metadataRootPath = new AbsolutePath(cacheConfig.MetadataRootPath);
localCache = LocalCache.CreateRpcContentStoreInProcMemoizationStoreCache(logger,
metadataRootPath,
serviceClientConfiguration,
CreateInProcMemoizationStoreConfiguration(cacheConfig, metadataRootPath));
}
var statsFilePath = new AbsolutePath(logPath.Path + ".stats");
var cache = new MemoizationStoreAdapterCache(cacheConfig.CacheId, localCache, logger, statsFilePath, cacheConfig.ReplaceExistingOnPlaceFile);
return(cache);
}
/// <nodoc />
protected LocalContentServerBase(
ILogger logger,
IAbsFileSystem fileSystem,
string scenario,
Func <AbsolutePath, TStore> contentStoreFactory,
LocalServerConfiguration localContentServerConfiguration)
{
Contract.Requires(logger != null);
Contract.Requires(fileSystem != null);
Contract.Requires(localContentServerConfiguration != null);
Contract.Requires(localContentServerConfiguration.GrpcPort > 0, "GrpcPort must be provided");
logger.Debug($"{Name} process id {Process.GetCurrentProcess().Id}");
logger.Debug($"{Name} constructing {nameof(ServiceConfiguration)}: {localContentServerConfiguration}");
FileSystem = fileSystem;
Logger = logger;
Config = localContentServerConfiguration;
_serviceReadinessChecker = new ServiceReadinessChecker(Tracer, logger, scenario);
_sessionHandles = new ConcurrentDictionary <int, SessionHandle <TSession> >();
foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
{
fileSystem.CreateDirectory(kvp.Value);
var store = contentStoreFactory(kvp.Value);
StoresByName.Add(kvp.Key, store);
}
foreach (var kvp in localContentServerConfiguration.NamedCacheRoots)
{
_tempFolderForStreamsByCacheName[kvp.Key] = kvp.Value / "TempFolder";
}
if (!string.IsNullOrEmpty(localContentServerConfiguration.GrpcPortFileName))
{
var portSharingFactory = new MemoryMappedFileGrpcPortSharingFactory(logger, localContentServerConfiguration.GrpcPortFileName);
var portExposer = portSharingFactory.GetPortExposer();
_portDisposer = portExposer.Expose(localContentServerConfiguration.GrpcPort);
}
}
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();
}
}
}
}
}
internal static BuildXL.Cache.MemoizationStore.Interfaces.Caches.ICache CreateBuildCacheCache <T>(T cacheConfig, ILogger logger, string pat = null) where T : BuildCacheCacheConfig
{
// TODO: Remove check when all clients are updated with unified Dedup flag
if (ContentHashingUtilities.HashInfo.HashType == HashType.DedupNodeOrChunk ^ cacheConfig.UseDedupStore)
{
var store = cacheConfig.UseDedupStore ? "DedupStore" : "BlobStore";
throw new ArgumentException($"HashType {ContentHashingUtilities.HashInfo.HashType} cannot be used with {store}");
}
string credentialProviderPath = Environment.GetEnvironmentVariable(CredentialProvidersPathEnvVariable);
if (!string.IsNullOrWhiteSpace(credentialProviderPath))
{
logger.Debug($"Credential providers path specified: {credentialProviderPath}");
}
else
{
logger.Debug("Using current user's credentials for obtaining AAD token");
}
VssCredentialsFactory credentialsFactory;
#if !PLATFORM_OSX
string userName = null; // when running on .NET Framework, user name doesn't have to be explicitly provided
#if FEATURE_CORECLR
userName = GetAadUserNameUpn();
#endif
credentialsFactory = new VssCredentialsFactory(new VsoCredentialHelper(s => logger.Debug(s)), userName);
#else
var secPat = new SecureString();
if (!string.IsNullOrWhiteSpace(pat))
{
foreach (char c in pat)
{
secPat.AppendChar(c);
}
}
else
{
throw new ArgumentException("PAT must be supplied when running with CoreCLR");
}
credentialsFactory = new VssCredentialsFactory(new VssBasicCredential(new NetworkCredential(string.Empty, secPat)));
#endif
logger.Diagnostic("Creating BuildCacheCache factory");
var fileSystem = new PassThroughFileSystem(logger);
// TODO: Once write-behind is implemented send a contentstorefunc down to the create.
Func <IContentStore> writeThroughStore = null;
if (!string.IsNullOrWhiteSpace(cacheConfig.CacheName))
{
ServiceClientRpcConfiguration rpcConfiguration;
if (cacheConfig.GrpcPort != 0)
{
rpcConfiguration = new ServiceClientRpcConfiguration((int)cacheConfig.GrpcPort);
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
var port = portReader.ReadPort();
rpcConfiguration = new ServiceClientRpcConfiguration(port);
}
writeThroughStore = () =>
new ServiceClientContentStore(
logger,
fileSystem,
cacheConfig.CacheName,
rpcConfiguration,
cacheConfig.ConnectionRetryIntervalSeconds,
cacheConfig.ConnectionRetryCount,
scenario: cacheConfig.ScenarioName);
}
BuildCacheServiceConfiguration buildCacheServiceConfiguration = cacheConfig.AsBuildCacheServiceConfigurationFile();
return(BuildCacheCacheFactory.Create(fileSystem, logger, credentialsFactory, buildCacheServiceConfiguration, writeThroughStore));
}
/// <inheritdoc />
public async Task <Possible <ICache, Failure> > InitializeCacheAsync(ICacheConfigData cacheData, Guid activityId)
{
Contract.Requires(cacheData != null);
var possibleCacheConfig = cacheData.Create <Config>();
if (!possibleCacheConfig.Succeeded)
{
return(possibleCacheConfig.Failure);
}
Config cacheConfig = possibleCacheConfig.Result;
try
{
Contract.Assert(cacheConfig.CacheName != null);
var logPath = new AbsolutePath(cacheConfig.MetadataLogPath);
var logger = new DisposeLogger(() => new EtwFileLog(logPath.Path, cacheConfig.CacheId), cacheConfig.LogFlushIntervalSeconds);
logger.Debug($"Creating CASaaS backed LocalCache using cache name: {cacheConfig.CacheName}");
ServiceClientRpcConfiguration rpcConfiguration;
if (cacheConfig.GrpcPort != 0)
{
rpcConfiguration = new ServiceClientRpcConfiguration((int)cacheConfig.GrpcPort);
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
var port = portReader.ReadPort();
rpcConfiguration = new ServiceClientRpcConfiguration(port);
}
var rootPath = new AbsolutePath(cacheConfig.MetadataRootPath);
var memoConfig = new SQLiteMemoizationStoreConfiguration(rootPath)
{
MaxRowCount = cacheConfig.MaxStrongFingerprints,
BackupDatabase = cacheConfig.BackupLKGCache,
VerifyIntegrityOnStartup = cacheConfig.CheckCacheIntegrityOnStartup,
SingleInstanceTimeoutSeconds = (int)cacheConfig.SingleInstanceTimeoutInSeconds
};
if (!string.IsNullOrEmpty(cacheConfig.SynchronizationMode))
{
memoConfig.SyncMode = (SynchronizationMode)Enum.Parse(typeof(SynchronizationMode), cacheConfig.SynchronizationMode, ignoreCase: true);
}
var localCache = new LocalCache(
logger,
cacheConfig.CacheName,
rootPath,
rpcConfiguration,
cacheConfig.ConnectionRetryIntervalSeconds,
cacheConfig.ConnectionRetryCount,
memoConfig,
scenarioName: cacheConfig.ScenarioName);
var statsFilePath = new AbsolutePath(logPath.Path + ".stats");
var cache = new MemoizationStoreAdapterCache(cacheConfig.CacheId, localCache, logger, statsFilePath, cacheConfig.ReplaceExistingOnPlaceFile);
var startupResult = await cache.StartupAsync();
if (!startupResult.Succeeded)
{
logger.Error($"Error while initializing the cache [{cacheConfig.CacheId}]. Failure: {startupResult.Failure}");
return(startupResult.Failure);
}
logger.Debug("Successfully started CloudStoreLocalCacheService client.");
return(cache);
}
catch (Exception e)
{
return(new CacheConstructionFailure(cacheConfig.CacheId, e));
}
}
internal static BuildXL.Cache.MemoizationStore.Interfaces.Caches.ICache CreateBuildCacheCache <T>(T cacheConfig, ILogger logger, string pat = null) where T : BuildCacheCacheConfig
{
// TODO: Remove check when all clients are updated with unified Dedup flag
if ((ContentHashingUtilities.HashInfo.HashType.IsValidDedup()) ^ cacheConfig.UseDedupStore)
{
var store = cacheConfig.UseDedupStore ? "DedupStore" : "BlobStore";
throw new ArgumentException($"HashType {ContentHashingUtilities.HashInfo.HashType} cannot be used with {store}");
}
string credentialProviderPath = Environment.GetEnvironmentVariable(CredentialProvidersPathEnvVariable);
bool isCredentialProviderSpecified = !string.IsNullOrWhiteSpace(credentialProviderPath);
if (isCredentialProviderSpecified)
{
logger.Debug($"Credential providers path specified: {credentialProviderPath}");
}
else
{
logger.Debug("Using current user's credentials for obtaining AAD token");
}
VssCredentialsFactory credentialsFactory;
#if PLATFORM_WIN
// Obtain and explicitly specify AAD user name ONLY when
// (1) no credential provider is specified, and
// (2) running on .NET Core.
// When a credential provider is specified, specifying AAD user name will override it and we don't want to do that.
// When running on .NET Framework, VsoCredentialHelper will automatically obtain currently logged on AAD user name.
string userName = !isCredentialProviderSpecified && Utilities.OperatingSystemHelper.IsDotNetCore
? GetAadUserNameUpn()
: null;
credentialsFactory = new VssCredentialsFactory(new VsoCredentialHelper(s => logger.Debug(s)), userName);
#else
var secPat = new SecureString();
if (!string.IsNullOrWhiteSpace(pat))
{
foreach (char c in pat)
{
secPat.AppendChar(c);
}
}
else
{
throw new ArgumentException("PAT must be supplied when not running on Windows");
}
credentialsFactory = new VssCredentialsFactory(new VssBasicCredential(new NetworkCredential(string.Empty, secPat)));
#endif
logger.Diagnostic("Creating BuildCacheCache factory");
var fileSystem = new PassThroughFileSystem(logger);
// TODO: Once write-behind is implemented send a contentstorefunc down to the create.
Func <IContentStore> writeThroughStore = null;
if (!string.IsNullOrWhiteSpace(cacheConfig.CacheName))
{
ServiceClientRpcConfiguration rpcConfiguration;
if (cacheConfig.GrpcPort != 0)
{
rpcConfiguration = new ServiceClientRpcConfiguration((int)cacheConfig.GrpcPort);
}
else
{
var factory = new MemoryMappedFileGrpcPortSharingFactory(logger, cacheConfig.GrpcPortFileName);
var portReader = factory.GetPortReader();
var port = portReader.ReadPort();
rpcConfiguration = new ServiceClientRpcConfiguration(port);
}
writeThroughStore = () =>
new ServiceClientContentStore(
logger,
fileSystem,
cacheConfig.CacheName,
rpcConfiguration,
cacheConfig.ConnectionRetryIntervalSeconds,
cacheConfig.ConnectionRetryCount,
scenario: cacheConfig.ScenarioName);
}
BuildCacheServiceConfiguration buildCacheServiceConfiguration = cacheConfig.AsBuildCacheServiceConfigurationFile();
return(BuildCacheCacheFactory.Create(fileSystem, logger, credentialsFactory, buildCacheServiceConfiguration, writeThroughStore));
}
