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);
}
public SubscriptionModeAttribute(SubscriptionMode subscriptionMode)
{
SubscriptionMode = subscriptionMode;
}
/// <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
);
}
