public void TestReadOnlyNearCacheConfig()
{
var config = new NearCacheConfig();
var readOnly = config.GetAsReadOnly();
var actions = new Action[]
{
() => readOnly.SetEvictionPolicy(TestSupport.RandomString()),
() => readOnly.SetName(TestSupport.RandomString()),
() => readOnly.SetInMemoryFormat(TestSupport.RandomString()),
() => readOnly.SetInMemoryFormat(InMemoryFormat.Binary),
() => readOnly.SetInvalidateOnChange(true),
() => readOnly.SetMaxIdleSeconds(TestSupport.RandomInt()),
() => readOnly.SetMaxSize(TestSupport.RandomInt()),
() => readOnly.SetTimeToLiveSeconds(TestSupport.RandomInt())
};
foreach (var action in actions)
{
try
{
action();
Assert.Fail("The config was not readonly.");
}
catch (NotSupportedException)
{
}
}
}
protected override void ConfigureClient(ClientConfig config)
{
base.ConfigureClient(config);
var nearCacheConfig = new NearCacheConfig().SetInMemoryFormat(InMemoryFormat.Object);
config.AddNearCacheConfig("nearCachedMap*", nearCacheConfig);
}
private static bool Equals(NearCacheConfig first, NearCacheConfig other)
{
return(first.EvictionPolicy == other.EvictionPolicy && first.InMemoryFormat == other.InMemoryFormat &&
first.MaxIdleSeconds == other.MaxIdleSeconds && first.MaxSize == other.MaxSize && first.Name == other.Name &&
first.TimeToLiveSeconds == other.TimeToLiveSeconds && first.InvalidateOnChange == other.InvalidateOnChange &&
first.SerializeKeys == other.SerializeKeys);
}
protected override void ConfigureClient(ClientConfig config)
{
base.ConfigureClient(config);
var defaultConfig = new NearCacheConfig().SetInvalidateOnChange(false)
.SetInMemoryFormat(InMemoryFormat.Object).SetEvictionPolicy("None").SetMaxSize(MaxSize);
config.AddNearCacheConfig("nearCachedMap*", defaultConfig);
var invalidateConfig = new NearCacheConfig().SetInvalidateOnChange(true);
config.AddNearCacheConfig("nearCacheMapInvalidate*", invalidateConfig);
var lruConfig = new NearCacheConfig().SetEvictionPolicy("Lru").SetInvalidateOnChange(false)
.SetMaxSize(MaxSize);
config.AddNearCacheConfig("nearCacheMapLru*", lruConfig);
var lfuConfig = new NearCacheConfig().SetEvictionPolicy("Lfu").SetInvalidateOnChange(false)
.SetMaxSize(MaxSize);
config.AddNearCacheConfig("nearCacheMapLfu*", lfuConfig);
var ttlConfig = new NearCacheConfig().SetInvalidateOnChange(false).SetTimeToLiveSeconds(1);
config.AddNearCacheConfig("nearCacheTtl*", ttlConfig);
var idleConfig = new NearCacheConfig().SetInvalidateOnChange(false).SetMaxIdleSeconds(1);
config.AddNearCacheConfig("nearCacheIdle*", idleConfig);
}
protected override void ConfigureClient(ClientConfig config)
{
base.ConfigureClient(config);
Environment.SetEnvironmentVariable("hazelcast.invalidation.max.tolerated.miss.count", "0");
var defaultConfig = new NearCacheConfig().SetInvalidateOnChange(true).SetEvictionPolicy("None")
.SetInMemoryFormat(InMemoryFormat.Binary);
config.AddNearCacheConfig("nearCachedMap*", defaultConfig);
}
public virtual void TestNearCacheConfigWildcard3()
{
var nearCacheConfig = new NearCacheConfig().SetName("com.hazelcast.test.*");
var config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig);
Assert.AreEqual(nearCacheConfig, config.GetNearCacheConfig("com.hazelcast.test.myNearCache"));
}
public virtual void TestMapConfigWildcardMultipleAmbiguousConfigs()
{
var nearCacheConfig1 = new NearCacheConfig().SetName("com.hazelcast*");
var nearCacheConfig2 = new NearCacheConfig().SetName("*com.hazelcast");
var config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig1);
config.AddNearCacheConfig(nearCacheConfig2);
config.GetNearCacheConfig("com.hazelcast");
}
protected override void ConfigureClient(Configuration config)
{
base.ConfigureClient(config);
Environment.SetEnvironmentVariable("hazelcast.invalidation.max.tolerated.miss.count", "0");
var defaultConfig = new NearCacheConfig
{
InvalidateOnChange = true, EvictionPolicy = EvictionPolicy.None, InMemoryFormat = InMemoryFormat.Binary
};
config.NearCacheConfigs.Add("nearCachedMap*", defaultConfig);
}
public virtual void TestNearCacheConfigWildcardOnlyMultipleConfigs()
{
var nearCacheConfig1 = new NearCacheConfig().SetName("*");
var nearCacheConfig2 = new NearCacheConfig().SetName("com.hazelcast.*");
var config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig1);
config.AddNearCacheConfig(nearCacheConfig2);
// we should get the best matching result
Assert.AreEqual(nearCacheConfig2, config.GetNearCacheConfig("com.hazelcast.myNearCache"));
}
public void TestNearCacheConfigWildcardOnly()
{
var nearCacheConfig = new NearCacheConfig {
Name = "*"
};
var config = new Configuration {
ConfigPatternMatcher = new MatchingPointConfigPatternMatcher()
};
config.NearCacheConfigs.Add(nearCacheConfig.Name, nearCacheConfig);
Assert.AreEqual(nearCacheConfig, config.GetNearCacheConfig("com.hazelcast.myNearCache"));
}
public virtual void TestDuplicateConfig()
{
NearCacheConfig nearCacheConfig1 = new NearCacheConfig().SetName("com.hazelcast.*ap");
NearCacheConfig nearCacheConfig2 = new NearCacheConfig().SetName("com.hazelcast*map");
ClientConfig config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig1);
config.AddNearCacheConfig(nearCacheConfig2);
config.GetNearCacheConfig("com.hazelcast.map");
}
public virtual void TestNearCacheConfigWithoutWildcard()
{
var nearCacheConfig = new NearCacheConfig().SetName("someNearCache");
var config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig);
Assert.AreEqual(nearCacheConfig, config.GetNearCacheConfig("someNearCache"));
// non-matching name
Assert.AreNotEqual(nearCacheConfig, config.GetNearCacheConfig("doesNotExist"));
// non-matching case
Assert.AreNotEqual(nearCacheConfig, config.GetNearCacheConfig("SomeNearCache"));
}
public void TestDuplicateConfig()
{
Assert.Throws <ConfigurationException>(() =>
{
var nearCacheConfig1 = new NearCacheConfig().SetName("com.hazelcast.*ap");
var nearCacheConfig2 = new NearCacheConfig().SetName("com.hazelcast*map");
var config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig1);
config.AddNearCacheConfig(nearCacheConfig2);
config.GetNearCacheConfig("com.hazelcast.map");
});
}
public void TestNearCacheConfigWildcard(
[Values("*hazelcast.test.myNearCache", "com.hazelcast.*.myNearCache", "com.hazelcast.test.*")]
string pattern1)
{
var nearCacheConfig = new NearCacheConfig {
Name = pattern1
};
var config = new Configuration {
ConfigPatternMatcher = new MatchingPointConfigPatternMatcher()
};
config.ConfigureNearCache(pattern1, ncCfg => { });
Assert.IsTrue(Equals(nearCacheConfig, config.GetNearCacheConfig("com.hazelcast.test.myNearCache")));
}
public virtual void TestNearCacheConfigWildcardMatchingPointStartsWith()
{
NearCacheConfig nearCacheConfig1 = new NearCacheConfig().SetName("hazelcast.*");
NearCacheConfig nearCacheConfig2 = new NearCacheConfig().SetName("hazelcast.test.*");
NearCacheConfig nearCacheConfig3 = new NearCacheConfig().SetName("hazelcast.test.sub.*");
ClientConfig config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig1);
config.AddNearCacheConfig(nearCacheConfig2);
config.AddNearCacheConfig(nearCacheConfig3);
// we should not match any of the configs (startsWith)
Assert.AreEqual(null, config.GetNearCacheConfig("com.hazelcast.myNearCache"));
Assert.AreEqual(null, config.GetNearCacheConfig("com.hazelcast.test.myNearCache"));
Assert.AreEqual(null, config.GetNearCacheConfig("com.hazelcast.test.sub.myNearCache"));
}
public void TestNearCacheConfigWithoutWildcard()
{
var nearCacheConfig = new NearCacheConfig {
Name = "someNearCache"
};
var config = new Configuration {
ConfigPatternMatcher = new MatchingPointConfigPatternMatcher()
};
config.NearCacheConfigs.Add(nearCacheConfig.Name, nearCacheConfig);
Assert.AreEqual(nearCacheConfig, config.GetNearCacheConfig("someNearCache"));
// non-matching name
Assert.AreNotEqual(nearCacheConfig, config.GetNearCacheConfig("doesNotExist"));
// non-matching case
Assert.AreNotEqual(nearCacheConfig, config.GetNearCacheConfig("SomeNearCache"));
}
public virtual void TestNearCacheConfigWildcardMatchingPointEndsWith()
{
var nearCacheConfig1 = new NearCacheConfig().SetName("*.sub");
var nearCacheConfig2 = new NearCacheConfig().SetName("*.test.sub");
var nearCacheConfig3 = new NearCacheConfig().SetName("*.hazelcast.test.sub");
var config = new ClientConfig();
config.SetConfigPatternMatcher(new MatchingPointConfigPatternMatcher());
config.AddNearCacheConfig(nearCacheConfig1);
config.AddNearCacheConfig(nearCacheConfig2);
config.AddNearCacheConfig(nearCacheConfig3);
// we should not match any of the configs (endsWith)
Assert.AreEqual(null, config.GetNearCacheConfig("com.hazelFast.Fast.sub.myNearCache"));
Assert.AreEqual(null, config.GetNearCacheConfig("hazelFast.test.sub.myNearCache"));
Assert.AreEqual(null, config.GetNearCacheConfig("test.sub.myNearCache"));
}
public virtual void TestSpecificNearCacheConfig_whenAsteriskInTheMiddle()
{
var clientConfig = new ClientConfig();
var genericNearCacheConfig = new NearCacheConfig();
genericNearCacheConfig.SetName("map*Bar");
clientConfig.AddNearCacheConfig(genericNearCacheConfig);
var specificNearCacheConfig = new NearCacheConfig();
specificNearCacheConfig.SetName("mapStudent*Bar");
clientConfig.AddNearCacheConfig(specificNearCacheConfig);
var mapFoo = clientConfig.GetNearCacheConfig("mapFooBar");
var mapStudentFoo = clientConfig.GetNearCacheConfig("mapStudentFooBar");
Assert.AreEqual(genericNearCacheConfig, mapFoo);
Assert.AreEqual(specificNearCacheConfig, mapStudentFoo);
}
public virtual void TestSpecificNearCacheConfig_whenAsteriskAtTheBeginning()
{
var clientConfig = new ClientConfig();
var genericNearCacheConfig = new NearCacheConfig();
genericNearCacheConfig.SetName("*Map");
clientConfig.AddNearCacheConfig(genericNearCacheConfig);
var specificNearCacheConfig = new NearCacheConfig();
specificNearCacheConfig.SetName("*MapStudent");
clientConfig.AddNearCacheConfig(specificNearCacheConfig);
var mapFoo = clientConfig.GetNearCacheConfig("fooMap");
var mapStudentFoo = clientConfig.GetNearCacheConfig("fooMapStudent");
Assert.AreEqual(genericNearCacheConfig, mapFoo);
Assert.AreEqual(specificNearCacheConfig, mapStudentFoo);
}
public void TestNearCacheConfigWildcardOnlyMultipleConfigs()
{
var nearCacheConfig1 = new NearCacheConfig {
Name = "*"
};
var nearCacheConfig2 = new NearCacheConfig {
Name = "com.hazelcast.*"
};
var config = new Configuration {
ConfigPatternMatcher = new MatchingPointConfigPatternMatcher()
};
config.NearCacheConfigs.Add(nearCacheConfig1.Name, nearCacheConfig1);
config.NearCacheConfigs.Add(nearCacheConfig2.Name, nearCacheConfig2);
// we should get the best matching result
Assert.AreEqual(nearCacheConfig2, config.GetNearCacheConfig("com.hazelcast.myNearCache"));
}
protected BaseNearCache(string name, HazelcastClient client, NearCacheConfig nearCacheConfig)
{
_name = name;
Client = client;
_maxSize = nearCacheConfig.MaxSize;
_maxIdleMillis = nearCacheConfig.MaxIdleSeconds * 1000;
_inMemoryFormat = nearCacheConfig.InMemoryFormat;
_timeToLiveMillis = nearCacheConfig.TimeToLiveSeconds * 1000;
_evictionPolicy = nearCacheConfig.EvictionPolicy;
_records = new ConcurrentDictionary <IData, Lazy <NearCacheRecord> >();
_canCleanUp = new AtomicBoolean(true);
_canEvict = new AtomicBoolean(true);
_lastCleanup = Clock.CurrentTimeMillis();
_selectedComparer = GetComparer(_evictionPolicy);
_stat = new NearCacheStatistics();
InvalidateOnChange = nearCacheConfig.InvalidateOnChange;
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
var nearCacheConfig = new NearCacheConfig();
nearCacheConfig.SetMaxSize(1000)
.SetInvalidateOnChange(true)
.SetEvictionPolicy("Lru")
.SetInMemoryFormat(InMemoryFormat.Binary);
config.AddNearCacheConfig("nearcache-map-*", nearCacheConfig);
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <string, string>("nearcache-map-1");
for (var i = 0; i < 1000; i++)
{
map.Put("key" + i, "value" + i);
}
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 1000; i++)
{
map.Get("key" + i);
}
Console.WriteLine("Got values in " + sw.ElapsedMilliseconds + " millis");
sw.Restart();
for (var i = 0; i < 1000; i++)
{
map.Get("key" + i);
}
Console.WriteLine("Got cached values in " + sw.ElapsedMilliseconds + " millis");
map.Destroy();
client.Shutdown();
}
protected override void ConfigureClient(ClientConfig config)
{
Environment.SetEnvironmentVariable("hazelcast.client.statistics.enabled", "true");
base.ConfigureClient(config);
var nearCacheConfig = new NearCacheConfig()
.SetInvalidateOnChange(false)
.SetInMemoryFormat(InMemoryFormat.Object)
.SetEvictionPolicy("LRU")
.SetMaxIdleSeconds(1)
.SetMaxSize(1000);
config.AddNearCacheConfig("nearCachedMap*", nearCacheConfig);
config.GetSerializationConfig().AddPortableFactory(1, new PortableFactory());
config.GetSerializationConfig()
.AddDataSerializableFactory(IdentifiedFactory.FactoryId, new IdentifiedFactory());
}
public virtual void TestSpecificNearCacheConfig_whenAsteriskAtTheBeginning()
{
var clientConfig = new Configuration();
var genericNearCacheConfig = new NearCacheConfig {
Name = "*Map"
};
clientConfig.NearCacheConfigs.Add(genericNearCacheConfig.Name, genericNearCacheConfig);
var specificNearCacheConfig = new NearCacheConfig {
Name = "*MapStudent"
};
clientConfig.NearCacheConfigs.Add(specificNearCacheConfig.Name, specificNearCacheConfig);
var mapFoo = clientConfig.GetNearCacheConfig("fooMap");
var mapStudentFoo = clientConfig.GetNearCacheConfig("fooMapStudent");
Assert.AreEqual(genericNearCacheConfig, mapFoo);
Assert.AreEqual(specificNearCacheConfig, mapStudentFoo);
}
public virtual void TestSpecificNearCacheConfig_whenAsteriskInTheMiddle()
{
var clientConfig = new Configuration();
var genericNearCacheConfig = new NearCacheConfig {
Name = "map*Bar"
};
clientConfig.NearCacheConfigs.Add(genericNearCacheConfig.Name, genericNearCacheConfig);
var specificNearCacheConfig = new NearCacheConfig {
Name = "mapStudent*Bar"
};
clientConfig.NearCacheConfigs.Add(specificNearCacheConfig.Name, specificNearCacheConfig);
var mapFoo = clientConfig.GetNearCacheConfig("mapFooBar");
var mapStudentFoo = clientConfig.GetNearCacheConfig("mapStudentFooBar");
Assert.AreEqual(genericNearCacheConfig, mapFoo);
Assert.AreEqual(specificNearCacheConfig, mapStudentFoo);
}
protected override void ConfigureClient(Configuration config)
{
Environment.SetEnvironmentVariable("hazelcast.client.statistics.enabled", "true");
base.ConfigureClient(config);
var nearCacheConfig = new NearCacheConfig
{
InvalidateOnChange = false,
InMemoryFormat = InMemoryFormat.Object,
EvictionPolicy = EvictionPolicy.Lru,
MaxIdleSeconds = 1,
MaxSize = 1000
};
config.NearCacheConfigs.Add("nearCachedMap*", nearCacheConfig);
config.SerializationConfig.PortableFactories.Add(1, new PortableFactory());
config.SerializationConfig
.DataSerializableFactories.Add(IdentifiedFactory.FactoryId, new IdentifiedFactory());
}
protected override void ConfigureClient(Configuration config)
{
base.ConfigureClient(config);
var defaultConfig = new NearCacheConfig
{
InvalidateOnChange = false, InMemoryFormat = InMemoryFormat.Object, EvictionPolicy = EvictionPolicy.None, MaxSize = MaxSize
};
config.NearCacheConfigs.Add("nearCachedMap*", defaultConfig);
var invalidateConfig = new NearCacheConfig {
InvalidateOnChange = true
};
config.NearCacheConfigs.Add("nearCacheMapInvalidate*", invalidateConfig);
var lruConfig = new NearCacheConfig {
EvictionPolicy = EvictionPolicy.Lru, InvalidateOnChange = false, MaxSize = MaxSize
};
config.NearCacheConfigs.Add("nearCacheMapLru*", lruConfig);
var lfuConfig = new NearCacheConfig {
EvictionPolicy = EvictionPolicy.Lfu, InvalidateOnChange = false, MaxSize = MaxSize
};
config.NearCacheConfigs.Add("nearCacheMapLfu*", lfuConfig);
var ttlConfig = new NearCacheConfig {
InvalidateOnChange = false, TimeToLiveSeconds = 1
};
config.NearCacheConfigs.Add("nearCacheTtl*", ttlConfig);
var idleConfig = new NearCacheConfig {
InvalidateOnChange = false, MaxIdleSeconds = 1
};
config.NearCacheConfigs.Add("nearCacheIdle*", idleConfig);
}
public ClientNearCache(string mapName, ClientNearCacheType cacheType, ClientContext context,
NearCacheConfig nearCacheConfig)
{
this.mapName = mapName;
this.cacheType = cacheType;
this.context = context;
maxSize = nearCacheConfig.GetMaxSize();
maxIdleMillis = nearCacheConfig.GetMaxIdleSeconds() * 1000;
inMemoryFormat = nearCacheConfig.GetInMemoryFormat();
timeToLiveMillis = nearCacheConfig.GetTimeToLiveSeconds() * 1000;
invalidateOnChange = nearCacheConfig.IsInvalidateOnChange();
evictionPolicy = (EvictionPolicy)Enum.Parse(typeof(EvictionPolicy), nearCacheConfig.GetEvictionPolicy());
cache = new ConcurrentDictionary <IData, CacheRecord>();
canCleanUp = new AtomicBoolean(true);
canEvict = new AtomicBoolean(true);
lastCleanup = Clock.CurrentTimeMillis();
if (invalidateOnChange)
{
AddInvalidateListener();
}
}
private static void Run(string[] args)
{
//This will enable client statistics
Environment.SetEnvironmentVariable("hazelcast.client.statistics.enabled", "true");
//set the statistics send period, default value is 3 seconds
Environment.SetEnvironmentVariable("hazelcast.client.statistics.period.seconds", "3");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var nearCacheConfig = new NearCacheConfig();
nearCacheConfig.SetMaxSize(1000)
.SetInvalidateOnChange(true)
.SetEvictionPolicy("Lru")
.SetInMemoryFormat(InMemoryFormat.Binary);
config.AddNearCacheConfig("myMap", nearCacheConfig);
var client = HazelcastClient.NewHazelcastClient(config);
//Let's generate some statistics
var map = client.GetMap <string, string>("myMap");
var task = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100000; i++)
{
map.Put("key-" + i, "value-" + i);
Thread.Sleep(500);
}
});
//After client connected you can use Management Center to visualize client statistics
task.Wait();
client.Shutdown();
}
public NearCachePre38(string name, HazelcastClient client, NearCacheConfig nearCacheConfig) : base(name, client,
nearCacheConfig)
{
}
