private static void OnStopSessionMessageReceived(StopSessionMessage message) { if (ProxySessionManager.TryGet(message.SessionId, out ProxySession session)) { ClientConnectionManager.Disconnect(session.ClientConnection, message.Reason); } }
public async Task ServiceConnectionDispatchOpenConnectionToUnauthorizedHubTest() { bool ExpectedErrors(WriteContext writeContext) { return(writeContext.LoggerName == typeof(ServiceConnection).FullName && writeContext.EventId == new EventId(11, "ConnectedStartingFailed") && writeContext.Exception.Message == "Unable to authorize request"); } using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug, expectedErrors: ExpectedErrors)) { var hubConfig = new HubConfiguration(); var ccm = new ClientConnectionManager(hubConfig, loggerFactory); hubConfig.Resolver.Register(typeof(IClientConnectionManager), () => ccm); using (var proxy = new TestServiceConnectionProxy(ccm, loggerFactory: loggerFactory)) { // start the server connection await proxy.StartServiceAsync().OrTimeout(); var clientConnection = Guid.NewGuid().ToString("N"); // Application layer sends OpenConnectionMessage to an authorized hub from anonymous user var openConnectionMessage = new OpenConnectionMessage(clientConnection, new Claim[0], null, "?transport=webSockets&connectionData=%5B%7B%22name%22%3A%22authchat%22%7D%5D"); await proxy.WriteMessageAsync(openConnectionMessage); await proxy.WaitForClientConnectAsync(clientConnection).OrTimeout(); // Verify client connection is not created due to authorized failure. ccm.TryGetServiceConnection(clientConnection, out var serviceConnection); Assert.Null(serviceConnection); } } }
public async void TestSendConnectionAsyncisOverwrittenWhenClientConnectionExisted() { var serviceConnectionManager = new TestServiceConnectionManager <TestHub>(); var clientConnectionManager = new ClientConnectionManager(); var context = new ClientConnectionContext(new OpenConnectionMessage("conn1", new Claim[] { })); var connection = new TestServiceConnectionPrivate(); context.ServiceConnection = connection; clientConnectionManager.AddClientConnection(context); var manager = MockLifetimeManager(serviceConnectionManager, clientConnectionManager); await manager.SendConnectionAsync("conn1", "foo", new object[] { 1, 2 }); Assert.NotNull(connection.LastMessage); if (connection.LastMessage is MultiConnectionDataMessage m) { Assert.Equal("conn1", m.ConnectionList[0]); Assert.Equal(1, m.Payloads.Count); Assert.True(m.Payloads.ContainsKey(MockProtocol)); return; } Assert.True(false); }
private void Init() { _connectionManager = _client.GetConnectionManager(); _clientMembershipListener = new ClientMembershipListener(_client); _connectionManager.AddConnectionListener(this); _credentials = _client.GetClientConfig().GetCredentials(); }
static void Main(string[] args) { Console.WindowHeight = Console.LargestWindowHeight - 20; Console.WindowWidth = Console.LargestWindowWidth - 20; Helpers.Out.startLogger(); //START LOGING!! ConnectionManager.SocketManager man = new ConnectionManager.SocketManager(); man.init(9001, 1337, 10, new GamePacketParser(), true); man.connectionEvent += new ConnectionManager.SocketManager.ConnectionEvent(man_connectionEvent); man.initializeConnectionRequests(); string s; ipcon = new ClientConnectionManager("127.0.0.1", 9001); ipcon.OnConnectionChange += new ClientConnectionManager.connectionChanged(ipcon_OnConnectionChange); while((s = Console.ReadLine()) != "exit") { switch (s) { case "con": { ipcon.openConnection(); break; } case "p": { ipcon.processSyncedMessages(); break; } } } ipcon.Dispose(); man.destroy(); Out.stopLogger(); }
public ClientMembershipListener(HazelcastClient client) { _client = client; _connectionManager = (ClientConnectionManager)client.GetConnectionManager(); _partitionService = (ClientPartitionService)client.GetClientPartitionService(); _clusterService = (ClientClusterService)client.GetClientClusterService(); }
public InventoryPredict(ClientConnectionManager connection, List <StockRecord> items, int selected) { InitializeComponent(); _connection = connection; _items = items; List <int> IDs = new List <int>(); foreach (StockRecord s in _items) { cmb_name.Items.Add(s.StockName); } if ((selected >= 0) && (selected < _items.Count)) { cmb_name.SelectedIndex = selected; } cmb_name.Enabled = false; IDs.Add(_items[selected].StockID); txt_sales.Text = PredictSales(IDs).ToString(); txt_profits.Text = PredictProfit(IDs).ToString(); }
public async Task ServiceConnectionDispatchOpenConnectionToUnauthorizedHubTest() { using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning, expectedErrors: c => true, logChecker: logs => { Assert.Single(logs); Assert.Equal("ConnectedStartingFailed", logs[0].Write.EventId.Name); Assert.Equal("Unable to authorize request", logs[0].Write.Exception.Message); return(true); })) { var hubConfig = new HubConfiguration(); var ccm = new ClientConnectionManager(hubConfig, loggerFactory); hubConfig.Resolver.Register(typeof(IClientConnectionManager), () => ccm); using (var proxy = new TestServiceConnectionProxy(ccm, loggerFactory: loggerFactory)) { // start the server connection await proxy.StartServiceAsync().OrTimeout(); var connectionId = Guid.NewGuid().ToString("N"); var connectTask = proxy.WaitForOutgoingMessageAsync(connectionId).OrTimeout(); // Application layer sends OpenConnectionMessage to an authorized hub from anonymous user var openConnectionMessage = new OpenConnectionMessage(connectionId, new Claim[0], null, "?transport=webSockets&connectionData=%5B%7B%22name%22%3A%22authchat%22%7D%5D"); await proxy.WriteMessageAsync(openConnectionMessage); var message = await connectTask; Assert.True(message is CloseConnectionMessage); // Verify client connection is not created due to authorized failure. Assert.False(ccm.ClientConnections.TryGetValue(connectionId, out var connection)); } } }
public async Task ServiceConnectionWithTransportLayerClosedShouldCleanupEndlessConnectClientConnections() { using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug, expectedErrors: c => true, logChecker: logs => { var errorLogs = logs.Where(s => s.Write.LogLevel == LogLevel.Error).ToList(); Assert.Single(errorLogs); Assert.Equal("ApplicationTaskTimedOut", errorLogs[0].Write.EventId.Name); return(true); })) { var hubConfig = Utility.GetActualHubConfig(loggerFactory); var appName = "app1"; var hub = "EndlessConnect"; var scm = new TestServiceConnectionHandler(); hubConfig.Resolver.Register(typeof(IServiceConnectionManager), () => scm); var ccm = new ClientConnectionManager(hubConfig, loggerFactory); hubConfig.Resolver.Register(typeof(IClientConnectionManager), () => ccm); DispatcherHelper.PrepareAndGetDispatcher(new TestAppBuilder(), hubConfig, new ServiceOptions { ConnectionString = ConnectionString }, appName, loggerFactory); using (var proxy = new TestServiceConnectionProxy(ccm, loggerFactory)) { // start the server connection var connectionTask = proxy.StartAsync(); await proxy.ConnectionInitializedTask.OrTimeout(); var clientConnection = Guid.NewGuid().ToString("N"); var connectTask = scm.WaitForTransportOutputMessageAsync(typeof(GroupBroadcastDataMessage)) .OrTimeout(); // Application layer sends OpenConnectionMessage var openConnectionMessage = new OpenConnectionMessage(clientConnection, new Claim[0], null, $"?transport=webSockets&connectionToken=conn1&connectionData=%5B%7B%22name%22%3A%22{hub}%22%7D%5D"); await proxy.WriteMessageAsync(openConnectionMessage); var connectMessage = (await connectTask)as GroupBroadcastDataMessage; Assert.NotNull(connectMessage); Assert.Equal($"hg-{hub}.note", connectMessage.GroupName); var message = connectMessage.Payloads["json"] .GetJsonMessageFromSingleFramePayload <HubResponseItem>(); Assert.Equal("Connected", message.A[0]); // close transport layer proxy.TestConnectionContext.Application.Output.Complete(); // wait for application task to timeout await proxy.WaitForConnectionClose.OrTimeout(10000); Assert.Equal(ServiceConnectionStatus.Disconnected, proxy.Status); // cleaned up clearly Assert.Empty(ccm.ClientConnections); } } }
public async Task ServiceConnectionWithErrorDisconnectHub() { using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug, expectedErrors: c => true, logChecker: logs => true)) { var hubConfig = Utility.GetActualHubConfig(loggerFactory); var appName = "app1"; var hub = "ErrorDisconnect"; // error connect hub var scm = new TestServiceConnectionHandler(); hubConfig.Resolver.Register(typeof(IServiceConnectionManager), () => scm); var ccm = new ClientConnectionManager(hubConfig, loggerFactory); hubConfig.Resolver.Register(typeof(IClientConnectionManager), () => ccm); DispatcherHelper.PrepareAndGetDispatcher(new TestAppBuilder(), hubConfig, new ServiceOptions { ConnectionString = ConnectionString }, appName, loggerFactory); using (var proxy = new TestServiceConnectionProxy(ccm, loggerFactory: loggerFactory)) { // start the server connection await proxy.StartServiceAsync().OrTimeout(); var clientConnection = Guid.NewGuid().ToString("N"); var connectTask = scm.WaitForTransportOutputMessageAsync(typeof(GroupBroadcastDataMessage)) .OrTimeout(); // Application layer sends OpenConnectionMessage var openConnectionMessage = new OpenConnectionMessage(clientConnection, new Claim[0], null, $"?transport=webSockets&connectionToken=conn1&connectionData=%5B%7B%22name%22%3A%22{hub}%22%7D%5D"); await proxy.WriteMessageAsync(openConnectionMessage); var connectMessage = (await connectTask)as GroupBroadcastDataMessage; Assert.NotNull(connectMessage); Assert.Equal($"hg-{hub}.note", connectMessage.GroupName); var message = connectMessage.Payloads["json"] .GetJsonMessageFromSingleFramePayload <HubResponseItem>(); Assert.Equal("Connected", message.A[0]); var disconnectTask = scm.WaitForTransportOutputMessageAsync(typeof(GroupBroadcastDataMessage)) .OrTimeout(); await proxy.WriteMessageAsync(new CloseConnectionMessage(clientConnection)); var disconnectMessage = (await disconnectTask)as GroupBroadcastDataMessage; Assert.NotNull(disconnectMessage); Assert.Equal($"hg-{hub}.note", disconnectMessage.GroupName); message = disconnectMessage.Payloads["json"] .GetJsonMessageFromSingleFramePayload <HubResponseItem>(); Assert.Equal("Disconnected", message.A[0]); // cleaned up clearly Assert.Empty(ccm.ClientConnections); } } }
public Inventory(ClientConnectionManager connection) { InitializeComponent(); _connection = connection; UpdateList(); }
public void AddClientConnection(ClientConnectionContext clientConnection) { ClientConnectionManager.AddClientConnection(clientConnection); if (_waitForConnectionOpen.TryGetValue(clientConnection.ConnectionId, out var tcs)) { tcs.TrySetResult(clientConnection); } }
public ClientConnectionManagerTests() { var hubConfig = new HubConfiguration(); var transport = new AzureTransportManager(hubConfig.Resolver); hubConfig.Resolver.Register(typeof(ITransportManager), () => transport); _clientConnectionManager = new ClientConnectionManager(hubConfig); }
public void RemoveClientConnection(string connectionId) { ClientConnectionManager.RemoveClientConnection(connectionId); if (_waitForConnectionClose.TryGetValue(connectionId, out var tcs)) { tcs.TrySetResult(null); } }
public ServiceConnectionProxy(ConnectionDelegate callback = null, PipeOptions clientPipeOptions = null, Func <Func <TestConnection, Task>, TestConnectionFactory> connectionFactoryCallback = null, int connectionCount = 1) { ConnectionFactory = connectionFactoryCallback?.Invoke(ConnectionFactoryCallbackAsync) ?? new TestConnectionFactory(ConnectionFactoryCallbackAsync); ClientConnectionManager = new ClientConnectionManager(); _clientPipeOptions = clientPipeOptions; ConnectionDelegateCallback = callback ?? OnConnectionAsync; ServiceConnectionContainer = new StrongServiceConnectionContainer(this, ConnectionFactory, connectionCount, new ServiceEndpoint("", "")); }
public override void ExecuteAiCommand(AiPlayer aiPlayer, ClientConnectionManager aiConnection) { //@TODO: Proper AI card selection int cardId = aiPlayer.m_cards[0].Key; aiPlayer.m_cards.RemoveAt(0); SGC_PlayCardFromHand command = new SGC_PlayCardFromHand(cardId); aiConnection.TransmitStream(command.PackCommand()); }
public Sales(ClientConnectionManager connection) { InitializeComponent(); _connection = connection; _stockrecords = _connection.RequestStockInfo(-1); UpdateList(); }
/** Start an offline server within the application and start a game */ public void PlayOffline() { m_offline = true; m_localServerRunner = new LocalServerRunner(); m_client = new ClientConnectionManager(); m_localServerRunner.StartServer(m_client); if (m_client.IsConnected() && m_visualManager == null) // Check for visual manager to know if we are already in-game - Hacky!! { SceneManager.LoadScene("Scenes/CardGame"); } }
public void ConnectButton() { m_client = new ClientConnectionManager(); bool connected = m_client.AttemptConnection(m_ipAddress, m_port); if (connected) { // load new scene SceneManager.LoadScene("Scenes/CardGame"); } }
public override void ExecuteAiCommand(AiPlayer aiPlayer, ClientConnectionManager aiConnection) { if (m_playerID == aiPlayer.m_playerID) { aiPlayer.m_lifeTotal = m_life; } else { aiPlayer.m_opponentLifeTotal = m_life; } }
public void StartServer(ClientConnectionManager connectionMgr) { m_clientConMgr = connectionMgr; m_aiConMgr = new ClientConnectionManager(); m_aiPlayer = new AiPlayer(); m_server = new CardGameServer(); InitializeServer(); ConnectClients(); RunServer(); }
public async Task ServiceConnectionDispatchGroupMessagesTest() { using (StartVerifiableLog(out var loggerFactory, LogLevel.Debug)) { var hubConfig = new HubConfiguration(); hubConfig.Resolver = new DefaultDependencyResolver(); var scm = new TestServiceConnectionManager(); hubConfig.Resolver.Register(typeof(IServiceConnectionManager), () => scm); var ccm = new ClientConnectionManager(hubConfig); hubConfig.Resolver.Register(typeof(IClientConnectionManager), () => ccm); DispatcherHelper.PrepareAndGetDispatcher(new TestAppBuilder(), hubConfig, new ServiceOptions { ConnectionString = ConnectionString }, "app1", loggerFactory); using (var proxy = new ServiceConnectionProxy(ccm, loggerFactory: loggerFactory)) { // start the server connection await proxy.StartServiceAsync().OrTimeout(); var clientConnection = Guid.NewGuid().ToString("N"); // Application layer sends OpenConnectionMessage var openConnectionMessage = new OpenConnectionMessage(clientConnection, new Claim[0], null, "?transport=webSockets&connectionToken=conn1"); await proxy.WriteMessageAsync(openConnectionMessage); await proxy.WaitForClientConnectAsync(clientConnection).OrTimeout(); // group message goes into the manager // make sure the tcs is called before writing message var jgTask = scm.WaitForTransportOutputMessageAsync(typeof(JoinGroupMessage)).OrTimeout(); var gbTask = scm.WaitForTransportOutputMessageAsync(typeof(GroupBroadcastDataMessage)).OrTimeout(); await proxy.WriteMessageAsync(new ConnectionDataMessage(clientConnection, Encoding.UTF8.GetBytes("{\"H\":\"chat\",\"M\":\"JoinGroup\",\"A\":[\"user1\",\"message1\"],\"I\":1}"))); await jgTask; await gbTask; var lgTask = scm.WaitForTransportOutputMessageAsync(typeof(LeaveGroupMessage)).OrTimeout(); gbTask = scm.WaitForTransportOutputMessageAsync(typeof(GroupBroadcastDataMessage)).OrTimeout(); await proxy.WriteMessageAsync(new ConnectionDataMessage(clientConnection, Encoding.UTF8.GetBytes("{\"H\":\"chat\",\"M\":\"LeaveGroup\",\"A\":[\"user1\",\"message1\"],\"I\":1}"))); await lgTask; await gbTask; var dTask = proxy.WaitForClientDisconnectAsync(clientConnection).OrTimeout(); await proxy.WriteMessageAsync(new CloseConnectionMessage(clientConnection)); await dTask; } } }
public ClientConnectionContext RemoveClientConnection(string connectionId) { var connection = ClientConnectionManager.RemoveClientConnection(connectionId); if (_waitForConnectionClose.TryGetValue(connectionId, out var tcs)) { tcs.TrySetResult(null); } return(connection); }
public ServiceConnectionTests(ITestOutputHelper output) : base(output) { var hubConfig = new HubConfiguration(); var protectedData = new EmptyProtectedData(); var transport = new AzureTransportManager(hubConfig.Resolver); hubConfig.Resolver.Register(typeof(IProtectedData), () => protectedData); hubConfig.Resolver.Register(typeof(ITransportManager), () => transport); _clientConnectionManager = new ClientConnectionManager(hubConfig); }
public ServiceConnectionProxy(ConnectionDelegate callback = null, PipeOptions clientPipeOptions = null, Func <Func <TestConnection, Task>, TestConnectionFactory> connectionFactoryCallback = null, int connectionCount = 1) { ConnectionFactory = connectionFactoryCallback?.Invoke(ConnectionFactoryCallbackAsync) ?? new TestConnectionFactory(ConnectionFactoryCallbackAsync); ClientConnectionManager = new ClientConnectionManager(); _clientPipeOptions = clientPipeOptions; ConnectionDelegateCallback = callback ?? OnConnectionAsync; ServiceConnectionContainer = new StrongServiceConnectionContainer(this, connectionCount, new HubServiceEndpoint("", null, null), NullLogger.Instance); ServiceMessageHandler = (StrongServiceConnectionContainer)ServiceConnectionContainer; }
public InventoryEdit(ClientConnectionManager connection, List <StockRecord> items) { InitializeComponent(); _connection = connection; _items = items; foreach (StockRecord s in _items) { cmb_name.Items.Add(s.StockName); } }
public override void ExecuteAiCommand(AiPlayer aiPlayer, ClientConnectionManager aiConnection) { // @TODO: AI implementation // Sending the same deck that the player loaded for now string deckFileName = m_visualManager.GetDeckFileName(); PackedDeck deck = new PackedDeck(); deck.LoadFromJSON(PackedDeck.deckPath + deckFileName); SGC_SendDeck command = new SGC_SendDeck(deck); m_visualManager.TransmitStream(command.PackCommand()); }
/// <summary> /// Creates a new MainServerConnection handeler with the given details /// </summary> /// <param name="ip">The ip address of the server</param> /// <param name="port">The port to connect to</param> public MainServerConnectionHolder(string ip, int port, string username, string license) { this.ip = ip; this.port = port; this.username = username; this.serial = license; keepThreadAlive = true; connection = new ClientConnectionManager(ip, port); connection.OnConnectionChange += ConStatusChanged; aliveCheck = new Thread(DoHealthChecks); aliveCheck.Start(); }
private void Start() { if (started) return; this.SessionID = Guid.NewGuid().ToString(); if (mgr == null) mgr = new ClientConnectionManager(); mgr.Connect(); }
public ClientConnectionManagerTests() { var hubConfig = new HubConfiguration { Resolver = new DefaultDependencyResolver() }; var transport = new AzureTransportManager(hubConfig.Resolver); hubConfig.Resolver.Register(typeof(ITransportManager), () => transport); _clientConnectionManager = new ClientConnectionManager(hubConfig, null); }
public bool TryAddClientConnection(ClientConnectionContext connection) { if (ClientConnectionManager.TryAddClientConnection(connection)) { if (_waitForConnectionOpen.TryGetValue(connection.ConnectionId, out var tcs)) { tcs.TrySetResult(connection); } return(true); } return(false); }
public bool TryRemoveClientConnection(string connectionId, out ClientConnectionContext connection) { if (ClientConnectionManager.TryRemoveClientConnection(connectionId, out connection)) { if (_waitForConnectionClose.TryGetValue(connectionId, out var tcs)) { tcs.TrySetResult(null); } return(true); } return(false); }
private void Stop() { if (mgr != null) mgr.Close(); mgr = null; }