private static BuildXL.Cache.MemoizationStore.Interfaces.Caches.ICache CreateDistributedCache(ILogger logger, Config cacheConfig)
{
int cacheKeyBumpTimeMins = cacheConfig.CacheKeyBumpTimeMins;
if (cacheKeyBumpTimeMins <= 0)
{
logger.Debug("Config specified bump time in minutes is invalid {0}. Using default bump time {1}", cacheKeyBumpTimeMins, Config.DefaultCacheKeyBumpTimeMins);
cacheKeyBumpTimeMins = Config.DefaultCacheKeyBumpTimeMins;
}
TimeSpan keyBump = TimeSpan.FromMinutes(cacheKeyBumpTimeMins);
var metadataTracer = new DistributedCacheSessionTracer(logger, nameof(DistributedCache));
string metadataKeyspace = cacheConfig.CacheNamespace;
if (string.IsNullOrWhiteSpace(metadataKeyspace))
{
metadataKeyspace = DefaultMetadataKeyspace;
}
IMetadataCache metadataCache = RedisMetadataCacheFactory.Create(metadataTracer, keySpace: metadataKeyspace, cacheKeyBumpTime: keyBump);
var innerCache = cacheConfig.DisableContent
? new OneLevelCache(
contentStoreFunc: () => new ReadOnlyEmptyContentStore(),
memoizationStoreFunc: () => (BuildCacheCache)BuildCacheUtils.CreateBuildCacheCache(cacheConfig, logger, Environment.GetEnvironmentVariable("VSTSPERSONALACCESSTOKEN")),
id: Guid.NewGuid(),
passContentToMemoization: false)
: BuildCacheUtils.CreateBuildCacheCache(cacheConfig, logger, Environment.GetEnvironmentVariable("VSTSPERSONALACCESSTOKEN"));
ReadThroughMode readThroughMode = cacheConfig.SealUnbackedContentHashLists ? ReadThroughMode.ReadThrough : ReadThroughMode.None;
return(new DistributedCache(logger, innerCache, metadataCache, metadataTracer, readThroughMode));
}
public void NoProviderThrows()
{
Action a = () => RedisMetadataCacheFactory.Create(_tracer).Dispose();
a.Should().Throw <InvalidOperationException>().Where(e =>
e.Message.Contains(ExecutableConnectionStringProvider.CredentialProviderVariableName) &&
e.Message.Contains(EnvironmentConnectionStringProvider.RedisConnectionStringEnvironmentVariable));
}
public Task CreateWithCacheKeyBumpTime()
{
return(TestWithEnvironmentConnectionStringAsync(
() => RedisMetadataCacheFactory.Create(tracer: _tracer, cacheKeyBumpTime: CacheKeyBumpTime),
cache =>
{
cache.CacheKeyBumpTime.Should().Be(CacheKeyBumpTime);
}));
}
public Task CreateWithKeySpace()
{
return(TestWithEnvironmentConnectionStringAsync(
() => RedisMetadataCacheFactory.Create(_tracer, KeySpace),
cache =>
{
cache.Keyspace.Should().Be(KeySpace + RedisMetadataCacheFactory.Salt);
}));
}
public Task CreateDefault()
{
return(TestWithEnvironmentConnectionStringAsync(
() => RedisMetadataCacheFactory.Create(_tracer),
cache =>
{
cache.Keyspace.Should().Be(RedisMetadataCacheFactory.DefaultKeySpace + RedisMetadataCacheFactory.Salt);
cache.CacheKeyBumpTime.Should().Be(RedisMetadataCache.DefaultCacheKeyBumpTime);
}));
}
public Task CreateWithCacheKeyBumpTimeAndProvider()
{
var connectionString = $"ConnectionString{ThreadSafeRandom.Generator.Next()}";
return(TestCacheAsync(
() => RedisMetadataCacheFactory.Create(CreateMockProvider(connectionString), _tracer, cacheKeyBumpTime: CacheKeyBumpTime),
cache =>
{
cache.CacheKeyBumpTime.Should().Be(CacheKeyBumpTime);
return Task.FromResult(0);
}));
}
public Task CreateDefaultWithProvider()
{
var connectionString = $"ConnectionString{ThreadSafeRandom.Generator.Next()}";
return(TestCacheAsync(
() => RedisMetadataCacheFactory.Create(CreateMockProvider(connectionString), _tracer),
async cache =>
{
var connectionStringResult = await cache.ConnectionStringProvider.GetConnectionString().ConfigureAwait(false);
connectionStringResult.ConnectionString.Should().Be(connectionString);
cache.Keyspace.Should().Be(RedisMetadataCacheFactory.DefaultKeySpace + RedisMetadataCacheFactory.Salt);
cache.CacheKeyBumpTime.Should().Be(RedisMetadataCache.DefaultCacheKeyBumpTime);
}));
}
public async Task NonexistentExecutableConnectionStringProviderError()
{
using (var testDirectory = new DisposableDirectory(FileSystem))
{
var nonexistentPath = testDirectory.CreateRandomFileName();
using (new TestEnvironmentVariable(ExecutableConnectionStringProvider.CredentialProviderVariableName, nonexistentPath.Path)
)
{
await TestCacheAsync(
() => RedisMetadataCacheFactory.Create(_tracer),
async cache =>
{
var connectionStringResult = await cache.ConnectionStringProvider.GetConnectionString().ConfigureAwait(false);
connectionStringResult.Succeeded.Should().BeFalse();
connectionStringResult.ErrorMessage.Should().Contain("The system cannot find the file specified");
}).ConfigureAwait(false);
}
}
}
public async Task EnvironmentProviderOverridesExecutableProvider()
{
var connectionString = $"ConnectionString{ThreadSafeRandom.Generator.Next()}";
using (var testDirectory = new DisposableDirectory(FileSystem))
{
var nonexistentPath = testDirectory.CreateRandomFileName();
using (new TestEnvironmentVariable(ExecutableConnectionStringProvider.CredentialProviderVariableName, nonexistentPath.Path)
)
using (new TestEnvironmentVariable(EnvironmentConnectionStringProvider.RedisConnectionStringEnvironmentVariable, connectionString))
{
await TestCacheAsync(
() => RedisMetadataCacheFactory.Create(_tracer),
async cache =>
{
var connectionStringResult =
await cache.ConnectionStringProvider.GetConnectionString().ConfigureAwait(false);
connectionStringResult.ConnectionString.Should().Be(connectionString);
}).ConfigureAwait(false);
}
}
}
