public void EventPumpQueueLength(int numberOfProducers, bool producerDelay)
{
EventQueue q = new EventQueue();
EventProducer[] producers = new EventProducer[numberOfProducers];
for (int i = 0; i < numberOfProducers; i++)
{
producers[i] = new EventProducer(q, i, producerDelay);
}
using (EventPump pump = new EventPump(NullListener.NULL, q, false))
{
pump.Name = "EventPumpQueueLength";
pump.Start();
foreach (EventProducer p in producers)
{
p.ProducerThread.Start();
}
foreach (EventProducer p in producers)
{
p.ProducerThread.Join();
}
pump.Stop();
}
Assert.That(q.Count, Is.EqualTo(0));
foreach (EventProducer p in producers)
{
Console.WriteLine(
"#Events: {0}, MaxQueueLength: {1}", p.SentEventsCount, p.MaxQueueLength);
Assert.IsNull(p.Exception, "{0}", p.Exception);
}
}
public EventList(EventQueue<string> events)
{
InitializeComponent();
EventQueue = events;
EventQueue.Updated += Events_Updated;
ReloadEvents();
}
/// <summary>
/// Constructs a new EventManager.
/// </summary>
/// <param name="robotProxy">the robot proxy that this event manager applies to.</param>
public EventManager(BasicRobotProxy robotProxy)
{
this.robotProxy = robotProxy;
eventQueue = new EventQueue();
RegisterEventNames();
Reset();
}
/**
* EventManager constructor comment.
*
* @param robotProxy robotProxy
*/
public EventManager(BasicRobotProxy robotProxy)
{
registerNamedEvents();
this.robotProxy = robotProxy;
eventQueue = new EventQueue();
reset();
}
/// <summary>
/// start a small server that listens to UDP messages through _port 1337(as indicated when initializing the server instance).
/// </summary>
/// <param name="_port"></param>
public Server(int _port)
{
this._iPort = _port;
_lMessageBacklog = new EventQueue<NetworkMessage>();
_lPlayerRooms = new EventList<Hub>();
Instance = this;
Console.WriteLine("Setting up the server...");
MessageReceived += ParseMessage;
}
public Environment(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) {
DefaultTimeStepSeconds = (defaultStep ?? TimeSpan.FromSeconds(1)).Duration().TotalSeconds;
StartDate = initialDateTime;
Now = initialDateTime;
Random = new SystemRandom(randomSeed);
ScheduleQ = new EventQueue(InitialMaxEvents);
Queue = new Queue<Event>();
Logger = Console.Out;
}
/// <summary>
/// Default constructor
/// </summary>
public EventOptions()
{
HostName = _hostName;
OnErrorHttpCaptureFlags = HttpCaptureFlags.All;
SourceLevels = SourceLevels.All;
ConfigKeys = new Keys();
ConnectorType = "HashTag.Logging.Client.NLog.NLogEventConnector, HashTag.Logging.Client";
_queue = new EventQueue(this);
}
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));
}
}
public void Log(GroupEvent e)
{
if (this.queue == null)
{
this.queue = new EventQueue(EventQueueId.Service, EventQueueType.Master, EventQueuePriority.Normal, 100000, null);
this.queue.Enqueue(new OnQueueOpened(this.queue));
this.framework.EventBus.CommandPipe.Add(this.queue);
}
this.queue.Enqueue(e);
}
public void Attach(EventBus bus)
{
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 25600, null)
{
IsSynched = true,
Name = $"attached {bus.framework.Name}"
};
q.Enqueue(new OnQueueOpened(q));
bus.DataPipe.Add(q);
this.attached[this.attachedCount++] = q;
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
EventPump pump = new EventPump( NullListener.NULL, q, true );
Assert.IsFalse( pump.Pumping, "Should not be pumping initially" );
StartPump( pump, 1000 );
Assert.IsTrue( pump.Pumping, "Pump failed to start" );
q.Enqueue( new RunFinishedEvent( new Exception() ) );
WaitForPumpToStop( pump, 1000 );
Assert.IsFalse( pump.Pumping, "Pump failed to stop" );
}
public void SetUp()
{
theQueue = new EventQueue<FakeTopic>();
theQueue.Write(new ServerEvent("2", "2"));
theQueue.Write(new ServerEvent("1", "1"));
for (int i = 3; i < 8; i++)
{
theQueue.Write(new ServerEvent(i.ToString(), i.ToString()));
}
}
public void PumpEvents()
{
EventQueue q = new EventQueue();
EnqueueEvents( q );
QueuingEventListener el = new QueuingEventListener();
EventPump pump = new EventPump( el, q, false );
Assert.IsFalse( pump.Pumping, "Should not be pumping initially" );
StartPump( pump, 1000 );
Assert.IsTrue( pump.Pumping, "Pump should still be running" );
StopPump( pump, 1000 );
Assert.IsFalse( pump.Pumping, "Pump should have stopped" );
VerifyQueue( el.Events );
}
protected override void OnConnected()
{
foreach (var s in Series)
{
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 25600, null)
{
IsSynched = true,
Name = s.Name
};
q.Enqueue(new OnQueueOpened(q));
this.framework.EventBus.DataPipe.Add(q);
this.emitters.Add(new DataSeriesObject(s, DateTime1, DateTime2, q, Processor));
}
}
public void spin_up_pre_builds()
{
var factory = MockRepository.GenerateMock<IEventQueueFactory<FakeTopic>>();
var queue = new EventQueue<FakeTopic>();
var topic = new FakeTopic{
Name = "Top"
};
factory.Stub(x => x.BuildFor(topic)).Return(queue);
var family = new TopicFamily<FakeTopic>(factory);
family.SpinUpChannel(topic);
factory.AssertWasCalled(x => x.BuildFor(topic));
}
public void PumpEventsWithAutoStop()
{
EventQueue q = new EventQueue();
EnqueueEvents( q );
QueuingEventListener el = new QueuingEventListener();
EventPump pump = new EventPump( el, q, true );
pump.Start();
int tries = 10;
while( --tries > 0 && q.Count > 0 )
{
Thread.Sleep(100);
}
VerifyQueue( el.Events );
Assert.IsFalse( pump.Pumping, "Pump failed to stop" );
}
public BaseInput(InputElement input, SelectorElement selector, EventQueue queue)
: base()
{
InputName = input.Name;
InputType = input.Type;
SelectorName = selector.Name;
Processor = selector.Processor;
switch (selector.Login)
{
case "success": Login = LoginStatus.SUCCESS; break;
case "failure": Login = LoginStatus.FAILURE; break;
default: Login = LoginStatus.UNKNOWN; break;
}
equeue = queue;
}
public void Produce(EventEntry item, string processor, EventQueue.Priority priority = EventQueue.Priority.Low)
{
if (equeue == null)
{
Log.Error("Unable to produce events before queue initialization!?!?");
return;
}
if (string.IsNullOrEmpty(processor))
{
Log.Error("Unable to queue events with empty processor name");
return;
}
Log.Info("Service[" + item.Id + "@" + item.Input.Name + "] (re)queued message"
+ " with first processor name " + processor);
equeue.Produce(item, processor, priority);
}
public void Start(int port, CryptoAlgoId_Values cryptoAlgoId, byte[] content, EventQueue eventQueue)
{
this.cryptoAlgoId = cryptoAlgoId;
this.content = content;
this.eventQueue = eventQueue;
this.aes = PccrrUtitlity.CreateAes(cryptoAlgoId);
this.iv = new byte[16];
for (int i = 0; i < iv.Length; i++)
{
this.iv[i] = (byte)i;
}
pccrrServer = new PccrrServer(port);
pccrrServer.MessageArrived += new MessageArrivedEventArgs(pccrrServer_MessageArrived);
pccrrServer.StartListening();
}
public RuntimeEngine(RuntimeEntityService entityService, ISystemManager systemManager, EventQueue eventQueue, ILogger logger)
{
AddEntityAccessGate = new AccessGate();
EventQueue = eventQueue;
_logger = logger;
EntityService = entityService;
EntityService.AddEntityAccessGate = AddEntityAccessGate;
SystemManager = systemManager;
SystemUpdateScheduler = new SystemUpdateScheduler(SystemManager.Systems);
foreach (var updateBurst in SystemUpdateScheduler.UpdateBursts)
{
_logger.Info($"Update Burst: {string.Join(", ", updateBurst.Systems.Select(p => p.System.Name))}");
}
// Add any entities that are already loaded into the engine.
SystemManager.AddEntities(entityService.Entities);
}
protected bool Authenticate(Session session, Identity identity, Request request)
{
var correlationId = new CorrelationID();
var eventQueue = new EventQueue();
session.SendAuthorizationRequest(request, identity, eventQueue, correlationId);
while (true)
{
var eventArgs = eventQueue.NextEvent();
foreach (var message in eventArgs.GetMessages())
{
if (MessageTypeNames.AuthorizationFailure.Equals(message.MessageType))
return false;
if (MessageTypeNames.AuthorizationSuccess.Equals(message.MessageType))
return true;
throw new Exception("Unknown message type: " + message);
}
}
}
private void CleanUpVoid(object _)
{
CleanUpOldEndPoints(TimeSpan.FromMilliseconds(config.SavedEndPointTtl));
EventQueue.AddEvent(CleanUpVoid, null, DateTime.Now + TimeSpan.FromMilliseconds(config.SavedEndPointsCleanUpInterval));
}
public ICollection <IGeometry> HandleEvent(CircleEvent sweepEvent, EventQueue eventQueue, BeachLine beachLine)
{
if (sweepEvent.Arc.Parent == null)
{
throw new InvalidOperationException($"CircleEvent: Arc {sweepEvent.Arc.Site}: Parent of node {0} is null");
}
var leftParent = sweepEvent.Arc.GetParent(TraverseDirection.CounterClockwise);
var rightParent = sweepEvent.Arc.GetParent(TraverseDirection.Clockwise);
var left = leftParent?.GetLeaf(TraverseDirection.CounterClockwise);
var right = rightParent?.GetLeaf(TraverseDirection.Clockwise);
if (left == null || right == null)
{
throw new InvalidOperationException($"Neighbor of node {sweepEvent.Arc.Site} is null.");
}
if (left.CircleEvent != null)
{
eventQueue.Remove(left.CircleEvent);
left.CircleEvent = null;
}
if (right.CircleEvent != null)
{
eventQueue.Remove(right.CircleEvent);
right.CircleEvent = null;
}
var p = new Point(sweepEvent.Point.X, _calculationService.GetY(sweepEvent.Arc.Site, sweepEvent.Point));
leftParent.HalfEdge.EndPoint = p;
rightParent.HalfEdge.EndPoint = p;
var vertex = new Vertex {
Point = p
};
ConnectHalfEdgeWithVertex(leftParent.HalfEdge, vertex, (e, v) => e.End = v);
ConnectHalfEdgeWithVertex(rightParent.HalfEdge, vertex, (e, v) => e.End = v);
// Add third half edge
var halfEdge = new HalfEdge(p, left.Site, right.Site);
ConnectHalfEdgeWithVertex(halfEdge, vertex, (e, v) => e.Start = v);
Logger.Instance.Log($"Left parent: {leftParent.HalfEdge}");
Logger.Instance.Log($"Right parent: {rightParent.HalfEdge}");
var higher = sweepEvent.Arc.GetFirstParent(leftParent, rightParent);
Logger.Instance.Log($"Higher node: {higher}");
Logger.Instance.Log($"Higher edge old: {higher.HalfEdge}");
higher.HalfEdge = halfEdge;
if (vertex.HalfEdges.Count != 3)
{
var message = $"Halfedge {halfEdge} is already connected to Vertex {vertex}";
Logger.Instance.Log(message);
Logger.Instance.ToFile();
throw new InvalidOperationException(message);
}
Logger.Instance.Log($"CircleEvent: Remove Arc {sweepEvent.Arc.Site}");
beachLine.RemoveLeaf(sweepEvent.Arc);
var circleEvents = beachLine.GenerateCircleEvent(new[] { left, right }, sweepEvent.Point.Y);
eventQueue.Insert(circleEvents);
return(new List <IGeometry> {
vertex, halfEdge
});
}
public void Stop()
{
EventQueue.StopReading();
EventQueue.Close();
}
private DataSeriesObject CreateDataSeriesEmitter(DataSeries series, DateTime dateTime1, DateTime dateTime2)
{
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 25600, null)
{
IsSynched = true,
Name = series.Name
};
q.Enqueue(new OnQueueOpened(q));
this.framework.EventBus.DataPipe.Add(q);
return new DataSeriesObject(series, dateTime1, dateTime2, q, Processor);
}
/// <summary>
/// Creates a new <see cref="ViewerPresentationLayout"/> instance and instantiates all of the child controls.
/// </summary>
/// <param name="model">The model whose <see cref="WorkspaceModel.CurrentDeckTraversal"/> property will
/// be used to display the current slide and deck.</param>
public ViewerPresentationLayout(PresenterModel model)
{
this.Name = "ViewerPresentationLayout";
this.m_Model = model;
this.m_EventQueue = new ControlEventQueue(this);
m_Model.Workspace.CurrentDeckTraversal.ListenAndInitialize(m_EventQueue, new Property <DeckTraversalModel> .EventHandler(this.HandleTraversalChanged));
// Create the film strip, docked to the right side of the container.
this.m_DeckStrip = new DeckStrip(this.m_Model);
/// Filmstrip docking
this.m_DeckStrip.Dock = DockStyle.Right;
this.m_MainSlideViewer = new MainSlideViewer(this.m_Model, true);
// Make the deck strip resizable with a LinkedSplitter.
// The splitter automatically sets its dock to be the same as the FilmStrip and
// keeps z-order correct with respect to the FilmStrip and the MainSlideViewer.
this.m_DeckStripSplitter = new LinkedSplitter(this.m_DeckStrip, this.m_MainSlideViewer);
// Create the MainSlideViewer, which occupies the remaining space in the container.
this.m_MainSlideViewer.Dock = DockStyle.Fill;
#region RealTimeStylus Initialization
// Create a new RealTimeStylus, which will process ink drawn on the MainSlideViewer.
this.m_RealTimeStylus = new RealTimeStylus(this.m_MainSlideViewer, true);
try {
// Enable touch input for the real time stylus
this.m_RealTimeStylus.MultiTouchEnabled = true;
this.m_TouchGestureHandler = new TouchGestureHandler(this.m_Model, this.m_EventQueue);
this.m_RealTimeStylus.SyncPluginCollection.Add(this.m_TouchGestureHandler);
}
catch { }
// Make sure the TransformableDynamicRenderer and InkAnnotationCollector
// find out whenever the current StylusModel changes.
this.m_StylusInputSelector = new StylusInputSelector(this.m_Model, this.m_RealTimeStylus);
this.m_RealTimeStylus.SyncPluginCollection.Add(this.m_StylusInputSelector);
// Scale the ink to the inverse of the MainSlideViewer's transform.
// This keeps the ink's coordinates correct when the MainSlideViewer's transform
// is applied again later by the TransformableDynamicRenderer and InkAnnotationCollector.
this.m_InkTransformFilter = new InkTransformFilter(this.m_MainSlideViewer.SlideDisplay);
this.m_RealTimeStylus.SyncPluginCollection.Add(this.m_InkTransformFilter);
// Create a *synchronous* TransformableDynamicRenderer, which will render ink received directly
// from the RealTimeStylus on a high-priority thread.
this.m_TransformableDynamicRenderer = new TransformableDynamicRendererLinkedToDisplay(this.m_MainSlideViewer, this.m_MainSlideViewer.SlideDisplay);
this.m_TransformableDynamicRenderer.Enabled = true;
this.m_RealTimeStylus.SyncPluginCollection.Add(this.m_TransformableDynamicRenderer);
// Don't dynamically render ink on the main slide viewer twice. The MainSlideViewer's RealTimeInkSheetRenderer's
// own TransformableDynamicRenderer would render the ink on a low-priority asynchronous thread, which is
// fine for secondary slide viewers and the FilmStrip, but not fine for the MainSlideViewer.
using (Synchronizer.Lock(this.m_MainSlideViewer.SlideDisplay.SyncRoot)) {
this.m_MainSlideViewer.SlideDisplay.RenderLocalRealTimeInk = false;
}
// Create an InkAnnotationCollector and wrap it in an InkSheetAdapter,
// which sends ink from the RealTimeStylus to the RealTimeInkSheetModel
// of the MainSlideViewer's current slide.
this.m_InkAnnotationCollector = new InkAnnotationCollector();
this.m_InkAnnotationCollector_InkSheetAdapter = new InkSheetAdapter(this.m_MainSlideViewer.SlideDisplay, this.m_InkAnnotationCollector);
this.m_RealTimeStylus.AsyncPluginCollection.Add(this.m_InkAnnotationCollector);
this.m_LassoPlugin = new LassoPlugin(this.m_MainSlideViewer, this.m_MainSlideViewer.SlideDisplay);
this.m_LassoPlugin_InkSheetAdapter = new InkSheetAdapter(this.m_MainSlideViewer.SlideDisplay, this.m_LassoPlugin);
this.m_RealTimeStylus.SyncPluginCollection.Add(this.m_LassoPlugin);
this.m_EraserPlugin = new EraserPlugin(this.m_MainSlideViewer.SlideDisplay);
this.m_EraserPlugin_InkSheetAdapter = new InkSheetAdapter(this.m_MainSlideViewer.SlideDisplay, this.m_EraserPlugin);
this.m_RealTimeStylus.SyncPluginCollection.Add(this.m_EraserPlugin);
// Now that all the plugins have been added, enable the RealTimeStylus.
this.m_RealTimeStylus.Enabled = true;
#endregion RealTimeStylus Initialization
// Create a DeckTraversalModelAdapter, which causes the MainSlideViewer to always display the
// current slide of the current deck of the PresenterModel's current DeckTraversalModel.
this.m_WorkspaceModelAdapter = new WorkspaceModelAdapter(this.m_MainSlideViewer.SlideDisplay.EventQueue, this.m_MainSlideViewer, this.m_Model);
// Create the Slide Preview control
this.m_SlidePreview = new SlidePreview(this.m_Model, this.m_DeckStripSplitter);
this.m_PreviewTraversalModelAdapter
= new PreviewTraversalModelAdapter(this.m_SlidePreview.m_EventQueue, this.m_SlidePreview.m_PreviewSlideViewer, this.m_Model);
// Create the Second Monitor Form, this displays the slide on the secondary display
this.m_SecondMonitorForm = new SecondMonitorForm(this.m_Model);
this.ParentChanged += new EventHandler(OnParentChanged);
// Create the Role Synchronizer for the MainSlideViewer
this.m_RoleSync = new RoleSynchronizer(this.m_MainSlideViewer, this.m_Model.Participant);
#region Add Controls
// Add the SlidePreview Control
this.Controls.Add(this.m_SlidePreview);
// Now, add the controls in reverse order of their docking priority.
// The MainSlideViewer gets added first so its Fill dock-style will be effective.
this.Controls.Add(this.m_MainSlideViewer);
// Next, dock the FilmStripSplitter and the FilmStrip in reverse order,
// so that the FilmStripSplitter will be farther away from the edge of the container.
this.Controls.Add(this.m_DeckStripSplitter);
this.Controls.Add(this.m_DeckStrip);
#endregion Add Controls
}
// Use this for initialization
void Start () {
instance = this;
actionEvents = new List<ActionEvent> ();
}
public ExclusiveSynchronizationContext(SynchronizationContext old)
{
var oldEx = old as ExclusiveSynchronizationContext;
_items = null != oldEx ? oldEx._items : new EventQueue();
}
public override void Self_OnChat(object sender, ChatEventArgs e)
{
var type = e.Type;
var message = e.Message;
var id = e.SourceID;
var fromName = e.FromName;
var sourceType = e.SourceType;
var position = e.Position;
var ownerid = e.OwnerID;
var audible = e.AudibleLevel;
PCode pCode = PCode.None;
if (sourceType == ChatSourceType.Agent)
{
pCode = PCode.Avatar;
}
if (sourceType == ChatSourceType.Object)
{
pCode = PCode.Prim;
}
SimObject source = AsObject(fromName, id, pCode);
object s1 = source;
if (source == null)
{
s1 = id;
}
if (!string.IsNullOrEmpty(fromName))
{
s1 = fromName;
}
if (source != null)
{
s1 = source;
}
object location = AsLocation(e.Simulator, position, source);
if (ownerid != id)
{
SendNewRegionEvent(SimEventType.NETWORK, "Bug", "id!=ownerID?", "on-chat",
message, audible, type, sourceType, fromName, id, ownerid, location);
}
if (type == ChatType.Normal || type == ChatType.Shout || type == ChatType.Whisper)
{
EventQueue.Enqueue(() =>
SendNewRegionEvent(SimEventType.SOCIAL, "ChatType-" + type.ToString(),
ToParameter("senderOfInfo", s1),
ToParameter("infoTransferred-NLString", message),
audible,
type,
sourceType,
ToParameter("eventPrimarilyOccursAt", location)));
return;
}
if (string.IsNullOrEmpty(message))
{
EventQueue.Enqueue(
() =>
SendNewRegionEvent(SimEventType.SOCIAL, "ChatType-" + type.ToString(),
audible,
sourceType,
type,
ToParameter("senderOfInfo", s1),
ToParameter("eventPrimarilyOccursAt", location)));
return;
}
EventQueue.Enqueue(() =>
SendNewRegionEvent(SimEventType.SOCIAL, "ChatType-" + type.ToString(),
ToParameter("senderOfInfo", s1),
ToParameter("infoTransferred-NLString", message),
audible,
type,
sourceType,
ToParameter("eventPrimarilyOccursAt", location)));
}
public override void Self_OnInstantMessage(object sender, InstantMessageEventArgs e)
{
var im = e.IM;
if (im.FromAgentID != UUID.Zero)
{
AddName2Key(im.FromAgentName, im.FromAgentID);
if (im.RegionID != UUID.Zero)
{
AvatarRegion[im.FromAgentID] = im.RegionID;
Debug("Avatar region " + im.FromAgentName + " " + im.RegionID);
}
}
bool Conference = false;
bool GroupIM = im.GroupIM || client.Groups.GroupName2KeyCache.ContainsKey(im.IMSessionID);
if (GroupIM)
{
DeclareGroup(im.IMSessionID);
}
if (im.Dialog == InstantMessageDialog.SessionSend)
{
if (!GroupIM)
{
Conference = true;
}
}
PCode pcode = PCode.None;
object s = im.FromAgentName;
if (string.IsNullOrEmpty(im.FromAgentName) || im.FromAgentName == "Object" || !im.FromAgentName.Contains(" "))
{
s = im.FromAgentID;
pcode = PCode.Prim;
}
else
{
pcode = PCode.Avatar;
}
InstantMessageDialog d = im.Dialog;
if (d == InstantMessageDialog.StartTyping || d == InstantMessageDialog.StopTyping)
{
pcode = PCode.Avatar;
}
if (!Conference && GroupIM)
{
//"recipientOfInfo-Intended";
}
SimObject source = AsObject(im.FromAgentName, im.FromAgentID, pcode);
if (source != null)
{
s = source;
}
object location = AsLocation(im.RegionID, im.Position);
EventQueue.Enqueue(() =>
client.SendPersonalEvent(SimEventType.SOCIAL, "InstantMessageDialog-" + im.Dialog.ToString() + (GroupIM ? "-Group" : ""),
ToParameter("senderOfInfo", s),
ToParameter("infoTransferred-NLString", im.Message),
ToParameter("recipientOfInfo-Intended", im.ToAgentID),
im.Offline,
im.IMSessionID,
ToParameter("eventPrimarilyOccursAt", location),
//(im.GroupIM ? "GroupIM" : ""),
//im.Dialog,
im.ParentEstateID));
}
private Interactor(Stream stream, string name, IPAddress address, DistributorRole distributorRole, EventQueue <InteractorEventArgs> eventQueue, CancellationToken token)
{
_stream = stream;
Id = Guid.NewGuid();
User = name;
Address = address;
_token = token;
_eventQueue = eventQueue;
_roleManager = new RoleManager(distributorRole, address, name);
}
public void DequeueEmpty()
{
EventQueue q = new EventQueue();
Assert.IsNull(q.Dequeue(false));
}
internal void SelfConnected()
{
CurrentStatus = ClientStatus.Connected;
EventQueue.RemoveEvent(connectionTimeoutEvent);
OnConnected?.Invoke();
}
public ImageSheetUndoService(EventQueue dispatcher, UndoModel undo, DeckModel deck, SlideModel slide, ImageSheetModel sheet) : base(undo, deck, slide, sheet)
{
// There are currently no published properties of ImageSheetModel, other than those handled by the base class.
}
/// <summary>
/// Retrieves the data from message processing custom request just to return custom response.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="request">The request of concrete type.</param>
/// <param name="service">The service is default parameter with default value null. If argument is not supplied service is created by the method.</param>
/// <returns></returns>
/// <exception cref="System.Exception">Request was not specified.</exception>
public Response <T> RetrieveData <T>(Request <T> request, Service service = null, bool Async = true)
{
//Session session;
Response <T> result = (Response <T>)Activator.CreateInstance(request.GetUnderlyingResponseType(), new object[] { request.RequestClass });
Type t = typeof(T);
Request blRequest;
#region Initialize Service and Request if not provided
/*if (request.GetSessionOptions() != null) { session = new Session(request.GetSessionOptions()); session.Start(); } // special session
* else session = this.session;*/
if (service == null)
{
service = session.GetService(request.GetService());
}
if (request != null)
{
blRequest = request.GetBloombergRequest(service);
}
else
{
throw new Exception("Request was not specified.");
}
#endregion
CorrelationID requestID = new CorrelationID(GenerateId());
EventQueue eventQueue = new EventQueue();
// Generate request from object definition
session.SendRequest(blRequest, eventQueue, requestID);
bool continueToLoop = true;
if (Async)
{
result.StartMessageProcessing();
while (continueToLoop)
{
Event eventObj = eventQueue.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE)
{
continueToLoop = false;
}
// Cracking messages
foreach (Message message in eventObj.GetMessages())
{
result.AddMessage(message);
//result.ProcessMessage(message);
}
if (result.ProcessingError != null)
{
break; throw result.ProcessingError;
}
}
result.StopMessageProcessing();
}
else
{
while (continueToLoop)
{
Event eventObj = eventQueue.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE)
{
continueToLoop = false;
}
// Cracking messages
foreach (Message message in eventObj.GetMessages())
{
result.ProcessMessage(message);
}
if (result.ProcessingError != null)
{
break; throw result.ProcessingError;
}
}
}
return(result);
}
public void Run(String[] args)
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions sessionOptions = new SessionOptions();
SessionOptions.ServerAddress[] servers = new SessionOptions.ServerAddress[d_hosts.Count];
for (int i = 0; i < d_hosts.Count; ++i)
{
servers[i] = new SessionOptions.ServerAddress(d_hosts[i], d_port);
}
sessionOptions.ServerAddresses = servers;
sessionOptions.AutoRestartOnDisconnection = true;
sessionOptions.NumStartAttempts = d_hosts.Count;
sessionOptions.DefaultSubscriptionService = d_service;
sessionOptions.DefaultTopicPrefix = ""; // normally defaults to "ticker"
sessionOptions.AuthenticationOptions = d_authOptions;
System.Console.WriteLine("Connecting to port " + d_port + " on ");
foreach (string host in d_hosts)
{
System.Console.WriteLine(host + " ");
}
Session session = new Session(sessionOptions);
if (!session.Start())
{
System.Console.Error.WriteLine("Failed to start session.");
return;
}
Identity identity = null;
if (d_authOptions.Length != 0)
{
EventQueue tokenEventQueue = new EventQueue();
session.GenerateToken(new CorrelationID(tokenEventQueue), tokenEventQueue);
String token = null;
const int timeoutMilliSeonds = 10000;
Event eventObj = tokenEventQueue.NextEvent(timeoutMilliSeonds);
if (eventObj.Type == Event.EventType.TOKEN_STATUS)
{
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == TOKEN_SUCCESS)
{
token = msg.GetElementAsString("token");
}
}
}
if (token == null)
{
System.Console.WriteLine("Failed to get token");
System.Environment.Exit(1);
}
if (session.OpenService("//blp/apiauth"))
{
Service authService = session.GetService("//blp/apiauth");
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set("token", token);
EventQueue authEventQueue = new EventQueue();
identity = session.CreateIdentity();
session.SendAuthorizationRequest(authRequest, identity, authEventQueue, new CorrelationID(identity));
bool isAuthorized = false;
while (!isAuthorized)
{
eventObj = authEventQueue.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.PARTIAL_RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
isAuthorized = true;
break;
}
else
{
System.Console.Error.WriteLine("Not authorized: " + msg);
System.Environment.Exit(1);
}
}
}
}
}
}
List <Subscription> subscriptions = new List <Subscription>();
// Short topic string; will get qualified by subscribe() using session
// options: 'DefaultSubscriptionService' and 'DefaultTopicPrefix'
// configured above
String topic1 = "IBM Equity";
// Fully qualified topic
String topic2 = d_service + "/RHAT Equity";
// Add a topic on unknown service to demonstrate event sequence
String topic3 = d_service + "-unknown/RHAT Equity";
subscriptions.Add(new Subscription(topic1, new CorrelationID(topic1)));
subscriptions.Add(new Subscription(topic2, new CorrelationID(topic2)));
subscriptions.Add(new Subscription(topic3, new CorrelationID(topic3)));
session.Subscribe(subscriptions, identity);
ProcessSubscriptionResponse(session);
}
private static async Task ProcessQueue(EventQueue queue)
{
if (queue.MainEvent != null)
{
try
{
await queue.MainEvent.Handler().ConfigureAwait(false);
foreach (var cb in queue.Callbacks)
{
if (cb != null)
{
Task.Run(() => cb.TrySetResult(true)).Forget();
}
}
}
catch (Exception ex)
{
foreach (var cb in queue.Callbacks)
{
if (cb != null)
{
Task.Run(() => cb.TrySetException(ex)).Forget();
}
}
}
return;
}
foreach (var keyspace in queue.Keyspaces)
{
if (keyspace.Value.RefreshKeyspaceEvent != null)
{
try
{
await keyspace.Value.RefreshKeyspaceEvent.Handler().ConfigureAwait(false);
foreach (var cb in keyspace.Value.Events.Select(e => e.Callback).Where(e => e != null))
{
Task.Run(() => cb.TrySetResult(true)).Forget();
}
}
catch (Exception ex)
{
foreach (var cb in keyspace.Value.Events.Select(e => e.Callback).Where(e => e != null))
{
Task.Run(() => cb.TrySetException(ex)).Forget();
}
}
continue;
}
foreach (var ev in keyspace.Value.Events)
{
try
{
await ev.KeyspaceEvent.Handler().ConfigureAwait(false);
if (ev.Callback != null)
{
Task.Run(() => ev.Callback.TrySetResult(true)).Forget();
}
}
catch (Exception ex)
{
if (ev.Callback != null)
{
Task.Run(() => ev.Callback.TrySetException(ex)).Forget();
}
}
}
}
}
public override void Self_OnAlertMessage(object sender, AlertMessageEventArgs e)
{
EventQueue.Enqueue(() => SendNewRegionEvent(SimEventType.SCRIPT, "On-Alert-Message", client.gridClient, e.Message));
}
public DataSeriesObject_bak(SubscribeInfo info, EventQueue queue)
{
EventQueue = queue;
_info = info;
Init();
}
public QueueConsumersManager(EventQueue queue)
{
_queue = queue;
_consumers = Enumerable.Range(0, _numConsumerTasks).Select(i => new QueueConsumer(_queue)).ToList();
}
internal DataSeriesObject(IDataSeries series, DateTime dateTime1, DateTime dateTime2, EventQueue queue, DataProcessor processor)
{
this.series = series;
eventQueue = queue;
if (processor == null)
{
this.processor = new DataProcessor();
}
else
{
this.processor = processor;
}
if (!(dateTime1 == DateTime.MinValue) && (dateTime1 >= series.DateTime1))
{
index1 = series.GetIndex(dateTime1, SearchOption.Next);
}
else
{
index1 = 0L;
}
if (!(dateTime2 == DateTime.MaxValue) && (dateTime2 <= series.DateTime2))
{
index2 = series.GetIndex(dateTime2);
}
else
{
index2 = series.Count - 1L;
}
current = index1;
progressDelta = (int)Math.Ceiling(Count() / 100.0);
progressCount = progressDelta;
progressPercent = 0;
}
public static IInteractor Create(TcpClient tcpClient, DistributorRole distributorRole, EventQueue <InteractorEventArgs> eventQueue, CancellationToken token)
{
var stream = new NegotiateStream(tcpClient.GetStream());
try
{
stream.AuthenticateAsServer();
}
catch (Exception error)
{
Log.Warn("Failed to negotiate stream", error);
return(null);
}
var interactor = new Interactor(stream, stream.RemoteIdentity.Name, ((IPEndPoint)tcpClient.Client.RemoteEndPoint).Address, distributorRole, eventQueue, token);
return(interactor);
}
public static void Init()
{
#if _NEWSTART_
/** AGL.START Controlado */
int Contador = 0;
var NewList = new List <VoidDelegate>
{
delegate()
{
if (string.IsNullOrEmpty(_HostId) || string.IsNullOrEmpty(_SipIp))
{
List <string> ips = General.GetOperationalV4Ips();
if (string.IsNullOrEmpty(_SipIp))
{
_SipIp = (ips.Count > 0) ? ips[ips.Count - 1] : "127.0.0.1";
}
if (string.IsNullOrEmpty(_HostId))
{
_HostId = "PICT" + _SipIp.Substring(_SipIp.LastIndexOf('.') + 1);
}
}
},
delegate(){ InitSnmp(); },
delegate(){ _WorkingThread = new EventQueue(); },
delegate(){ _PublisherThread = new EventQueue(); },
delegate()
{
#if _AUDIOGENERIC_
// switch (Properties.Settings.Default.TipoAudioUsb)
switch (HwManager.AudioDeviceType)
{
case eAudioDeviceTypes.MICRONAS:
_HwManager = new MicronasHwManager();
break;
case eAudioDeviceTypes.CMEDIA:
_HwManager = new HidCMediaHwManager();
break;
case eAudioDeviceTypes.GENERIC_PTT: // Cascos y Altavoces USB...
_HwManager = new HidGenericHwManager(true);
break;
case eAudioDeviceTypes.GENERIC: // Cascos sin PTT y Altavoces USB...
_HwManager = new HidGenericHwManager(false);
break;
case eAudioDeviceTypes.SIMUL: // Simulacion de Tarjetas HID
_HwManager = new SimCMediaHwManager();
break;
default:
throw new Exception("Dispositivos de Audio no Conocidos...");
}
#else
_HwManager = new HwManager();
#endif
},
delegate(){ _Registry = new TopRegistry(); },
delegate(){ _CfgManager = new CfgManager(); },
delegate(){ _SipManager = new SipManager(); },
delegate(){ _MixerManager = new MixerManager(); },
delegate(){ _TlfManager = new TlfManager(); },
delegate(){ _LcManager = new LcManager(); },
delegate(){ _RdManager = new RdManager(); },
delegate(){ _RecorderManager = new RecorderManager(Settings.Default.GLP); },
delegate(){ _ReplayManager = new ReplayManager(); }
};
var nNames = new List <string>
{
"_SipIp & _HostId", "InitSnmp", "_WorkingThread", "_PublisherThread", "HwManager",
"Registry", "CfgManager", "SipManager", "MixedManager", "TlfManager", "LcManager", "RdManager", "RecorderManager", "ReplayManager"
};
foreach (VoidDelegate _new in NewList)
{
try
{
_new();
Contador++;
}
catch (Exception x)
{
_Logger.Fatal("Error en Rutina {1} de Creacion TOP: \n{0}", x.Message, nNames[Contador]);
}
}
#else
if (string.IsNullOrEmpty(_HostId) || string.IsNullOrEmpty(_SipIp))
{
List <string> ips = General.GetOperationalV4Ips();
if (string.IsNullOrEmpty(_SipIp))
{
_SipIp = (ips.Count > 0) ? ips[ips.Count - 1] : "127.0.0.1";
}
if (string.IsNullOrEmpty(_HostId))
{
_HostId = "PICT" + _SipIp.Substring(_SipIp.LastIndexOf('.') + 1);
}
}
/* Inicializa la gestion SNMP */
InitSnmp();
_WorkingThread = new EventQueue();
_PublisherThread = new EventQueue();
#if _AUDIOGENERIC_
/** AGL.CMEDIA */
switch (Properties.Settings.Default.TipoAudioUsb)
{
case 0: // IAU. Micronas.
_HwManager = new MicronasHwManger();
break;
case 1: // IAU. CMedia.
_HwManager = new HidCMediaHwManager();
break;
case 2: // Cascos y Altavoces USB...
_HwManager = new HidGenericHwManager(true);
break;
case 3: // Cascos sin PTT y Altavoces USB...
_HwManager = new HidGenericHwManager(true);
break;
default:
throw new Exception("HwManager de tipo Desconocido...");
}
#else
_HwManager = new HwManager();
#endif
/** */
_Registry = new TopRegistry();
_CfgManager = new CfgManager();
_SipManager = new SipManager();
_MixerManager = new MixerManager();
_TlfManager = new TlfManager();
_LcManager = new LcManager();
_RdManager = new RdManager();
_RecorderManager = new RecorderManager();
_ReplayManager = new ReplayManager();
/** */
#endif
#if _NEWSTART_
/** AGL.START Controlado */
Contador = 0;
var InitList = new List <VoidDelegate>
{
delegate() { if (_HwManager != null)
{
_HwManager.Init();
}
},
delegate() { if (_Registry != null)
{
_Registry.Init();
}
},
delegate() { if (_CfgManager != null)
{
_CfgManager.Init();
}
},
delegate() { if (_SipManager != null)
{
_SipManager.Init();
}
},
delegate() { if (_MixerManager != null)
{
_MixerManager.Init();
}
},
delegate() { if (_TlfManager != null)
{
_TlfManager.Init();
}
},
delegate() { if (_LcManager != null)
{
_LcManager.Init();
}
},
delegate() { if (_RdManager != null)
{
_RdManager.Init();
}
},
delegate() { if (_RecorderManager != null)
{
_RecorderManager.Init();
}
}
};
var iNames = new List <string> {
"HwManager", "Registry", "CfgManager", "SipManager", "MixedManager", "TlfManager", "LcManager", "RdManager", "RecorderManager"
};
foreach (VoidDelegate init in InitList)
{
try
{
init();
Contador++;
}
catch (Exception x)
{
_Logger.Fatal("Error en Rutina {1} de Inicializacion TOP: \n{0}", x.Message, iNames[Contador]);
}
}
#else
_HwManager.Init();
_Registry.Init();
_CfgManager.Init();
_SipManager.Init();
_MixerManager.Init(_HwManager.ListaDispositivos);
_TlfManager.Init();
_LcManager.Init();
_RdManager.Init();
_RecorderManager.Init();
#endif
#if _NICMON_V0_
/** */
NetworkIFSupervisor.AutoReset = true;
NetworkIFSupervisor.Elapsed += NetworkChange_NetworkAvailabilityChanged;
NetworkIFSupervisor.Enabled = Settings.Default.SNMPEnabled == 1;
_Logger.Info("TIMER NetworkIFSupervisor Arrancado...");
#else
string jconfig = Properties.Settings.Default.LanTeamConfigs.Count > Properties.Settings.Default.LanTeamType ?
Properties.Settings.Default.LanTeamConfigs[Properties.Settings.Default.LanTeamType] : "";
mon = new NicEventMonitor(jconfig,
(lan, status) =>
{
string oid = lan == 0 ? Settings.Default.NetworkIF_1_Oid : Settings.Default.NetworkIF_2_Oid;
SnmpIntObject.Get(oid).Value = (int)status;
_Logger.Info(String.Format("Notificado cambio en LAN {0} => {1}", lan, status));
}, (m, x) =>
{
_Logger.Error(String.Format("Error Message: {0}", m));
} /*, filePath*/);
_Logger.Info("NetworkIFSupervisor Arrancado...");
#endif
/** 20170309. AGL. Supervision Cliente NTP. */
NtpClientSupervisor.AutoReset = true;
NtpClientSupervisor.Elapsed += NtpClientSupervisor_tick;
NtpClientSupervisor.Enabled = Settings.Default.SNMPEnabled == 1;
_Logger.Info("TIMER NtpClientSupervisor Arrancado...");
/*****************/
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dispatcher">The event queue</param>
/// <param name="model">The model</param>
public RedoToolBarButton(EventQueue dispatcher, PresenterModel model) : base(dispatcher, model)
{
// TODO: Dynamically change the ToolTipText depending on what type of change will be redone.
this.ToolTipText = Strings.RedoTooltipText;
}
protected void Produce(EventEntry item, string processor = null, EventQueue.Priority priority = EventQueue.Priority.Medium)
{
Service.Produce(item, processor, priority);
}
public EventQueueTests()
{
this.Q = new EventQueue(EventQueues.Ec2Events);
}
public void Run()
{
this.thread = new Thread(() =>
{
Console.WriteLine($"{DateTime.Now} Data simulator thread started");
if (!IsConnected)
Connect();
var q = new EventQueue(EventQueueId.Data, EventQueueType.Master, EventQueuePriority.Normal, 16, null)
{
Name = "Data Simulator Start Queue",
IsSynched = true
};
q.Enqueue(new OnQueueOpened(q));
q.Enqueue(new OnSimulatorStart(DateTime1, DateTime2, 0));
q.Enqueue(new OnQueueClosed(q));
this.framework.EventBus.DataPipe.Add(q);
this.running = true;
this.exit = false;
while (!this.exit)
{
LinkedListNode<DataSeriesObject> lastNode = null;
var node = this.emitters.First;
while (node != null)
{
var emitter = node.Data;
if (!emitter.Done)
{
if (emitter.Enqueue())
this.objCount++;
lastNode = node;
}
else
{
if (lastNode == null)
this.emitters.First = node.Next;
else
lastNode.Next = node.Next;
this.emitters.Count--;
emitter.dataQueue.Enqueue(new OnQueueClosed(emitter.dataQueue));
}
node = node.Next;
}
}
this.exit = false;
this.running = false;
Console.WriteLine($"{DateTime.Now} Data simulator thread stopped");
})
{
Name = "Data Simulator Thread",
IsBackground = true
};
this.thread.Start();
}
public ProjectLoadedListener(EventQueue eventQueue)
{
_eventQueue = eventQueue;
}
public DataSeriesObject(IDataSeries series, DateTime dateTime1, DateTime dateTime2, EventQueue dataQueue, DataProcessor processor)
{
this.queue = new EventQueue(EventQueueId.All, EventQueueType.Master, EventQueuePriority.Normal, 128, null);
this.series = series;
this.dataQueue = dataQueue;
this.processor = processor ?? new DataProcessor();
this.index1 = dateTime1 == DateTime.MinValue || dateTime1 < series.DateTime1 ? 0 : series.GetIndex(dateTime1, SearchOption.Next);
this.index2 = dateTime2 == DateTime.MaxValue || dateTime2 > series.DateTime2 ? series.Count - 1 : series.GetIndex(dateTime2, SearchOption.Prev);
this.current = this.index1;
this.delta = (int)Math.Ceiling((this.index2 - this.index1 + 1) / 100.0);
this.count = this.delta;
this.percent = 0;
}
public void SetUp()
{
theQueue = new EventQueue <FakeTopic>();
theChannel = new Channel <FakeTopic>(theQueue);
}
public static ICoroutineEvent DequeueEvent(this EventQueue eventQueue)
{
Assert.True(eventQueue.TryDequeue(out IEvent ev));
Assert.IsAssignableFrom <ICoroutineEvent>(ev);
return(ev as ICoroutineEvent);
}
public void BeforeTest()
{
mockStrategy = new Mock <IEventQueueStorageStrategy <TestEvent> >();
queue = new EventQueueImp(mockStrategy.Object);
}
public void ClearQueue()
{
m_TimerQueued = false;
EventQueue.Clear();
}
private bool Authorize(
Service authService,
Identity identity,
ProviderSession session,
CorrelationID cid)
{
lock (d_authorizationStatus)
{
d_authorizationStatus[cid] = AuthorizationStatus.WAITING;
}
EventQueue tokenEventQueue = new EventQueue();
try
{
session.GenerateToken(new CorrelationID(tokenEventQueue), tokenEventQueue);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
return(false);
}
String token = null;
const int timeoutMilliSeconds = 10000;
Event eventObj = tokenEventQueue.NextEvent(timeoutMilliSeconds);
if (eventObj.Type == Event.EventType.TOKEN_STATUS ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == TOKEN_SUCCESS)
{
token = msg.GetElementAsString("token");
}
}
}
if (token == null)
{
System.Console.WriteLine("Failed to get token");
return(false);
}
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set("token", token);
lock (d_authorizationStatus)
{
session.SendAuthorizationRequest(authRequest, identity, cid);
DateTime startTime = System.DateTime.Now;
int waitTime = 10 * 1000; // 10 seconds in milliseconds
while (true)
{
Monitor.Wait(d_authorizationStatus, waitTime);
if (d_authorizationStatus[cid] != AuthorizationStatus.WAITING)
{
return(d_authorizationStatus[cid] == AuthorizationStatus.AUTHORIZED);
}
waitTime -= (int)(System.DateTime.Now - startTime).TotalMilliseconds;
if (waitTime <= 0)
{
return(false);
}
}
}
}
public void HostedCacheServer_PchcServer_BatchedOffer_ContentRetrieved()
{
CheckApplicability();
EventQueue eventQueue = new EventQueue(BaseTestSite);
eventQueue.Timeout = testConfig.Timeout;
byte[] content = TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize);
Content_Information_Data_Structure_V2 contentInformationV2 = contentInformationUtility.CreateContentInformationV2();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR server to be ready to serve content to hosted cache server");
using (PccrrTestServerV2 pccrrTestServerV2 = new PccrrTestServerV2())
{
pccrrTestServerV2.Start(
testConfig.ClientContentRetrievalListenPort,
CryptoAlgoId_Values.AES_128,
contentInformationV2,
content,
eventQueue);
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTP,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPListenPort,
PchcConsts.HttpUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Directly Supply segment info to hosted cache server");
var batchedOfferMessage = pchcClient.CreateBatchedOfferMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformationV2);
pchcClient.SendBatchedOfferMessage(batchedOfferMessage);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Make sure all the segments in chunk 0 is retrieved by hosted cache server");
int blockCount = 0;
int totalBlockCount = contentInformationV2.GetBlockCount();
TestUtility.DoUntilSucceed(delegate()
{
eventQueue.Expect<MessageArrivedEventArgs>(typeof(PccrrServer).GetEvent("MessageArrived"), delegate(System.Net.IPEndPoint sender, PccrrPacket pccrrPacket)
{
var pccrrGetBlksRequest = pccrrPacket as PccrrGETBLKSRequestPacket;
if (pccrrGetBlksRequest != null)
{
blockCount++;
}
});
return blockCount == totalBlockCount;
}, TimeSpan.MaxValue, TimeSpan.Zero);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Wait until cache is available on hosted cache server");
TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.Timeout, testConfig.RetryInterval);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Re-supply segment info to hosted cache server");
var batchedOfferResponse = pchcClient.SendBatchedOfferMessage(batchedOfferMessage);
BaseTestSite.Assert.AreEqual(
RESPONSE_CODE.OK,
batchedOfferResponse.ResponseCode,
"Hosted cache server should return OK to batched offer message");
}
}
/// <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;
}
}
if (DebugLevel >= 2)
{
m_log.DebugFormat(
"[SCRIPT INSTANCE]: Processing event {0} for {1}/{2}({3})/{4}({5}) @ {6}/{7}",
data.EventName,
ScriptName,
Part.Name,
Part.LocalId,
Part.ParentGroup.Name,
Part.ParentGroup.UUID,
Part.AbsolutePosition,
Part.ParentGroup.Scene.Name);
}
m_DetectParams = data.DetectParams;
if (data.EventName == "state") // Hardcoded state change
{
State = data.Params[0].ToString();
if (DebugLevel >= 1)
{
m_log.DebugFormat(
"[SCRIPT INSTANCE]: Changing state to {0} for {1}/{2}({3})/{4}({5}) @ {6}/{7}",
State,
ScriptName,
Part.Name,
Part.LocalId,
Part.ParentGroup.Name,
Part.ParentGroup.UUID,
Part.AbsolutePosition,
Part.ParentGroup.Scene.Name);
}
AsyncCommandManager.UnregisterScriptFacilities(Engine,
LocalID, ItemID);
Part.SetScriptEvents(ItemID, (int)m_Script.GetStateEventFlags(State));
}
else
{
if (Engine.World.PipeEventsForScript(LocalID) ||
data.EventName == "control") // Don't freeze avies!
{
// 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 (EventAbortException)
{
}
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.InnerException is ScriptCoopStopException))) &&
!(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);
m_log.Debug(string.Format(
"[SCRIPT INSTANCE]: Runtime error in script {0}, part {1} {2} at {3} in {4} ",
ScriptName,
PrimName,
Part.UUID,
Part.AbsolutePosition,
Part.ParentGroup.Scene.Name),
e);
}
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;
Engine.World.DeleteSceneObject(Part.ParentGroup, false);
}
else if ((e is TargetInvocationException) && (e.InnerException is ScriptDeleteException))
{
m_InSelfDelete = true;
Part.Inventory.RemoveInventoryItem(ItemID);
}
else if ((e is TargetInvocationException) && (e.InnerException is ScriptCoopStopException))
{
if (DebugLevel >= 1)
{
m_log.DebugFormat(
"[SCRIPT INSTANCE]: Script {0}.{1} in event {2}, state {3} stopped co-operatively.",
PrimName, ScriptName, data.EventName, State);
}
}
}
}
}
// 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)
{
EventsProcessed++;
if (EventQueue.Count > 0 && Running && !ShuttingDown)
{
m_CurrentWorkItem = Engine.QueueEventHandler(this);
}
else
{
m_CurrentWorkItem = null;
}
}
m_DetectParams = null;
return(0);
}
}
internal virtual void Clear() {
ObstacleTree.Clear();
eventQueue = new EventQueue();
HorizontalScanSegments = new ScanSegmentTree(ScanDirection.HorizontalInstance);
VerticalScanSegments = new ScanSegmentTree(ScanDirection.VerticalInstance);
VisibilityGraph = null;
}
/// <summary>
/// Post an event to this script instance.
/// </summary>
/// <remarks>
/// The request to run the event is sent
/// </remarks>
/// <param name="data"></param>
public void PostEvent(EventParams data)
{
// m_log.DebugFormat("[Script] Posted event {2} in state {3} to {0}.{1}",
// PrimName, ScriptName, data.EventName, State);
if (!Running)
{
return;
}
// If min event delay is set then ignore any events untill the time has expired
// This currently only allows 1 event of any type in the given time period.
// This may need extending to allow for a time for each individual event type.
if (m_eventDelayTicks != 0)
{
if (DateTime.Now.Ticks < m_nextEventTimeTicks)
{
return;
}
m_nextEventTimeTicks = DateTime.Now.Ticks + m_eventDelayTicks;
}
lock (EventQueue)
{
if (EventQueue.Count >= m_MaxScriptQueue)
{
return;
}
if (data.EventName == "timer")
{
if (m_TimerQueued)
{
return;
}
m_TimerQueued = true;
}
if (data.EventName == "control")
{
int held = ((LSL_Types.LSLInteger)data.Params[1]).value;
// int changed = ((LSL_Types.LSLInteger)data.Params[2]).value;
// If the last message was a 0 (nothing held)
// and this one is also nothing held, drop it
//
if (m_LastControlLevel == held && held == 0)
{
return;
}
// If there is one or more queued, then queue
// only changed ones, else queue unconditionally
//
if (m_ControlEventsInQueue > 0)
{
if (m_LastControlLevel == held)
{
return;
}
}
m_LastControlLevel = held;
m_ControlEventsInQueue++;
}
if (data.EventName == "collision")
{
if (m_CollisionInQueue)
{
return;
}
if (data.DetectParams == null)
{
return;
}
m_CollisionInQueue = true;
}
EventQueue.Enqueue(data);
if (m_CurrentWorkItem == null)
{
m_CurrentWorkItem = Engine.QueueEventHandler(this);
}
}
}
public QueueConsumer(EventQueue queue)
{
_queue = queue;
}
public void TriggerComponentTest_navigationNodeMove()
{
// Initializing trigger Entity
Entity l_testTriggerEntity = Entity.alloc();
l_testTriggerEntity.EntityGameWorld = EntityGameWorld.build(TransformComponent.alloc());
EntityComponent.add_component(l_testTriggerEntity, NavigationEngineTestTriggerComponent.alloc());
EntityComponent.add_component(l_testTriggerEntity, Locomotion.alloc(new LocomotionData()
{
Speed = float.MaxValue * 0.1f
}));
// We warp the l_testTriggeredEntity to a random NavigationNode
EventQueue.enqueueEvent(
TestEventQueue,
NavigationNodeWarpEntityEvent.alloc(
l_testTriggerEntity,
NavigationGraphAlgorithm.pickRandomNode(NavigationGraphContainer.UniqueNavigationGraph)
)
);
EventQueue.iterate(TestEventQueue);
// We create the Entity that will be involved in the trigger
Entity l_entity = Entity.alloc();
l_entity.EntityGameWorld = EntityGameWorld.build(TransformComponent.alloc());
EntityComponent.add_component(l_entity, Locomotion.alloc(new LocomotionData()
{
Speed = float.MaxValue * 0.1f
}));
ActionPointData l_actionPointdata = new ActionPointData()
{
InitialActionPoints = 999f, CurrentActionPoints = 999f
};
EntityComponent.add_component(l_entity, ActionPoint.alloc(ref l_actionPointdata));
var l_entityNavigationNodeEnumerator =
NavigationGraphAlgorithm.getReachableNeighborNavigationNodes(NavigationGraphContainer.UniqueNavigationGraph, l_testTriggerEntity.CurrentNavigationNode, NavigationGraphFlag.CURRENT).GetEnumerator();
l_entityNavigationNodeEnumerator.MoveNext();
EventQueue.enqueueEvent(
TestEventQueue,
NavigationNodeWarpEntityEvent.alloc(
l_entity,
l_entityNavigationNodeEnumerator.Current
)
);
NavigationNodeMoveEvent l_navigationNodeMoveEvent = NavigationNodeMoveEvent.alloc(l_entity, l_testTriggerEntity.CurrentNavigationNode);
EventQueue.enqueueEvent(
TestEventQueue,
l_navigationNodeMoveEvent
);
while (!l_navigationNodeMoveEvent.IsCompleted())
{
LocomotionSystemV2Container.Tick(1.0f);
EventQueue.iterate(TestEventQueue);
}
NavigationEngineTestTriggerComponent l_triggerComponent = EntityComponent.get_component <NavigationEngineTestTriggerComponent>(l_testTriggerEntity);
Assert.IsTrue(l_triggerComponent.IsTriggered);
Assert.IsTrue(l_triggerComponent.TriggeredEntity == l_entity);
}
