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); } }