public void RemoveListener(IClientListener listener)
{
if (_listeners.Contains(listener))
{
_listeners.Remove(listener);
}
}
public Server(string address, int port, IClientListener <Request, Response> listener, ISerializeProcessor sp, bool isIPAddressAny)
{
this._address = address;
this._port = port;
this._lisenter = listener;
this.SP = sp;
this.isAnyIPAddress = isIPAddressAny || string.IsNullOrEmpty(_address);
var excutor = new TryCatchExecutor((e) =>
{
//Console.Write(e);
});
var bootStrapper = new ServerBootstrap()
.Executor(excutor)
.SetTransport(System.Net.TransportType.Tcp)
.Build();
_server = bootStrapper.NewReactor(
NodeBuilder.BuildNode()
.Host(isIPAddressAny? IPAddress.Any:IPAddress.Parse(_address))
.WithPort(port)
);
_server.OnConnection += _server_OnConnection;;
_server.OnDisconnection += TempServer_OnDisconnection;
}
/// <summary>
/// Adds a create listener that will be notified when new clients are created.
/// </summary>
/// <param name="listener">The listener to add.</param>
public static void AddClientCreatedListener(IClientListener listener)
{
if (listener != null)
{
_createdListeners.AddIfAbsent(listener);
}
}
public void AddListener(IClientListener listener)
{
if (!_listeners.Contains(listener))
{
_listeners.Add(listener);
}
}
/// <summary>
/// Removes a Client created listener.
/// </summary>
/// <param name="listener">The listener to remove.</param>
public static void RemoveClientCreatedListener(IClientListener listener)
{
if (listener != null)
{
_createdListeners.Remove(listener);
}
}
// --
public Client(IClientListener listener)
{
this.listeners = new List<IClientListener>();
this.listeners.Add(listener);
this.username = User.Instance.username;
this.id = User.Instance.id;
this.state = SocketState.DISCONNECTED;
}
public WebSocketClient(
IClientListener clientListener,
string address,
IConnectionLogger clientLogger = null)
{
_clientListener = clientListener;
_clientAddress = address; // the server address the connection will be connecting to.
_clientLogger = clientLogger;
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
TransportMsg msg = message as TransportMsg;
IClientListener listener = context.Channel.GetAttribute(AttributeKey <IClientListener> .ValueOf(typeof(DefaultTransportClientFactory), nameof(IClientListener))).Get();
IClientSender sender = context.Channel.GetAttribute(AttributeKey <IClientSender> .ValueOf(typeof(DefaultTransportClientFactory), nameof(IClientSender))).Get();
listener.Received(sender, msg);
}
public DefaultTransportClient(IClientListener listener, IClientSender sender, ISerializer serializer, ILogger logger)
{
_listener = listener;
_sender = sender;
_serializer = serializer;
_logger = logger;
_listener.OnReceived += ListenerOnReceived;
}
public IMClientEngine(string host, int port, int timeoutSeconds = 60, IClientListener clientListener = null)
{
this.Host = host;
this.Port = port;
this.TimeoutSeconds = timeoutSeconds;
this.messageExecutors = new Dictionary <ImMessageType, IClientMessageExecutor>();
this.clientListener = clientListener;
Init();
}
/// <summary>
/// Removes a client destroy listener.
/// </summary>
/// <param name="listener">The listener to remove.</param>
public void RemoveClientDestroyedListener(IClientListener listener)
{
if (listener != null)
{
if (_destroyedListeners != null)
{
_destroyedListeners.Remove(listener);
}
}
}
public Client(IClientListener listener)
{
if (listener == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at client init: " + ex.ToString());
throw ex;
}
this.listener = listener;
}
internal void Connect(string host, int port, IClientListener listener)
{
if (m_Dispose)
{
throw new ObjectDisposedException("ClientChannel already disposed!");
}
m_Listener = listener;
m_Transport = new ClientTransport();
m_Transport.Connect(host, port);
RegisterMessages();
}
public override void Dispose()
{
if (m_Dispose)
{
return;
}
m_Dispose = true;
m_Transport.Dispose();
ClearMsgHandlers();
m_Listener = null;
m_Transport = null;
}
public OptionsImprimante(IClientListener clientListener)
{
InitializeComponent();
_clientListener = clientListener;
_printer = new Printer();
port = 2000 + new Random().Next(6000);
IPHostEntry iphostentry = Dns.GetHostEntry(Dns.GetHostName());
_serverSocket = new TcpListener(iphostentry.AddressList[0], port);
_serverSocket.Start();
new Thread(WaitForClientToConnect).Start();
}
public Client(IPAddress ipAddress, int port, LoginDetails loginDetails, IClientListener listener)
{
if (port < 0)
{
throw new ArgumentException("Invalid port number", nameof(port));
}
_ipAddress = ipAddress;
_port = port;
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
_listener = listener;
_loginDetails = loginDetails;
}
public DefaultListeningManager(ILogger logger, IAlarmState alarmState, IWasListener wasListener, IClientListener clientListener, IPing ping)
{
this.mLogger = logger;
this.mAlarmState = alarmState;
this.mWasListener = wasListener;
this.mClientListener = clientListener;
this.mPing = ping;
TaskScheduler.UnobservedTaskException += (object sender, UnobservedTaskExceptionEventArgs ex) =>
{
this.mLogger.LogError("(ListeningManager/Constructor/UnobservedTaskException)", ErrorType.ListeningManager_UnobservedTaskException, ex.Exception);
};
}
public ICamoranBrokerSession BindListener(HostConfig config)
{
this.ConsumerListener = new CamoranClientListener_ByHelios <ConsumerRequest, ConsumerResponse>(
config.ConsumerAddress,
config.ConsumerPort,
new ProtoBufSerializeProcessor(),
config.ServerWithAnyIPAddress); // need optimize later
this.ProducerListener = new CamoranClientListener_ByHelios <ProducerRequest, ProducerResponse>(
config.ProduceAddress,
config.ProducePort,
new ProtoBufSerializeProcessor(),
config.ServerWithAnyIPAddress);// need optimize later
return(this);
}
public DefaultListeningManager(params INinjectModule[] modules)
{
using (StandardKernel kernel = new StandardKernel(modules))
{
this.mLogger = kernel.Get <ILogger>();
this.mAlarmState = kernel.Get <IAlarmState>();
this.mWasListener = kernel.Get <IWasListener>();
this.mClientListener = kernel.Get <IClientListener>();
this.mPing = kernel.Get <IPing>();
}
TaskScheduler.UnobservedTaskException += (object sender, UnobservedTaskExceptionEventArgs ex) =>
{
this.mLogger.LogError("(ListeningManager/Constructor/UnobservedTaskException)", ErrorType.ListeningManager_UnobservedTaskException, ex.Exception);
};
}
/*
* internal void Disconnect(bool timeout)
* {
* lock (this.SyncRoot)
* {
* if (this.IsDisconnecting || this.IsDisconnected)
* return;
* try
* {
* SetIsDisconnecting(true);
* //restore context
* IConnection currentConnection = null;
* if (this.Connections != null && this.Connections.Count > 0)
* {
* IEnumerator enumerator = this.Connections.GetEnumerator();
* enumerator.MoveNext();
* currentConnection = enumerator.Current as IConnection;
* }
* if (FluorineContext.Current == null)
* {
* _TimeoutContext context = new _TimeoutContext(currentConnection, this);
* //WebSafeCallContext.SetData(FluorineContext.FluorineContextKey, context);
* try
* {
* // See if we're running in full trust
* new SecurityPermission(PermissionState.Unrestricted).Demand();
* WebSafeCallContext.SetData(FluorineContext.FluorineContextKey, context);
* }
* catch (SecurityException)
* {
* System.Web.HttpContext ctx = System.Web.HttpContext.Current;
* if (ctx != null)
* ctx.Items[FluorineContext.FluorineContextKey] = context;
* }
* }
* _clientManager.RemoveSubscriber(this);
* // Unregister from all sessions.
* if (_sessions != null && _sessions.Count != 0)
* {
* foreach (ISession session in _sessions)
* UnregisterSession(session);
* }
* //Invalidate associated MessageClient subscriptions.
* if (_messageClients != null)
* {
* foreach (MessageClient messageClient in _messageClients)
* {
* messageClient.RemoveMessageClientDestroyedListener(this);
* if (timeout)
* messageClient.Timeout();
* else
* messageClient.Disconnect();
* }
* _messageClients.Clear();
* }
* //Notify destroy listeners.
* if (_destroyedListeners != null)
* {
* foreach (IClientListener listener in _destroyedListeners)
* {
* listener.ClientDestroyed(this);
* }
* }
* // Close any registered push handlers.
* if (_endpointPushHandlers != null && _endpointPushHandlers.Count != 0)
* {
* foreach (IEndpointPushHandler handler in _endpointPushHandlers.Values)
* {
* handler.Close();
* }
* _endpointPushHandlers = null;
* }
*
* foreach (IConnection connection in this.Connections)
* {
* if (timeout)
* connection.Timeout();
* connection.Close();
* }
* }
* catch(Exception ex)
* {
* if (log.IsErrorEnabled)
* log.Error(string.Format("Disconnect Client {0}", this.Id), ex);
* }
* finally
* {
* SetIsDisconnecting(false);
* SetIsDisconnected(true);
* }
* }
* }
*/
/*
* public IMessage[] GetPendingMessages(int waitIntervalMillis)
* {
* ArrayList messages = new ArrayList();
* try
* {
* SetIsPolling(true);
* do
* {
* _clientManager.LookupClient(this._id);//renew
*
* if (_messageClients != null)
* {
* foreach (MessageClient messageClient in _messageClients)
* {
* messageClient.Renew();
* messages.AddRange(messageClient.GetPendingMessages());
* }
* }
* if (waitIntervalMillis == 0)
* {
* return messages.ToArray(typeof(IMessage)) as IMessage[];
* }
* if (messages.Count > 0)
* {
* return messages.ToArray(typeof(IMessage)) as IMessage[];
* }
* System.Threading.Thread.Sleep(500);
* waitIntervalMillis -= 500;
* if (waitIntervalMillis <= 0)
* SetIsPolling(false);
* }
* while (this.IsPolling && !this.IsInvalidating && !this.IsValid);
* }
* catch (Exception ex)
* {
* if (log.IsErrorEnabled)
* log.Error(string.Format("GetPendingMessages Client {0}", this.Id), ex);
* }
* finally
* {
* SetIsPolling(false);
* }
* return messages.ToArray(typeof(IMessage)) as IMessage[];
* }
*/
/// <summary>
/// Adds a client destroy listener that will be notified when the client is destroyed.
/// </summary>
/// <param name="listener">The listener to add.</param>
public void AddClientDestroyedListener(IClientListener listener)
{
if (listener != null)
{
if (_destroyedListeners == null)
{
lock (this.SyncRoot) {
if (_destroyedListeners == null)
{
_destroyedListeners = new CopyOnWriteArray();
}
}
}
_destroyedListeners.AddIfAbsent(listener);
}
}
public Client(
NetConfig netConfig,
MessagePackSerializerOptions serverSerializerOptions,
MessagePackSerializerOptions clientsSerializerOptions,
IClientListener <TPlayerStatus, TRoomMessage, TMsg> listener
)
{
_netConfig = netConfig;
_serverSerializerOptions = serverSerializerOptions;
_clientsSerializerOptions = clientsSerializerOptions;
_gameMessages = new List <RelayedGameMessage>();
Id = null;
IsStarted = false;
_updateContext = new Queue <Action>();
_messageHandler = new MessageHandler <IClientMsg, IServerMsg>();
_listener = listener;
_manager = new NetManager(new Listener(this))
{
NatPunchEnabled = netConfig.NatPunchEnabled,
UpdateTime = netConfig.UpdateTime,
PingInterval = netConfig.PingInterval,
DisconnectTimeout = netConfig.DisconnectTimeout
};
#if DEBUG
var debugOnly = netConfig.DebugOnly;
if (debugOnly.SimulationPacketLossChance is int chance)
{
_manager.SimulatePacketLoss = true;
_manager.SimulationPacketLossChance = chance;
}
if (debugOnly.SimulationLatencyRange is (int min, int max))
{
_manager.SimulateLatency = true;
_manager.SimulationMinLatency = min;
_manager.SimulationMaxLatency = max;
}
#endif
}
/**
* Class constructor
*/
public Client(TransportClient transport, IClientListener clientListener)
{
this.clientListener = clientListener;
dispatcher = new ChannelDispatcher();
transport.SetChannelDispatcher(dispatcher);
surfaceServer = new SurfaceServer(transport, this);
dispatcher.RegisterChannel(surfaceServer);
sessionServer = new SessionServer(transport, this);
dispatcher.RegisterChannel(sessionServer);
inputServer = new InputServer(transport, this);
dispatcher.RegisterChannel(inputServer);
transport.StartThread();
dispatcher.OnConnect();
}
/**
* Class constructor
*/
public Client(TransportClient transport, IClientListener clientListener)
{
this.clientListener = clientListener;
dispatcher = new ChannelDispatcher();
transport.SetChannelDispatcher(dispatcher);
surfaceServer = new SurfaceServer(transport, this);
dispatcher.RegisterChannel(surfaceServer);
sessionServer = new SessionServer(transport, this);
dispatcher.RegisterChannel(sessionServer);
inputServer = new InputServer(transport, this);
dispatcher.RegisterChannel(inputServer);
transport.StartThread();
dispatcher.OnConnect();
}
public ServerTCP(string ip, int port, IClientListener clientListener, IMessageManager manager)
{
if (!IPAddress.TryParse(ip, out _ipAddress))
{
throw new ArgumentException("Incorrect IP", nameof(ip));
}
if (port < 1024 || port > 65535)
{
throw new ArgumentException("Incorrect port", nameof(port));
}
if (clientListener == null)
{
throw new ArgumentNullException(nameof(clientListener));
}
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
_port = port;
_clientListener = clientListener;
_manager = manager;
}
/// <summary>Adds a client listener to the server.</summary>
public void AddListener(IClientListener <Client> clientListener)
{
clientListener.ClientConnected += this.OnClientConnected;
this.AddDependency(clientListener);
}
/// <summary>
/// Unsubscribes from a Client.
/// </summary>
/// <param name="unsubscriber">The Unsubscriber.</param>
public void Unsubscribe(IClientListener unsubscriber)
{
_clientListeners.Remove(unsubscriber);
}
public static IClient CreateClient(IClientListener clientListener, string address, IConnectionLogger clientLogger = null)
{
return(new WebSocketClient(clientListener, address, clientLogger));
}
public HttpClientSender(JimuAddress address, IClientListener clientListener)
{
_address = address;
_clientListener = clientListener;
}
public NetworkOptions(IClientListener icl)
{
InitializeComponent();
this._mc = new ModuleClient(icl);
}
public ClientHandler(LoginDetails loginDetails, IClientListener listener)
{
_listener = listener;
_loginDetails = loginDetails;
}
/// <summary>
/// Adds a create listener that will be notified when new clients are created.
/// </summary>
/// <param name="listener">The listener to add.</param>
public static void AddClientCreatedListener(IClientListener listener)
{
if (listener != null)
_createdListeners.AddIfAbsent(listener);
}
public void AddListener(IClientListener listener) => this.listener = listener;
public void AddListener(IClientListener listener)
{
this.listeners.Add(listener);
}
/// <summary>
/// Unsubscribes from a Client.
/// </summary>
/// <param name="unsubscriber">The Unsubscriber.</param>
public void Unsubscribe(IClientListener unsubscriber)
{
_clientListeners.Remove(unsubscriber);
}
/*
internal void Disconnect(bool timeout)
{
lock (this.SyncRoot)
{
if (this.IsDisconnecting || this.IsDisconnected)
return;
try
{
SetIsDisconnecting(true);
//restore context
IConnection currentConnection = null;
if (this.Connections != null && this.Connections.Count > 0)
{
IEnumerator enumerator = this.Connections.GetEnumerator();
enumerator.MoveNext();
currentConnection = enumerator.Current as IConnection;
}
if (FluorineContext.Current == null)
{
_TimeoutContext context = new _TimeoutContext(currentConnection, this);
//WebSafeCallContext.SetData(FluorineContext.FluorineContextKey, context);
try
{
// See if we're running in full trust
new SecurityPermission(PermissionState.Unrestricted).Demand();
WebSafeCallContext.SetData(FluorineContext.FluorineContextKey, context);
}
catch (SecurityException)
{
System.Web.HttpContext ctx = System.Web.HttpContext.Current;
if (ctx != null)
ctx.Items[FluorineContext.FluorineContextKey] = context;
}
}
_clientManager.RemoveSubscriber(this);
// Unregister from all sessions.
if (_sessions != null && _sessions.Count != 0)
{
foreach (ISession session in _sessions)
UnregisterSession(session);
}
//Invalidate associated MessageClient subscriptions.
if (_messageClients != null)
{
foreach (MessageClient messageClient in _messageClients)
{
messageClient.RemoveMessageClientDestroyedListener(this);
if (timeout)
messageClient.Timeout();
else
messageClient.Disconnect();
}
_messageClients.Clear();
}
//Notify destroy listeners.
if (_destroyedListeners != null)
{
foreach (IClientListener listener in _destroyedListeners)
{
listener.ClientDestroyed(this);
}
}
// Close any registered push handlers.
if (_endpointPushHandlers != null && _endpointPushHandlers.Count != 0)
{
foreach (IEndpointPushHandler handler in _endpointPushHandlers.Values)
{
handler.Close();
}
_endpointPushHandlers = null;
}
foreach (IConnection connection in this.Connections)
{
if (timeout)
connection.Timeout();
connection.Close();
}
}
catch(Exception ex)
{
if (log.IsErrorEnabled)
log.Error(string.Format("Disconnect Client {0}", this.Id), ex);
}
finally
{
SetIsDisconnecting(false);
SetIsDisconnected(true);
}
}
}
*/
/*
public IMessage[] GetPendingMessages(int waitIntervalMillis)
{
ArrayList messages = new ArrayList();
try
{
SetIsPolling(true);
do
{
_clientManager.LookupClient(this._id);//renew
if (_messageClients != null)
{
foreach (MessageClient messageClient in _messageClients)
{
messageClient.Renew();
messages.AddRange(messageClient.GetPendingMessages());
}
}
if (waitIntervalMillis == 0)
{
return messages.ToArray(typeof(IMessage)) as IMessage[];
}
if (messages.Count > 0)
{
return messages.ToArray(typeof(IMessage)) as IMessage[];
}
System.Threading.Thread.Sleep(500);
waitIntervalMillis -= 500;
if (waitIntervalMillis <= 0)
SetIsPolling(false);
}
while (this.IsPolling && !this.IsInvalidating && !this.IsValid);
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
log.Error(string.Format("GetPendingMessages Client {0}", this.Id), ex);
}
finally
{
SetIsPolling(false);
}
return messages.ToArray(typeof(IMessage)) as IMessage[];
}
*/
/// <summary>
/// Adds a client destroy listener that will be notified when the client is destroyed.
/// </summary>
/// <param name="listener">The listener to add.</param>
public void AddClientDestroyedListener(IClientListener listener)
{
if (listener != null)
{
if (_destroyedListeners == null)
{
lock (this.SyncRoot)
{
if (_destroyedListeners == null)
_destroyedListeners = new CopyOnWriteArray();
}
}
_destroyedListeners.AddIfAbsent(listener);
}
}
/// <summary>
/// Removes a Client created listener.
/// </summary>
/// <param name="listener">The listener to remove.</param>
public static void RemoveClientCreatedListener(IClientListener listener)
{
if (listener != null)
_createdListeners.Remove(listener);
}
public void RemoveListener(IClientListener listener)
{
this.listeners.Remove(listener);
}
public ClientChannelHandler(Dictionary <ImMessageType, IClientMessageExecutor> executors, IClientListener clientListener, Action pingCall)
{
this.messageExecutors = executors;
this.channelListener = clientListener;
this.pingCall = pingCall;
}
/// <summary>
/// Subscribes to a Client.
/// </summary>
/// <param name="subscriber">The Subscriber.</param>
public void Subscribe(IClientListener subscriber)
{
_clientListeners.Add(subscriber);
}
/// <summary>
/// Removes a client destroy listener.
/// </summary>
/// <param name="listener">The listener to remove.</param>
public void RemoveClientDestroyedListener(IClientListener listener)
{
if (listener != null)
{
if (_destroyedListeners != null)
{
_destroyedListeners.Remove(listener);
}
}
}
