/// <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); } } } }