/// <summary>
/// Changes the port that the server is listening on to the given port.
/// </summary>
/// <param name="newPort">The given port.</param>
public static void ChangePort(int newPort)
{
lock (_syncRoot)
{
if (_socketServer == null)
{
return; //not initialized
}
//if there was not port change return.
if (_socketServer.PortNumber == newPort)
{
return;
}
try
{
SocketServer oldServer = _socketServer;
bool useAsyncHandler = _socketServer.MessageHandler is SocketServerAsyncMessageHandler;
bool whitelistOnly = _socketServer.WhitelistOnly;
_setupNewSocketServer(_myRelayNode, oldServer.InstanceName,
newPort, useAsyncHandler, _connectionWhitelist, whitelistOnly);
oldServer.Stop();
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
{
log.Error("Error changing listen port: {0}", ex);
}
}
}
}
public async Task TestSessionCount()
{
var server = new SocketServer();
var dic = new Dictionary <string, string>
{
{ "name", "TestServer" },
{ "listeners:0:ip", "Any" },
{ "listeners:0:port", "4040" }
};
var builder = new ConfigurationBuilder().AddInMemoryCollection(dic);
var config = builder.Build();
Assert.True(server.Configure(config));
Assert.Equal("TestServer", server.Name);
Assert.True(server.Start());
Assert.Equal(0, server.SessionCount);
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 4040));
await Task.Delay(1);
Assert.Equal(1, server.SessionCount);
server.Stop();
}
static void Main(string[] args)
{
encoding = Encoding.ASCII;
SocketServer server;
server = new SocketServer(new IPEndPoint(IPAddress.Loopback, 0));
server.Connected.Subscribe(c =>
{
serverClient = new FramedClient(c);
// When received is called, bs will contain no more and no less
// data than whole packet as sent from client.
serverClient.Received.Subscribe(bs =>
{
var msg = encoding.GetString(bs.Array, bs.Offset, bs.Count);
msg = "Hello, " + msg + "!";
serverClient.SendPacket(encoding.GetBytes(msg));
});
});
server.Start();
HandleClient(server.BindEndPoint.Port);
Console.WriteLine("Press any key to stop...");
Console.ReadKey();
server.Stop();
client.Close();
serverClient.Close();
}
/// <summary>
/// 析构函数
/// </summary>
public void Close()
{
client.Close();
server.Stop();
threadOut.Stop();
threadIn.Stop();
}
private static void CheckReconnection(StatsdConfig config)
{
SocketServer server = null;
try
{
server = new SocketServer(config);
using (var service = new DogStatsdService())
{
service.Configure(config);
service.Increment("test1");
Assert.AreEqual("test1:1|c", server.Stop().Single());
server.Dispose();
// Send a metric when the server is not running.
service.Increment("test2");
Task.Delay(TimeSpan.FromMilliseconds(500)).Wait();
// Restart the server
server = new SocketServer(config, removeUDSFileBeforeStarting: true);
service.Increment("test3");
service.Dispose();
Assert.AreEqual("test3:1|c", server.Stop().Last());
}
}
finally
{
server?.Dispose();
}
}
private void btnInit_Click(object sender, EventArgs e)
{
if (txtIp.Text.Trim() == string.Empty || txtPort.Text.Trim() == string.Empty)
{
txtLog.AppendText("Ip or port is enpty ...\r\n");
}
else
{
if (btnInit.Text == "Start")
{
btnInit.Text = "Stop";
txtIp.Enabled = txtPort.Enabled = false;
txtMsg.Enabled = btnAllSend.Enabled = lvBroker.Enabled = true;
_socketServer.Start(txtIp.Text, int.Parse(txtPort.Text), 200);
}
else
{
btnInit.Text = "Start";
txtIp.Enabled = txtPort.Enabled = true;
txtMsg.Enabled = btnAllSend.Enabled = lvBroker.Enabled = btnOnlySend.Enabled = false;
_socketServer.Stop();
}
}
}
public void Stop()
{
_socketServer.Stop();
_serviceDiscovery.Stop();
_trackStateMonitor.Stop();
_playerStateMonitor.Stop();
_libraryScanner.Stop();
}
// Click event of "Pause" button
public void OnPauseButtonClicked()
{
if (server == null)
{
return;
}
server.Stop();
}
public void Stop()
{
_socketServer.Stop();
_ahemClientManager.Dispose();
_storageSaver.Stop();
Running = false;
OnMessageRecived?.Invoke("Server stopped");
}
// AVRO-625 [Test]
public void CancelPendingRequestsOnTransceiverClose()
{
// Start up a second server so that closing the server doesn't
// interfere with the other unit tests:
var blockingSimpleImpl = new BlockingSimpleImpl();
var responder = new SpecificResponder <Simple>(blockingSimpleImpl);
var server2 = new SocketServer("localhost", 0, responder);
server2.Start();
try
{
int serverPort = server2.Port;
var transceiver2 = new SocketTransceiver("localhost", serverPort);
var addFuture = new CallFuture <int>();
try
{
var simpleClient2 = SpecificRequestor.CreateClient <SimpleCallback>(transceiver2);
// The first call has to block for the handshake:
Assert.AreEqual(3, simpleClient2.add(1, 2));
// Now acquire the semaphore so that the server will block:
blockingSimpleImpl.acquireRunPermit();
simpleClient2.add(1, 2, addFuture);
}
finally
{
// When the transceiver is closed, the CallFuture should get
// an IOException
transceiver2.Close();
}
bool ioeThrown = false;
try
{
addFuture.WaitForResult(2000);
}
catch (Exception)
{
}
//catch (ExecutionException e) {
// ioeThrown = e.getCause() instanceof IOException;
// Assert.assertTrue(e.getCause() instanceof IOException);
//} catch (Exception e) {
// e.printStackTrace();
// Assert.fail("Unexpected Exception: " + e.toString());
//}
Assert.IsTrue(ioeThrown, "Expected IOException to be thrown");
}
finally
{
blockingSimpleImpl.releaseRunPermit();
server2.Stop();
}
}
private void OnLoginEnded(string obj)
{
Debug.LogWarning(obj);
int splitPosition = obj.IndexOf(' ');
LoginCallback(obj.Substring(0, splitPosition) == "SUCCESS", obj.Substring(splitPosition + 1));
socketServer.Stop();
socketServer = null;
}
public void Dispose()
{
bCloseSocket = true;
if (_server != null)
{
_server.Stop();
_server.Dispose();
}
}
static void Main(string[] args)
{
var server = new SocketServer();
server.Start();
if (Console.ReadLine() == "quit")
{
server.Stop();
}
}
/// <summary>
/// Stops this virtualized service. When used as Virtual Server, it will release all services descriptions and network resources like TCP Port.
/// When the service is stopped, the virtual server will not reply anymore.
/// </summary>
public override void Stop()
{
if (sersock != null)
{
sersock.Stop();
sersock = null;
}
IsRunning = false;
EmiService.Stop();
}
public void Close()
{
foreach (var session in SocketServer.GetAllSessions())
{
session.CloseWithHandshake("Server is stopping");
}
SocketServer.Stop();
log.Info("WebSocket server was closed");
}
private void btnStop_Click(object sender, EventArgs e)
{
if (server?.Running == true)
{
server.Stop();
}
btnStart.Enabled = server.Running;
btnStop.Enabled = !server.Running;
}
public static void StopAndAssertStopped(this SocketServer server)
{
var stopped = new ManualResetEventSlim(false);
server.Stopped.Subscribe(_ =>
{
stopped.Set();
});
server.Stop();
stopped.AssertWaitFor(3000);
}
/// <summary>
/// Stops the server from listening on a port.
/// </summary>
public static void Shutdown()
{
lock (_syncRoot)
{
if (_socketServer != null && _socketServer.IsRunning)
{
_socketServer.Stop();
_socketServer = null;
}
}
}
public async Task Stop()
{
if (!_isRunning)
{
return;
}
_socketServer.OnClientMessage -= HandleClientCommand;
await _socketServer.Stop();
_isRunning = false;
}
public void Stop()
{
// Setup
Mock <ISocket> mockSocket = new Mock <ISocket>();
SocketServer socketServer = new SocketServer();
socketServer.Start(mockSocket.Object, 6128);
// Act
socketServer.Stop();
// Verify
mockSocket.Verify(s => s.Close(), Times.Once());
}
public void Stop()
{
if (!IsRunning)
{
return;
}
//close All client
MonitorPool.Singleton.Exit();
IsRunning = false;
ServiceServer.Stop();
Server.Stop();
}
public static void Main1(String[] args)
{
Common.SocketIsDebug = true;
IPAddress addr = IPAddress.Parse("192.168.32.1");
SocketServer server = new SocketServer(addr, 8888);
server.OnClientConnected += server_OnClientConnected;
server.OnServerRecevied += server_OnServerRecevied;
server.OnClientThreadStop += server_OnClientThreadStop;
server.OnClientDisConnected += server_OnClientDisConnected;
server.Start();
Console.Read();
server.Stop();
}
public void Stop()
{
server.Stop();
executor.Enqueue(() =>
{
isStopped = true;
pingTimer.Change(Timeout.Infinite, Timeout.Infinite);
foreach (var client in clients)
{
client.Close();
}
});
}
protected void Application_End(object sender, EventArgs e)
{
Logger.LogInformation("Stopping Game Server");
if (_policyServer != null)
{
_policyServer.Stop();
}
if (_socketServer != null)
{
_socketServer.Stop();
}
Game.Server.Stop();
_serverThread.Abort();
}
public void ClientReconnectAfterServerRestart()
{
// Start up a second server so that closing the server doesn't
// interfere with the other unit tests:
SimpleImpl simpleImpl = new BlockingSimpleImpl();
var responder = new SpecificResponder <Simple>(simpleImpl);
var server2 = new SocketServer("localhost", 0, responder);
server2.Start();
try
{
int serverPort = server2.Port;
// Initialize a client, and establish a connection to the server:
Transceiver transceiver2 = new SocketTransceiver("localhost", serverPort);
var simpleClient2 =
SpecificRequestor.CreateClient <SimpleCallback>(transceiver2);
Assert.AreEqual(3, simpleClient2.add(1, 2));
// Restart the server:
server2.Stop();
try
{
simpleClient2.add(2, -1);
Assert.Fail("Client should not be able to invoke RPCs because server is no longer running");
}
catch (Exception)
{
// Expected since server is no longer running
}
Thread.Sleep(2000);
server2 = new SocketServer("localhost", serverPort, new SpecificResponder <Simple>(new SimpleImpl()));
server2.Start();
// Invoke an RPC using the same client, which should reestablish the
// connection to the server:
Assert.AreEqual(3, simpleClient2.add(1, 2));
}
finally
{
server2.Stop();
}
}
static void Main(string[] args)
{
//TcpServer = new SocketServer(NetworkType.Tcp, IPAddress.Loopback, 5400);
//TcpServer.OnConnected += UdpServer_OnConnected;
//TcpServer.OnDisconnected += UdpServer_OnDisconnected;
//TcpServer.OnError += UdpServer_OnError;
//TcpServer.OnReceived += UdpServer_OnReceived;
//TcpServer.OnStart += UdpServer_OnStart;
//TcpServer.OnStop += UdpServer_OnStop;
//Console.WriteLine("Starting tcp server");
//TcpServer.Start();
//SocketClient TcpClient = new SocketClient(NetworkType.Tcp);
//TcpClient.OnConnected += TcpClient_OnConnected;
//TcpClient.OnDisconnected += TcpClient_OnDisconnect;
//TcpClient.OnReceived += TcpClient_OnReceived;
//TcpClient.Connect(IPAddress.Loopback, 5400);
//TcpClient.Disconnect();
//TcpServer.Stop();
UdpServer = new SocketServer(NetworkType.Udp, IPAddress.Loopback, 5401);
UdpServer.OnConnected += UdpServer_OnConnected;
UdpServer.OnDisconnected += UdpServer_OnDisconnected;
UdpServer.OnError += UdpServer_OnError;
UdpServer.OnReceived += UdpServer_OnReceived;
UdpServer.OnStart += UdpServer_OnStart;
UdpServer.OnStop += UdpServer_OnStop;
Console.WriteLine("Starting udp server");
UdpServer.Start();
SocketClient UdpClient = new SocketClient(NetworkType.Udp);
UdpClient.OnConnected += TcpClient_OnConnected;
UdpClient.OnDisconnected += TcpClient_OnDisconnect;
UdpClient.OnReceived += TcpClient_OnReceived;
UdpClient.Connect(IPAddress.Loopback, 5401);
Console.ReadKey();
for (int i = 0; i < 100000; ++i)
{
UdpClient.Socket.Send(Encoding.Default.GetBytes($"Hello my dear friends {i}"));
Thread.Sleep(1);
}
Console.ReadKey();
UdpClient.Disconnect();
Console.ReadKey();
UdpServer.Stop();
Console.ReadKey();
}
private void SwitchTcpServer(object sender, RoutedEventArgs e)
{
if (_isServerStarted)
{
_isServerStarted = !_socketServer.Stop();
}
else
{
if (!TryParseIpEndPoint(out IPEndPoint endPoint))
{
LblMessage.Content = "错误IP地址或端口号！";
}
else
{
_isServerStarted = _socketServer.StartServer(endPoint);
}
}
SwitchServerButton();
}
static void Main(string[] args)
{
ushort port = DefaultPort;
var serverName = DefaultServerName;
if (args.Length > 1)
{
serverName = args[0];
if (!ushort.TryParse(args[1], out port) || port == 0)
{
Console.WriteLine("Port must be a number between 1 and 65535");
Console.Read();
return;
}
}
IServer server = new SocketServer();
server.OnClientConnected += (roomId, clientId) => Console.WriteLine($"{DateTime.Now.ToLongTimeString()} Client connected. RoomId = {roomId}, ClientId = {clientId}");
server.OnClientDisconnected += c => Console.WriteLine($"{DateTime.Now.ToLongTimeString()} Client disconnected: {c}");
server.OnError += exc => Console.WriteLine($"{DateTime.Now.ToLongTimeString()} Error: {exc.Message}");
server.OnRoomCreated += r => Console.WriteLine($"{DateTime.Now.ToLongTimeString()} Room created: {r}");
server.OnRoomDestroyed += r => Console.WriteLine($"{DateTime.Now.ToLongTimeString()} Room destroyed: {r}");
//server.OnMessageReceived += (roomId, clientId, text) => Console.WriteLine($"{DateTime.Now.ToLongTimeString()} Message received. RoomId = {roomId}, ClientId = {clientId}, Text = {text}");
try
{
server.Run(serverName, port);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine($"Server started on {serverName}:{port}");
Console.WriteLine("Press any key to exit");
Console.Read();
server.Stop();
}
public void SendDataBetweenTwentyTcpClientsAndOneTcpServer()
{
var resetEvent = new ManualResetEvent(false);
var address = IPAddress.Loopback;
var port = 55555;
var numberClients = 20;
var results = new ConcurrentDictionary <IPEndPoint, Byte[]>();
var clients = new List <SocketClient>();
var server = new SocketServer(address, port);
server.ReceivedData += (s, e) => {
var data = results.ContainsKey(e.RemotePoint) ? results[e.RemotePoint] : new Byte[] { };
data = data.Concat(e.ReceivedData);
results[e.RemotePoint] = data;
};
server.Start();
for (var i = 0; i < numberClients; i++)
{
var client = new SocketClient();
client.Connect(address, port);
clients.Add(client);
}
for (var i = 0; i < numberClients; i++)
{
clients[i].SendData(_data);
}
resetEvent.WaitOne(WAIT_TIMEOUT);
server.Stop();
server.Dispose();
for (var i = 0; i < numberClients; i++)
{
clients[i].Dispose();
}
Assert.AreEqual(numberClients, results.Count);
foreach (Byte[] data in results.Values)
{
CollectionAssert.AreEqual(_data, data);
}
}
static void Main(string[] args)
{
//SimplySocket();
//return;
byte[] val = new byte[] { 0x58, 0x59, 0x5A, 0x41 };
var i = val.GetString(0, 4);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
server = new CurrencyStore.Communication.Server.SocketServer();
server.Start();
Thread.Sleep(1000);
var th = new Thread(new ThreadStart(DrawDisplay));
th.Start();
Console.ReadLine();
exit = true;
server.Stop();
}
