public void CallGenerateNewNumber()
{
// producer bound to specific Queue (=Destination) sends a message
_callGenerateNewNumberProducer.Send(
_callGenerateNewNumberProducer.CreateObjectMessage(
new GenerateNewNumberMessage()));
}
public void ProdutorTopico()
{
try
{
//Console.WriteLine("------------ PRODUTOR ------------");
IDestination dest = _sessao.GetTopic(TOPICO);
using (IMessageProducer producer = _sessao.CreateProducer(dest))
{
for (int i = 1; i < 101; i++)
{
Thread.Sleep(100);
var mensagem = new Mensagem
{
Message = $"Mensagem {i}",
};
var objectMessage = producer.CreateObjectMessage(JsonConvert.SerializeObject(mensagem));
producer.DeliveryMode = MsgDeliveryMode.NonPersistent;
producer.Send(objectMessage);
Console.WriteLine($"{Thread.CurrentThread.Name} - Escrevendo no {TOPICO} => '{mensagem.Message}'");
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <string> CallCalculateWinner()
{
try
{
if (_requestWinnerCalculationProducer == null)
{
_requestWinnerCalculationDestination = _session.GetQueue("RequestWinnerCalculationQueue");
_requestWinnerCalculationProducer = _session.CreateProducer(_requestWinnerCalculationDestination);
_responseWinnerCalculationDestination = _session.GetQueue("ResponseWinnerCalculationQueue");
_responseWinnerCalculationConsumer = _session.CreateConsumer(_responseWinnerCalculationDestination);
}
_requestWinnerCalculationProducer.Send(
_requestWinnerCalculationProducer.CreateObjectMessage(
new RequestWinnerCalculation())); // TODO: rename to -Message
IMessage message;
while ((message = _responseWinnerCalculationConsumer.Receive(TimeSpan.FromMinutes(1))) != null)
{
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
if (objectMessage?.Body is ResponseWinnerCalculation responseMessage) // TODO rename -Message
{
return(responseMessage.Text);
}
}
}
catch (Exception exc)
{
// TODO: reopen connection, proper handling of exception type
}
return("Error in receiving message");
}
public void ProdutorFila()
{
try
{
//Console.WriteLine("------------ PRODUTOR ------------");
IDestination dest = _sessao.GetQueue(FILA);
using (IMessageProducer producer = _sessao.CreateProducer(dest))
{
for (int i = 1; i < 101; i++)
{
Thread.Sleep(100);
var mensagem = new Mensagem
{
Message = $"Mensagem {i}",
};
var objectMessage = producer.CreateObjectMessage(JsonConvert.SerializeObject(mensagem));
producer.Send(objectMessage);
Console.WriteLine($"{Thread.CurrentThread.Name} - Escrevendo na {FILA} => '{mensagem.Message}'");
}
}
}
catch (Exception ex)
{
throw ex;
}
}
static void Main(string[] args)
{
// initialize connection to active mq with producer and consumer
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
IConnection connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession();
IDestination destRequestQueue = session.GetQueue(HashFinderConfig.RequestQueueName);
IMessageProducer producer = session.CreateProducer(destRequestQueue);
IDestination destResponseQueue = session.GetQueue(HashFinderConfig.ResponseQueueName);
IMessageConsumer consumer = session.CreateConsumer(destResponseQueue);
// ------------------------------------------------------------------------------------------------------------
// calculate a hash to find based on user input
PrintTimestamp();
Console.Write("Please enter your pin: ");
var myPin = Console.ReadLine();
PrintTimestamp();
var hash = PinUtil.GetPinHash(myPin);
PrintTimestamp();
Console.WriteLine();
Console.WriteLine("Your hash is: " + hash);
// ------------------------------------------------------------------------------------------------------------
// send workers their work to do
for (int i = 0; i <= 9999; i++)
{
var objectMessage = producer.CreateObjectMessage(
new HashFinderRequest()
{
PinToCalculate = i.ToString("0000"),
HashToFind = hash
});
producer.Send(objectMessage);
}
PrintTimestamp();
// ------------------------------------------------------------------------------------------------------------
IMessage message;
if ((message = consumer.Receive(TimeSpan.FromMinutes(2))) != null)
{
var objectMessage = message as IObjectMessage;
var mapMessage = objectMessage?.Body as HashFinderResponse;
Console.WriteLine("Successfully found pin by worker: " + (mapMessage?.FoundPin ?? "<invalid pin>"));
PrintTimestamp();
}
PrintTimestamp();
Console.WriteLine("... processing finished");
}
static void Main(string[] args)
{
// init connection to activeMQ
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
((ConnectionFactory)factory).PrefetchPolicy.SetAll(0);
IConnection connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession();
IDestination requestDestination = session.GetQueue(HashFinderConfig.RequestQueueName);
IMessageConsumer consumer = session.CreateConsumer(requestDestination);
IDestination responseDestination = session.GetQueue(HashFinderConfig.ResponseQueueName);
IMessageProducer producer = session.CreateProducer(responseDestination);
// -----------------------------------------------------------------------------------------------
// read worker-messages
IMessage message;
while ((message = consumer.Receive(TimeSpan.FromMinutes(1))) != null)
{
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
if (objectMessage?.Body is RequestMessage mapMessage)
{
// debug output
Console.WriteLine(mapMessage.PinToCalculate);
// analyze pin
if (PinUtil.GetMD5Hash(mapMessage.PinToCalculate) == mapMessage.ResultHash)
{
// pin found!
Console.WriteLine(
$"yeaaah found the hash {mapMessage.PinToCalculate} - {mapMessage.ResultHash}");
producer.Send(producer.CreateObjectMessage(
new ResponseMessage()
{
ResultPin = mapMessage.PinToCalculate,
ResultHash = mapMessage.ResultHash
}));
break;
}
}
}
while (consumer.Receive(TimeSpan.FromSeconds(1)) != null)
{
}
Console.WriteLine("... processing finished");
Console.WriteLine("Press enter to continue...");
Console.ReadLine();
}
static void Main(string[] args)
{
// initialize connection
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
((ConnectionFactory)factory).PrefetchPolicy.SetAll(0);
IConnection connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession();
IDestination destRequestQueue = session.GetQueue(HashFinderConfig.RequestQueueName);
IMessageConsumer consumer = session.CreateConsumer(destRequestQueue);
IDestination destResponseQueue = session.GetQueue(HashFinderConfig.ResponseQueueName);
IMessageProducer producer = session.CreateProducer(destResponseQueue);
// ------------------------------------------------------------------------------------------------------------
// receive packages
IMessage message;
while ((message = consumer.Receive(TimeSpan.FromMinutes(1))) != null)
{
var objectMessage = message as IObjectMessage;
var mapMessage = objectMessage?.Body as HashFinderRequest;
// analyze packages
if (PinUtil.GetPinHash(mapMessage?.PinToCalculate) == (mapMessage?.HashToFind ?? "invalid hash"))
{
// successfully found hash
Console.WriteLine("hash found for pin " + (mapMessage.PinToCalculate ?? "<invalid>"));
// answer to response queue
producer.Send(
producer.CreateObjectMessage(new HashFinderResponse()
{
FoundPin = mapMessage.PinToCalculate,
HashToFind = mapMessage?.HashToFind
}));
break;
}
}
// clean queue, so that in the next start of this service we don't need to bother with old data
while (consumer.Receive(TimeSpan.FromSeconds(1)) != null)
{
// clean request queue
}
// ------------------------------------------------------------------------------------------------------------
// keep window open, so we can see the std-out (and check if the pin to find is right)
Console.WriteLine("... processing finished");
Console.WriteLine("press enter to stop");
Console.ReadLine();
}
public void CallSendGuess(string username, int guess)
{
// producer bound to specific Queue (=Destination) sends a message
_callSendGuessProducer.Send(
_callSendGuessProducer.CreateObjectMessage(
new SendGuessMessage()
{
Username = username, Guess = guess
}));
}
public async Task CallGenerateNewNumber()
{
if (_generateNewNumberProducer == null)
{
_generateNewNumberDestination = _session.GetQueue("GenerateNewNumberQueue");
_generateNewNumberProducer = _session.CreateProducer(_generateNewNumberDestination);
}
_generateNewNumberProducer.Send(
_generateNewNumberProducer.CreateObjectMessage(
new GenerateNumberMessage()));
}
public async Task CallSendGuess(string username, int guess)
{
if (_sendGuessProducer == null)
{
_sendGuessDestination = _session.GetQueue("SendGuessQueue");
_sendGuessProducer = _session.CreateProducer(_sendGuessDestination);
}
_sendGuessProducer.Send(
_sendGuessProducer.CreateObjectMessage(
new SendGuessMessage(username, guess)));
}
private void SendMessage()
{
//创建临时目的地，它们的存在时间只限于创建它们的连接所保持的时间
//只有创建该临时目的地的连接上的消息消费者才能够从临时目的地中提取消息
//ITemporaryQueue queue = m_session.CreateTemporaryQueue();
IQueue queue = m_session.GetQueue("test_Queue");
m_producer = m_session.CreateProducer(queue);
//TextMessage消息类型, 普通文本消息
ITextMessage textMessage = m_producer.CreateTextMessage();
textMessage.Text = this.txtBox_消息.Text;
//MapMessafe消息类型, Map集合消息
IMapMessage mapMessage = m_producer.CreateMapMessage();
m_producer.Send(mapMessage);
//ObjectMessage消息类型, 发送序列化对象
Queue <string> obj = new Queue <string>();
obj.Enqueue("one");
obj.Enqueue("two");
IObjectMessage objectMessage = m_producer.CreateObjectMessage(obj);
m_producer.Send(objectMessage);
//BytesMessage消息类型， 发送字节消息
IBytesMessage bytesMessage = m_producer.CreateBytesMessage();
bytesMessage.WriteBytes(System.Text.Encoding.Default.GetBytes("字节"));
m_producer.Send(bytesMessage);
//其它消息类型大同小异
//设置是否持久化
//m_producer.DeliveryMode= MsgDeliveryMode.Persistent;
//设置优先级 默认 MsgPriority.BelowNormal 4级
//m_producer.Priority = MsgPriority.BelowNormal;
//设置过期时间，5秒后 只有Queue点对点有效
//m_producer.TimeToLive=new TimeSpan(1000*5);
//发送超时时间，默认等于0，如果设置超时，则所有的消息都是用同步发送
//m_producer.RequestTimeout = new TimeSpan(1000*20);
}
public static IMessage CreateMessage(this TransferProtocol protocol, IMessageProducer messageProducer, object msg)
{
switch (protocol)
{
case TransferProtocol.Binary:
return(messageProducer.CreateObjectMessage(msg));
case TransferProtocol.Json:
return(messageProducer.CreateTextMessage(msg is string s ? s : JsonConvert.SerializeObject(msg)));
default:
throw new NotSupportedException($"{typeof(TransferProtocol).FullName}.{protocol.ToString()}");
}
}
static void Main(string[] args)
{
Console.Write("enter a number> ");
var rawInput = Console.ReadLine();
int secret = int.Parse(rawInput);
using (MD5 md5Hash = MD5.Create())
{
var hashedSecret = GetMd5Hash(md5Hash, secret.ToString());
Console.WriteLine(hashedSecret);
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
using IConnection connection = factory.CreateConnection();
connection.Start();
using ISession session = connection.CreateSession();
using IDestination destination = session.GetQueue("KAW.MD5Hasher");
using IMessageProducer producer = session.CreateProducer(destination);
for (int messageNr = 0; messageNr < 20; messageNr++)
{
IMessage message = producer.CreateObjectMessage(new HFMessage()
{
Start = messageNr * 100000000,
End = ((messageNr + 1) * 100000000) - 1,
HashedSecret = hashedSecret,
});
producer.Send(message);
}
producer.Close();
session.Close();
connection.Close();
/*
* for (int guess = 0; guess < int.MaxValue; guess++)
* {
* string hashedGuess = GetMd5Hash(md5Hash, guess.ToString());
*
* if (hashedGuess == hashedSecret)
* {
* Console.WriteLine($"found secret: {guess} with hash {hashedGuess}");
* break;
* }
* }*/
}
}
/// <summary>
/// The send object.
/// </summary>
/// <param name="session">
/// The session.
/// </param>
/// <param name="t">
/// The t.
/// </param>
/// <typeparam name="T">
/// </typeparam>
private static void SendObject <T>(ISession session, T t, string queueName)
{
//4.消息的目的地：destination
IDestination dest = session.GetQueue(queueName);
log.DebugFormat("ActiveMQ创建: {0}", dest.ToString());
//5.创建用于发送消息的对象(设置其持久模式)
using (IMessageProducer producer = session.CreateProducer(dest))
{
log.DebugFormat("ActiveMQ创建: {0}", producer.ToString());
var objectMessage = producer.CreateObjectMessage(t);
producer.Send(objectMessage);
log.DebugFormat("ActiveMQ已发送: {0}", objectMessage.ToString());
}
}
public Task EnqueueAsync <T>(T message, CancellationToken cancellationToken) where T : class, Options.IMessage
{
if (!IsConnected)
{
TryConnect();
}
using (var channel = _connection.CreateSession())
{
IDestination dest = channel.GetQueue(message.QName);
using (IMessageProducer producer = channel.CreateProducer(dest))
{
producer.DeliveryMode = MsgDeliveryMode.Persistent;
string json = JsonConvert.SerializeObject(message, Formatting.Indented);
var txtMessage = channel.CreateTextMessage(json);
var objectMessage = producer.CreateObjectMessage(json);
producer.Send(txtMessage);
}
}
return(Task.CompletedTask);
}
/// <summary>
/// 生产,入队列
/// </summary>
/// <param name="entity">对象</param>
/// <param name="delay">延迟时间,单位毫秒</param>
public void EnqueueObject(object entity, long delay)
{
if (producer == null)
{
if (sessionArray.Count == 0)
{
throw new Exception("队列服务尚未启动,请使用Start()方法.");
}
ISession session = sessionArray[0] as ISession;
producer = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue(queueName));
}
IObjectMessage msg = producer.CreateObjectMessage(entity);
if (delay > 0)
{
msg.Properties["AMQ_SCHEDULED_DELAY"] = delay;
}
producer.Send(msg, Apache.NMS.MsgDeliveryMode.Persistent, Apache.NMS.MsgPriority.Normal, TimeSpan.MinValue);
//msg.Acknowledge();//不需要??
}
public static void SendObj(object body, string filter)
{
try
{
IConnectionFactory factory = new ConnectionFactory("failover:(tcp://192.168.100.199:61616,tcp://192.168.100.199:61617,tcp://192.168.100.199:61618)?randomize=false");
using (IConnection connection = factory.CreateConnection())
{
using (ISession session = connection.CreateSession())
{
IMessageProducer prod = session.CreateProducer(new Apache.NMS.ActiveMQ.Commands.ActiveMQQueue("njbosaQueue"));
IObjectMessage message = prod.CreateObjectMessage(body);
//message.Body = body;
message.Properties.SetString("filter", filter);
prod.Send(message, MsgDeliveryMode.NonPersistent, MsgPriority.Normal, TimeSpan.MinValue);
}
}
}
catch (ThreadAbortException)
{
return;
}
}
public string CallCalculateWinner()
{
// producer bound to specific Queue (=Destination) sends a message
_callCalcWinnerRequestProducer.Send(
_callCalcWinnerRequestProducer.CreateObjectMessage(
new CalcWinnerRequestMessage()));
// our internal protocol defines that after this request a response will be sent
// so wait for 1min to receive this message which consists the winner-string
IMessage message;
while ((message = _callCalcWinnerResponseConsumer.Receive(TimeSpan.FromMinutes(1))) != null)
{
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
if (objectMessage?.Body is CalcWinnerResponseMessage responseMessage)
{
return(responseMessage.Text);
}
}
return("Error in communication");
}
static async Task Main(string[] args)
{
var logFactory = new LoggerFactory();
var logger = logFactory.CreateLogger <Program>();
Uri connecturi = new Uri("activemq:tcp://localhost:61616");
logger.LogInformation($"about to connect to {connecturi}");
var factory = new Apache.NMS.ActiveMQ.ConnectionFactory(connecturi);
var _connection = factory.CreateConnection();
_connection.Start();
logger.LogInformation($"connected to {factory.BrokerUri}");
var _session = _connection.CreateSession();
var dest = SessionUtil.GetDestination(_session, "test-q1");
using (IMessageProducer producer = _session.CreateProducer(dest))
{
var cnt = 1;
while (cnt <= 10)
{
var message = new
{
Id = Guid.NewGuid(),
Name = $"Book {cnt}"
};
var objectMessage = producer.CreateObjectMessage(System.Text.Json.JsonSerializer.Serialize(message));
Thread.Sleep(1000);
producer.Send(objectMessage);
cnt++;
logger.LogInformation($"sent the message {message.Name}");
}
}
}
static void Main(string[] args)
{
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
IConnection connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession();
IDestination dest = session.GetQueue("KAW.Seti");
IMessageProducer producer = session.CreateProducer(dest);
var lines = File.ReadAllLines("spacemap.txt");
foreach (var line in lines)
{
var objectMessage = producer.CreateObjectMessage(new SETIMessage()
{
Content = line
});
producer.Send(objectMessage);
}
Console.WriteLine("... processing finished");
}
/// <summary>
/// The send object.
/// </summary>
/// <param name="session">
/// The session.
/// </param>
/// <param name="t">
/// The t.
/// </param>
/// <typeparam name="T">
/// </typeparam>
private static void SendObject <T>(ISession session, T t, string queueName, string selector)
{
//4.消息的目的地：destination
IDestination dest = session.GetQueue(queueName);
log.DebugFormat("ActiveMQ创建: {0}", dest.ToString());
//5.创建用于发送消息的对象(设置其持久模式)
using (IMessageProducer producer = session.CreateProducer(dest))
{
log.DebugFormat("ActiveMQ创建: {0}", producer.ToString());
var objectMessage = producer.CreateObjectMessage(t);
if (!string.IsNullOrEmpty(selector))
{
var arr = selector.Split('=');
if (!arr.IsNullOrEmpty() && arr.Length == 2)
{
objectMessage.Properties.SetString(arr[0], arr[1].Replace("'", "").Replace("'", ""));
}
}
producer.Send(objectMessage);
log.DebugFormat("ActiveMQ已发送: {0}", objectMessage.ToString());
}
}
static void Main(string[] args)
{
// init connection to activeMQ
IConnectionFactory factory = new ConnectionFactory("tcp://localhost:61616");
((ConnectionFactory)factory).PrefetchPolicy.SetAll(0);
IConnection connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession();
Task generateNewNumberTask = Task.Run(() =>
{
IDestination generateNewNumberDestination = session.GetQueue("GenerateNewNumberQueue");
IMessageConsumer generateNewNumberConsumer = session.CreateConsumer(generateNewNumberDestination);
IMessage message;
while ((message = generateNewNumberConsumer.Receive(TimeSpan.FromMinutes(60))) != null)
{
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
// TODO: rename to GenerateNewNumberMessage
if (objectMessage?.Body is GenerateNumberMessage generateNewNumberMessage)
{
GenerateNewNumber();
Console.WriteLine(_secretNumber.ToString());
}
}
});
Task sendGuessTask = Task.Run(() =>
{
IDestination sendGuessDestination = session.GetQueue("SendGuessQueue");
IMessageConsumer sendGuessConsumer = session.CreateConsumer(sendGuessDestination);
IMessage message;
while ((message = sendGuessConsumer.Receive(TimeSpan.FromMinutes(60))) != null)
{
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
if (objectMessage?.Body is SendGuessMessage sendGuessMessage)
{
AddGuess(sendGuessMessage.Username, sendGuessMessage.Guess);
Console.WriteLine($"{sendGuessMessage.Username} - {sendGuessMessage.Guess}");
}
}
});
Task requestWinnerCalculationTask = Task.Run(() =>
{
IDestination requestWinnerCalculationDestination = session.GetQueue("RequestWinnerCalculationQueue");
IMessageConsumer requestWinnerCalculationConsumer = session.CreateConsumer(requestWinnerCalculationDestination);
IDestination responseWinnerCalculationDestination = session.GetQueue("ResponseWinnerCalculationQueue");
IMessageProducer responseWinnerCalculationProducer = session.CreateProducer(responseWinnerCalculationDestination);
IMessage message;
while ((message = requestWinnerCalculationConsumer.Receive(TimeSpan.FromMinutes(60))) != null)
{
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
if (objectMessage?.Body is RequestWinnerCalculation)
{
var winnerText = CalculateWinner();
responseWinnerCalculationProducer.Send(
responseWinnerCalculationProducer.CreateObjectMessage(
new ResponseWinnerCalculation()
{
Text = winnerText
}));
Console.WriteLine(winnerText);
}
}
});
Task.WaitAll(generateNewNumberTask, sendGuessTask);
}
static void Main(string[] args)
{
// connect to activeMQ
IConnectionFactory factory = new ConnectionFactory(HashFinderConfig.ActiveMQEndpoint);
IConnection connection = factory.CreateConnection();
connection.Start();
ISession session = connection.CreateSession();
IDestination requestDestination = session.GetQueue(HashFinderConfig.RequestQueueName);
IMessageProducer producer = session.CreateProducer(requestDestination);
IDestination responseDestination = session.GetQueue(HashFinderConfig.ResponseQueueName);
IMessageConsumer consumer = session.CreateConsumer(responseDestination);
// -----------------------------------------------------------------------------------------------
// handle UI input and calculate Hash
Console.Write("Please enter your pin: ");
var pin = Console.ReadLine();
var hashedPin = PinUtil.GetMD5Hash(pin);
Console.WriteLine();
Console.WriteLine("your hash is: " + hashedPin);
// -----------------------------------------------------------------------------------------------
var itemFound = false;
Task t = Task.Run(() =>
{
// create messages for workers
for (int i = 0; i <= 9999 && !itemFound; i++)
{
var objectMessage = producer.CreateObjectMessage(
new RequestMessage()
{
PinToCalculate = i.ToString("0000"),
ResultHash = hashedPin,
});
producer.Send(objectMessage);
}
});
// -----------------------------------------------------------------------------------------------
// read worker-responses
IMessage message;
if ((message = consumer.Receive(TimeSpan.FromMinutes(1))) != null)
{
itemFound = true;
// map message body to our strongly typed message type
var objectMessage = message as IObjectMessage;
var mapMessage = objectMessage?.Body as ResponseMessage;
Console.WriteLine($"pin is: {mapMessage.ResultPin} ({mapMessage.ResultHash})");
}
Task.WaitAll(new[] { t });
// final UI candy
Console.WriteLine("... processing finished");
Console.WriteLine("Press enter to continue...");
Console.ReadLine();
}
/// <summary>
/// Creates the object message.
/// </summary>
/// <param name="body">The body.</param>
/// <returns>A new object message with the given body.</returns>
public IObjectMessage CreateObjectMessage(object body)
{
return(target.CreateObjectMessage(body));
}
public IObjectMessage CreateObjectMessage(object body)
{
Used?.Invoke();
return(_producer.CreateObjectMessage(body));
}
