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); }