/// <summary>
/// Invokes local filter using data from specified stream.
/// </summary>
/// <typeparam name="T">Event object type.</typeparam>
/// <param name="stream">The stream.</param>
/// <param name="listener">The listener.</param>
/// <returns>Filter invocation result.</returns>
private bool InvokeLocalFilter <T>(IPortableStream stream, IEventFilter <T> listener) where T : IEvent
{
var evt = EventReader.Read <T>(Marshaller.StartUnmarshal(stream));
// No guid in local mode
return(listener.Invoke(Guid.Empty, evt));
}
public static StackHashEventCollection GetEventsApi(ref Login login, ApplicationFile file, out List <Event> rawEvents, DateTime startTime)
{
EventPageReader eventPageReader = file.GetEvents(startTime); // Get all events.
StackHashEventCollection apiStackHashEvents = new StackHashEventCollection();
rawEvents = new List <Event>();
// Read each page of new events.
while (eventPageReader.Read(ref login) == true)
{
// Get the events for the page.
EventReader events = eventPageReader.Events;
while (events.Read() == true)
{
// Get the event
Event dpEvent = events.Event;
rawEvents.Add(dpEvent);
StackHashEvent stackHashEvent = ObjectConversion.ConvertEvent(dpEvent, file.ID);
apiStackHashEvents.Add(stackHashEvent);
}
}
return(apiStackHashEvents);
}
public Event GetEvent(string pr,
string fi,
int eventId,
ref Login login)
{
foreach (Product p in Product.GetProducts(ref login))
{
if (p.Name == pr)
{
ApplicationFileCollection ac =
p.GetApplicationFiles(ref login);
foreach (ApplicationFile file in ac)
{
if (file.Name == fi)
{
EventPageReader epr = file.GetEvents();
while (epr.Read(ref login) == true)
{
EventReader er = epr.Events;
while (er.Read() == true)
{
Event e = er.Event;
return(e);
}
}
}
}
}
}
throw new Exception("Event Not Found");
}
/// <summary>
/// Waits for the specified events.
/// </summary>
/// <typeparam name="T">Type of events.</typeparam>
/// <param name="filter">Optional filtering predicate. Event wait will end as soon as it returns false.</param>
/// <param name="handle">The filter handle, if applicable.</param>
/// <param name="types">Types of the events to wait for.
/// If not provided, all events will be passed to the filter.</param>
/// <returns>Ignite event.</returns>
private T WaitForLocal0 <T>(IEventFilter <T> filter, ref long handle, params int[] types) where T : IEvent
{
if (filter != null)
{
handle = Ignite.HandleRegistry.Allocate(new LocalEventFilter
{
InvokeFunc = stream => InvokeLocalFilter(stream, filter)
});
}
var hnd = handle;
return(DoOutInOp((int)Op.WaitForLocal,
writer =>
{
if (filter != null)
{
writer.WriteBoolean(true);
writer.WriteLong(hnd);
}
else
{
writer.WriteBoolean(false);
}
WriteEventTypes(types, writer);
},
reader => EventReader.Read <T>(Marshaller.StartUnmarshal(reader))));
}
/** <inheritdoc /> */
public int Invoke(IPortableStream stream)
{
var reader = _ignite.Marshaller.StartUnmarshal(stream);
var evt = EventReader.Read <IEvent>(reader);
var nodeId = reader.ReadGuid() ?? Guid.Empty;
return(_filter(nodeId, evt) ? 1 : 0);
}
/** <inheritdoc /> */
public int Invoke(IBinaryStream stream)
{
var reader = _ignite.Marshaller.StartUnmarshal(stream);
var evt = EventReader.Read <IEvent>(reader);
reader.ReadGuid(); // unused node id
return(_filter(evt) ? 1 : 0);
}
public void ReturnErrosWithInvalidJson()
{
//Arrange
var basePath = filePathHelper();
var fileLocation = "TestJsonFile\\exception.json";
var filePath = Path.Combine(basePath, fileLocation);
var reader = new EventReader();
//Act
var result = reader.Read(filePath);
//Assert
Assert.Null(result.Events);
Assert.NotEmpty(result.Errors);
}
/// <summary>
/// Reads events from a portable reader.
/// </summary>
/// <typeparam name="T">Event type.</typeparam>
/// <param name="portableReader">Reader.</param>
/// <returns>Resulting list or null.</returns>
protected static List <T> ReadEvents <T>(PortableReaderImpl portableReader) where T : IEvent
{
var count = portableReader.RawReader().ReadInt();
if (count == -1)
{
return(null);
}
var result = new List <T>(count);
for (var i = 0; i < count; i++)
{
result.Add(EventReader.Read <T>(portableReader));
}
return(result);
}
/// <summary>
/// Reads events from a binary reader.
/// </summary>
/// <typeparam name="T">Event type.</typeparam>
/// <param name="binaryReader">Reader.</param>
/// <returns>Resulting list or null.</returns>
private static ICollection <T> ReadEvents <T>(BinaryReader binaryReader) where T : IEvent
{
var count = binaryReader.GetRawReader().ReadInt();
if (count == -1)
{
return(null);
}
var result = new List <T>(count);
for (var i = 0; i < count; i++)
{
result.Add(EventReader.Read <T>(binaryReader));
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="AffinityFunctionContext"/> class.
/// </summary>
/// <param name="reader">The reader.</param>
internal AffinityFunctionContext(IBinaryRawReader reader)
{
var cnt = reader.ReadInt();
if (cnt > 0)
{
_previousAssignment = new List <List <IClusterNode> >(cnt);
for (var i = 0; i < cnt; i++)
{
_previousAssignment.Add(IgniteUtils.ReadNodes(reader));
}
}
_backups = reader.ReadInt();
_currentTopologySnapshot = IgniteUtils.ReadNodes(reader);
_currentTopologyVersion = new AffinityTopologyVersion(reader.ReadLong(), reader.ReadInt());
_discoveryEvent = EventReader.Read <DiscoveryEvent>(reader);
}
/** <inheritdoc /> */
public override IFuture <T> GetFuture <T>()
{
if (_curFut.Value != null)
{
var fut = _curFut.Value;
_curFut.Value = null;
return((IFuture <T>)fut);
}
Func <PortableReaderImpl, T> converter = null;
if (_lastAsyncOp.Value == (int)Op.WaitForLocal)
{
converter = reader => (T)EventReader.Read <IEvent>(reader);
}
return(GetFuture((futId, futTyp) => UU.TargetListenFutureForOperation(Target, futId, futTyp, _lastAsyncOp.Value),
convertFunc: converter));
}
public void ReturnEventsWithValidJson()
{
//Arrange
var basePath = filePathHelper();
var fileLocation = "TestJsonFile\\departure.json";
var filePath = Path.Combine(basePath, fileLocation);
var reader = new EventReader();
var expect = "Departure";
//Act
var result = reader.Read(filePath);
//Assert
Assert.Empty(result.Errors);
Assert.NotEmpty(result.Events);
Assert.Equal(expect, result.Events[0].EventType.ToString());
}
/** <inheritDoc /> */
public T WaitForLocal <T>(IEventFilter <T> filter, params int[] types) where T : IEvent
{
var hnd = GetFilterHandle(filter);
try
{
return(DoOutInOp((int)Op.WaitForLocal,
writer =>
{
writer.WriteObject(hnd);
WriteEventTypes(types, writer);
},
reader => EventReader.Read <T>(Marshaller.StartUnmarshal(reader))));
}
finally
{
if (hnd != null)
{
Ignite.HandleRegistry.Release(hnd.Value);
}
}
}
public void TestSerialization()
{
var grid = (Ignite)_grid1;
var comp = (ImplCompute)grid.GetCluster().ForLocal().GetCompute();
var locNode = grid.GetCluster().GetLocalNode();
var expectedGuid = Guid.Parse("00000000-0000-0001-0000-000000000002");
var expectedGridGuid = new IgniteGuid(expectedGuid, 3);
using (var inStream = IgniteManager.Memory.Allocate().GetStream())
{
var result = comp.ExecuteJavaTask <bool>("org.apache.ignite.platform.PlatformEventsWriteEventTask",
inStream.MemoryPointer);
Assert.IsTrue(result);
inStream.SynchronizeInput();
var reader = grid.Marshaller.StartUnmarshal(inStream);
var cacheEvent = EventReader.Read <CacheEvent>(reader);
CheckEventBase(cacheEvent);
Assert.AreEqual("cacheName", cacheEvent.CacheName);
Assert.AreEqual(locNode, cacheEvent.EventNode);
Assert.AreEqual(1, cacheEvent.Partition);
Assert.AreEqual(true, cacheEvent.IsNear);
Assert.AreEqual(2, cacheEvent.Key);
Assert.AreEqual(expectedGridGuid, cacheEvent.Xid);
Assert.AreEqual(4, cacheEvent.NewValue);
Assert.AreEqual(true, cacheEvent.HasNewValue);
Assert.AreEqual(5, cacheEvent.OldValue);
Assert.AreEqual(true, cacheEvent.HasOldValue);
Assert.AreEqual(expectedGuid, cacheEvent.SubjectId);
Assert.AreEqual("cloClsName", cacheEvent.ClosureClassName);
Assert.AreEqual("taskName", cacheEvent.TaskName);
Assert.IsTrue(cacheEvent.ToShortString().StartsWith("NODE_FAILED: IsNear="));
var qryExecEvent = EventReader.Read <CacheQueryExecutedEvent>(reader);
CheckEventBase(qryExecEvent);
Assert.AreEqual("qryType", qryExecEvent.QueryType);
Assert.AreEqual("cacheName", qryExecEvent.CacheName);
Assert.AreEqual("clsName", qryExecEvent.ClassName);
Assert.AreEqual("clause", qryExecEvent.Clause);
Assert.AreEqual(expectedGuid, qryExecEvent.SubjectId);
Assert.AreEqual("taskName", qryExecEvent.TaskName);
Assert.AreEqual(
"NODE_FAILED: QueryType=qryType, CacheName=cacheName, ClassName=clsName, Clause=clause, " +
"SubjectId=00000000-0000-0001-0000-000000000002, TaskName=taskName", qryExecEvent.ToShortString());
var qryReadEvent = EventReader.Read <CacheQueryReadEvent>(reader);
CheckEventBase(qryReadEvent);
Assert.AreEqual("qryType", qryReadEvent.QueryType);
Assert.AreEqual("cacheName", qryReadEvent.CacheName);
Assert.AreEqual("clsName", qryReadEvent.ClassName);
Assert.AreEqual("clause", qryReadEvent.Clause);
Assert.AreEqual(expectedGuid, qryReadEvent.SubjectId);
Assert.AreEqual("taskName", qryReadEvent.TaskName);
Assert.AreEqual(1, qryReadEvent.Key);
Assert.AreEqual(2, qryReadEvent.Value);
Assert.AreEqual(3, qryReadEvent.OldValue);
Assert.AreEqual(4, qryReadEvent.Row);
Assert.AreEqual(
"NODE_FAILED: QueryType=qryType, CacheName=cacheName, ClassName=clsName, Clause=clause, " +
"SubjectId=00000000-0000-0001-0000-000000000002, TaskName=taskName, Key=1, Value=2, " +
"OldValue=3, Row=4", qryReadEvent.ToShortString());
var cacheRebalancingEvent = EventReader.Read <CacheRebalancingEvent>(reader);
CheckEventBase(cacheRebalancingEvent);
Assert.AreEqual("cacheName", cacheRebalancingEvent.CacheName);
Assert.AreEqual(1, cacheRebalancingEvent.Partition);
Assert.AreEqual(locNode, cacheRebalancingEvent.DiscoveryNode);
Assert.AreEqual(2, cacheRebalancingEvent.DiscoveryEventType);
Assert.AreEqual(3, cacheRebalancingEvent.DiscoveryTimestamp);
Assert.IsTrue(cacheRebalancingEvent.ToShortString().StartsWith(
"NODE_FAILED: CacheName=cacheName, Partition=1, DiscoveryNode=GridNode"));
var checkpointEvent = EventReader.Read <CheckpointEvent>(reader);
CheckEventBase(checkpointEvent);
Assert.AreEqual("cpKey", checkpointEvent.Key);
Assert.AreEqual("NODE_FAILED: Key=cpKey", checkpointEvent.ToShortString());
var discoEvent = EventReader.Read <DiscoveryEvent>(reader);
CheckEventBase(discoEvent);
Assert.AreEqual(grid.TopologyVersion, discoEvent.TopologyVersion);
Assert.AreEqual(grid.GetNodes(), discoEvent.TopologyNodes);
Assert.IsTrue(discoEvent.ToShortString().StartsWith("NODE_FAILED: EventNode=GridNode"));
var jobEvent = EventReader.Read <JobEvent>(reader);
CheckEventBase(jobEvent);
Assert.AreEqual(expectedGridGuid, jobEvent.JobId);
Assert.AreEqual("taskClsName", jobEvent.TaskClassName);
Assert.AreEqual("taskName", jobEvent.TaskName);
Assert.AreEqual(locNode, jobEvent.TaskNode);
Assert.AreEqual(expectedGridGuid, jobEvent.TaskSessionId);
Assert.AreEqual(expectedGuid, jobEvent.TaskSubjectId);
Assert.IsTrue(jobEvent.ToShortString().StartsWith("NODE_FAILED: TaskName=taskName"));
var taskEvent = EventReader.Read <TaskEvent>(reader);
CheckEventBase(taskEvent);
Assert.AreEqual(true, taskEvent.Internal);
Assert.AreEqual(expectedGuid, taskEvent.SubjectId);
Assert.AreEqual("taskClsName", taskEvent.TaskClassName);
Assert.AreEqual("taskName", taskEvent.TaskName);
Assert.AreEqual(expectedGridGuid, taskEvent.TaskSessionId);
Assert.IsTrue(taskEvent.ToShortString().StartsWith("NODE_FAILED: TaskName=taskName"));
}
}
/** <inheritdoc /> */
public int Invoke(IBinaryStream stream)
{
var evt = EventReader.Read <T>(_marshaller.StartUnmarshal(stream));
return(_listener.Invoke(evt) ? 1 : 0);
}
/// <summary>
/// Invokes local filter using data from specified stream.
/// </summary>
/// <typeparam name="T">Event object type.</typeparam>
/// <param name="stream">The stream.</param>
/// <param name="listener">The listener.</param>
/// <returns>Filter invocation result.</returns>
private bool InvokeLocalListener <T>(IBinaryStream stream, IEventListener <T> listener) where T : IEvent
{
var evt = EventReader.Read <T>(Marshaller.StartUnmarshal(stream));
return(listener.Invoke(evt));
}
/** <inheritDoc /> */
public Task <T> WaitForLocalAsync <T>(IEventFilter <T> filter, params int[] types) where T : IEvent
{
long hnd = 0;
try
{
AsyncInstance.WaitForLocal0(filter, ref hnd, types);
// ReSharper disable once RedundantTypeArgumentsOfMethod (won't compile in VS2010)
var fut = GetFuture <T>((futId, futTyp) => UU.TargetListenFutureForOperation(AsyncInstance.Target, futId,
futTyp, (int)Op.WaitForLocal), convertFunc: reader => (T)EventReader.Read <IEvent>(reader));
if (filter != null)
{
// Dispose handle as soon as future ends.
fut.Task.ContinueWith(x => Ignite.HandleRegistry.Release(hnd));
}
return(fut.Task);
}
catch (Exception)
{
Ignite.HandleRegistry.Release(hnd);
throw;
}
}
private void UpdateEvents(DateTime lastPullDate, IErrorIndex errorIndex,
StackHashProduct stackHashProduct, bool getCabs, ApplicationFile file, StackHashFile stackHashFile)
{
// Get the events for the file with the start date as last pull date + 1.
// Only stores the last 90 days worth - this will exception if you specify a date
// before that time. In the case of the last pulldown date being close to 90 days ago
// just get ALL the events.
DateTime startTime = lastPullDate; // This is a local time.
EventPageReader eventPageReader;
TimeSpan timeSinceLastSync = (DateTime.UtcNow - lastPullDate.ToUniversalTime());
if (timeSinceLastSync.Days >= 89)
{
StackHashUtilities.DiagnosticsHelper.LogMessage(DiagSeverity.Information,
String.Format(CultureInfo.InvariantCulture, "Updating Events for {0} {1} ALL",
stackHashProduct.Name, stackHashFile.Name));
eventPageReader = file.GetEvents(); // Get all events.
}
else
{
StackHashUtilities.DiagnosticsHelper.LogMessage(DiagSeverity.Information,
String.Format(CultureInfo.InvariantCulture, "Updating Events for {0} {1} since {2} {3}",
stackHashProduct.Name, stackHashFile.Name, startTime, startTime.Kind));
eventPageReader = file.GetEvents(startTime);
}
// Read each page of new events.
while (eventPageReader.Read(ref m_Login) == true)
{
if (m_AbortRequested)
{
throw new OperationCanceledException("Abort requested during Win Qual synchronize");
}
// Get the events for the page.
EventReader events = eventPageReader.Events;
while (events.Read() == true)
{
if (m_AbortRequested)
{
throw new OperationCanceledException("Abort requested during Win Qual synchronize");
}
// Get the event
Event dpEvent = events.Event;
StackHashEvent stackHashEvent = ObjectConversion.ConvertEvent(dpEvent, stackHashFile.Id);
m_SyncProgress.EventId = stackHashEvent.Id;
m_SyncProgress.EventTypeName = stackHashEvent.EventTypeName;
// Check the date created. If it is greater than the last
// pull date then this is a new event and hence insert.
if (dpEvent.DateCreatedLocal > lastPullDate)
{
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
}
else if (dpEvent.DateModifiedLocal > lastPullDate)
{
// update the event information if event modified
// date is greater than the last pull date
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
}
else
{
// Check if the event exists. If not then add it.
if (!errorIndex.EventExists(stackHashProduct, stackHashFile, stackHashEvent))
{
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
}
}
// Get the details for the event.
EventInfoCollection infoCollection = dpEvent.GetEventDetails(ref m_Login);
// Loop through the event info.
StackHashEventInfo stackHashEventInfo = null;
StackHashEventInfoCollection stackHashEventInfoCollection = new StackHashEventInfoCollection();
foreach (EventInfo info in infoCollection)
{
if (m_AbortRequested)
{
throw new OperationCanceledException("Abort requested during Win Qual synchronize");
}
stackHashEventInfo = ObjectConversion.ConvertEventInfo(info);
stackHashEventInfoCollection.Add(stackHashEventInfo);
}
errorIndex.MergeEventInfoCollection(stackHashProduct, stackHashFile, stackHashEvent, stackHashEventInfoCollection);
// Now get the total hits.
StackHashEventInfoCollection newEventInfos = errorIndex.LoadEventInfoList(stackHashProduct, stackHashFile, stackHashEvent);
int hits = 0;
foreach (StackHashEventInfo theEvent in newEventInfos)
{
hits += theEvent.TotalHits;
}
// Update the hits count.
stackHashEvent.TotalHits = hits;
errorIndex.AddEvent(stackHashProduct, stackHashFile, stackHashEvent);
if (getCabs)
{
UpdateCabs(lastPullDate, errorIndex, stackHashProduct, dpEvent, stackHashFile, stackHashEvent);
}
}
}
}
