public static void Main() { using (var ignite = Ignition.StartFromApplicationConfiguration()) { Console.WriteLine(); Console.WriteLine(">>> Optimistic transaction example started."); // Create Transactional cache. var cacheCfg = new CacheConfiguration(CacheName) { AtomicityMode = CacheAtomicityMode.Transactional }; var cache = ignite.GetOrCreateCache<int, int>(cacheCfg); // Put a value. cache[1] = 0; // Increment a value in parallel within a transaction. var task1 = Task.Factory.StartNew(() => IncrementCacheValue(cache, 1)); var task2 = Task.Factory.StartNew(() => IncrementCacheValue(cache, 2)); Task.WaitAll(task1, task2); Console.WriteLine(); Console.WriteLine(">>> Resulting value in cache: " + cache[1]); Console.WriteLine(); Console.WriteLine(">>> Example finished, press any key to exit ..."); Console.ReadKey(); } }
/// <summary> /// Initializes a new instance of the <see cref="CacheConfiguration"/> class, /// performing a deep copy of specified cache configuration. /// </summary> /// <param name="other">The other configuration to perfrom deep copy from.</param> public CacheConfiguration(CacheConfiguration other) { if (other != null) { using (var stream = IgniteManager.Memory.Allocate().GetStream()) { other.Write(BinaryUtils.Marshaller.StartMarshal(stream)); stream.SynchronizeOutput(); stream.Seek(0, SeekOrigin.Begin); Read(BinaryUtils.Marshaller.StartUnmarshal(stream)); } CopyLocalProperties(other); } }
/// <summary> /// Initializes a new instance of the <see cref="CacheConfiguration"/> class, /// performing a deep copy of specified cache configuration. /// </summary> /// <param name="other">The other configuration to perfrom deep copy from.</param> public CacheConfiguration(CacheConfiguration other) { if (other != null) { using (var stream = IgniteManager.Memory.Allocate().GetStream()) { other.Write(BinaryUtils.Marshaller.StartMarshal(stream)); stream.SynchronizeOutput(); stream.Seek(0, SeekOrigin.Begin); Read(BinaryUtils.Marshaller.StartUnmarshal(stream)); } // Plugins should be copied directly. PluginConfigurations = other.PluginConfigurations; } }
/// <summary> /// Copies the local properties (properties that are not written in Write method). /// </summary> internal void CopyLocalProperties(CacheConfiguration cfg) { Debug.Assert(cfg != null); PluginConfigurations = cfg.PluginConfigurations; if (QueryEntities != null && cfg.QueryEntities != null) { var entities = cfg.QueryEntities.Where(x => x != null).ToDictionary(x => GetQueryEntityKey(x), x => x); foreach (var entity in QueryEntities.Where(x => x != null)) { QueryEntity src; if (entities.TryGetValue(GetQueryEntityKey(entity), out src)) { entity.CopyLocalProperties(src); } } } }
public DbCache(IIgnite ignite, CacheConfiguration metaCacheConfiguration, CacheConfiguration dataCacheConfiguration) { IgniteArgumentCheck.NotNull(ignite, "ignite"); IgniteArgumentCheck.NotNull(metaCacheConfiguration, "metaCacheConfiguration"); IgniteArgumentCheck.NotNull(dataCacheConfiguration, "metaCacheConfiguration"); IgniteArgumentCheck.Ensure(metaCacheConfiguration.Name != dataCacheConfiguration.Name, "dataCacheConfiguration", "Meta and Data cache can't have the same name."); _metaCache = ignite.GetOrCreateCache<string, long>(metaCacheConfiguration); _cache = ignite.GetOrCreateCache<string, object>(dataCacheConfiguration); var metaCfg = _metaCache.GetConfiguration(); if (metaCfg.AtomicityMode != CacheAtomicityMode.Transactional) throw new IgniteException("EntityFramework meta cache should be Transactional."); if (metaCfg.CacheMode == CacheMode.Partitioned && metaCfg.Backups < 1) ignite.Logger.Warn("EntityFramework meta cache is partitioned and has no backups. " + "This can lead to data loss and incorrect query results."); }
public static void Main() { Console.WriteLine(); Console.WriteLine(">>> Multi-tiered cache example started."); // Configure swap in the current bin directory (where our assembly is located). var binDir = Path.GetDirectoryName(typeof(MultiTieredCacheExample).Assembly.Location); var swapDir = Path.Combine(binDir, "ignite-swap"); Console.WriteLine(">>> Swap space directory: " + swapDir); var cfg = new IgniteConfiguration { DiscoverySpi = new TcpDiscoverySpi { IpFinder = new TcpDiscoveryMulticastIpFinder { Endpoints = new[] { "127.0.0.1:47500" } } }, SwapSpaceSpi = new FileSwapSpaceSpi { BaseDirectory = swapDir } }; using (var ignite = Ignition.Start(cfg)) { var cacheCfg = new CacheConfiguration { Name = CacheName, Backups = 1, EvictionPolicy = new LruEvictionPolicy { MaxSize = 10 // Maximum number of entries that will be stored in Java heap. }, // Limit off-heap to roughly 10 entries. Actual entry count will be lower due to metadata overhead. OffHeapMaxMemory = EntrySize * 10, // Data will be swapped to disk if there is no more space in off-heap space. EnableSwap = true }; ICache<int, byte[]> cache = ignite.GetOrCreateCache<int, byte[]>(cacheCfg); // Sample data. byte[] dataBytes = new byte[EntrySize]; // Filling out cache and printing its metrics. PrintCacheMetrics(cache); for (int i = 0; i < 100; i++) { cache.Put(i, dataBytes); if (i%10 == 0) { Console.WriteLine(">>> Cache entries created: {0}", i + 1); PrintCacheMetrics(cache); } } Console.WriteLine(">>> Waiting for metrics final update..."); Thread.Sleep(TcpDiscoverySpi.DefaultHeartbeatFrequency); PrintCacheMetrics(cache); Console.WriteLine(); Console.WriteLine(">>> Example finished, press any key to exit ..."); Console.ReadKey(); } }
/// <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); }
/// <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> public static void InitializeIgniteCaching(DbConfiguration dbConfiguration, IIgnite ignite, CacheConfiguration metaCacheConfiguration, CacheConfiguration dataCacheConfiguration, IDbCachingPolicy policy) { IgniteArgumentCheck.NotNull(ignite, "ignite"); IgniteArgumentCheck.NotNull(dbConfiguration, "configuration"); IgniteArgumentCheck.Ensure(!(dbConfiguration is IgniteDbConfiguration), "dbConfiguration", "IgniteDbConfiguration.InitializeIgniteCaching should not be called for IgniteDbConfiguration " + "instance. This method should be used only when IgniteDbConfiguration can't be inherited."); InitializeIgniteCachingInternal(dbConfiguration, ignite, metaCacheConfiguration, dataCacheConfiguration, policy); }
public IgniteDbConfiguration(IIgnite ignite, CacheConfiguration metaCacheConfiguration, CacheConfiguration dataCacheConfiguration, IDbCachingPolicy policy) { IgniteArgumentCheck.NotNull(ignite, "ignite"); InitializeIgniteCachingInternal(this, ignite, metaCacheConfiguration, dataCacheConfiguration, policy); }
/// <summary> /// Initializes a new instance of the <see cref="IgniteDbConfiguration" /> class. /// </summary> /// <param name="igniteConfiguration">The ignite configuration to use for starting Ignite instance.</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> public IgniteDbConfiguration(IgniteConfiguration igniteConfiguration, CacheConfiguration metaCacheConfiguration, CacheConfiguration dataCacheConfiguration, IDbCachingPolicy policy) : this(GetOrStartIgnite(igniteConfiguration), metaCacheConfiguration, dataCacheConfiguration, policy) { // No-op. }
/// <summary> /// Initializes a new instance of the <see cref="IgniteDbConfiguration"/> class. /// </summary> /// <param name="configurationSectionName">Name of the configuration section.</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> public IgniteDbConfiguration(string configurationSectionName, CacheConfiguration metaCacheConfiguration, CacheConfiguration dataCacheConfiguration, IDbCachingPolicy policy) : this(GetConfiguration(configurationSectionName, true), metaCacheConfiguration, dataCacheConfiguration, policy) { // No-op. }
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)); }