public CorrelationToken Subscribe(IQueueSubscriber <M> Subscriber)
{
var ct = CorrelationToken.Create();
Subscribers.TryAdd(ct, Subscriber);
return(ct);
}
static void Main(string[] args)
{
IContainer container = CreateContainer();
string timestampConfig = container.Resolve <IConfiguration>().GetSection("EventStoreReplica")["timestamp"];
DateTime?timestamp = null;
if (!string.IsNullOrEmpty(timestampConfig))
{
timestamp = DateTime.Parse(timestampConfig).ToUniversalTime();
Console.WriteLine($"### Replication start for period before {timestampConfig}");
}
IEnumerable <IInitializer> initializers = container.Resolve <IEnumerable <IReplicaInitializer> >();
RunInitializers(initializers);
IEnumerable <IReplicationManager> replicationManagers = container.Resolve <IEnumerable <IReplicationManager> >();
RunReplicators(replicationManagers, timestamp);
IQueueSubscriber readStorageSubscriber = container.Resolve <IReadStorageSyncQueueSubscriber>();
readStorageSubscriber.Subscribe();
Console.ReadLine();
readStorageSubscriber.Dispose();
}
CorrelationToken IQueueReceiver.Subscribe(IQueueSubscriber Subscriber)
{
var ct = CorrelationToken.Create();
Subscribers.TryAdd(ct, Subscriber);
return(ct);
}
public SmSSubcriberJobService(ILogger <SmSSubcriberJobService> logger,
IConfiguration configuration)
{
_configuration = configuration;
_subscriber = CreateSubscriber();
_logger = logger;
}
public CorrelationToken Subscribe <M>(IQueueSubscriber <M> Subscriber)
where M : new()
{
var receiver = Receiver <M>();
return(RecordSubscription(receiver.Subscribe(Subscriber), receiver));
}
static void Main(string[] args)
{
IQueueSubscriber subscriber = null;
IQueueSubscriber readStorageSubscriber = null;
int attempts_count = 0;
while (attempts_count <= 20)
{
try
{
IContainer container = CreateContainer();
subscriber = container.Resolve <IProcessOrderQueueSubscriber>();
subscriber.Subscribe();
readStorageSubscriber = container.Resolve <IReadStorageSyncQueueSubscriber>();
readStorageSubscriber.Subscribe();
attempts_count = 21;
Console.WriteLine($"### Subscription to Rabbit MQ successful");
}
catch (Exception ex)
{
attempts_count += 1;
Console.WriteLine($"### Retry connect to Rabbit MQ attempt {attempts_count}");
}
Thread.Sleep(TimeSpan.FromSeconds(10));
}
Console.ReadLine();
subscriber?.Dispose();
readStorageSubscriber?.Dispose();
}
/// <summary>
/// Initializes a new instance of the <see cref="Mediator"/> class.
/// </summary>
/// <param name="dataScheduler">
/// The data scheduler.
/// </param>
/// <param name="queueSubscriber">
/// The queue subscriber.
/// </param>
/// <param name="logger">
/// The logger.
/// </param>
public Mediator(
IDataCoordinatorScheduler dataScheduler,
IQueueSubscriber queueSubscriber,
ILogger <Mediator> logger)
{
this.dataScheduler = dataScheduler ?? throw new ArgumentNullException(nameof(dataScheduler));
this.queueSubscriber = queueSubscriber ?? throw new ArgumentNullException(nameof(queueSubscriber));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
private static void Subscriber_MessageCallback(IQueueSubscriber sender, ulong deliveryTag, byte[] body)
{
//收到信息输出
string msg = Encoding.Default.GetString(body);
//回复确认消息
sender.AckAnswer(deliveryTag);
Console.WriteLine(msg);
}
private void RemoveSubscriber(IQueueSubscriber queueConsumer)
{
lock (_lock)
{
List <IQueueSubscriber> queueSubscribers = _subscribers.ToList();
bool found = queueSubscribers.Remove(queueConsumer);
_subscribers = queueSubscribers.ToArray();
_subCount--;
//if not found?
}
}
public static IQueueSubscriber CreateGoogleSubscriber(QueueProvider provider, QueueSetting queueSetting, string subscriptionName, Action <string> handler)
{
IQueueSubscriber subscriber = default;
switch (provider)
{
case QueueProvider.GOOGLE:
subscriber = new GoogleQueueSubscriber(queueSetting, subscriptionName, handler);
break;
}
return(subscriber);
}
public void Publish(TMsg message)
{
if (_subCount == 0)
{
return;
}
long index = Interlocked.Increment(ref _index) % _subCount;
IQueueSubscriber queueSubscriber = _subscribers[index];
queueSubscriber.Signal(message);
}
static void Main(string[] args)
{
Console.Title = "Rabbit MQ测试控制台";
Console.WriteLine("****** 输入数字1以发布者方式运行，输入数字2以订阅者方式运行 ******");
Console.Write("输入数字 1 或 2：");
int cmd;
if (!int.TryParse(Console.ReadKey().KeyChar.ToString(), out cmd))
{
Console.WriteLine("输入错误，按任意键退出!");
Console.ReadLine();
return;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("\r\n\r\n开始\r\n");
Console.ForegroundColor = ConsoleColor.White;
string txt = File.ReadAllText("test.xml");
MessageQueueManager.InitMessageQueueServer("192.168.5.16", 5672, "trkj", "trkj");
switch (cmd)
{
case 1:
Console.Title = "Rabbit MQ 发布者";
IQueuePublisher publisher = MessageQueueManager.GerarateIQueuePublisher(
exchangeName: "my_test_exchange",
typeName: "topic",
routeKey: "test_key",
exchangeDurable: true,
exchangeAutoDelete: false);
//消息进队
for (int i = 0; i < int.MaxValue; i++)
{
Console.WriteLine(i);
publisher.MessageEnqueue(txt, true);
Thread.Sleep(1000);
}
break;
case 2:
Console.Title = "Rabbit MQ 订阅者";
IQueueSubscriber subscriber = MessageQueueManager.GerarateIQueueSubscriber(
exchangeName: "my_test_exchange",
queueName: "my_test_queue",
typeName: "topic",
routeKey: "test_key",
exchangeDurable: true,
exchangeAutoDelete: false,
queueDurable: true,
queueAutoDelete: false,
queueExclusive: false,
prefetchCount: 0,
noAck: false,
maxLength: -1,
maxBytes: -1,
messageTtl: -1);
subscriber.MessageCallback += Subscriber_MessageCallback;
break;
default:
Console.WriteLine("输入错误，按任意键退出!");
Console.ReadLine();
break;
}
Console.ReadLine();
}
static void Main(string[] args)
{
try
{
// Create the platform session.
ISession session = GlobalSettings.Sessions.GetSession();
// Open the session
session.Open();
// ********************************************************************************************
// Headline Alert Endpoint URL.
// ********************************************************************************************
const string alertHeadlinesEndpoint = "https://api.refinitiv.com/alerts/v1/news-headlines-subscriptions";
// Determine if we are using an existing queue or creating one. The QueueManager will assist us here.
IQueueManager manager = DeliveryFactory.CreateQueueManager(new QueueManager.Params().Session(session)
.Endpoint(alertHeadlinesEndpoint)
.OnError((qm, err) => Console.WriteLine(err)));
// First, check to see if we have any news headline queues active in the cloud, if not, create one.
List <IQueue> queues = manager.GetAllQueues();
// Determine if we retrieved anything...create one if not.
IQueue queue = (queues?.Count > 0 ? queues[0] : manager.CreateQueue());
// Ensure our queue is created
if (queue != null)
{
Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue...");
// Start polling for news headline messages from the queue
// A QueueSubscriber provides the mechanisms to poll the queue and capture each headline alert via lambda expressions
IQueueSubscriber subscriber = DeliveryFactory.CreateQueueSubscriber(
new AWSQueueSubscriber.Params().Queue(queue)
.WithMessagePollingInterval(1)
.OnResponse((s, response) =>
{
if (response.IsSuccess)
{
DisplayHeadline(response.Data.Raw);
}
else
{
Console.WriteLine(response.Status);
}
}));
// Open the subscriber to begin polling for messages
subscriber.StartPolling();
Console.WriteLine("Polling for messages from the queue...hit any key to stop polling");
// Hit any key to stop...
Console.ReadKey();
// Close the subscription - stops polling for messages
subscriber.StopPolling();
Console.WriteLine($"{Environment.NewLine}Stopped polling for messages from the queue.");
// Prompt the user to delete the queue
Console.Write("Delete the queue (Y/N) [N]: ");
var delete = Console.ReadLine();
if (delete?.ToUpper() == "Y")
{
if (manager.DeleteQueue(queue))
{
Console.WriteLine("Successfully deleted queue.");
}
else
{
Console.WriteLine($"Issues deleting queue {manager.Error}");
}
}
}
}
catch (Exception e)
{
Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n***************");
}
}
static void Main(string[] _)
{
const string researchEndpoint = "https://api.refinitiv.com/message-services/v1/research/subscriptions";
try
{
using (ISession session = Configuration.Sessions.GetSession())
{
if (session.Open() == Session.State.Opened)
{
// Create a QueueManager to actively manage our queues
IQueueManager manager = DeliveryFactory.CreateQueueManager(new QueueManager.Params().Session(session)
.Endpoint(researchEndpoint)
.OnError((qm, err) => Console.WriteLine(err)));
// First, check to see if we have any news headline queues active in the cloud...
List <IQueue> queues = manager.GetAllQueues();
// Check the error property to determine the result of the last request
if (manager.Error == null)
{
// Prepare Research criteria if we plan to create a new AWS queue - we must supply a research ID.
JObject criteria = new JObject()
{
["transport"] = new JObject()
{
["transportType"] = "AWS-SQS"
},
["payloadVersion"] = "2.0",
["userID"] = Configuration.Credentials.ResearchID
};
// If no existing queue exists, create one.
IQueue queue = (queues.Count > 0 ? queues[0] : manager.CreateQueue(criteria));
if (queue != null)
{
Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue...");
// Subscribe to the queue.
// Note: The subscriber interface has 2 mechanisms to retrieve data from the queue. The first mechanism is to selectively
// poll the queue for new messages. The second mechanism is to define a callback/lambda expression and notify the
// the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
//
// The following example demonstrates the first mechanism.
IQueueSubscriber subscriber = DeliveryFactory.CreateQueueSubscriber(new AWSQueueSubscriber.Params().Queue(queue));
Console.WriteLine("Attempt to retrieve research messages. Hit any key to interrupt fetching...");
// Instead of defining a lambda callback, we manually poll the queue until we hit any key on the keyboard.
// Each poll will timeout after 5 seconds.
bool noMsgAvailable = false;
while (!Console.KeyAvailable)
{
IQueueResponse result = subscriber.GetNextMessage(5);
if (result.IsSuccess)
{
if (result.IsMessageAvailable)
{
DisplayResearch(result);
}
else
{
Console.Write(noMsgAvailable ? "." : "No Message available from GetNextMessage");
}
noMsgAvailable = !result.IsMessageAvailable;
}
else
{
Console.WriteLine(result.Status);
}
}
Console.ReadKey();
// Prompt the user to delete the queue
Console.Write("\nDelete the queue (Y/N) [N]: ");
var delete = Console.ReadLine();
if (delete?.ToUpper() == "Y")
{
if (manager.DeleteQueue(queue))
{
Console.WriteLine("Successfully deleted queue.");
}
else
{
Console.WriteLine($"Issues deleting queue {manager.Error}");
}
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
}
}
public void Setup()
{
this.dataScheduler = A.Fake <IDataCoordinatorScheduler>();
this.queueSubscriber = A.Fake <IQueueSubscriber>();
this.logger = A.Fake <ILogger <Mediator> >();
}
public Worker(IQueueSubscriber serviceBus, IMessageSubscriber subscriber, CourseDbContext context)
{
_ServiceBus = serviceBus;
_Subscriber = subscriber;
_Context = context;
}
static void Main(string[] _)
{
const string newsHeadlinesEndpoint = "https://api.refinitiv.com/message-services/v1/news-headlines/subscriptions";
try
{
// Create the platform session.
using (ISession session = Configuration.Sessions.GetSession())
{
// Open the session
session.Open();
// Create a QueueManager to actively manage our queues
IQueueManager manager = DeliveryFactory.CreateQueueManager(new QueueManager.Params().Session(session)
.Endpoint(newsHeadlinesEndpoint)
.OnError((qm, err) => Console.WriteLine(err)));
// First, check to see if we have any news headline queues active in the cloud...
List <IQueue> queues = manager.GetAllQueues();
// Check the error property to determine the result of the last request
if (manager.Error == null)
{
// Determine if we retrieved an active headline queue...create one if not.
IQueue queue;
if (queues.Count > 0)
{
queue = queues[0];
}
else
{
queue = CreateQueue(manager, "AA"); // Create a Queue with the new query expression ("AA" - alerts only)
}
// Ensure our queue is created
if (queue != null)
{
Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue. Waiting for headlines...");
// Subscribe to the queue.
// Note: The subscriber interface has 2 mechanisms to retrieve data from the queue. The first mechanism is to selectively
// poll the queue for new messages. The second mechanism is to define a callback/lambda expression and notify the
// the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
//
// The following example demonstrates the first mechanism.
IQueueSubscriber subscriber = DeliveryFactory.CreateQueueSubscriber(new AWSQueueSubscriber.Params().Queue(queue));
// Poll the queue until we hit any key on the keyboard.
// Each poll will timeout after 5 seconds.
while (!Console.KeyAvailable)
{
IQueueResponse result = subscriber.GetNextMessage(5);
if (result.IsSuccess)
{
DisplayHeadline(result);
}
else
{
Console.WriteLine(result.Status);
}
}
Console.ReadKey();
// Prompt the user to delete the queue
Console.Write("\nDelete the queue (Y/N) [N]: ");
var delete = Console.ReadLine();
if (delete?.ToUpper() == "Y")
{
if (manager.DeleteQueue(queue))
{
Console.WriteLine("Successfully deleted queue.");
}
else
{
Console.WriteLine($"Issues deleting queue {manager.Error}");
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
}
}
public CorrelationToken Subscribe(Type MessageType, IQueueSubscriber Subscriber)
{
var receiver = Receiver(MessageType);
return(RecordSubscription(receiver.Subscribe(Subscriber), receiver));
}
static void Main(string[] _)
{
const string newsStoriesEndpoint = "https://api.refinitiv.com/message-services/v1/news-stories/subscriptions";
try
{
using (ISession session = Configuration.Sessions.GetSession())
{
// Open the session
session.Open();
// Create our stories definition
var definition = Queue.Definition(newsStoriesEndpoint);
// Create a QueueManager to actively manage our queues
IQueueManager manager = definition.CreateQueueManager().OnError((err, qm) => Console.WriteLine(err));
// First, check to see if we have any news headline queues active in the cloud...
var queues = manager.GetAllQueues();
// If no existing queue exists, create one.
IQueueNode queue = (queues.Count > 0 ? queues[0] : manager.CreateQueue());
// Ensure our queue is created
if (queue != null)
{
Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue. Waiting for stories...");
// Subscribe to the queue.
// Note: The subscriber interface has 2 mechanisms to retrieve data from the queue. The first mechanism is to selectively
// poll the queue for new messages. The second mechanism is to define a callback/lambda expression and notify the
// the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
//
// The following example demonstrates the second mechanism.
IQueueSubscriber subscriber = definition.CreateAWSSubscriber(queue);
// Open the subscriber to begin polling for messages. Use Async() as this method is a long running task.
var task = subscriber.StartPollingAsync((story, s) => DisplayStory(story));
Console.ReadKey();
// Close the subscription - stops polling for messages
subscriber.StopPolling();
task.GetAwaiter().GetResult();
Console.WriteLine("Stopped polling for messages from the queue.");
// Prompt the user to delete the queue
Console.Write("Delete the queue (Y/N) [N]: ");
var delete = Console.ReadLine();
if (delete?.ToUpper() == "Y")
{
if (manager.DeleteQueue(queue))
{
Console.WriteLine("Successfully deleted queue.");
}
else
{
Console.WriteLine($"Issues deleting queue.");
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
}
}
public Worker(ILogger <Worker> logger, IConfiguration configuration)
{
_configuration = configuration;
_subscriber = CreateSubscriber();
_logger = logger;
}
public void Start()
{
subscriber = _queueConnectionFactory.GetQueueSubscriber <ProbeTemperatureMessage>("Temperature");
subscriber.OnMessage += Received;
subscriber.Connect();
}
