public void ExternalLoginCallback_RedirectsTo_ExternalLoginConfirm_WhenUserIsNew()
{
// Arrange
var mocks = new OAuthMocks();
var controller = GetController(mocks);
var extraData = new Dictionary<string, string> {{"accesstoken", "providerAccessToken"}};
var authResult = new AuthenticationResult(true, PROVIDER, PROVIDER_USERID, USERNAME, extraData);
var mxClient = new MxClient(new InMemoryOAuthTokenManager("a", "b"));
mocks.Response.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns(RETURN_URL);
mocks.OAuthWebSecurity.Setup(ows => ows.VerifyAuthentication(It.IsAny<string>())).Returns(authResult);
mocks.OAuthWebSecurity.Setup(ows => ows.Login(PROVIDER, PROVIDER_USERID, false)).Returns(false);
mocks.Identity.Setup(i => i.IsAuthenticated).Returns(false);
mocks.OAuthWebSecurity.Setup(ows => ows.SerializeProviderUserId(PROVIDER, PROVIDER_USERID)).Returns(PROVIDER_USERID);
mocks.OAuthWebSecurity.Setup(ows => ows.GetOAuthClientData(PROVIDER)).Returns(new AuthenticationClientData(mxClient, PROVIDER_DISPLAY_NAME, null));
// Act
var result = controller.ExternalLoginCallback(RETURN_URL) as ViewResult;
// Assert
Assert.NotNull(result, "result");
Assert.AreEqual(result.ViewBag.ProviderDisplayName, PROVIDER_DISPLAY_NAME);
var model = result.Model as RegisterExternalLoginModel;
Assert.NotNull(model, "result");
Assert.AreEqual(model.UserName, authResult.UserName);
Assert.AreEqual(model.ExternalLoginData, authResult.ProviderUserId);
Assert.AreEqual(model.AccessToken, "providerAccessToken");
}
public void TokenManager()
{
var tokenManager = new InMemoryOAuthTokenManager("a", "b");
var mxClient = new MxClient(tokenManager);
Assert.NotNull(mxClient, "mxClient");
var tokens = mxClient.TokenManager;
Assert.NotNull(tokens, "tokens");
}
public ClientChunkStateManager(
IChunkOctreeFactory chunkOctreeFactory,
IPositionScaleTranslation positionScaleTranslation,
IPredeterminedChunkPositions predeterminedChunkPositions,
MxClient client)
{
this.m_PositionScaleTranslation = positionScaleTranslation;
this.m_PredeterminedChunkPositions = predeterminedChunkPositions;
this.m_ClientHasChunkOctree = chunkOctreeFactory.CreateChunkOctree<ServerChunk>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MxReliability"/> class.
/// </summary>
/// <param name="client">
/// The client that this reliability class is associated with.
/// </param>
public MxReliability(MxClient client)
{
this.m_Client = client;
this.m_QueuedMessages = new Queue<byte[]>();
this.m_ActiveMessages = new List<MxReliabilitySendState>();
this.m_ActiveReceiveMessages = new Dictionary<int, MxReliabilityReceiveState>();
this.m_Client.MessageAcknowledged += this.ClientOnMessageAcknowledged;
this.m_Client.MessageLost += this.ClientOnMessageLost;
this.m_Client.MessageReceived += this.ClientOnMessageReceived;
}
public PlayerServerEntity(
ITerrainSurfaceCalculator terrainSurfaceCalculator,
IServerEntityFactory serverEntityFactory,
TychaiaServer server,
TychaiaServerWorld serverWorld,
MxClient client,
int uniqueClientIdentifier)
{
this.m_TerrainSurfaceCalculator = terrainSurfaceCalculator;
this.m_ServerEntityFactory = serverEntityFactory;
this.m_Server = server;
this.m_ServerWorld = serverWorld;
this.m_Client = client;
this.m_UniqueClientIdentifier = uniqueClientIdentifier;
}
public void SendMessage(string type, byte[] data, MxClient client = null, bool reliable = false)
{
var bytes = InMemorySerializer.Serialize(new TychaiaInternalMessage { Type = type, Data = data });
if (client == null)
{
foreach (var endpoint in this.m_MxDispatcher.Endpoints)
{
this.m_MxDispatcher.Send(endpoint, bytes, reliable);
}
}
else
{
this.m_MxDispatcher.Send(client.DualEndpoint, bytes, reliable);
}
}
public ServerClientManager(
IServerFactory serverFactory,
TychaiaServer server,
TychaiaServerWorld world,
int uniqueID,
string initialPlayerName,
MxClient client)
{
this.m_Server = server;
this.m_World = world;
this.UniqueID = uniqueID;
this.PlayerName = initialPlayerName;
this.MxClient = client;
this.Entities = new List<IServerEntity>();
this.ClientChunkStateManager = serverFactory.CreateClientChunkStateManager(client);
}
/// <summary>
/// Unregister from a client's events.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
private void UnregisterFromEvents(MxClient client)
{
client.MessageSent -= OnClientMessageSent;
client.MessageReceived -= OnClientMessageReceived;
client.MessageLost -= OnClientMessageLost;
client.MessageAcknowledged -= OnClientMessageAcknowledged;
client.DisconnectWarning -= OnClientDisconnectWarning;
}
/// <summary>
/// Register for a client's events.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
private void RegisterForEvents(MxClient client)
{
client.MessageSent += OnClientMessageSent;
client.MessageReceived += OnClientMessageReceived;
client.MessageLost += OnClientMessageLost;
client.MessageAcknowledged += OnClientMessageAcknowledged;
client.DisconnectWarning += OnClientDisconnectWarning;
}
/// <summary>
/// Raise the ClientDisconnected event.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
protected virtual void OnClientDisconnected(MxClient client)
{
var handler = ClientDisconnected;
handler?.Invoke(this, new MxClientEventArgs { Client = client });
}
/// <summary>
/// Queue a packet for sending to the specified client.
/// </summary>
/// <param name="client">
/// The client to send the message to.
/// </param>
/// <param name="packet">
/// The associated data to send.
/// </param>
/// <param name="reliable">
/// Whether or not this message should be sent reliably and intact. This also
/// permits messages larger than 512 bytes to be sent.
/// </param>
public void Send(MxClient client, byte[] packet, bool reliable = false)
{
AssertNotClosed();
if (!reliable)
{
client.EnqueueSend(packet, MxMessage.RealtimeProtocol);
}
else
{
var reliability = client.Group.ReliableClients.First(x => x.Client == client);
reliability.Send(packet);
}
}
/// <summary>
/// Raise the ClientDisconnected event.
/// </summary>
/// <param name="client">
/// The client.
/// </param>
protected virtual void OnClientDisconnected(MxClient client)
{
var handler = this.ClientDisconnected;
if (handler != null)
{
handler(this, new MxClientEventArgs { Client = client });
}
}
private List<IServerEntity> GetListForClient(MxClient client)
{
return this.m_ConnectedClients[client].Entities;
}
/// <summary>
/// Places the specified Mx client in the specified group.
/// </summary>
/// <param name="client">The Mx client.</param>
/// <param name="identifier">The group identifier.</param>
public MxClientGroup PlaceInGroup(MxClient client, string identifier)
{
if (client.Group.Identifier == identifier)
{
return client.Group;
}
if (!_mxClientGroups.ContainsKey(identifier))
{
_mxClientGroups[identifier] = new MxClientGroup(this, identifier);
}
var reliability = client.Group.ReliableClients.First(x => x.Client == client);
client.Group.RealtimeClients.Remove(client);
client.Group.ReliableClients.Remove(reliability);
client.Group = _mxClientGroups[identifier];
client.Group.RealtimeClients.Add(client);
client.Group.ReliableClients.Add(reliability);
return client.Group;
}
public void AddPlayer(MxClient client, string playerName)
{
var entities = this.GetListForClient(client);
var playerEntity = this.m_ServerEntityFactory.CreatePlayerServerEntity(
this.m_Server,
this,
client,
this.m_ConnectedClients[client].UniqueID);
playerEntity.Name = playerName;
this.m_ConnectedClients[client].Player = playerEntity;
entities.Add(playerEntity);
}
public void ChangePlayerName(MxClient client, string newName)
{
var entities = this.GetListForClient(client);
var player = entities.OfType<PlayerServerEntity>().First();
player.Name = newName;
}
private MxClient ThreadSafeGetOrCreateClient(IPEndPoint endpoint)
{
MxClient client;
lock (_mxClientGroupLock)
{
client =
_mxClientGroups
.Select(x => x.Value.RealtimeClients.FirstOrDefault(y => y.Endpoint.ToString() == endpoint.ToString()))
.FirstOrDefault(x => x != null);
if (client != null)
{
return client;
}
if (_explicitlyDisconnected.Contains(endpoint))
{
return null;
}
client = new MxClient(
this,
_mxClientGroups[MxClientGroup.Ungrouped],
endpoint,
_udpClient);
_mxClientGroups[MxClientGroup.Ungrouped].RealtimeClients.Add(client);
RegisterForEvents(client);
var reliability = new MxReliability(client);
_mxClientGroups[MxClientGroup.Ungrouped].ReliableClients.Add(reliability);
RegisterForEvents(reliability);
}
OnClientConnected(client);
return client;
}
private void OnUserInput(MxClient client, byte[] data)
{
var userInput = InMemorySerializer.Deserialize<UserInput>(data);
// Find the player entity for this client.
var entities = this.GetListForClient(client);
var player = entities.OfType<PlayerServerEntity>().FirstOrDefault();
if (player == null)
{
return;
}
switch (userInput.GetAction())
{
case UserInputAction.Move:
player.MoveInDirection(userInput.DirectionInDegrees);
break;
}
}
/// <summary>
/// Disconnects the specified Mx client. This removes it from
/// the group that owns it, and prevents it from reconnecting to
/// this dispatcher implicitly.
/// </summary>
/// <param name="client">The client.</param>
public void Disconnect(MxClient client)
{
AssertNotClosed();
lock (_mxClientGroupLock)
{
var reliability = client.Group.ReliableClients.First(x => x.Client == client);
var group = client.Group;
group.RealtimeClients.Remove(client);
group.ReliableClients.Remove(reliability);
UnregisterFromEvents(client);
UnregisterFromEvents(reliability);
_explicitlyDisconnected.Add(client.Endpoint);
}
OnClientDisconnected(client);
}
