public void StartMessageListener()
{
_channel.QueueDeclare(queue: _rabbitMqOptions.NameMessageQueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
_channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var strMessage = Encoding.UTF8.GetString(body);
NameMessage nameMessage = JsonConvert.DeserializeObject <NameMessage>(strMessage);
if (nameMessage != null && _messageValidatorService.IsValidMessage(nameMessage.Message))
{
Console.WriteLine($"Hello {nameMessage.Message.Split(", ")[1]}, I am your receiver!");
}
else
{
Console.WriteLine("Invalid Message.");
}
};
_channel.BasicConsume(queue: _rabbitMqOptions.NameMessageQueueName, autoAck: true, consumer: consumer);
}
private void __OnRoom(NetworkMessage message)
{
NetworkConnection connection = message == null ? null : message.conn;
if (connection == null)
{
return;
}
NameMessage nameMessage = message.ReadMessage <NameMessage>();
if (nameMessage == null)
{
return;
}
Room room;
if (__roomMap == null || !__roomMap.TryGetValue(nameMessage.name, out room) || room == null)
{
SendErrorMessage(connection.connectionId, MahjongErrorType.RoomNone);
}
else
{
if (GetCount(room.index) < 4)
{
Send(connection.connectionId, (short)MahjongNetworkMessageType.Room, new NameMessage(nameMessage.name));
}
else
{
SendErrorMessage(connection.connectionId, MahjongErrorType.RoomFull);
}
}
}
void SendNameMessage(string name)
{
var nameMessage = new NameMessage();
nameMessage.name = name;
client.Send(NetworkMessages.Name, nameMessage);
}
public void MessageService_PublishMessage_When_Have_Invalid_Input_Throws_Exception()
{
NameMessage nameMessage = null;
_rabbitMqServiceMock.Setup(s => s.PublishMessage(It.IsAny <string>()));
var messageService = new MessageService(_rabbitMqServiceMock.Object);
messageService.SendMessage(nameMessage);
}
public override void OnClientConnect(NetworkConnection conn)
{
//base.OnClientConnect(conn);
Debug.Log("Connected successfully to server, now to set up other stuff for the client...");
NameMessage msg = new NameMessage();
msg.name = GameObject.Find("PlayerProfile").GetComponent <playerProfile>().pname;
myClient.Send(MyMsgType.Name, msg);
ClientScene.Ready(conn);
ClientScene.AddPlayer(conn, 0);
}
public void UpdateName(string name)
{
if (IsConnected())
{
// update local player.
players[serverAssignedId].SetName(name);
var nameMessage = new NameMessage();
nameMessage.name = name;
client.Send(CustomNetMsg.Name, nameMessage);
}
}
public void MessageService_PublishMessage_When_Have_Valid_Input_Executes_Successfully()
{
var nameMessage = new NameMessage
{
Message = "Valid"
};
_rabbitMqServiceMock.Setup(s => s.PublishMessage(It.IsAny <string>()));
var messageService = new MessageService(_rabbitMqServiceMock.Object);
messageService.SendMessage(nameMessage);
}
void OnServerGotName(NetworkMessage netMsg)
{
var msg = netMsg.ReadMessage <NameMessage>();
players[netMsg.conn.connectionId].name = msg.name;
dWin.Text(GetPlayerStats());
// broadcast
var nameMessage = new NameMessage();
nameMessage.id = netMsg.conn.connectionId;
nameMessage.name = msg.name;
NetworkServer.SendToAll(NetworkMessages.Name, nameMessage);
}
public void SendMessage(INameMessage nameMessage)
{
if (nameMessage == null)
{
throw new ArgumentNullException(nameof(nameMessage));
}
var objNameMessage = new NameMessage
{
Message = nameMessage.Message
};
var serializedMessage = JsonConvert.SerializeObject(objNameMessage);
_rabbitMqService.CreateConnection();
_rabbitMqService.PublishMessage(serializedMessage);
_rabbitMqService.CloseConnection();
}
void GotName(NetworkMessage netMsg)
{
var msg = netMsg.ReadMessage <NameMessage>();
players[netMsg.conn.connectionId].SetName(msg.name);
if (lobbyGui != null)
{
lobbyGui.UpdateUI(players);
}
// broadcast
var nameMessage = new NameMessage();
nameMessage.id = netMsg.conn.connectionId;
nameMessage.name = msg.name;
NetworkServer.SendToAll(CustomNetMsg.Name, nameMessage);
}
private void __OnPlayer(NetworkMessage message)
{
if (__client != null)
{
__client.UnregisterHandler((short)MahjongNetworkMessageType.Player);
}
NameMessage nameMessage = message == null ? null : message.ReadMessage <NameMessage>();
if (nameMessage == null)
{
return;
}
if (string.IsNullOrEmpty(nameMessage.name))
{
if (__nameMessage == null && __roomMessage == null)
{
__coroutine = StartCoroutine(__LoadScene(menuSceneBuildIndex, null, __coroutine));
}
else if (__client != null)
{
if (__nameMessage != null)
{
__client.RegisterHandler((short)MahjongNetworkMessageType.Room, __OnRoom);
__client.Send((short)MahjongNetworkMessageType.Room, __nameMessage);
__nameMessage = null;
__roomMessage = null;
}
else if (__roomMessage != null)
{
__client.RegisterHandler((short)MahjongNetworkMessageType.Room, __OnRoom);
__client.Send((short)MahjongNetworkMessageType.Create, __roomMessage);
__roomMessage = null;
}
}
}
else
{
JoinRoom(nameMessage.name);
}
}
public static void Main(string[] args)
{
String user = "******";
Channel channel = new Channel(StackBadgerServerAddress, ChannelCredentials.Insecure);
var cakeDistributer = new CakeDistributer.CakeDistributerClient(channel);
NameMessage message = new NameMessage {
Name = user
};
var reply = cakeDistributer.HowMuchCake(message);
Console.WriteLine(reply.Message);
// Console.WriteLine(reply.NumberOfPiecesOfCakeYouOweMark);
channel.ShutdownAsync().Wait();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public void CommandIsProperlySentThrough(string destQueue, string message)
{
// arrange
using var context = new RabbitMqContextBuilder()
.WithConnectionString("amqp://*****:*****@localhost")
.WithExchange("HelloExchange")
.CreateContext();
using var receiver = context.CreateCommandReceiver(destQueue);
receiver.DeclareCommandQueue();
var sender = context.CreateCommandSender();
var nameObject = new NameMessage(message);
var command = new CommandMessage
{
DestinationQueue = destQueue,
Timestamp = 294859,
CorrelationId = Guid.NewGuid(),
ReplyQueue = "ReplyQueue",
Body = Encoding.Unicode.GetBytes(JsonConvert.SerializeObject(nameObject))
};
// Act
receiver.StartReceivingCommands(commandMessage =>
{
NameMessage name = JsonConvert.DeserializeObject <NameMessage>(Encoding.Unicode.GetString(commandMessage.Body));
return(new CommandMessage
{
CorrelationId = commandMessage.CorrelationId,
Timestamp = commandMessage.Timestamp,
Body = Encoding.Unicode.GetBytes($"Hallo {name.Name}")
});
});
var result = sender.SendCommandAsync(command);
// Assert
var stringResult = Encoding.Unicode.GetString(result.Result.Body);
Assert.AreEqual($"Hallo {message}", stringResult);
}
public void RabbitMqService_PublishMessage_When_Have_Valid_Message_Sends_To_RabbitMq()
{
_rabbitMqOptionsMock.Object.HostName = "localhost";
_rabbitMqOptionsMock.Object.NameMessageExchangeName = "AppName.Service.NameMessageExchange";
_rabbitMqOptionsMock.Object.NameMessageQueueName = "AppName.Service.NameMessageQueue";
_rabbitMqOptionsMock.Object.JsonMimeType = "application/json";
var objNameMessage = new NameMessage
{
Message = "Name"
};
var serializedMessage = JsonConvert.SerializeObject(objNameMessage);
var rabbitMqService = new RabbitMqService(_rabbitMqOptionsMock.Object);
rabbitMqService.CreateConnection();
rabbitMqService.PublishMessage(serializedMessage);
}
private void __OnRoom(NetworkMessage message)
{
__client.UnregisterHandler((short)MahjongNetworkMessageType.Room);
NameMessage nameMessage = message == null ? null : message.ReadMessage <NameMessage>();
__coroutine = StartCoroutine(__LoadScene(roomSceneBuildIndex, delegate()
{
MahjongClientRoom room = __InitRoom();
if (room != null)
{
if (room.name != null)
{
room.name.text = nameMessage.name;
}
}
__client.onRegistered += __OnRegistered;
__client.Register(new RegisterMessage(__uid, nameMessage.name));
}, __coroutine));
}
public void JoinRoom(string name)
{
if (__client == null)
{
return;
}
if (__client.isConnected)
{
__client.RegisterHandler((short)MahjongNetworkMessageType.Room, __OnRoom);
__client.Send((short)MahjongNetworkMessageType.Room, new NameMessage(name));
__nameMessage = null;
}
else if (__nameMessage == null && __roomMessage == null)
{
__nameMessage = new NameMessage(name);
Create();
}
}
private void __OnPlayer(NetworkMessage message)
{
NetworkConnection connection = message == null ? null : message.conn;
if (connection == null)
{
return;
}
NameMessage nameMessage = message.ReadMessage <NameMessage>();
if (nameMessage == null)
{
return;
}
int connectionId = connection.connectionId;
string roomName;
Player player;
if (__playerMap != null && __playerMap.TryGetValue(nameMessage.name, out player))
{
roomName = player.roomName;
if (__roomMap != null)
{
Room room;
if (__roomMap.TryGetValue(roomName, out room) && room != null && room.isRunning)
{
SendShuffleMessage(connectionId, (byte)room.point0, (byte)room.point1, (byte)room.point2, (byte)room.point3, ((byte)room.tileCount));
}
}
}
else
{
roomName = string.Empty;
}
Send(connectionId, (short)MahjongNetworkMessageType.Player, new NameMessage(roomName));
}
public void OnReceiveName(NetworkMessage netMsg)
{
NameMessage msg = netMsg.ReadMessage <NameMessage>();
if (GameObject.Find("OnlineUsersRecord"))
{
Debug.Log("Record found.");
}
else
{
Debug.Log("Record not found.");
}
if (GameObject.Find("PlayerProfile"))
{
Debug.Log("PlayerProfile found.");
}
else
{
Debug.Log("PlayerProfile not found.");
}
GameObject.Find("OnlineUsersRecord").GetComponent <OnlineUsersTable>().AddUser(msg.name, netMsg.conn.connectionId);
}
public void A_plain_message_should_find_the_correct_saga_using_a_property()
{
NameMessage name = new NameMessage { Name = "Joe" };
//new PropertySagaMessageSink<TestSaga,NameMessage>(context, bus, _repository, new ExistingSagaPolicy<TestSaga, NameMessage>());
// bool found = locator.TryGetSagaForMessage(name, out saga);
//Assert.IsTrue(found);
// using (saga)
{
// Assert.IsNotNull(saga);
// Assert.IsNotNull(saga.Instance);
// Assert.AreEqual(_sagaId, saga.Instance.CorrelationId);
}
}
public void A_plain_message_with_an_unknown_relationship_should_not_find_it()
{
NameMessage name = new NameMessage { Name = "Tom" };
// ISagaLocator<TestSaga, NameMessage> locator =
//// new PropertySagaLocator<TestSaga, NameMessage>(_repository, new ExistingSagaPolicy<TestSaga, NameMessage>(),
// (s, m) => s.Name == m.Name);
// InstanceScope<TestSaga> saga;
// bool found = locator.TryGetSagaForMessage(name, out saga);
// Assert.IsFalse(found);
// Assert.IsNull(saga);
}
