/// <summary>
/// Removes the subscriber from the list of subscribers for the associated event type.
/// </summary>
/// <typeparam name="TEvent">The type of the event.</typeparam>
/// <param name="subscriber">The subscriber to remove.</param>
internal void Remove <TEvent>(EventSubscriber subscriber)
where TEvent : EventBase
{
var eventType = typeof(TEvent).Name;
Remove(eventType, subscriber);
}
public static void Main(string[] args)
{
INode node = NodeFactory.Default;
node.Loger.Type = LogType.ALL;
node.AddLogHandler(new SmartRoute.ConsoleLogHandler(LogType.ALL));
node.Open();
EventSubscriber henry = node.Register <EventSubscriber>("henry");
henry.Register <User>(OnUser);
henry.Register <Employee>(OnEmployees);
node.SubscriberRegisted = (n, s) =>
{
if (s.Name == "ken")
{
// System.Threading.ThreadPool.QueueUserWorkItem(ToKen, henry);
}
};
while (true)
{
//System.Text.StringBuilder sb = new System.Text.StringBuilder();
//foreach (ISubscriber item in node.GetLocalSubscriber())
// sb.Append(item.ToString() + ',');
//foreach (ISubscriber item in node.GetRemoteSubscriber())
// sb.Append(item.ToString() + ',');
//node.Loger.Process(LogType.INFO, sb.ToString());
// Console.WriteLine(mCount);
System.Threading.Thread.Sleep(1000);
}
Console.Read();
}
public void WhenSourceEventRaised_ThenCollectedSubscriberIsNotNotified()
{
var source = new EventSource();
var publisher = new EventPublisher(source);
var subscriber = new EventSubscriber();
var subscription = publisher.PropertyChanged.Subscribe(subscriber.OnChanged);
try
{
subscriber = null;
subscription.Dispose();
GC.Collect();
GC.WaitForFullGCApproach(-1);
GC.WaitForFullGCComplete(-1);
GC.WaitForPendingFinalizers();
source.RaisePropertyChanged("Foo");
Assert.Equal(0, EventSubscriber.ChangedProperties.Count);
}
finally
{
//subscription.Dispose();
}
}
public bool Unsubscribe(object source, string type, EventSubscriber subscriber)
{
EventFilter filter;
CreateFilter(source, type, out filter, false);
return(Unsubscribe(ref filter, subscriber));
}
public void WhenSourceEventRaised_ThenCollectedSubscriberIsNotNotified()
{
var source = new EventSource();
var publisher = new EventPublisher(source);
var subscriber = new EventSubscriber();
var subscription = publisher.PropertyChanged.Subscribe(subscriber.OnChanged);
try
{
subscriber = null;
subscription.Dispose();
GC.Collect();
GC.WaitForFullGCApproach(-1);
GC.WaitForFullGCComplete(-1);
GC.WaitForPendingFinalizers();
source.RaisePropertyChanged("Foo");
Assert.Equal(0, EventSubscriber.ChangedProperties.Count);
}
finally
{
//subscription.Dispose();
}
}
public static void Main(string[] args)
{
INode node = NodeFactory.Default;
node.Loger.Type = LogType.ALL;
node.AddLogHandler(new SmartRoute.ConsoleLogHandler(LogType.ALL));
node.Open();
EventSubscriber ken = node.Register <EventSubscriber>("ken");
ken.Register <User>(OnUser);
ken.Register <Employee>(OnEmployees);
node.SubscriberRegisted = (n, s) =>
{
if (s.Name == "henry")
{
ken.Publish("henry", Employee.GetEmployee());
}
};
while (true)
{
Console.WriteLine(mCount);
System.Threading.Thread.Sleep(1000);
}
Console.Read();
}
static void Main(string[] args)
{
INode node = NodeFactory.Default;
node.Loger.Type = LogType.ALL;
node.AddLogHandler(new ConsoleLogHandler(LogType.ALL));
node.Open();
EventSubscriber ken = node.Register <EventSubscriber>("ken");
node.SubscriberRegisted += (n, s) =>
{
if (s.Name == "henry")
{
System.Threading.ThreadPool.QueueUserWorkItem(o =>
{
while (true)
{
Employee result = ken.Publish <Employee>("henry", Employee.GetEmployee());
if (result == null)
{
throw new Exception("error");
}
System.Threading.Interlocked.Increment(ref mCount);
}
});
}
};
while (true)
{
Console.WriteLine("{0}/秒|{1}", mCount - mLastCount, mCount);
mLastCount = mCount;
System.Threading.Thread.Sleep(1000);
}
Console.Read();
}
public IActionResult Delete(int id)
{
EventSubscriber es = _subscriptionService.GetSubscription(id);
if (es == null)
{
var result = new
{
status = "error",
code = "1000",
message = "Subscription with such 'id' is not exist!"
};
var error = JsonConvert.SerializeObject(result, _serializerSettings);
return(new OkObjectResult(error));
}
var status = _subscriptionService.DeleteSubscriptionAsync(es);
if (!status)
{
return(new StatusCodeResult(500));
}
var response = new
{
status = "success",
code = "200",
message = "Ok"
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public void Main()
{
this.subscriber = new EventSubscriber("localhost:5000");
//Run(this);
OnStart(null);
ReadLine();
}
private WeakReference CreateEventSubscriber(EventPublisher publisher)
{
var subscriber = new EventSubscriber(publisher);
Assert.AreEqual(1, publisher.Subscribers);
return(new WeakReference(subscriber));
}
public void PublishAllEventsAndSubscribeToSome()
{
IEventRegistry registry = new EventRegistry();
SimpleClient client = new SimpleClient("PublishAllEventsAndSubscribeToSome");
registry.PublishEvents(client);
EventSubscriber sub = new EventSubscriber();
OtherEventSubscriber sub2 = new OtherEventSubscriber();
Assert.IsFalse(sub.EventRaised, "Event raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
client.ClientMethodThatTriggersEvent();
Assert.IsFalse(sub.EventRaised, "Event raised");
client.ClientMethodThatTriggersEvent3();
Assert.IsFalse(sub2.EventRaised, "Event raised");
registry.Subscribe(sub);
registry.Subscribe(sub2);
client.ClientMethodThatTriggersEvent();
client.ClientMethodThatTriggersEvent3();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsTrue(sub2.EventRaised, "Event Not Raised");
}
public void TestInitialize()
{
fixture = new Fixture().Customize(new AutoNSubstituteCustomization());
inversionOfControlContainer = fixture.Freeze <IServiceProvider>();
configuration = fixture.Freeze <IEventSubscriberConfiguration>();
subscriptionClientFactory = fixture.Freeze <ISubscriptionClientFactory>();
logger = fixture.Freeze <ILogger>();
IList <SubscriptionInfo> subscriptionsConfig = new List <SubscriptionInfo>
{
new SubscriptionInfo(
typeof(FakeEvent1),
typeof(FakeEvent1Handler),
TopicName1,
Subscriptioname1,
RetryPolicyBase.DefaultRetry),
new SubscriptionInfo(
typeof(FakeEvent2),
typeof(FakeEvent2Handler),
TopicName2,
Subscriptioname2,
RetryPolicyBase.DefaultRetry)
};
configuration.ServiceBusConnectionString.Returns(fixture.Create <string>());
configuration.Subscriptions.Returns(subscriptionsConfig);
sut = fixture.Create <EventSubscriber>();
}
private void NotifySubscribers(AbstractEvent eventData)
{
List <EventSubscriber> subscribers = gameEvents[eventData.type];
for (int cnt = subscribers.Count - 1; cnt >= 0; cnt--) // Trigger buffs, then argument effects, then debuffs
// This check is LITERALLY for only one status effect - Resonance.
// Because Resonance will remove all other Resonance subscribers during its own NotifyOfEvent, and the original notification happens here...
// If there were 5 resonance listeners, the subscribers.count would go from 5->0 in the first iteration, but the for loop would still iterate 4 more times.
// This causes an array-out-of-index error. Ideally, this check prevents that.
// I don't want to have to keep doing hacks like this as it's gonna come back to bite me, but it works.
// TODO: Rework Resonance implementation to prevent having to use this
{
if (cnt >= subscribers.Count)
{
continue;
}
EventSubscriber subscriber = subscribers[cnt];
subscriber.NotifyOfEvent(eventData);
}
// update ui
List <ITriggerOnEvent> UISubscribers = UIEvents[eventData.type];
foreach (ITriggerOnEvent subscriber in UISubscribers)
{
subscriber.TriggerOnEvent(eventData);
}
}
public void PublishAllEventsSubscribeToNamedEvents()
{
IEventRegistry registry = new EventRegistry();
SimpleClient client = new SimpleClient("PublishAllEvents");
SimpleClient2 client2 = new SimpleClient2();
registry.PublishEvents(client);
registry.PublishEvents(client2);
EventSubscriber sub = new EventSubscriber();
EventSubscriber sub2 = new EventSubscriber();
Assert.IsFalse(sub.EventRaised, "Event raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
client.ClientMethodThatTriggersEvent();
client2.ClientMethodThatTriggersEvent();
Assert.IsFalse(sub.EventRaised, "Event raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
registry.Subscribe(sub, typeof(SimpleClient));
registry.Subscribe(sub2, typeof(SimpleClient2));
client.ClientMethodThatTriggersEvent();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
client2.ClientMethodThatTriggersEvent();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsTrue(sub2.EventRaised, "Event Not Raised");
}
public void EventSubscriber_WaitForFutureEvents()
{
var loopback = new Loopback();
var subscriber = new EventSubscriber(loopback);
Task.Delay(1).ContinueWith(t => loopback.Raise());
VerifyResults(subscriber);
}
public void EventSubscriber_WaitForPastEvents()
{
var loopback = new Loopback();
var subscriber = new EventSubscriber(loopback);
loopback.Raise();
VerifyResults(subscriber);
}
public DMonitoCenter(int timeout = 10000)
{
Node = SmartRoute.NodeFactory.Default;
TimeOut = timeout;
mLockEventSubscriber = Node.Register <EventSubscriber>(SMART_DLOCKCENTER);
mLockEventSubscriber.Register <Protocols.EnterKey>(OnEnter);
mLockEventSubscriber.Register <Protocols.FreeKey>(OnFree);
}
public DMonitoCenter(INode node, int timeout = 10000)
{
TimeOut = timeout;
mLockEventSubscriber = node.Register <EventSubscriber>(SMART_DLOCKCENTER);
mLockEventSubscriber.Register <Protocols.EnterKey>(OnEnter);
mLockEventSubscriber.Register <Protocols.FreeKey>(OnFree);
Node = node;
}
static void VerifyResults(EventSubscriber subscriber)
{
var result = subscriber.WaitForEvent();
Assert.IsTrue(result.Name == nameof(Loopback.NoParams) && result.Params.Length == 0);
result = subscriber.WaitForEvent();
Assert.IsTrue(result.Name == nameof(Loopback.TwoParams) && result.Params.Length == 2 && (string)result.Params[0] == "A" && (int)result.Params[1] == 1);
}
protected override async Task OnStart()
{
_caller = await CreateMethodCaller <Integer, Integer>(":testmethod");
_sub = await SubscribeEvent <String>(":stringsforfun");
_sub.OnReceived += _sub_OnReceived;
}
public void UnsubscribeFromAllEvents(EventSubscriber subscriber)
{
foreach (EventType type in subscriber.eventsSubscribedTo)
{
EventSystemManager.Instance.UnsubscribeFromEvent(subscriber, type);
}
subscriber.eventsSubscribedTo.Clear();
}
protected void Subscribe(int id, EventHandler <GameEventArgs> handler)
{
if (eventSubscriber == null)
{
eventSubscriber = EventSubscriber.Create(this);
}
eventSubscriber.Subscribe(id, handler);
}
private void UnsubscribeFromEvent(EventSubscriber subscriber, EventType type)
{
// for (int i = gameEvents[type].Count - 1; i >= 0; i--){
// if (gameEvents[type][i].INSTANCE_ID == subscriber.INSTANCE_ID){
// gameEvents[type].RemoveAt(i);
// }
// }
gameEvents[type].RemoveAll(sub => sub.Equals(subscriber));
}
private void AddEventSubscriber(EventSubscriber eventSubscriber)
{
eventSubscriber.EventRaised += EventSubscriberOnEventRaised;
foreach (var availableEvent in eventSubscriber.AvailableEvents)
{
_events.TryAdd(availableEvent.EventId, availableEvent);
}
}
protected async Task UnsubscribeEvent <TEvent>(EventSubscriber <TEvent> subscr)
{
await CallControlMethod <Deregister, Empty>("events.unsubscribe", new Deregister()
{
EndPoint = subscr.Endpoint.ToString()
});
_eventHandlers.Remove(subscr);
}
/// <summary>
/// Processes the messages received from the event client.
/// </summary>
/// <param name="message">Message received from the client.</param>
private void ProcessMessage(string message)
{
// Turn the message into an xml document.
XmlDocument document = new XmlDocument();
document.LoadXml(message);
// Find out what type of request message was sent.
if (IProcEventRegistration.IsValidRequest(document))
{
IProcEventRegistration er = new IProcEventRegistration(document);
// Make sure that the host address is loopback for now.
if (!IPAddress.IsLoopback(er.RemoteAddress))
{
log.Error(String.Format("An invalid address was specified in the registration message {0}.", er.RemoteAddress));
eventSocket.Shutdown(SocketShutdown.Both);
eventSocket.Close();
subscriberTable.Remove(port);
}
// See if the client is registering or deregistering.
if (er.Registering)
{
// Create the event subscribers.
simiasNodeEventSubscriber = new EventSubscriber();
simiasSyncEventSubscriber = new SyncEventSubscriber();
simiasNotifyEventSubscriber = new NotifyEventSubscriber();
log.Debug("Client {0}:{1} has registered for interprocess events", er.RemoteAddress, er.Port);
}
else
{
DisposeSubscribers();
log.Debug("Client {0}:{1} has deregistered for interprocess events", er.RemoteAddress, er.Port);
}
}
else if (IProcEventListener.IsValidRequest(document))
{
// Make sure that registration has occurred.
if ((simiasNodeEventSubscriber == null) ||
(simiasSyncEventSubscriber == null) ||
(simiasNodeEventSubscriber == null))
{
log.Error("Client must be registered before subscribing for events.");
throw new SimiasException("Client must be registered before subscribing for events.");
}
IProcEventListener el = new IProcEventListener(document);
ProcessEventListener(el);
}
else
{
log.Debug("{0} : An invalid request message was received.", port);
throw new SimiasException("An invalid request message was received.");
}
}
public override bool Initialize(ref string errMsg)
{
InitResult = InitResult.InitFail;
bool configured = ConfigMgr.Contains(typeof(IPSSetting).FullName);
Setting = ConfigMgr.GetSetting(typeof(IPSSetting), true) as IPSSetting;
if (Setting == null)
{
Log.Error("IPS Setting can not be instantiated");
return(false);
}
if (!configured)
{
Log.Error("IPS subsystem has not been configured");
return(true);
}
InitializeDirectory();
if (!string.IsNullOrEmpty(Setting.ServerAddr))
{
_remoteProc = new IPSRemoteProc(Setting.ServerAddr, Setting.InstructPort);
}
if (!InitializeDevices())
{
return(false);
}
if (!InitializeMaps())
{
return(false);
}
_eventSubscriber = new EventSubscriber();
_eventSubscriber.ServerAddr = Setting.ServerAddr;
_eventSubscriber.ServrtPort = Setting.EventPort;
_eventSubscriber.LocationTag = Setting.EventTag;
_eventSubscriber.OnLocationChanged += OnLocationUpdate;
_eventSubscriber.OnCameraStateChanged += OnCameraStateChanged;
_eventSubscriber.StartNidsEvent();
if (Setting.IsLDAPEnabled)
{
_ldapClient = new LDAPClient(Setting.LDAPServerAddr);
_ldapClient.Port = Setting.LDAPPort;
_ldapClient.User = Setting.LDAPUser;
_ldapClient.Password = Setting.LDAPPassowrd;
_ldapClient.PortraitDir = PortraitDir;
_ldapClient.OnPortaitDownloaded += OnPortraitDownloaded;
}
return(true);
}
public bool IsSubscriber(Event _event, AppUser user)
{
EventSubscriber subscription = _event.Subscribers.FirstOrDefault(a => a.Subscriber.Id == user.Id);
if (subscription != null)
{
return(true);
}
return(false);
}
private static void ToKen(object state)
{
EventSubscriber henry = (EventSubscriber)state;
while (true)
{
henry.Publish("ken", Employee.GetEmployee());
System.Threading.Thread.Sleep(1);
}
}
/// <summary>
/// Register private events with a session id
/// </summary>
/// <typeparam name="TEventInterface">
/// The event contract interface which defines the events. Please note that all events
/// must be an <see cref="EventHandler" /> or <see cref="EventHandler{TEventArgs}" />.
/// </typeparam>
/// <param name="eventProvider">The instance of <see cref="TEventInterface" /> which calls the events</param>
/// <returns>Return the session id</returns>
public uint RegisterPrivateEvents <TEventInterface>(TEventInterface eventProvider)
{
var id = (uint)Interlocked.Increment(ref _eventIdCounter);
var eventSubscriber = new EventSubscriber(eventProvider, typeof(TEventInterface), id);
AddEventSubscriber(eventSubscriber);
return(id);
}
/// <summary>
/// Look through and return all models in scope for event publishers with the specified event name.
/// If eventName is null then all will be returned.
/// </summary>
/// <param name="subscriber">The event subscriber to find publishers for</param>
/// <returns>The list of matching event publishers</returns>
private static List <EventPublisher> FindEventPublishers(EventSubscriber subscriber)
{
List <EventPublisher> publishers = new List <EventPublisher>();
foreach (Model model in Apsim.FindAll(subscriber.Model))
{
publishers.AddRange(FindEventPublishers(subscriber.Name, model));
}
return(publishers);
}
public void WhenSourceEventRaised_ThenSubscriberIsNotified()
{
var source = new EventSource();
var publisher = new EventPublisher(source);
var subscriber = new EventSubscriber();
publisher.PropertyChanged.Subscribe(subscriber.OnChanged);
Assert.Equal(0, EventSubscriber.ChangedProperties.Count);
source.RaisePropertyChanged("Foo");
Assert.Equal(1, EventSubscriber.ChangedProperties.Count);
Assert.Equal("Foo", EventSubscriber.ChangedProperties[0]);
}
public EventWiringDescriptor(string eventName, EventSubscriber[] subscribers)
{
this.eventName = eventName;
this.subscribers = subscribers;
}
/// <summary>
/// Look through and return all models in scope for event publishers with the specified event name.
/// If eventName is null then all will be returned.
/// </summary>
/// <param name="subscriber">The event subscriber to find publishers for</param>
/// <returns>The list of matching event publishers</returns>
private static List<EventPublisher> FindEventPublishers(EventSubscriber subscriber)
{
List<EventPublisher> publishers = new List<EventPublisher>();
foreach (Model model in Apsim.FindAll(subscriber.Model))
publishers.AddRange(FindEventPublishers(subscriber.Name, model));
return publishers;
}
private WeakReference CreateEventSubscriber(EventPublisher publisher)
{
var subscriber = new EventSubscriber(publisher);
Assert.AreEqual(1, publisher.Subscribers);
return new WeakReference(subscriber);
}
private string EventHandlerMethodName(EventSubscriber eventSubscriber)
{
return eventSubscriber.EventHandler ?? ("On" + eventName);
}
public void TestUnsubscribe()
{
var trace = new List<string>();
var sender = "Foo";
var handlers = new EventSubscriber[] {
(e) => trace.Add("a"),
(e) => trace.Add("b"),
(e) => trace.Add("c")
};
foreach (var handler in handlers)
Bus.Subscribe(sender, "Test", handler);
Bus.Unsubscribe(sender, "Test", handlers[1]);
Bus.Broadcast(sender, "Test", null);
Assert.AreEqual(new string[] { "c", "a" }, trace.ToArray());
}
public void TestDisposeSubscription()
{
var trace = new List<string>();
var sender = "Foo";
var handlers = new EventSubscriber[] {
(e) => trace.Add("a"),
(e) => trace.Add("b"),
(e) => trace.Add("c")
};
var subscriptions = (from handler in handlers select Bus.Subscribe(sender, "Test", handler)).ToArray();
subscriptions[1].Dispose();
Bus.Broadcast(sender, "Test", null);
Assert.AreEqual(new string[] { "c", "a" }, trace.ToArray());
}
public void PublishAllEventsAndSubscribeToSome()
{
IEventRegistry registry = new EventRegistry();
SimpleClient client = new SimpleClient("PublishAllEventsAndSubscribeToSome");
registry.PublishEvents(client);
EventSubscriber sub = new EventSubscriber();
OtherEventSubscriber sub2 = new OtherEventSubscriber();
Assert.IsFalse(sub.EventRaised, "Event raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
client.ClientMethodThatTriggersEvent();
Assert.IsFalse(sub.EventRaised, "Event raised");
client.ClientMethodThatTriggersEvent3();
Assert.IsFalse(sub2.EventRaised, "Event raised");
registry.Subscribe(sub);
registry.Subscribe(sub2);
client.ClientMethodThatTriggersEvent();
client.ClientMethodThatTriggersEvent3();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsTrue(sub2.EventRaised, "Event Not Raised");
}
public void PublishAllEventsSubscribeToNamedEvents()
{
IEventRegistry registry = new EventRegistry();
SimpleClient client = new SimpleClient("PublishAllEvents");
SimpleClient2 client2 = new SimpleClient2();
registry.PublishEvents(client);
registry.PublishEvents(client2);
EventSubscriber sub = new EventSubscriber();
EventSubscriber sub2 = new EventSubscriber();
Assert.IsFalse(sub.EventRaised, "Event raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
client.ClientMethodThatTriggersEvent();
client2.ClientMethodThatTriggersEvent();
Assert.IsFalse(sub.EventRaised, "Event raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
registry.Subscribe(sub, typeof (SimpleClient));
registry.Subscribe(sub2, typeof (SimpleClient2));
client.ClientMethodThatTriggersEvent();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsFalse(sub2.EventRaised, "Event raised");
client2.ClientMethodThatTriggersEvent();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsTrue(sub2.EventRaised, "Event Not Raised");
}
public void PublishAllEventsMultipleSubscribersAndUnsubscribe()
{
IEventRegistry registry = new EventRegistry();
SimpleClient client = new SimpleClient("PublishAllEvents");
registry.PublishEvents(client);
EventSubscriber sub = new EventSubscriber();
EventSubscriber sub2 = new EventSubscriber();
registry.Subscribe(sub);
registry.Subscribe(sub2);
client.ClientMethodThatTriggersEvent();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
Assert.IsTrue(sub2.EventRaised, "Event Not Raised");
Assert.AreEqual(1, sub.EventCount);
Assert.AreEqual(1, sub2.EventCount);
registry.Unsubscribe(sub2);
client.ClientMethodThatTriggersEvent();
Assert.AreEqual(2, sub.EventCount);
Assert.AreEqual(1, sub2.EventCount);
}
public void RespectsInheritance()
{
SimpleClient source = new SimpleClient("foo");
IEventRegistry registry = new EventRegistry();
registry.PublishEvents(source);
EventSubscriber sub = new EventSubscriber();
Assert.IsFalse(sub.EventRaised, "Event raised");
source.ClientMethodThatTriggersEvent();
Assert.IsFalse(sub.EventRaised, "Event raised");
registry.Subscribe(sub, typeof(ISimpleClient));
source.ClientMethodThatTriggersEvent();
Assert.IsTrue(sub.EventRaised, "Event Not Raised");
}
