public Subscription(SubscriptionMode mode, int delegateHash = 0) { Mode = mode; StreamSelectors = null; DelegateHash = delegateHash; }
protected Subscription( SubscriptionId subscriptionId, TopicId topicId, Type messageType, string queueName, SubscriptionMode subscriptionMode, bool acceptMessagesOlderThanSubscriptionTime, Action <object> messageHandler, Action <object, object> messageHandlerWithProperties, Action <object, Dictionary <string, string> > messageHandlerWithHeaders, Action <object, object, Dictionary <string, string> > messageHandlerWithPropertiesAndHeaders) { if ((messageHandler != null) && (messageHandlerWithProperties != null)) { throw new ArgumentException("MessageHandler and MessageHandlerWithProperties cannot be both assigned!"); } SubscriptionId = subscriptionId; TopicId = topicId; MessageType = messageType; SubscriptionMode = subscriptionMode; AcceptMessagesOlderThanSubscriptionTime = acceptMessagesOlderThanSubscriptionTime; MessageHandler = messageHandler; MessageHandlerWithHeaders = messageHandlerWithHeaders; MessageHandlerWithProperties = messageHandlerWithProperties; MessageHandlerWithPropertiesAndHeaders = messageHandlerWithPropertiesAndHeaders; QueueName = queueName; }
protected SubscriptionRequestBase(SubscriptionMode subscriptionMode, string callbackUri, string topic, string verify, string secret, string verifyToken) : this(subscriptionMode, callbackUri, topic, verify) { _secret = secret; _verifyToken = verifyToken; }
/// <summary> /// Constructor of the subscription processor /// </summary> /// <param name="conn">Connection instance</param> /// <param name="initMessage">Initialization message</param> public ModelSubscription(Connection conn, ClientInitMessage initMessage) : base(conn) { SubscribeInitMessage subscribeInitMessage = (SubscribeInitMessage)initMessage; _mode = subscribeInitMessage.SubscriptionMode; if (subscribeInitMessage.Filters != null) { _filters = Filter.ConvertFilters(subscribeInitMessage.Filters); } #pragma warning disable CS0612 // Type or member is obsolete else if (!string.IsNullOrEmpty(subscribeInitMessage.Filter)) { _filters = Filter.ConvertFilters(subscribeInitMessage.Filter); } #pragma warning restore CS0612 // Type or member is obsolete else { _filters = Array.Empty <object[]>(); } lock (_subscriptions) { _subscriptions.Add(this); } conn.Logger.Debug("Subscription processor registered in {0} mode", _mode); }
internal static bool MessageShouldBeSubscribedOnStartup(Type messageType, SubscriptionMode? subscriptionMode = null) { if (subscriptionMode != null) return subscriptionMode == SubscriptionMode.Auto; return !Attribute.IsDefined(messageType, typeof(Routable)); }
protected override InSingleProcessMemorySubscription NewSubscribeSubscription(Type messageType, SubscriptionId subscriptionId, TopicId topicId, SubscriptionMode subscriptionMode, bool acceptMessagesOlderThanSubscriptionTime, Action<object> messageHandler, string queueName) { return new InSingleProcessMemoryAuthorizedSubscription( this, AuthorizedMessageOperation.Subscribe, subscriptionId, topicId, messageType, queueName, subscriptionMode, acceptMessagesOlderThanSubscriptionTime, messageHandler, null, null, null ); }
public EventSubscriptionItem(Type eventType, object eventHandler, Action<object, object> method, SubscriptionMode subscriptionMode, String topic) { this.EventHandler = eventHandler; this.Method = method; this.SubscriptionMode = subscriptionMode; this.EventType = eventType; this.Topic = topic; }
public Subscription(SubscriptionMode mode, List <TEvent> eventSelectors, int delegateHash = 0) { Mode = mode; EventSelectors = eventSelectors; DelegateHash = delegateHash; }
public Subscription(SubscriptionMode mode, TEvent eventSelector, int delegateHash = 0) { Mode = mode; EventSelectors = new List <TEvent>((IEnumerable <TEvent>?)eventSelector); DelegateHash = delegateHash; }
public Subscription(SubscriptionMode mode, List <TStream> streamSelectors, int delegateHash = 0) { Mode = mode; StreamSelectors = streamSelectors; DelegateHash = delegateHash; }
public Subscription(SubscriptionMode mode, TStream streamSelector, int delegateHash = 0) { Mode = mode; StreamSelectors = new List <TStream>((IEnumerable <TStream>?)streamSelector); DelegateHash = delegateHash; }
/// <summary> /// Establishes a connection to the given UNIX socket file /// </summary> /// <param name="mode">Subscription mode</param> /// <param name="socketPath">Path to the UNIX socket file</param> /// <param name="cancellationToken">Optional cancellation token</param> /// <returns>Asynchronous task</returns> /// <exception cref="IncompatibleVersionException">API level is incompatible</exception> /// <exception cref="IOException">Connection mode is unavailable</exception> public Task Connect(SubscriptionMode mode, string socketPath = Defaults.SocketPath, CancellationToken cancellationToken = default(CancellationToken)) { SubscribeInitMessage initMessage = new SubscribeInitMessage { SubscriptionMode = mode }; Mode = mode; return(Connect(initMessage, socketPath, cancellationToken)); }
public Task Connect(SubscriptionMode mode, string filter = null, string socketPath = Defaults.FullSocketPath, CancellationToken cancellationToken = default) { Mode = mode; Filter = filter; Filters.Clear(); SubscribeInitMessage initMessage = new() { SubscriptionMode = mode, Filter = Filter }; return(Connect(initMessage, socketPath, cancellationToken)); }
protected SubscriptionRequestBase(SubscriptionMode subscriptionMode, string callbackUri, string topic, string verify) { _callbackUri = callbackUri; _subscriptionMode = subscriptionMode; _topic = topic; _verify = verify; _secret = null; _verifyToken = null; }
/// <summary> /// Constructor of the subscription processor /// </summary> /// <param name="conn">Connection instance</param> /// <param name="initMessage">Initialization message</param> public Subscription(Connection conn, ClientInitMessage initMessage) : base(conn, initMessage) { lock (_subscriptions) { _subscriptions.Add(this); } _mode = (initMessage as SubscribeInitMessage).SubscriptionMode; using (Model.Provider.AccessReadOnly()) { _model = (MachineModel)Model.Provider.Get.Clone(); } }
public RabbitMQSubscription( IRabbitMQMessageBus messageBus, SubscriptionId subscriptionId, TopicId topicId, Type messageType, string queueName, SubscriptionMode subscriptionMode, bool acceptMessagesOlderThanSubscriptionTime, Action<object> messageHandler, Action<object, object> messageHandlerWithProperties, Action<object, Dictionary<string, string>> messageHandlerWithHeaders, Action<object, object, Dictionary<string, string>> messageHandlerWithPropertiesAndHeaders) : base(subscriptionId, topicId, messageType, queueName, subscriptionMode, acceptMessagesOlderThanSubscriptionTime, messageHandler, messageHandlerWithProperties, messageHandlerWithHeaders, messageHandlerWithPropertiesAndHeaders) { if (topicId == null) throw new ArgumentNullException("topicId"); MessageBus = messageBus; }
/// <summary> /// Establishes a connection to the given UNIX socket file /// </summary> /// <param name="mode">Subscription mode</param> /// <param name="filters">Optional filter strings</param> /// <param name="socketPath">Path to the UNIX socket file</param> /// <param name="cancellationToken">Optional cancellation token</param> /// <returns>Asynchronous task</returns> /// <exception cref="IncompatibleVersionException">API level is incompatible</exception> /// <exception cref="IOException">Connection mode is unavailable</exception> /// <exception cref="OperationCanceledException">Operation has been cancelled</exception> /// <exception cref="SocketException">Init message could not be processed</exception> public Task Connect(SubscriptionMode mode, IEnumerable <string> filters = null, string socketPath = Defaults.FullSocketPath, CancellationToken cancellationToken = default) { Mode = mode; Filters.Clear(); if (filters != null) { Filters.AddRange(filters); } SubscribeInitMessage initMessage = new() { SubscriptionMode = mode, Filters = Filters }; return(Connect(initMessage, socketPath, cancellationToken)); }
public void Subscribe(TSubject Receiver, StreamEvent Handler, SubscriptionMode Mode) { int Hash = Receiver.GetHashCode(); if (!ObjectRegistry.ContainsKey(Hash)) { ObjectRegistry.Add(Hash, new Subscriber <TSubject, TStream, TEvent> (Receiver, Mode)); } Publish += Handler; }
/// <summary> /// Constructor of the subscription processor /// </summary> /// <param name="conn">Connection instance</param> /// <param name="initMessage">Initialization message</param> public Subscription(Connection conn, ClientInitMessage initMessage) : base(conn) { SubscribeInitMessage subscribeInitMessage = (SubscribeInitMessage)initMessage; _mode = subscribeInitMessage.SubscriptionMode; if (!string.IsNullOrEmpty(subscribeInitMessage.Filter)) { string[] filterStrings = subscribeInitMessage.Filter.Split(',', '|', '\r', '\n', ' '); _filters = filterStrings.Select(filter => filter.Split('/')).ToArray(); } lock (_subscriptions) { _subscriptions.Add(this); } }
/// <summary> /// Constructor of the subscription processor /// </summary> /// <param name="conn">Connection instance</param> /// <param name="initMessage">Initialization message</param> public Subscription(Connection conn, ClientInitMessage initMessage) : base(conn) { SubscribeInitMessage subscribeInitMessage = (SubscribeInitMessage)initMessage; _mode = subscribeInitMessage.SubscriptionMode; if (!string.IsNullOrEmpty(subscribeInitMessage.Filter)) { _filters = Filter.ConvertFilters(subscribeInitMessage.Filter); } lock (_subscriptions) { _subscriptions.Add(this); } conn.Logger.Debug("Subscription processor registered in {0} mode", _mode); }
public static SubscriptionUpdateMode ToSubscriptionUpdateMode(this SubscriptionMode mode) { switch (mode) { case SubscriptionMode.Callback: return(SubscriptionUpdateMode.callback); case SubscriptionMode.None: return(SubscriptionUpdateMode.none); case SubscriptionMode.Poll: return(SubscriptionUpdateMode.poll); default: return(SubscriptionUpdateMode.callback); } }
public IAsyncResult BeginLogin( Uri server, string accessToken, SubscriptionMode subscriptionMode, IReadOnlyHashSet <AccountId> presenceSubscriptions, IReadOnlyHashSet <AccountId> blockedPresenceSubscriptions, IReadOnlyHashSet <AccountId> allowedPresenceSubscriptions, AsyncCallback callback) { if (string.IsNullOrEmpty(accessToken)) { throw new ArgumentNullException(nameof(accessToken)); } AssertLoggedOut(); AsyncNoResult result = new AsyncNoResult(callback); State = LoginState.LoggingIn; _client.BeginGetConnectorHandle(server, ar2 => { string connectorHandle; try { connectorHandle = _client.EndGetConnectorHandle(ar2); } catch (Exception e) { VivoxDebug.Instance.VxExceptionMessage($"BeginGetConnectorHandle failed: {e}"); State = LoginState.LoggedOut; result.SetComplete(e); if (VivoxDebug.Instance.throwInternalExcepetions) { throw; } return; } Debug.Write($"connectorHandle={connectorHandle}"); Login(accessToken, connectorHandle, result, subscriptionMode); }); return(result); }
public void Subscribe(TSubject Receiver, StreamEvent Handler, SubscriptionMode Mode, List <TStream> StreamSelectors) { int Hash = Receiver.GetHashCode(); if (!Mode.HasFlag(SubscriptionMode.Selected)) { Mode &= SubscriptionMode.Selected; } if (!ObjectRegistry.ContainsKey(Hash)) { ObjectRegistry.Add(Hash, new Subscriber <TSubject, TStream, TEvent> (Receiver, Mode, StreamSelectors)); } Publish += Handler; }
protected Subscription( SubscriptionId subscriptionId, TopicId topicId, Type messageType, string queueName, SubscriptionMode subscriptionMode, bool acceptMessagesOlderThanSubscriptionTime, Action<object> messageHandler, Action<object, object> messageHandlerWithProperties, Action<object, Dictionary<string, string>> messageHandlerWithHeaders, Action<object, object, Dictionary<string, string>> messageHandlerWithPropertiesAndHeaders) { if ((messageHandler != null) && (messageHandlerWithProperties != null)) throw new ArgumentException("MessageHandler and MessageHandlerWithProperties cannot be both assigned!"); SubscriptionId = subscriptionId; TopicId = topicId; MessageType = messageType; SubscriptionMode = subscriptionMode; AcceptMessagesOlderThanSubscriptionTime = acceptMessagesOlderThanSubscriptionTime; MessageHandler = messageHandler; MessageHandlerWithHeaders = messageHandlerWithHeaders; MessageHandlerWithProperties = messageHandlerWithProperties; MessageHandlerWithPropertiesAndHeaders = messageHandlerWithPropertiesAndHeaders; QueueName = queueName; }
public ConsumerConfigBuilder <T> SubscriptionMode(SubscriptionMode subscriptionMode) { _conf.SubscriptionMode = subscriptionMode; return(this); }
public Subscription(int delegateHash = 0) { Mode = SubscriptionMode.Self; StreamSelectors = null; DelegateHash = delegateHash; }
public void Should_CalculateSchedule_ThrowException_WhenTheSubscriptionTypeIsIncorrect(SubscriptionMode mode) { // Arrange var sut = new NeverNotificationScheduleStrategy(); // Act Action action = () => sut.CalculateSchedule(_fixture.GetSubscription(mode), DateTime.Today, 1); // Assert action.Should().Throw <ArgumentException>(); }
public void TestMessageTransferRate(string publishConfirmationMode, string messageTypeIdentificationMode, StorageType storageType, SubscriptionMode subscriptionMode) { DeleteQueues(); var requirePublishConfirmation = publishConfirmationMode == "WithPublishConfirms"; const int cicles = 60; const int runtime = cicles * 1000; var receivedMessageCount = 0; var publishedMessageCount = 0; using (var subscriptionBus = DependencyResolver.Get<ISubscriptionBus>()) { switch (messageTypeIdentificationMode) { case "Generics": subscriptionBus.SubscribeTo<EventOccurred>( SubscriptionId.FromString("TestMessageTransferRate"), m => { receivedMessageCount++; }, subscriptionMode ); break; case "NonGenerics": subscriptionBus.SubscribeTo( typeof(EventOccurred), SubscriptionId.FromString("TestMessageTransferRate"), m => { receivedMessageCount++; }, subscriptionMode ); break; } using (var publishBus = DependencyResolver.Get<IPublishingBus>()) { var stopwatch = new Stopwatch(); stopwatch.Start(); while (stopwatch.ElapsedMilliseconds < runtime) { var message = new EventOccurred(); switch (messageTypeIdentificationMode) { case "Generics": publishBus.Publish(message, storageType, requirePublishConfirmation); break; case "NonGenerics": publishBus.Publish(typeof(EventOccurred), message, storageType, requirePublishConfirmation); break; } publishedMessageCount++; } stopwatch.Stop(); } Thread.Sleep(1000); } Console.WriteLine(); Console.WriteLine("Published: {0}/s, Received: {1}/s, Runtime: {2}", publishedMessageCount / cicles, receivedMessageCount / cicles, runtime); Console.WriteLine(); DeleteQueues(); if (requirePublishConfirmation) { receivedMessageCount.Should().Be(publishedMessageCount); } }
public SubscriptionModeAttribute(SubscriptionMode subscriptionMode) { SubscriptionMode = subscriptionMode; }
public void Should_Read_ThrowInvalidRowException_WhenThereAreMonthlyOrWeeklyRowsWithoutExtraInfoColumn(string invalidRow, SubscriptionMode mode) { // Arrange var content = new[] { "Alice|Never", invalidRow }; var reader = new Mock <IFileReader>(); reader.Setup(x => x.Exists(It.IsAny <string>())).Returns(true); reader.Setup(x => x.ReadAllLines(It.IsAny <string>())).Returns(content); var sut = new ScheduleInputReader(reader.Object, new InputSettings()); // Act Action action = () => sut.Read("schedule.csv"); // Assert action.Should().Throw <InvalidRowException>() .WithMessage($"Invalid row format for {mode.ToString()}. missing extra info") .Where(m => m.Line == invalidRow); }
/// <summary> /// Constructor of the subscription processor /// </summary> /// <param name="conn">Connection instance</param> /// <param name="initMessage">Initialization message</param> public Subscription(Connection conn, ClientInitMessage initMessage) : base(conn, initMessage) { _mode = (initMessage as SubscribeInitMessage).SubscriptionMode; }
public SubscriptionRequestBase Get(SubscriptionMode subscriptionMode, string topic, string verifyToken) { var subscriptionRequestBase = _innerList.Find( x => x.SubscriptionMode == subscriptionMode && x.Topic == topic && x.VerifyToken == verifyToken); return subscriptionRequestBase; }
public InSingleProcessMemoryAuthorizedSubscription(IInSingleProcessMemoryMessageBus messageBus, AuthorizedMessageOperation operation, SubscriptionId subscriptionId, TopicId topicId, Type messageType, string queueName, SubscriptionMode subscriptionMode, bool acceptMessagesOlderThanSubscriptionTime, Action<object> messageHandler, Action<object, object> messageHandlerWithProperties, Action<object, Dictionary<string, string>> messageHandlerWithHeaders, Action<object, object, Dictionary<string, string>> messageHandlerWithPropertiesAndHeaders) : base(messageBus, subscriptionId, topicId, messageType, queueName, subscriptionMode, acceptMessagesOlderThanSubscriptionTime, messageHandler, messageHandlerWithProperties, messageHandlerWithHeaders, messageHandlerWithPropertiesAndHeaders) { Operation = operation; }
public ScheduleStrategyNotFoundException(SubscriptionMode subscriptionMode) : base( $"Strategy for handling {subscriptionMode} is not configured correctly") { }
protected override RabbitMQSubscription NewReceivingSubscription(Type messageType, SubscriptionId subscriptionId, SubscriptionMode subscriptionMode, bool acceptMessagesOlderThanSubscriptionTime, Action<object> messageHandler, string queueName) { return new RabbitMQAuthorizedSubscription( this, AuthorizedMessageOperation.Receive, subscriptionId, TopicId.None, messageType, queueName, subscriptionMode, acceptMessagesOlderThanSubscriptionTime, messageHandler, null, null, null ); }