void userKicked_Published(object sender, EventSubscription<UserKicked>.PublishedEventArgs e) { // Inform that user has been kicked and exit the application when UserKicked event is published ExecuteOnUIThread(() => { MessageBox.Show("You have been kicked"); this.Close(); }); }
public void NullActionThrows() { var filterDelegateReference = new MockDelegateReference() { Target = (Predicate<object>)(arg => { return true; }) }; var eventSubscription = new EventSubscription<object>(null, filterDelegateReference); }
public static EventListener Create(EventSubscription eventSubscription) { switch (eventSubscription.EventType) { case "NewSensorData": return new SensorDataEventListener(eventSubscription); case "NewPosition": return new PositionEventListener(eventSubscription); } throw new ArgumentOutOfRangeException("eventSubscription", "EventType does not exist."); }
public void FilterShouldNotBeNull() { var action = new Mock<IDelegateReference>(); action.SetupGet(a => a.Target).Returns((Action<object>)delegate { }); var filter = new Mock<IDelegateReference>(); filter.SetupGet(a => a.Target).Returns((Predicate<object>)delegate { return true; }); var subscription = new EventSubscription<object>(action.Object, filter.Object); Assert.That(subscription.Filter, Is.Not.Null); }
/// <summary> /// Creates an instance of the correct child eventlistener /// </summary> /// <param name="eventSubscription"></param> /// <returns></returns> public static EventListener Create(EventSubscription eventSubscription) { switch (eventSubscription.EventType) { case "ButtonPressed": case "HumidityChanged": case "LightChanged": case "TemperatureChanged": return new SensorDataEventListener(eventSubscription); case "LocationUpdated": return new PositionEventListener(eventSubscription); } throw new ArgumentOutOfRangeException("eventSubscription", "EventType does not exist."); }
public void NullTargetInFilterThrows() { var actionDelegateReference = new MockDelegateReference() { Target = (Action<object>)delegate { } }; var filterDelegateReference = new MockDelegateReference() { Target = null }; var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference); }
public void CanInitEventSubscription() { var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { }); var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { return true; }); var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference, null, EventCommunicatorsRelationship.All); var subscriptionToken = new SubscriptionToken(t => { }); eventSubscription.SubscriptionToken = subscriptionToken; Assert.Same(actionDelegateReference.Target, eventSubscription.Action); Assert.Same(filterDelegateReference.Target, eventSubscription.Filter); Assert.Same(subscriptionToken, eventSubscription.SubscriptionToken); }
private void SubscribeToEvents() { // Workaround for issue #2 'EventSubscription<TEvent> default constructor does not start the service' // This issue is fixed in nvents 0.7 Events.Service.Start(); // Create a EventSubscription for the MessageSent event var messageSent = new EventSubscription<MessageSent>(); // Register a handler for when Published is raised for MessageSent event messageSent.Published += messageSent_Published; // Create a EventSubscription for the UserKicked event and filter to only the current user var userKicked = new EventSubscription<UserKicked>(user => user.UserId == currentUser.Id); // Register a handler for when Published is raised for UserKicked event (will only be raised for events that passes the subscription filter) userKicked.Published += userKicked_Published; }
public void DifferentTargetTypeInActionThrows() { var actionDelegateReference = new MockDelegateReference() { Target = (Action<int>)delegate { } }; var filterDelegateReference = new MockDelegateReference() { Target = (Predicate<string>)(arg => { return true; }) }; var eventSubscription = new EventSubscription<string>(actionDelegateReference, filterDelegateReference); }
public void GetExecutionStrategyDoesNotExecuteActionIfFilterReturnsFalse() { bool actionExecuted = false; var actionDelegate = new Mock<IDelegateReference>(); actionDelegate.SetupGet(d => d.Target).Returns((Action<int>)delegate { actionExecuted = true; }); var filterDelegate = new Mock<IDelegateReference>(); filterDelegate.SetupGet(d => d.Target).Returns((Predicate<int>)delegate { return false; }); var eventSubscription = new EventSubscription<int>(actionDelegate.Object, filterDelegate.Object); var publishAction = eventSubscription.GetExecutionStrategy(); publishAction.Invoke(new object[] { null }); Assert.That(actionExecuted, Is.False); }
public void NullTargetInActionThrows() { Assert.ThrowsException<ArgumentException>(() => { var actionDelegateReference = new MockDelegateReference() { Target = null }; var filterDelegateReference = new MockDelegateReference() { Target = (Predicate<object>)(arg => { return true; }) }; var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference); }); }
public void DifferentTargetTypeInActionThrows() { var actionDelegateReference = new MockDelegateReference() { Target = (Action<int>)delegate { } }; var filterDelegateReference = new MockDelegateReference() { Target = (Predicate<string>)(arg => { return true; }) }; Assert.Throws<ArgumentException>( () => { var eventSubscription = new EventSubscription<string>(actionDelegateReference, filterDelegateReference, null, EventCommunicatorsRelationship.All); }); }
public IEnumerable<EventSubscription> GetAll() { var subscriptions = new List<EventSubscription>(); var path = GetPathForSubscriptions(); var files = Directory.GetFiles(path); foreach (var file in files) { var json = File.ReadAllText(file); var holder = _serializer.FromJson<EventSubscriptionHolder>(json); var subscription = new EventSubscription(); subscription.Id = Guid.Parse(holder.Id); subscription.LastEventId = holder.LastEventId; subscription.Owner = Type.GetType(holder.Owner); subscription.EventType = Type.GetType(holder.EventType); subscription.EventName = holder.EventName; subscription.Method = subscription.Owner.GetMethod(Bifrost.Events.ProcessMethodInvoker.ProcessMethodName, new Type[] { subscription.EventType }); subscriptions.Add(subscription); } return subscriptions; }
public void GetExecutionStrategyShouldReturnDelegateThatExecutesTheFilterAndThenTheAction() { var executedDelegates = new List<string>(); var actionDelegate = new Mock<IDelegateReference>(); actionDelegate.SetupGet(d => d.Target).Returns((Action<object>) delegate { executedDelegates.Add("Action"); }); var filterDelegate = new Mock<IDelegateReference>(); filterDelegate.SetupGet(d => d.Target).Returns((Predicate<object>) delegate { executedDelegates.Add("Filter"); return true; }); var eventSubscription = new EventSubscription<object>(actionDelegate.Object, filterDelegate.Object); var publishAction = eventSubscription.GetExecutionStrategy(); Assert.That(publishAction, Is.Not.Null); publishAction.Invoke(null); Assert.That(executedDelegates.Count, Is.EqualTo(2)); Assert.That(executedDelegates[0], Is.EqualTo("Filter")); Assert.That(executedDelegates[1], Is.EqualTo("Action")); }
public Task <string> CreateEventSubscription(EventSubscription subscription) => _innerService.CreateEventSubscription(subscription);
public static void AddQueueHandler( this EventSubscription subscription, IQueue queue, IQueueMessageMapper mapper = null, long id = 0) { subscription.AddHandler(new QueueHandler(subscription, id, queue, mapper)); }
public async Task <string> EventSource() { // use the event stream content type, as per specification HttpContext.Response.ContentType = "text/event-stream"; // get the last event id out of the header string lastEventIdString = HttpContext.Request.Headers["Last-Event-ID"].FirstOrDefault(); int temp; int? lastEventId = null; if (lastEventIdString != null && int.TryParse(lastEventIdString, out temp)) { lastEventId = temp; } string remoteIp = HttpContext.Connection.RemoteIpAddress.ToString(); // open the current request stream for writing. // Use UTF-8 encoding, and do not close the stream when disposing. using (var clientStream = new StreamWriter(HttpContext.Response.Body, Encoding.UTF8, 1024, true) { AutoFlush = true }) { // subscribe to the heartbeat event. Elsewhere, a timer will push updates to this event periodically. using (EventSubscription <EventSourceUpdate> subscription = eventsService.SubscribeTo <EventSourceUpdate>("heartbeat")) { try { logger.LogInformation($"Opened event source stream to address: {remoteIp}"); await clientStream.WriteLineAsync($":connected {DateTimeOffset.Now.ToString("o")}"); // If a last event id is given, pump out any intermediate events here. if (lastEventId != null) { // We're not doing anything that stores events in this heartbeat demo, // so do nothing here. } // start pumping out events as they are pushed to the subscription queue while (true) { // asynchronously wait for an event to fire before continuing this loop. // this is implemented with a semaphore slim using the async wait, so it // should play nice with the async framework. EventSourceUpdate update = await subscription.WaitForData(); // push the update down the request stream to the client if (update != null) { string updateString = update.ToString(); await clientStream.WriteAsync(updateString); } if (HttpContext.RequestAborted.IsCancellationRequested == true) { break; } } } catch (Exception e) { // catch client closing the connection logger.LogInformation($"Closed event source stream from {remoteIp}. Message: {e.Message}"); } } } return(":closed"); }
public PSEventSubscriptionListInstance(EventSubscription eventSubscription) : base(eventSubscription) { }
public void StrategyPassesArgumentToDelegates() { string passedArgumentToAction = null; string passedArgumentToFilter = null; var actionDelegateReference = new MockDelegateReference((Action<string>)(obj => passedArgumentToAction = obj)); var filterDelegateReference = new MockDelegateReference((Predicate<string>)(obj => { passedArgumentToFilter = obj; return true; })); var eventSubscription = new EventSubscription<string>(actionDelegateReference, filterDelegateReference); var publishAction = eventSubscription.GetExecutionStrategy(); publishAction.Invoke(new[] { "TestString" }); Assert.AreEqual("TestString", passedArgumentToAction); Assert.AreEqual("TestString", passedArgumentToFilter); }
public void CanInitEventSubscription() { var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { }); var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { return true; }); var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference); var subscriptionToken = new SubscriptionToken(); eventSubscription.SubscriptionToken = subscriptionToken; Assert.AreSame(actionDelegateReference.Target, eventSubscription.Action); Assert.AreSame(filterDelegateReference.Target, eventSubscription.Filter); Assert.AreSame(subscriptionToken, eventSubscription.SubscriptionToken); }
/// <summary> /// Constructor /// </summary> /// <param name="eventSubscription">Data of the event to listen to</param> protected EventListener(EventSubscription eventSubscription) { this.EventSubscription = eventSubscription; }
public void Save(EventSubscription subscription) { var path = GetPathForSubscriptions(); var file = string.Format("{0}\\{1}.{2}.{3}", path, subscription.Owner.Namespace, subscription.Owner.Name, subscription.EventName); var holder = new EventSubscriptionHolder { Id = subscription.Id.ToString(), LastEventId = subscription.LastEventId, Owner = string.Format("{0}.{1}, {2}", subscription.Owner.Namespace, subscription.Owner.Name, subscription.Owner.Assembly.GetName().Name), EventType = string.Format("{0}.{1}, {2}", subscription.EventType.Namespace, subscription.EventType.Name, subscription.EventType.Assembly.GetName().Name), EventName = subscription.EventName }; var json = _serializer.ToJson(holder); File.WriteAllText(file, json); }
/// <summary> /// Create or update an event subscription to a domain. /// </summary> /// <remarks> /// Asynchronously creates a new event subscription or updates an existing /// event subscription. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group within the user's subscription. /// </param> /// <param name='domainName'> /// Name of the domain topic. /// </param> /// <param name='eventSubscriptionName'> /// Name of the event subscription to be created. Event subscription names must /// be between 3 and 100 characters in length and use alphanumeric letters /// only. /// </param> /// <param name='eventSubscriptionInfo'> /// Event subscription properties containing the destination and filter /// information. /// </param> public static EventSubscription CreateOrUpdate(this IDomainEventSubscriptionsOperations operations, string resourceGroupName, string domainName, string eventSubscriptionName, EventSubscription eventSubscriptionInfo) { return(operations.CreateOrUpdateAsync(resourceGroupName, domainName, eventSubscriptionName, eventSubscriptionInfo).GetAwaiter().GetResult()); }
public void DifferentTargetTypeInFilterThrows() { Assert.ThrowsException<ArgumentException>(() => { var actionDelegateReference = new MockDelegateReference() { Target = (Action<string>)delegate { } }; var filterDelegateReference = new MockDelegateReference() { Target = (Predicate<int>)(arg => { return true; }) }; var eventSubscription = new EventSubscription<string>(actionDelegateReference, filterDelegateReference); }); }
/// <summary> /// Subscribes to the role player changed event. /// </summary> /// <param name="domainRelationshipInfo">RelationshipInfo, which changes cause a notification.</param> /// <param name="bSourceRole"></param> /// <param name="elementId">Id of the role player, on which role changes to notify the observer.</param> /// <param name="action">Action to call on the observer.</param> public void Subscribe(DomainRelationshipInfo domainRelationshipInfo, bool bSourceRole, Guid elementId, Action <RolePlayerChangedEventArgs> action) { IDelegateReference actionReference = new DelegateReference(action, false); IDelegateReference filterReference = new DelegateReference(new Predicate <RolePlayerChangedEventArgs>(delegate { return(true); }), true); IEventSubscription subscription = new EventSubscription <RolePlayerChangedEventArgs>(actionReference, filterReference); #region dictionarySource if (bSourceRole) { lock (dictionarySource) { Guid domainClassId = domainRelationshipInfo.Id; if (!dictionarySource.Keys.Contains(domainClassId)) { dictionarySource.Add(domainClassId, new Dictionary <Guid, List <IEventSubscription> >()); } if (!dictionarySource[domainClassId].Keys.Contains(elementId)) { dictionarySource[domainClassId].Add(elementId, new List <IEventSubscription>()); } dictionarySource[domainClassId][elementId].Add(subscription); // process descendants foreach (DomainClassInfo info in domainRelationshipInfo.AllDescendants) { domainClassId = info.Id; if (!dictionarySource.Keys.Contains(domainClassId)) { dictionarySource.Add(domainClassId, new Dictionary <Guid, List <IEventSubscription> >()); } if (!dictionarySource[domainClassId].Keys.Contains(elementId)) { dictionarySource[domainClassId].Add(elementId, new List <IEventSubscription>()); } dictionarySource[domainClassId][elementId].Add(subscription); } } } #endregion #region dictionaryTarget if (!bSourceRole) { lock (dictionaryTarget) { Guid domainClassId = domainRelationshipInfo.Id; if (!dictionaryTarget.Keys.Contains(domainClassId)) { dictionaryTarget.Add(domainClassId, new Dictionary <Guid, List <IEventSubscription> >()); } if (!dictionaryTarget[domainClassId].Keys.Contains(elementId)) { dictionaryTarget[domainClassId].Add(elementId, new List <IEventSubscription>()); } dictionaryTarget[domainClassId][elementId].Add(subscription); // process descendants foreach (DomainClassInfo info in domainRelationshipInfo.AllDescendants) { domainClassId = info.Id; if (!dictionaryTarget.Keys.Contains(domainClassId)) { dictionaryTarget.Add(domainClassId, new Dictionary <Guid, List <IEventSubscription> >()); } if (!dictionaryTarget[domainClassId].Keys.Contains(elementId)) { dictionaryTarget[domainClassId].Add(elementId, new List <IEventSubscription>()); } dictionaryTarget[domainClassId][elementId].Add(subscription); } } } #endregion }
public void GetExecutionStrategyShouldReturnNullIfActionIsNull() { var actionDelegate = new Mock<IDelegateReference>(); actionDelegate.SetupGet(d => d.Target).Returns((Action<object>)delegate { }); var filterDelegate = new Mock<IDelegateReference>(); filterDelegate.SetupGet(d => d.Target).Returns((Predicate<object>)delegate { return true; }); var eventSubscription = new EventSubscription<object>(actionDelegate.Object, filterDelegate.Object); var publishAction = eventSubscription.GetExecutionStrategy(); Assert.That(publishAction, Is.Not.Null); actionDelegate.SetupGet(d => d.Target).Returns(null); publishAction = eventSubscription.GetExecutionStrategy(); Assert.That(publishAction, Is.Null); }
private async Task <bool> SeedSubscription(Event evt, EventSubscription sub, HashSet <string> toQueue, CancellationToken cancellationToken) { foreach (var eventId in await _eventRepository.GetEvents(sub.EventName, sub.EventKey, sub.SubscribeAsOf, cancellationToken)) { if (eventId == evt.Id) { continue; } var siblingEvent = await _eventRepository.GetEvent(eventId, cancellationToken); if ((!siblingEvent.IsProcessed) && (siblingEvent.EventTime < evt.EventTime)) { await QueueProvider.QueueWork(eventId, QueueType.Event); return(false); } if (!siblingEvent.IsProcessed) { toQueue.Add(siblingEvent.Id); } } if (!await _lockProvider.AcquireLock(sub.WorkflowId, cancellationToken)) { Logger.LogInformation("Workflow locked {0}", sub.WorkflowId); return(false); } try { var workflow = await _workflowRepository.GetWorkflowInstance(sub.WorkflowId, cancellationToken); IEnumerable <ExecutionPointer> pointers = null; if (!string.IsNullOrEmpty(sub.ExecutionPointerId)) { pointers = workflow.ExecutionPointers.Where(p => p.Id == sub.ExecutionPointerId && !p.EventPublished && p.EndTime == null); } else { pointers = workflow.ExecutionPointers.Where(p => p.EventName == sub.EventName && p.EventKey == sub.EventKey && !p.EventPublished && p.EndTime == null); } foreach (var p in pointers) { p.EventData = evt.EventData; p.EventPublished = true; p.Active = true; } workflow.NextExecution = 0; await _workflowRepository.PersistWorkflow(workflow, cancellationToken); await _subscriptionRepository.TerminateSubscription(sub.Id, cancellationToken); return(true); } catch (Exception ex) { Logger.LogError(ex, ex.Message); return(false); } finally { await _lockProvider.ReleaseLock(sub.WorkflowId); await QueueProvider.QueueWork(sub.WorkflowId, QueueType.Workflow); } }
protected EventListener(EventSubscription eventSubscription) { this.EventSubscription = eventSubscription; }
/// <summary> /// Processes the Query /// Retreives the data from the events /// For use in IEventSource /// </summary> /// <param name="query">Query</param> /// <returns>Whether the Query succeeded or not</returns> public static bool TryQuery(EventSubscription eventSubscription, TagBlink tagBlink, out TagBlink ReturnTagBlink) { ReturnTagBlink = new TagBlink(); int hours = TimeZoneInfo.Local.BaseUtcOffset.Hours; string timezone = hours >= 0 ? " +" + hours : " " + hours; //filters foreach (string filterKey in eventSubscription.Filters.Keys) { List <string> filterValues = eventSubscription.Filters[filterKey]; bool availaible = false; try { switch (filterKey) { case "TagID": foreach (string filterValue in filterValues) { if (tagBlink["TagID"] == filterValue) { availaible = true; } } if (!availaible) { return(false); } break; case "": break; default: throw new FaultException("Filtering on: " + filterKey + " is not supported yet in WsnEngine"); } } //TODO: catch more specific exception catch (Exception) { throw new FaultException("Filtering on: " + filterKey + " is not supported for an " + eventSubscription.EventType + " event."); } } //fields!! foreach (string field in eventSubscription.Fields) { try { switch (field) { //convert to the correct formats //add the fields to the Query (select) case "TagID": ReturnTagBlink["TagID"] = tagBlink["TagID"]; break; case "Name": ReturnTagBlink["Name"] = tagBlink["name"]; break; case "Serial": ReturnTagBlink["Serial"] = tagBlink["sensor"]; break; case "Location": ReturnTagBlink["Location/X"] = tagBlink["X"]; ReturnTagBlink["Location/Y"] = tagBlink["Y"]; break; case "Location/X": ReturnTagBlink["Location/X"] = tagBlink["X"]; break; case "Location/Y": ReturnTagBlink["Location/Y"] = tagBlink["Y"]; break; case "Buttons": //skip if this boolean is 0 ReturnTagBlink["Buttons"] = tagBlink["Button"]; break; case "Temperature": ReturnTagBlink["Temperature"] = tagBlink["temperature"]; break; case "Light": ReturnTagBlink["Light"] = tagBlink["Light"]; break; case "Humidity": ReturnTagBlink["Humidity"] = tagBlink["Humidity"]; break; case "RTLSBlinkTime": ReturnTagBlink["RTLSBlinkTime"] = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss") + timezone; break; case "All": //switch on the type of event switch (eventSubscription.EventType) { case "TemperatureChanged": ReturnTagBlink["TagID"] = tagBlink["TagID"]; ReturnTagBlink["Temperature"] = tagBlink["Temperature"]; ReturnTagBlink["RTLSBlinkTime"] = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss") + timezone; break; case "LightChanged": ReturnTagBlink["TagID"] = tagBlink["TagID"]; ReturnTagBlink["Light"] = tagBlink["Light"]; ReturnTagBlink["RTLSBlinkTime"] = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss") + timezone; break; case "HumidityChanged": ReturnTagBlink["TagID"] = tagBlink["TagID"]; ReturnTagBlink["Humidity"] = tagBlink["Humidity"]; ReturnTagBlink["RTLSBlinkTime"] = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss") + timezone; break; case "ButtonPressed": ReturnTagBlink["TagID"] = tagBlink["TagID"]; ReturnTagBlink["Button"] = tagBlink["Button"]; ReturnTagBlink["RTLSBlinkTime"] = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss") + timezone; break; case "LocationUpdated": ReturnTagBlink["TagID"] = tagBlink["TagID"]; ReturnTagBlink["Location/X"] = tagBlink["X"]; ReturnTagBlink["Location/Y"] = tagBlink["Y"]; ReturnTagBlink["Location/MapID"] = tagBlink["MapID"]; ReturnTagBlink["Location/Accuracy"] = tagBlink["Accuracy"]; ReturnTagBlink["RTLSBlinkTime"] = DateTime.UtcNow.ToString("yyyy/MM/dd HH:mm:ss") + timezone; break; } break; default: throw new FaultException("The field" + field.ToString() + " is not provided in the WSN engine"); } } //TODO: catch more specific exception catch (Exception) { throw new FaultException("The field" + field.ToString() + " is not provided in the " + eventSubscription.EventType + " event."); } } return(true); }
public void Subscribe(EventSubscription eventSubscription) { //this.Logger.Trace("Subscribe method called on Ekahau4EngineAdapterService."); this.Callback = OperationContext.Current.GetCallbackChannel<IEventSourceCallback>(); this.WsnEngine.Subscribe(eventSubscription); }
public async Task <string> CreateEventSubscription(EventSubscription subscription) { subscription.Id = Guid.NewGuid().ToString(); _subscriptions.Add(subscription); return(subscription.Id); }
public void Subscribe() { World.Subscribe(EventSubscription.Create <KeyDownEvent>(TriggerActionOnProperKey, _owner)); }
public void GetPublishActionReturnsNullIfFilterIsNull() { var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { }); var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { return true; }); var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference); var publishAction = eventSubscription.GetExecutionStrategy(); Assert.IsNotNull(publishAction); filterDelegateReference.Target = null; publishAction = eventSubscription.GetExecutionStrategy(); Assert.IsNull(publishAction); }
public AvailableTargetsView() { Event.Subscribe(EventSubscription.Create <ShootSelected>(ShowOptions, this)); Event.Subscribe(EventSubscription.Create <ActionCancelled>(e => ClearOptions(), this)); Event.Subscribe(EventSubscription.Create <ActionConfirmed>(e => ClearOptions(), this)); }
public override void ExecuteCmdlet() { if (this.ShouldProcess(this.EventSubscriptionName, $"Create a new Event Grid subscription {this.EventSubscriptionName}")) { string scope; bool isSubjectCaseSensitive = this.SubjectCaseSensitive.IsPresent; RetryPolicy retryPolicy = null; if (!string.IsNullOrEmpty(this.ResourceId)) { scope = this.ResourceId; } else if (this.InputObject != null) { scope = this.InputObject.Id; } else if (this.DomainInputObject != null) { scope = this.DomainInputObject.Id; } else if (this.DomainTopicInputObject != null) { scope = this.DomainTopicInputObject.Id; } else { // ResourceID not specified, build the scope for the event subscription for either the // subscription, or resource group, or custom topic depending on which of the parameters are provided. scope = EventGridUtils.GetScope( this.DefaultContext.Subscription.Id, this.ResourceGroupName, this.TopicName, this.DomainName, this.DomainTopicName); } if (this.IsParameterBound(c => c.MaxDeliveryAttempt) || this.IsParameterBound(c => c.EventTtl)) { retryPolicy = new RetryPolicy( maxDeliveryAttempts: this.MaxDeliveryAttempt == 0 ? (int?)null : this.MaxDeliveryAttempt, eventTimeToLiveInMinutes: this.EventTtl == 0 ? (int?)null : this.EventTtl); } if (!string.Equals(this.EndpointType, EventGridConstants.Webhook, StringComparison.OrdinalIgnoreCase)) { if (this.IsParameterBound(c => c.MaxEventsPerBatch) || this.IsParameterBound(c => c.PreferredBatchSizeInKiloByte)) { throw new ArgumentException("MaxEventsPerBatch and PreferredBatchSizeInKiloByte are supported when EndpointType is webhook only."); } if (this.IsParameterBound(c => c.AzureActiveDirectoryApplicationIdOrUri) || this.IsParameterBound(c => c.AzureActiveDirectoryTenantId)) { throw new ArgumentException("AzureActiveDirectoryApplicationIdOrUri and AzureActiveDirectoryTenantId are supported when EndpointType is webhook only."); } } if (EventGridUtils.ShouldShowEventSubscriptionWarningMessage(this.Endpoint, this.EndpointType)) { WriteWarning(EventGridConstants.EventSubscriptionHandshakeValidationMessage); } if (this.IncludedEventType != null && this.IncludedEventType.Length == 1 && string.Equals(this.IncludedEventType[0], "All", StringComparison.OrdinalIgnoreCase)) { // Show Warning message for user this.IncludedEventType = null; WriteWarning(EventGridConstants.IncludedEventTypeDeprecationMessage); } EventSubscription eventSubscription = this.Client.CreateEventSubscription( scope, this.EventSubscriptionName, this.Endpoint, this.EndpointType, this.SubjectBeginsWith, this.SubjectEndsWith, isSubjectCaseSensitive, this.IncludedEventType, this.Label, retryPolicy, this.DeliverySchema, this.DeadLetterEndpoint, this.ExpirationDate, this.AdvancedFilter, this.MaxEventsPerBatch, this.PreferredBatchSizeInKiloByte, this.AzureActiveDirectoryTenantId, this.AzureActiveDirectoryApplicationIdOrUri); PSEventSubscription psEventSubscription = new PSEventSubscription(eventSubscription); this.WriteObject(psEventSubscription, true); } }
public CallQueue() { World.Subscribe(EventSubscription.Create <AgentCallStatusChanged>(PlayerAvailable, this)); World.Subscribe(EventSubscription.Create <JobChanged>(JobChanged, this)); _generator = new CallGenerator(Job.ReturnSpecialistLevel1); }
public PSEventSubscriptionListInstance(EventSubscription eventSubscription, string fullEndpointUrl) : base(eventSubscription, fullEndpointUrl) { }
public static void Subscribe <T>(EventSubscription <T> subscription) { _events.Subscribe(subscription); Resources.Put(Guid.NewGuid().ToString(), subscription); }
public static void AddStorageHandler(this EventSubscription subscription, ILogHandler logHandler, long id = 0) { subscription.AddHandler(new StorageHandler(subscription, id, logHandler)); }
public static void SubscribeForever(EventSubscription subscription) { _persistentEvents.Subscribe(subscription); }
public static void AddQueueHandler( this EventSubscription subscription, IQueue queue, Func <DecodedEvent, object> mappingFunc, long id = 0) { AddQueueHandler(subscription, queue, new QueueMessageMapper(mappingFunc), id); }
public static void Subscribe(EventSubscription subscription) { _events.Subscribe(subscription); _eventSubs.Add(subscription); Resources.Put(subscription.GetHashCode().ToString(), subscription); }
public async Task <EventSubscription> Subscription_CreateOrUpdateAsync(string scope, string eventSubscriptionName, EventSubscription subscription, CancellationToken cancellationToken = default) { return(await client.EventSubscriptions.CreateOrUpdateAsync(scope, eventSubscriptionName, subscription, cancellationToken).ConfigureAwait(false)); }
public void GetPublishActionReturnsNullIfActionIsNull() { var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { }); var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { return true; }); var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference, null, EventCommunicatorsRelationship.All); var publishAction = eventSubscription.GetExecutionStrategy(); Assert.NotNull(publishAction); actionDelegateReference.Target = null; publishAction = eventSubscription.GetExecutionStrategy(); Assert.Null(publishAction); }
public EventExpectation() { _subscription = new EventSubscription <T>(_ => _eventWasFired = true); }
public void Subscribe(EventSubscription eventSubscription) { if (!this.EventListeners.ContainsKey(eventSubscription.EventId)) { //TODO: filters checken -> Ekahau var eventListener = EventListener.Create(eventSubscription); eventListener.EventReceived += this.EventListenerEventReceived; this.EventListeners.Add(eventSubscription.EventId, eventListener); //pass a reference to the event of the controller eventListener.Advise(ControllerRef); } }
public override void ExecuteCmdlet() { if (string.IsNullOrEmpty(this.EventSubscriptionName)) { // This can happen with the InputObject parameter set where the // event subscription name needs to be determined based on the piped in // EventSubscriptionObject if (this.InputObject == null) { throw new Exception("Unexpected condition: Event Subscription name cannot be determined."); } this.EventSubscriptionName = this.InputObject.EventSubscriptionName; } if (this.ShouldProcess(this.EventSubscriptionName, $"Update existing Event Grid subscription {this.EventSubscriptionName}")) { string scope; RetryPolicy retryPolicy = null; int? maxEventsPerBatch = null; int? preferredBatchSizeInKiloByte = null; string aadAppIdOrUri = string.Empty; string aadTenantId = string.Empty; if (!string.IsNullOrEmpty(this.ResourceId)) { scope = this.ResourceId; } else if (this.InputObject != null) { scope = this.InputObject.Topic; } else { // ResourceID not specified, build the scope for the event subscription for either the // subscription, or resource group, or custom topic depending on which of the parameters are provided. scope = EventGridUtils.GetScope( this.DefaultContext.Subscription.Id, this.ResourceGroupName, this.TopicName, this.DomainName, this.DomainTopicName); } EventSubscription existingEventSubscription = this.Client.GetEventSubscription(scope, this.EventSubscriptionName); if (existingEventSubscription == null) { throw new Exception($"Cannot find an existing event subscription with name {this.EventSubscriptionName}."); } if (this.IsParameterBound(c => c.MaxDeliveryAttempt) || this.IsParameterBound(c => c.EventTtl)) { retryPolicy = new RetryPolicy(existingEventSubscription.RetryPolicy?.MaxDeliveryAttempts, existingEventSubscription.RetryPolicy?.EventTimeToLiveInMinutes); // Only override the new values if any. if (this.IsParameterBound(c => c.MaxDeliveryAttempt)) { retryPolicy.MaxDeliveryAttempts = this.MaxDeliveryAttempt; } if (this.IsParameterBound(c => c.EventTtl)) { retryPolicy.EventTimeToLiveInMinutes = this.EventTtl; } } else { retryPolicy = existingEventSubscription.RetryPolicy; } if (string.Equals(this.EndpointType, EventGridConstants.Webhook, StringComparison.OrdinalIgnoreCase)) { WebHookEventSubscriptionDestination dest = existingEventSubscription.Destination as WebHookEventSubscriptionDestination; if (dest != null) { maxEventsPerBatch = this.IsParameterBound(c => c.MaxEventsPerBatch) ? (int?)this.MaxEventsPerBatch : dest.MaxEventsPerBatch.HasValue ? dest.MaxEventsPerBatch : null; preferredBatchSizeInKiloByte = this.IsParameterBound(c => c.PreferredBatchSizeInKiloByte) ? (int?)this.PreferredBatchSizeInKiloByte : dest.PreferredBatchSizeInKilobytes.HasValue ? dest.PreferredBatchSizeInKilobytes : null; aadAppIdOrUri = this.IsParameterBound(c => c.AzureActiveDirectoryApplicationIdOrUri) ? this.AzureActiveDirectoryApplicationIdOrUri : dest.AzureActiveDirectoryApplicationIdOrUri; aadTenantId = this.IsParameterBound(c => c.AzureActiveDirectoryTenantId) ? this.AzureActiveDirectoryTenantId : dest.AzureActiveDirectoryTenantId; } else { maxEventsPerBatch = this.IsParameterBound(c => c.MaxEventsPerBatch) ? (int?)this.MaxEventsPerBatch : null; preferredBatchSizeInKiloByte = this.IsParameterBound(c => c.PreferredBatchSizeInKiloByte) ? (int?)this.PreferredBatchSizeInKiloByte : null; aadAppIdOrUri = this.IsParameterBound(c => c.AzureActiveDirectoryApplicationIdOrUri) ? this.AzureActiveDirectoryApplicationIdOrUri : string.Empty; aadTenantId = this.IsParameterBound(c => c.AzureActiveDirectoryTenantId) ? this.AzureActiveDirectoryTenantId : string.Empty; } } else { if (this.IsParameterBound(c => c.MaxEventsPerBatch) || this.IsParameterBound(c => c.PreferredBatchSizeInKiloByte)) { throw new ArgumentException("MaxEventsPerBatch and PreferredBatchSizeInKiloByte are supported when EndpointType is webhook only."); } if (this.IsParameterBound(c => c.AzureActiveDirectoryApplicationIdOrUri) || this.IsParameterBound(c => c.AzureActiveDirectoryTenantId)) { throw new ArgumentException("AzureActiveDirectoryApplicationIdOrUri and AzureActiveDirectoryTenantId are supported when EndpointType is webhook only."); } } if (EventGridUtils.ShouldShowEventSubscriptionWarningMessage(this.Endpoint, this.EndpointType)) { WriteWarning(EventGridConstants.EventSubscriptionHandshakeValidationMessage); } if (this.IncludedEventType != null && this.IncludedEventType.Length == 1 && string.Equals(this.IncludedEventType[0], "All", StringComparison.OrdinalIgnoreCase)) { // Show Warning message for user this.IncludedEventType = null; WriteWarning(EventGridConstants.IncludedEventTypeDeprecationMessage); } EventSubscription eventSubscription = this.Client.UpdateEventSubscription( scope: scope, eventSubscriptionName: this.EventSubscriptionName, endpoint: this.Endpoint, endpointType: this.EndpointType, subjectBeginsWith: this.SubjectBeginsWith ?? existingEventSubscription.Filter.SubjectBeginsWith, subjectEndsWith: this.SubjectEndsWith ?? existingEventSubscription.Filter.SubjectEndsWith, isSubjectCaseSensitive: existingEventSubscription.Filter.IsSubjectCaseSensitive, includedEventTypes: this.IncludedEventType, labels: this.Label, retryPolicy: retryPolicy, deadLetterEndpoint: this.DeadLetterEndpoint, expirationDate: this.ExpirationDate, advancedFilter: this.AdvancedFilter, maxEventsPerBatch: maxEventsPerBatch, preferredBatchSizeInKiloByte: preferredBatchSizeInKiloByte, aadAppIdOrUri: aadAppIdOrUri, aadTenantId: aadTenantId); PSEventSubscription psEventSubscription = new PSEventSubscription(eventSubscription); this.WriteObject(psEventSubscription); } }
public void NullActionThrows() { var filterDelegateReference = new MockDelegateReference() { Target = (Predicate<object>)(arg => { return true; }) }; Assert.Throws<ArgumentNullException>( () => { var eventSubscription = new EventSubscription<object>(null, filterDelegateReference, null, EventCommunicatorsRelationship.All); }); }
public GovernmentTaxes(IAccount playerAccount) { _playerAccount = playerAccount; World.Subscribe(EventSubscription.Create <HourChanged>(HourChanged, this)); World.Subscribe(EventSubscription.Create <SalaryPaymentOccured>(ApplyIncomeTaxes, this)); }
public void NullTargetInFilterThrows() { var actionDelegateReference = new MockDelegateReference() { Target = (Action<object>)delegate { } }; var filterDelegateReference = new MockDelegateReference() { Target = null }; Assert.Throws<ArgumentException>( () => { var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference, null, EventCommunicatorsRelationship.All); }); }
public FoodDelivery() { World.Subscribe(EventSubscription.Create <FoodOrdered>(Ordered, this)); }
public async Task <string> CreateEventSubscription(EventSubscription subscription) { await EventSubscriptions.InsertOneAsync(subscription); return(subscription.Id); }
public void GetPublishActionReturnsDelegateThatExecutesTheFilterAndThenTheAction() { var executedDelegates = new List<string>(); var actionDelegateReference = new MockDelegateReference((Action<object>)delegate { executedDelegates.Add("Action"); }); var filterDelegateReference = new MockDelegateReference((Predicate<object>)delegate { executedDelegates.Add( "Filter"); return true; }); var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference); var publishAction = eventSubscription.GetExecutionStrategy(); Assert.IsNotNull(publishAction); publishAction.Invoke(null); Assert.AreEqual(2, executedDelegates.Count); Assert.AreEqual("Filter", executedDelegates[0]); Assert.AreEqual("Action", executedDelegates[1]); }
public async Task <ExecutionResult <EventMessage> > AssignMessageToSubscriber(EventSubscription subscription, EventMessage message) { message.IsProcessing = true; message.ProcessingStartDateTime = DateTime.Now; message.Subscription = message.Subscription.Any() ? new List <EventSubscription>(message.Subscription) { subscription } : new List <EventSubscription>() { subscription }; return(await EventRepository.UpdateAsync(message)); }
public void GetPublishActionDoesNotExecuteActionIfFilterReturnsFalse() { bool actionExecuted = false; var actionDelegateReference = new MockDelegateReference() { Target = (Action<int>)delegate { actionExecuted = true; } }; var filterDelegateReference = new MockDelegateReference((Predicate<int>)delegate { return false; }); var eventSubscription = new EventSubscription<int>(actionDelegateReference, filterDelegateReference); var publishAction = eventSubscription.GetExecutionStrategy(); publishAction.Invoke(new object[] { null }); Assert.IsFalse(actionExecuted); }
/// <summary> /// Create or update an event subscription to a topic. /// </summary> /// <remarks> /// Asynchronously creates a new event subscription or updates an existing /// event subscription. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group within the user's subscription. /// </param> /// <param name='topicName'> /// Name of the domain topic. /// </param> /// <param name='eventSubscriptionName'> /// Name of the event subscription to be created. Event subscription names must /// be between 3 and 100 characters in length and use alphanumeric letters /// only. /// </param> /// <param name='eventSubscriptionInfo'> /// Event subscription properties containing the destination and filter /// information. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <EventSubscription> BeginCreateOrUpdateAsync(this ITopicEventSubscriptionsOperations operations, string resourceGroupName, string topicName, string eventSubscriptionName, EventSubscription eventSubscriptionInfo, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, topicName, eventSubscriptionName, eventSubscriptionInfo, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
/// <summary> /// Create or update an event subscription to a topic. /// </summary> /// <remarks> /// Asynchronously creates a new event subscription or updates an existing /// event subscription. /// </remarks> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group within the user's subscription. /// </param> /// <param name='topicName'> /// Name of the domain topic. /// </param> /// <param name='eventSubscriptionName'> /// Name of the event subscription to be created. Event subscription names must /// be between 3 and 100 characters in length and use alphanumeric letters /// only. /// </param> /// <param name='eventSubscriptionInfo'> /// Event subscription properties containing the destination and filter /// information. /// </param> public static EventSubscription BeginCreateOrUpdate(this ITopicEventSubscriptionsOperations operations, string resourceGroupName, string topicName, string eventSubscriptionName, EventSubscription eventSubscriptionInfo) { return(operations.BeginCreateOrUpdateAsync(resourceGroupName, topicName, eventSubscriptionName, eventSubscriptionInfo).GetAwaiter().GetResult()); }
public void StrategyShouldPassArgumentToDelegates() { string passedArgumentToAction = null; string passedArgumentToFilter = null; var actionDelegate = new Mock<IDelegateReference>(); actionDelegate.SetupGet(d => d.Target).Returns((Action<string>)(obj => passedArgumentToAction = obj)); var filterDelegate = new Mock<IDelegateReference>(); filterDelegate.SetupGet(d => d.Target).Returns((Predicate<string>)(obj => { passedArgumentToFilter = obj; return true; })); var eventSubscription = new EventSubscription<string>(actionDelegate.Object, filterDelegate.Object); var publishAction = eventSubscription.GetExecutionStrategy(); publishAction.Invoke(new[] { "TestString" }); Assert.That(passedArgumentToAction, Is.EqualTo("TestString")); Assert.That(passedArgumentToFilter, Is.EqualTo("TestString")); }
public override Task ProcessRequestAsync(IRequest req, IResponse res, string operationName) { if (HostContext.ApplyCustomHandlerRequestFilters(req, res)) { return(TypeConstants.EmptyTask); } var feature = HostContext.GetPlugin <ServerEventsFeature>(); var session = req.GetSession(); if (feature.LimitToAuthenticatedUsers && !session.IsAuthenticated) { session.ReturnFailedAuthentication(req); return(TypeConstants.EmptyTask); } res.ContentType = MimeTypes.ServerSentEvents; res.AddHeader(HttpHeaders.CacheControl, "no-cache"); res.ApplyGlobalResponseHeaders(); res.UseBufferedStream = false; res.KeepAlive = true; if (feature.OnInit != null) { feature.OnInit(req); } res.Flush(); var serverEvents = req.TryResolve <IServerEvents>(); var userAuthId = session != null ? session.UserAuthId : null; var anonUserId = serverEvents.GetNextSequence("anonUser"); var userId = userAuthId ?? ("-" + anonUserId); var displayName = session.GetSafeDisplayName() ?? "user" + anonUserId; var now = DateTime.UtcNow; var subscriptionId = SessionExtensions.CreateRandomSessionId(); //Handle both ?channel=A,B,C or ?channels=A,B,C var channels = new List <string>(); var channel = req.QueryString["channel"]; if (!string.IsNullOrEmpty(channel)) { channels.AddRange(channel.Split(',')); } channel = req.QueryString["channels"]; if (!string.IsNullOrEmpty(channel)) { channels.AddRange(channel.Split(',')); } if (channels.Count == 0) { channels = EventSubscription.UnknownChannel.ToList(); } var subscription = new EventSubscription(res) { CreatedAt = now, LastPulseAt = now, Channels = channels.ToArray(), SubscriptionId = subscriptionId, UserId = userId, UserName = session != null ? session.UserName : null, DisplayName = displayName, SessionId = req.GetSessionId(), IsAuthenticated = session != null && session.IsAuthenticated, UserAddress = req.UserHostAddress, OnPublish = feature.OnPublish, //OnError = feature.OnError, Meta = { { "userId", userId }, { "displayName", displayName }, { "channels", string.Join(",", channels) }, { AuthMetadataProvider.ProfileUrlKey, session.GetProfileUrl() ?? AuthMetadataProvider.DefaultNoProfileImgUrl }, } }; if (feature.OnCreated != null) { feature.OnCreated(subscription, req); } if (req.Response.IsClosed) { return(TypeConstants.EmptyTask); //Allow short-circuiting in OnCreated callback } var heartbeatUrl = feature.HeartbeatPath != null ? req.ResolveAbsoluteUrl("~/".CombineWith(feature.HeartbeatPath)).AddQueryParam("id", subscriptionId) : null; var unRegisterUrl = feature.UnRegisterPath != null ? req.ResolveAbsoluteUrl("~/".CombineWith(feature.UnRegisterPath)).AddQueryParam("id", subscriptionId) : null; heartbeatUrl = AddSessionParamsIfAny(heartbeatUrl, req); unRegisterUrl = AddSessionParamsIfAny(unRegisterUrl, req); subscription.ConnectArgs = new Dictionary <string, string>(subscription.Meta) { { "id", subscriptionId }, { "unRegisterUrl", unRegisterUrl }, { "heartbeatUrl", heartbeatUrl }, { "updateSubscriberUrl", req.ResolveAbsoluteUrl("~/event-subscribers/" + subscriptionId) }, { "heartbeatIntervalMs", ((long)feature.HeartbeatInterval.TotalMilliseconds).ToString(CultureInfo.InvariantCulture) }, { "idleTimeoutMs", ((long)feature.IdleTimeout.TotalMilliseconds).ToString(CultureInfo.InvariantCulture) } }; if (feature.OnConnect != null) { feature.OnConnect(subscription, subscription.ConnectArgs); } serverEvents.Register(subscription, subscription.ConnectArgs); var tcs = new TaskCompletionSource <bool>(); subscription.OnDispose = _ => { try { res.EndHttpHandlerRequest(skipHeaders: true); } catch { } tcs.SetResult(true); }; return(tcs.Task); }
public void NullTargetInFilterThrows() { Assert.ThrowsException<ArgumentException>(() => { var actionDelegateReference = new MockDelegateReference() { Target = (Action<object>)delegate { } }; var filterDelegateReference = new MockDelegateReference() { Target = null }; var eventSubscription = new EventSubscription<object>(actionDelegateReference, filterDelegateReference); }); }