public void Clear() { using (CreateCrossPlatLock(_storageCreationProperties)) { CacheStore.Clear(); } }
public void Fetch_OnSave_test() { var root = Substitute.For <ISite>(); var cacheRegistry = new CacheRegistry(new TestCacheConfig()); var cacheStore = new CacheStore(); var cache = new Cache(cacheStore, cacheRegistry, root); async Task <IEnumerable <TestItem> > Task(ICache c) => await System.Threading.Tasks.Task.Run(() => new[] { new TestItem { ItemId = 1 }, new TestItem { ItemId = 3 }, new TestItem { ItemId = 2 } }).ConfigureAwait(false); cacheRegistry.Add(Task) .Span(300) .OnSave(x => x.OrderBy(y => y.ItemId)); var result = cache.Fetch <TestItem>().ToList(); Assert.That(result, Is.Not.Null); Assert.That(result.First().ItemId, Is.EqualTo(1)); Assert.That(result.Last().ItemId, Is.EqualTo(3)); }
static void Main(string[] args) { const string baseDirectory = "c:\\tmp\\PersistantCache"; //var diskCache = new BPlusTreeCache<Thing>(baseDirectory, 1); var diskCache = new EsentPersistentDictionary(baseDirectory); PersistentCache = new CacheStore <PersistentCache.CacheItem>(baseDirectory, "1", null, "00:00:10", diskCache); Console.WriteLine("Creating Data"); const int itemsToUse = 1000000; var items = GenerateList(itemsToUse, 20); items.Shuffle(); //var temp = new CacheItem[itemsToUse]; //items.CopyTo(temp); //var reversedItems = temp.Reverse().ToList(); var items2 = GenerateList(itemsToUse, 20); items2.Shuffle(); RunPersistanceCacheTest(new List <List <CacheItem> >(2) { items, items2 }); Console.ReadKey(); }
/// <summary> /// 清楚所有缓存 /// </summary> public static void ClearCache() { foreach (var item in CacheStore) { CacheStore.Remove(item.Key); } }
private long CacheStoreCreate(long memPtr) { var cacheStore = CacheStore.CreateInstance(memPtr, _handleRegistry); if (_ignite != null) { cacheStore.Init(_ignite); } else { lock (_initActions) { if (_ignite != null) { cacheStore.Init(_ignite); } else { _initActions.Add(cacheStore.Init); } } } return(cacheStore.Handle); }
/// <summary> /// Agrega la cabecera con los datos de la carga útil necesarios para autenticar a un usuario en el servicio Aspen. /// </summary> /// <param name="request">Solicitud a donde se agrega la cabecera.</param> /// <param name="jwtEncoder">Instancia del codificador del contenido de la carga útil.</param> /// <param name="apiSecret">Secreto de la aplicación que se utiliza para codificar el contenido del carga útil.</param> /// <param name="token">El token de autenticación emitido para el usuario.</param> /// <param name="username">La identificación del usuario autenticado.</param> /// <param name="device">La información asociada con el dispositivo del usuario.</param> public void AddSignedPayloadHeader( IRestRequest request, IJwtEncoder jwtEncoder, string apiSecret, string token, string username, IDeviceInfo device = null) { Throw.IfNull(request, nameof(request)); Throw.IfNull(jwtEncoder, nameof(jwtEncoder)); Throw.IfNullOrEmpty(apiSecret, nameof(apiSecret)); Throw.IfNullOrEmpty(token, nameof(token)); Throw.IfNullOrEmpty(username, nameof(username)); IDeviceInfo deviceInfo = device ?? CacheStore.Get <DeviceInfo>(CacheKeys.CurrentDevice) ?? DeviceInfo.Current; Dictionary <string, object> payload = new Dictionary <string, object>(); ServiceLocator.Instance.PayloadClaimsManager.AddNonceClaim(payload, ServiceLocator.Instance.NonceGenerator.GetNonce()); ServiceLocator.Instance.PayloadClaimsManager.AddEpochClaim(payload, ServiceLocator.Instance.EpochGenerator.GetSeconds()); ServiceLocator.Instance.PayloadClaimsManager.AddTokenClaim(payload, token); ServiceLocator.Instance.PayloadClaimsManager.AddUsernameClaim(payload, username); ServiceLocator.Instance.PayloadClaimsManager.AddDeviceIdClaim(payload, deviceInfo.DeviceId); string jwt = jwtEncoder.Encode(payload, apiSecret); request.AddHeader(ServiceLocator.Instance.RequestHeaderNames.PayloadHeaderName, jwt); }
/// <summary> /// Agrega la cabecera con los datos de la carga útil necesarios para autenticar a un usuario en el servicio Aspen. /// </summary> /// <param name="request">Solicitud a donde se agrega la cabecera.</param> /// <param name="jwtEncoder">Instancia del codificador del contenido de la carga útil.</param> /// <param name="apiSecret">Secreto de la aplicación que se utiliza para codificar el contenido del carga útil.</param> /// <param name="userIdentity">La información que se utiliza para autenticar la solicitud en función de un usuario.</param> public void AddSigninPayloadHeader( IRestRequest request, IJwtEncoder jwtEncoder, string apiSecret, IUserIdentity userIdentity) { Throw.IfNull(request, nameof(request)); Throw.IfNull(jwtEncoder, nameof(jwtEncoder)); Throw.IfNullOrEmpty(apiSecret, nameof(apiSecret)); Throw.IfNull(userIdentity, nameof(userIdentity)); IDeviceInfo deviceInfo = userIdentity.Device ?? CacheStore.Get <DeviceInfo>(CacheKeys.CurrentDevice) ?? DeviceInfo.Current; request.AddHeader(ServiceLocator.Instance.RequestHeaderNames.DeviceInfoHeaderName, deviceInfo.ToJson()); CacheStore.Add(CacheKeys.CurrentDevice, deviceInfo); Dictionary <string, object> payload = new Dictionary <string, object>(); ServiceLocator.Instance.PayloadClaimsManager.AddNonceClaim(payload, ServiceLocator.Instance.NonceGenerator.GetNonce()); ServiceLocator.Instance.PayloadClaimsManager.AddEpochClaim(payload, ServiceLocator.Instance.EpochGenerator.GetSeconds()); ServiceLocator.Instance.PayloadClaimsManager.AddDocTypeClaim(payload, userIdentity.DocType); ServiceLocator.Instance.PayloadClaimsManager.AddDocNumberClaim(payload, userIdentity.DocNumber); ServiceLocator.Instance.PayloadClaimsManager.AddPasswordClaim(payload, userIdentity.Password); ServiceLocator.Instance.PayloadClaimsManager.AddDeviceIdClaim(payload, deviceInfo.DeviceId); string jwt = jwtEncoder.Encode(payload, apiSecret); request.AddHeader(ServiceLocator.Instance.RequestHeaderNames.PayloadHeaderName, jwt); }
public void Basic_Put_Get_Remove() { using (var store = new CacheStore(null)) { var tbl1 = store["t1"]; for (int i = 0; i < 1000; i++) { var bo = new businessObject { ID = i, Name = "Xroemson-{0}".Args(i), IsGood = i % 7 == 0 }; Assert.IsTrue(tbl1.Put((ulong)i, bo)); } Assert.AreEqual(1000, tbl1.Count); Assert.IsTrue(tbl1.Remove(115)); Assert.AreEqual(999, tbl1.Count); Assert.AreEqual("Xroemson-12", tbl1.Get(12).ValueAs <businessObject>().Name); Assert.AreEqual(null, tbl1.Get(115)); Assert.AreEqual("Xroemson-999", tbl1.Get(999).ValueAs <businessObject>().Name); Assert.AreEqual(true, tbl1.Get(7).ValueAs <businessObject>().IsGood); } }
public void CreatesCorrectPolicy(int seconds) { var basePolicy = new CacheStore(TimeSpan.FromSeconds(seconds)); var xml = basePolicy.GetXml().ToString(); xml.Should().Be($"<cache-store duration=\"{seconds}\" />"); }
public JsonResult Delete(int id) { CacheStore.Remove <Tutor>(id.ToString()); string message = $"User has been removed successfully!"; return(Json(message, JsonRequestBehavior.AllowGet)); }
public void ComplexKeyHashingStrategy_1() { using (var store = new CacheStore(null)) { var strat = new ComplexKeyHashingStrategy(store); strat.Put("t1", "A", new businessObject { ID = 000, Name = "Adoyan", IsGood = true }); strat.Put("t1", "B", new businessObject { ID = 234, Name = "Borisenko", IsGood = false }); strat.Put("t1", "C", new businessObject { ID = 342, Name = "Carov", IsGood = true }); strat.Put("t2", "A", new businessObject { ID = 2000, Name = "2Adoyan", IsGood = true }); strat.Put("t2", "B", new businessObject { ID = 2234, Name = "2Borisenko", IsGood = false }); strat.Put("t2", "C", new businessObject { ID = 2342, Name = "2Carov", IsGood = true }); Assert.AreEqual("Adoyan", ((businessObject)strat.Get("t1", "A")).Name); Assert.AreEqual("Borisenko", ((businessObject)strat.Get("t1", "B")).Name); Assert.AreEqual("Carov", ((businessObject)strat.Get("t1", "C")).Name); Assert.AreEqual("2Adoyan", ((businessObject)strat.Get("t2", "A")).Name); Assert.AreEqual("2Borisenko", ((businessObject)strat.Get("t2", "B")).Name); Assert.AreEqual("2Carov", ((businessObject)strat.Get("t2", "C")).Name); } }
public void Configuration_UnNamedStore() { var conf = LaconicConfiguration.CreateFromString(CONF_SRC); using (var app = new ServiceBaseApplication(null, conf.Root)) { using (var store = new CacheStore("SomeStoreThat will be configured from default store without name")) { store.Configure(null); Assert.AreEqual(true, store.ParallelSweep); Assert.AreEqual(true, store.InstrumentationEnabled); Assert.AreEqual(1234567, store.TableOptions["doctor"].BucketCount); Assert.AreEqual(7, store.TableOptions["doctor"].RecPerPage); Assert.AreEqual(19, store.TableOptions["doctor"].LockCount); Assert.AreEqual(193, store.TableOptions["doctor"].MaxAgeSec); Assert.AreEqual(true, store.TableOptions["doctor"].ParallelSweep); Assert.AreEqual(451000000, store.TableOptions["PATIENT"].BucketCount); Assert.AreEqual(17, store.TableOptions["PATIENT"].RecPerPage); Assert.AreEqual(1025, store.TableOptions["PATIENT"].LockCount); Assert.AreEqual(739, store.TableOptions["PATIENT"].MaxAgeSec); Assert.AreEqual(true, store.TableOptions["PATIENT"].ParallelSweep); } } }
public void Put_Expire_Get() { using (var store = new CacheStore(null)) { var tbl1 = store["t1"]; for (int i = 0; i < 1000; i++) { var bo = new businessObject { ID = i, Name = "Suvorov-{0}".Args(i), IsGood = i % 7 == 0 }; Assert.IsTrue(tbl1.Put((ulong)i, bo, i < 500 ? 5 : 100)); } Assert.AreEqual(1000, tbl1.Count); //warning: this timeout depends on how fast the store will purge garbage for (var spin = 0; spin < 20 && tbl1.Count != 500; spin++) { System.Threading.Thread.Sleep(1000); } Assert.AreEqual(500, tbl1.Count); Assert.AreEqual(null, tbl1.Get(1)); Assert.AreEqual(null, tbl1.Get(499)); Assert.AreEqual("Suvorov-500", tbl1.Get(500).ValueAs <businessObject>().Name); Assert.AreEqual("Suvorov-999", tbl1.Get(999).ValueAs <businessObject>().Name); } }
private long CacheStoreCreate(void *target, long memPtr) { return(SafeCall(() => { var cacheStore = CacheStore.CreateInstance(memPtr, _handleRegistry); if (_ignite != null) { cacheStore.Init(_ignite); } else { lock (_initActions) { if (_ignite != null) { cacheStore.Init(_ignite); } else { _initActions.Add(cacheStore.Init); } } } return cacheStore.Handle; }, true)); }
public void Basic_Put_Get_HitCount() { using (var store = new CacheStore(null)) { var tbl1 = store["t1"]; for (int i = 0; i < 100; i++) { var bo = new businessObject { ID = i, Name = "Froemson-{0}".Args(i), IsGood = i % 7 == 0 }; Assert.IsTrue(tbl1.Put((ulong)i, bo)); } Assert.AreEqual(100, tbl1.Count); Assert.AreEqual("Froemson-12", tbl1.Get(12).ValueAs <businessObject>().Name); Assert.AreEqual("Froemson-12", store["t1", 12].ValueAs <businessObject>().Name); Assert.AreEqual(true, tbl1.Get(7).ValueAs <businessObject>().IsGood); Assert.AreEqual(1, tbl1.Get(0).HitCount); Assert.AreEqual(3, tbl1.Get(12).HitCount); Assert.AreEqual(2, tbl1.Get(7).HitCount); } }
public void Clear() { using (CreateCrossPlatLock(_storageCreationProperties)) { CacheStore.Clear(ignoreExceptions: true); } }
/// <summary> /// Extracts the token cache data from the persistent store /// </summary> /// <returns>an UTF-8 byte array of the unencrypted token cache</returns> /// <remarks>This method should be used with care. The data returned is unencrypted.</remarks> public byte[] LoadUnencryptedTokenCache() { using (CreateCrossPlatLock(_storageCreationProperties)) { return(CacheStore.ReadData(ignoreExceptions: false)); } }
/// <summary> /// Before cache access /// </summary> /// <param name="args">Callback parameters from MSAL</param> internal void BeforeAccessNotification(TokenCacheNotificationArgs args) { _logger.LogInformation($"Before access"); _logger.LogInformation($"Acquiring lock for token cache"); // OK, we have two nested locks here. We need to maintain a clear ordering to avoid deadlocks. // 1. Use the CrossPlatLock which is respected by all processes and is used around all cache accesses. // 2. Use _lockObject which is used in UnregisterCache, and is needed for all accesses of _registeredCaches. CacheLock = CreateCrossPlatLock(_storageCreationProperties); _logger.LogInformation($"Before access, the store has changed"); var cachedStoreData = CacheStore.ReadData(); _logger.LogInformation($"Read '{cachedStoreData?.Length}' bytes from storage"); lock (_lockObject) { try { _logger.LogInformation($"Deserializing the store"); args.TokenCache.DeserializeMsalV3(cachedStoreData, shouldClearExistingCache: true); } catch (Exception e) { _logger.LogError($"An exception was encountered while deserializing the {nameof(MsalCacheHelper)} : {e}"); _logger.LogError($"No data found in the store, clearing the cache in memory."); // Clear the memory cache Clear(); throw; } } }
/// <summary> /// Saves an unencrypted, UTF-8 encoded byte array representing an MSAL token cache. /// The save operation will persist the data in a secure location, as configured in <see cref="StorageCreationProperties"/> /// </summary> public void SaveUnencryptedTokenCache(byte[] tokenCache) { using (CreateCrossPlatLock(_storageCreationProperties)) { CacheStore.WriteData(tokenCache, ignoreExceptions: false); } }
public void Refresh() { try { if (null != this.RefreshStart) { RefreshStart(this, new EventArgs()); } Geocache selected = SelectedCache; m_disabledOrArchivedCount = 0; m_visibleCount = 0; m_mineCount = 0; m_foundCount = 0; if (m_app.AppConfig.ImperialUnits) { m_distanceColumn.Title = Catalog.GetString("Mi"); distanceLabel.Text = Catalog.GetString("Mi"); } else { m_distanceColumn.Title = Catalog.GetString("km"); distanceLabel.Text = Catalog.GetString("km"); } UpdateStatus(); CacheStore.GlobalFilters.AddFilterCriteria(FilterList.KEY_STATUS, new bool[] { foundCheck.Active, notFoundCheck.Active, mineCheck.Active, availCheck.Active, notAvailCheck.Active, archiveCheck.Active }); cacheListTree.Model = null; if (m_list == null) { m_list = new CacheStoreModel(); } else { m_list.Clear(); } if (m_sort == null) { m_sort = new TreeModelSort(new TreeModelAdapter(m_list)); m_sort.SetSortFunc(3, TitleCompare); m_sort.SetSortFunc(2, DistanceCompare); m_sort.SetSortFunc(0, SymbolCompare); m_sort.DefaultSortFunc = DistanceCompare; } CacheStore.ReadCache += HandleCacheStoreReadCache; CacheStore.Complete += HandleCacheStoreComplete; CacheStore.GetUnfilteredCaches(m_app.CentreLat, m_app.CentreLon, m_app.OwnerIDs.ToArray()); CacheStore.ReadCache -= HandleCacheStoreReadCache; CacheStore.Complete -= HandleCacheStoreComplete; } catch (Exception e) { OCMApp.ShowException(e); } }
public void CacheStoreCanAddAnEntryWithExpirationTime() { // Arrange var keyName = "MyKeyName"; var keyValue = "MyKeyValue"; var secondsToWait = 2; // Expire Configuration Dictionary <string, TimeSpan> expirationConfiguration = new Dictionary <string, TimeSpan>() { { "MyKeyName", TimeSpan.Parse($"00:00:0{secondsToWait}") } }; // Act ICacheStore _cache = new CacheStore(_memoryCache, expirationConfiguration); _cache.Add <string>(keyName, keyValue); var cacheValue = _memoryCache.Get(keyName); Thread.Sleep(secondsToWait * 1000); var cacheValueAfterExpireTime = _memoryCache.Get <string>(keyName); // Assert Assert.NotNull(cacheValue); Assert.Equal(keyValue, cacheValue); Assert.Null(cacheValueAfterExpireTime); }
private void AddInjectionAssembly(string assemblyName) { ReflectionAssemblyResolver assemblyInjectionCode = null; if (CacheStore.Exists <ReflectionAssemblyResolver>("injection|" + assemblyName)) { assemblyInjectionCode = CacheStore.Get <ReflectionAssemblyResolver>("injection|" + assemblyName); } else { assemblyInjectionCode = new ReflectionAssemblyResolver(assemblyName); CacheStore.Add <ReflectionAssemblyResolver>("injection|" + assemblyName, assemblyInjectionCode); } var nodeAssembly = new TreeNode { Text = Path.GetFileName(assemblyName), Tag = assemblyInjectionCode }; List <Type> types = assemblyInjectionCode.FindTypes <ICInject>(); for (int i = 0; i < types.Count; i++) { OnBindInjectors(assemblyInjectionCode, types[i], nodeAssembly, true); } // don't show the assembly if it does not have any injectors if (types.Count > 0) { _rootInjection.Nodes.Add(nodeAssembly); treeInjectionCode.ExpandAll(); } _injectorAssemblyLoaded = true; SendMessageToPlugins(EventType.InjectionAssemblyLoaded, null, null, assemblyName); }
public void Configuration_NamedStore() { var conf = LaconicConfiguration.CreateFromString(CONF_SRC); using (var app = new ServiceBaseApplication(null, conf.Root)) { using (var store = new CacheStore("BANKING")) { store.Configure(null); Assert.AreEqual(789001, store.TableOptions["Account"].BucketCount); Assert.AreEqual(23, store.TableOptions["Account"].RecPerPage); Assert.AreEqual(149, store.TableOptions["Account"].LockCount); Assert.AreEqual(12000, store.TableOptions["Account"].MaxAgeSec); Assert.AreEqual(true, store.TableOptions["Account"].ParallelSweep); Assert.AreEqual(1023, store.TableOptions["BaLaNCE"].BucketCount); Assert.AreEqual(3, store.TableOptions["BaLaNCE"].RecPerPage); Assert.AreEqual(11, store.TableOptions["BaLaNCE"].LockCount); Assert.AreEqual(230000, store.TableOptions["BaLaNCE"].MaxAgeSec); Assert.AreEqual(false, store.TableOptions["BaLaNCE"].ParallelSweep); var tbl = store["AccoUNT"]; Assert.AreEqual(789001, tbl.BucketCount); Assert.AreEqual(23, tbl.RecPerPage); Assert.AreEqual(789001 * 23, tbl.Capacity); Assert.AreEqual(149, tbl.LockCount); Assert.AreEqual(12000, tbl.MaxAgeSec); Assert.AreEqual(true, tbl.ParallelSweep); } } }
public void Get_Does_Not_See_AbsoluteExpired() { using (var store = new CacheStore(null)) { var tbl1 = store["t1"]; var utcNow = App.TimeSource.UTCNow; var utcExp = utcNow.AddSeconds(5); var bo1 = new businessObject { ID = 1, Name = "Suvorov-1", IsGood = true }; Assert.IsTrue(tbl1.Put(1, bo1, maxAgeSec: int.MaxValue, absoluteExpirationUTC: utcExp)); var bo2 = new businessObject { ID = 2, Name = "Meduzer-2", IsGood = false }; Assert.IsTrue(tbl1.Put(2, bo2)); Assert.AreEqual(2, tbl1.Count); System.Threading.Thread.Sleep(15000);// this timeout depends on store sweep thread speed, 15 sec span should be enough Assert.AreEqual(1, tbl1.Count); Assert.IsNull(tbl1.Get(1)); // expired Assert.AreEqual("Meduzer-2", tbl1.Get(2).ValueAs <businessObject>().Name); //still there } }
static HomeController() { Id = 1; //Adding Intial Record CacheStore.Add(Id.ToString(), new Tutor { Id = 1, Name = "Rahul Malviya", Email = "*****@*****.**", Topics = "AngularJS Assignment", Price = 1000 }); }
public void CacheStoreCanBeCreatedByInjection() { // Arrange-Act CacheStore myCache = new CacheStore(_memoryCache); // Assert Assert.NotNull(myCache); }
public void CacheStoreCanBeCreatedWithNullParameters() { // Arrange-Act CacheStore myCache = new CacheStore(null, null); // Assert Assert.NotNull(myCache); }
private void AddTargetAssembly(string assemblyName) { MonoAssemblyResolver assemblyTarget = null; if (CacheStore.Exists <MonoAssemblyResolver>("mono|" + assemblyName)) { assemblyTarget = CacheStore.Get <MonoAssemblyResolver>("mono|" + assemblyName); } else { assemblyTarget = new MonoAssemblyResolver(assemblyName); CacheStore.Add <MonoAssemblyResolver>("mono|" + assemblyName, assemblyTarget); } // add in the dictionary if (_targetAssemblies.ContainsKey(assemblyName) == false) { _targetAssemblies.Add(assemblyName, assemblyTarget); } // attach message received event assemblyTarget.OnMessageReceived += resolver_OnMessageReceived; // add node var nodeAssembly = new TreeNode { Text = Path.GetFileName(assemblyName), Tag = new BindItem { Assembly = assemblyTarget, Method = null } }; _rootTarget.Nodes.Add(nodeAssembly); List <TypeDefinition> types = assemblyTarget.FindClasses(); for (int i = 0; i < types.Count; i++) { if (types[i].HasMethods) { var nodeClass = new TreeNode { Text = types[i].Name, Tag = types[i] }; nodeAssembly.Nodes.Add(nodeClass); OnBindMethodsDefinitions(assemblyTarget, types[i], nodeClass); } } treeTarget.CollapseAll(); _targetAssemblyLoaded = true; SendMessageToPlugins(EventType.TargetAssemblyLoaded, null, null, assemblyName); }
private void CacheTest_Load(object sender, EventArgs e) { store = new CacheStore("Test Ztore1"); store.InstrumentationEnabled = true; store.TableOptions.Register(new TableOptions(TBL, TableCapacity.Default)); //.DBServer_128GB) ); //store.TableOptions.Register( new TableOptions(TBL2, TableCapacity.M100,1024) ); //store.TableOptions.Register( new TableOptions(TBL3, TableCapacity.M100,1024) ); //store.TableOptions.Register( new TableOptions(TBL4, TableCapacity.M100,1024) ); }
/// <summary> /// Opens metabase from the specified file system instance at the specified metabase root path /// </summary> /// <param name="bootApplication">IApplication chassis which this metabank boots from</param> /// <param name="skyApplication">ISkyApplication chassis which this metabank installs in</param> /// <param name="fileSystem"> /// An instance of a file system that stores the metabase files /// Note: This file system is typically a component of Boot application, not the sky app which is being mounted. /// Metabank does NOT dispose the FS, as it is an external resource relative to metabank /// </param> /// <param name="fsSessionParams">File system connection parameter</param> /// <param name="rootPath">A path to the directory within the file system that contains metabase root data</param> internal Metabank(IApplication bootApplication, ISkyApplication skyApplication, IFileSystem fileSystem, FileSystemSessionConnectParams fsSessionParams, string rootPath) : base(bootApplication.NonNull(nameof(bootApplication))) { this.m_SkyApplication = skyApplication.NonNull(nameof(skyApplication)); if (fileSystem is LocalFileSystem && fsSessionParams == null) { fsSessionParams = new FileSystemSessionConnectParams(); } if (fileSystem == null || fsSessionParams == null) { throw new MetabaseException(StringConsts.ARGUMENT_ERROR + "Metabank.ctor(fileSystem|fsSessionParams==null)"); } using (var session = ctorFS(fileSystem, fsSessionParams, rootPath)) { m_CommonLevelConfig = getConfigFromFile(session, CONFIG_COMMON_FILE).Root; m_RootConfig = getConfigFromFile(session, CONFIG_SECTION_LEVEL_FILE).Root; includeCommonConfig(m_RootConfig); m_RootConfig.ResetModified(); m_RootAppConfig = getConfigFromFile(session, CONFIG_SECTION_LEVEL_ANY_APP_FILE).Root; m_PlatformConfig = getConfigFromFile(session, CONFIG_PLATFORMS_FILE).Root; m_NetworkConfig = getConfigFromFile(session, CONFIG_NETWORKS_FILE).Root; m_ContractConfig = getConfigFromFile(session, CONFIG_CONTRACTS_FILE).Root; } m_Catalogs = new Registry <Catalog>(); var cacheStore = new CacheStore(this, "AC.Metabank"); //No app available - nowhere to configure: //cacheStore.Configure(null); /* * cacheStore.TableOptions.Register( new TableOptions(APP_CATALOG, 37, 3) ); * cacheStore.TableOptions.Register( new TableOptions(BIN_CATALOG, 37, 7) ); * cacheStore.TableOptions.Register( new TableOptions(REG_CATALOG, 37, 17) ); * superseded by the cacheStore.DefaultTableOptions below: */ cacheStore.DefaultTableOptions = new TableOptions("*", 37, 17); //reg catalog needs more space cacheStore.TableOptions.Register(new TableOptions(REG_CATALOG, 571, 37)); cacheStore.InstrumentationEnabled = false; m_Cache = new ComplexKeyHashingStrategy(cacheStore); new AppCatalog(this); new BinCatalog(this); new SecCatalog(this); new RegCatalog(this); ConfigAttribute.Apply(this, m_RootConfig); }
static void Main(string[] args) { PersistentCache = new CacheStore<Thing>("c:\\tmp\\PersistantCache", "1", null, "00:00:10"); Console.WriteLine("Creating Data"); const int itemsToUse = 2000000; var items = GenerateList(itemsToUse, 20); items.Shuffle(); //var temp = new CacheItem[itemsToUse]; //items.CopyTo(temp); //var reversedItems = temp.Reverse().ToList(); var items2 = GenerateList(itemsToUse, 20); items2.Shuffle(); RunPersistanceCacheTest(new List<List<CacheItem>>(2) { items, items2 }); Console.ReadKey(); }
public AccountCreationServiceImpl(ChronokeeperService chronokeeperService, CacheStore<Guid, Account> accountCacheStore) { this.chronokeeperService = chronokeeperService; this.accountCacheStore = accountCacheStore; }
public ClientLogImportingServiceImpl(ChronokeeperService chronokeeperService, CacheStore<Guid, ClientLog> clientLogCacheStore, ZipArchiveToMapConverter zipArchiveToMapConverter) { this.chronokeeperService = chronokeeperService; this.clientLogCacheStore = clientLogCacheStore; this.zipArchiveToMapConverter = zipArchiveToMapConverter; }
public void Initialize() { clientLogCacheStore = new MicroLiteCacheStore<Guid, ClientLog>(platformCacheConfiguration.DatabaseSessionFactory); }
public void Initialize() { accountCacheStore = new MicroLiteCacheStore<Guid, Account>(platformCacheConfiguration.DatabaseSessionFactory); accountCache = cacheInitializer.NearCache("account-cache", accountCacheStore); accountIdByUsernameCache = cacheInitializer.NearCache<string, Guid>("account-id-by-username-cache"); accessTokenCache = cacheInitializer.NearCache<string, Guid>("access-token-cache"); }