private static ServiceClientContentStoreConfiguration CreateConfiguration(
string cacheName,
string scenario,
ServiceConfiguration serviceConfiguration,
uint retryIntervalSeconds = DefaultRetryIntervalSeconds,
uint retryCount = DefaultRetryCount)
{
return(new ServiceClientContentStoreConfiguration(
cacheName,
ServiceClientRpcConfiguration.CreateGrpc((int)serviceConfiguration.GrpcPort),
scenario)
{
RetryCount = retryCount,
RetryIntervalSeconds = retryIntervalSeconds,
});
}
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 !FEATURE_CORECLR
credentialsFactory = new VssCredentialsFactory(new VsoCredentialHelper(s => logger.Debug(s)));
#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 = ServiceClientRpcConfiguration.CreateGrpc((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 />
protected override ICache CreateCache(DisposableDirectory testDirectory)
{
var backendCacheDirectory = testDirectory.Path / "Backend";
FileSystem.CreateDirectory(backendCacheDirectory);
var namedCacheRoots = new Dictionary <string, AbsolutePath> {
[CacheName] = backendCacheDirectory / "Root"
};
var grpcPort = PortExtensions.GetNextAvailablePort();
var serverConfiguration = new LocalServerConfiguration(backendCacheDirectory, namedCacheRoots, grpcPort)
{
GrpcPortFileName = null, // Port is well known at configuration time, no need to expose it.
};
var serviceClientConfiguration = new ServiceClientContentStoreConfiguration(CacheName, ServiceClientRpcConfiguration.CreateGrpc(serverConfiguration.GrpcPort), "Scenario-" + Guid.NewGuid());
Func <AbsolutePath, ICache> contentStoreFactory = CreateBackendCache;
var serviceClient = new TestInProcessServiceClientCache(Logger, FileSystem, contentStoreFactory, serverConfiguration, serviceClientConfiguration);
return(serviceClient);
}
/// <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 = ServiceClientRpcConfiguration.CreateGrpc((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);
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));
}
}
