public static IServiceCollection AddCachingManager(
this IServiceCollection services,
CachingType cachingOptions,
Action <CachingOptions> options = null,
int defaultMemcacheStoreSize = 1024)
{
if (options != null)
{
services.Configure(options);
}
switch (cachingOptions)
{
case CachingType.MemoryCache:
services.AddTransient <ICachingManager, MemoryCachingManager>();
services.AddTransient <IConfigurableCacheManager, MemoryCachingManager>();
services.AddSingleton <ICustomMemCache>(new FiLoggerMemCache(defaultMemcacheStoreSize));
break;
case CachingType.DistributedCache:
services.AddTransient <ICachingManager, DistributedCacheManager>();
services.AddTransient <IConfigurableCacheManager, DistributedCacheManager>();
break;
case CachingType.DoubleCache:
services.AddSingleton <ICustomMemCache>(new FiLoggerMemCache(defaultMemcacheStoreSize));
services.AddTransient <ICachingManager, DoubleCacheManager>();
services.AddTransient <IConfigurableCacheManager, DistributedCacheManager>();
break;
}
return(services);
}
public async Task NuGetExe_Caching_DoesNotNoOp(Type type, CachingType caching, ServerType server, bool success, bool noOp)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(UsesGlobalPackageFolderCopyOnEveryRunTest),
type,
nuGetExe,
caching,
server);
// Assert
var firstPass = true;
foreach (var validation in validations)
{
validation.Assert(CachingValidationType.CommandSucceeded, true);
validation.Assert(CachingValidationType.PackageInstalled, true);
validation.Assert(CachingValidationType.PackageFromGlobalPackagesFolderUsed, success);
validation.Assert(CachingValidationType.PackageFromSourceNotUsed, success);
if (firstPass)
{
firstPass = false;
validation.Assert(CachingValidationType.RestoreNoOp, false);
}
else
{
validation.Assert(CachingValidationType.RestoreNoOp, noOp);
}
}
}
/// /////////////////////////////////////////////////////////
/// Constructor
/// /////////////////////////////////////////////////////////
// Constructor
public RFRuntimeCaching()
{
type = CachingType.Disable;
frames = 3;
fragments = 4;
skipFirstDemolition = false;
inProgress = false;
wasUsed = false;
stop = false;
}
/// <summary>
/// Creates a new Configuration
/// </summary>
/// <param name="builder">The builder that contains all the configurations</param>
internal DatabaseConfig(DatabaseConfigBuilder builder)
{
DatabaseConnectionString = builder.ConnectionString;
ReceiverQueueName = builder.ReceiverQueueName;
SenderQueueName = builder.SenderQueueName;
ReceiverServiceName = builder.ReceiverServiceName;
SenderServiceName = builder.SenderServiceName;
MessageTypeName = builder.MessageTypeName;
ContractName = builder.ContractName;
TriggerNameTemplate = builder.TriggerNameTemplate;
QueryViewNameTemplate = builder.QueryViewNameTemplate;
ViewCacheTableNameTemplate = builder.ViewCacheTableNameTemplate;
CachingType = builder.CachingType;
}
internal static string ToSerializedValue(this CachingType value)
{
switch (value)
{
case CachingType.None:
return("none");
case CachingType.Readonly:
return("readonly");
case CachingType.Readwrite:
return("readwrite");
}
return(null);
}
public bool TrySetValue <T>(string key, T value, CachingType cachingType = CachingType.GlobalMemoryCaching, HttpContext instance = null)
{
switch (cachingType)
{
case CachingType.GlobalMemoryCaching:
return(TrySetValueGlobalMemory <T>(key, value));
case CachingType.SessionCaching:
return(TrySetValueSession <T>(key, value, instance));
case CachingType.SqlCaching:
return(TrySetValueSql <T>(key, value));
default:
return(false);
}
}
[InlineData(typeof(RestoreProjectJsonCommand), CachingType.NoCache | CachingType.DirectDownload, ServerType.V3, true, true)] // Should fail?
public async Task NuGetExe_Caching_AllowsMissingPackageOnSource(Type type, CachingType caching, ServerType server, bool success, bool installed)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(AllowsMissingPackageOnSourceTest),
type,
nuGetExe,
caching,
server);
// Assert
validations.Assert(CachingValidationType.CommandSucceeded, success);
validations.Assert(CachingValidationType.PackageInstalled, installed);
}
public async Task NuGetExe_Caching_InstallsToDestinationFolder(Type type, CachingType caching, ServerType server)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(InstallsToDestinationFolderTest),
type,
nuGetExe,
caching,
server);
// Assert
validations.Assert(CachingValidationType.CommandSucceeded, true);
validations.Assert(CachingValidationType.PackageInstalled, true);
}
public async Task NuGetExe_Caching_WritesToHttpCache(Type type, CachingType caching, ServerType server, bool success)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(WritesToHttpCacheTest),
type,
nuGetExe,
caching,
server);
// Assert
validations.Assert(CachingValidationType.CommandSucceeded, true);
validations.Assert(CachingValidationType.PackageInHttpCache, success);
}
public async Task NuGetExe_Caching_CleansUpDirectDownload(Type type, CachingType caching, ServerType server, bool success)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(CleansUpDirectDownloadTest),
type,
nuGetExe,
caching,
server);
// Assert
validations.Assert(CachingValidationType.CommandSucceeded, true);
validations.Assert(CachingValidationType.DirectDownloadFilesDoNotExist, success);
}
public async Task NuGetExe_Caching_PopulatesGlobalPackagesFolder(Type type, CachingType caching, ServerType server, bool success)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(PopulatesGlobalPackagesFolderTest),
type,
nuGetExe,
caching,
server);
// Assert
validations.Assert(CachingValidationType.CommandSucceeded, true);
validations.Assert(CachingValidationType.PackageInGlobalPackagesFolder, success);
}
public bool TryRemoveCaching <T>(string key, CachingType cachingType = CachingType.GlobalMemoryCaching, HttpContext instance = null)
{
switch (cachingType)
{
case CachingType.GlobalMemoryCaching:
return(TryRemoveCachingGlobalMemory <T>(key));
case CachingType.SessionCaching:
return(TryRemoveCachingSession <T>(key, instance));
case CachingType.SqlCaching:
return(TryRemoveCachingSql <T>(key));
default:
return(false);
}
}
public async Task NuGetExe_Caching_UsesHttpCacheCopy(Type type, CachingType caching, ServerType server, bool success)
{
// Arrange
var nuGetExe = await GetNuGetExeAsync();
// Act
var validations = await CachingTestRunner.ExecuteAsync(
typeof(UsesHttpCacheCopyTest),
type,
nuGetExe,
caching,
server);
// Assert
validations.Assert(CachingValidationType.CommandSucceeded, true);
validations.Assert(CachingValidationType.PackageInstalled, true);
validations.Assert(CachingValidationType.PackageFromHttpCacheUsed, success);
validations.Assert(CachingValidationType.PackageFromSourceNotUsed, success);
}
/// <exclude />
public CachingAttribute(CachingType cachingType)
{
this.CachingType = cachingType;
}
public static void DoWithDb(CachingType cachingType)
{
Console.WriteLine(cachingType);
var stopwatch = Stopwatch.StartNew();
using (
var context = new RealtimeDbDataContextBuilder <SomeDbDataContext>(() => new SomeDbDataContext())
{
CachingType = cachingType
}.Build()
)
{
Console.WriteLine("Context Created {0}ms", stopwatch.Elapsed.TotalMilliseconds);
context.DatabaseConfig.DatabaseConnectionString.WithConnection(con => con.ExecuteNonQuery(@"
UPDATE MyTable
SET [some] = NULL
WHERE [some] = 'Merge'"));
context.DatabaseConfig.DatabaseConnectionString.WithConnection(con => con.ExecuteNonQuery(@"
UPDATE MyTable2
SET [some] = NULL
WHERE [some] = 'Merge'"));
context.DatabaseConfig.DatabaseConnectionString.WithConnection(con => con.ExecuteNonQuery(@"
UPDATE TOP (1) MyTable2
SET [some] = 'Merge'
WHERE [some] IS NULL"));
context.DatabaseConfig.DatabaseConnectionString.WithConnection(con => con.ExecuteNonQuery(@"
UPDATE TOP (2000) MyTable
SET [some] = 'Merge'
WHERE [some] IS NULL"));
Thread.Sleep(100);
stopwatch.Restart();
var queries =
Enumerable.Range(0, 1000).AsParallel().Select(i => context.Query
(
c =>
from m in c.MyTable
join m2 in c.MyTable2 on m.some equals m2.some
where m.some != null && m2.some != "asd"
where m.some == "Merge"
select new
{
m.MyTable_id,
m.some,
m2.MyTable2_id,
Some2 = m2.some
},
r => new
{
r.MyTable_id,
r.MyTable2_id
}
)).ToArray();
Console.WriteLine("Queries created {0}ms", stopwatch.Elapsed.TotalMilliseconds);
stopwatch.Restart();
Task.WaitAll(queries);
var results = queries.Select(q => q.Result).ToList();
Console.WriteLine("Queries loaded {0}ms", stopwatch.Elapsed.TotalMilliseconds);
stopwatch.Restart();
var reference = results.First();
var count = reference.Count();
if (results.All(q => q.Count() == count) == false)
{
Console.WriteLine("Queries have different count");
}
context.DatabaseConfig.DatabaseConnectionString.WithConnection(con => con.ExecuteNonQuery(@"
UPDATE TOP (1000) MyTable
SET [some] = 'Merge'
WHERE [some] IS NULL"));
count += 1000;
while (true)
{
Thread.Sleep(100);
if (results.All(q => q.Count() == count))
{
break;
}
}
Console.WriteLine("Wait for Sync after change {0}ms", stopwatch.Elapsed.TotalMilliseconds);
stopwatch.Restart();
queries.AsParallel().ForAll(q => q.Dispose());
Console.WriteLine("Dispose Queries {0}ms", stopwatch.Elapsed.TotalMilliseconds);
stopwatch.Restart();
}
Console.WriteLine("Dispose {0}ms", stopwatch.Elapsed.TotalMilliseconds);
}
/// <exclude />
public CachingAttribute(CachingType cachingType)
{
this.CachingType = cachingType;
}
///GENMHASH:724C7623D19A41D0DA37EDEDF5B45340:E0613BA7E2936CBE7482C98B6400EA39
public IWithVMSize WithDataDisks(int diskSizeInGB, int diskCount, StorageAccountType storageAccountType, CachingType cachingType)
{
DataDisks dataDisks = EnsureDataDisks();
dataDisks.DiskSizeInGB = diskSizeInGB;
dataDisks.DiskCount = diskCount;
dataDisks.StorageAccountType = storageAccountType;
dataDisks.CachingType = cachingType;
return(this);
}
public static async Task <IEnumerable <CachingValidations> > ExecuteAsync(ICachingTest test, ICachingCommand command, INuGetExe nuGetExe, CachingType caching, ServerType server)
{
using (var testFolder = TestDirectory.Create())
using (var mockServer = new MockServer())
{
var tc = new CachingTestContext(testFolder, mockServer, nuGetExe);
// Enable this flag to launch the debugger when the nuget.exe process starts. This also increases
// logging verbosity and command timeout.
//
// tc.Debug = true;
tc.NoCache = caching.HasFlag(CachingType.NoCache);
tc.DirectDownload = caching.HasFlag(CachingType.DirectDownload);
tc.CurrentSource = server == ServerType.V2 ? tc.V2Source : tc.V3Source;
tc.ClearHttpCache();
var validations = new List <CachingValidations>();
for (var i = 0; i < test.IterationCount; i++)
{
var args = await test.PrepareTestAsync(tc, command);
var result = tc.Execute(args);
validations.Add(test.Validate(tc, command, result));
}
return(validations);
}
}
/// <summary>
/// Specifies settings for the data disks which would be created for the file server.
/// </summary>
/// <param name="diskSizeInGB">Initial disk size in GB for blank data disks.</param>
/// <param name="diskCount">Number of data disks to be attached to the VM. RAID level 0 will be applied in the case of multiple disks.</param>
/// <param name="storageAccountType">Type of storage account to be used on the disk.</param>
/// <param name="cachingType">Caching type.</param>
/// <return>The next stage of the definition.</return>
BatchAIFileServer.Definition.IWithVMSize BatchAIFileServer.Definition.IWithDataDisks.WithDataDisks(int diskSizeInGB, int diskCount, StorageAccountType storageAccountType, CachingType cachingType)
{
return(this.WithDataDisks(diskSizeInGB, diskCount, storageAccountType, cachingType) as BatchAIFileServer.Definition.IWithVMSize);
}
public static string ToSerialString(this CachingType value) => value switch
{
public SqlCachedQuery(Database db, string query, CachingType cachingType, string primaryKeyColumn, params string[] additionalPrimaryKeyColumns)
: base(db, query, r => r, r => r.Key, s => s.RowKeyEqualityComparer, cachingType, primaryKeyColumn, additionalPrimaryKeyColumns)
{
}
public CachingAttribute(CachingType cacheType, int validity = 0)
{
Cache = cacheType;
Validity = validity;
}
public static async Task <IEnumerable <CachingValidations> > ExecuteAsync(Type testType, Type commandType, INuGetExe nuGetExe, CachingType caching, ServerType server)
{
var test = (ICachingTest)Activator.CreateInstance(testType);
var command = (ICachingCommand)Activator.CreateInstance(commandType);
return(await ExecuteAsync(
test,
command,
nuGetExe,
caching,
server));
}
/// <summary>
/// Create a new instance of <see cref="SqlCachedQuery"/>
/// </summary>
/// <param name="db">Database this query belongs to</param>
/// <param name="query">UserQuery that is encapsulated by this query</param>
/// <param name="keyExtractor">Function to extract <typeparamref name="TKey"/> from <typeparamref name="TRow"/></param>
/// <param name="keyComparerFactory">Comparer to compare <typeparamref name="TKey"/></param>
/// <param name="cachingType">Type of cache used to detect changes</param>
/// <param name="primaryKeyColumn">The column used as primary key</param>
/// <param name="additionalPrimaryKeyColumns">Additional column names for the primary key</param>
/// <param name="rowFactory">Function to transform <see cref="Row"/> into <typeparamref name="TRow"/></param>
internal MappedSqlCachedQuery(Database db, string query, Func <Row, TRow> rowFactory, Func <TRow, TKey> keyExtractor, Func <RowSchema, IEqualityComparer <TKey> > keyComparerFactory, CachingType cachingType, string primaryKeyColumn, params string[] additionalPrimaryKeyColumns) : base(Guid.NewGuid())
{
_rowFactory = rowFactory;
_keyExtractor = keyExtractor;
switch (cachingType)
{
case CachingType.InMemory:
_view = new InMemoryCache(db, query, new[] { primaryKeyColumn }.Union(additionalPrimaryKeyColumns).ToArray());
break;
case CachingType.SqlTable:
_view = new SqlTableCache(db, query, new[] { primaryKeyColumn }.Union(additionalPrimaryKeyColumns).ToArray());
break;
case CachingType.SqlInMemoryTable:
_view = new SqlMemoryTableCache(db, query, new[] { primaryKeyColumn }.Union(additionalPrimaryKeyColumns).ToArray());
break;
default:
throw new ArgumentOutOfRangeException(nameof(cachingType), cachingType, null);
}
lock (_dataAccessLock)
{
_view.Invalidated += ViewOnInvalidated;
_disposeHelper.Attach(() => _view.Invalidated -= ViewOnInvalidated);
var data = _view.Initialize();
_rows = new ReducableDictionary <TKey, TRow>(data.Count, keyComparerFactory(_view.Schema));
foreach (var row in data)
{
var entry = rowFactory(row);
var key = keyExtractor(entry);
_rows.Add(key, entry);
}
_disposeHelper.Attach(_view);
}
}
