public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new Configuration();
var nearCacheConfig = new NearCacheConfig
{
MaxSize = 1000, InvalidateOnChange = true, EvictionPolicy = EvictionPolicy.Lru, InMemoryFormat = InMemoryFormat.Binary
};
config.NearCacheConfigs.Add("nearcache-map-*", nearCacheConfig);
config.NetworkConfig.Addresses.Add("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();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
//TODO fix here
// config.SetClusterName("dev").SetClusterPassword("dev-pass");
config.GetNetworkConfig().AddAddress("127.0.0.1:5701")
.SetSmartRouting(false);
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <int, string>("test");
var map2 = client.GetMap <int, string>("test3");
map.Clear();
map2.Clear();
long totalDuration = 0;
int count = 100;
for (int i = 0; i < count; i++)
{
TransactionOptions options = new TransactionOptions()
.SetTransactionType(TransactionOptions.TransactionType.TwoPhase);
ITransactionContext context = client.NewTransactionContext(options);
var watch = System.Diagnostics.Stopwatch.StartNew();
context.BeginTransaction();
var tmap = context.GetMap <int, string>("test");
var tmap2 = context.GetMap <int, string>("test2");
tmap.Set(i, "value");
tmap2.Set(i, "value");
context.CommitTransaction();
watch.Stop();
totalDuration += watch.ElapsedMilliseconds;
}
Console.WriteLine((double)totalDuration / count);
}
public static void Run(string[] args)
{
// Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
var hz = HazelcastClient.NewHazelcastClient();
// Get the Distributed List from Cluster.
var list = hz.GetList <string>("my-distributed-list");
// Add elements to the list
list.Add("item1");
list.Add("item2");
// Remove the first element
Console.WriteLine("Removed: " + list.Remove(0));
// There is only one element left
Console.WriteLine("Current size is " + list.Size());
// Clear the list
list.Clear();
// Shutdown this Hazelcast client
hz.Shutdown();
}
public static void Run(string[] args)
{
// Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
var hz = HazelcastClient.NewHazelcastClient();
// Get a Blocking Queue called "my-distributed-queue"
var queue = hz.GetQueue <string>("my-distributed-queue");
// Offer a String into the Distributed Queue
queue.Offer("item");
// Poll the Distributed Queue and return the String
queue.Poll();
//Timed blocking Operations
queue.Offer("anotheritem", 500, TimeUnit.Milliseconds);
queue.Poll(5, TimeUnit.Seconds);
//Indefinitely blocking Operations
queue.Put("yetanotheritem");
Console.WriteLine(queue.Take());
// Shutdown this Hazelcast Client
hz.Shutdown();
}
public static void Run(string[] args)
{
// Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
var hz = HazelcastClient.NewHazelcastClient();
// Get a distributed lock called "my-distributed-lock"
var lck = hz.GetLock("my-distributed-lock");
// Now create a lock and execute some guarded code.
lck.Lock();
try
{
//do something here
}
finally
{
lck.Unlock();
}
// Shutdown this Hazelcast Client
hz.Shutdown();
}
public static void Run(string[] args)
{
// Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
var hz = HazelcastClient.NewHazelcastClient();
var rb = hz.GetRingbuffer <long>("rb");
// add two items into ring buffer
rb.Add(100);
rb.Add(200);
// we start from the oldest item.
// if you want to start from the next item, call rb.tailSequence()+1
var sequence = rb.HeadSequence();
Console.WriteLine(rb.ReadOne(sequence));
sequence += 1;
Console.WriteLine(rb.ReadOne(sequence));
// Shutdown this Hazelcast Client
hz.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <string, string>("listener-example");
var cdown = new CountdownEvent(3);
map.AddEntryListener(new EntryAdapter <string, string>
{
Added = e =>
{
Console.WriteLine("Key '{0}' with value ' {1}' was added.", e.GetKey(), e.GetValue());
cdown.Signal();
},
Updated = e =>
{
Console.WriteLine("Key '{0}' with value ' {1}' was added.", e.GetKey(), e.GetValue());
cdown.Signal();
},
Removed = e =>
{
Console.WriteLine("Key '{0}' with value ' {1}' was removed.", e.GetKey(), e.GetOldValue());
cdown.Signal();
}
}, true);
map.Put("key", "value"); //first put
map.Put("key", "valueNew"); //makes update
map.Remove("key");
cdown.Wait();
map.Destroy();
}
static void Main2(string[] args)
{
ClientConfig clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("192.168.1.162");
var hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
var hzMap = hazelcast.GetMap <string, string>("mylist");
//hzMap.Put("key1","Value1");
//hzMap.Put("key2","Value2");
//hzMap.Put("key3","Value3");
//hzMap.Put("key4","Value4");
Console.WriteLine(hzMap.Get("key1"));
Console.WriteLine(hzMap.Get("key2"));
Console.WriteLine(hzMap.Get("key3"));
Console.WriteLine(hzMap.Get("key4"));
Console.ReadKey();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <int, int>("predicate-example");
Console.WriteLine("Populating map");
for (int i = 0; i < 1000; i++)
{
map.Put(i, i);
}
Console.WriteLine("Map size: " + map.Size());
var partitionKey = 10;
//all keys on the same partition of the partitionKey will be returned
var allPartitionKeys = map.KeySet(new PartitionPredicate(partitionKey, Predicates.True()));
//keys less than 100 and on the same partition of the partitionKey will be returned
var result = map.KeySet(new PartitionPredicate(partitionKey, Predicates.IsLessThan("this", 100)));
Console.Write("\nKey set: ");
foreach (var key in result)
{
Console.Write(key + ", ");
}
client.Shutdown();
}
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 static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var theLock = client.GetLock("lock-example");
var i = 0;
Action increment = () =>
{
for (var j = 0; j < 100; j++)
{
theLock.Lock();
try
{
i++;
}
finally
{
theLock.Unlock();
}
}
};
var task1 = Task.Factory.StartNew(increment);
var task2 = Task.Factory.StartNew(increment);
Task.WaitAll(task1, task2);
Console.WriteLine("final value: " + i);
theLock.Destroy();
}
public static void Run(string[] args)
{
// Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
var hz = HazelcastClient.NewHazelcastClient();
// Get the Distributed Set from Cluster.
var set = hz.GetSet <string>("my-distributed-set");
// Add items to the set with duplicates
set.Add("item1");
set.Add("item1");
set.Add("item2");
set.Add("item2");
set.Add("item2");
set.Add("item3");
// Get the items. Note that there are no duplicates.
foreach (var item in set)
{
Console.WriteLine(item);
}
// Shutdown this Hazelcast client
hz.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var clientConfig = new ClientConfig();
var clientNetworkConfig = clientConfig.GetNetworkConfig();
clientNetworkConfig.GetCloudConfig()
.SetEnabled(true)
.SetDiscoveryToken("DISCOVERY_TOKEN_HASH"); //Discovery token copied from Cloud console
var client = HazelcastClient.NewHazelcastClient(clientConfig);
var map = client.GetMap <string, string>("ssl-example");
map.Put("key", "value");
Console.WriteLine("Key: " + map.Get("key"));
map.Destroy();
client.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var semaphore = client.GetSemaphore("example-semaphore");
semaphore.Init(1);
var i = 0;
Action increment = () =>
{
for (var j = 0; j < 100; j++)
{
semaphore.Acquire();
try
{
i++;
}
finally
{
semaphore.Release();
}
}
};
var task1 = Task.Factory.StartNew(increment);
var task2 = Task.Factory.StartNew(increment);
Task.WaitAll(task1, task2);
Console.WriteLine("Final value: " + i);
semaphore.Destroy();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var clientConfig = new Configuration();
var clientNetworkConfig = clientConfig.NetworkConfig;
clientNetworkConfig.ConfigureHazelcastCloud(hzCloudConfig =>
{
hzCloudConfig.Enabled = true;
hzCloudConfig.DiscoveryToken = "DISCOVERY_TOKEN_HASH";//Discovery token copied from Cloud console
});
//Server certificate will be validated by OS,
//Download and register the server trust store to your OS
clientNetworkConfig.ConfigureSSL(sslConfig =>
{
sslConfig.Enabled = true;
//in order to disable certificate validating uncomment below line
// sslConfig.ValidateCertificateChain = false;
//Client certificate file path downloaded from cloud console
sslConfig.CertificateFilePath = "CLIENT_PFX_CERTIFICATE_PATH";
});
var client = HazelcastClient.NewHazelcastClient(clientConfig);
var map = client.GetMap <string, string>("ssl-example");
map.Put("key", "value");
Console.WriteLine("Key: " + map.Get("key"));
map.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var clientConfig = new Configuration();
var clientNetworkConfig = clientConfig.NetworkConfig;
//replace with your actual server host/ip and port
clientNetworkConfig.AddAddress("127.0.0.1:5701");
//Server certificate will be validated by OS,
//signed certificates will just work,
//self-signed certificates should be registered by OS depended way and allowed.
clientNetworkConfig.ConfigureSSL(sslConfig =>
{
sslConfig.Enabled = true;
//in order to disable certificate validating uncomment below line
// sslConfig.ValidateCertificateChain = false;
//in order to validate the server certificate name use below
// sslConfig.ValidateCertificateName = true;
// sslConfig.CertificateName = "CERTIFICATE CN OR SAN VALUE HERE";
});
var client = HazelcastClient.NewHazelcastClient(clientConfig);
var map = client.GetMap <string, string>("ssl-example");
map.Put("key", "value");
Console.WriteLine("Key: " + map.Get("key"));
map.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var clientConfig = new Configuration();
clientConfig.ConfigureNetwork(networkConfig =>
{
//replace with your actual server host/ip and port
networkConfig.Addresses.Add("127.0.0.1:5701");
});
//Server certificate will be validated by OS,
//signed certificates will just work,
//self-signed certificates should be registered by OS depended way and allowed.
clientConfig.NetworkConfig.ConfigureSSL(sslConfig =>
{
sslConfig.Enabled = true;
//in order to disable certificate validating uncomment below line
// sslConfig.ValidateCertificateChain = false;
//Providing a client pfx certificate will enable mutual authenticating if server also configured mutual auth.
// sslConfig.CertificateFilePath = "CLIENT_PFX_CERTIFICATE_PATH";
});
var client = HazelcastClient.NewHazelcastClient(clientConfig);
var map = client.GetMap <string, string>("ssl-example");
map.Put("key", "value");
Console.WriteLine("Key: " + map.Get("key"));
map.Destroy();
client.Shutdown();
}
public static void Run(string[] args)
{
// Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
var hz = HazelcastClient.NewHazelcastClient();
// Get the Distributed MultiMap from Cluster.
var multiMap = hz.GetMultiMap <string, string>("my-distributed-multimap");
// Put values in the map against the same key
multiMap.Put("my-key", "value1");
multiMap.Put("my-key", "value2");
multiMap.Put("my-key", "value3");
// Print out all the values for associated with key called "my-key"
var values = multiMap.Get("my-key");
foreach (var item in values)
{
Console.WriteLine(item);
}
// remove specific key/value pair
multiMap.Remove("my-key", "value2");
// Shutdown this Hazelcast Client
hz.Shutdown();
}
public Cache(string[] hosts)
{
try
{
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress(hosts);
clientConfig.GetSerializationConfig().
AddPortableFactory(PersonPortableFactory.FACTORY_ID, new PersonPortableFactory());
_hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
_map = _hazelcast.GetMap <int, Person>("persons");
Console.WriteLine("Hazelcast cluster addresses:");
foreach (var h in hosts)
{
Console.WriteLine(h);
}
}
catch (Exception e)
{
Console.WriteLine("Hazelcast: connection failed.");
Console.WriteLine(e.Message);
}
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <string, HazelcastJsonValue>("json-example");
map.Put("item1", new HazelcastJsonValue("{ \"age\": 4 }"));
map.Put("item2", new HazelcastJsonValue("{ \"age\": 20 }"));
var result = map.Values(Predicates.IsLessThan("age", 6));
Console.WriteLine("Retrieved " + result.Count + " values whose age is less than 6.");
Console.WriteLine("Entry is: " + result.First().ToString());
Console.WriteLine("Finished");
client.Shutdown();
}
public async Task <ActionResult <IEnumerable <MetricItem> > > GetMetricItems(string userName)
{
// We should clear context each time
ClearContext();
string hazelcastIP = Environment.GetEnvironmentVariable("ENV_HIP");
if (string.IsNullOrEmpty(hazelcastIP))
{
hazelcastIP = "127.0.0.1";
}
var cfg = new ClientConfig();
cfg.GetNetworkConfig().AddAddress(hazelcastIP);
var client = HazelcastClient.NewHazelcastClient(cfg);
IMap <string, double> mapMetricsAggregatedData = client.GetMap <string, double>("metrics-aggregated-data");
ICollection <string> keys = mapMetricsAggregatedData.KeySet();
MetricItem metricItem;
foreach (var key in keys)
{
string[] keyParts = key.Split('*');
if (String.Equals(userName, keyParts[0]))
{
metricItem = new MetricItem();
metricItem.Id = key;
metricItem.Value = mapMetricsAggregatedData.Get(key);;
_context.MetricItems.Add(metricItem);
await _context.SaveChangesAsync();
}
}
return(await _context.MetricItems.ToListAsync());
}
/// <summary>
/// Starts the Hazelcast Client on 127.0.0.1, connects to an already running Hazelcast Cluster and gets the Distributed Map from Cluster
/// </summary>
public static void SetupStoreage()
{
var client = HazelcastClient.NewHazelcastClient();
mapMetricsAggregatedData = client.GetMap <string, double>("metrics-aggregated-data");
}
private static void Main(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
Environment.SetEnvironmentVariable("hazelcast.client.request.timeout", "250000");
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("192.168.2.50:5701");
clientConfig.GetNetworkConfig().SetConnectionAttemptLimit(1000);
hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
Console.WriteLine("Client Ready to go");
stats = new Stats();
//Thread.Sleep(100000);
if (args != null && args.Length > 0)
{
foreach (var _arg in args)
{
var arg = _arg.Trim();
//if (arg.startsWith("t")) {
// THREAD_COUNT = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("c")) {
// ENTRY_COUNT = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("v")) {
// VALUE_SIZE = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("g")) {
// GET_PERCENTAGE = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("p")) {
// PUT_PERCENTAGE = Integer.parseInt(arg.substring(1));
//}
}
}
else
{
Console.WriteLine("Help: sh test.sh t200 v130 p10 g85 ");
Console.WriteLine(" // means 200 threads, value-size 130 bytes, 10% put, 85% get");
Console.WriteLine("");
}
Console.WriteLine("Starting Test with ");
Console.WriteLine(" Thread Count: " + THREAD_COUNT);
Console.WriteLine(" Entry Count: " + ENTRY_COUNT);
Console.WriteLine(" Value Size: " + VALUE_SIZE);
Console.WriteLine(" Get Percentage: " + GET_PERCENTAGE);
Console.WriteLine(" Put Percentage: " + PUT_PERCENTAGE);
Console.WriteLine(" Remove Percentage: " + (100 - (PUT_PERCENTAGE + GET_PERCENTAGE)));
var tasks = new List <Task>();
for (var i = 0; i < THREAD_COUNT; i++)
{
var t = new Task(() => HzTask(hazelcast), TaskCreationOptions.LongRunning);
tasks.Add(t);
t.Start();
}
var tm = new Thread(StatDisplayTask);
tm.Start();
Task.WaitAll(tasks.ToArray());
tm.Abort();
Console.WriteLine("--THE END--");
//Task.Factory.StartNew(StatDisplayTask);
//startNew.Wait();
//StatDisplayTask();
//Task.Factory.Scheduler.MaximumConcurrencyLevel = THREAD_COUNT;
Console.ReadKey();
}
