http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheConfiguration.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheConfiguration.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheConfiguration.cs new file mode 100644 index 0000000..b319be9 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheConfiguration.cs @@ -0,0 +1,601 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// ReSharper disable MemberCanBePrivate.Global +// ReSharper disable UnusedMember.Global +// ReSharper disable UnusedAutoPropertyAccessor.Global +namespace Apache.Ignite.Core.Cache.Configuration +{ + using System; + using System.Collections.Generic; + using System.ComponentModel; + using System.Diagnostics.CodeAnalysis; + using System.Linq; + using Apache.Ignite.Core.Binary; + using Apache.Ignite.Core.Cache; + using Apache.Ignite.Core.Cache.Store; + using Apache.Ignite.Core.Common; + using Apache.Ignite.Core.Impl.Binary; + + /// <summary> + /// Defines grid cache configuration. + /// </summary> + public class CacheConfiguration + { + /// <summary> Default size of rebalance thread pool. </summary> + public const int DefaultRebalanceThreadPoolSize = 2; + + /// <summary> Default rebalance timeout.</summary> + public static readonly TimeSpan DefaultRebalanceTimeout = TimeSpan.FromMilliseconds(10000); + + /// <summary> Time to wait between rebalance messages to avoid overloading CPU. </summary> + public static readonly TimeSpan DefaultRebalanceThrottle = TimeSpan.Zero; + + /// <summary> Default number of backups. </summary> + public const int DefaultBackups = 0; + + /// <summary> Default caching mode. </summary> + public const CacheMode DefaultCacheMode = CacheMode.Partitioned; + + /// <summary> Default atomicity mode. </summary> + public const CacheAtomicityMode DefaultAtomicityMode = CacheAtomicityMode.Atomic; + + /// <summary> Default lock timeout. </summary> + public static readonly TimeSpan DefaultLockTimeout = TimeSpan.Zero; + + /// <summary> Initial default cache size. </summary> + public const int DefaultStartSize = 1500000; + + /// <summary> Default cache size to use with eviction policy. </summary> + public const int DefaultCacheSize = 100000; + + /// <summary> Default value for 'invalidate' flag that indicates if this is invalidation-based cache. </summary> + public const bool DefaultInvalidate = false; + + /// <summary> Default rebalance mode for distributed cache. </summary> + public const CacheRebalanceMode DefaultRebalanceMode = CacheRebalanceMode.Async; + + /// <summary> Default rebalance batch size in bytes. </summary> + public const int DefaultRebalanceBatchSize = 512*1024; // 512K + + /// <summary> Default maximum eviction queue ratio. </summary> + public const float DefaultMaxEvictionOverflowRatio = 10; + + /// <summary> Default eviction synchronized flag. </summary> + public const bool DefaultEvictSynchronized = false; + + /// <summary> Default eviction key buffer size for batching synchronized evicts. </summary> + public const int DefaultEvictSynchronizedKeyBufferSize = 1024; + + /// <summary> Default synchronous eviction timeout. </summary> + public static readonly TimeSpan DefaultEvictSynchronizedTimeout = TimeSpan.FromMilliseconds(10000); + + /// <summary> Default synchronous eviction concurrency level. </summary> + public const int DefaultEvictSynchronizedConcurrencyLevel = 4; + + /// <summary> Default value for eager ttl flag. </summary> + public const bool DefaultEagerTtl = true; + + /// <summary> Default off-heap storage size is {@code -1} which means that off-heap storage is disabled. </summary> + public const long DefaultOffHeapMaxMemory = -1; + + /// <summary> Default value for 'swapEnabled' flag. </summary> + public const bool DefaultEnableSwap = false; + + /// <summary> Default value for 'maxConcurrentAsyncOps'. </summary> + public const int DefaultMaxConcurrentAsyncOperations = 500; + + /// <summary> Default value for 'writeBehindEnabled' flag. </summary> + public const bool DefaultWriteBehindEnabled = false; + + /// <summary> Default flush size for write-behind cache store. </summary> + public const int DefaultWriteBehindFlushSize = 10240; // 10K + + /// <summary> Default flush frequency for write-behind cache store. </summary> + public static readonly TimeSpan DefaultWriteBehindFlushFrequency = TimeSpan.FromMilliseconds(5000); + + /// <summary> Default count of flush threads for write-behind cache store. </summary> + public const int DefaultWriteBehindFlushThreadCount = 1; + + /// <summary> Default batch size for write-behind cache store. </summary> + public const int DefaultWriteBehindBatchSize = 512; + + /// <summary> Default value for load previous value flag. </summary> + public const bool DefaultLoadPreviousValue = false; + + /// <summary> Default memory mode. </summary> + public const CacheMemoryMode DefaultMemoryMode = CacheMemoryMode.OnheapTiered; + + /// <summary> Default value for 'readFromBackup' flag. </summary> + public const bool DefaultReadFromBackup = true; + + /// <summary> Default timeout after which long query warning will be printed. </summary> + public static readonly TimeSpan DefaultLongQueryWarningTimeout = TimeSpan.FromMilliseconds(3000); + + /// <summary> Default size for onheap SQL row cache size. </summary> + public const int DefaultSqlOnheapRowCacheSize = 10*1024; + + /// <summary> Default value for keep portable in store behavior .</summary> + public const bool DefaultKeepVinaryInStore = true; + + /// <summary> Default value for 'copyOnRead' flag. </summary> + public const bool DefaultCopyOnRead = true; + + /// <summary> + /// Gets or sets the cache name. + /// </summary> + public string Name { get; set; } + + /// <summary> + /// Initializes a new instance of the <see cref="CacheConfiguration"/> class. + /// </summary> + public CacheConfiguration() : this((string) null) + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="CacheConfiguration"/> class. + /// </summary> + /// <param name="name">Cache name.</param> + public CacheConfiguration(string name) + { + Name = name; + + Backups = DefaultBackups; + AtomicityMode = DefaultAtomicityMode; + CacheMode = DefaultCacheMode; + CopyOnRead = DefaultCopyOnRead; + EagerTtl = DefaultEagerTtl; + EvictSynchronizedKeyBufferSize = DefaultEvictSynchronizedKeyBufferSize; + EvictSynchronized = DefaultEvictSynchronized; + EvictSynchronizedConcurrencyLevel = DefaultEvictSynchronizedConcurrencyLevel; + EvictSynchronizedTimeout = DefaultEvictSynchronizedTimeout; + Invalidate = DefaultInvalidate; + KeepBinaryInStore = DefaultKeepVinaryInStore; + LoadPreviousValue = DefaultLoadPreviousValue; + LockTimeout = DefaultLockTimeout; + LongQueryWarningTimeout = DefaultLongQueryWarningTimeout; + MaxConcurrentAsyncOperations = DefaultMaxConcurrentAsyncOperations; + MaxEvictionOverflowRatio = DefaultMaxEvictionOverflowRatio; + MemoryMode = DefaultMemoryMode; + OffHeapMaxMemory = DefaultOffHeapMaxMemory; + ReadFromBackup = DefaultReadFromBackup; + RebalanceBatchSize = DefaultRebalanceBatchSize; + RebalanceMode = DefaultRebalanceMode; + RebalanceThrottle = DefaultRebalanceThrottle; + RebalanceTimeout = DefaultRebalanceTimeout; + SqlOnheapRowCacheSize = DefaultSqlOnheapRowCacheSize; + StartSize = DefaultStartSize; + EnableSwap = DefaultEnableSwap; + WriteBehindBatchSize = DefaultWriteBehindBatchSize; + WriteBehindEnabled = DefaultWriteBehindEnabled; + WriteBehindFlushFrequency = DefaultWriteBehindFlushFrequency; + WriteBehindFlushSize = DefaultWriteBehindFlushSize; + WriteBehindFlushThreadCount= DefaultWriteBehindFlushThreadCount; + } + + /// <summary> + /// Initializes a new instance of the <see cref="CacheConfiguration"/> class + /// and populates <see cref="QueryEntities"/> according to provided query types. + /// </summary> + /// <param name="name">Cache name.</param> + /// <param name="queryTypes"> + /// Collection of types to be registered as query entities. These types should use + /// <see cref="QuerySqlFieldAttribute"/> to configure query fields and properties. + /// </param> + public CacheConfiguration(string name, params Type[] queryTypes) : this(name) + { + QueryEntities = queryTypes.Select(type => new QueryEntity {ValueType = type}).ToArray(); + } + + /// <summary> + /// Initializes a new instance of the <see cref="CacheConfiguration"/> class. + /// </summary> + /// <param name="name">Cache name.</param> + /// <param name="queryEntities">Query entities.</param> + public CacheConfiguration(string name, params QueryEntity[] queryEntities) : this(name) + { + QueryEntities = queryEntities; + } + + /// <summary> + /// Initializes a new instance of the <see cref="CacheConfiguration"/> class. + /// </summary> + /// <param name="reader">The reader.</param> + internal CacheConfiguration(IBinaryRawReader reader) + { + AtomicityMode = (CacheAtomicityMode) reader.ReadInt(); + AtomicWriteOrderMode = (CacheAtomicWriteOrderMode) reader.ReadInt(); + Backups = reader.ReadInt(); + CacheMode = (CacheMode) reader.ReadInt(); + CopyOnRead = reader.ReadBoolean(); + EagerTtl = reader.ReadBoolean(); + EnableSwap = reader.ReadBoolean(); + EvictSynchronized = reader.ReadBoolean(); + EvictSynchronizedConcurrencyLevel = reader.ReadInt(); + EvictSynchronizedKeyBufferSize = reader.ReadInt(); + EvictSynchronizedTimeout = reader.ReadLongAsTimespan(); + Invalidate = reader.ReadBoolean(); + KeepBinaryInStore = reader.ReadBoolean(); + LoadPreviousValue = reader.ReadBoolean(); + LockTimeout = reader.ReadLongAsTimespan(); + LongQueryWarningTimeout = reader.ReadLongAsTimespan(); + MaxConcurrentAsyncOperations = reader.ReadInt(); + MaxEvictionOverflowRatio = reader.ReadFloat(); + MemoryMode = (CacheMemoryMode) reader.ReadInt(); + Name = reader.ReadString(); + OffHeapMaxMemory = reader.ReadLong(); + ReadFromBackup = reader.ReadBoolean(); + RebalanceBatchSize = reader.ReadInt(); + RebalanceDelay = reader.ReadLongAsTimespan(); + RebalanceMode = (CacheRebalanceMode) reader.ReadInt(); + RebalanceThrottle = reader.ReadLongAsTimespan(); + RebalanceTimeout = reader.ReadLongAsTimespan(); + SqlEscapeAll = reader.ReadBoolean(); + SqlOnheapRowCacheSize = reader.ReadInt(); + StartSize = reader.ReadInt(); + WriteBehindBatchSize = reader.ReadInt(); + WriteBehindEnabled = reader.ReadBoolean(); + WriteBehindFlushFrequency = reader.ReadLongAsTimespan(); + WriteBehindFlushSize = reader.ReadInt(); + WriteBehindFlushThreadCount = reader.ReadInt(); + WriteSynchronizationMode = (CacheWriteSynchronizationMode) reader.ReadInt(); + CacheStoreFactory = reader.ReadObject<IFactory<ICacheStore>>(); + + var count = reader.ReadInt(); + QueryEntities = count == 0 ? null : Enumerable.Range(0, count).Select(x => new QueryEntity(reader)).ToList(); + } + + /// <summary> + /// Writes this instane to the specified writer. + /// </summary> + /// <param name="writer">The writer.</param> + internal void Write(IBinaryRawWriter writer) + { + writer.WriteInt((int) AtomicityMode); + writer.WriteInt((int) AtomicWriteOrderMode); + writer.WriteInt(Backups); + writer.WriteInt((int) CacheMode); + writer.WriteBoolean(CopyOnRead); + writer.WriteBoolean(EagerTtl); + writer.WriteBoolean(EnableSwap); + writer.WriteBoolean(EvictSynchronized); + writer.WriteInt(EvictSynchronizedConcurrencyLevel); + writer.WriteInt(EvictSynchronizedKeyBufferSize); + writer.WriteLong((long) EvictSynchronizedTimeout.TotalMilliseconds); + writer.WriteBoolean(Invalidate); + writer.WriteBoolean(KeepBinaryInStore); + writer.WriteBoolean(LoadPreviousValue); + writer.WriteLong((long) LockTimeout.TotalMilliseconds); + writer.WriteLong((long) LongQueryWarningTimeout.TotalMilliseconds); + writer.WriteInt(MaxConcurrentAsyncOperations); + writer.WriteFloat(MaxEvictionOverflowRatio); + writer.WriteInt((int) MemoryMode); + writer.WriteString(Name); + writer.WriteLong(OffHeapMaxMemory); + writer.WriteBoolean(ReadFromBackup); + writer.WriteInt(RebalanceBatchSize); + writer.WriteLong((long) RebalanceDelay.TotalMilliseconds); + writer.WriteInt((int) RebalanceMode); + writer.WriteLong((long) RebalanceThrottle.TotalMilliseconds); + writer.WriteLong((long) RebalanceTimeout.TotalMilliseconds); + writer.WriteBoolean(SqlEscapeAll); + writer.WriteInt(SqlOnheapRowCacheSize); + writer.WriteInt(StartSize); + writer.WriteInt(WriteBehindBatchSize); + writer.WriteBoolean(WriteBehindEnabled); + writer.WriteLong((long) WriteBehindFlushFrequency.TotalMilliseconds); + writer.WriteInt(WriteBehindFlushSize); + writer.WriteInt(WriteBehindFlushThreadCount); + writer.WriteInt((int) WriteSynchronizationMode); + writer.WriteObject(CacheStoreFactory); + + if (QueryEntities != null) + { + writer.WriteInt(QueryEntities.Count); + + foreach (var entity in QueryEntities) + { + if (entity == null) + throw new InvalidOperationException("Invalid cache configuration: QueryEntity can't be null."); + + entity.Write(writer); + } + } + else + writer.WriteInt(0); + } + + /// <summary> + /// Gets or sets write synchronization mode. This mode controls whether the main + /// caller should wait for update on other nodes to complete or not. + /// </summary> + public CacheWriteSynchronizationMode WriteSynchronizationMode { get; set; } + + /// <summary> + /// Gets or sets flag indicating whether eviction is synchronized between primary, backup and near nodes. + /// If this parameter is true and swap is disabled then <see cref="ICache{TK,TV}.LocalEvict"/> + /// will involve all nodes where an entry is kept. + /// If this property is set to false then eviction is done independently on different cache nodes. + /// Note that it's not recommended to set this value to true if cache store is configured since it will allow + /// to significantly improve cache performance. + /// </summary> + [DefaultValue(DefaultEvictSynchronized)] + public bool EvictSynchronized { get; set; } + + /// <summary> + /// Gets or sets size of the key buffer for synchronized evictions. + /// </summary> + [DefaultValue(DefaultEvictSynchronizedKeyBufferSize)] + public int EvictSynchronizedKeyBufferSize { get; set; } + + /// <summary> + /// Gets or sets concurrency level for synchronized evictions. + /// This flag only makes sense with <see cref="EvictSynchronized"/> set to true. + /// When synchronized evictions are enabled, it is possible that local eviction policy will try + /// to evict entries faster than evictions can be synchronized with backup or near nodes. + /// This value specifies how many concurrent synchronous eviction sessions should be allowed + /// before the system is forced to wait and let synchronous evictions catch up with the eviction policy. + /// </summary> + [DefaultValue(DefaultEvictSynchronizedConcurrencyLevel)] + public int EvictSynchronizedConcurrencyLevel { get; set; } + + /// <summary> + /// Gets or sets timeout for synchronized evictions + /// </summary> + [DefaultValue(typeof(TimeSpan), "00:00:10")] + public TimeSpan EvictSynchronizedTimeout { get; set; } + + /// <summary> + /// This value denotes the maximum size of eviction queue in percents of cache size + /// in case of distributed cache (replicated and partitioned) and using synchronized eviction + /// <para/> + /// That queue is used internally as a buffer to decrease network costs for synchronized eviction. + /// Once queue size reaches specified value all required requests for all entries in the queue + /// are sent to remote nodes and the queue is cleared. + /// </summary> + [DefaultValue(DefaultMaxEvictionOverflowRatio)] + public float MaxEvictionOverflowRatio { get; set; } + + /// <summary> + /// Gets or sets flag indicating whether expired cache entries will be eagerly removed from cache. + /// When set to false, expired entries will be removed on next entry access. + /// </summary> + [DefaultValue(DefaultEagerTtl)] + public bool EagerTtl { get; set; } + + /// <summary> + /// Gets or sets initial cache size which will be used to pre-create internal hash table after start. + /// </summary> + [DefaultValue(DefaultStartSize)] + public int StartSize { get; set; } + + /// <summary> + /// Gets or sets flag indicating whether value should be loaded from store if it is not in the cache + /// for the following cache operations: + /// <list type="bullet"> + /// <item><term><see cref="ICache{TK,TV}.PutIfAbsent"/></term></item> + /// <item><term><see cref="ICache{TK,TV}.Replace(TK,TV)"/></term></item> + /// <item><term><see cref="ICache{TK,TV}.Remove(TK)"/></term></item> + /// <item><term><see cref="ICache{TK,TV}.GetAndPut"/></term></item> + /// <item><term><see cref="ICache{TK,TV}.GetAndRemove"/></term></item> + /// <item><term><see cref="ICache{TK,TV}.GetAndReplace"/></term></item> + /// <item><term><see cref="ICache{TK,TV}.GetAndPutIfAbsent"/></term></item> + /// </list> + /// </summary> + [DefaultValue(DefaultLoadPreviousValue)] + public bool LoadPreviousValue { get; set; } + + /// <summary> + /// Gets or sets the flag indicating whether <see cref="ICacheStore"/> is working with binary objects + /// instead of deserialized objects. + /// </summary> + [DefaultValue(DefaultKeepVinaryInStore)] + public bool KeepBinaryInStore { get; set; } + + /// <summary> + /// Gets or sets caching mode to use. + /// </summary> + [DefaultValue(DefaultCacheMode)] + public CacheMode CacheMode { get; set; } + + /// <summary> + /// Gets or sets cache atomicity mode. + /// </summary> + [DefaultValue(DefaultAtomicityMode)] + public CacheAtomicityMode AtomicityMode { get; set; } + + /// <summary> + /// Gets or sets cache write ordering mode. + /// </summary> + public CacheAtomicWriteOrderMode AtomicWriteOrderMode { get; set; } + + /// <summary> + /// Gets or sets number of nodes used to back up single partition for + /// <see cref="Configuration.CacheMode.Partitioned"/> cache. + /// </summary> + [DefaultValue(DefaultBackups)] + public int Backups { get; set; } + + /// <summary> + /// Gets or sets default lock acquisition timeout. + /// </summary> + [DefaultValue(typeof(TimeSpan), "00:00:00")] + public TimeSpan LockTimeout { get; set; } + + /// <summary> + /// Invalidation flag. If true, values will be invalidated (nullified) upon commit in near cache. + /// </summary> + [DefaultValue(DefaultInvalidate)] + public bool Invalidate { get; set; } + + /// <summary> + /// Gets or sets cache rebalance mode. + /// </summary> + [DefaultValue(DefaultRebalanceMode)] + public CacheRebalanceMode RebalanceMode { get; set; } + + /// <summary> + /// Gets or sets size (in number bytes) to be loaded within a single rebalance message. + /// Rebalancing algorithm will split total data set on every node into multiple batches prior to sending data. + /// </summary> + [DefaultValue(DefaultRebalanceBatchSize)] + public int RebalanceBatchSize { get; set; } + + /// <summary> + /// Flag indicating whether Ignite should use swap storage by default. + /// </summary> + [DefaultValue(DefaultEnableSwap)] + public bool EnableSwap { get; set; } + + /// <summary> + /// Gets or sets maximum number of allowed concurrent asynchronous operations, 0 for unlimited. + /// </summary> + [DefaultValue(DefaultMaxConcurrentAsyncOperations)] + public int MaxConcurrentAsyncOperations { get; set; } + + /// <summary> + /// Flag indicating whether Ignite should use write-behind behaviour for the cache store. + /// </summary> + [DefaultValue(DefaultWriteBehindEnabled)] + public bool WriteBehindEnabled { get; set; } + + /// <summary> + /// Maximum size of the write-behind cache. If cache size exceeds this value, all cached items are flushed + /// to the cache store and write cache is cleared. + /// </summary> + [DefaultValue(DefaultWriteBehindFlushSize)] + public int WriteBehindFlushSize { get; set; } + + /// <summary> + /// Frequency with which write-behind cache is flushed to the cache store. + /// This value defines the maximum time interval between object insertion/deletion from the cache + /// at the moment when corresponding operation is applied to the cache store. + /// <para/> + /// If this value is 0, then flush is performed according to the flush size. + /// <para/> + /// Note that you cannot set both + /// <see cref="WriteBehindFlushSize"/> and <see cref="WriteBehindFlushFrequency"/> to 0. + /// </summary> + [DefaultValue(typeof(TimeSpan), "00:00:05")] + public TimeSpan WriteBehindFlushFrequency { get; set; } + + /// <summary> + /// Number of threads that will perform cache flushing. Cache flushing is performed when cache size exceeds + /// value defined by <see cref="WriteBehindFlushSize"/>, or flush interval defined by + /// <see cref="WriteBehindFlushFrequency"/> is elapsed. + /// </summary> + [DefaultValue(DefaultWriteBehindFlushThreadCount)] + public int WriteBehindFlushThreadCount { get; set; } + + /// <summary> + /// Maximum batch size for write-behind cache store operations. + /// Store operations (get or remove) are combined in a batch of this size to be passed to + /// <see cref="ICacheStore.WriteAll"/> or <see cref="ICacheStore.DeleteAll"/> methods. + /// </summary> + [DefaultValue(DefaultWriteBehindBatchSize)] + public int WriteBehindBatchSize { get; set; } + + /// <summary> + /// Gets or sets rebalance timeout. + /// </summary> + [DefaultValue(typeof(TimeSpan), "00:00:10")] + public TimeSpan RebalanceTimeout { get; set; } + + /// <summary> + /// Gets or sets delay upon a node joining or leaving topology (or crash) + /// after which rebalancing should be started automatically. + /// Rebalancing should be delayed if you plan to restart nodes + /// after they leave topology, or if you plan to start multiple nodes at once or one after another + /// and don't want to repartition and rebalance until all nodes are started. + /// </summary> + public TimeSpan RebalanceDelay { get; set; } + + /// <summary> + /// Time to wait between rebalance messages to avoid overloading of CPU or network. + /// When rebalancing large data sets, the CPU or network can get over-consumed with rebalancing messages, + /// which consecutively may slow down the application performance. This parameter helps tune + /// the amount of time to wait between rebalance messages to make sure that rebalancing process + /// does not have any negative performance impact. Note that application will continue to work + /// properly while rebalancing is still in progress. + /// <para/> + /// Value of 0 means that throttling is disabled. + /// </summary> + public TimeSpan RebalanceThrottle { get; set; } + + /// <summary> + /// Gets or sets maximum amount of memory available to off-heap storage. Possible values are + /// -1 means that off-heap storage is disabled. 0 means that Ignite will not limit off-heap storage + /// (it's up to user to properly add and remove entries from cache to ensure that off-heap storage + /// does not grow indefinitely. + /// Any positive value specifies the limit of off-heap storage in bytes. + /// </summary> + [DefaultValue(DefaultOffHeapMaxMemory)] + public long OffHeapMaxMemory { get; set; } + + /// <summary> + /// Gets or sets memory mode for cache. + /// </summary> + [DefaultValue(DefaultMemoryMode)] + public CacheMemoryMode MemoryMode { get; set; } + + /// <summary> + /// Gets or sets flag indicating whether data can be read from backup. + /// </summary> + [DefaultValue(DefaultReadFromBackup)] + public bool ReadFromBackup { get; set; } + + /// <summary> + /// Gets or sets flag indicating whether copy of of the value stored in cache should be created + /// for cache operation implying return value. + /// </summary> + [DefaultValue(DefaultCopyOnRead)] + public bool CopyOnRead { get; set; } + + /// <summary> + /// Gets or sets the timeout after which long query warning will be printed. + /// </summary> + [DefaultValue(typeof(TimeSpan), "00:00:03")] + public TimeSpan LongQueryWarningTimeout { get; set; } + + /// <summary> + /// If true all the SQL table and field names will be escaped with double quotes like + /// ({ "tableName"."fieldsName"}). This enforces case sensitivity for field names and + /// also allows having special characters in table and field names. + /// </summary> + public bool SqlEscapeAll { get; set; } + + /// <summary> + /// Number of SQL rows which will be cached onheap to avoid deserialization on each SQL index access. + /// This setting only makes sense when offheap is enabled for this cache. + /// </summary> + [DefaultValue(DefaultSqlOnheapRowCacheSize)] + public int SqlOnheapRowCacheSize { get; set; } + + /// <summary> + /// Gets or sets the factory for underlying persistent storage for read-through and write-through operations. + /// </summary> + public IFactory<ICacheStore> CacheStoreFactory { get; set; } + + /// <summary> + /// Gets or sets the query entity configuration. + /// </summary> + [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] + public ICollection<QueryEntity> QueryEntities { get; set; } + } +}
http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMemoryMode.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMemoryMode.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMemoryMode.cs new file mode 100644 index 0000000..a072302 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMemoryMode.cs @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + /// <summary> + /// Memory modes define whether cache entries are stored on heap memory, offheap memory, or in swap space. + /// </summary> + public enum CacheMemoryMode + { + /// <summary> + /// Entries will be stored on-heap first. The onheap tiered storage works as follows: + /// <list type="bullet"> + /// <item><description> + /// Entries are cached on heap memory first. + /// </description></item> + /// <item><description> + /// If offheap memory is enabled and eviction policy evicts an entry from heap memory, + /// entry will be moved to offheap memory. If offheap memory is disabled, then entry is simply discarded. + /// </description></item> + /// <item><description> + /// If swap space is enabled and offheap memory fills up, then entry will be evicted into swap space. + /// If swap space is disabled, then entry will be discarded. If swap is enabled and offheap memory is disabled, + /// then entry will be evicted directly from heap memory into swap. + /// </description></item> + /// </list> + /// <para /> + /// Note that heap memory evictions are handled by configured EvictionPolicy implementation. By default, + /// no eviction policy is enabled, so entries never leave heap memory space unless explicitly removed. + /// </summary> + OnheapTiered, + + /// <summary> + /// Works the same as <see cref="OnheapTiered"/>, except that entries never end up in heap memory and get + /// stored in offheap memory right away. Entries get cached in offheap memory first and then + /// get evicted to swap, if one is configured. + /// </summary> + OffheapTiered, + + /// <summary> + /// Entry keys will be stored on heap memory, and values will be stored in offheap memory. + /// Note that in this mode entries can be evicted only to swap. + /// </summary> + OffheapValues + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMode.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMode.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMode.cs new file mode 100644 index 0000000..6608354 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheMode.cs @@ -0,0 +1,52 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + /// <summary> + /// Caching modes. + /// </summary> + public enum CacheMode + { + /// <summary> + /// Specifies local-only cache behaviour. In this mode caches residing on + /// different grid nodes will not know about each other. + /// <para /> + /// Other than distribution, <see cref="Local"/> caches still have all + /// the caching features, such as eviction, expiration, swapping, + /// querying, etc... This mode is very useful when caching read-only data + /// or data that automatically expires at a certain interval and + /// then automatically reloaded from persistence store. + /// </summary> + Local, + + /// <summary> + /// Specifies fully replicated cache behavior. In this mode all the keys are distributed + /// to all participating nodes. + /// </summary> + Replicated, + + /// <summary> + /// Specifies partitioned cache behaviour. In this mode the overall + /// key set will be divided into partitions and all partitions will be split + /// equally between participating nodes. + /// <para /> + /// Note that partitioned cache is always fronted by local 'near' cache which stores most recent data. + /// </summary> + Partitioned + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheRebalanceMode.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheRebalanceMode.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheRebalanceMode.cs new file mode 100644 index 0000000..2ef2115 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheRebalanceMode.cs @@ -0,0 +1,51 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + /// <summary> + /// Cache rebalance mode. When rebalancing is enabled (i.e. has value other than <see cref="None"/>), + /// distributed caches will attempt to rebalance all necessary values from other grid nodes. + /// <para /> + /// Replicated caches will try to load the full set of cache entries from other nodes, + /// while partitioned caches will only load the entries for which current node is primary or backup. + /// <para /> + /// Note that rebalance mode only makes sense for <see cref="CacheMode.Replicated"/> + /// and <see cref="CacheMode.Partitioned"/> caches. Caches with <see cref="CacheMode.Local"/> + /// mode are local by definition and therefore cannot rebalance any values from neighboring nodes. + /// </summary> + public enum CacheRebalanceMode + { + /// <summary> + /// Synchronous rebalance mode. Distributed caches will not start until all necessary data + /// is loaded from other available grid nodes. + /// </summary> + Sync, + + /// <summary> + /// Asynchronous rebalance mode. Distributed caches will start immediately and will load all necessary + /// data from other available grid nodes in the background. + /// </summary> + Async, + + /// <summary> + /// In this mode no rebalancing will take place which means that caches will be either loaded on + /// demand from persistent store whenever data is accessed, or will be populated explicitly. + /// </summary> + None + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheWriteSynchronizationMode.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheWriteSynchronizationMode.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheWriteSynchronizationMode.cs new file mode 100644 index 0000000..3257f15 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/CacheWriteSynchronizationMode.cs @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + /// <summary> + /// Mode indicating how Ignite should wait for write replies from other nodes. + /// </summary> + public enum CacheWriteSynchronizationMode + { + /// <summary> + /// Mode indicating that Ignite should wait for write or commit replies from all nodes. + /// This behavior guarantees that whenever any of the atomic or transactional writes + /// complete, all other participating nodes which cache the written data have been updated. + /// </summary> + FullSync, + + /// <summary> + /// Flag indicating that Ignite will not wait for write or commit responses from participating nodes, + /// which means that remote nodes may get their state updated a bit after any of the cache write methods + /// complete, or after {@link Transaction#commit()} method completes. + /// </summary> + FullAsync, + + /// <summary> + /// This flag only makes sense for {@link CacheMode#PARTITIONED} mode. When enabled, Ignite will wait + /// for write or commit to complete on primary node, but will not wait for backups to be updated. + /// </summary> + PrimarySync + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryAlias.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryAlias.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryAlias.cs new file mode 100644 index 0000000..33849c7 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryAlias.cs @@ -0,0 +1,59 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + using Apache.Ignite.Core.Impl.Common; + + /// <summary> + /// Represents cache query configuration alias. + /// </summary> + public class QueryAlias + { + /// <summary> + /// Initializes a new instance of the <see cref="QueryAlias"/> class. + /// </summary> + public QueryAlias() + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryAlias"/> class. + /// </summary> + /// <param name="fullName">The full name.</param> + /// <param name="alias">The alias.</param> + public QueryAlias(string fullName, string alias) + { + IgniteArgumentCheck.NotNullOrEmpty(fullName, "fullName"); + IgniteArgumentCheck.NotNullOrEmpty(alias, "alias"); + + FullName = fullName; + Alias = alias; + } + + /// <summary> + /// Gets or sets the full name of the query field. + /// </summary> + public string FullName { get; set; } + + /// <summary> + /// Gets or sets the alias for the full name. + /// </summary> + public string Alias { get; set; } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs new file mode 100644 index 0000000..4151540 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs @@ -0,0 +1,401 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// ReSharper disable UnusedAutoPropertyAccessor.Global +// ReSharper disable MemberCanBePrivate.Global +namespace Apache.Ignite.Core.Cache.Configuration +{ + using System; + using System.Collections.Generic; + using System.Diagnostics; + using System.Diagnostics.CodeAnalysis; + using System.Linq; + using System.Reflection; + using Apache.Ignite.Core.Binary; + using Apache.Ignite.Core.Impl.Binary; + + /// <summary> + /// Query entity is a description of cache entry (composed of key and value) + /// in a way of how it must be indexed and can be queried. + /// </summary> + public class QueryEntity + { + /** */ + private Type _keyType; + + /** */ + private Type _valueType; + + /** */ + private string _valueTypeName; + + /** */ + private string _keyTypeName; + + /// <summary> + /// Initializes a new instance of the <see cref="QueryEntity"/> class. + /// </summary> + public QueryEntity() + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryEntity"/> class. + /// </summary> + /// <param name="valueType">Type of the cache entry value.</param> + public QueryEntity(Type valueType) + { + ValueType = valueType; + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryEntity"/> class. + /// </summary> + /// <param name="keyType">Type of the key.</param> + /// <param name="valueType">Type of the value.</param> + public QueryEntity(Type keyType, Type valueType) + { + KeyType = keyType; + ValueType = valueType; + } + + /// <summary> + /// Gets or sets key Java type name. + /// </summary> + public string KeyTypeName + { + get { return _keyTypeName; } + set + { + _keyTypeName = value; + _keyType = null; + } + } + + /// <summary> + /// Gets or sets the type of the key. + /// <para /> + /// This is a shortcut for <see cref="KeyTypeName"/>. Getter will return null for non-primitive types. + /// <para /> + /// Setting this property will overwrite <see cref="Fields"/> and <see cref="Indexes"/> according to + /// <see cref="QuerySqlFieldAttribute"/>, if any. + /// </summary> + public Type KeyType + { + get { return _keyType ?? JavaTypes.GetDotNetType(KeyTypeName); } + set + { + RescanAttributes(value, _valueType); // Do this first because it can throw + + KeyTypeName = value == null + ? null + : (JavaTypes.GetJavaTypeName(value) ?? BinaryUtils.GetTypeName(value)); + + _keyType = value; + } + } + + /// <summary> + /// Gets or sets value Java type name. + /// </summary> + public string ValueTypeName + { + get { return _valueTypeName; } + set + { + _valueTypeName = value; + _valueType = null; + } + } + + /// <summary> + /// Gets or sets the type of the value. + /// <para /> + /// This is a shortcut for <see cref="ValueTypeName"/>. Getter will return null for non-primitive types. + /// <para /> + /// Setting this property will overwrite <see cref="Fields"/> and <see cref="Indexes"/> according to + /// <see cref="QuerySqlFieldAttribute"/>, if any. + /// </summary> + public Type ValueType + { + get { return _valueType ?? JavaTypes.GetDotNetType(ValueTypeName); } + set + { + RescanAttributes(_keyType, value); // Do this first because it can throw + + ValueTypeName = value == null + ? null + : (JavaTypes.GetJavaTypeName(value) ?? BinaryUtils.GetTypeName(value)); + + _valueType = value; + } + } + + /// <summary> + /// Gets or sets query fields, a map from field name to Java type name. + /// The order of fields defines the order of columns returned by the 'select *' queries. + /// </summary> + [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] + public ICollection<QueryField> Fields { get; set; } + + /// <summary> + /// Gets or sets field name aliases: mapping from full name in dot notation to an alias + /// that will be used as SQL column name. + /// Example: {"parent.name" -> "parentName"}. + /// </summary> + [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] + public ICollection<QueryAlias> Aliases { get; set; } + + /// <summary> + /// Gets or sets the query indexes. + /// </summary> + [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] + public ICollection<QueryIndex> Indexes { get; set; } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryEntity"/> class. + /// </summary> + /// <param name="reader">The reader.</param> + internal QueryEntity(IBinaryRawReader reader) + { + KeyTypeName = reader.ReadString(); + ValueTypeName = reader.ReadString(); + + var count = reader.ReadInt(); + Fields = count == 0 ? null : Enumerable.Range(0, count).Select(x => + new QueryField(reader.ReadString(), reader.ReadString())).ToList(); + + count = reader.ReadInt(); + Aliases = count == 0 ? null : Enumerable.Range(0, count) + .Select(x=> new QueryAlias(reader.ReadString(), reader.ReadString())).ToList(); + + count = reader.ReadInt(); + Indexes = count == 0 ? null : Enumerable.Range(0, count).Select(x => new QueryIndex(reader)).ToList(); + } + + /// <summary> + /// Writes this instance. + /// </summary> + internal void Write(IBinaryRawWriter writer) + { + writer.WriteString(KeyTypeName); + writer.WriteString(ValueTypeName); + + if (Fields != null) + { + writer.WriteInt(Fields.Count); + + foreach (var field in Fields) + { + writer.WriteString(field.Name); + writer.WriteString(field.FieldTypeName); + } + } + else + writer.WriteInt(0); + + + if (Aliases != null) + { + writer.WriteInt(Aliases.Count); + + foreach (var queryAlias in Aliases) + { + writer.WriteString(queryAlias.FullName); + writer.WriteString(queryAlias.Alias); + } + } + else + writer.WriteInt(0); + + if (Indexes != null) + { + writer.WriteInt(Indexes.Count); + + foreach (var index in Indexes) + { + if (index == null) + throw new InvalidOperationException("Invalid cache configuration: QueryIndex can't be null."); + + index.Write(writer); + } + } + else + writer.WriteInt(0); + } + + + /// <summary> + /// Rescans the attributes in <see cref="KeyType"/> and <see cref="ValueType"/>. + /// </summary> + private void RescanAttributes(params Type[] types) + { + if (types.Length == 0 || types.All(t => t == null)) + return; + + var fields = new List<QueryField>(); + var indexes = new List<QueryIndexEx>(); + + foreach (var type in types.Where(t => t != null)) + ScanAttributes(type, fields, indexes, null, new HashSet<Type>()); + + if (fields.Any()) + Fields = fields; + + if (indexes.Any()) + Indexes = GetGroupIndexes(indexes).ToArray(); + } + + /// <summary> + /// Gets the group indexes. + /// </summary> + /// <param name="indexes">Ungrouped indexes with their group names.</param> + /// <returns></returns> + private static IEnumerable<QueryIndex> GetGroupIndexes(List<QueryIndexEx> indexes) + { + return indexes.Where(idx => idx.IndexGroups != null) + .SelectMany(idx => idx.IndexGroups.Select(g => new {Index = idx, GroupName = g})) + .GroupBy(x => x.GroupName) + .Select(g => + { + var idxs = g.Select(pair => pair.Index).ToArray(); + + var first = idxs.First(); + + return new QueryIndex(idxs.SelectMany(i => i.Fields).ToArray()) + { + IndexType = first.IndexType, + Name = first.Name + }; + }) + .Concat(indexes.Where(idx => idx.IndexGroups == null)); + } + + /// <summary> + /// Scans specified type for occurences of <see cref="QuerySqlFieldAttribute"/>. + /// </summary> + /// <param name="type">The type.</param> + /// <param name="fields">The fields.</param> + /// <param name="indexes">The indexes.</param> + /// <param name="parentPropName">Name of the parent property.</param> + /// <param name="visitedTypes">The visited types.</param> + private static void ScanAttributes(Type type, List<QueryField> fields, List<QueryIndexEx> indexes, + string parentPropName, ISet<Type> visitedTypes) + { + Debug.Assert(type != null); + Debug.Assert(fields != null); + Debug.Assert(indexes != null); + + if (visitedTypes.Contains(type)) + throw new InvalidOperationException("Recursive Query Field definition detected: " + type); + + visitedTypes.Add(type); + + foreach (var memberInfo in GetFieldsAndProperties(type)) + { + var customAttributes = memberInfo.Key.GetCustomAttributes(true); + + foreach (var attr in customAttributes.OfType<QuerySqlFieldAttribute>()) + { + var columnName = attr.Name ?? memberInfo.Key.Name; + + // Dot notation is required for nested SQL fields + if (parentPropName != null) + columnName = parentPropName + "." + columnName; + + fields.Add(new QueryField(columnName, memberInfo.Value)); + + if (attr.IsIndexed) + indexes.Add(new QueryIndexEx(columnName, attr.IsDescending, QueryIndexType.Sorted, + attr.IndexGroups)); + + ScanAttributes(memberInfo.Value, fields, indexes, columnName, visitedTypes); + } + + foreach (var attr in customAttributes.OfType<QueryTextFieldAttribute>()) + { + var columnName = attr.Name ?? memberInfo.Key.Name; + + // No dot notation for FullText index names + indexes.Add(new QueryIndexEx(columnName, false, QueryIndexType.FullText, null)); + + if (parentPropName != null) + columnName = parentPropName + "." + columnName; + + fields.Add(new QueryField(columnName, memberInfo.Value)); + + ScanAttributes(memberInfo.Value, fields, indexes, columnName, visitedTypes); + } + } + + visitedTypes.Remove(type); + } + + /// <summary> + /// Gets the fields and properties. + /// </summary> + /// <param name="type">The type.</param> + /// <returns></returns> + private static IEnumerable<KeyValuePair<MemberInfo, Type>> GetFieldsAndProperties(Type type) + { + Debug.Assert(type != null); + + if (type.IsPrimitive) + yield break; + + var bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | + BindingFlags.DeclaredOnly; + + while (type != typeof (object) && type != null) + { + foreach (var fieldInfo in type.GetFields(bindingFlags)) + yield return new KeyValuePair<MemberInfo, Type>(fieldInfo, fieldInfo.FieldType); + + foreach (var propertyInfo in type.GetProperties(bindingFlags)) + yield return new KeyValuePair<MemberInfo, Type>(propertyInfo, propertyInfo.PropertyType); + + type = type.BaseType; + } + } + + /// <summary> + /// Extended index with group names. + /// </summary> + private class QueryIndexEx : QueryIndex + { + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndexEx"/> class. + /// </summary> + /// <param name="fieldName">Name of the field.</param> + /// <param name="isDescending">if set to <c>true</c> [is descending].</param> + /// <param name="indexType">Type of the index.</param> + /// <param name="groups">The groups.</param> + public QueryIndexEx(string fieldName, bool isDescending, QueryIndexType indexType, + ICollection<string> groups) + : base(isDescending, indexType, fieldName) + { + IndexGroups = groups; + } + + /// <summary> + /// Gets or sets the index groups. + /// </summary> + public ICollection<string> IndexGroups { get; set; } + } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs new file mode 100644 index 0000000..8c70a29 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs @@ -0,0 +1,109 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// ReSharper disable UnusedAutoPropertyAccessor.Global +// ReSharper disable MemberCanBePrivate.Global +namespace Apache.Ignite.Core.Cache.Configuration +{ + using System; + using Apache.Ignite.Core.Impl.Binary; + using Apache.Ignite.Core.Impl.Common; + + /// <summary> + /// Represents a queryable field. + /// </summary> + public class QueryField + { + /** */ + private Type _type; + + /** */ + private string _fieldTypeName; + + /// <summary> + /// Initializes a new instance of the <see cref="QueryField"/> class. + /// </summary> + public QueryField() + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryField"/> class. + /// </summary> + /// <param name="name">Name.</param> + /// <param name="javaFieldTypeName">Java type name.</param> + public QueryField(string name, string javaFieldTypeName) + { + IgniteArgumentCheck.NotNullOrEmpty(name, "name"); + IgniteArgumentCheck.NotNullOrEmpty(javaFieldTypeName, "typeName"); + + Name = name; + FieldTypeName = javaFieldTypeName; + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryField" /> class. + /// </summary> + /// <param name="name">Name.</param> + /// <param name="fieldType">Type.</param> + public QueryField(string name, Type fieldType) + { + IgniteArgumentCheck.NotNullOrEmpty(name, "name"); + IgniteArgumentCheck.NotNull(fieldType, "type"); + + Name = name; + FieldType = fieldType; + } + + /// <summary> + /// Gets the field name. + /// </summary> + public string Name { get; set; } + + /// <summary> + /// Gets or sets the type of the value. + /// <para /> + /// This is a shortcut for <see cref="FieldTypeName"/>. Getter will return null for non-primitive types. + /// </summary> + public Type FieldType + { + get { return _type ?? JavaTypes.GetDotNetType(FieldTypeName); } + set + { + FieldTypeName = value == null + ? null + : (JavaTypes.GetJavaTypeName(value) ?? BinaryUtils.GetTypeName(value)); + + _type = value; + } + } + + /// <summary> + /// Gets the Java type name. + /// </summary> + public string FieldTypeName + { + get { return _fieldTypeName; } + set + { + _fieldTypeName = value; + _type = null; + } + } + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndex.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndex.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndex.cs new file mode 100644 index 0000000..7079606 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndex.cs @@ -0,0 +1,137 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// ReSharper disable UnusedMember.Global +namespace Apache.Ignite.Core.Cache.Configuration +{ + using System; + using System.Collections.Generic; + using System.Linq; + using Apache.Ignite.Core.Binary; + + /// <summary> + /// Represents cache query index configuration. + /// </summary> + public class QueryIndex + { + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndex"/> class. + /// </summary> + public QueryIndex() + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndex" /> class. + /// </summary> + /// <param name="fieldNames">Names of the fields to index.</param> + public QueryIndex(params string[] fieldNames) : this(false, fieldNames) + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndex" /> class. + /// </summary> + /// <param name="isDescending">Sort direction.</param> + /// <param name="fieldNames">Names of the fields to index.</param> + public QueryIndex(bool isDescending, params string[] fieldNames) + { + Fields = fieldNames.Select(f => new QueryIndexField(f, isDescending)).ToArray(); + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndex" /> class. + /// </summary> + /// <param name="isDescending">Sort direction.</param> + /// <param name="indexType">Type of the index.</param> + /// <param name="fieldNames">Names of the fields to index.</param> + public QueryIndex(bool isDescending, QueryIndexType indexType, params string[] fieldNames) + : this(isDescending, fieldNames) + { + IndexType = indexType; + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndex"/> class. + /// </summary> + /// <param name="fields">The fields.</param> + public QueryIndex(params QueryIndexField[] fields) + { + if (fields == null || fields.Length == 0) + throw new ArgumentException("Query index must have at least one field"); + + if (fields.Any(f => f == null)) + throw new ArgumentException("IndexField cannot be null."); + + Fields = fields; + } + + /// <summary> + /// Gets or sets the index name. + /// Will be set automatically if not specified. + /// </summary> + public string Name { get; set; } + + /// <summary> + /// Gets or sets the type of the index. + /// </summary> + public QueryIndexType IndexType { get; set; } + + /// <summary> + /// Gets or sets a collection of fields to be indexed. + /// </summary> + public ICollection<QueryIndexField> Fields { get; private set; } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndex"/> class. + /// </summary> + /// <param name="reader">The reader.</param> + internal QueryIndex(IBinaryRawReader reader) + { + Name = reader.ReadString(); + IndexType = (QueryIndexType) reader.ReadByte(); + + var count = reader.ReadInt(); + Fields = count == 0 ? null : Enumerable.Range(0, count).Select(x => + new QueryIndexField(reader.ReadString(), reader.ReadBoolean())).ToList(); + } + + /// <summary> + /// Writes this instance. + /// </summary> + internal void Write(IBinaryRawWriter writer) + { + writer.WriteString(Name); + writer.WriteByte((byte) IndexType); + + if (Fields != null) + { + writer.WriteInt(Fields.Count); + + foreach (var field in Fields) + { + writer.WriteString(field.Name); + writer.WriteBoolean(field.IsDescending); + } + } + else + writer.WriteInt(0); + } + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexField.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexField.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexField.cs new file mode 100644 index 0000000..0b11e9c --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexField.cs @@ -0,0 +1,66 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + using Apache.Ignite.Core.Impl.Common; + + /// <summary> + /// Represents an indexed field. + /// </summary> + public class QueryIndexField + { + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndexField"/> class. + /// </summary> + public QueryIndexField() + { + // No-op. + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndexField"/> class. + /// </summary> + /// <param name="name">The name.</param> + public QueryIndexField(string name) + { + IgniteArgumentCheck.NotNullOrEmpty(name, "name"); + + Name = name; + } + + /// <summary> + /// Initializes a new instance of the <see cref="QueryIndexField"/> class. + /// </summary> + /// <param name="name">The name.</param> + /// <param name="isDescending">Sort direction.</param> + public QueryIndexField(string name, bool isDescending) : this (name) + { + IsDescending = isDescending; + } + + /// <summary> + /// Gets the name. + /// </summary> + public string Name { get; set; } + + /// <summary> + /// Gets a value indicating whether this index is descending. Default is false. + /// </summary> + public bool IsDescending { get; set; } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexType.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexType.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexType.cs new file mode 100644 index 0000000..25fed62 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryIndexType.cs @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + /// <summary> + /// Query index type. + /// </summary> + public enum QueryIndexType + { + /// <summary> + /// Sorted index. + /// </summary> + Sorted, + + /// <summary> + /// Fulltext index. + /// </summary> + FullText, + + /// <summary> + /// Geo-spatial index. + /// </summary> + Geospatial + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QuerySqlFieldAttribute.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QuerySqlFieldAttribute.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QuerySqlFieldAttribute.cs new file mode 100644 index 0000000..a522115 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QuerySqlFieldAttribute.cs @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + using System; + using System.Diagnostics.CodeAnalysis; + + /// <summary> + /// Marks field or property for SQL queries. + /// <para /> + /// Using this attribute is an alternative to <see cref="QueryEntity.Fields"/> in <see cref="CacheConfiguration"/>. + /// </summary> + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] + public sealed class QuerySqlFieldAttribute : Attribute + { + /// <summary> + /// Gets or sets the sql field name. + /// If not provided, property or field name will be used. + /// </summary> + public string Name { get; set; } + + /// <summary> + /// Gets or sets a value indicating whether corresponding field should be indexed. + /// Just like with databases, field indexing may require additional overhead during updates, + /// but makes select operations faster. + /// </summary> + public bool IsIndexed { get; set; } + + /// <summary> + /// Gets or sets a value indicating whether index for this field should be descending. + /// Ignored when <see cref="IsIndexed"/> is <c>false</c>. + /// </summary> + public bool IsDescending { get; set; } + + /// <summary> + /// Gets or sets the collection of index groups this field belongs to. + /// Groups are used for compound indexes, + /// whenever index should be created on more than one field. + /// All fields within the same group will belong to the same index. + /// </summary> + [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", + Justification = "Attribute initializers do not allow collections")] + public string[] IndexGroups { get; set; } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryTextFieldAttribute.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryTextFieldAttribute.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryTextFieldAttribute.cs new file mode 100644 index 0000000..6386496 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryTextFieldAttribute.cs @@ -0,0 +1,36 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Cache.Configuration +{ + using System; + + /// <summary> + /// Marks field or property for Text queries. + /// <para /> + /// Using this attribute is an alternative to <see cref="QueryEntity.Fields"/> in <see cref="CacheConfiguration"/>. + /// </summary> + [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)] + public sealed class QueryTextFieldAttribute : Attribute + { + /// <summary> + /// Gets or sets the text field name. + /// If not provided, property or field name will be used. + /// </summary> + public string Name { get; set; } + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICache.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICache.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICache.cs index 192dabf..f5e7cd2 100644 --- a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICache.cs +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/ICache.cs @@ -22,6 +22,7 @@ namespace Apache.Ignite.Core.Cache using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; + using Apache.Ignite.Core.Cache.Configuration; using Apache.Ignite.Core.Cache.Expiry; using Apache.Ignite.Core.Cache.Query; using Apache.Ignite.Core.Cache.Query.Continuous; @@ -66,6 +67,11 @@ namespace Apache.Ignite.Core.Cache IIgnite Ignite { get; } /// <summary> + /// Gets the cache configuration. + /// </summary> + CacheConfiguration GetConfiguration(); + + /// <summary> /// Checks whether this cache contains no key-value mappings. /// <para /> /// Semantically equals to <c>ICache.Size(CachePeekMode.PRIMARY) == 0</c>. http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Common/IFactory.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Common/IFactory.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Common/IFactory.cs new file mode 100644 index 0000000..67c2683 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Common/IFactory.cs @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Common +{ + using System; + + /// <summary> + /// Factory that produces instances of a specific type. + /// Implementation can be passed over the wire and thus should be marked with <see cref="SerializableAttribute"/>. + /// </summary> + public interface IFactory<out T> + { + /// <summary> + /// Creates an instance of the cache store. + /// </summary> + /// <returns>New instance of the cache store.</returns> + T CreateInstance(); + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/IDiscoverySpi.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/IDiscoverySpi.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/IDiscoverySpi.cs new file mode 100644 index 0000000..2fcafbf --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/IDiscoverySpi.cs @@ -0,0 +1,32 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Discovery +{ + using System.Diagnostics.CodeAnalysis; + using Apache.Ignite.Core.Discovery.Tcp; + + /// <summary> + /// Represents a discovery service provider interface. + /// Only predefined implementation is supported now: <see cref="TcpDiscoverySpi"/>. + /// </summary> + [SuppressMessage("Microsoft.Design", "CA1040:AvoidEmptyInterfaces")] + public interface IDiscoverySpi + { + // No-op. + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/ee20f1d9/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/Tcp/ITcpDiscoveryIpFinder.cs ---------------------------------------------------------------------- diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/Tcp/ITcpDiscoveryIpFinder.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/Tcp/ITcpDiscoveryIpFinder.cs new file mode 100644 index 0000000..c2f4329 --- /dev/null +++ b/modules/platforms/dotnet/Apache.Ignite.Core/Discovery/Tcp/ITcpDiscoveryIpFinder.cs @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +namespace Apache.Ignite.Core.Discovery.Tcp +{ + using System.Diagnostics.CodeAnalysis; + using Apache.Ignite.Core.Discovery.Tcp.Multicast; + using Apache.Ignite.Core.Discovery.Tcp.Static; + + /// <summary> + /// Represents an IP finder for <see cref="TcpDiscoverySpi"/>. + /// Only predefined implementations are supported now: + /// <see cref="TcpDiscoveryStaticIpFinder"/>, <see cref="TcpDiscoveryMulticastIpFinder"/>. + /// </summary> + [SuppressMessage("Microsoft.Design", "CA1040:AvoidEmptyInterfaces")] + public interface ITcpDiscoveryIpFinder + { + // No-op. + } +} \ No newline at end of file
