/// <summary>
/// Verifies received messages against expected messages.
/// </summary>
/// <param name="cluster">Cluster.</param>
/// <param name="expectedMessages">Expected messages.</param>
/// <param name="resultFunc">Result transform function.</param>
/// <param name="expectedRepeat">Expected repeat count.</param>
public static void VerifyReceive(IClusterGroup cluster, IEnumerable <string> expectedMessages,
Func <IEnumerable <string>, IEnumerable <string> > resultFunc, int expectedRepeat)
{
expectedMessages = expectedMessages.SelectMany(x => Enumerable.Repeat(x, expectedRepeat)).ToArray();
var expectedMessagesStr = string.Join(", ", expectedMessages);
// check if expected message count has been received; Wait returns false if there were none.
Assert.IsTrue(ReceivedEvent.Wait(MessageTimeout),
string.Format("expectedMessages: {0}, expectedRepeat: {1}, remaining: {2}",
expectedMessagesStr, expectedRepeat, ReceivedEvent.CurrentCount));
var receivedMessages = ReceivedMessages.ToArray();
var actualMessages = resultFunc(receivedMessages.Select(m => m.Message)).ToArray();
CollectionAssert.AreEqual(
expectedMessages,
actualMessages,
string.Format("Expected messages: '{0}', actual messages: '{1}', expectedRepeat: {2}",
expectedMessagesStr,
string.Join(", ", receivedMessages.Select(x => x.ToString())),
expectedRepeat));
// check that all messages came from local node.
var localNodeId = cluster.Ignite.GetCluster().GetLocalNode().Id;
Assert.AreEqual(localNodeId, ReceivedMessages.Select(m => m.NodeId).Distinct().Single());
AssertFailures();
}
public void TestForLocal()
{
IClusterGroup prj = _grid1.GetCluster().ForLocal();
Assert.AreEqual(1, prj.GetNodes().Count);
Assert.AreEqual(_grid1.GetCluster().GetLocalNode(), prj.GetNodes().First());
}
/// <summary>
/// Initializes a new instance of the <see cref="Events" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="clusterGroup">Cluster group.</param>
public Events(IPlatformTargetInternal target, IClusterGroup clusterGroup)
: base(target)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
}
public void TestForCacheNodes()
{
ICollection <IClusterNode> nodes = _grid1.GetCluster().GetNodes();
// Cache nodes.
IClusterGroup prjCache = _grid1.GetCluster().ForCacheNodes("cache1");
Assert.AreEqual(2, prjCache.GetNodes().Count);
Assert.IsTrue(nodes.Contains(prjCache.GetNodes().ElementAt(0)));
Assert.IsTrue(nodes.Contains(prjCache.GetNodes().ElementAt(1)));
// Data nodes.
IClusterGroup prjData = _grid1.GetCluster().ForDataNodes("cache1");
Assert.AreEqual(2, prjData.GetNodes().Count);
Assert.IsTrue(prjCache.GetNodes().Contains(prjData.GetNodes().ElementAt(0)));
Assert.IsTrue(prjCache.GetNodes().Contains(prjData.GetNodes().ElementAt(1)));
// Client nodes.
IClusterGroup prjClient = _grid1.GetCluster().ForClientNodes("cache1");
Assert.AreEqual(0, prjClient.GetNodes().Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="Events" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
public Events(IUnmanagedTarget target, Marshaller marsh, IClusterGroup clusterGroup)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
}
/// <summary>
/// Initializes a new instance of the <see cref="Events" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
public Events(IUnmanagedTarget target, Marshaller marsh, IClusterGroup clusterGroup)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
_asyncInstance = new Lazy <Events>(() => new Events(this));
}
/// <summary>
/// Initializes a new instance of the <see cref="Events"/> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
public Events(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
ClusterGroup = clusterGroup;
Ignite = (Ignite)clusterGroup.Ignite;
}
/// <summary>
/// Initializes a new instance of the <see cref="Messaging" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="prj">Cluster group.</param>
public Messaging(IPlatformTargetInternal target, IClusterGroup prj)
: base(target)
{
Debug.Assert(prj != null);
_clusterGroup = prj;
_ignite = (Ignite)prj.Ignite;
}
/// <summary>
/// Initializes a new instance of the <see cref="Messaging" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="prj">Cluster group.</param>
public Messaging(IUnmanagedTarget target, Marshaller marsh, IClusterGroup prj)
: base(target, marsh)
{
Debug.Assert(prj != null);
_clusterGroup = prj;
_ignite = (Ignite)prj.Ignite;
}
/** <inheritdoc /> */
public IEvents Events(IClusterGroup clusterGroup)
{
if (clusterGroup == null)
{
throw new ArgumentNullException("clusterGroup");
}
return(clusterGroup.Events());
}
/// <summary>
/// Initializes a new instance of the <see cref="Services" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepBinary">Invoker binary flag.</param>
/// <param name="srvKeepBinary">Server binary flag.</param>
public Services(IUnmanagedTarget target, Marshaller marsh, IClusterGroup clusterGroup,
bool keepBinary, bool srvKeepBinary)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
_keepBinary = keepBinary;
_srvKeepBinary = srvKeepBinary;
}
/// <summary>
/// Initializes a new instance of the <see cref="Services" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepPortable">Invoker portable flag.</param>
/// <param name="srvKeepPortable">Server portable flag.</param>
public Services(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup,
bool keepPortable, bool srvKeepPortable)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
KeepPortable = keepPortable;
SrvKeepPortable = srvKeepPortable;
}
/// <summary>
/// Initializes a new instance of the <see cref="Services" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepBinary">Invoker binary flag.</param>
/// <param name="srvKeepBinary">Server binary flag.</param>
public Services(IPlatformTargetInternal target, IClusterGroup clusterGroup,
bool keepBinary, bool srvKeepBinary)
: base(target)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
_keepBinary = keepBinary;
_srvKeepBinary = srvKeepBinary;
}
public void TestForRemotes()
{
ICollection <IClusterNode> nodes = _grid1.GetCluster().GetNodes();
IClusterGroup prj = _grid1.GetCluster().ForRemotes();
Assert.AreEqual(2, prj.GetNodes().Count);
Assert.IsTrue(nodes.Contains(prj.GetNodes().ElementAt(0)));
Assert.IsTrue(nodes.Contains(prj.GetNodes().ElementAt(1)));
}
public void TestForAttribute()
{
ICollection <IClusterNode> nodes = _grid1.GetCluster().GetNodes();
IClusterGroup prj = _grid1.GetCluster().ForAttribute("my_attr", "value1");
Assert.AreEqual(1, prj.GetNodes().Count);
Assert.IsTrue(nodes.Contains(prj.GetNode()));
Assert.AreEqual("value1", prj.GetNodes().First().GetAttribute <string>("my_attr"));
}
public void TestProjection()
{
IClusterGroup prj = _grid1.GetCluster();
Assert.NotNull(prj);
Assert.AreEqual(prj, prj.Ignite);
// Check that default Compute projection excludes client nodes.
CollectionAssert.AreEquivalent(prj.ForServers().GetNodes(), prj.GetCompute().ClusterGroup.GetNodes());
}
/// <summary>
/// Initializes a new instance of the <see cref="Messaging" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="prj">Cluster group.</param>
public Messaging(IUnmanagedTarget target, Marshaller marsh, IClusterGroup prj)
: base(target, marsh)
{
Debug.Assert(prj != null);
_clusterGroup = prj;
_ignite = (Ignite)prj.Ignite;
_asyncInstance = new Lazy <Messaging>(() => new Messaging(this));
}
/// <summary>
/// Initializes a new instance of the <see cref="Services" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepBinary">Invoker binary flag.</param>
/// <param name="srvKeepBinary">Server binary flag.</param>
public Services(IUnmanagedTarget target, Marshaller marsh, IClusterGroup clusterGroup,
bool keepBinary, bool srvKeepBinary)
: base(target, marsh)
{
Debug.Assert(clusterGroup != null);
_clusterGroup = clusterGroup;
_keepBinary = keepBinary;
_srvKeepBinary = srvKeepBinary;
_asyncInstance = new Lazy <Services>(() => new Services(this));
}
/** <inheritDoc /> */
public ICacheMetrics GetMetrics(IClusterGroup clusterGroup)
{
IgniteArgumentCheck.NotNull(clusterGroup, "clusterGroup");
var prj = clusterGroup as ClusterGroupImpl;
if (prj == null)
{
throw new ArgumentException("Unexpected IClusterGroup implementation: " + clusterGroup.GetType());
}
return(prj.GetCacheMetrics(Name));
}
public void TestForNodes()
{
ICollection <IClusterNode> nodes = _grid1.GetCluster().GetNodes();
IClusterNode first = nodes.ElementAt(0);
IClusterNode second = nodes.ElementAt(1);
IClusterGroup singleNodePrj = _grid1.GetCluster().ForNodeIds(first.Id);
Assert.AreEqual(1, singleNodePrj.GetNodes().Count);
Assert.AreEqual(first.Id, singleNodePrj.GetNodes().First().Id);
singleNodePrj = _grid1.GetCluster().ForNodeIds(new List <Guid> {
first.Id
});
Assert.AreEqual(1, singleNodePrj.GetNodes().Count);
Assert.AreEqual(first.Id, singleNodePrj.GetNodes().First().Id);
singleNodePrj = _grid1.GetCluster().ForNodes(first);
Assert.AreEqual(1, singleNodePrj.GetNodes().Count);
Assert.AreEqual(first.Id, singleNodePrj.GetNodes().First().Id);
singleNodePrj = _grid1.GetCluster().ForNodes(new List <IClusterNode> {
first
});
Assert.AreEqual(1, singleNodePrj.GetNodes().Count);
Assert.AreEqual(first.Id, singleNodePrj.GetNodes().First().Id);
IClusterGroup multiNodePrj = _grid1.GetCluster().ForNodeIds(first.Id, second.Id);
Assert.AreEqual(2, multiNodePrj.GetNodes().Count);
Assert.IsTrue(multiNodePrj.GetNodes().Contains(first));
Assert.IsTrue(multiNodePrj.GetNodes().Contains(second));
multiNodePrj = _grid1.GetCluster().ForNodeIds(new[] { first, second }.Select(x => x.Id));
Assert.AreEqual(2, multiNodePrj.GetNodes().Count);
Assert.IsTrue(multiNodePrj.GetNodes().Contains(first));
Assert.IsTrue(multiNodePrj.GetNodes().Contains(second));
multiNodePrj = _grid1.GetCluster().ForNodes(first, second);
Assert.AreEqual(2, multiNodePrj.GetNodes().Count);
Assert.IsTrue(multiNodePrj.GetNodes().Contains(first));
Assert.IsTrue(multiNodePrj.GetNodes().Contains(second));
multiNodePrj = _grid1.GetCluster().ForNodes(new List <IClusterNode> {
first, second
});
Assert.AreEqual(2, multiNodePrj.GetNodes().Count);
Assert.IsTrue(multiNodePrj.GetNodes().Contains(first));
Assert.IsTrue(multiNodePrj.GetNodes().Contains(second));
}
public void TestForPredicate()
{
IClusterGroup prj1 = _grid1.GetCluster().ForPredicate(new NotAttributePredicate("value1").Apply);
Assert.AreEqual(2, prj1.GetNodes().Count);
IClusterGroup prj2 = prj1.ForPredicate(new NotAttributePredicate("value2").Apply);
Assert.AreEqual(1, prj2.GetNodes().Count);
string val;
prj2.GetNodes().First().TryGetAttribute("my_attr", out val);
Assert.IsTrue(val == null || (!val.Equals("value1") && !val.Equals("value2")));
}
/// <summary>
/// Verifies received messages against expected messages.
/// </summary>
/// <param name="cluster">Cluster.</param>
/// <param name="expectedMessages">Expected messages.</param>
/// <param name="resultFunc">Result transform function.</param>
/// <param name="expectedRepeat">Expected repeat count.</param>
public static void VerifyReceive(IClusterGroup cluster, IEnumerable <string> expectedMessages,
Func <IEnumerable <string>, IEnumerable <string> > resultFunc, int expectedRepeat)
{
// check if expected message count has been received; Wait returns false if there were none.
Assert.IsTrue(ReceivedEvent.Wait(MessageTimeout));
expectedMessages = expectedMessages.SelectMany(x => Enumerable.Repeat(x, expectedRepeat));
Assert.AreEqual(expectedMessages, resultFunc(ReceivedMessages));
// check that all messages came from local node.
var localNodeId = cluster.Ignite.GetCluster().GetLocalNode().Id;
Assert.AreEqual(localNodeId, LastNodeIds.Distinct().Single());
AssertFailures();
}
public void TestForOldestYoungestRandom()
{
ICollection <IClusterNode> nodes = _grid1.GetCluster().GetNodes();
IClusterGroup prj = _grid1.GetCluster().ForYoungest();
Assert.AreEqual(1, prj.GetNodes().Count);
Assert.IsTrue(nodes.Contains(prj.GetNode()));
prj = _grid1.GetCluster().ForOldest();
Assert.AreEqual(1, prj.GetNodes().Count);
Assert.IsTrue(nodes.Contains(prj.GetNode()));
prj = _grid1.GetCluster().ForRandom();
Assert.AreEqual(1, prj.GetNodes().Count);
Assert.IsTrue(nodes.Contains(prj.GetNode()));
}
public ClusterController(ICluster clusterSvc, IClusterGroup clusterGroupSvc)
{
_clusterSvc = clusterSvc;
_clusterGroupSvc = clusterGroupSvc;
}
/// <summary>
/// Initializes a new async instance.
/// </summary>
/// <param name="events">The events.</param>
private Events(Events events) : base(UU.EventsWithAsync(events.Target), events.Marshaller)
{
_clusterGroup = events.ClusterGroup;
}
public ClusterGroupController(IClusterGroup clusterGroupSvc)
{
_clusterGroupSvc = clusterGroupSvc;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServicesAsync" /> class.
/// </summary>
/// <param name="target">Target.</param>
/// <param name="marsh">Marshaller.</param>
/// <param name="clusterGroup">Cluster group.</param>
/// <param name="keepPortable">Portable flag.</param>
/// <param name="srvKeepPortable">Server portable flag.</param>
public ServicesAsync(IUnmanagedTarget target, PortableMarshaller marsh, IClusterGroup clusterGroup,
bool keepPortable, bool srvKeepPortable)
: base(target, marsh, clusterGroup, keepPortable, srvKeepPortable)
{
// No-op
}
static void Main(string[] args)
{
string s;
DateTime startTime;
DateTime endTime;
IgniteConfiguration cfg = new IgniteConfiguration()
{
IgniteInstanceName = "TRex",
// Register custom class for Ignite serialization
BinaryConfiguration = new Apache.Ignite.Core.Binary.BinaryConfiguration(typeof(MyCacheClass))
};
IIgnite ignite = Ignition.Start(cfg);
// Add a cache to Ignite
ICache <string, MyCacheClass> cache = ignite.CreateCache <string, MyCacheClass>
(new CacheConfiguration()
{
Name = "TestCache",
CopyOnRead = false,
KeepBinaryInStore = false,
CacheStoreFactory = new TRexCacheStoreFactory(),
ReadThrough = true,
WriteThrough = true,
WriteBehindFlushFrequency = new TimeSpan(0, 0, 5), // 5 seconds
EvictionPolicy = new LruEvictionPolicy()
{
MaxMemorySize = 1000000,
}
});
int NumCacheEntries = 5000;
// Add a cache item
cache.Put("First", new MyCacheClass("FirstItem"));
// Add a collectikon of items
startTime = DateTime.Now;
for (int i = 0; i < NumCacheEntries; i++)
{
cache.Put("First" + i, new MyCacheClass("First" + i));
}
endTime = DateTime.Now;
s = string.Format("{0}", endTime - startTime);
Console.WriteLine("Time to add cache items with serialisation: {0}", s);
int sumsum = 0;
// Query back the cache items with serialisation
startTime = DateTime.Now;
for (int i = 0; i < NumCacheEntries; i++)
{
MyCacheClass first = cache.Get("First" + i);
int sum = 0;
for (int ii = 0; ii < first.localData.Length; ii++)
{
sum += first.localData[ii];
}
sumsum += sum;
}
endTime = DateTime.Now;
s = string.Format("{0}", endTime - startTime);
Console.WriteLine("Time to query cache items with serialisation: {0}, sum = {1}", s, sumsum);
var binCache = cache.WithKeepBinary <string, IBinaryObject>();
// IBinaryObject binCacheItem = binCache["First"];
// Console.WriteLine(binCacheItem.GetField<string>("Name"));
// Query back the cache items without serialisation (using BinaryObject)
startTime = DateTime.Now;
for (int i = 0; i < NumCacheEntries; i++)
{
IBinaryObject binCacheItem = binCache["First" + i];
byte[] bytes = binCacheItem.GetField <byte[]>("localData");
int sum = 0;
for (int ii = 0; ii < bytes.Length; ii++)
{
sum += bytes[ii];
}
sumsum += sum;
}
endTime = DateTime.Now;
s = string.Format("{0}", endTime - startTime);
Console.WriteLine("Time to query cache items without serialisation: {0}, sum = {1}", s, sumsum);
// Get compute instance over all nodes in the cluster.
ICompute compute = ignite.GetCompute();
IClusterGroup compute2 = ignite.GetCompute().ClusterGroup;
// Execute a map reduce on the cluster
if (compute2.ForServers()?.GetNodes()?.Any() == true)
{
try
{
string mapReduceResult = ignite.GetCompute().Execute <string, string, string>(new MyComputeTask(), "Bob");
Console.WriteLine("Mapreduce result = '{0}'", mapReduceResult);
}
catch (Exception e)
{
Console.WriteLine("Exception executing mapReduce execution\r\n: {0}", e);
}
}
else
{
Console.WriteLine("Calling cluster mapReduce broadcast function: No servers present in cluster");
}
// Execute a command using affinity on the cluster
try
{
string affinityResult = ignite.GetCompute().AffinityCall <string>("TestCache", "First", new AffinityComputeFunc("First"));
Console.WriteLine("Affinity result = '{0}'", affinityResult);
}
catch (Exception e)
{
Console.WriteLine("Exception executing affinity execution\r\n: {0}", e);
}
if (ignite == null)
{
Console.WriteLine("Ignite instance is null at end of method");
}
Console.ReadKey();
}
/** <inheritdoc /> */
public ICompute Compute(IClusterGroup clusterGroup)
{
IgniteArgumentCheck.NotNull(clusterGroup, "clusterGroup");
return(clusterGroup.Compute());
}
/** <inheritDoc /> */
public ICacheMetrics GetMetrics(IClusterGroup clusterGroup)
{
return(_cache.GetMetrics(clusterGroup));
}
public ICacheMetrics GetMetrics(IClusterGroup clusterGroup)
{
throw new NotImplementedException();
}
/** <inheritdoc /> */
public IMessaging Message(IClusterGroup clusterGroup)
{
IgniteArgumentCheck.NotNull(clusterGroup, "clusterGroup");
return(clusterGroup.Message());
}
