public async Task UpdateAsync(NetworkEndpoint item)
{
validator.Validate(item);
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var old = await cn.QueryFirstOrDefaultAsync <NetworkEndpointRecord>(
queryUpdate,
new
{
id = item.Id,
name = item.Name,
address = item.Address.AbsoluteUri,
issuer = item.Issuer,
keyid = item.KeyId,
certificate = item.Certificate
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure);
log.LogInformation("Updated NetworkEndpoint. Old:{@Old} New:{@New}", old, item);
}
}
// TODO(cspital) migrate to future admin service
public async Task <UpdateResult <NetworkEndpoint> > UpdateAsync(NetworkEndpoint item)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var old = await cn.QueryFirstOrDefaultAsync <NetworkEndpointRecord>(
queryUpdate,
new
{
id = item.Id,
name = item.Name,
address = item.Address.AbsoluteUri,
issuer = item.Issuer,
keyid = item.KeyId,
certificate = item.Certificate
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure);
return(new UpdateResult <NetworkEndpoint>
{
Old = old.NetworkEndpoint(),
New = item
});
}
}
public async Task <NetworkEndpoint> CreateEndpointAsync(NetworkEndpoint e)
{
Ensure.NotNull(e, nameof(e));
Ensure.NotNullOrWhitespace(e.Name, nameof(e.Name));
validator.Validate(e);
Ensure.NotNullOrWhitespace(e.Issuer, nameof(e.Issuer));
Ensure.NotNullOrWhitespace(e.KeyId, nameof(e.KeyId));
Ensure.NotNull(e.Certificate, nameof(e.Certificate));
try
{
var created = await updater.CreateEndpointAsync(e);
log.LogInformation("Created NetworkEndpoint. Endpoint:{@Endpoint}", new { e.Id, e.Name, e.Issuer, e.KeyId, e.IsInterrogator, e.IsResponder });
return(created);
}
catch (DbException de)
{
log.LogError("Failed to create NetworkEndpoint. Endpoint:{@Endpoint} Code:{Code} Error:{Error}",
new { e.Name, e.Issuer, e.KeyId, e.IsInterrogator, e.IsResponder },
de.ErrorCode, de.Message);
de.MapThrow();
throw;
}
}
public async Task <NetworkEndpoint> CreateEndpointAsync(NetworkEndpoint endpoint)
{
var record = new NetworkEndpointRecord(endpoint);
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
var inserted = await cn.QueryFirstAsync <NetworkEndpointRecord>(
Sql.CreateEndpoint,
new
{
name = record.Name,
addr = record.Address,
iss = record.Issuer,
kid = record.KeyId,
cert = record.Certificate,
isInterrogator = record.IsInterrogator,
isResponder = record.IsResponder,
user = user.UUID
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure);
return(inserted.NetworkEndpoint());
}
}
private void HandleCreateRoomRequest(NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
if (!fromPlayer.IsInLobby)
{
return;
}
var roomOptions = new RoomOptions();
roomOptions.Read(receivedMessage);
var createResponse = this.CreateServerMessage(ClientIncomingMessageTypes.CreateResponse);
if (this.lobbyRooms.ContainsKey(roomOptions.RoomName))
{
createResponse.Write(EnterRoomResultCodes.RoomAlreadyExists);
}
else
{
this.CreateRoom(roomOptions, fromPlayer);
createResponse.Write(EnterRoomResultCodes.Succeed);
}
this.SendToPlayer(createResponse, fromPlayer);
}
public async Task <NetworkEndpoint> Refresh(NetworkEndpoint ne)
{
var req = new HttpRequestMessage
{
RequestUri = new Uri(ne.Address, "/api/network/certificate"),
Method = HttpMethod.Get
};
var resp = await client.SendAsync(req);
resp.EnsureSuccessStatusCode();
var body = await resp.Content.ReadAsStringAsync();
var cert = JsonConvert.DeserializeObject <Certificate>(body);
return(new NetworkEndpoint
{
Id = ne.Id,
Name = ne.Name,
Address = ne.Address,
Issuer = ne.Issuer,
KeyId = cert.KeyId,
Certificate = Convert.FromBase64String(cert.Data)
});
}
private void HandleSetPlayerProperties(NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
if (fromPlayer != null)
{
OutgoingMessage refreshPlayerPropsMsg = null;
if (fromPlayer.Room != null)
{
// Send to players in the same room
refreshPlayerPropsMsg = this.CreateServerMessage(ClientIncomingMessageTypes.RefreshOtherPlayerProperties);
refreshPlayerPropsMsg.Write(fromPlayer.Id);
refreshPlayerPropsMsg.Write(receivedMessage);
}
fromPlayer.ReadFromMessage(receivedMessage);
if (refreshPlayerPropsMsg != null)
{
var otherPlayersInRoom = this.GetOtherPlayersInRoom(fromPlayer);
this.SendToPlayers(refreshPlayerPropsMsg, otherPlayersInRoom);
}
this.PlayerSynchronized?.Invoke(this, fromPlayer);
}
}
/// <summary>
/// Connects the client to the specified server endpoint asynchronously.
/// </summary>
/// <param name="server">The server endpoint.</param>
/// <returns>An a value indicating if the connection was succeed or not</returns>
private async Task <bool> InternalConnectAsync(NetworkEndpoint server)
{
bool result = false;
var tcs = new TaskCompletionSource <bool>();
EventHandler <HostConnectedEventArgs> connectHandler = (sender, e) =>
{
var connectedHost = e.HostEndpoint;
if (connectedHost.Address == server.Address && connectedHost.Port == server.Port)
{
tcs.SetResult(true);
}
};
this.networkClient.HostConnected += connectHandler;
try
{
var playerSyncMessage = this.CreateSyncLocalPlayerMessage(true);
this.networkClient.Connect(server, playerSyncMessage);
result = await tcs.Task;
}
finally
{
this.networkClient.HostConnected -= connectHandler;
}
return(result);
}
/// <summary>
/// Looks for a player with the specified endpoint.
/// </summary>
/// <param name="playerEndpoint">The player endpoint.</param>
/// <returns>The <see cref="ServerPlayer"/> if the player can be found; otherwise, null.</returns>
public ServerPlayer FindPlayer(NetworkEndpoint playerEndpoint)
{
ServerPlayer player;
this.connectedPlayers.TryGetValue(playerEndpoint.GetHashCode(), out player);
return(player);
}
public NetworkEndpointRecord(NetworkEndpoint ne)
{
Id = ne.Id;
Name = ne.Name;
Address = ne.Address.AbsoluteUri;
Issuer = ne.Issuer;
KeyId = ne.KeyId;
Certificate = Convert.ToBase64String(ne.Certificate);
}
public void UpdateEndpointAsync_Should_Throw_On_Null_Address()
{
var manager = GetManager(MixedEndpoints);
var update = new NetworkEndpoint {
Id = 4, Name = "Site4", Issuer = "urn:leaf:iss:site4", Address = null, IsResponder = true, IsInterrogator = true
};
Assert.ThrowsAsync <ArgumentNullException>(() => manager.UpdateEndpointAsync(update));
}
/// <summary>
/// Sends a user data message to the matchmaking server.
/// </summary>
/// <param name="messageToSend">The message to be sent.</param>
/// <param name="destinationClient">The destination client endpoint.</param>
/// <param name="deliveryMethod">The delivery method.</param>
public void SendToClient(OutgoingMessage messageToSend, NetworkEndpoint destinationClient, DeliveryMethod deliveryMethod)
{
this.CheckServerIsStarted();
var userDataMsg = this.CreateServerMessage(ClientIncomingMessageTypes.UserDataFromHost);
userDataMsg.Write(messageToSend);
this.networkServer.Send(userDataMsg, deliveryMethod, destinationClient);
}
public void UpdateEndpointAsync_Should_Throw_On_NonHTTPS()
{
var manager = GetManager(MixedEndpoints);
var update = new NetworkEndpoint {
Id = 4, Name = "Site4", Issuer = "urn:leaf:iss:site4", Address = new Uri("http://leaf.site4.tld"), IsResponder = true, IsInterrogator = true
};
Assert.ThrowsAsync <UriFormatException>(() => manager.UpdateEndpointAsync(update));
}
/// <summary>
/// Handles the messages received from the host.
/// </summary>
private void ClientMessageReceived(object sender, NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var playerIdentifier = receivedMessage.ReadString();
var playerSpriteIndex = receivedMessage.ReadInt32();
if (this.networkService.ClientIdentifier == playerIdentifier)
{
this.HandlePlayerSelectionResponse(playerSpriteIndex);
}
}
private void HandleSetRoomProperties(NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
if (fromPlayer != null &&
fromPlayer.Room != null)
{
var playerRoom = fromPlayer.Room;
var previousVisibility = playerRoom.IsVisible;
var refreshRoomPropsMsg = this.CreateServerMessage(ClientIncomingMessageTypes.RefreshCurrentRoomProperties);
refreshRoomPropsMsg.Write(receivedMessage);
playerRoom.ReadFromMessage(receivedMessage);
if (previousVisibility != playerRoom.IsVisible)
{
// Update rooms in lobby to other users
var othersRoomMsg = this.CreateServerMessage(ClientIncomingMessageTypes.RefreshRoomsInLobby);
var refreshLobbyMessage = new RefreshLobbyRoomsMessage();
if (playerRoom.IsVisible)
{
refreshLobbyMessage.IncludedRooms.Add(playerRoom.RoomInfo);
}
else
{
refreshLobbyMessage.RemovedRooms.Add(playerRoom.Name);
}
refreshLobbyMessage.Write(othersRoomMsg);
var lobbyPlayers = this.GetPlayersInLobby();
this.SendToPlayers(othersRoomMsg, lobbyPlayers);
}
if (playerRoom.IsVisible &&
playerRoom.RoomInfo.NeedSync)
{
var othersRoomMsg = this.CreateServerMessage(ClientIncomingMessageTypes.RefreshRoomInLobbyProperties);
othersRoomMsg.Write(playerRoom.RoomInfo.Name);
playerRoom.RoomInfo.WriteSyncMessage(othersRoomMsg);
var lobbyPlayers = this.GetPlayersInLobby();
this.SendToPlayers(othersRoomMsg, lobbyPlayers);
}
// Send room changes to other players
var otherPlayersInRoom = this.GetOtherPlayersInRoom(fromPlayer);
this.SendToPlayers(refreshRoomPropsMsg, otherPlayersInRoom);
this.RoomSynchronized?.Invoke(this, playerRoom);
}
}
public Task <UpdateResult <NetworkEndpoint> > UpdateAsync(NetworkEndpoint endpoint)
{
var old = endpoints[endpoint.Id];
endpoints[endpoint.Id] = endpoint;
return(Task.FromResult(new UpdateResult <NetworkEndpoint>
{
Old = old,
New = endpoint
}));
}
public void UpdateEndpointAsync_Should_Update_HTTPS_Endpoint()
{
var manager = GetManager(MixedEndpoints);
var update = new NetworkEndpoint {
Id = 4, Name = "Site4", Issuer = "urn:leaf:iss:site4", Address = new Uri("https://leaf.site4.tld"), KeyId = "12309123khjg423khj4g", Certificate = new byte[] { }, IsResponder = true, IsInterrogator = true
};
var updated = manager.UpdateEndpointAsync(update).Result;
Assert.Equal(4, update.Id);
Assert.True(updated.IsInterrogator);
}
public NetworkEndpointRecord(NetworkEndpoint ne)
{
Id = ne.Id;
Name = ne.Name;
Address = ne.Address.AbsoluteUri;
Issuer = ne.Issuer;
KeyId = ne.KeyId;
Certificate = Convert.ToBase64String(ne.Certificate);
IsInterrogator = ne.IsInterrogator;
IsResponder = ne.IsResponder;
Created = ne.Created;
Updated = ne.Updated;
}
public void UpdateEndpointAsync_Should_Update_HTTPS_Endpoint()
{
var manager = GetManager(MixedEndpoints);
var update = new NetworkEndpoint {
Id = 4, Name = "Site4", Address = new Uri("https://leaf.site4.tld"), IsResponder = true, IsInterrogator = true
};
var result = manager.UpdateEndpointAsync(update).Result;
Assert.Equal(update.Id, result.Old.Id);
Assert.Equal(update.Address, result.New.Address);
Assert.True(result.New.IsInterrogator);
}
private void HandleUserDataToRoom(NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
if (fromPlayer.Room != null)
{
var userDataMsg = this.CreateServerMessage(ClientIncomingMessageTypes.UserDataFromRoom);
userDataMsg.Write(fromPlayer.Id);
userDataMsg.Write(receivedMessage);
var otherPlayersInRoom = this.GetOtherPlayersInRoom(fromPlayer);
this.SendToPlayers(userDataMsg, otherPlayersInRoom);
}
}
private async void OnConnectToHostClicked(NetworkEndpoint host)
{
try
{
await this.networkService.ConnectAsync(host);
WaveServices.ScreenContextManager.Push(new ScreenContext(new SelectPlayerScene()));
}
catch (Exception exception)
{
this.ShowErrorMenssage(exception);
}
}
private async void OnConnectToServerClicked(NetworkEndpoint host)
{
try
{
await this.matchmakingClientService.ConnectAsync(host);
WaveServices.ScreenContextManager.Push(new ScreenContext(new LoadingScene()));
}
catch (Exception exception)
{
this.ShowErrorMenssage(exception);
}
}
private void HandleLeaveRoomRequest(NetworkEndpoint fromEndpoint)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
var playerRoom = this.RemovePlayerFromRoom(fromPlayer);
var responseMsg = this.CreateServerMessage(ClientIncomingMessageTypes.LeaveResponse);
var refreshLobbyMessage = new RefreshLobbyRoomsMessage();
var lobbyVisibleRoomInfos = this.lobbyRooms.Values.Where(r => r.IsVisible).Select(r => r.RoomInfo);
refreshLobbyMessage.IsAbsolute = true;
refreshLobbyMessage.IncludedRooms.AddRange(lobbyVisibleRoomInfos);
refreshLobbyMessage.Write(responseMsg);
this.SendToPlayer(responseMsg, fromPlayer);
}
/// <summary>
/// Handles the messages received from the clients. Only when this player is the host.
/// </summary>
private void HostMessageReceived(object sender, NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var playerIdentifier = receivedMessage.ReadString();
var playerSpriteIndex = receivedMessage.ReadInt32();
var resultPlayerSpriteIndex = this.AssignPlayerSpriteIndex(playerIdentifier, playerSpriteIndex);
var responseMessage = this.networkService.CreateServerMessage();
responseMessage.Write(playerIdentifier);
responseMessage.Write(resultPlayerSpriteIndex);
this.networkService.SendToClients(responseMessage, DeliveryMethod.ReliableUnordered);
}
private void HandleUserDataToOtherClient(NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
if (fromPlayer.Room != null)
{
var destinationPlayerId = receivedMessage.ReadPlayerId();
var userDataMsg = this.CreateServerMessage(ClientIncomingMessageTypes.UserDataFromOtherClient);
userDataMsg.Write(fromPlayer.Id);
userDataMsg.Write(receivedMessage);
var otherPlayer = fromPlayer.Room.GetPlayer <ServerPlayer>(destinationPlayerId);
this.SendToPlayer(userDataMsg, otherPlayer);
}
}
public async Task <NetworkEndpoint> UpdateEndpointAsync(NetworkEndpoint e)
{
Ensure.NotNull(e, nameof(e));
Ensure.NotNullOrWhitespace(e.Name, nameof(e.Name));
validator.Validate(e);
Ensure.NotNullOrWhitespace(e.Issuer, nameof(e.Issuer));
Ensure.NotNullOrWhitespace(e.KeyId, nameof(e.KeyId));
Ensure.NotNull(e.Certificate, nameof(e.Certificate));
var updated = await updater.UpdateEndpointAsync(e);
cache.Put(updated);
log.LogInformation("Updated NetworkEndpoint. Result:{@Result}", updated);
return(updated);
}
private void OnHostDiscovered(object sender, NetworkEndpoint host)
{
var clientButton = new Button
{
Text = string.Format("Connect to: {0}:{1}", host.Address, host.Port),
Width = 400,
Height = 50,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Top,
Margin = new Thickness(10, 10 + (70 * (this.discoveredHostButtons.Count + 2)), 10, 10)
};
clientButton.Click += (s, e) => this.OnConnectToHostClicked(host);
this.discoveredHostButtons.Add(clientButton.Entity);
this.EntityManager.Add(clientButton);
WaveServices.Layout.PerformLayout(this);
}
public async Task DeleteAsync(NetworkEndpoint item)
{
using (var cn = new SqlConnection(opts.ConnectionString))
{
await cn.OpenAsync();
await cn.ExecuteAsync(
queryDelete,
new
{
id = item.Id
},
commandTimeout : opts.DefaultTimeout,
commandType : CommandType.StoredProcedure
);
log.LogInformation("Deleted NetworkEndpoint. Endpoint:{@Endpoint}", item);
}
}
public static NetworkEndpointDTO NetworkEndpointDTO(this NetworkEndpoint e)
{
if (e == null)
{
return(null);
}
return(new NetworkEndpointDTO
{
Id = e.Id,
Name = e.Name,
Address = e.Address.AbsoluteUri,
Issuer = e.Issuer,
KeyId = e.KeyId,
Certificate = Convert.ToBase64String(e.Certificate),
IsInterrogator = e.IsInterrogator,
IsResponder = e.IsResponder,
Created = e.Created,
Updated = e.Updated
});
}
/// <summary>
/// Connects the client to the specified matchmaking server asynchronously.
/// </summary>
/// <param name="serverEndpoint">The matchmaking server endpoint.</param>
/// <exception cref="InvalidOperationException">
/// You can't call Connect method while is connected to a matchmaking server. Call before to <see cref="Disconnect"/> method.
/// or
/// <see cref="ApplicationIdentifier"/> must have a valid value before trying to connect.
/// </exception>
/// <returns>An a value indicating whether the connection was succeed or not</returns>
public async Task <bool> ConnectAsync(NetworkEndpoint serverEndpoint)
{
if (this.State != ClientStates.Disconnected)
{
throw new InvalidOperationException("You can't call connect method while is connected to a matchmaking server. Call before to disconnect method.");
}
if (string.IsNullOrEmpty(this.ApplicationIdentifier))
{
throw new InvalidOperationException($"{nameof(this.ApplicationIdentifier)} must have a valid value before trying to connect.");
}
var fullIdentifier = $"{this.ApplicationIdentifier}.{this.ClientApplicationVersion}";
this.EnsureClient(fullIdentifier);
var isConnected = await this.InternalConnectAsync(serverEndpoint);
this.State = isConnected ? ClientStates.InLobby : ClientStates.Disconnected;
return(isConnected);
}
