protected virtual void Dispose(bool disposing) { if (m_disposed) { return; } //if (disposing) { } m_handlerDisconnected = null; m_handlerReceived = null; m_saeaReciver = null; m_saeaSender = null; m_pooledBufferManager = null; m_queueSend = null; m_listSend.Clear(); m_listSend = null; m_bClosed = null; m_bClosing = null; m_bSending = null; m_bReceiving = null; m_disposed = true; }
/// <summary> /// Initializes a new instance of the <see cref="TcpChannel" /> class. /// </summary> /// <param name="readBuffer">Buffer used for our reading.</param> /// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param> /// <param name="decoder"> /// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be /// overridden by this class. /// </param> public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { if (readBuffer == null) throw new ArgumentNullException("readBuffer"); if (encoder == null) throw new ArgumentNullException("encoder"); if (decoder == null) throw new ArgumentNullException("decoder"); _readArgs = new SocketAsyncEventArgs(); _readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity); _readArgs.Completed += OnReadCompleted; _readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs); _encoder = encoder; _decoder = decoder; _decoder.MessageReceived = OnMessageReceived; _writeArgs = new SocketAsyncEventArgs(); _writeArgs.Completed += OnSendCompleted; _writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs); _sendCompleteAction = (channel, message) => { }; _disconnectAction = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported); RemoteEndpoint = EmptyEndpoint.Instance; ChannelId = GuidFactory.Create().ToString(); Data = new ChannelData(); }
public Handler( InitializeHandler initialize, TerminateHandler terminate, LoginHandler login, ConnectHandler connect, LatencyHandler latency, DisconnectHandler disconnect, RoomHandler room, RoomsPageHandler roomsPage, RoomOperationHandler roomOperation, DataHandler data, ForeignDataHandler foreignData, LogHandler log) { Initialize = initialize; Terminate = terminate; Login = login; Connect = connect; Latency = latency; Disconnect = disconnect; Room = room; RoomsPage = roomsPage; RoomOperation = roomOperation; Data = data; ForeignData = foreignData; Log = log; }
/// <summary> /// </summary> /// <param name="readBuffer"></param> /// <param name="encoder"></param> /// <param name="decoder"></param> /// <param name="sslStreamBuilder">Used to wrap the socket with a SSL stream</param> public SecureTcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder, ISslStreamBuilder sslStreamBuilder) { if (readBuffer == null) { throw new ArgumentNullException("readBuffer"); } if (encoder == null) { throw new ArgumentNullException("encoder"); } if (decoder == null) { throw new ArgumentNullException("decoder"); } if (sslStreamBuilder == null) { throw new ArgumentNullException("sslStreamBuilder"); } _encoder = encoder; _decoder = decoder; _sslStreamBuilder = sslStreamBuilder; _decoder.MessageReceived = OnMessageReceived; _sendCompleteAction = (channel, message) => { }; _disconnectAction = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported); RemoteEndpoint = EmptyEndpoint.Instance; _readBuffer = new SocketBuffer(readBuffer); _writeBuffer = new SocketBuffer(); ChannelId = GuidFactory.Create().ToString(); Data = new ChannelData(); }
public async Task ShouldRemoveClientFromStore( [Frozen] Mock <IConnectedClientStore> store, ConnectedClient client, DisconnectHandler sut) { await sut.HandleAsync(client, Create <Disconnect>(), Cts.Token); store.Verify(x => x.Remove(client.ClientId)); }
public async Task ShouldSendDisconnectedMessage( [Frozen] Mock <IConnection> connection, ConnectedClient client, DisconnectHandler sut) { await sut.HandleAsync(client, Create <Disconnect>(), Cts.Token); connection.Verify(x => x.SendAsync(It.IsAny <Disconnected>(), Cts.Token)); }
public bool AddDisconnectHandler(DisconnectHandler handler) { if (this.m_disconnectHandlers.Contains(handler)) { return(false); } this.m_disconnectHandlers.Add(handler); return(true); }
/// <summary> /// Initializes a new instance of the <see cref="SocketChannel" /> class. /// </summary> public SocketChannel() { ChannelId = Guid.NewGuid().ToString(); RemoteEndpoint = new IPEndPoint(0, 0); _messageReceived = (channel, message) => { }; _messageSent = (channel, message) => { }; _clientDisconnected = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported); }
/// <summary> /// Create an instance of <see cref="WebAppServer"/>. /// </summary> /// <param name="urlReservation"> /// The URL reservation to listen on. This string is similar to a URL, but the /// hostname may be a strong wildcard ('+') or a weak wildcard ('*'). E.g. "http://+:8080/". /// </param> public WebAppServer(string urlReservation) { _urlRegex = new Regex("^" + urlReservation.Replace("*", ".*?").Replace("+", ".*?"), RegexOptions.IgnoreCase); _listener = new HttpListener(); _listener.Prefixes.Add(urlReservation); _disconnectHandler = new DisconnectHandler(_listener); var uri = new Uri(urlReservation.Replace("*", "localhost").Replace("+", "localhost")); _webAppConfiguration = new WebAppConfiguration(uri); StaticFiles = new StaticFileSpecCollection(); }
internal OwinHttpListenerContext(HttpListenerContext httpListenerContext, string basePath, string path, string query, DisconnectHandler disconnectHandler) { _httpListenerContext = httpListenerContext; _environment = new CallEnvironment(this); _owinRequest = new OwinHttpListenerRequest(_httpListenerContext.Request, basePath, path, query, _environment); _owinResponse = new OwinHttpListenerResponse(_httpListenerContext, _environment); _disconnectHandler = disconnectHandler; _environment.OwinVersion = Constants.OwinVersion; SetServerUser(_httpListenerContext.User); _environment.RequestContext = _httpListenerContext; }
/// <summary> /// 释放资源 /// </summary> /// <param name="disposing">是否也释放托管资源</param> protected virtual void Dispose(bool disposing) { this.Shutdown(); this.StreamReader.Stream.Dispose(); if (disposing) { this.socketRoot = null; this.Socket = null; this.Tag = null; this.StreamReader = null; this.CloseHandler = null; this.DisconnectHandler = null; this.ReceiveCompletedHandler = null; } }
public Handler( InitializeHandler initialize, TerminateHandler terminate, LoginHandler login, ConnectHandler connect, LatencyHandler latency, DisconnectHandler disconnect, DataHandler data, ForeignDataHandler foreignData, LogHandler log) { Initialize = initialize; Terminate = terminate; Login = login; Connect = connect; Latency = latency; Disconnect = disconnect; Data = data; ForeignData = foreignData; Log = log; }
/// <summary> /// </summary> /// <param name="readBuffer"></param> /// <param name="encoder"></param> /// <param name="decoder"></param> /// <param name="sslStreamBuilder">Used to wrap the socket with a SSL stream</param> public SecureTcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder, ISslStreamBuilder sslStreamBuilder) { if (readBuffer == null) throw new ArgumentNullException("readBuffer"); if (encoder == null) throw new ArgumentNullException("encoder"); if (decoder == null) throw new ArgumentNullException("decoder"); if (sslStreamBuilder == null) throw new ArgumentNullException("sslStreamBuilder"); _encoder = encoder; _decoder = decoder; _sslStreamBuilder = sslStreamBuilder; _decoder.MessageReceived = OnMessageReceived; _sendCompleteAction = (channel, message) => { }; _disconnectAction = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported); RemoteEndpoint = EmptyEndpoint.Instance; _readBuffer = new SocketBuffer(readBuffer); _writeBuffer = new SocketBuffer(); ChannelId = GuidFactory.Create().ToString(); Data = new ChannelData(); }
/// <summary> /// Initializes a new instance of the <see cref="TcpChannel" /> class. /// </summary> /// <param name="readBuffer">Buffer used for our reading.</param> /// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param> /// <param name="decoder"> /// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be /// overridden by this class. /// </param> public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) { IsConnected = false; if (readBuffer == null) { throw new ArgumentNullException("readBuffer"); } if (encoder == null) { throw new ArgumentNullException("encoder"); } if (decoder == null) { throw new ArgumentNullException("decoder"); } _readArgs = new SocketAsyncEventArgs(); _readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity); _readArgs.Completed += OnReadCompleted; _readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs); _encoder = encoder; _decoder = decoder; _decoder.MessageReceived = OnMessageReceived; _writeArgs = new SocketAsyncEventArgs(); _writeArgs.Completed += OnSendCompleted; _writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs); _sendCompleteAction = (channel, message) => { }; _disconnectAction = (channel, exception) => { }; ChannelFailure = (channel, error) => HandleRemoteDisconnect(SocketError.ProtocolNotSupported, error); RemoteEndpoint = EmptyEndpoint.Instance; ChannelId = GuidFactory.Create().ToString(); Data = new ChannelData(); }
private void OnDisconnectEventHandler() { DisconnectHandler?.Invoke(this, EventArgs.Empty); }
public void SetDisconnectHandler(DisconnectHandler handler) { _disconnectHandler = handler; }
public bool RemoveDisconnectHandler(DisconnectHandler handler) { return(this.m_disconnectHandlers.Remove(handler)); }
public void Update() { SslSocket.Process(); List <SslClientConnection.ConnectionEvent> connectionEvents = this.m_connectionEvents; lock (connectionEvents) { using (List <SslClientConnection.ConnectionEvent> .Enumerator enumerator = this.m_connectionEvents.GetEnumerator()) { while (enumerator.MoveNext()) { SslClientConnection.ConnectionEvent current = enumerator.get_Current(); switch (current.Type) { case SslClientConnection.ConnectionEventTypes.OnConnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); this.m_connectionState = SslClientConnection.ConnectionState.ConnectionFailed; } else { this.m_connectionState = SslClientConnection.ConnectionState.Connected; } ConnectHandler[] array = this.m_connectHandlers.ToArray(); for (int i = 0; i < array.Length; i++) { ConnectHandler connectHandler = array[i]; connectHandler(current.Error); } break; } case SslClientConnection.ConnectionEventTypes.OnDisconnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); } DisconnectHandler[] array2 = this.m_disconnectHandlers.ToArray(); for (int j = 0; j < array2.Length; j++) { DisconnectHandler disconnectHandler = array2[j]; disconnectHandler(current.Error); } break; } case SslClientConnection.ConnectionEventTypes.OnPacketCompleted: for (int k = 0; k < this.m_listeners.get_Count(); k++) { IClientConnectionListener <BattleNetPacket> clientConnectionListener = this.m_listeners.get_Item(k); object state = this.m_listenerStates.get_Item(k); clientConnectionListener.PacketReceived(current.Packet, state); } break; } } } this.m_connectionEvents.Clear(); } if (this.m_sslSocket == null || this.m_connectionState != SslClientConnection.ConnectionState.Connected) { return; } while (this.m_outQueue.get_Count() > 0) { if (this.OnlyOneSend && !this.m_sslSocket.m_canSend) { return; } BattleNetPacket packet = this.m_outQueue.Dequeue(); this.SendPacket(packet); } }
public Task Disconnect(Connection connection) { return(DisconnectHandler?.Invoke(connection)); }
public void InitDisconnect() { Connection.On <string>("Disconnect", (tcpId) => DisconnectHandler?.Invoke(tcpId)); }
public void Update() { object mutex = this.m_mutex; lock (mutex) { using (List <ClientConnection <PacketType> .ConnectionEvent> .Enumerator enumerator = this.m_connectionEvents.GetEnumerator()) { while (enumerator.MoveNext()) { ClientConnection <PacketType> .ConnectionEvent current = enumerator.get_Current(); this.PrintConnectionException(current); switch (current.Type) { case ClientConnection <PacketType> .ConnectionEventTypes.OnConnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.DisconnectSocket(); this.m_connectionState = ClientConnection <PacketType> .ConnectionState.ConnectionFailed; } else { this.m_connectionState = ClientConnection <PacketType> .ConnectionState.Connected; } ConnectHandler[] array = this.m_connectHandlers.ToArray(); for (int i = 0; i < array.Length; i++) { ConnectHandler connectHandler = array[i]; connectHandler(current.Error); } break; } case ClientConnection <PacketType> .ConnectionEventTypes.OnDisconnected: { if (current.Error != BattleNetErrors.ERROR_OK) { this.Disconnect(); } DisconnectHandler[] array2 = this.m_disconnectHandlers.ToArray(); for (int j = 0; j < array2.Length; j++) { DisconnectHandler disconnectHandler = array2[j]; disconnectHandler(current.Error); } break; } case ClientConnection <PacketType> .ConnectionEventTypes.OnPacketCompleted: for (int k = 0; k < this.m_listeners.get_Count(); k++) { IClientConnectionListener <PacketType> clientConnectionListener = this.m_listeners.get_Item(k); object state = this.m_listenerStates.get_Item(k); clientConnectionListener.PacketReceived(current.Packet, state); } break; } } } this.m_connectionEvents.Clear(); } if (this.m_socket == null || this.m_connectionState != ClientConnection <PacketType> .ConnectionState.Connected) { return; } this.SendQueuedPackets(); }