public void GetKeyExtractor_ConventionEnabled()
{
_config = new CacheConfiguration(new MemoryCache("CacheConfigurationTests"));
var keyExtractor = _config.GetKeyExtractor(typeof(Person));
Assert.IsNotNull(keyExtractor);
Assert.AreEqual("1", keyExtractor(new Person { Id = 1 }));
}
public Level1Fixture()
{
CacheConfiguration config = new CacheConfiguration()
.WithFirstLevel(FirstLevelCacheType.ConcurrentDictionary);
this.Cache = config.CreateCache();
this.Elector = new ConfiguredElection(true);
}
public void ItemExpires_RemovedFromCache()
{
var redis = new RedisConnectionManager();
// this is just testing the built in expiry
var config = new CacheConfiguration(redis);
var cache = new RedisCacheProvider(config);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:ItemExpires_RemovedFromCache";
String value = "Hello World!";
DateTime expires = DateTime.Now.AddSeconds(3);
string tag1 = "tag1";
string tag2 = "tag2";
cache.Set(key, value, expires, new List<string> { tag1, tag2 });
var result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
Thread.Sleep(1000);
result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
Thread.Sleep(2500);
result = cache.Get<String>(key);
Assert.IsNull(result);
}
public void GetKeyExtractor_WhenConventionTrowsException_OnVerifyFitInConvetion()
{
var convention = new Mock<Convention>();
_config = new CacheConfiguration(new MemoryCache("CacheConfigurationTests"), convention.Object);
convention.Setup(p => p.FitInConvention(It.IsAny<Type>())).Throws(new System.Exception());
_config.GetKeyExtractor(typeof(City));
}
public ConcurrentCaches()
{
CacheConfiguration config = new CacheConfiguration();
config.WithFirstLevel(FirstLevelCacheType.ConcurrentDictionary);
config.WithSecondLevel(0, new RedisServer { Hostname = "127.0.0.1", Port = 6379 });
this._cache1 = config.CreateCache();
this._cache2 = config.CreateCache();
}
public void CreatePartialKey()
{
_config = new CacheConfiguration(new MemoryCache("KeyCreatorTests"), new MalformedConvention());
_keyCreator = new KeyCreator(_config);
var person = new Person { Id = 1, Name = "Maria" };
var createdKey = _keyCreator.CreateKey(person);
}
public Level2Fixture()
{
CacheConfiguration config = new CacheConfiguration()
.WithFirstLevel(FirstLevelCacheType.ConcurrentDictionary)
.WithSecondLevel(0, new RedisServer { Hostname = "127.0.0.1", Port = 6379 });
Cache cc = config.CreateCache();
this.Cache = cc;
this.Elector = new DistributedMutexElection(cc.DistributedCache);
}
private static CacheConfiguration GenerateCacheConfiguration(ConfigurationInfo info)
{
CacheConfiguration configuration = new CacheConfiguration();
foreach (ConfigNode node in info)
{
configuration.SchedulerConfiguration.Add(node.Convert());
}
return configuration;
}
public void CreateKey()
{
_config = new CacheConfiguration(new MemoryCache("KeyCreatorTests"));
_keyCreator = new KeyCreator(_config);
var person = new Person { Id = 2, Name = "person" };
var key = CreateKey(person, person.Id.ToString());
var createdKey = _keyCreator.CreateKey(person);
Assert.AreEqual(key, createdKey);
}
public CacheConfiguration BuildConfiguration()
{
var fixedForOneHour = new CacheInstruction(CacheType.Fixed, TimeSpan.FromHours(1));
var cacheConfig = new CacheConfiguration();
cacheConfig.ApplyCachingOn(x => x.DeclaringType.Name.EndsWith("Repository"), fixedForOneHour)
.InvalidateOn(x => x.Name.StartsWith("Save"))
.InvalidateOn(x => x.Name.StartsWith("Delete"))
.InvalidateOn(x => x.Name.StartsWith("Update"));
//apply exceptions
//cacheConfig
// .ExceptFor<IPersonRepository>(x => x.GetByName(null))
// .InvalidateOn<IPersonRepository>(x => x.Save(null));
return cacheConfig;
}
/// <summary>
/// Creates near cache.
/// </summary>
private INearCache CreateNearCache(CacheConfiguration cacheConfiguration)
{
var nearCfg = cacheConfiguration.PlatformNearConfiguration;
Debug.Assert(nearCfg != null);
Func <object> affinityTopologyVersionFunc = () => _affinityTopologyVersion;
var affinity = _ignite.GetAffinity(cacheConfiguration.Name);
var keepBinary = nearCfg.KeepBinary;
TypeResolver resolver = null;
Func <string, string, Type> resolve = (typeName, fieldName) =>
{
if (typeName == null)
{
return(typeof(object));
}
if (resolver == null)
{
resolver = new TypeResolver();
}
var resolved = resolver.ResolveType(typeName);
if (resolved == null)
{
throw new InvalidOperationException(string.Format(
"Can not create .NET Near Cache: {0}.{1} is invalid. Failed to resolve type: '{2}'",
typeof(PlatformNearCacheConfiguration).Name, fieldName, typeName));
}
return(resolved);
};
var keyType = resolve(nearCfg.KeyTypeName, "KeyTypeName");
var valType = resolve(nearCfg.ValueTypeName, "ValueTypeName");
var cacheType = typeof(NearCache <,>).MakeGenericType(keyType, valType);
var nearCache = Activator.CreateInstance(
cacheType,
affinityTopologyVersionFunc,
affinity,
keepBinary);
return((INearCache)nearCache);
}
public void Arrange()
{
_giasApiClientMock = new Mock <IGiasApiClient>();
_stateRepositoryMock = new Mock <IStateRepository>();
_stateRepositoryMock.Setup(r => r.GetLastStagingDateClearedAsync(It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(DateTime.Today.AddDays(-15));
_establishmentRepositoryMock = new Mock <IEstablishmentRepository>();
_groupRepositoryMock = new Mock <IGroupRepository>();
_localAuthorityRepositoryMock = new Mock <ILocalAuthorityRepository>();
_mapperMock = new Mock <IMapper>();
_eventPublisherMock = new Mock <IEventPublisher>();
_establishmentProcessingQueueMock = new Mock <IEstablishmentProcessingQueue>();
_groupProcessingQueueMock = new Mock <IGroupProcessingQueue>();
_localAuthorityProcessingQueueMock = new Mock <ILocalAuthorityProcessingQueue>();
_configuration = new CacheConfiguration
{
NumberOfDaysToRetainStagingData = 14,
};
_loggerMock = new Mock <ILoggerWrapper>();
_manager = new CacheManager(
_giasApiClientMock.Object,
_stateRepositoryMock.Object,
_establishmentRepositoryMock.Object,
_groupRepositoryMock.Object,
_localAuthorityRepositoryMock.Object,
_mapperMock.Object,
_eventPublisherMock.Object,
_establishmentProcessingQueueMock.Object,
_groupProcessingQueueMock.Object,
_localAuthorityProcessingQueueMock.Object,
_configuration,
_loggerMock.Object);
_cancellationToken = new CancellationToken();
}
public void TestCompositeKeyAllDataTypes()
{
var cfg = new CacheConfiguration("composite_key_all", new QueryEntity(typeof(KeyAll), typeof(string)));
var cache = Ignition.GetIgnite().CreateCache <KeyAll, string>(cfg);
var key = new KeyAll
{
Byte = byte.MaxValue,
SByte = sbyte.MaxValue,
Short = short.MaxValue,
UShort = ushort.MaxValue,
Int = int.MaxValue,
UInt = uint.MaxValue,
Long = long.MaxValue,
ULong = ulong.MaxValue,
Float = float.MaxValue,
Double = double.MaxValue,
Decimal = decimal.MaxValue,
Guid = Guid.NewGuid(),
String = "привет",
Key = new Key(255, 65555)
};
// Test insert.
var res = cache.QueryFields(new SqlFieldsQuery(
"insert into string(byte, sbyte, short, ushort, int, uint, long, ulong, float, double, decimal, " +
"guid, string, key, _val) values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
key.Byte, key.SByte, key.Short, key.UShort, key.Int, key.UInt, key.Long, key.ULong, key.Float,
key.Double, key.Decimal, key.Guid, key.String, key.Key, "VALUE"))
.GetAll();
Assert.AreEqual(1, res.Count);
Assert.AreEqual(1, res[0].Count);
Assert.AreEqual(1, res[0][0]);
// Compare resulting keys.
Assert.AreEqual(key, cache.Single().Key);
// Compare keys in binary form.
var binKey = cache.Ignite.GetBinary().ToBinary <IBinaryObject>(key);
var binKeyRes = cache.WithKeepBinary <IBinaryObject, string>().Single().Key;
Assert.AreEqual(binKey, binKeyRes);
// Get by key to verify identity.
Assert.AreEqual("VALUE", cache[key]);
}
private static void StartTransactionStatsCache(string name,
bool loadCacheFromDatabase)
{
var cacheCfg = new CacheConfiguration
{
KeepBinaryInStore = false, // Depends on your case
CacheStoreFactory = new TransactionsStatsCacheStoreFactory(),
Name = name,
};
TransactionsStatsCache = _ignite.GetOrCreateCache <string, object>(cacheCfg);
if (loadCacheFromDatabase)
{
TransactionsStatsCache.Clear();
TransactionsStatsCache.LoadCache(null);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var cacheConfiguration = new CacheConfiguration();
this._config.Bind(nameof(CacheConfiguration), cacheConfiguration);
services.AddDistributedRedisCache(options =>
{
options.Configuration = cacheConfiguration.RedisConnectionString;
});
services.Configure <CacheConfiguration>(this._config.GetSection(nameof(CacheConfiguration)));
services.AddScoped <IMyComplexValueRepository, MyComplexValueRepository>();
services.AddSingleton <IHybridCacheManager <int, MyComplexValue>, HybridCacheManager <int, MyComplexValue> >();
}
public async Task should_save_version_on_cache_create()
{
var version = new Version(5, 32);
var cacheContainer = new CacheContainer();
cacheContainer.Register <ILogger, TestLogger>();
cacheContainer.Register <IVersionProvider, TestVersionProvider>().WithValue("version", version);
cacheContainer.Register <IStorage, TestStorage>().AsSingleton();
cacheContainer.Register <ISerializer, ProtoBufSerializer>().WithDependency("storage", typeof(IStorage).FullName).WithValue("userTypes", null);
var cacheConfiguration = new CacheConfiguration(1024, 5, 1024, 5);
var cache = new Cache(cacheContainer, cacheConfiguration);
await cache.Initialize();
var storage = (TestStorage)cacheContainer.Resolve <IStorage>();
storage.KeyToStrings[Cache.VersionEntryName].Should().BeEquivalentTo(version.ToString());
}
public static void AdvancedConfigKeyValTypes()
{
var ignite = Ignition.Start();
//tag::advancedConfigKeyValTypes[]
var cacheCfg = new CacheConfiguration("people")
{
PlatformCacheConfiguration = new PlatformCacheConfiguration
{
KeyTypeName = typeof(long).FullName,
ValueTypeName = typeof(Guid).FullName
}
};
var cache = ignite.CreateCache <long, Guid>(cacheCfg);
//end::advancedConfigKeyValTypes[]
}
public static async Task <CacheConfiguration> CreateTenantCacheConfigAsync(string cacheName)
{
CacheConfiguration cacheCfg = null;
try
{
var models = new[] { new QueryEntityIndexFields()
{
PrimaryKeys = indexFields, ModelType = typeof(Employee)
} };
List <QueryEntity> queryList = new List <QueryEntity>();
foreach (var modelObject in models)
{
var query = new QueryEntity(typeof(string), modelObject.ModelType)
{
Indexes = new List <QueryIndex>(queryIndex)
{
new QueryIndex(modelObject.PrimaryKeys)
}
};
queryList.Add(query);
}
cacheCfg = new CacheConfiguration
{
Name = cacheName,
KeepBinaryInStore = false, // Cache store works with deserialized data.
//ReadThrough = true,
//WriteThrough = true,
//WriteBehindEnabled = true,
QueryEntities = queryList,
EvictionPolicy = new LruEvictionPolicy
{
MaxSize = 1000000
}
};
}
catch (Exception ex)
{
throw ex;
}
return(cacheCfg);
}
private static async Task MainAsync()
{
var cfg = new IgniteConfiguration
{
DiscoverySpi = new TcpDiscoverySpi
{
IpFinder = new TcpDiscoveryStaticIpFinder
{
Endpoints = new[] { "127.0.0.1:47500" }
},
SocketTimeout = TimeSpan.FromSeconds(0.3)
}
};
using (var ignite = Ignition.Start(cfg))
{
var cacheCfg = new CacheConfiguration(
"cache1",
new QueryEntity(typeof(int), typeof(Person)));
var cache = ignite.CreateCache <int, Person>(cacheCfg);
cache.Put(1, new Person(1));
Debug.Assert(1 == cache[1].Age);
var resPerson = cache.AsCacheQueryable()
.Where(e => e.Key > 0 && e.Value.Name.StartsWith("Person"))
.Select(e => e.Value)
.Single();
Debug.Assert(1 == resPerson.Age);
using (var igniteThin = Ignition.StartClient(new IgniteClientConfiguration("127.0.0.1")))
{
var cacheThin = igniteThin.GetCache <int, Person>(cacheCfg.Name);
var personThin = await cacheThin.GetAsync(1);
Debug.Assert("Person-1" == personThin.Name);
var personNames = cacheThin.AsCacheQueryable()
.Where(e => e.Key != 2 && e.Value.Age < 10)
.Select(e => e.Value.Name)
.ToArray();
Debug.Assert(personNames.SequenceEqual(new[] { "Person-1" }));
}
}
}
public void CacheConfigDurationTest()
{
// Arrange
const string cacheName = "AccessClient";
var cacheManager = new CacheManager();
var cache = new InMemoryTestCache(cacheName);
cacheManager.AddCache(cache);
//Assert
Assert.AreEqual(5, CacheConfiguration.Instance(cacheName).DefaultDuration, "Default duration");
Assert.AreEqual(5, CacheConfiguration.Instance(cacheName).GetCacheTime("GetEntityWithDefaultDuration"), "Item with defafult duration");
Assert.AreEqual(1, CacheConfiguration.Instance(cacheName).GetCacheTime("GetEntityWith1MinuteDuration"), "Item 1 min duration");
Assert.AreEqual(0, CacheConfiguration.Instance(cacheName).GetCacheTime("GetEntityWithZeroDuration"), "Item 0 duration");
Assert.AreEqual(0, CacheConfiguration.Instance(cacheName).GetCacheTime("NonExistingItem"), "Non-existing 0 duration");
}
public static void QueryEntityDemo()
{
// tag::queryEntity[]
var cacheCfg = new CacheConfiguration
{
Name = "myCache",
QueryEntities = new[]
{
new QueryEntity
{
KeyType = typeof(long),
KeyFieldName = "id",
ValueType = typeof(dotnet_helloworld.Person),
Fields = new[]
{
new QueryField
{
Name = "id",
FieldType = typeof(long)
},
new QueryField
{
Name = "name",
FieldType = typeof(string)
},
new QueryField
{
Name = "salary",
FieldType = typeof(long)
},
},
Indexes = new[]
{
new QueryIndex("name"),
new QueryIndex(false, QueryIndexType.Sorted, new[] { "id", "salary" })
}
}
}
};
Ignition.Start(new IgniteConfiguration
{
CacheConfiguration = new[] { cacheCfg }
});
// end::queryEntity[]
}
public MemoryCacheService(
IMemoryCache memoryCache,
IOptions <CacheConfiguration> cacheConfig)
{
_memoryCache = memoryCache;
_cacheConfig = cacheConfig.Value;
if (_cacheConfig != null)
{
_cacheOptions = new MemoryCacheEntryOptions
{
AbsoluteExpiration = DateTime.Now.AddHours(_cacheConfig.AbsoluteExpirationInHours),
Priority = CacheItemPriority.High,
SlidingExpiration = TimeSpan.FromMinutes(_cacheConfig.SlidingExpirationInMinutes)
};
}
}
public void TestAttributeFilterWithNullValues()
{
TestDelegate action = () =>
{
var _ = new CacheConfiguration
{
NodeFilter = new AttributeNodeFilter
{
Attributes = null
},
};
};
var ex = Assert.Throws <ArgumentNullException>(action);
StringAssert.Contains("value", ex.Message);
}
public async Task custom_config_cache_construction_should_work()
{
var cacheConfig = new CacheConfiguration(1024, 5, 1024, 5, TimeSpan.FromMinutes(1));
var cache = await PortableCacheFactory.GetCache(cacheConfig, null, "someCacheName2");
await cache.Set("key1", "stringValue");
cache.Size.Should().BeGreaterThan(0);
cache.Count.Should().Be(1);
cache.Get <string>("key1").Result.Value.Should().Be("stringValue");
await cache.Remove("key1");
cache.Count.Should().Be(0);
cache.Size.Should().Be(0);
cache.Get <string>("key1").Result.Should().BeNull();
}
public void TestCompositeKey()
{
var cfg = new CacheConfiguration("composite_key_arr", new QueryEntity(typeof(Key), typeof(Foo)));
var cache = Ignition.GetIgnite().CreateCache <Key, Foo>(cfg);
// Test insert.
var res = cache.Query(new SqlFieldsQuery("insert into foo(hi, lo, id, name) " +
"values (-1, 65500, 3, 'John'), (255, 128, 6, 'Mary')")).GetAll();
Assert.AreEqual(1, res.Count);
Assert.AreEqual(1, res[0].Count);
Assert.AreEqual(2, res[0][0]); // 2 affected rows
var foos = cache.OrderByDescending(x => x.Key.Lo).ToArray();
Assert.AreEqual(2, foos.Length);
Assert.AreEqual(-1, foos[0].Key.Hi);
Assert.AreEqual(65500, foos[0].Key.Lo);
Assert.AreEqual(3, foos[0].Value.Id);
Assert.AreEqual("John", foos[0].Value.Name);
Assert.AreEqual(255, foos[1].Key.Hi);
Assert.AreEqual(128, foos[1].Key.Lo);
Assert.AreEqual(6, foos[1].Value.Id);
Assert.AreEqual("Mary", foos[1].Value.Name);
// Existence tests check that hash codes are consistent.
var binary = cache.Ignite.GetBinary();
var binCache = cache.WithKeepBinary <IBinaryObject, IBinaryObject>();
Assert.IsTrue(cache.ContainsKey(new Key(65500, -1)));
Assert.IsTrue(cache.ContainsKey(foos[0].Key));
Assert.IsTrue(binCache.ContainsKey(
binary.GetBuilder(typeof(Key)).SetField("hi", -1).SetField("lo", 65500).Build()));
Assert.IsTrue(binCache.ContainsKey( // Fields are sorted.
binary.GetBuilder(typeof(Key)).SetField("lo", 65500).SetField("hi", -1).Build()));
Assert.IsTrue(cache.ContainsKey(new Key(128, 255)));
Assert.IsTrue(cache.ContainsKey(foos[1].Key));
Assert.IsTrue(binCache.ContainsKey(
binary.GetBuilder(typeof(Key)).SetField("hi", 255).SetField("lo", 128).Build()));
Assert.IsTrue(binCache.ContainsKey( // Fields are sorted.
binary.GetBuilder(typeof(Key)).SetField("lo", 128).SetField("hi", 255).Build()));
}
/// <summary>
/// Tests the type registration.
/// </summary>
private static void Test(IIgnite ignite1, IIgnite ignite2)
{
var cfg = new CacheConfiguration("cache")
{
CacheMode = CacheMode.Partitioned,
WriteSynchronizationMode = CacheWriteSynchronizationMode.FullSync
};
// Put on one grid.
var cache1 = ignite1.GetOrCreateCache <int, object>(cfg);
cache1[1] = new Foo {
Int = 1, Str = "1"
};
cache1[2] = ignite1.GetBinary().GetBuilder(typeof(Bar)).SetField("Int", 5).SetField("Str", "s").Build();
// Get on another grid.
var cache2 = ignite2.GetOrCreateCache <int, Foo>(cfg);
var foo = cache2[1];
Assert.AreEqual(1, foo.Int);
Assert.AreEqual("1", foo.Str);
var bar = cache2.WithKeepBinary <int, IBinaryObject>()[2];
Assert.AreEqual("s", bar.GetField <string>("Str"));
Assert.AreEqual(5, bar.GetField <int>("Int"));
var bar0 = bar.Deserialize <Bar>();
Assert.AreEqual("s", bar0.Str);
Assert.AreEqual(5, bar0.Int);
// Test compute.
var serverNodeCount = ignite1.GetCluster().ForServers().GetNodes().Count;
var res = ignite1.GetCompute().Broadcast(new CompFn <DateTime>(() => DateTime.Now));
Assert.AreEqual(serverNodeCount, res.Count);
// Variable capture.
var res2 = ignite1.GetCompute().Broadcast(new CompFn <string>(() => bar0.Str));
Assert.AreEqual(Enumerable.Repeat(bar0.Str, serverNodeCount), res2);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
DatabaseConfigurations connectionString = Configuration.GetSection("ConnectionStrings")
.Get <DatabaseConfigurations>();
EmailConfiguration emailConfiguration = Configuration.GetSection("EmailConfiguration")
.Get <EmailConfiguration>();
CacheConfiguration cacheConfiguration = Configuration.GetSection("CacheConfiguration")
.Get <CacheConfiguration>();
if (cacheConfiguration.IsEnabled)
{
services.AddStackExchangeRedisCache(options => options.Configuration = cacheConfiguration.ConnectionString);
services.AddSingleton <IResponseCacheService, ResponseCacheService>();
}
CloudConfiguration cloudConfiguration = Configuration.GetSection("CLOUDINARY")
.Get <CloudConfiguration>();
services.AddSingleton(cacheConfiguration);
services.AddSingleton(emailConfiguration);
services.AddSingleton(connectionString);
services.AddSingleton(cloudConfiguration);
services.AddTransient <IDBContext, DBContext>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <ITokenManager, TokenManager>();
services.AddScoped <IBooksRepository, BooksRepository>();
services.AddScoped <IBookService, BookService>();
services.AddScoped <IWishlistRepository, WishlistRepository>();
services.AddScoped <IWishlistService, WishlistService>();
services.AddScoped <ICartRepository, CartRepository>();
services.AddScoped <ICartService, CartService>();
services.AddScoped <IOrderRepository, OrderRepository>();
services.AddScoped <IOrderService, OrderService>();
services.AddScoped <IEmailSender, EmailSender>();
services.AddScoped <IMqServices, MsmqServices>();
services.AddScoped <IEmailItemDetails, EmailItemDetails>();
services.AddScoped <ICacheRepository, CacheRepository>();
services.AddScoped <IAddressRepository, AddressRepository>();
services.AddScoped <IAddressService, AddressService>();
services.AddScoped <ICloudService, CloudService>();
services.AddAutoMapper(typeof(Startup));
services.AddSwagger();
services.AddCors();
}
public async void Initialize()
{
var cacheContainer = new CacheContainer();
cacheContainer.Register <ILogger, TestLogger>();
cacheContainer.Register <IVersionProvider, TestVersionProvider>().WithValue("version", new Version("1.0"));
cacheContainer.Register <IStorage, TestStorage>();
cacheContainer.Register <ISerializer, ProtoBufSerializer>().WithDependency("storage", typeof(IStorage).FullName).WithValue("userTypes", null);
var cacheConfiguration = new CacheConfiguration(2048, 6, 2048, 5);
_cache = new Cache(cacheContainer, cacheConfiguration);
await _cache.Initialize();
await _cache.Set("key1", "string1", TimeSpan.FromMilliseconds(1));
Thread.Sleep(10);
}
public CommonRegistry(CacheConfiguration cacheConfiguration)
{
For <IConfigurationManager>().Singleton().Use <ConfigurationManager>();
For <IConfigurationService>().Singleton().Use <AzureBlobConfigurationService>().Name = "ConfigurationService";
For <IDateTimeService>().Use <DateTimeService>();
For <ICurrentUserService>().Use <CurrentUserService>();
if (cacheConfiguration.UseCache)
{
For <IConfigurationService>()
.Singleton()
.Use <CachedConfigurationService>()
.Ctor <IConfigurationService>()
.Named("ConfigurationService")
.Ctor <ICacheService>()
.Named(cacheConfiguration.DefaultCache);
}
}
public void TestCustomFilterIsNotSupported()
{
var cacheCfg = new CacheConfiguration
{
Name = Guid.NewGuid().ToString(),
CacheMode = CacheMode.Replicated,
NodeFilter = new CustomFilter()
};
TestDelegate action = () => { _grid1.CreateCache <object, object>(cacheCfg); };
var ex = Assert.Throws <NotSupportedException>(action);
Assert.AreEqual("Unsupported CacheConfiguration.NodeFilter: " +
"'CustomFilter'. " +
"Only predefined implementations are supported: " +
"'AttributeNodeFilter'", ex.Message);
}
public IgniteDbConfiguration(IIgnite ignite, CacheConfiguration metaCacheConfiguration,
CacheConfiguration dataCacheConfiguration, IDbCachingPolicy policy)
{
IgniteArgumentCheck.NotNull(ignite, "ignite");
metaCacheConfiguration = metaCacheConfiguration ?? GetDefaultMetaCacheConfiguration();
dataCacheConfiguration = dataCacheConfiguration ?? GetDefaultDataCacheConfiguration();
var efCache = new DbCache(ignite, metaCacheConfiguration, dataCacheConfiguration);
var txHandler = new DbTransactionInterceptor(efCache);
AddInterceptor(txHandler);
// SetProviderServices is not suitable. We should replace whatever provider there is with our proxy.
Loaded += (sender, args) => args.ReplaceService <DbProviderServices>(
(services, a) => new DbProviderServicesProxy(services, policy, efCache, txHandler));
}
public void Map(CacheConfiguration cacheConfiguration)
{
cacheConfiguration.AddCacheService <IDefensiveCacheMapping>(configuration =>
{
configuration.AddMethod(x => nameof(x.GetBool), "mapGetBool-{id}", 600);
configuration.AddMethod(x => nameof(x.GetBoolAsync), "mapGetBoolAsync-{id}", 600);
configuration.AddMethod(x => nameof(x.GetDateTime), "mapGetDateTime-{id}", 600);
configuration.AddMethod(x => nameof(x.GetDateTimeAsync), "mapGetDateTimeAsync-{id}", 600);
configuration.AddMethod(x => nameof(x.GetInt), "mapGetInt-{id}", 600);
configuration.AddMethod(x => nameof(x.GetIntAsync), "mapGetIntAsync-{id}", 600);
configuration.AddMethod(x => nameof(x.GetListObject), "mapGetListObject-{filter.Page}_{filter.Records}", 600);
configuration.AddMethod(x => nameof(x.GetListObjectAsync), "mapGetListObjectAsync-{filter.Page}_{filter.Records}", 600);
configuration.AddMethod(x => nameof(x.GetObject), "mapGetObject-{id}", 600);
configuration.AddMethod(x => nameof(x.GetObjectAsync), "mapGetObjectAsync-{id}", 600);
configuration.AddMethod(x => nameof(x.GetString), "mapGetString-{id}", 600);
configuration.AddMethod(x => nameof(x.GetStringAsync), "mapGetStringAsync-{id}", 600);
});
}
/// <summary>
/// Inits a grid.
/// </summary>
private void InitNode(int i, bool serverNear = true, bool waitForPrimary = true, int backups = 0)
{
var cacheConfiguration = new CacheConfiguration(CacheName)
{
NearConfiguration = serverNear ? new NearCacheConfiguration() : null,
PlatformCacheConfiguration = serverNear ? new PlatformCacheConfiguration() : null,
Backups = backups
};
_ignite[i] = Ignition.Start(TestUtils.GetTestConfiguration(name: "node" + i));
_cache[i] = _ignite[i].GetOrCreateCache <int, Foo>(cacheConfiguration);
if (i == 2 && waitForPrimary)
{
// ReSharper disable once AccessToDisposedClosure
TestUtils.WaitForTrueCondition(() => TestUtils.GetPrimaryKey(_ignite[2], CacheName) == Key3, 300000);
}
}
public void TestFailedCacheStoreException()
{
try
{
var ccfg = new CacheConfiguration("CacheWithFailedStore")
{
CacheStoreFactory = new FailedCacheStoreFactory(),
ReadThrough = true
};
Assert.Throws <CacheException>(() => Ignition.GetIgnite(GridName).GetOrCreateCache <int, int>(ccfg));
}
finally
{
// After failed cache grid is in ivalid state. Should be restarted.
Restart();
}
}
/// <summary>
/// Tests the key.
/// </summary>
private static void TestKey <T>(params T[] vals)
{
var cfg = new CacheConfiguration("primitive_key_dotnet_" + typeof(T),
new QueryEntity(typeof(T), typeof(string)));
var cache = Ignition.GetIgnite().CreateCache <T, string>(cfg);
foreach (var val in vals)
{
var res = cache.Query(new SqlFieldsQuery(
"insert into string(_key, _val) values (?, ?)", val, val.ToString())).GetAll();
Assert.AreEqual(1, res.Count);
Assert.AreEqual(1, res[0].Count);
Assert.AreEqual(1, res[0][0]);
Assert.AreEqual(val.ToString(), cache[val]);
}
}
public CombinedTestResult TestCacheIsSet(CacheConfiguration config, TestRequest payload)
{
// Arrange
var consumer = new TestConsumer();
consumer.InitData();
var message = new Message <TestRequest>(MessageLabel.From("message.label"), payload);
var context = new TestContext(message);
var sut = new CachingConsumerOf <TestRequest>(consumer, config);
// Act
sut.Handle(context);
// Assert
var cachedValue = config?.Cache.ContainsKey(message) ?? false ? ((TestResponse)config.Cache[message]).Value : null;
return(new CombinedTestResult(cachedValue, context.Response.Value));
}
/// <summary>
/// Initializes Ignite caching for specified <see cref="DbConfiguration"/>.
/// This method should be used when it is not possible to use or inherit <see cref="IgniteDbConfiguration"/>.
/// </summary>
/// <param name="dbConfiguration"><see cref="DbConfiguration"/> instance to be initialized
/// for Ignite caching.</param>
/// <param name="ignite">The ignite instance to use.</param>
/// <param name="metaCacheConfiguration">
/// Configuration of the metadata cache which holds entity set information. Null for default configuration.
/// <para />
/// This cache holds small amount of data, but should not lose entries. At least one backup recommended.
/// </param>
/// <param name="dataCacheConfiguration">
/// Configuration of the data cache which holds query results. Null for default configuration.
/// <para />
/// This cache tolerates lost data and can have no backups.
/// </param>
/// <param name="policy">The caching policy. Null for default <see cref="DbCachingPolicy" />.</param>
private static void InitializeIgniteCachingInternal(DbConfiguration dbConfiguration, IIgnite ignite,
CacheConfiguration metaCacheConfiguration, CacheConfiguration dataCacheConfiguration,
IDbCachingPolicy policy)
{
Debug.Assert(ignite != null);
Debug.Assert(dbConfiguration != null);
metaCacheConfiguration = metaCacheConfiguration ?? GetDefaultMetaCacheConfiguration();
dataCacheConfiguration = dataCacheConfiguration ?? GetDefaultDataCacheConfiguration();
var efCache = new DbCache(ignite, metaCacheConfiguration, dataCacheConfiguration);
var txHandler = new DbTransactionInterceptor(efCache);
AddInterceptorDelegate(dbConfiguration, txHandler);
RegisterProviderServicesReplacer(dbConfiguration, policy, efCache, txHandler);
}
public void Arrange()
{
_stateRepositoryMock = new Mock <IStateRepository>();
_ukrlpApiClientMock = new Mock <IUkrlpApiClient>();
_mapperMock = new Mock <IMapper>();
_mapperMock.Setup(m => m.MapAsync <LearningProvider>(It.IsAny <Provider>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((Provider provider, CancellationToken cancellationToken) => new LearningProvider
{
Name = provider.ProviderName,
});
_eventPublisherMock = new Mock <IEventPublisher>();
_providerProcessingQueueMock = new Mock <IProviderProcessingQueue>();
_providerRepositoryMock = new Mock <IProviderRepository>();
_providerRepositoryMock.Setup(r => r.GetProviderAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((PointInTimeProvider)null);
_providerRepositoryMock.Setup(r =>
r.GetProviderFromStagingAsync(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <CancellationToken>()))
.ReturnsAsync((long ukprn, DateTime pointInTime, CancellationToken cancellationToken) => new PointInTimeProvider
{
UnitedKingdomProviderReferenceNumber = ukprn,
ProviderName = ukprn.ToString(),
});
_configuration = new CacheConfiguration();
_loggerMock = new Mock <ILoggerWrapper>();
_manager = new CacheManager(
_stateRepositoryMock.Object,
_ukrlpApiClientMock.Object,
_providerRepositoryMock.Object,
_mapperMock.Object,
_eventPublisherMock.Object,
_providerProcessingQueueMock.Object,
_configuration,
_loggerMock.Object);
_cancellationToken = new CancellationToken();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.TryAddTransient <IResponseHelper, ResponseHelper>();
services.AddControllers();
services.AddCoreServiceConfig();
services.AddStoreServiceConfig();
services.AddConfigurationServiceConfig(Configuration);
services.AddHostedService <HistoryService>();
var corsConfig = new CorsConfiguration();
Configuration.GetSection(CorsConfiguration.Configuration).Bind(corsConfig);
if (corsConfig.Origins.Length != 0)
{
UseCors = true;
services.AddCors(options =>
{
options.AddDefaultPolicy(builder => builder.WithOrigins(corsConfig.Origins).AllowAnyMethod().AllowAnyHeader());
});
}
var cacheConfig = new CacheConfiguration();
Configuration.GetSection(CacheConfiguration.Configuration).Bind(cacheConfig);
if (cacheConfig.UseRedis)
{
if (string.IsNullOrWhiteSpace(cacheConfig.Host) || string.IsNullOrWhiteSpace(cacheConfig.Instance))
{
throw new Exception("Redis not configured properly");
}
services.AddStackExchangeRedisCache(options =>
{
options.Configuration = cacheConfig.Host;
options.InstanceName = cacheConfig.Instance;
});
}
else
{
services.AddDistributedMemoryCache();
}
}
public void Arrange()
{
_giasApiClientMock = new Mock <IGiasApiClient>();
_giasApiClientMock.Setup(c => c.DownloadEstablishmentsAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(new Establishment[0]);
_stateRepositoryMock = new Mock <IStateRepository>();
_establishmentRepositoryMock = new Mock <IEstablishmentRepository>();
_groupRepositoryMock = new Mock <IGroupRepository>();
_localAuthorityRepositoryMock = new Mock <ILocalAuthorityRepository>();
_mapperMock = new Mock <IMapper>();
_eventPublisherMock = new Mock <IEventPublisher>();
_establishmentProcessingQueueMock = new Mock <IEstablishmentProcessingQueue>();
_groupProcessingQueueMock = new Mock <IGroupProcessingQueue>();
_localAuthorityProcessingQueueMock = new Mock <ILocalAuthorityProcessingQueue>();
_configuration = new CacheConfiguration();
_loggerMock = new Mock <ILoggerWrapper>();
_manager = new CacheManager(
_giasApiClientMock.Object,
_stateRepositoryMock.Object,
_establishmentRepositoryMock.Object,
_groupRepositoryMock.Object,
_localAuthorityRepositoryMock.Object,
_mapperMock.Object,
_eventPublisherMock.Object,
_establishmentProcessingQueueMock.Object,
_groupProcessingQueueMock.Object,
_localAuthorityProcessingQueueMock.Object,
_configuration,
_loggerMock.Object);
_cancellationToken = new CancellationToken();
}
public void Setup()
{
_config = new CacheConfiguration(new MemoryCache("CacheConfigurationTests"), false);
}
public void GetKeyExtractor_WhenTypeDoNotFitInConvention()
{
_config = new CacheConfiguration(new MemoryCache("CacheConfigurationTests"));
var keyExtractor = _config.GetKeyExtractor(typeof(City));
}
public CachingAdvice(ICacheProvider cacheProvider, ICacheConfigurationService configurationService)
{
_cacheProvider = cacheProvider;
_cacheConfiguration = configurationService.BuildConfiguration();
}
public CacheInformation()
{
Configuration = new CacheConfiguration();
Statistics = new CacheStatistics();
}
public void ItemExpires_Tag_RemovedFromCache()
{
// this is testing that when expiry happens, the events kick in and remove the tags
// see RedisExpireHandler
var redis = new RedisConnectionManager();
var config = new CacheConfiguration(redis);
var cache = new RedisCacheProvider(config);
var client = newRedisClient(config.RedisClientConfiguration);
cache.Logger = new TestRedisLogger();
Console.WriteLine("Start Logger");
string key = "TagCacheTests:ItemExpires_Tag_RemovedFromCache";
String value = "Hello World!";
DateTime expires = DateTime.Now.AddSeconds(3);
string tag1 = "tag1001";
string tag2 = "tag1002";
cache.Set(key, value, expires, new List<string>{tag1, tag2});
// first check everything has been set
var result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
var keysForTag1 = client.GetKeysForTag(tag1);
Assert.IsNotNull(keysForTag1);
Assert.IsTrue(keysForTag1.Any(x => x == key));
var tagsForKey = client.GetTagsForKey(key);
Assert.IsNotNull(tagsForKey);
Assert.IsTrue(tagsForKey.Any(x => x == tag1));
Assert.IsTrue(tagsForKey.Any(x => x == tag2));
// wait a while
Thread.Sleep(1000);
// check it has not expired yet
result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
keysForTag1 = client.GetKeysForTag(tag1);
Assert.IsNotNull(keysForTag1);
Assert.IsTrue(keysForTag1.Any(x => x == key));
tagsForKey = client.GetTagsForKey(key);
Assert.IsNotNull(tagsForKey);
Assert.IsTrue(tagsForKey.Any(x => x == tag1));
Assert.IsTrue(tagsForKey.Any(x => x == tag2));
// now wait until it should have been removed
Thread.Sleep(2500);
// now check its all been removed
result = cache.Get<String>(key);
Assert.IsNull(result);
keysForTag1 = client.GetKeysForTag(tag1);
Assert.IsNotNull(keysForTag1);
Assert.IsFalse(keysForTag1.Any(x => x == key));
tagsForKey = client.GetTagsForKey(key);
Assert.IsNotNull(tagsForKey);
Assert.IsFalse(tagsForKey.Any(x => x == tag1));
Assert.IsFalse(tagsForKey.Any(x => x == tag2));
}
public static async Task<ICache> GetInMemotyCache(CacheConfiguration cacheConfiguration, IEnumerable<Type> userTypes = null, string cacheName = "default")
{
return await Instance.InMemoryCache(cacheConfiguration, userTypes, cacheName);
}
public static async Task<ICache> GetInMemotyCache(CacheContainer cacheContainer, CacheConfiguration cacheConfiguration)
{
return await Instance.InMemoryCache(cacheContainer, cacheConfiguration);
}
public void GetKeyExtractor_WithCustomConvetion()
{
_config = new CacheConfiguration(new MemoryCache("CacheConfigurationTests"), new CityConvention());
var keyExtractor = _config.GetKeyExtractor(typeof(City));
var city = new City { Name = "city", PopulationCount = 12345 };
var key = keyExtractor(city);
Assert.AreEqual(city.PopulationCount.ToString(), key);
}
public void Setup()
{
_internalCache = new MemoryCache("CacheTest");
_config = new CacheConfiguration(_internalCache);
_cache = new Cache(_config);
}
internal KeyCreator(CacheConfiguration configuration)
{
_configuration = configuration;
}
