void Awake()
{
Application.runInBackground = true;
DontDestroyOnLoad(this);
prot = new SimpleProtocolFilter();
rpc = new RPCParser();
rpc.addRpcMethod("Add", Add);
rpc.addRpcMethod("Screenshot", Screenshot);
rpc.addRpcMethod("GetScreenSize", GetScreenSize);
rpc.addRpcMethod("Dump", Dump);
rpc.addRpcMethod("GetDebugProfilingData", GetDebugProfilingData);
rpc.addRpcMethod("SetText", SetText);
rpc.addRpcMethod("GetSDKVersion", GetSDKVersion);
mRunning = true;
server = new AsyncTcpServer(port);
server.Encoding = Encoding.UTF8;
server.ClientConnected +=
new EventHandler <TcpClientConnectedEventArgs> (server_ClientConnected);
server.ClientDisconnected +=
new EventHandler <TcpClientDisconnectedEventArgs> (server_ClientDisconnected);
server.DatagramReceived +=
new EventHandler <TcpDatagramReceivedEventArgs <byte[]> > (server_Received);
server.Start();
Debug.Log("Tcp server started");
}
public FrmMain()
{
log = flf.CreateLogger();
try
{
InitializeComponent();
dic = new ProcessControVariables().SetKeyValue();
LogFactory.Assign(new ConsoleLogFactory());
// 异步通讯初始化 端口10001 编码UTF8
server = new AsyncTcpServer(10001);
server.Encoding = Encoding.UTF8;
// 客户端连接事件
server.ClientConnected +=
new EventHandler <TcpClientConnectedEventArgs>(server_ClientConnected);
// 客户端断开事件
server.ClientDisconnected +=
new EventHandler <TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
// 接受string类型电文事件
server.PlaintextReceived +=
new EventHandler <TcpDatagramReceivedEventArgs <string> >(server_PlaintextReceived);
// 接受byte[]类型电文事件
server.DatagramReceived += new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(server_DatagramReceived);
frmMM.ManualOperationOrders += FrmMM_ManualOperationOrders;
// 启动服务程序
server.Start();
}
catch (Exception ex) { log.Exception(ex); }
}
// Use this for initialization
void Start()
{
asyncServer = new AsyncTcpServer(IPAddress.Any, 11999);
asyncServer.MessageReceived += HandleMessageReceived;
asyncServer.DisConnectClient += HandlerDisConnect;
asyncServer.Start();
}
public void Start(int port)
{
server = new AsyncTcpServer(port);
server.Encoding = Encoding.UTF8;
server.OnClientConnected = MT_OnClientConnected;
server.OnClientDisconnected = MT_OnClientDisconnected;
server.OnDatagramReceived = MT_OnDatagramReceived;
server.Start();
}
/// <summary>启动监听服务</summary>
public bool StartListener()
{
try
{
Console.Write("启动监听服务");
server.Start();
Console.WriteLine(" -> 完成.");
return(true);
}
catch (Exception ex)
{
Console.WriteLine(" -> listener.start.error.");
Console.WriteLine(ex.Message);
}
return(false);
}
void StartServer()
{
if (!isTcpStart)
{
LogTool.Log(ipAddress + ":" + tcpPort);
if (tcpServer == null)
{
tcpServer = new AsyncTcpServer(IPAddress.Parse(ipAddress), tcpPort);
tcpServer.maxConnectCount = maxCount;
tcpServer.Start();
tcpServer.DataReceived += Server_DataReceived;
heartBeat = Loom.StartSingleThread(HeartBeat, System.Threading.ThreadPriority.AboveNormal, true);
checkHeartBeat = Loom.StartSingleThread(CheckHeatBeat, System.Threading.ThreadPriority.Normal, true);
}
isTcpStart = true;
}
}
public MainProcess()
{
RootPath = Environment.CurrentDirectory;
_context = SynchronizationContext.Current;
string msg = $"System start ";
Logger(msg);
server = new AsyncTcpServer(9999);
server.Encoding = Encoding.UTF8;
server.ClientConnected +=
new EventHandler <TcpClientConnectedEventArgs>(server_ClientConnected);
server.ClientDisconnected +=
new EventHandler <TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
server.PlaintextReceived +=
new EventHandler <TcpDatagramReceivedEventArgs <string> >(server_PlaintextReceived);
server.Start();
Logger("Server listening");
#region Gocator Initi
gocator.DeviceStatusEvent += Gocator_DeviceStatusEvent;
gocator.OnDataReceivedEvent += Gocator_OnDataReceivedEvent;
gocator.InitialAcq();
#endregion
#region UI Binding
Run = new RelayCommand(RunExcute, RunCanExcute);
Stop = new RelayCommand(StopExcute, StopCanExcute);
LineEditor01 = new RelayCommand(LineEditor01Excute, LineEditor01CanExcute);
LineEditor02 = new RelayCommand(LineEditor02Excute, LineEditor02CanExcute);
LineEditor03 = new RelayCommand(LineEditor03Excute, LineEditor03CanExcute);
Match = new RelayCommand(MatchExcute, MatchCanExcute);
Debug = new RelayCommand(DebugExcute, DebugCanExcute);
ImageSourceTop = new BitmapImage(new Uri(ConfigPath.LogoPath));
ImageSourceBottom = new BitmapImage(new Uri(ConfigPath.LogoPath));
#endregion
#region AVL RunTime
try
{
string avsProjectPath = ConfigPath.AVProgramPath;
macros = SinvoProgramMacrofilters.Create(avsProjectPath);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
#endregion
}
/// <summary>
/// 服务器启动，核心部分
/// </summary>
void startserver()
{
ClientList.ctPrint += ShowLog;
try
{
ALLOffLine();
server = new AsyncTcpServer(2758);//-----端口号改成： 2758-----
server.Encoding = Encoding.ASCII;
server.ClientConnected += new EventHandler <TcpClientConnectedEventArgs>(server_ClientConnected);
server.ClientDisconnected += new EventHandler <TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
server.DatagramReceived += new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(server_DatagramReceived);
server.Start();
}
catch (Exception)
{
txtLog.Text += "服务器启动失败";
}
}
static void Main(string[] args)
{
LogFactory.Assign(new ConsoleLogFactory());
server = new AsyncTcpServer(9999);
server.Encoding = Encoding.UTF8;
server.ClientConnected += new EventHandler <TcpClientConnectedEventArgs>(server_ClientConnected);
server.ClientDisconnected += new EventHandler <TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
server.PlaintextReceived += new EventHandler <TcpDatagramReceivedEventArgs <string> >(server_PlaintextReceived);
server.Start();
Console.WriteLine("TCP server has been started.");
Console.WriteLine("Type something to send to client...");
while (true)
{
string text = Console.ReadLine();
server.SendToAll(text);
}
}
private static List <TcpClient[]> battleList = new List <TcpClient[]>(); //对战列表
static void Main(string[] args)
{
server = new AsyncTcpServer(8088);
server.Encoding = Encoding.UTF8;
//注册事件
server.ClientConnected +=
new EventHandler <TcpClientConnectedEventArgs>(server_ClientConnected);
server.ClientDisconnected +=
new EventHandler <TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
server.DatagramReceived +=
new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(server_DatagramReceived);
server.Start();
Console.WriteLine("TCP server has been started.");
Console.WriteLine("Type something to send to client...");
while (true)
{
string text = Console.ReadLine();
server.SendAll(text);
}
}
/// <summary>
/// 开始监控
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void StartMonitorClicked(object sender, RoutedEventArgs e)
{
//初始化Tcp服务器
if (tcpServer == null)
{
tcpServer = new AsyncTcpServer(IPAddress.Any, 6666);
tcpServer.ClientConnected += tcpServer_ClientConnected;
tcpServer.ClientDisconnected += tcpServer_ClientDisconnected;
}
//开始监控
tcpServer.Start();
//开始监控线程，定时向客户端发送服务状态
if (monitorThread == null)
{
monitorThread = new Thread(SendServiceInfos);
monitorThread.IsBackground = true;
monitorThread.Start();
}
lblStatus.Content = "监控中...";
}
private void BtnStart_Click(object sender, EventArgs e)
{
try
{
if (tcpServer == null)
{
tcpServer = new AsyncTcpServer(ConfigHelper.AppSettings <int>("ServerPort"));
tcpServer.Encoding = Encoding.UTF8;
tcpServer.ClientConnected += TcpServer_ClientConnected;
tcpServer.ClientDisconnected += TcpServer_ClientDisconnected;
tcpServer.DatagramReceived += TcpServer_DatagramReceived;
}
tcpServer.Start();
context.Logger.WriteLog("服务已启动！");
SetButtonEnabled(true);
}
catch (Exception ex)
{
context.Logger.WriteLog("服务启动失败：" + ex.ToString());
}
}
/// <summary>
/// 服务器启动关闭
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnStart_Click(object sender, EventArgs e)
{
if (server.IsRunning)
{
try
{
server.Stop();
lock (CurrentClient)
{
CurrentClient.Clear();
}
label1.BeginInvoke(new EventHandler(delegate
{
label1.Text = "0";
}));
btnStart.Text = "启动服务";
}
catch (Exception ex) { }
}
else
{
try
{
server = new AsyncTcpServer(2758);
server.Encoding = Encoding.ASCII;
server.ClientConnected += new EventHandler <TcpClientConnectedEventArgs>(server_ClientConnected);
server.ClientDisconnected += new EventHandler <TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
server.DatagramReceived += new EventHandler <TcpDatagramReceivedEventArgs <byte[]> >(server_DatagramReceived);
server.Start(2049);
btnStart.Text = "停止服务";
}
catch (Exception ex)
{
LogHelper.showLog(txtLog, "服务器启动失败" + ex.Message);
}
}
}
static void Main(string[] args)
{
AsyncTcpServer srv = new AsyncTcpServer(new IPEndPoint(IPAddress.Any, 50001));
srv.Start();
MessageReceiver receiver = new MessageReceiver(srv);
MovingWindowSequence seq = new MovingWindowSequence(1000*60, 1000*5*60);
string mongoUrl = File.ReadAllText("settings\\mongoConnection");
//CountersDatabase.InitConnection(mongoUrl);
var observableEvents = receiver.ObservableEvents.Buffer(seq.BufferOpenings, seq.ClosingWindowSequenceSelector).Publish();
//observableEvents.Connect();
Settings settings = new Settings();
settings.ObservableEvents = observableEvents;
settings.ReadAggregators();
CountersAutoDiscoverer countersAutoDiscoverer = new CountersAutoDiscoverer(receiver.ObservableEvents, settings);
countersAutoDiscoverer.StartDiscovery();
CounterDumper counterDumper = new CounterDumper(receiver.ObservableEvents);
CounterForwarder counterForwarder = new CounterForwarder(receiver.ObservableEvents);
DeadCountersDetector deadCountersDetector = new DeadCountersDetector(receiver.ObservableEvents, settings);
observableEvents.Subscribe(l => Console.WriteLine("Total events: " + l.Count));
ConsoleKeyInfo keyInfo;
while ((keyInfo = Console.ReadKey()).Key !=ConsoleKey.Enter)
{
if (keyInfo.Key == ConsoleKey.Add)
{
seq.IncreaseInterval(1000);
Console.WriteLine("Interval is {0} ms now", seq.MoveEvery);
}
if (keyInfo.Key == ConsoleKey.Subtract)
{
seq.DecreaseInterval(1000);
Console.WriteLine("Interval is {0} ms now", seq.MoveEvery);
}
if (keyInfo.Key == ConsoleKey.R)
{
settings.ReadAggregators();
Console.WriteLine("Aggregators were updated");
}
if (keyInfo.Key == ConsoleKey.F)
{
if (counterForwarder.IsForwarding)
{
counterForwarder.StopForwarding();
Console.WriteLine("Forwarding stopped");
}
else
{
counterForwarder.StartForwarding();
Console.WriteLine("Forwarding started");
}
}
if (keyInfo.Key == ConsoleKey.D)
{
if (counterDumper.IsDumping)
{
counterDumper.StopDumping();
Console.WriteLine("Counter Dumping Stopped");
}
else
{
counterDumper.StartDumping();
Console.WriteLine("Counter Dumping Started");
}
}
if (keyInfo.Key == ConsoleKey.A)
{
File.WriteAllText("deadCounters",deadCountersDetector.GetCounterFreshnessTimeStats());
Console.WriteLine("Stats have been written to file deadCounters");
}
}
}
static void Main(string[] args)
{
AsyncTcpServer srv = new AsyncTcpServer(new IPEndPoint(IPAddress.Any, 50001));
srv.Start();
MessageReceiver receiver = new MessageReceiver(srv);
MovingWindowSequence seq = new MovingWindowSequence(1000 * 60, 1000 * 5 * 60);
string mongoUrl = File.ReadAllText("settings\\mongoConnection");
//CountersDatabase.InitConnection(mongoUrl);
var observableEvents = receiver.ObservableEvents.Buffer(seq.BufferOpenings, seq.ClosingWindowSequenceSelector).Publish();
//observableEvents.Connect();
Settings settings = new Settings();
settings.ObservableEvents = observableEvents;
settings.ReadAggregators();
CountersAutoDiscoverer countersAutoDiscoverer = new CountersAutoDiscoverer(receiver.ObservableEvents, settings);
countersAutoDiscoverer.StartDiscovery();
CounterDumper counterDumper = new CounterDumper(receiver.ObservableEvents);
CounterForwarder counterForwarder = new CounterForwarder(receiver.ObservableEvents);
DeadCountersDetector deadCountersDetector = new DeadCountersDetector(receiver.ObservableEvents, settings);
observableEvents.Subscribe(l => Console.WriteLine("Total events: " + l.Count));
ConsoleKeyInfo keyInfo;
while ((keyInfo = Console.ReadKey()).Key != ConsoleKey.Enter)
{
if (keyInfo.Key == ConsoleKey.Add)
{
seq.IncreaseInterval(1000);
Console.WriteLine("Interval is {0} ms now", seq.MoveEvery);
}
if (keyInfo.Key == ConsoleKey.Subtract)
{
seq.DecreaseInterval(1000);
Console.WriteLine("Interval is {0} ms now", seq.MoveEvery);
}
if (keyInfo.Key == ConsoleKey.R)
{
settings.ReadAggregators();
Console.WriteLine("Aggregators were updated");
}
if (keyInfo.Key == ConsoleKey.F)
{
if (counterForwarder.IsForwarding)
{
counterForwarder.StopForwarding();
Console.WriteLine("Forwarding stopped");
}
else
{
counterForwarder.StartForwarding();
Console.WriteLine("Forwarding started");
}
}
if (keyInfo.Key == ConsoleKey.D)
{
if (counterDumper.IsDumping)
{
counterDumper.StopDumping();
Console.WriteLine("Counter Dumping Stopped");
}
else
{
counterDumper.StartDumping();
Console.WriteLine("Counter Dumping Started");
}
}
if (keyInfo.Key == ConsoleKey.A)
{
File.WriteAllText("deadCounters", deadCountersDetector.GetCounterFreshnessTimeStats());
Console.WriteLine("Stats have been written to file deadCounters");
}
}
}
static void Main(string[] args)
{
AsyncTcpServer tcpServer = new AsyncTcpServer(IPAddress.Parse("127.0.0.1"), 8000);
tcpServer.Start();
}
private void Form1_Load(object sender, EventArgs e)
{
System.Diagnostics.Debug.WriteLine("ABC");
server = new AsyncTcpServer(IPAddress.Parse("127.0.0.1"), 9999);
server.Encoding = Encoding.UTF8;
server.ClientConnected += server_ClientConnected;
server.ClientDisconnected += server_ClientDisconnected;
server.DatagramReceived += server_DatagramReceived;
server.Start();
}
public void Start()
{
_server.Start(10);
_server.ClientConnected += new EventHandler <TcpClientConnectedEventArgs>(OnClientConnected);
_server.ClientDisconnected += new EventHandler <TcpClientDisconnectedEventArgs>(OnClientDisconnected);
}
static void Main(string[] args)
{
#region Fileds
AsyncTcpServer server = null;
int totalNum = 0, rownum = 0, columnum = 0, usedcabinet = 0;
string rangeRule = "";
string serverip = "";
int serverport = 0;
#endregion
#region Initial
#region 读取箱体配置文件
try
{
ConfigLoad conip = new ConfigLoad(configPath);
totalNum = conip.GetIntValue("totalNum");
rangeRule = conip.GetStringValue("rangeRule");
rownum = conip.GetIntValue("rowNum");
columnum = conip.GetIntValue("colunNum");
usedcabinet = conip.GetIntValue("usedNum");
serverip = conip.GetStringValue("ServerIP");
serverport = conip.GetIntValue("ServerPort");
}
catch (Exception ex)
{
Logger.Custom("log/", $"load config failed with error:{ex}");
}
strsend = totalNum.ToString("000") + "-" + rangeRule + "-" + rownum.ToString("000") + "-"
+ columnum.ToString("000") + "-" + usedcabinet.ToString("000");
Console.WriteLine(strsend);
#endregion
#region 启动服务器
try
{
Console.WriteLine("sever is starting.....");
Logger.Custom("log/", "sever is starting.....");
server = new AsyncTcpServer(IPAddress.Parse("192.168.2.20"), 10001);
//server = new AsyncTcpServer(IPAddress.Parse("127.0.0.1"), 10001);
server.ClientConnected += new EventHandler <TcpClientConnectedEventArgs>(Server_ClientConnected);
server.ClientDisconnected += new EventHandler <TcpClientDisconnectedEventArgs>(Server_ClientDisconnected);
server.PlaintextReceived += new EventHandler <TcpDatagramReceivedEventArgs <string> >(Server_PlaintextReceived);
server.Start();
Console.WriteLine($"server is started");
Logger.Custom("log/", "server is started");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"server starting excetpiton:{ex.Message}");
}
#endregion
#region 建立客户端
IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Parse(serverip), serverport);
AsyncTcpClient = new AsyncTcpClient(iPEndPoint);
//AsyncTcpClient.DatagramReceived += AsyncTcpClient_DatagramReceived;
try
{
AsyncTcpClient.Connect();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"建立服务器连接出错：{ex.Message}");
}
#endregion
#region 启动串口
string[] names = CustomSerialPort.GetPortNames();
foreach (var item in names)
{
Console.WriteLine(item);
}
try
{
mySer = new CustomSerialPort("/dev/COM1", 9600);
//mySer = new CustomSerialPort("COM1", 9600);
Console.WriteLine($"PortName:{mySer.PortName}");
if (mySer != null)
{
mySer.ReceivedEvent += MySer_DataReceived;
if (mySer.Open())
{
Console.WriteLine("Serial Open Success!");
Logger.Custom("log/", $"Serial Open Success!");
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"Serial Opening exception:{ex.Message}");
}
#endregion
#region 初始化逻辑
//1是开，2关
logicals.Clear();
logicals.Add(new Logical("N-O-D-R", 1, "2", "1", 2));
logicals.Add(new Logical("A-O-D-R", 1, "2", "1", 2));
logicals.Add(new Logical("A-R-D-R", 1, "2", "1", -1));
logicals.Add(new Logical("C-R-D-R", -1, "-1", "1", -1));
#endregion
#region 检查柜门状态
lock (objPortLock)
{
mySer.Write(readOneall);
Thread.Sleep(500);
mySer.Write(readsecondAll);
Thread.Sleep(500);
}
for (int i = 0; i < 60; i++)
{
if (CheckLockState(i + 1) == 2)
{
isNormalClose[i] = true;
}
if (i < 3)
{
Console.WriteLine($"D{i.ToString("000")} is normalClosed:{isNormalClose[i].ToString()}");
}
}
#endregion
Console.WriteLine($"状态数组当前的大小时:{sourcebyte.Length}");
foreach (var item in sourcebyte)
{
Console.WriteLine(item.ToString("X"));
}
#endregion
while (true)
{
lock (objPortLock)
{
try
{
mySer.Write(readOneall);
Thread.Sleep(500);
mySer.Write(readsecondAll);
Thread.Sleep(500);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"主程序出错：{ex.Message}");
}
}
for (int i = 0; i < 60; i++)
{
#region 检查非法开门
if (isNormalClose[i] && CheckLockState(i + 1) == 1 && !isSendError[i])
{
if (!AsyncTcpClient.Connected)
{
try
{
Console.WriteLine("client disconnect!");
AsyncTcpClient = new AsyncTcpClient(iPEndPoint);
AsyncTcpClient.Connect();
if (AsyncTcpClient.Connected)
{
AsyncTcpClient.Send(Encoding.Default.GetBytes($"D{(i + 1).ToString("000")} is opened Illegally!"));
isSendError[i] = true;
Console.WriteLine($"D{i + 1}非法开门了！");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"建立服务器连接出错：{ex.Message}");
}
}
else
{
AsyncTcpClient.Send(Encoding.Default.GetBytes($"D{(i+1).ToString("000")} is opened Illegally!"));
isSendError[i] = true;
Console.WriteLine($"D{i + 1}非法开门了！");
}
}
#endregion
#region 等待非法开门关门
if (isSendError[i] && CheckLockState(i + 1) == 2)
{
if (!AsyncTcpClient.Connected)
{
try
{
Console.WriteLine("client disconnect!");
AsyncTcpClient = new AsyncTcpClient(iPEndPoint);
AsyncTcpClient.Connect();
if (AsyncTcpClient.Connected)
{
AsyncTcpClient.Send(Encoding.Default.GetBytes($"D{(i + 1).ToString("000")} is Closed!"));
isSendError[i] = false;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Logger.Custom("log/", $"建立服务器连接出错：{ex.Message}");
}
}
else
{
AsyncTcpClient.Send(Encoding.Default.GetBytes($"D{(i+1).ToString("000")} is closed!"));
isSendError[i] = false;
}
}
#endregion
}
//delete threedays ago logger
if (DateTime.Now.Hour == 0 && DateTime.Now.Minute == 0 && DateTime.Now.Second < 10)
{
//删除文件
for (int i = 0; i < Directory.GetFiles("log").ToList().Count; i++)
{
try
{
string filestr = Directory.GetFiles("log")[i];
string date = filestr.Substring(4, filestr.Length - 8);
DateTime recoderdate = Convert.ToDateTime(date);
TimeSpan timespan = DateTime.Now - recoderdate;
if (timespan > new TimeSpan(72, 0, 0))
{
File.Delete(Directory.GetFiles("log")[i]);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}
}
public async Task ServerIsAbleToProcessPacketsAndCleansUpResources(ISocketSessionFactory sessionFactory, IProcessor processor, IPlayer player)
{
player.GetCityCount().Returns(1);
player.HasTwoFactorAuthenticated = DateTime.Now;
var socketAwaitablePool = new SocketAwaitablePool(10);
var buffer = new BlockingBufferManager(1000, 15);
Socket serverSideSocket = null;
AsyncSocketSession session = null;
sessionFactory.CreateAsyncSocketSession(Arg.Any <string>(), Arg.Any <Socket>())
.Returns(args =>
{
serverSideSocket = args.Arg <Socket>();
session = new AsyncSocketSession(string.Empty, serverSideSocket, processor, socketAwaitablePool, buffer)
{
Player = player
};
return(session);
});
AsyncTcpServer server = new AsyncTcpServer(sessionFactory, socketAwaitablePool, buffer);
try
{
server.Start("127.0.0.1", 0);
// Connect and verify client connected and socket options are set
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
NoDelay = true
};
var packetToSend1 = new Packet(Command.MarketSell);
packetToSend1.AddString("Hello");
var bytesToSendOnConnect = packetToSend1.GetBytes();
await socket.ConnectAsync(new SocketAwaitable
{
RemoteEndPoint = server.LocalEndPoint
});
await Task.Delay(1000);
await socket.SendAsync(new SocketAwaitable
{
Buffer = new ArraySegment <byte>(bytesToSendOnConnect, 0, bytesToSendOnConnect.Length)
});
await Task.Delay(1000);
server.GetSessionCount().Should().Be(1);
serverSideSocket.Connected.Should().BeTrue();
serverSideSocket.NoDelay.Should().BeTrue();
serverSideSocket.SendTimeout.Should().Be(1000);
// Send packets and verify server processes packets
var packetToSend2 = new Packet(Command.MarketBuy);
packetToSend2.AddString("World");
var bytesToSecondAfterConnect = packetToSend2.GetBytes();
await socket.SendAsync(new SocketAwaitable
{
Buffer = new ArraySegment <byte>(bytesToSecondAfterConnect, 0, bytesToSecondAfterConnect.Length)
});
await Task.Delay(1000);
// Stop server and verify it disconnect and releases resources
server.Stop();
await Task.Delay(1000);
player.HasTwoFactorAuthenticated.Should().Be(null);
serverSideSocket.Connected.Should().BeFalse();
socketAwaitablePool.Count.Should().Be(10);
buffer.AvailableBuffers.Should().Be(15);
processor.Received(1).Execute(session, Arg.Is <Packet>(packet => packet.GetBytes().SequenceEqual(bytesToSecondAfterConnect)));
processor.Received(1).Execute(session, Arg.Is <Packet>(packet => packet.GetBytes().SequenceEqual(bytesToSendOnConnect)));
processor.Received(1).ExecuteEvent(session, Arg.Is <Packet>(packet => packet.Cmd == Command.OnDisconnect));
}
finally
{
server.Stop();
}
}
/// <summary>
///
/// </summary>
/// <param name="ip"></param>
/// <param name="port"></param>
public bool StartServer(string ip,int port)
{
__server = new AsyncTcpServer(System.Net.IPAddress.Parse(ip), port);
__server.PlaintextReceived += __server_PlaintextReceived;
__server.Start();
return true;
}
