/// <summary>
/// Asserts the client configs are equal.
/// </summary>
public static void AssertClientConfigsAreEqual(CacheClientConfiguration cfg, CacheClientConfiguration cfg2)
{
if (cfg2.QueryEntities != null)
{
// Remove identical aliases which are added during config roundtrip.
foreach (var e in cfg2.QueryEntities)
{
e.Aliases = e.Aliases.Where(x => x.Alias != x.FullName).ToArray();
}
}
HashSet <string> ignoredProps = null;
if (cfg.ExpiryPolicyFactory != null && cfg2.ExpiryPolicyFactory != null)
{
ignoredProps = new HashSet <string> {
"ExpiryPolicyFactory"
};
AssertExtensions.ReflectionEqual(cfg.ExpiryPolicyFactory.CreateInstance(),
cfg2.ExpiryPolicyFactory.CreateInstance());
}
AssertExtensions.ReflectionEqual(cfg, cfg2, ignoredProperties: ignoredProps);
}
public void TestConstructors()
{
// Default property values.
var clientCfg = new CacheClientConfiguration();
var defCfg = new CacheClientConfiguration(new CacheConfiguration(), false);
ClientTestBase.AssertClientConfigsAreEqual(defCfg, clientCfg);
// Name.
clientCfg = new CacheClientConfiguration("foo");
Assert.AreEqual("foo", clientCfg.Name);
clientCfg.Name = null;
ClientTestBase.AssertClientConfigsAreEqual(defCfg, clientCfg);
// Query entities.
clientCfg = new CacheClientConfiguration("bar", typeof(QueryPerson));
Assert.AreEqual("bar", clientCfg.Name);
var qe = clientCfg.QueryEntities.Single();
Assert.AreEqual(typeof(QueryPerson), qe.ValueType);
Assert.AreEqual("Name", qe.Fields.Single().Name);
clientCfg = new CacheClientConfiguration("baz", new QueryEntity(typeof(QueryPerson)));
qe = clientCfg.QueryEntities.Single();
Assert.AreEqual(typeof(QueryPerson), qe.ValueType);
Assert.AreEqual("Name", qe.Fields.Single().Name);
}
public void Start(IDictionary <string, string> properties)
{
CacheClientConfiguration configuration;
try {
var tenantName = properties["cache.region_prefix"];
bool enableCompression = false;
string enableCompressionString;
if (properties.TryGetValue("compression_enabled", out enableCompressionString))
{
enableCompression = Boolean.Parse(enableCompressionString);
}
var pca = new DefaultPlatformConfigurationAccessor();
configuration = CacheClientConfiguration.FromPlatformConfiguration(tenantName, Constants.DatabaseCacheSettingNamePrefix, pca);
configuration.CompressionIsEnabled = enableCompression;
configuration.Validate();
}
catch (Exception ex) {
throw new Exception(String.Format("The {0} configuration settings are missing or invalid.", Constants.DatabaseCacheFeatureName), ex);
}
_dataCacheFactory = configuration.CreateCache();
_dataCache = _dataCacheFactory.GetDefaultCache();
}
public static void Main()
{
using (IIgniteClient ignite = Ignition.StartClient(Utils.GetThinClientConfiguration()))
{
Console.WriteLine();
Console.WriteLine(">>> Optimistic transaction example started.");
// Create Transactional cache.
var cacheCfg = new CacheClientConfiguration(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 transactions = ignite.GetTransactions();
var task1 = Task.Factory.StartNew(() => IncrementCacheValue(cache, transactions, 1));
var task2 = Task.Factory.StartNew(() => IncrementCacheValue(cache, transactions, 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();
}
}
public static void Main()
{
var cfg = new IgniteClientConfiguration("127.0.0.1");
using (IIgniteClient igniteClient = Ignition.StartClient(cfg))
{
Console.WriteLine();
Console.WriteLine(">>> Cache query client example started.");
// Configure query entities to enable SQL.
var cacheCfg = new CacheClientConfiguration
{
Name = CacheName,
QueryEntities = new[]
{
new QueryEntity(typeof(int), typeof(Employee)),
}
};
ICacheClient <int, Employee> cache = igniteClient.GetOrCreateCache <int, Employee>(cacheCfg);
// Populate cache with sample data entries.
PopulateCache(cache);
// Run examples.
SqlExample(cache);
LinqExample(cache);
LinqFieldsExample(cache);
}
Console.WriteLine();
Console.WriteLine(">>> Example finished, press any key to exit ...");
Console.ReadKey();
}
public void TestCreateFromConfigurationWithExpiration()
{
var expiryPolicy = new ExpiryPolicy(
TimeSpan.FromMilliseconds(20),
TimeSpan.FromMilliseconds(10),
TimeSpan.FromMilliseconds(30));
// Default config.
var cfg = new CacheClientConfiguration("a")
{
ExpiryPolicyFactory = new ExpiryPolicyFactory(expiryPolicy)
};
var cache = Client.CreateCache <int, int>(cfg);
AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration());
var remoteExpiryPolicy = cache.GetConfiguration().ExpiryPolicyFactory.CreateInstance();
AssertExtensions.ReflectionEqual(expiryPolicy, remoteExpiryPolicy);
cache.Put(1, 1);
// Wait for expiration period.
Thread.Sleep(100);
Assert.IsFalse(cache.ContainsKey(1));
}
public AzureOutputCacheStorageProvider(ShellSettings shellSettings, IAzureOutputCacheHolder cacheHolder)
{
var region = shellSettings.Name;
// Azure Cache supports only alphanumeric strings for regions, but Orchard supports some
// non-alphanumeric characters in tenant names. Remove all non-alphanumering characters
// from the region, and append the hash code of the original string to mitigate the risk
// of two distinct original region strings yielding the same transformed region string.
_regionAlphaNumeric = new String(Array.FindAll(region.ToCharArray(), Char.IsLetterOrDigit)) + region.GetHashCode().ToString(CultureInfo.InvariantCulture);
_cache = cacheHolder.TryGetDataCache(() => {
CacheClientConfiguration cacheConfig;
try {
cacheConfig = CacheClientConfiguration.FromPlatformConfiguration(shellSettings.Name, Constants.OutputCacheSettingNamePrefix);
cacheConfig.Validate();
}
catch (Exception ex) {
throw new Exception(String.Format("The {0} configuration settings are missing or invalid.", Constants.OutputCacheFeatureName), ex);
}
var cache = cacheConfig.CreateCache();
cache.CreateRegion(_regionAlphaNumeric);
return(cache);
});
}
public void TestCreateFromPartialConfiguration()
{
// Default config.
var cfg = new CacheClientConfiguration("a")
{
Backups = 7
};
var client = (IgniteClient)Client;
// Create cache directly through a socket with only some config properties provided.
client.Socket.DoOutInOp <object>(ClientOp.CacheCreateWithConfiguration, s =>
{
var w = client.Marshaller.StartMarshal(s);
w.WriteInt(2 + 2 + 6 + 2 + 4); // config length in bytes.
w.WriteShort(2); // 2 properties.
w.WriteShort(3); // backups opcode.
w.WriteInt(cfg.Backups);
w.WriteShort(0); // name opcode.
w.WriteString(cfg.Name);
}, null);
var cache = new CacheClient <int, int>(client, cfg.Name);
AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration());
}
/// <summary>
/// Serializes and deserializes the config.
/// </summary>
private static CacheClientConfiguration SerializeDeserialize(CacheClientConfiguration cfg)
{
using (var stream = new BinaryHeapStream(128))
{
ClientCacheConfigurationSerializer.Write(stream, cfg);
stream.Seek(0, SeekOrigin.Begin);
return(new CacheClientConfiguration(stream));
}
}
/** <inheritDoc /> */
public ICacheClient <TK, TV> CreateCache <TK, TV>(CacheClientConfiguration configuration)
{
IgniteArgumentCheck.NotNull(configuration, "configuration");
DoOutOp(ClientOp.CacheCreateWithConfiguration,
w => ClientCacheConfigurationSerializer.Write(w.Stream, configuration, ServerVersion()));
return(GetCache <TK, TV>(configuration.Name));
}
/** <inheritDoc /> */
public ICacheClient <TK, TV> GetOrCreateCache <TK, TV>(CacheClientConfiguration configuration)
{
IgniteArgumentCheck.NotNull(configuration, "configuration");
DoOutOp(ClientOp.CacheGetOrCreateWithConfiguration,
ctx => ClientCacheConfigurationSerializer.Write(ctx.Stream, configuration, ctx.ProtocolVersion));
return(GetCache <TK, TV>(configuration.Name));
}
/// <summary>
/// Serializes and deserializes the config.
/// </summary>
private static CacheClientConfiguration SerializeDeserialize(CacheClientConfiguration cfg)
{
using (var stream = new BinaryHeapStream(128))
{
ClientCacheConfigurationSerializer.Write(stream, cfg, ClientSocket.CurrentProtocolVersion, true);
stream.Seek(0, SeekOrigin.Begin);
return(new CacheClientConfiguration(stream, ClientSocket.CurrentProtocolVersion));
}
}
public void TestConfigConversion()
{
// Copy ctor.
var clientCfg = new CacheClientConfiguration(
CacheConfigurationTest.GetCustomCacheConfiguration("z"), true);
ClientTestBase.AssertClientConfigsAreEqual(clientCfg, new CacheClientConfiguration(clientCfg));
// Convert to server cfg.
var serverCfg = clientCfg.ToCacheConfiguration();
ClientTestBase.AssertClientConfigsAreEqual(clientCfg, new CacheClientConfiguration(serverCfg, false));
}
/// <summary>
/// Asserts the client configs are equal.
/// </summary>
public static void AssertClientConfigsAreEqual(CacheClientConfiguration cfg, CacheClientConfiguration cfg2)
{
if (cfg2.QueryEntities != null)
{
// Remove identical aliases which are added during config roundtrip.
foreach (var e in cfg2.QueryEntities)
{
e.Aliases = e.Aliases.Where(x => x.Alias != x.FullName).ToArray();
}
}
AssertExtensions.ReflectionEqual(cfg, cfg2);
}
public static void ThinClientCacheOperations()
{
var cfg = new IgniteClientConfiguration
{
Endpoints = new[] { "127.0.0.1:10800" }
};
using (var client = Ignition.StartClient(cfg))
{
//tag::createCache[]
var cacheCfg = new CacheClientConfiguration
{
Name = "References",
CacheMode = CacheMode.Replicated,
WriteSynchronizationMode = CacheWriteSynchronizationMode.FullSync
};
var cache = client.GetOrCreateCache <int, string>(cacheCfg);
//end::createCache[]
//tag::basicOperations[]
var data = Enumerable.Range(1, 100).ToDictionary(e => e, e => e.ToString());
cache.PutAll(data);
var replace = cache.Replace(1, "2", "3");
Console.WriteLine(replace); //false
var value = cache.Get(1);
Console.WriteLine(value); //1
replace = cache.Replace(1, "1", "3");
Console.WriteLine(replace); //true
value = cache.Get(1);
Console.WriteLine(value); //3
cache.Put(101, "101");
cache.RemoveAll(data.Keys);
var sizeIsOne = cache.GetSize() == 1;
Console.WriteLine(sizeIsOne); //true
value = cache.Get(101);
Console.WriteLine(value); //101
cache.RemoveAll();
var sizeIsZero = cache.GetSize() == 0;
Console.WriteLine(sizeIsZero); //true
//end::basicOperations[]
}
}
public CacheClientConfiguration GetOrCreateEmployeeCacheConfig(string cacheName)
{
var cacheConfig = new CacheClientConfiguration
{
CacheMode = Apache.Ignite.Core.Cache.Configuration.CacheMode.Partitioned,
Name = cacheName,
QueryEntities = new[]
{
new QueryEntity(typeof(string), typeof(Employee))
}
};
return(cacheConfig);
}
/// <summary>
/// Writes the specified config.
/// </summary>
public static void Write(IBinaryStream stream, CacheClientConfiguration cfg)
{
Debug.Assert(stream != null);
Debug.Assert(cfg != null);
// Configuration should be written with a system marshaller.
var writer = BinaryUtils.Marshaller.StartMarshal(stream);
var pos = writer.Stream.Position;
writer.WriteInt(0); // Reserve for length.
writer.WriteInt((int)cfg.AtomicityMode);
writer.WriteInt(cfg.Backups);
writer.WriteInt((int)cfg.CacheMode);
writer.WriteBoolean(cfg.CopyOnRead);
writer.WriteString(cfg.DataRegionName);
writer.WriteBoolean(cfg.EagerTtl);
writer.WriteBoolean(cfg.EnableStatistics);
writer.WriteString(cfg.GroupName);
writer.WriteBoolean(cfg.Invalidate);
writer.WriteTimeSpanAsLong(cfg.LockTimeout);
writer.WriteInt(cfg.MaxConcurrentAsyncOperations);
writer.WriteInt(cfg.MaxQueryIteratorsCount);
writer.WriteString(cfg.Name);
writer.WriteBoolean(cfg.OnheapCacheEnabled);
writer.WriteInt((int)cfg.PartitionLossPolicy);
writer.WriteInt(cfg.QueryDetailMetricsSize);
writer.WriteInt(cfg.QueryParallelism);
writer.WriteBoolean(cfg.ReadFromBackup);
writer.WriteInt(cfg.RebalanceBatchSize);
writer.WriteLong(cfg.RebalanceBatchesPrefetchCount);
writer.WriteTimeSpanAsLong(cfg.RebalanceDelay);
writer.WriteInt((int)cfg.RebalanceMode);
writer.WriteInt(cfg.RebalanceOrder);
writer.WriteTimeSpanAsLong(cfg.RebalanceThrottle);
writer.WriteTimeSpanAsLong(cfg.RebalanceTimeout);
writer.WriteBoolean(cfg.SqlEscapeAll);
writer.WriteInt(cfg.SqlIndexMaxInlineSize);
writer.WriteString(cfg.SqlSchema);
writer.WriteInt((int)cfg.WriteSynchronizationMode);
writer.WriteCollectionRaw(cfg.KeyConfiguration);
writer.WriteCollectionRaw(cfg.QueryEntities);
// Write length (so that part of the config can be skipped).
var len = writer.Stream.Position - pos - 4;
writer.Stream.WriteInt(pos, len);
}
/// <summary>
/// Reads the config.
/// </summary>
public static void Read(IBinaryStream stream, CacheClientConfiguration cfg, ClientFeatures features)
{
Debug.Assert(stream != null);
// Configuration should be read with system marshaller.
var reader = BinaryUtils.Marshaller.StartUnmarshal(stream);
var len = reader.ReadInt();
var pos = reader.Stream.Position;
cfg.AtomicityMode = (CacheAtomicityMode)reader.ReadInt();
cfg.Backups = reader.ReadInt();
cfg.CacheMode = (CacheMode)reader.ReadInt();
cfg.CopyOnRead = reader.ReadBoolean();
cfg.DataRegionName = reader.ReadString();
cfg.EagerTtl = reader.ReadBoolean();
cfg.EnableStatistics = reader.ReadBoolean();
cfg.GroupName = reader.ReadString();
cfg.LockTimeout = reader.ReadLongAsTimespan();
cfg.MaxConcurrentAsyncOperations = reader.ReadInt();
cfg.MaxQueryIteratorsCount = reader.ReadInt();
cfg.Name = reader.ReadString();
cfg.OnheapCacheEnabled = reader.ReadBoolean();
cfg.PartitionLossPolicy = (PartitionLossPolicy)reader.ReadInt();
cfg.QueryDetailMetricsSize = reader.ReadInt();
cfg.QueryParallelism = reader.ReadInt();
cfg.ReadFromBackup = reader.ReadBoolean();
cfg.RebalanceBatchSize = reader.ReadInt();
cfg.RebalanceBatchesPrefetchCount = reader.ReadLong();
cfg.RebalanceDelay = reader.ReadLongAsTimespan();
cfg.RebalanceMode = (CacheRebalanceMode)reader.ReadInt();
cfg.RebalanceOrder = reader.ReadInt();
cfg.RebalanceThrottle = reader.ReadLongAsTimespan();
cfg.RebalanceTimeout = reader.ReadLongAsTimespan();
cfg.SqlEscapeAll = reader.ReadBoolean();
cfg.SqlIndexMaxInlineSize = reader.ReadInt();
cfg.SqlSchema = reader.ReadString();
cfg.WriteSynchronizationMode = (CacheWriteSynchronizationMode)reader.ReadInt();
cfg.KeyConfiguration = reader.ReadCollectionRaw(r => new CacheKeyConfiguration(r));
cfg.QueryEntities = reader.ReadCollectionRaw(r => ReadQueryEntity(r, features));
if (features.HasCacheConfigurationExpiryPolicyFactory())
{
cfg.ExpiryPolicyFactory = ExpiryPolicySerializer.ReadPolicyFactory(reader);
}
Debug.Assert(len == reader.Stream.Position - pos);
}
public void TestAuthentication()
{
using (var srv = Ignition.Start(SecureServerConfig()))
{
srv.GetCluster().SetActive(true);
using (var cli = Ignition.StartClient(SecureClientConfig()))
{
CacheClientConfiguration ccfg = new CacheClientConfiguration()
{
Name = "TestCache",
QueryEntities = new[]
{
new QueryEntity
{
KeyType = typeof(string),
ValueType = typeof(string),
},
},
};
ICacheClient <string, string> cache = cli.GetOrCreateCache <string, string>(ccfg);
cache.Put("key1", "val1");
cache.Query(new SqlFieldsQuery("CREATE USER \"my_User\" WITH PASSWORD 'my_Password'")).GetAll();
}
var cliCfg = SecureClientConfig();
cliCfg.UserName = "******";
cliCfg.Password = "******";
using (var cli = Ignition.StartClient(cliCfg))
{
ICacheClient <string, string> cache = cli.GetCache <string, string>("TestCache");
string val = cache.Get("key1");
Assert.True(val == "val1");
}
}
}
public void TestGetOrCreateFromConfiguration()
{
// Default configur.
var cfg = new CacheClientConfiguration("a");
var cache = Client.GetOrCreateCache <int, int>(cfg);
AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration());
cache[1] = 1;
// Create when exists.
cache = Client.GetOrCreateCache <int, int>("a");
Assert.AreEqual(1, cache[1]);
// Custom config.
cfg = GetFullCacheConfiguration("b");
cache = Client.GetOrCreateCache <int, int>(cfg);
AssertClientConfigsAreEqual(cfg, cache.GetConfiguration());
}
/// <summary>
/// Start new node, create new user with given credentials and try to authenticate.
/// </summary>
/// <param name="user">Username</param>
/// <param name="pass">Password</param>
private void CreateNewUserAndAuthenticate(string user, string pass)
{
using (var srv = Ignition.Start(SecureServerConfig()))
{
srv.GetCluster().SetActive(true);
using (var cli = Ignition.StartClient(GetSecureClientConfig()))
{
CacheClientConfiguration ccfg = new CacheClientConfiguration
{
Name = "TestCache",
QueryEntities = new[]
{
new QueryEntity
{
KeyType = typeof(string),
ValueType = typeof(string),
},
},
};
ICacheClient <string, string> cache = cli.GetOrCreateCache <string, string>(ccfg);
cache.Put("key1", "val1");
cache.Query(new SqlFieldsQuery("CREATE USER \"" + user + "\" WITH PASSWORD '" + pass + "'")).GetAll();
}
var cliCfg = GetSecureClientConfig();
cliCfg.UserName = user;
cliCfg.Password = pass;
using (var cli = Ignition.StartClient(cliCfg))
{
ICacheClient <string, string> cache = cli.GetCache <string, string>("TestCache");
string val = cache.Get("key1");
Assert.True(val == "val1");
}
}
}
public static ICacheClient <TKey, TData> GetOrCreateCache <TKey, TData>(IIgniteClient ignite, string cacheName, Action <CacheClientConfiguration> extendConfigurationAction = null)
{
var cacheCfg = new CacheClientConfiguration()
{
Name = cacheName,
CacheMode = CacheMode.Partitioned,
GroupName = typeof(TData).FullName,
QueryEntities = new[]
{
new QueryEntity
{
KeyType = typeof(TKey),
ValueType = typeof(TData),
}
}
};
extendConfigurationAction?.Invoke(cacheCfg);
return(ignite.GetOrCreateCache <TKey, TData>(cacheCfg));
}
public void ReplicatedCacheGet_RepeatedCall_DoesNotRequestAffinityMapping()
{
// Test cache for which affinity awareness is not applicable.
var cfg = new CacheClientConfiguration("replicated_cache")
{
CacheMode = CacheMode.Replicated
};
var cache = Client.CreateCache <int, int>(cfg);
// Init the replicated cache and start the new one to enforce partition mapping request.
cache.PutAll(Enumerable.Range(1, 3).ToDictionary(x => x, x => x));
Client.CreateCache <int, int>("repeat-call-test-replicated");
ClearLoggers();
cache.Get(1);
cache.Get(2);
cache.Get(3);
var reqs = GetLoggers()
.Select(l => new
{
Logger = l,
Requests = GetServerRequestNames(l, RequestNamePrefixCache).ToArray()
})
.Where(r => r.Requests.Length > 0)
.ToArray();
// All requests should go to a single (default) node, because affinity awareness is not applicable.
Assert.AreEqual(1, reqs.Length);
// There should be only one partitions request.
var expectedRequests = new[]
{
"Partitions",
"Get",
"Get",
"Get"
};
Assert.AreEqual(expectedRequests, reqs[0].Requests);
}
public void TestCreateFromConfiguration()
{
// Default config.
var cfg = new CacheClientConfiguration("a");
var cache = Client.CreateCache <int, int>(cfg);
AssertExtensions.ReflectionEqual(cfg, cache.GetConfiguration());
// Create when exists.
var ex = Assert.Throws <IgniteClientException>(() => Client.CreateCache <int, int>(cfg));
Assert.AreEqual(
"Failed to start cache (a cache with the same name is already started): a", ex.Message);
Assert.AreEqual(ClientStatusCode.CacheExists, ex.StatusCode);
// Custom config.
cfg = GetFullCacheConfiguration("b");
cache = Client.CreateCache <int, int>(cfg);
AssertClientConfigsAreEqual(cfg, cache.GetConfiguration());
}
/// <summary>
/// Copies one cache configuration to another.
/// </summary>
public static void Copy(CacheClientConfiguration from, CacheConfiguration to)
{
Debug.Assert(from != null);
Debug.Assert(to != null);
to.AtomicityMode = from.AtomicityMode;
to.Backups = from.Backups;
to.CacheMode = from.CacheMode;
to.CopyOnRead = from.CopyOnRead;
to.DataRegionName = from.DataRegionName;
to.EagerTtl = from.EagerTtl;
to.ExpiryPolicyFactory = from.ExpiryPolicyFactory;
to.EnableStatistics = from.EnableStatistics;
to.GroupName = from.GroupName;
to.LockTimeout = from.LockTimeout;
to.MaxConcurrentAsyncOperations = from.MaxConcurrentAsyncOperations;
to.MaxQueryIteratorsCount = from.MaxQueryIteratorsCount;
to.Name = from.Name;
to.OnheapCacheEnabled = from.OnheapCacheEnabled;
to.PartitionLossPolicy = from.PartitionLossPolicy;
to.QueryDetailMetricsSize = from.QueryDetailMetricsSize;
to.QueryParallelism = from.QueryParallelism;
to.ReadFromBackup = from.ReadFromBackup;
to.RebalanceBatchSize = from.RebalanceBatchSize;
to.RebalanceBatchesPrefetchCount = from.RebalanceBatchesPrefetchCount;
to.RebalanceDelay = from.RebalanceDelay;
to.RebalanceMode = from.RebalanceMode;
to.RebalanceOrder = from.RebalanceOrder;
to.RebalanceThrottle = from.RebalanceThrottle;
to.RebalanceTimeout = from.RebalanceTimeout;
to.SqlEscapeAll = from.SqlEscapeAll;
to.SqlIndexMaxInlineSize = from.SqlIndexMaxInlineSize;
to.SqlSchema = from.SqlSchema;
to.WriteSynchronizationMode = from.WriteSynchronizationMode;
to.KeyConfiguration = from.KeyConfiguration;
to.QueryEntities = from.QueryEntities;
}
public void CachePut_UserDefinedTypeWithAffinityKey_ThrowsIgniteException()
{
// Note: annotation-based configuration is not supported on Java side.
// Use manual configuration instead.
var cacheClientConfiguration = new CacheClientConfiguration("c_custom_key_aff")
{
KeyConfiguration = new List <CacheKeyConfiguration>
{
new CacheKeyConfiguration(typeof(TestKeyWithAffinity))
{
AffinityKeyFieldName = "_i"
}
}
};
var cache = Client.GetOrCreateCache <TestKeyWithAffinity, int>(cacheClientConfiguration);
var ex = Assert.Throws <IgniteException>(() => cache.Put(new TestKeyWithAffinity(1, "1"), 1));
var expected = string.Format("Affinity keys are not supported. Object '{0}' has an affinity key.",
typeof(TestKeyWithAffinity));
Assert.AreEqual(expected, ex.Message);
}
public void TestCacheStartFromThinClientRegistersMetaForQueryEntityTypes()
{
var cfg = new CacheClientConfiguration
{
Name = TestUtils.TestName,
QueryEntities = new[]
{
new QueryEntity
{
KeyType = typeof(Key1),
ValueType = typeof(Value1)
}
}
};
using (var client = Ignition.StartClient(new IgniteClientConfiguration("localhost:10800..10801")))
{
client.CreateCache <Key1, Value1>(cfg);
var type = client.GetBinary().GetBinaryType(typeof(Key1));
Assert.AreEqual("Bar", type.AffinityKeyFieldName);
}
}
public static void Main()
{
using (IIgniteClient ignite = Ignition.StartClient(Utils.GetThinClientConfiguration()))
{
Console.WriteLine();
Console.WriteLine(">>> Cache query DDL example started.");
// Create dummy cache to act as an entry point for SQL queries (new SQL API which do not require this
// will appear in future versions, JDBC and ODBC drivers do not require it already).
var cacheCfg = new CacheClientConfiguration("dummy_cache")
{
SqlSchema = "PUBLIC",
CacheMode = CacheMode.Replicated
};
ICacheClient <object, object> cache = ignite.GetOrCreateCache <object, object>(cacheCfg);
// Create reference City table based on REPLICATED template.
cache.Query(new SqlFieldsQuery(
"CREATE TABLE city (id LONG PRIMARY KEY, name VARCHAR) WITH \"template=replicated\"")).GetAll();
// Create table based on PARTITIONED template with one backup.
cache.Query(new SqlFieldsQuery(
"CREATE TABLE person (id LONG, name VARCHAR, city_id LONG, PRIMARY KEY (id, city_id)) " +
"WITH \"backups=1, affinity_key=city_id\"")).GetAll();
// Create an index.
cache.Query(new SqlFieldsQuery("CREATE INDEX on Person (city_id)")).GetAll();
Console.WriteLine("\n>>> Created database objects.");
const string addCity = "INSERT INTO city (id, name) VALUES (?, ?)";
cache.Query(new SqlFieldsQuery(addCity, 1L, "Forest Hill"));
cache.Query(new SqlFieldsQuery(addCity, 2L, "Denver"));
cache.Query(new SqlFieldsQuery(addCity, 3L, "St. Petersburg"));
const string addPerson = "INSERT INTO person (id, name, city_id) values (?, ?, ?)";
cache.Query(new SqlFieldsQuery(addPerson, 1L, "John Doe", 3L));
cache.Query(new SqlFieldsQuery(addPerson, 2L, "Jane Roe", 2L));
cache.Query(new SqlFieldsQuery(addPerson, 3L, "Mary Major", 1L));
cache.Query(new SqlFieldsQuery(addPerson, 4L, "Richard Miles", 2L));
Console.WriteLine("\n>>> Populated data.");
IFieldsQueryCursor res = cache.Query(new SqlFieldsQuery(
"SELECT p.name, c.name FROM Person p INNER JOIN City c on c.id = p.city_id"));
Console.WriteLine("\n>>> Query results:");
foreach (var row in res)
{
Console.WriteLine("{0}, {1}", row[0], row[1]);
}
cache.Query(new SqlFieldsQuery("drop table Person")).GetAll();
cache.Query(new SqlFieldsQuery("drop table City")).GetAll();
Console.WriteLine("\n>>> Dropped database objects.");
}
Console.WriteLine();
Console.WriteLine(">>> Example finished, press any key to exit ...");
Console.ReadKey();
}
/// <summary>
/// Copies one cache configuration to another.
/// </summary>
public static void Copy(CacheConfiguration from, CacheClientConfiguration to, bool ignoreUnsupportedProperties)
{
Debug.Assert(from != null);
Debug.Assert(to != null);
to.AtomicityMode = from.AtomicityMode;
to.Backups = from.Backups;
to.CacheMode = from.CacheMode;
to.CopyOnRead = from.CopyOnRead;
to.DataRegionName = from.DataRegionName;
to.EagerTtl = from.EagerTtl;
to.ExpiryPolicyFactory = from.ExpiryPolicyFactory;
to.EnableStatistics = from.EnableStatistics;
to.GroupName = from.GroupName;
to.LockTimeout = from.LockTimeout;
to.MaxConcurrentAsyncOperations = from.MaxConcurrentAsyncOperations;
to.MaxQueryIteratorsCount = from.MaxQueryIteratorsCount;
to.Name = from.Name;
to.OnheapCacheEnabled = from.OnheapCacheEnabled;
to.PartitionLossPolicy = from.PartitionLossPolicy;
to.QueryDetailMetricsSize = from.QueryDetailMetricsSize;
to.QueryParallelism = from.QueryParallelism;
to.ReadFromBackup = from.ReadFromBackup;
to.RebalanceBatchSize = from.RebalanceBatchSize;
to.RebalanceBatchesPrefetchCount = from.RebalanceBatchesPrefetchCount;
to.RebalanceDelay = from.RebalanceDelay;
to.RebalanceMode = from.RebalanceMode;
to.RebalanceOrder = from.RebalanceOrder;
to.RebalanceThrottle = from.RebalanceThrottle;
to.RebalanceTimeout = from.RebalanceTimeout;
to.SqlEscapeAll = from.SqlEscapeAll;
to.SqlIndexMaxInlineSize = from.SqlIndexMaxInlineSize;
to.SqlSchema = from.SqlSchema;
to.WriteSynchronizationMode = from.WriteSynchronizationMode;
to.KeyConfiguration = from.KeyConfiguration;
to.QueryEntities = from.QueryEntities;
if (!ignoreUnsupportedProperties)
{
// Unsupported complex properties.
ThrowUnsupportedIfNotDefault(from.AffinityFunction, "AffinityFunction");
ThrowUnsupportedIfNotDefault(from.EvictionPolicy, "EvictionPolicy");
ThrowUnsupportedIfNotDefault(from.PluginConfigurations, "PluginConfigurations");
ThrowUnsupportedIfNotDefault(from.CacheStoreFactory, "CacheStoreFactory");
ThrowUnsupportedIfNotDefault(from.NearConfiguration, "NearConfiguration");
// Unsupported store-related properties.
ThrowUnsupportedIfNotDefault(from.KeepBinaryInStore, "KeepBinaryInStore");
ThrowUnsupportedIfNotDefault(from.LoadPreviousValue, "LoadPreviousValue");
ThrowUnsupportedIfNotDefault(from.ReadThrough, "ReadThrough");
ThrowUnsupportedIfNotDefault(from.WriteThrough, "WriteThrough");
ThrowUnsupportedIfNotDefault(from.StoreConcurrentLoadAllThreshold, "StoreConcurrentLoadAllThreshold",
CacheConfiguration.DefaultStoreConcurrentLoadAllThreshold);
ThrowUnsupportedIfNotDefault(from.WriteBehindBatchSize, "WriteBehindBatchSize",
CacheConfiguration.DefaultWriteBehindBatchSize);
ThrowUnsupportedIfNotDefault(from.WriteBehindCoalescing, "WriteBehindCoalescing",
CacheConfiguration.DefaultWriteBehindCoalescing);
ThrowUnsupportedIfNotDefault(from.WriteBehindEnabled, "WriteBehindEnabled");
ThrowUnsupportedIfNotDefault(from.WriteBehindFlushFrequency, "WriteBehindFlushFrequency",
CacheConfiguration.DefaultWriteBehindFlushFrequency);
ThrowUnsupportedIfNotDefault(from.WriteBehindFlushSize, "WriteBehindFlushSize",
CacheConfiguration.DefaultWriteBehindFlushSize);
ThrowUnsupportedIfNotDefault(from.WriteBehindFlushThreadCount, "WriteBehindFlushThreadCount",
CacheConfiguration.DefaultWriteBehindFlushThreadCount);
}
}
/// <summary>
/// Writes the specified config.
/// </summary>
public static void Write(IBinaryStream stream, CacheClientConfiguration cfg, ClientFeatures features,
bool skipCodes = false)
{
Debug.Assert(stream != null);
Debug.Assert(cfg != null);
// Configuration should be written with a system marshaller.
var writer = BinaryUtils.Marshaller.StartMarshal(stream);
var pos = writer.Stream.Position;
writer.WriteInt(0); // Reserve for length.
if (!skipCodes)
{
writer.WriteShort(PropertyCount); // Property count.
}
var code = skipCodes
? (Action <Op>)(o => { })
: o => writer.WriteShort((short)o);
code(Op.AtomicityMode);
writer.WriteInt((int)cfg.AtomicityMode);
code(Op.Backups);
writer.WriteInt(cfg.Backups);
code(Op.CacheMode);
writer.WriteInt((int)cfg.CacheMode);
code(Op.CopyOnRead);
writer.WriteBoolean(cfg.CopyOnRead);
code(Op.DataRegionName);
writer.WriteString(cfg.DataRegionName);
code(Op.EagerTtl);
writer.WriteBoolean(cfg.EagerTtl);
code(Op.StatisticsEnabled);
writer.WriteBoolean(cfg.EnableStatistics);
code(Op.GroupName);
writer.WriteString(cfg.GroupName);
code(Op.DefaultLockTimeout);
writer.WriteTimeSpanAsLong(cfg.LockTimeout);
code(Op.MaxConcurrentAsyncOperations);
writer.WriteInt(cfg.MaxConcurrentAsyncOperations);
code(Op.MaxQueryIteratorsCount);
writer.WriteInt(cfg.MaxQueryIteratorsCount);
code(Op.Name);
writer.WriteString(cfg.Name);
code(Op.OnheapCacheEnabled);
writer.WriteBoolean(cfg.OnheapCacheEnabled);
code(Op.PartitionLossPolicy);
writer.WriteInt((int)cfg.PartitionLossPolicy);
code(Op.QueryDetailMetricsSize);
writer.WriteInt(cfg.QueryDetailMetricsSize);
code(Op.QueryParallelism);
writer.WriteInt(cfg.QueryParallelism);
code(Op.ReadFromBackup);
writer.WriteBoolean(cfg.ReadFromBackup);
code(Op.RebalanceBatchSize);
writer.WriteInt(cfg.RebalanceBatchSize);
code(Op.RebalanceBatchesPrefetchCount);
writer.WriteLong(cfg.RebalanceBatchesPrefetchCount);
code(Op.RebalanceDelay);
writer.WriteTimeSpanAsLong(cfg.RebalanceDelay);
code(Op.RebalanceMode);
writer.WriteInt((int)cfg.RebalanceMode);
code(Op.RebalanceOrder);
writer.WriteInt(cfg.RebalanceOrder);
code(Op.RebalanceThrottle);
writer.WriteTimeSpanAsLong(cfg.RebalanceThrottle);
code(Op.RebalanceTimeout);
writer.WriteTimeSpanAsLong(cfg.RebalanceTimeout);
code(Op.SqlEscapeAll);
writer.WriteBoolean(cfg.SqlEscapeAll);
code(Op.SqlIndexMaxInlineSize);
writer.WriteInt(cfg.SqlIndexMaxInlineSize);
code(Op.SqlSchema);
writer.WriteString(cfg.SqlSchema);
code(Op.WriteSynchronizationMode);
writer.WriteInt((int)cfg.WriteSynchronizationMode);
code(Op.KeyConfiguration);
writer.WriteCollectionRaw(cfg.KeyConfiguration);
code(Op.QueryEntities);
writer.WriteCollectionRaw(cfg.QueryEntities, (w, qe) => WriteQueryEntity(w, qe, features));
code(Op.ExpiryPolicy);
ExpiryPolicySerializer.WritePolicyFactory(writer, cfg.ExpiryPolicyFactory);
// Write length (so that part of the config can be skipped).
var len = writer.Stream.Position - pos - 4;
writer.Stream.WriteInt(pos, len);
}
