public async Task TestReceiveEventAfterMultipleEnqueues() { int notificationCount = 0; var tcs = new TaskCompletionSource <bool>(); var logger = new TestOutputLogger(this.TestOutput, false); var machineStateManager = new MockMachineStateManager(logger, (notification, evt, _) => { notificationCount++; if (notificationCount == 4) { Assert.Equal(MockMachineStateManager.Notification.ReceiveEvent, notification); tcs.SetResult(true); } }); var queue = new EventQueue(machineStateManager); var task = Task.Run(async() => { var receivedEvent = await queue.ReceiveAsync(typeof(E1)); Assert.IsType <E1>(receivedEvent); Assert.Equal(2, queue.Size); }); // Small delay to force ordering. await Task.Delay(100); var enqueueStatus = queue.Enqueue(new E2(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(1, queue.Size); enqueueStatus = queue.Enqueue(new E3(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(2, queue.Size); enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null); Assert.Equal(EnqueueStatus.Received, enqueueStatus); Assert.Equal(2, queue.Size); await task; var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E2>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(1, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E3>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(0, queue.Size); await Task.WhenAny(tcs.Task, Task.Delay(500)); Assert.True(tcs.Task.IsCompleted); }
public async SystemTasks.Task TestReceiveEventWithoutWaitingAndWithMultipleEventsInQueue() { int notificationCount = 0; var tcs = new TaskCompletionSource <bool>(); var logger = new TestOutputLogger(this.TestOutput, false); var mockActorManager = new MockActorManager(logger, (notification, evt, _) => { notificationCount++; if (notificationCount == 4) { Assert.Equal(MockActorManager.Notification.ReceiveEventWithoutWaiting, notification); tcs.SetResult(true); } }); using (var queue = new EventQueue(mockActorManager)) { var enqueueStatus = queue.Enqueue(new E2(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(1, queue.Size); enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(2, queue.Size); enqueueStatus = queue.Enqueue(new E3(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(3, queue.Size); var receivedEvent = await queue.ReceiveEventAsync(typeof(E1)); Assert.IsType <E1>(receivedEvent); Assert.Equal(2, queue.Size); var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E2>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(1, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E3>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(0, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); await Task.WhenAny(tcs.Task, Task.Delay(500)); Assert.True(tcs.Task.IsCompleted); } }
private IEnumerable <IEvent> DequeueAll() { var returnedEvents = new List <IEvent>(); var ev = _internalBuffer.Dequeue(); while (ev != null) { returnedEvents.Add(ev); ev = _internalBuffer.Dequeue(); } return(returnedEvents); }
public async SystemTasks.Task TestReceiveEventWithPredicate() { int notificationCount = 0; var tcs = new TaskCompletionSource <bool>(); var logger = new TestOutputLogger(this.TestOutput, false); var mockActorManager = new MockActorManager(logger, (notification, evt, _) => { notificationCount++; if (notificationCount == 3) { Assert.Equal(MockActorManager.Notification.ReceiveEvent, notification); tcs.SetResult(true); } }); using (var queue = new EventQueue(mockActorManager)) { var receivedEventTask = queue.ReceiveEventAsync(typeof(E4), evt => (evt as E4).Value); var enqueueStatus = queue.Enqueue(new E4(false), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(1, queue.Size); enqueueStatus = queue.Enqueue(new E4(true), Guid.Empty, null); Assert.Equal(EnqueueStatus.Received, enqueueStatus); Assert.Equal(1, queue.Size); var receivedEvent = await receivedEventTask; Assert.IsType <E4>(receivedEvent); Assert.True((receivedEvent as E4).Value); Assert.Equal(1, queue.Size); var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E4>(e); Assert.False((e as E4).Value); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(0, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); await Task.WhenAny(tcs.Task, Task.Delay(500)); Assert.True(tcs.Task.IsCompleted); } }
public async Task TestReceiveEventWithPredicateWithoutWaiting() { int notificationCount = 0; var tcs = new TaskCompletionSource <bool>(); var logger = new TestOutputLogger(this.TestOutput, false); var machineStateManager = new MockMachineStateManager(logger, (notification, evt, _) => { notificationCount++; if (notificationCount == 2) { Assert.Equal(MockMachineStateManager.Notification.ReceiveEventWithoutWaiting, notification); tcs.SetResult(true); } }); var queue = new EventQueue(machineStateManager); var enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerRunning, enqueueStatus); Assert.Equal(1, queue.Size); var receivedEvent = await queue.ReceiveAsync(typeof(E1)); Assert.IsType <E1>(receivedEvent); Assert.Equal(0, queue.Size); var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); await Task.WhenAny(tcs.Task, Task.Delay(500)); Assert.True(tcs.Task.IsCompleted); }
void ProcessEvents() { while (EventQueue.Count > 0) { ProcessEvent(EventQueue.Dequeue()); } }
public async Task TestEnqueueDequeueEvents() { var logger = new TestOutputLogger(this.TestOutput, false); var machineStateManager = new MockStateMachineManager(logger, (notification, evt, _) => { }); var queue = new EventQueue(machineStateManager); int numMessages = 10000; var enqueueTask = Task.Run(() => { for (int i = 0; i < numMessages; i++) { queue.Enqueue(new E1(), Guid.Empty, null); } }); var dequeueTask = Task.Run(() => { for (int i = 0; i < numMessages; i++) { var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); if (deqeueStatus is DequeueStatus.Success) { Assert.IsType <E1>(e); } } }); await Task.WhenAny(Task.WhenAll(enqueueTask, dequeueTask), Task.Delay(3000)); Assert.True(enqueueTask.IsCompleted); Assert.True(dequeueTask.IsCompleted); }
private void HandleEvent() { if (EventQueue.Count < 1) { return; } var e = EventQueue.Dequeue() as Event; if (e != null) { switch (e.Type) { case EventType.Connected: Log(Name, string.Format("连上服务器了,上层处理事件,{0}", DataTime2String(DateTime.Now))); ConnectedToServer(); break; case EventType.CanNotConnect: Log(Name, string.Format("无法连接服务器,上层处理事件,{0}", DataTime2String(DateTime.Now))); CannotConnectToServer(); break; case EventType.DisConnect: Log(Name, string.Format("掉线了,上层处理事件,{0}", DataTime2String(DateTime.Now))); DisConnectToServer(); break; default: break; } } }
public void TestRecoverAfterCancel_() { UTF8Encoding enc = new UTF8Encoding(); Channel.BasicPublish("", Queue, null, enc.GetBytes("message")); EventingBasicConsumer Consumer = new EventingBasicConsumer(Channel); SharedQueue <(bool Redelivered, byte[] Body)> EventQueue = new SharedQueue <(bool Redelivered, byte[] Body)>(); // Making sure we copy the delivery body since it could be disposed at any time. Consumer.Received += (_, e) => EventQueue.Enqueue((e.Redelivered, e.Body.ToArray())); string CTag = Channel.BasicConsume(Queue, false, Consumer); (bool Redelivered, byte[] Body)Event = EventQueue.Dequeue(); Channel.BasicCancel(CTag); Channel.BasicRecover(true); EventingBasicConsumer Consumer2 = new EventingBasicConsumer(Channel); SharedQueue <(bool Redelivered, byte[] Body)> EventQueue2 = new SharedQueue <(bool Redelivered, byte[] Body)>(); // Making sure we copy the delivery body since it could be disposed at any time. Consumer2.Received += (_, e) => EventQueue2.Enqueue((e.Redelivered, e.Body.ToArray())); Channel.BasicConsume(Queue, false, Consumer2); (bool Redelivered, byte[] Body)Event2 = EventQueue2.Dequeue(); CollectionAssert.AreEqual(Event.Body, Event2.Body); Assert.IsFalse(Event.Redelivered); Assert.IsTrue(Event2.Redelivered); }
private void onEventFired(Level level, string eventName) { Dictionary <string, object> expected = EventQueue.Dequeue(); Assert.AreEqual(expected["handler"], eventName); Assert.AreEqual(expected["id"], level.ID); }
private static void VerifyQueue(EventQueue q) { for (int index = 0; index < events.Length; index++) { Event e = q.Dequeue(false); Assert.AreEqual(events[index].GetType(), e.GetType(), string.Format("Event {0}", index)); } }
private void VerifyQueue(EventQueue q) { for (int index = 0; index < events.Length; index++) { Event e = q.Dequeue(); Assert.AreEqual(events[index].GetType(), e.GetType(), string.Format("Event {0}", index)); } }
void Calculate() { InitQueueOfEvents(); foreach (Point portLocation in PortLocations) { EnqueueEvent(new PortLocationEvent(portLocation)); } while (EventQueue.Count > 0) { ProcessEvent(EventQueue.Dequeue()); } }
/// <summary> /// Run the event queue down. All events in the queue are given a /// chance to run. /// </summary> /// <param name="Script">Supplies the script object.</param> /// <param name="Database">Supplies the database connection.</param> public void RunQueue(ACR_ServerCommunicator Script, ALFA.Database Database) { #if DEBUG_MODE Script.WriteTimestampedLogEntry(String.Format("ACR_ServerCommunicator: Running queue of {0} entries", EventQueue.Count)); #endif while (!Empty()) { IGameEventQueueEvent Event = EventQueue.Dequeue(); Event.DispatchEvent(Script, Database); } }
public bool MoveNext() { if (state == ParserState.StreamEnd) { currentEvent = null; return(false); } if (pendingEvents.Count == 0) { pendingEvents.Enqueue(StateMachine()); } currentEvent = pendingEvents.Dequeue(); return(true); }
private void ThreadRun() { Console.WriteLine($@"JsonOrderServer thread started: Framework = {_framework.Name} Clock = {_framework.Clock.GetModeAsString()}"); while (true) { if (_queue.IsEmpty()) { Thread.Sleep(1); } else { ProcessMessage((ExecutionMessage)_queue.Dequeue()); } } }
/// <summary> /// Moves to the next event. /// </summary> /// <returns>Returns true if there are more events available, otherwise returns false.</returns> public bool MoveNext() { // No events after the end of the stream or error. if (state == ParserState.StreamEnd) { Current = null; return(false); } else if (pendingEvents.Count == 0) { // Generate the next event. pendingEvents.Enqueue(StateMachine()); } Current = pendingEvents.Dequeue(); return(true); }
public void TestEnqueueEventWithHandlerNotRunning() { var logger = new TestOutputLogger(this.TestOutput, false); var mockActorManager = new MockActorManager(logger, (notification, evt, _) => { }); using (var queue = new EventQueue(mockActorManager)) { var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); var enqueueStatus = queue.Enqueue(new E1(), Guid.Empty, null); Assert.Equal(EnqueueStatus.EventHandlerNotRunning, enqueueStatus); Assert.Equal(1, queue.Size); } }
public void DoEvents() { while (EventQueue.Count > 0) { EventQueue.Dequeue()(); } /*while (true) * { * Action _event = null; * lock (Sync) * if (EventQueue.Count > 0) * _event = EventQueue.Dequeue(); * else * break; * _event(); * }*/ }
public void TestRaiseEvent() { var logger = new TestOutputLogger(this.TestOutput, false); var machineStateManager = new MockMachineStateManager(logger, (notification, evt, _) => { }); var queue = new EventQueue(machineStateManager); queue.Raise(new E1(), Guid.Empty); Assert.True(queue.IsEventRaised); Assert.Equal(0, queue.Size); var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E1>(e); Assert.Equal(DequeueStatus.Raised, deqeueStatus); Assert.False(queue.IsEventRaised); Assert.Equal(0, queue.Size); }
/// <summary> /// 從隊列獲取一個事件 /// </summary> /// <param name="e"></param> /// <returns></returns> private bool GetEvent(out Event e) { eventLock.WaitOne(); { if (eventQueue.Count <= 0) { eventLock.ReleaseMutex(); e = Event.Idle; return(false); } e = eventQueue.Dequeue(); } eventLock.ReleaseMutex(); return(true); }
public void TestRaiseEvent() { var logger = new TestOutputLogger(this.TestOutput, false); var mockActorManager = new MockActorManager(logger, (notification, evt, _) => { }); using (var queue = new EventQueue(mockActorManager)) { queue.RaiseEvent(new E1(), null); Assert.True(queue.IsEventRaised); Assert.Equal(0, queue.Size); var(deqeueStatus, e, group, info) = queue.Dequeue(); Assert.IsType <E1>(e); Assert.Equal(DequeueStatus.Raised, deqeueStatus); Assert.False(queue.IsEventRaised); Assert.Equal(0, queue.Size); } }
// Event hozzáadása a listához. Ha túlcsordulna, a legrégebbit kidobja static public void AddEvent(String s) { if (EventQueue == null) // Lusta inicializalas { EventQueue = new Queue <string>(); } EventQueue.Enqueue(s); if (LogolasBekapcsolva) { using (System.IO.StreamWriter file = new System.IO.StreamWriter(LogFileNev + ".txt", true)) { file.WriteLine(s); } } if (EventQueue.Count == 10) { EventQueue.Dequeue(); } }
public WebSocketEvent Poll() { lock (ConnectionLock) { if (EventQueue.Count > 0) { return(EventQueue.Dequeue()); } else { return(new WebSocketEvent() { ClientId = 0, Payload = null, Type = WebSocketEvent.WebSocketEventType.Nothing, Error = null, Reason = null }); } } }
private void ServeEventQueue(bool predictive) { var cac = new Cac(predictive); while (EventQueue.Any()) { var @event = EventQueue.Dequeue(); if (@event.GetType() == typeof(CallStartedEvent)) { var evt = (CallStartedEvent)@event; cac.AdmitCall(evt); } else { var evt = (CallEndedEvent)@event; var mobileTerminal = HetNet.Instance.MobileTerminals .FirstOrDefault(x => x.MobileTerminalId == evt.MobileTerminalId); //Find if call was considered var call = HetNet.Instance.Rats .SelectMany(x => x.OngoingSessions) .SelectMany(x => x.ActiveCalls) .FirstOrDefault(x => x.CallId == evt.CallId); //if no session contains this call then it was never considered if (call is null) { //Log.Warning($"CallStartedEventCorresponding to {nameof(CallEndedEvent)} was rejected"); } else { Events.Add(evt); mobileTerminal.EndCall(evt); } } } }
public bool IsEventReceived(Func <string, bool> filter) { // check previously received events first while (EventQueue.Count > 0) { if (filter(EventQueue.Dequeue())) { return(true); } } // receive new events and check them ReceiveEvents(); while (EventQueue.Count > 0) { if (filter(EventQueue.Dequeue())) { return(true); } } return(false); }
/// <inheritdoc /> public void Tick() { //On tick we just check if the eventqueue has events //if it does we can dispatch one. Otherwise, if (EventQueue.Count == 0) { return; } if (ServiceAllQueue) { //We don't want to loop on count since it //could change midloop and exploit could cause //a server to stall under some circumstances. int count = EventQueue.Count; lock (SyncObj) for (int i = 0; i < count; i++) { HandleEvent(EventQueue.Dequeue()); } //At this point, it's possible that the EventQueue has more events //but we are NOT going to handle them until next tick. } else { lock (SyncObj) HandleEvent(EventQueue.Dequeue()); } //When events are finished handling then we //can dispatch this overridable method to any implementer //who want want to extend the Tick logic to do things after //the original event handling. OnFinishedServicingEvents(); }
public async SystemTasks.Task TestReceiveEventMultipleTypes() { int notificationCount = 0; var tcs = new TaskCompletionSource <bool>(); var logger = new TestOutputLogger(this.TestOutput, false); var mockActorManager = new MockActorManager(logger, (notification, evt, _) => { notificationCount++; if (notificationCount == 2) { Assert.Equal(MockActorManager.Notification.ReceiveEvent, notification); tcs.SetResult(true); } }); using (var queue = new EventQueue(mockActorManager)) { var receivedEventTask = queue.ReceiveEventAsync(typeof(E1), typeof(E2)); var enqueueStatus = queue.Enqueue(new E2(), Guid.Empty, null); Assert.Equal(EnqueueStatus.Received, enqueueStatus); Assert.Equal(0, queue.Size); var receivedEvent = await receivedEventTask; Assert.IsType <E2>(receivedEvent); Assert.Equal(0, queue.Size); var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); await Task.WhenAny(tcs.Task, Task.Delay(500)); Assert.True(tcs.Task.IsCompleted); } }
public async Task LogAsync(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { using (var ct = new CancellationTokenSource(TimeSpan.FromSeconds(5))) { var item = _eventQueue.Dequeue(ct.Token); if (item == null) { await Task.Delay(TimeSpan.FromSeconds(5)); } else { var json = JsonConvert.SerializeObject(item); var message = new Message { Key = "message-key-1", Value = json }; await _messageBrokerProducer.ProduceAsync( _systemMetricsOptions.SystemMetricsChannelName , message); } } } }
public void TestDequeueEvent() { var logger = new TestOutputLogger(this.TestOutput, false); var mockActorManager = new MockActorManager(logger, (notification, evt, _) => { }); using (var queue = new EventQueue(mockActorManager)) { var(deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); queue.Enqueue(new E1(), Guid.Empty, null); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E1>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(0, queue.Size); queue.Enqueue(new E3(), Guid.Empty, null); queue.Enqueue(new E2(), Guid.Empty, null); queue.Enqueue(new E1(), Guid.Empty, null); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E3>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(2, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E2>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(1, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.IsType <E1>(e); Assert.Equal(DequeueStatus.Success, deqeueStatus); Assert.Equal(0, queue.Size); (deqeueStatus, e, opGroupId, info) = queue.Dequeue(); Assert.Equal(DequeueStatus.NotAvailable, deqeueStatus); Assert.Equal(0, queue.Size); } }
public void DequeueEmpty() { EventQueue q = new EventQueue(); Assert.IsNull(q.Dequeue(false)); }
/// <summary> /// Process the next event queued for this script /// </summary> /// <returns></returns> public object EventProcessor() { // We check here as the thread stopping this instance from running may itself hold the m_Script lock. if (!Running) { return(0); } lock (m_Script) { // m_log.DebugFormat("[XEngine]: EventProcessor() invoked for {0}.{1}", PrimName, ScriptName); if (Suspended) { return(0); } EventParams data = null; lock (EventQueue) { data = (EventParams)EventQueue.Dequeue(); if (data == null) // Shouldn't happen { if (EventQueue.Count > 0 && Running && !ShuttingDown) { m_CurrentWorkItem = Engine.QueueEventHandler(this); } else { m_CurrentWorkItem = null; } return(0); } if (data.EventName == "timer") { m_TimerQueued = false; } if (data.EventName == "control") { if (m_ControlEventsInQueue > 0) { m_ControlEventsInQueue--; } } if (data.EventName == "collision") { m_CollisionInQueue = false; } } // m_log.DebugFormat("[XEngine]: Processing event {0} for {1}", data.EventName, this); m_DetectParams = data.DetectParams; if (data.EventName == "state") // Hardcoded state change { // m_log.DebugFormat("[Script] Script {0}.{1} state set to {2}", // PrimName, ScriptName, data.Params[0].ToString()); State = data.Params[0].ToString(); AsyncCommandManager.RemoveScript(Engine, LocalID, ItemID); SceneObjectPart part = Engine.World.GetSceneObjectPart( LocalID); if (part != null) { part.SetScriptEvents(ItemID, (int)m_Script.GetStateEventFlags(State)); } } else { if (Engine.World.PipeEventsForScript(LocalID) || data.EventName == "control") // Don't freeze avies! { SceneObjectPart part = Engine.World.GetSceneObjectPart( LocalID); // m_log.DebugFormat("[Script] Delivered event {2} in state {3} to {0}.{1}", // PrimName, ScriptName, data.EventName, State); try { m_CurrentEvent = data.EventName; m_EventStart = DateTime.Now; m_InEvent = true; int start = Util.EnvironmentTickCount(); // Reset the measurement period when we reach the end of the current one. if (start - MeasurementPeriodTickStart > MaxMeasurementPeriod) { MeasurementPeriodTickStart = start; } m_Script.ExecuteEvent(State, data.EventName, data.Params); MeasurementPeriodExecutionTime += Util.EnvironmentTickCount() - start; m_InEvent = false; m_CurrentEvent = String.Empty; if (m_SaveState) { // This will be the very first event we deliver // (state_entry) in default state // SaveState(m_Assembly); m_SaveState = false; } } catch (Exception e) { // m_log.DebugFormat( // "[SCRIPT] Exception in script {0} {1}: {2}{3}", // ScriptName, ItemID, e.Message, e.StackTrace); m_InEvent = false; m_CurrentEvent = String.Empty; if ((!(e is TargetInvocationException) || (!(e.InnerException is SelfDeleteException) && !(e.InnerException is ScriptDeleteException))) && !(e is ThreadAbortException)) { try { // DISPLAY ERROR INWORLD string text = FormatException(e); if (text.Length > 1000) { text = text.Substring(0, 1000); } Engine.World.SimChat(Utils.StringToBytes(text), ChatTypeEnum.DebugChannel, 2147483647, part.AbsolutePosition, part.Name, part.UUID, false); } catch (Exception) { } // catch (Exception e2) // LEGIT: User Scripting // { // m_log.Error("[SCRIPT]: "+ // "Error displaying error in-world: " + // e2.ToString()); // m_log.Error("[SCRIPT]: " + // "Errormessage: Error compiling script:\r\n" + // e.ToString()); // } } else if ((e is TargetInvocationException) && (e.InnerException is SelfDeleteException)) { m_InSelfDelete = true; if (part != null) { Engine.World.DeleteSceneObject(part.ParentGroup, false); } } else if ((e is TargetInvocationException) && (e.InnerException is ScriptDeleteException)) { m_InSelfDelete = true; if (part != null) { part.Inventory.RemoveInventoryItem(ItemID); } } } } } // If there are more events and we are currently running and not shutting down, then ask the // script engine to run the next event. lock (EventQueue) { if (EventQueue.Count > 0 && Running && !ShuttingDown) { m_CurrentWorkItem = Engine.QueueEventHandler(this); } else { m_CurrentWorkItem = null; } } m_DetectParams = null; return(0); } }