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