///<summary>Sets the subscriber for this context and object type</summary>
///<param name="subscriber"></param>
///<param name="objectType"></param>
///<param name="options"></param>
public void setSubscriber(
ISubscriber subscriber,
IElementDef objectType,
SubscriptionOptions options)
{
SetHandler(fSubs, subscriber, objectType, options);
}
public ISubscriptionClient Create(SubscriptionOptions options)
{
var clientMock = new SubscriptionClientMock(options.SubscriptionName);
_registeredClients.Add(clientMock);
return(clientMock.Client);
}
private void BuildAndRegisterSubscription(SubscriptionOptions options, ServiceBusOptions parentOptions)
{
var subscription = new SubscriptionWrapper(options, parentOptions, _provider);
subscription.Initialize();
_registry.Register(subscription);
}
public IDisposable Subscribe(string tag)
{
var options = new SubscriptionOptions {
Id = "Tag@" + tag
};
return(Dispatcher.Subscribe(Repo.GetLastCheckpoint <TProjection, TIdentity>(), (list, info) => Projector.Projector.Handle(list), options));
}
public IDisposable Subscribe <TAggregate>()
{
var options = new SubscriptionOptions {
Id = "Type@" + typeof(TAggregate).AssemblyQualifiedName
};
return(Dispatcher.Subscribe(Repo.GetLastCheckpoint <TProjection, TIdentity>(), (list, info) => Projector.Projector.Handle(list), options));
}
public void TestBasicMessageSubscriptionWithSubtopic()
{
SetLatch();
SetMessage();
string subtopic = "sub" + Random.Next();
SubscriptionOptions subscriptionOptions = new SubscriptionOptions();
subscriptionOptions.Subtopic = subtopic;
subscription = Backendless.Messaging.Subscribe(TEST_CHANNEL,
new ResponseCallback <List <Message> >(this)
{
ResponseHandler = messages =>
{
try
{
Assert.IsNotNull(messages,
"Server returned a null object instead of messages list");
Assert.IsFalse(messages.Count == 0,
"Server returned an empty messages list");
foreach (Message resultMessage in messages)
{
if (
resultMessage.MessageId.Equals(
messageStatus.MessageId))
{
Assert.AreEqual(message, resultMessage.Data,
"Server returned a message with a wrong message data");
Assert.AreEqual(messageStatus.MessageId,
resultMessage.MessageId,
"Server returned a message with a wrong messageId");
latch.Signal();
}
}
}
catch (System.Exception t)
{
FailCountDownWith(t);
}
}
}, subscriptionOptions);
var publishOptions = new PublishOptions();
publishOptions.Subtopic = subtopic;
messageStatus = Backendless.Messaging.Publish(message, TEST_CHANNEL, publishOptions);
Assert.IsNotNull(messageStatus.MessageId, "Server didn't set a messageId for the message");
Assert.IsTrue(messageStatus.Status.Equals(PublishStatusEnum.PUBLISHED),
"Message status was not set as published");
Await();
CheckResult();
}
public void TestMessagePublishWithHeadersAndSubtopics()
{
SetLatch();
SetMessage();
SetHeaders();
string subtopic = "foo.bar";
SubscriptionOptions subscriptionOptions = new SubscriptionOptions();
subscriptionOptions.Subtopic = subtopic;
subscription = Backendless.Messaging.Subscribe(TEST_CHANNEL, new AsyncCallback <List <Message> >(messages =>
{
try
{
Assert.IsNotNull(messages, "Server returned a null object instead of messages list");
foreach (Message resultMessage in messages)
{
if (resultMessage.MessageId.Equals(messageStatus.MessageId))
{
Assert.AreEqual(message, resultMessage.Data, "Server returned a message with a wrong message data");
foreach (var key in PublishTest.headers.Keys)
{
Assert.IsTrue(resultMessage.Headers.ContainsKey(key),
"Server returned a message with wrong headers");
Assert.IsTrue(resultMessage.Headers[key].Equals(PublishTest.headers[key]),
"Server returned a message with wrong headers");
}
latch.Signal();
}
}
}
catch (System.Exception t)
{
FailCountDownWith(t);
}
}, FailCountDownWith), subscriptionOptions);
PublishOptions publishOptions = new PublishOptions();
publishOptions.Headers = headers;
publishOptions.Subtopic = subtopic;
messageStatus = Backendless.Messaging.Publish(message, TEST_CHANNEL, publishOptions);
Assert.IsNotNull(messageStatus.MessageId, "Server didn't set a messageId for the message");
Assert.IsTrue(messageStatus.Status.Equals(PublishStatusEnum.PUBLISHED),
"Message status was not set as published");
Await();
CheckResult();
}
/// <summary>
/// 订阅
/// </summary>
public void Subscribe <TMessage>(
Action <TMessage, ConsumeContext> subscribeEvent,
Action <SubscriptionOptions> config = null) where TMessage : class
{
// 配置初始化
var subscriptionOptions = new SubscriptionOptions();
config?.Invoke(subscriptionOptions);
var channel = _connection.CreateModel();
// 回调事件
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (sender, args) =>
{
var consumeContext = new ConsumeContext()
{
Exchange = args.Exchange,
RoutingKey = args.RoutingKey,
ConsumerTag = args.ConsumerTag,
DeliveryTag = args.DeliveryTag,
MessageId = args.BasicProperties.MessageId
};
// 读取消息
var body = args.Body;
var data = Encoding.UTF8.GetString(body);
var message = JsonConvert.DeserializeObject <TMessage>(data);
// 执行订阅事件
subscribeEvent(message, consumeContext);
// 交付确认
if (!subscriptionOptions.AutoAck)
{
channel.BasicAck(deliveryTag: args.DeliveryTag, multiple: false);
}
};
// 声明队列名称
var messageTypeName = subscriptionOptions.MessageTypeName ?? typeof(TMessage).Name;
var reciveQueueName = $"{_options.Prefix}-rmq-{messageTypeName}";
var reciveExchangeName = $"{_options.Prefix}-rexc-{messageTypeName}";
// 绑定接收队列
channel.ExchangeDeclare(exchange: reciveExchangeName, type: "direct");
channel.QueueBind(
queue: reciveQueueName,
exchange: reciveExchangeName,
routingKey: reciveQueueName);
channel.BasicConsume(
reciveQueueName,
subscriptionOptions.AutoAck,
consumer);
}
public AzureServiceBusTopicClient(ILoggingService logging, string asbConnectionString, string topicName, string subscriptionQueueName, SubscriptionOptions options, IMessageSerializer serializer)
{
this.logging = logging;
this.log = logging.GetCurrentClassLogger();
this.asbConnectionString = asbConnectionString;
this.topicName = topicName;
this.subscriptionQueueName = subscriptionQueueName;
this.options = options;
this.serializer = serializer;
ConnectToSubscription();
}
public void SetSubscriber(ISubscriber subscriber, IElementDef objectType, SubscriptionOptions options)
{
if (options == null)
{
options = new SubscriptionOptions();
}
foreach (SifContext context in options.SupportedContexts)
{
GetOrCreateContextMatrix(context).setSubscriber(subscriber, objectType, options);
}
}
public virtual void Subscribe(Action <TArgs> action, SubscriptionOptions options)
{
lock (this)
{
subscriptions.Add(
new Subscription
{
Action = action,
Options = options
});
}
}
public SubscriptionWrapper(
SubscriptionOptions options,
ServiceBusOptions parentOptions,
IServiceProvider provider)
: base(
options,
parentOptions,
provider,
EntityNameHelper.FormatSubscriptionPath(options.TopicName, options.SubscriptionName))
{
_options = options;
}
public IDisposable Subscribe(Subscription[] subscriptions, SubscriptionOptions options = SubscriptionOptions.Default)
{
var shouldHaveHanlderInvoker = (options & SubscriptionOptions.ThereIsNoHandlerButIKnowWhatIAmDoing) == 0;
if (shouldHaveHanlderInvoker)
{
EnsureMessageHandlerInvokerExists(subscriptions);
}
AddSubscriptions(subscriptions);
return(new DisposableAction(() => RemoveSubscriptions(subscriptions)));
}
public void testNormalEvent()
{
IElementDef objType = StudentDTD.STUDENTCONTACT;
ErrorMessageHandler handler = new ErrorMessageHandler(ErrorMessageHandler.HandlerBehavior.Normal);
SubscriptionOptions options = new SubscriptionOptions();
fZone.SetSubscriber(handler, objType, options);
fZone.Connect(ProvisioningFlags.Register);
//fZone.SetSubscriber(handler, objType, null);
SIF_Event evnt = createSIF_Event(objType);
assertNormalHandling(handler, evnt, fZone);
}
public ISubscriptionClient Create(SubscriptionOptions options)
{
if (options.Connection != null)
{
return(new SubscriptionClient(options.Connection, options.TopicName, options.SubscriptionName, options.ReceiveMode, options.RetryPolicy));
}
if (options.ConnectionStringBuilder != null)
{
return(new SubscriptionClient(options.ConnectionStringBuilder, options.SubscriptionName, options.ReceiveMode, options.RetryPolicy));
}
return(new SubscriptionClient(options.ConnectionString, options.TopicName, options.SubscriptionName, options.ReceiveMode, options.RetryPolicy));
}
public When_the_requested_checkpoint_is_ahead_of_the_store_and_auto_restart_is_configured()
{
Given(async() =>
{
UseThe(new MemoryEventSource());
WithSubject(_ => new Dispatcher(The <MemoryEventSource>().Subscribe));
await The <MemoryEventSource>().Write(
new TransactionBuilder().WithCheckpoint(1).Build());
await The <MemoryEventSource>().Write(
new TransactionBuilder().WithCheckpoint(999).Build());
});
When(() =>
{
var options = new SubscriptionOptions
{
Id = "someId",
RestartWhenAhead = true,
BeforeRestarting = () =>
{
trace.Add("BeforeRestarting");
return(Task.FromResult(0));
}
};
Subject.Subscribe(1000, (transactions, info) =>
{
foreach (var transaction in transactions)
{
trace.Add("TransactionReceived");
}
foreach (var transaction in transactions)
{
receivedTransactions.Add(transaction);
}
if (receivedTransactions.Count == 2)
{
allTransactionsReceived.SetResult(transactions);
}
return(Task.FromResult(0));
}, options);
});
}
public IDisposable Subscribe(Subscription subscription, SubscriptionOptions options = SubscriptionOptions.Default)
{
lock (Subscriptions)
{
Subscriptions.Add(subscription);
}
return(new DisposableAction(() =>
{
lock (Subscriptions)
{
Subscriptions.Remove(subscription);
}
}));
}
public IDisposable Subscribe(Subscription[] subscriptions, SubscriptionOptions options = SubscriptionOptions.Default)
{
lock (_subscriptions)
{
_subscriptions.AddRange(subscriptions);
}
return(new DisposableAction(() =>
{
lock (_subscriptions)
{
_subscriptions.RemoveRange(subscriptions);
}
}));
}
public void TestBasicMessageSubscriptionWithSubtopic()
{
SetLatch();
SetMessage();
string subtopic = "sub" + Random.Next();
SubscriptionOptions subscriptionOptions = new SubscriptionOptions();
subscriptionOptions.Subtopic = subtopic;
channel = Backendless.Messaging.Subscribe(TEST_CHANNEL);
channel.AddMessageListener <Message>((message) =>
{
try
{
if (
message.MessageId.Equals(
messageStatus.MessageId))
{
Assert.AreEqual(message, message.Data,
"Server returned a message with a wrong message data");
Assert.AreEqual(messageStatus.MessageId,
message.MessageId,
"Server returned a message with a wrong messageId");
latch.Signal();
}
}
catch (System.Exception t)
{
FailCountDownWith(t);
}
});
var publishOptions = new PublishOptions();
publishOptions.Subtopic = subtopic;
messageStatus = Backendless.Messaging.Publish(message, TEST_CHANNEL, publishOptions);
Assert.IsNotNull(messageStatus.MessageId, "Server didn't set a messageId for the message");
Assert.IsTrue(messageStatus.Status.Equals(PublishStatusEnum.PUBLISHED),
"Message status was not set as published");
Await();
CheckResult();
}
public void testEventThrowsException()
{
IElementDef objType = StudentDTD.STUDENTCONTACT;
ErrorMessageHandler handler = new ErrorMessageHandler(ErrorMessageHandler.HandlerBehavior.ThrowException);
SubscriptionOptions options = new SubscriptionOptions();
fZone.SetSubscriber(handler, objType, options);
fZone.Connect(ProvisioningFlags.Register);
//
// fZone.SetSubscriber(handler, objType, null);
SIF_Event evnt = createSIF_Event(objType);
AssertExceptionHandling(handler, evnt, fZone, typeof(AdkException));
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscribedMethod" /> class.
/// </summary>
/// <param name="targetTypeFactory">
/// The delegate to be used to resolve an instantiate of the type declaring the subscribed method.
/// </param>
/// <param name="methodInfo">
/// The <see cref="MethodInfo" /> related to the subscribed method.
/// </param>
/// <param name="options">
/// The <see cref="SubscriptionOptions" />.
/// </param>
public SubscribedMethod(
Func <IServiceProvider, object> targetTypeFactory,
MethodInfo methodInfo,
SubscriptionOptions options)
{
_targetTypeFactory = Check.NotNull(targetTypeFactory, nameof(targetTypeFactory));
MethodInfo = Check.NotNull(methodInfo, nameof(methodInfo));
Options = Check.NotNull(options, nameof(options));
Parameters = methodInfo.GetParameters();
if (Parameters.Count == 0)
{
throw new SubscribedMethodInvocationException(
methodInfo,
"The subscribed method must have at least 1 argument.");
}
}
public When_there_are_no_new_transactions_available_and_auto_restart_is_configured()
{
Given(async() =>
{
UseThe(new MemoryEventSource());
WithSubject(_ => new Dispatcher(The <MemoryEventSource>().Subscribe));
await The <MemoryEventSource>().Write(
new TransactionBuilder().WithCheckpoint(123).Build());
await The <MemoryEventSource>().Write(
new TransactionBuilder().WithCheckpoint(456).Build());
});
When(() =>
{
var options = new SubscriptionOptions
{
Id = "someId",
RestartWhenAhead = true,
BeforeRestarting = () =>
{
restarted = true;
return(Task.FromResult(0));
}
};
Subject.Subscribe(123, (transactions, info) =>
{
foreach (var transaction in transactions)
{
receivedTransactions.Add(transaction);
}
if (receivedTransactions.Count == 1)
{
allTransactionsReceived.SetResult(true);
}
return(Task.FromResult(0));
}, options);
});
}
public void TestMessagePublishWithHeadersAndSubtopics()
{
SetLatch();
SetMessage();
SetHeaders();
string subtopic = "foo.bar";
SubscriptionOptions subscriptionOptions = new SubscriptionOptions();
subscriptionOptions.Subtopic = subtopic;
channel = Backendless.Messaging.Subscribe(TEST_CHANNEL);
channel.AddMessageListener <Message>((resultMessage) =>
{
if (resultMessage.MessageId.Equals(messageStatus.MessageId))
{
Assert.AreEqual(message, resultMessage.Data, "Server returned a message with a wrong message data");
foreach (var key in PublishTest.headers.Keys)
{
Assert.IsTrue(resultMessage.Headers.ContainsKey(key),
"Server returned a message with wrong headers");
Assert.IsTrue(resultMessage.Headers[key].Equals(PublishTest.headers[key]),
"Server returned a message with wrong headers");
}
}
});
PublishOptions publishOptions = new PublishOptions();
publishOptions.Headers = headers;
publishOptions.Subtopic = subtopic;
messageStatus = Backendless.Messaging.Publish(message, TEST_CHANNEL, publishOptions);
Assert.IsNotNull(messageStatus.MessageId, "Server didn't set a messageId for the message");
Assert.IsTrue(messageStatus.Status.Equals(PublishStatusEnum.PUBLISHED),
"Message status was not set as published");
Await();
CheckResult();
}
public void SetSubscriber(ISubscriber subscriber,
SubscriptionOptions flags)
{
assertProvisioningOptions(flags);
if (subscriber == null)
{
fSub = null;
fSubOpts = null;
}
else
{
fSub = subscriber;
if (flags == null)
{
flags = new SubscriptionOptions();
}
fSubOpts = flags;
}
}
public RabbitMQSubscription(string topicName, string subscriptionName, SubscriptionOptions options, IConnection rabbitMQ, IMessageSerializer serializer)
{
this.serializer = serializer;
this.topicName = topicName;
this.subscriptionName = subscriptionName;
this.options = options;
this.rabbitMQ = rabbitMQ;
this.rabbitModel = rabbitMQ.CreateModel();
rabbitModel.ExchangeDeclare(topicName, ExchangeType.Topic, options.Durable, false, null);
rabbitModel.QueueDeclare(subscriptionName, options.Durable, exclusive, false);
rabbitModel.QueueBind(subscriptionName, topicName, "");
this.rabbitConsumer = new EventingBasicConsumer(rabbitModel);
rabbitConsumer.Received += RabbitConsumer_Received;
this.isSubscribed = true;
}
public When_the_autorestart_cleanup_action_throws_but_a_retry_is_requested()
{
Given(async() =>
{
UseThe(new MemoryEventSource());
WithSubject(_ => new Dispatcher(The <MemoryEventSource>().Subscribe));
await The <MemoryEventSource>().Write(
new TransactionBuilder().WithCheckpoint(1).Build());
await The <MemoryEventSource>().Write(
new TransactionBuilder().WithCheckpoint(999).Build());
});
When(() =>
{
var options = new SubscriptionOptions
{
Id = "someId",
RestartWhenAhead = true,
BeforeRestarting = () =>
{
attempts++;
if (attempts < 2)
{
throw new InvalidOperationException();
}
return(Task.FromResult(0));
}
};
Subject.ExceptionHandler = (exception, attempts, info) => Task.FromResult(ExceptionResolution.Retry);
Subject.Subscribe(1000, (transactions, info) => Task.FromResult(0), options);
});
}
private void startStreaming()
{
if (!streamingIsActive)
{
StreamingOptions streamingOptions = new StreamingOptions();
streamingOptions.include_annotations = true;
streamingOptions.include_html = false;
streamingOptions.include_marker = true;
streamingOptions.include_channel_annotations = false;
streamingOptions.include_message_annotations = true;
streamingOptions.include_post_annotations = true;
streamingOptions.include_user_annotations = true;
userStream = new Streaming.UserStream(this.accessToken, streamingOptions);
IAsyncResult asyncResult = userStream.StartUserStream(
streamCallback: streamCallback,
unifiedCallback: unifiedCallback,
mentionsCallback: mentionsCallback,
channelsCallback: channelsCallback,
streamStoppedCallback: streamStoppedCallback);
SubscriptionOptions subscriptionOptions = new SubscriptionOptions();
subscriptionOptions.include_deleted = true;
subscriptionOptions.include_incomplete = false;
subscriptionOptions.include_muted = false;
subscriptionOptions.include_private = true;
subscriptionOptions.include_read = true;
//userStream.subscribe_to_endpoint(userStream.available_endpoints["Unified"]);
userStream.subscribe_to_endpoint(userStream.available_endpoints["Stream"]);
userStream.subscribe_to_endpoint(userStream.available_endpoints["Mentions"]);
userStream.subscribe_to_endpoint(userStream.available_endpoints["Channels"]);
streamingIsActive = true;
}
}
public ISubscriptionClient <TContent> SubscribeToTopic <TContent>(string topicName, string subscriptionQueueName = null, SubscriptionOptions options = null)
{
throw new NotImplementedException();
}
public override ISubscriptionClient <TContent> SubscribeToTopic <TContent>(string topicName, string subscriptionName = null, SubscriptionOptions options = null)
{
var subscription = new SolaceTopicSubscription <TContent>(this.loggingService, this.config, this.session,
this.solaceContext, serializer, topicName, options ?? new SubscriptionOptions(), this.uniqueClientName);
this.subs.Add(subscription);
return(subscription);
}
public Client SubscribeALL(SubscriptionOptions options)
{
Options = options;
Symbols = null;
return this;
}
/// <summary>
/// Subscribes the specified handler method to the messages being published into the bus.
/// </summary>
/// <typeparam name="TMessage">The type of the messages to be handled.</typeparam>
/// <param name="handler">The message handler delegate.</param>
/// <param name="options">A <see cref="SubscriptionOptions"/> instance specifying parallelism options.</param>
/// <returns></returns>
public BusConfigurator Subscribe <TMessage>(Func <TMessage, object> handler, SubscriptionOptions options = null)
{
_busOptions.Subscriptions.Add(new DelegateSubscription(handler, options));
return(this);
}
public void SetSubscriber(ISubscriber subscriber,
SubscriptionOptions flags)
{
assertProvisioningOptions(flags);
if (subscriber == null)
{
fSub = null;
fSubOpts = null;
}
else
{
fSub = subscriber;
if (flags == null)
{
flags = new SubscriptionOptions();
}
fSubOpts = flags;
}
}
public Client Subscribe(SubscriptionOptions options, IEnumerable<string> symbols = null)
{
Options = options;
Symbols = symbols;
return this;
}
