private void Slaving()
{
TcpServerSocket ClientServiceSocket = null;
try
{
ClientServiceSocket = new TcpServerSocket(this.EnvHostBase.LocalIpAddress, this._listenSlavePort);
do
{
// ClientServiceSocket.AcceptListen();
//if (ClientServiceSocket.Pending())
//{
//}
Thread.Sleep(200);
} while (!requestStop);
}
catch (Exception ex)
{
string ExceptionMsg = ex.Message + ex.StackTrace;
// write to log file ..
EnvLog.Writer(AssemblyInfoClass.ProductInfo, Log.Level.Error, ExceptionMsg, true);
}
finally
{
if (ClientServiceSocket != null)
{
// clean server socket resource ..
ClientServiceSocket.Close();
}
}
}
public EchoServer(TcpServerSocket socket)
: base(socket)
{
ClientDataReceived += (socket1, data) =>
{
socket1.Send(new TestMessage("TestMessage"));
};
}
public void Listen(int port)
{
TcpServerSocket tcpServerSocket = new TcpServerSocket();
this.socket = tcpServerSocket;
tcpServerSocket.OnClientConnected += delegate(TcpServerSocket sender, Socket client)
{
this.onConnected();
};
tcpServerSocket.Listen(port);
}
// 開始処理
private void Form_Load(object sender, EventArgs e)
{
// フォームのLoadイベントで開始処理を呼ぶ
tcpServerToolStrip.Begin(@"SETTING.INI", this.Text);
// ソケット
socket = tcpServerToolStrip.Socket;
// パケット数カウンタ表示
updateCounter();
}
/// <summary>
/// Starts listening for new connections.
/// </summary>
void StartServer(IPEndPoint _ipEndpoint)
{
// Starts listening if the server isn't already listening.
if (this.serverSocket == null || !this.serverSocket.Running)
{
this.serverSocket = new TcpServerSocket(_ipEndpoint)
{
ConnectedClients = new List <TcpClientSocket>()
};
// Subscribe to find when new clients are connected.
// <param="s"> The instance of the class that invoded the event. <param>
// <param="e"> AcceptedTcpSocketEventArgs (which contains the accepted socket, the remote endpoint, the tcpsocket connection state (e.g. an exception that has occured or if the socket is connected, if a data has been received and a reference to the socket in the socket object which can be used for extra purposes.))<param>
this.serverSocket.Accepted += (s, e) =>
{
this.serverSocket.ConnectedClients.Add(e.AcceptedSocket);
beginReceiving(this.serverSocket.ConnectedClients[this.serverSocket.ConnectedClients.IndexOf(e.AcceptedSocket)]);
TsslConnectedClients.Text = $"Connected Clients: {this.serverSocket.ConnectedClients.Count}";
};
this.serverSocket.ConnectedClients.Clear();
for (int i = 0; i < this.serverSocket.ConnectedClients.Count; i++)
{
this.serverSocket.ConnectedClients[i] = null;
}
try
{
this.serverSocket.Start();
if (rtbServerMessages.TextLength <= 0)
{
AppendText("Server started.", true);
}
else
{
AppendText("Server started.");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Unable to start the server.");
}
btnSend.Enabled = true;
tsslServerStatus.Text = "State: Running";
}
else
{
MessageBox.Show("The server is already started.", "Cannot Start Server");
}
}
static void initServer(string[] args)
{
int port = 0;
try {
port = int.Parse(args[1]);
var server = new TcpServerSocket();
server.OnDisconnect += onDisconnect;
server.Listen(port);
_socket = server;
start();
} catch (Exception) {
Console.WriteLine("Invalid port");
}
}
bool isSocketReady()
{
if (this.socket != null)
{
TcpServerSocket tcpServerSocket = this.socket as TcpServerSocket;
if (tcpServerSocket != null)
{
return(tcpServerSocket.count > 0);
}
TcpClientSocket tcpClientSocket = this.socket as TcpClientSocket;
if (tcpClientSocket != null)
{
return(tcpClientSocket.isConnected);
}
}
return(false);
}
public void Disconnect()
{
if (m_serverSocket != null)
{
UpdateBehaviour.RemoveUpdate(this);
m_serverSocket.OnClientConnect -= OnClientConnected;
m_serverSocket.OnClientDisconnect -= OnClientDisconnected;
m_serverSocket.OnReceive -= OnReceived;
m_serverSocket.OnDisconnect -= OnDisconnected;
if (m_serverSocket.IsConnected)
{
m_serverSocket.Disconnect();
}
m_serverSocket = null;
}
}
public override void Run(string[] args)
{
var port = 0;
try {
port = int.Parse(args[1]);
} catch (Exception) {
port = 3333;
}
var server = new TcpServerSocket();
_socket = server;
server.OnDisconnect += onDisconnect;
server.Listen(port);
server.OnReceive += onReceive;
Console.CancelKeyPress += onCancel;
while (true)
{
server.Send(Encoding.UTF8.GetBytes(Console.ReadLine()));
}
}
public void Listen(int port)
{
if (m_Port != port && m_serverSocket != null)
{
DebugLog.Warning("");
Disconnect();
}
m_Port = port;
m_serverSocket = new TcpServerSocket();
m_serverSocket.OnClientConnect += OnClientConnected;
m_serverSocket.OnClientDisconnect += OnClientDisconnected;
m_serverSocket.OnReceive += OnReceived;
m_serverSocket.OnDisconnect += OnDisconnected;
m_serverSocket.Listen(m_Port);
UpdateBehaviour.AddUpdate(this);
}
static void Server_HandleMessage(TcpServerSocket sender, string repoint, Message msg)
{
// if (rp == null)
rp = repoint;
lock (lck)
recCount++;
// Thread.Sleep(1);
//return;
//Console.WriteLine($"收到的信息为：{msg.Value}");
// if (reCount % 2 == 0)
{
//msg.Value = $"{reCount}Server:SendMessageAsync:{DateTime.Now}";
if (sender.SendMessageAsync(repoint, msg))
{
lock (lck2)
sendCount++;
}
}
// else
{
// msg.Value = $"{reCount}Server:SendMessage:{DateTime.Now}";
//sender.SendMessage(repoint, msg, 100000);
}
}
private void OnDisconnected(object sender, EventArgs e)
{
m_serverSocket = null;
}
void when_created()
{
TcpServerSocket server = null;
before = () => {
server = new TcpServerSocket();
};
it["has no connected clients"] = () => server.connectedClients.should_be(0);
it["is not listening"] = () => server.isConnected.should_be_false();
it["can disconnect without triggering event"] = () => {
server.OnDisconnect += (sender, e) => fail();
server.Disconnect();
};
it["can listen"] = () => {
server.Listen(Port);
server.isConnected.should_be_true();
// Cleanup
server.Disconnect();
};
it["can not listen when address is used"] = () => {
var blockingServer = new TcpServerSocket();
blockingServer.Listen(Port);
server.Listen(Port);
server.isConnected.should_be_false();
// Cleanup
blockingServer.Disconnect();
};
it["can not send"] = () => server.Send(new byte[] { 1, 2 });
context["when listening"] = () => {
before = () => {
server.Listen(Port);
};
after = () => {
try {
server.Disconnect();
} catch (Exception) {
}
};
it["can disconnect"] = () => {
var didDisconnect = false;
server.OnDisconnect += (sender, e) => didDisconnect = true;
server.Disconnect();
didDisconnect.should_be_true();
server.isConnected.should_be_false();
};
it["accepts connections"] = () => {
var clientConnected = false;
server.OnClientConnect += (sender, e) => clientConnected = true;
createAndConnectClient(Port);
server.connectedClients.should_be(1);
clientConnected.should_be_true();
};
it["accepts multiple connections"] = () => {
createAndConnectClient(Port);
createAndConnectClient(Port);
createAndConnectClient(Port);
server.connectedClients.should_be(3);
};
context["when connection accepted"] = () => {
Socket client1 = null;
Socket client2 = null;
before = () => {
client1 = createAndConnectClient(Port);
client2 = createAndConnectClient(Port);
};
it["can disconnect"] = () => {
server.Disconnect();
wait();
server.connectedClients.should_be(0);
};
it["receives client disconnect"] = () => {
var clientDidDisconntect = false;
server.OnReceive += (sender, e) => fail();
server.OnClientDisconnect += (sender, e) => clientDidDisconntect = true;
client1.Disconnect(false);
client1.Close();
wait();
server.connectedClients.should_be(1);
clientDidDisconntect.should_be_true();
};
it["receives message"] = () => {
var message = "Hello";
ReceiveEventArgs receiveEventArgs = null;
server.OnReceive += (sender, e) => receiveEventArgs = e;
client1.Send(Encoding.UTF8.GetBytes(message));
wait();
message.should_be(Encoding.UTF8.GetString(receiveEventArgs.bytes));
receiveEventArgs.client.should_not_be_null();
};
it["receives multiple messages"] = () => {
var message1 = "Hello1";
var message2 = "Hello2";
ReceiveEventArgs receiveEventArgs = null;
server.OnReceive += (sender, e) => receiveEventArgs = e;
client1.Send(Encoding.UTF8.GetBytes(message1));
wait();
message1.should_be(Encoding.UTF8.GetString(receiveEventArgs.bytes));
client1.Send(Encoding.UTF8.GetBytes(message2));
wait();
message2.should_be(Encoding.UTF8.GetString(receiveEventArgs.bytes));
};
it["can respond to client"] = () => {
var clientMessage = "Hello";
var serverMessage = "Hi";
var receivedMessage = string.Empty;
ReceiveEventArgs receiveEventArgs = null;
server.OnReceive += (sender, e) => receiveEventArgs = e;
client1.Send(Encoding.UTF8.GetBytes(clientMessage));
wait();
prepareForReceive(client1, msg => receivedMessage = msg);
server.SendWith(receiveEventArgs.client, Encoding.UTF8.GetBytes(serverMessage));
wait();
receivedMessage.should_be(serverMessage);
};
it["can send to all connected clients"] = () => {
var message = "Hello";
var client1ReceivedMessage = string.Empty;
var client2ReceivedMessage = string.Empty;
prepareForReceive(client1, msg => client1ReceivedMessage = msg);
prepareForReceive(client2, msg => client2ReceivedMessage = msg);
server.Send(Encoding.UTF8.GetBytes(message));
wait();
client1ReceivedMessage.should_be(message);
client2ReceivedMessage.should_be(message);
};
};
};
}
public static void Main(string[] args)
{
DataTable dt = new DataTable();
var dddd = dt.SerializeToByte();
int len = 1234445566;
byte[] d = new byte[4];
d[0] = (Byte)((len & 0x7f000000) >> 24);
d[1] = (Byte)((len & 0xff0000) >> 16);
d[2] = (Byte)((len & 0xff00) >> 8);
d[3] = (Byte)(len & 0xff);
int reciveObjLength = d[3];
reciveObjLength += (d[2] << 8);
reciveObjLength += d[1] << 16;
reciveObjLength += (d[0] & 0x7f) << 24;
Message msg = new Message();
var server = new TcpServerSocket();
//server.eShowMsg += Server_eShowMsg;
//server.HandleMessage += Server_HandleMessage;
server.OnError += Server_OnError;
if (server.Bind(23456))
{
server.Listen();
}
int lastSended = 0, lastRec = 0;
new Action <TcpServerSocket>((s) => {
while (true)
{
// while (sendCount < recCount)
{
//lock (lck2)
//sendCount += s.SendMessageAsync(msg);
// Thread.Sleep(1);
}
Thread.Sleep(10);
}
}).BeginInvoke(server, null, null);
while (true)
{
// if (rp != null)
{
// server.SendMessageAsync(msg);
// Thread.Sleep(1);
}
// else
{
Thread.Sleep(1000);
Console.WriteLine($"收到：{recCount} 发出：{sendCount} 客户端：{server.ClientCount}");
Console.Title = $"接收：{recCount - lastRec} 发出：{sendCount - lastSended} 客户端：{server.ClientCount}";
lastRec = recCount;
lastSended = sendCount;
}
//reCount = 0;
}
}
public void TcpTest()
{
object monitor = new object();
lock (monitor) {
bool clientMaySend = false;
int payloadCounter = 0;
Console.WriteLine("Starting server");
HashSet <Socket> connectedSockets = new HashSet <Socket>();
TcpServerSocket server = null;
server = new TcpServerSocket(socket => {
lock (monitor) {
lock (connectedSockets) {
Console.WriteLine("Server received client's connection");
connectedSockets.Add(socket);
}
}
}, (sender, buffer, size) => {
lock (monitor) {
Console.WriteLine("SRec " + size);
server.Send(sender, buffer, 0, size);
}
}, socket => {
lock (connectedSockets) {
Console.WriteLine("Server lost connection to client");
connectedSockets.Remove(socket);
}
}, connectedSockets, 1, Port);
byte[] sendBuffer = new byte[DataSize];
_random.NextBytes(sendBuffer);
Console.WriteLine("Starting client");
TcpClientSocket client = null;
client = new TcpClientSocket(() => {
lock (monitor) {
Console.WriteLine("Client connected to server");
if (clientMaySend)
{
Console.WriteLine("Client not waiting for main thread");
}
else
{
Console.WriteLine("Client waiting for main thread");
Monitor.Wait(monitor);
}
Console.WriteLine("Client sending first data");
client.Send(sendBuffer, 0, sendBuffer.Length);
}
}, error => {
lock (monitor) {
Console.WriteLine("Client failed to connect to server: " + error);
}
}, (buffer, size) => {
lock (monitor) {
Console.WriteLine("CRec " + size);
AssertArrayContentsEqualInFirstArrayLengthRange(sendBuffer, buffer);
if (++payloadCounter == PayloadCount)
{
Monitor.Pulse(monitor);
}
else
{
_random.NextBytes(sendBuffer);
client.Send(sendBuffer, 0, sendBuffer.Length);
}
}
}, () => Console.WriteLine("Client lost connection to server"));
client.Start(Ip, Port);
clientMaySend = true;
Monitor.Pulse(monitor);
Console.WriteLine("Main thread waiting");
Monitor.Wait(monitor);
Console.WriteLine("Closing client");
client.Close();
Console.WriteLine("Closing server");
server.Close();
}
}
