public void Close()
{
try
{
if (m_socket != null)
{
m_Closed = true;
if (m_listener != null)
{
m_listener.StopListening();
}
m_socket.Close();
m_listener = null;
m_socWorker = null;
m_socket = null;
}
}
catch (ObjectDisposedException odex)
{
Debug.Fail(odex.ToString(), "Stop failed");
}
}
public ReceiveSocket(ForwardReceivedDataDelegate ForwardReceivedDataIn)
{
ForwardReceivedData = ForwardReceivedDataIn;
socketListener = new SocketListener();
socketListener.ForwardReceivedData = ForwardData;
thread = new Thread(RunAsyncSocketListener);
thread.Start();
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
public bool Remove(SocketListener item)
{
if (this.SocketListeners.Remove(item))
{
UnregisterEvents(item);
return true;
}
return false;
}
/// <summary>
///
/// </summary>
public void Listen()
{
SocketListener sl = new SocketListener(1234);
sl.Start();
Soft.SocketListenerManager.Add(sl);
SocketListener sl2 = new SocketListener(21);
sl2.Start();
Soft.SocketListenerManager.Add(sl2);
}
public NewConnectEventArgs(SocketListener socketListener, Socket socket)
{
if (socketListener == null)
throw new ArgumentNullException("socketListener");
if (socket == null)
throw new ArgumentNullException("socket");
this._socket = socket;
this._socketListener = socketListener;
}
public void TestStartListner()
{
Moq.Mock<Socket> mock = new Moq.Mock<Socket>(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
SocketListener listener = new SocketListener(mock.Object);
listener.Start();
Assert.IsTrue(listener.Started);
Assert.AreEqual(listener.Server,mock.Object);
mock.Verify(s => s.AcceptAsync(Moq.It.IsAny<SocketAsyncEventArgs>()));
}
static void Main(string[] args)
{
var socketHandler = new SocketListener(12000, (handler, content) =>
{
//var frame = content.Length.ToString().PadLeft(4, '0');
//content = frame + content;
var clientKey = content.ToString().Substring(0, 36);
if (content.Contains("x"))
SocketSender.Send(handler, "0054" + clientKey + "SELECTORxxRESPONSE");
else
SocketSender.Send(handler, "0055" + clientKey + "SELECTORyyyRESPONSE");
});
socketHandler.StartListening();
}
public void Close()
{
if (m_socClient == null)
{
return;
}
if (m_listener != null)
{
m_listener.StopListening();
}
m_socClient.Close();
m_listener = null;
m_socClient = null;
}
public void StartListen()
{
if (m_socClient == null)
{
return;
}
if (m_listener != null)
{
return;
}
m_listener = new SocketListener();
m_listener.Disconnected += OnServerConnectionDroped;
m_listener.MessageRecived += OnMessageRecvied;
m_listener.StartReciving(m_socClient);
}
/// <summary>
///
/// </summary>
/// <param name="soft"></param>
public override void Build(CommuniSoft soft)
{
XmlDocument doc = new XmlDocument();
doc.Load(_filename);
XmlNode node = doc.SelectSingleNode(XmlListenNodeNames.ListenPortCollection);
if (node != null)
{
foreach (XmlNode n in node.ChildNodes)
{
if (n.Name == XmlListenNodeNames.ListenPort)
{
int port = int.Parse(n.InnerText);
SocketListener sckListener = new SocketListener(port);
sckListener.Start();
soft.SocketListenerManager.Add(sckListener);
}
}
}
}
public void Start()
{
try
{
Int32 numConnections = Convert.ToInt32(ConfigurationManager.AppSettings["NoOfConnections"] ?? "1");
Int32 bufferSize = Convert.ToInt32(ConfigurationManager.AppSettings["ConnectionBufferSize"] ?? "50");
string ProtocolsNPorts = ConfigurationManager.AppSettings["ProtocolsNPorts"];
List<string[]> items = ProtocolsNPorts.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Split(new[] { '|' })).ToList();
var protocolNPort = items.Select(s =>
new Tracker.TcpServer.TcpServerSAEA.Model.ProtocolNPort()
{
Key = s[0],
Value = s[1]
}).ToList();
if (numConnections >= protocolNPort.Count)
{
sl = new SocketListener(numConnections, bufferSize);
sl.Start(protocolNPort);
log.DebugFormat("{0}/Start: Server listening. Press any key to terminate the server process...", _fileNm);
}
else
{
log.DebugFormat("{0}/Start: Server failed to start. NoOfConnections should be higher than Protocol count", _fileNm);
}
}
catch (IndexOutOfRangeException iore)
{
log.ErrorFormat("{0}/Start: {1}", _fileNm, iore);
}
catch (FormatException fe)
{
log.ErrorFormat("{0}/Start: {1}", _fileNm, fe);
}
catch (Exception ex)
{
log.ErrorFormat("{0}/Start: {1}", _fileNm, ex);
}
}
/// <summary>
/// 处理假人死亡
/// </summary>
/// <param name="sl"></param>
/// <param name="pool"></param>
/// <param name="client"></param>
/// <param name="enemy"></param>
private static void ProcessFakeRoleDead(SocketListener sl, TCPOutPacketPool pool, GameClient client, FakeRoleItem fakeRoleItem)
{
if (fakeRoleItem.HandledDead)
{
return;
}
fakeRoleItem.HandledDead = true;
fakeRoleItem.FakeRoleDeadTicks = DateTime.Now.Ticks / 10000;
int ownerRoleID = fakeRoleItem.GetAttackerFromList(); //根据血量计算
if (ownerRoleID >= 0 && ownerRoleID != client.ClientData.RoleID)
{
GameClient findClient = GameManager.ClientMgr.FindClient(ownerRoleID);
if (null != findClient)
{
client = findClient;
}
}
}
static void Main(string[] args)
{
var socketThread = new Thread(() =>
{
var socketHandler = new SocketListener(11000, (handler, content) =>
{
var clientKey = Guid.NewGuid().ToString();
connectedClients.GetOrAdd(clientKey, handler);
var messageQueued = new MessageQueued
{
ClientKey = clientKey,
EntidadId = ENTIDAD_ID,
RawData = content
};
QueueSender.Send(clientKey, messageQueued, QueueConstants.REQUEST_QUEQUE, QueueConstants.CELLPHONE_QUEQUE);
});
socketHandler.StartListening();
});
socketThread.Start();
var queueThread = new Thread(() =>
{
var queueListener = new QueueListener(QueueConstants.CELLPHONE_QUEQUE, messageQueued =>
{
Socket handler;
connectedClients.TryRemove(messageQueued.ClientKey, out handler);
if (handler==null)
{
throw new ClienteConectadoNoReconocidoException(messageQueued.ClientKey);
}
SocketSender.Send(handler, messageQueued.RawData.ToString());
});
queueListener.Start();
});
queueThread.Start();
Console.WriteLine("CELULAR service started....");
socketThread.Join();
queueThread.Join();
}
public void TestConnection()
{
var listenSettings = new SocketListenerSettings <IListenerStateData>
{
LocalEndPoint = new IPEndPoint(IPAddress.Any, TestPort),
MaxConnections = 10,
MaxPendingConnections = 1000,
MaxSimultaneousAcceptOperations = 2,
IoBufferSize = 4096,
ExcessConnectionHandlers = 5,
ConnectionTimeOut = 100000,
WatchDogCheckDelay = 10 * 1000, // 5 seconds
MaxTaskConcurrencyLevel = 10,
MaxTaskDelay = 3000,
};
var mockMessageHandler = new TestMessageHandler <TestingSocketStateData, IListenerStateData>();
using (var socketListener = new SocketListener <TestingSocketStateData, IListenerStateData>(listenSettings, mockMessageHandler))
{
socketListener.StartListen();
using (var socket = new TcpClient())
{
socket.Connect("localhost", TestPort);
using (var stream = socket.GetStream())
{
SendMessage(stream,
"GET /process.aspx?data=351777047213077|OGeNuj4NrSR00cY96P5E3Rc04h120Qd-000O001n0c1x HTTP/1.1\r\n" +
"Host: 10.1.224.2\r\n" +
"\r\n");
WaitForResponse(stream);
Assert.AreEqual(1, mockMessageHandler.HandledMessages);
}
}
}
}
public async Task CanCreateWorkingEchoServer_ChannelSocketServer_ChannelSocketClient()
{
var endpoint = new IPEndPoint(IPAddress.Loopback, 5010);
const string MessageToSend = "Hello world!";
string reply = null;
using (var server = new SocketListener())
{
server.OnConnection(Echo);
server.Start(endpoint);
using (var client = await SocketConnection.ConnectAsync(endpoint))
{
var output = client.Output.Alloc();
output.WriteUtf8String(MessageToSend);
await output.FlushAsync();
client.Output.Complete();
while (true)
{
var input = await client.Input.ReadAsync();
// wait for the end of the data before processing anything
if (client.Input.Reading.IsCompleted)
{
reply = input.GetUtf8String();
client.Input.Advance(input.End);
break;
}
else
{
client.Input.Advance(input.Start, input.End);
}
}
}
}
Assert.Equal(MessageToSend, reply);
}
/// <summary>
/// Starts the transport.
/// </summary>
/// <param name="binding">The network binding the transport will use.</param>
/// <param name="cbSocketBuffer">Size of the socket's send and receive buffers in bytes.</param>
/// <param name="router">The <see cref="ISipMessageRouter" /> instance that will handle the routing of received messages.</param>
/// <exception cref="SocketException">Thrown if there's a conflict with the requested and existing socket bindings.</exception>
public void Start(NetworkBinding binding, int cbSocketBuffer, ISipMessageRouter router)
{
this.cbSocketBuffer = cbSocketBuffer;
this.listener = new SocketListener();
this.connections = new Dictionary <string, Connection>();
this.sweepInterval = TimeSpan.FromSeconds(30);
this.maxInactive = TimeSpan.FromMinutes(5); // Minimum time is 3 minutes according to RFC 3261
this.router = router;
this.localEP = binding;
this.traceMode = SipTraceMode.None;
try
{
listener.SocketAcceptEvent += new SocketAcceptDelegate(OnAccept);
listener.Start(binding, 100);
}
catch
{
listener.StopAll();
listener = null;
}
}
private void StartListener()
{
try
{
int port = Convert.ToInt16(tb_port.Text);
int connect = Convert.ToInt16(tb_connect.Text);
int buffer = Convert.ToInt16(tb_buffer.Text);
listener = new SocketListener(connect, buffer);
listener.Init();
listener.Start(new IPEndPoint(IPAddress.Any, port));
listener.OnClientNumberChange += Listener_OnClientNumberChange;
listener.GetIDByEndPoint += Listener_GetIDByEndPoint;
listener.GetPackageLength += Listener_GetPackageLength;
listener.OnMsgReceived += Listener_OnMsgReceived;
listener.OnSended += Listener_OnSended;
online = new ConcurrentDictionary <string, string>();
btn1.Text = "停止";
btn1.Tag = 1;
AppendLog("启动成功，开始监听端口 " + port + "\r\n");
}
catch (Exception ex)
{
AppendLog(ex.Message);
}
}
/// <summary>
/// 发送假人到给自己
/// </summary>
/// <param name="client"></param>
public static void SendMySelfFakeRoleItems(SocketListener sl, TCPOutPacketPool pool, GameClient client, List <Object> objsList, int totalRoleAndMonsterNum)
{
if (null == objsList)
{
return;
}
FakeRoleItem fakeRoleItem = null;
for (int i = 0; i < objsList.Count; i++)
{
fakeRoleItem = objsList[i] as FakeRoleItem;
if (null == fakeRoleItem)
{
continue;
}
if (!GameManager.TestGameShowFakeRoleForUser && fakeRoleItem.FakeRoleType != (int)FakeRoleTypes.DiaoXiang &&
fakeRoleItem.FakeRoleType != (int)FakeRoleTypes.DiaoXiang2 && fakeRoleItem.FakeRoleType != (int)FakeRoleTypes.DiaoXiang3 &&
fakeRoleItem.FakeRoleType != (int)FakeRoleTypes.CoupleWishMan && fakeRoleItem.FakeRoleType != (int)FakeRoleTypes.CoupleWishWife)
{
continue;
}
if (fakeRoleItem.CurrentLifeV <= 0)
{
continue;
}
if (totalRoleAndMonsterNum >= 30)
{
if (fakeRoleItem.FakeRoleType == (int)FakeRoleTypes.LiXianGuaJi)
{
continue;
}
}
GameManager.ClientMgr.NotifyMySelfNewFakeRole(sl, pool, client, fakeRoleItem);
}
}
private bool SocketReceived(object sender, SocketAsyncEventArgs e)
{
SocketListener sl = sender as SocketListener;
TCPInPacket tcpInPacket = null;
AsyncUserToken userToken = e.UserToken as AsyncUserToken;
TMSKSocket s = userToken.CurrentSocket;
tcpInPacket = s._TcpInPacket;
if (null == tcpInPacket)
{
lock (this.dictInPackets)
{
if (!this.dictInPackets.TryGetValue(s, out tcpInPacket))
{
tcpInPacket = this.tcpInPacketPool.Pop(s, new TCPCmdPacketEventHandler(this.TCPCmdPacketEvent));
this.dictInPackets[s] = tcpInPacket;
}
}
s._TcpInPacket = tcpInPacket;
}
return(tcpInPacket.WriteData(e.Buffer, e.Offset, e.BytesTransferred));
}
/// <summary>
/// Starts the server.
/// </summary>
/// <param name="perfBytesRecv">Performance counter to receive updates about bytes received (or <c>null</c>).</param>
/// <param name="perfBytesSent">Performance counter to receive updates about bytes sent (or <c>null</c>).</param>
public void Start(PerfCounter perfBytesRecv, PerfCounter perfBytesSent)
{
using (TimedLock.Lock(syncLock))
{
if (listener != null)
{
throw new InvalidOperationException("Server already started.");
}
this.perfBytesRecv = perfBytesRecv;
this.perfBytesSent = perfBytesSent;
listener = new SocketListener();
listener.SocketAcceptEvent += new SocketAcceptDelegate(OnAccept);
for (int i = 0; i < endPoints.Length; i++)
{
listener.Start(endPoints[i], cBacklog);
}
connections = new Hashtable();
}
}
public static void NotifyInjured(SocketListener sl, TCPOutPacketPool pool, GameClient client, int roleID, int enemy, int enemyX, int enemyY, int burst, int injure, double attackPercent, int addAttack, double baseRate = 1.0, int addVlue = 0, int nHitFlyDistance = 0)
{
object obj = FakeRoleManager.FindFakeRoleByID(enemy);
if (null != obj)
{
if ((obj as FakeRoleItem).CurrentLifeV > 0)
{
injure = 10000;
(obj as FakeRoleItem).CurrentLifeV -= injure;
(obj as FakeRoleItem).CurrentLifeV = Global.GMax((obj as FakeRoleItem).CurrentLifeV, 0);
int enemyLife = (obj as FakeRoleItem).CurrentLifeV;
(obj as FakeRoleItem).AttackedRoleID = client.ClientData.RoleID;
GameManager.ClientMgr.SpriteInjure2Blood(sl, pool, client, injure);
GameManager.SystemServerEvents.AddEvent(string.Format("假人减血, Injure={0}, Life={1}", injure, enemyLife), EventLevels.Debug);
if ((obj as FakeRoleItem).CurrentLifeV <= 0)
{
GameManager.SystemServerEvents.AddEvent(string.Format("假人死亡, roleID={0}", (obj as FakeRoleItem).FakeRoleID), EventLevels.Debug);
FakeRoleManager.ProcessFakeRoleDead(sl, pool, client, obj as FakeRoleItem);
}
int ownerRoleID = (obj as FakeRoleItem).GetAttackerFromList();
if (ownerRoleID >= 0 && ownerRoleID != client.ClientData.RoleID)
{
GameClient findClient = GameManager.ClientMgr.FindClient(ownerRoleID);
if (null != findClient)
{
GameManager.ClientMgr.NotifySpriteInjured(sl, pool, findClient, findClient.ClientData.MapCode, findClient.ClientData.RoleID, (obj as FakeRoleItem).FakeRoleID, 0, 0, (double)enemyLife, findClient.ClientData.Level, new Point(-1.0, -1.0), 0, EMerlinSecretAttrType.EMSAT_None, 0);
ClientManager.NotifySelfEnemyInjured(sl, pool, findClient, findClient.ClientData.RoleID, (obj as FakeRoleItem).FakeRoleID, 0, 0, (double)enemyLife, 0L, 0, EMerlinSecretAttrType.EMSAT_None, 0);
}
}
GameManager.ClientMgr.NotifySpriteInjured(sl, pool, client, client.ClientData.MapCode, client.ClientData.RoleID, (obj as FakeRoleItem).FakeRoleID, burst, injure, (double)enemyLife, client.ClientData.Level, new Point(-1.0, -1.0), 0, EMerlinSecretAttrType.EMSAT_None, 0);
ClientManager.NotifySelfEnemyInjured(sl, pool, client, client.ClientData.RoleID, (obj as FakeRoleItem).FakeRoleID, burst, injure, (double)enemyLife, 0L, 0, EMerlinSecretAttrType.EMSAT_None, 0);
if (!client.ClientData.DisableChangeRolePurpleName)
{
GameManager.ClientMgr.ForceChangeRolePurpleName2(sl, pool, client);
}
}
}
}
public static int NotifyInjured(SocketListener sl, TCPOutPacketPool pool, GameClient client, BiaoCheItem enemy, int burst, int injure, double injurePercent, int attackType, bool forceBurst, int addInjure, double attackPercent, int addAttackMin, int addAttackMax, double baseRate = 1.0, int addVlue = 0, int nHitFlyDistance = 0)
{
int ret = 0;
if ((enemy as BiaoCheItem).CurrentLifeV > 0)
{
injure = (enemy as BiaoCheItem).CutLifeV;
injure = (int)((double)injure * baseRate + (double)addVlue);
injure = (int)((double)injure * injurePercent);
ret = injure;
(enemy as BiaoCheItem).CurrentLifeV -= injure;
(enemy as BiaoCheItem).CurrentLifeV = Global.GMax((enemy as BiaoCheItem).CurrentLifeV, 0);
double enemyLife = (double)(enemy as BiaoCheItem).CurrentLifeV;
(enemy as BiaoCheItem).AttackedRoleID = client.ClientData.RoleID;
GameManager.ClientMgr.SpriteInjure2Blood(sl, pool, client, injure);
GameManager.SystemServerEvents.AddEvent(string.Format("镖车减血, Injure={0}, Life={1}", injure, enemyLife), EventLevels.Debug);
if ((enemy as BiaoCheItem).CurrentLifeV <= 0)
{
GameManager.SystemServerEvents.AddEvent(string.Format("镖车死亡, roleID={0}", (enemy as BiaoCheItem).BiaoCheID), EventLevels.Debug);
BiaoCheManager.ProcessBiaoCheDead(sl, pool, client, enemy as BiaoCheItem);
}
if ((enemy as BiaoCheItem).AttackedRoleID >= 0 && (enemy as BiaoCheItem).AttackedRoleID != client.ClientData.RoleID)
{
GameClient findClient = GameManager.ClientMgr.FindClient((enemy as BiaoCheItem).AttackedRoleID);
if (null != findClient)
{
GameManager.ClientMgr.NotifySpriteInjured(sl, pool, findClient, findClient.ClientData.MapCode, findClient.ClientData.RoleID, (enemy as BiaoCheItem).BiaoCheID, 0, 0, enemyLife, findClient.ClientData.Level, new Point(-1.0, -1.0), 0, EMerlinSecretAttrType.EMSAT_None, 0);
ClientManager.NotifySelfEnemyInjured(sl, pool, findClient, findClient.ClientData.RoleID, enemy.BiaoCheID, 0, 0, enemyLife, 0L, 0, EMerlinSecretAttrType.EMSAT_None, 0);
}
}
GameManager.ClientMgr.NotifySpriteInjured(sl, pool, client, client.ClientData.MapCode, client.ClientData.RoleID, (enemy as BiaoCheItem).BiaoCheID, burst, injure, enemyLife, client.ClientData.Level, new Point(-1.0, -1.0), 0, EMerlinSecretAttrType.EMSAT_None, 0);
ClientManager.NotifySelfEnemyInjured(sl, pool, client, client.ClientData.RoleID, enemy.BiaoCheID, burst, injure, enemyLife, 0L, 0, EMerlinSecretAttrType.EMSAT_None, 0);
if (!client.ClientData.DisableChangeRolePurpleName)
{
GameManager.ClientMgr.ForceChangeRolePurpleName2(sl, pool, client);
}
}
return(ret);
}
public void TestFixtureSetUp()
{
engineListen = new SocketEngine();
engineListen.MessageCacheFactory = new MessageCacheFlatFileFactory();
engineListen.MessageFactory = factory;
engineListen.AllowOfflineSend = true;
engineListen.Initialize("LISTEN", "CONNECT");
engineListen.Received += new MessageEventHandler(engineListen_Received);
engineListen.Sent += new MessageEventHandler(engineListen_Sent);
listener = new SocketListener();
listener.Add(engineListen);
listener.Init(9050);
engineConnect = new SocketEngine();
engineConnect.MessageCacheFactory = new MessageCacheFlatFileFactory();
engineConnect.MessageFactory = factory;
engineConnect.AllowOfflineSend = true;
engineConnect.Initialize("CONNECT", "LISTEN");
engineConnect.Received += new MessageEventHandler(engineConnect_Received);
engineConnect.Sent += new MessageEventHandler(engineConnect_Sent);
}
public void SocketListener_BadPort_0()
{
SocketListener listener = new SocketListener();
IPEndPoint ep1 = new IPEndPoint(IPAddress.Loopback, 0);
try
{
Init(listener);
listener.Start(ep1, 10);
}
catch (Exception e)
{
Assert.AreEqual(typeof(ArgumentException).Name, e.GetType().Name);
return;
}
finally
{
listener.StopAll();
}
Assert.Fail();
}
private Main1(SocketListener listener)
{
_listener = listener;
_listener.OnClientNumberChange += Listener_OnClientNumberChange;
_listener.GetIDByEndPoint += Listener_GetIDByEndPoint;
_listener.GetPackageLength += Listener_GetPackageLength;
_listener.OnMsgReceived += Listener_OnMsgReceived;
_listener.OnSended += Listener_OnSended;
//_online = new ConcurrentDictionary<string, string>();
_devices = new BindingList <DeviceRow>();
InitializeComponent();
this.WindowState = FormWindowState.Maximized;
}
private async void WaitConnections(SocketListener socketListener)
{
while (socketListener.IsListening)
{
Logger.Info("Listening for connection");
var socket = await socketListener.AcceptAsync();
await Task.Run(async() => {
Logger.Info("Accepted");
await new ReaderPipeline(new HttpParser()).ProcessLinesAsync(socket, new DefaultParserRequestHandler());
});
/*_ = Task.Run(async () => {
* Logger.Info($"New Connection: {((IPEndPoint)socket.RemoteEndPoint).Address}");
* stopWatch.Start();
* var httpClient = new HttpClient(socket);
* await httpClient.Start();
* stopWatch.Stop();
* Logger.Info($"Decoder took: {stopWatch.ElapsedMilliseconds}ms");
* stopWatch.Reset();
* });*/
}
}
private static bool ProcessBiaoCheDead(SocketListener sl, TCPOutPacketPool pool, long nowTicks, BiaoCheItem biaoCheItem)
{
bool result;
if (biaoCheItem.CurrentLifeV > 0)
{
result = false;
}
else
{
long subTicks = nowTicks - biaoCheItem.BiaoCheDeadTicks;
if (subTicks < 2000L)
{
result = false;
}
else
{
BiaoCheManager.ProcessDelBiaoChe(sl, pool, biaoCheItem.BiaoCheID);
result = true;
}
}
return(result);
}
private static void ProcessBiaoCheAddLife(SocketListener sl, TCPOutPacketPool pool, long nowTicks, BiaoCheItem biaoCheItem)
{
long subTicks = nowTicks - biaoCheItem.LastLifeMagicTick;
if (subTicks >= 5000L)
{
biaoCheItem.LastLifeMagicTick = nowTicks;
if (biaoCheItem.CurrentLifeV > 0)
{
if (biaoCheItem.CurrentLifeV < biaoCheItem.LifeV)
{
double lifeMax = (double)biaoCheItem.CutLifeV;
lifeMax += (double)biaoCheItem.CurrentLifeV;
if (biaoCheItem.CurrentLifeV > 0)
{
biaoCheItem.CurrentLifeV = (int)Global.GMin((double)biaoCheItem.LifeV, lifeMax);
List <object> objList = Global.GetAll9Clients(biaoCheItem);
GameManager.ClientMgr.NotifyOtherBiaoCheLifeV(sl, pool, objList, biaoCheItem.BiaoCheID, biaoCheItem.CurrentLifeV);
}
}
}
}
}
private static bool ProcessFakeRoleDead(SocketListener sl, TCPOutPacketPool pool, long nowTicks, FakeRoleItem fakeRoleItem)
{
bool result;
if (fakeRoleItem.CurrentLifeV > 0)
{
result = false;
}
else
{
long subTicks = nowTicks - fakeRoleItem.FakeRoleDeadTicks;
if (subTicks < 2000L)
{
result = false;
}
else
{
FakeRoleManager.ProcessFakeRoleGoBack(fakeRoleItem.FakeRoleID);
result = true;
}
}
return(result);
}
public async Task RunStressPingPongTest_Socket()
{
var endpoint = new IPEndPoint(IPAddress.Loopback, 5020);
using (var server = new SocketListener())
{
server.OnConnection(PongServer);
server.Start(endpoint);
const int SendCount = 500, ClientCount = 5;
for (int loop = 0; loop < ClientCount; loop++)
{
using (var client = await SocketConnection.ConnectAsync(endpoint))
{
var tuple = await PingClient(client, SendCount);
Assert.Equal(SendCount, tuple.Item1);
Assert.Equal(SendCount, tuple.Item2);
Console.WriteLine($"Ping: {tuple.Item1}; Pong: {tuple.Item2}; Time: {tuple.Item3}ms");
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="setting"></param>
/// <param name="packetHead"></param>
protected GameSocketHost()
{
var port = ConfigUtils.GetSetting("Game.Port", "9001").ToInt();
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, port);
int maxConnections = ConfigUtils.GetSetting("MaxConnections", "1000").ToInt();
int backlog = ConfigUtils.GetSetting("Backlog", "100").ToInt();
int maxAcceptOps = ConfigUtils.GetSetting("MaxAcceptOps", "100").ToInt();
int bufferSize = ConfigUtils.GetSetting("BufferSize", "8192").ToInt();
threadPool = new SmartThreadPool(180 * 1000, 100, 5);
threadPool.Start();
var socketSettings = new SocketSettings(maxConnections, backlog, maxAcceptOps, bufferSize, localEndPoint, 3600000, 3600000);
socketLintener = new SocketListener(socketSettings);
socketLintener.DataReceived += new ConnectionEventHandler(socketLintener_DataReceived);
socketLintener.Connected += new ConnectionEventHandler(OnConnectCompleted);
socketLintener.Disconnected += new ConnectionEventHandler(socketLintener_Disconnected);
queueProcessThread = new Thread(ProcessQueue);
queueProcessThread.Start();
}
/// <summary>
/// Stops the transport if it's running.
/// </summary>
public void Stop()
{
if (listener == null)
{
return;
}
using (TimedLock.Lock(this))
{
if (!disabled)
{
listener.StopAll();
}
foreach (Connection con in connections.Values)
{
con.Close();
}
listener = null;
connections = null;
}
}
private void OnClientConnection(IAsyncResult asyn)
{
if (m_Closed)
{
return;
}
try
{
allDone.Set();
m_socWorker = m_socket.EndAccept(asyn);
bool WebSocket = ShakeHands(m_socWorker);
m_connectedClient.Add(new Client()
{
socket = m_socWorker, isWebSocket = WebSocket
});
RaiseClientConnected(m_socWorker);
m_listener = new SocketListener();
m_listener.MessageRecived += OnMessageRecived;
m_listener.Disconnected += OnClientDisconnection;
m_listener.StartReciving(m_socWorker);
}
catch (ObjectDisposedException odex)
{
Debug.Fail(odex.ToString(), "OnClientConnection: Socket has been closed");
}
catch (Exception sex)
{
Debug.Fail(sex.ToString(), "OnClientConnection: Socket failed");
}
}
static void Main(string[] args)
{
//Create a log file writer, so you can see the flow easily.
//It can be printed. Makes it easier to figure out complex program flow.
//The log StreamWriter uses a buffer. So it will only work right if you close
//the server console properly at the end of the test.
_log = new Log(consoleWatch);
try
{
// Get endpoint for the listener.
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse(DEFAULT_SERVER), DEFAULT_PORT);
WriteInfoToConsole(localEndPoint);
//This object holds a lot of settings that we pass from Main method
//to the SocketListener. In a real app, you might want to read
//these settings from a database or windows registry settings that
//you would create.
ISocketListenerSettings theSocketListenerSettings =
new SocketListenerSettings
(maxNumberOfConnections, excessSaeaObjectsInPool, maxSimultaneousAcceptOps, testBufferSize, opsToPreAlloc, localEndPoint);
SocketListener listener = new SocketListener(theSocketListenerSettings, _log);
listener.Start(new IPEndPoint(IPAddress.Parse("127.0.0.1"), DEFAULT_PORT));
_log.WriteLine("Server listening on port {0}. Press any key to terminate the server process..." + DEFAULT_PORT);
Console.Read();
_log.Close();
listener.Stop();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public async Task ConnectAsyncCanceled()
{
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 5701);
using var server = new SocketListener(endpoint, SocketListenerMode.AcceptOnce);
using var socket = new Socket(endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
var i = 0;
const int count = 5;
while (i++ < count)
{
try
{
await socket.ConnectAsync(endpoint, -1, new CancellationToken(true));
}
catch (OperationCanceledException)
{
break;
}
socket.Disconnect(true);
await Task.Delay(100);
}
// fail
if (i == count)
{
Assert.Throws <OperationCanceledException>(() => { });
}
//Assert.ThrowsAsync<OperationCanceledException>(async () =>
//{
// await socket.ConnectAsync(endpoint, -1, new CancellationToken(true));
//});
}
/// <summary>
/// 发送镖车到给自己
/// </summary>
/// <param name="client"></param>
public static void SendMySelfBiaoCheItems(SocketListener sl, TCPOutPacketPool pool, GameClient client, List <Object> objsList)
{
if (null == objsList)
{
return;
}
BiaoCheItem biaoCheItem = null;
for (int i = 0; i < objsList.Count; i++)
{
if (!(objsList[i] is BiaoCheItem))
{
continue;
}
if ((objsList[i] as BiaoCheItem).CurrentLifeV <= 0)
{
continue;
}
biaoCheItem = objsList[i] as BiaoCheItem;
GameManager.ClientMgr.NotifyMySelfNewBiaoChe(sl, pool, client, biaoCheItem);
}
}
/// <summary>
/// 删除自己哪儿的假人
/// </summary>
/// <param name="client"></param>
public static void DelMySelfFakeRoleItems(SocketListener sl, TCPOutPacketPool pool, GameClient client, List <Object> objsList)
{
if (null == objsList)
{
return;
}
FakeRoleItem fakeRoleItem = null;
for (int i = 0; i < objsList.Count; i++)
{
fakeRoleItem = objsList[i] as FakeRoleItem;
if (null == fakeRoleItem)
{
continue;
}
if (!GameManager.TestGameShowFakeRoleForUser && fakeRoleItem.FakeRoleType != (int)FakeRoleTypes.DiaoXiang)
{
continue;
}
GameManager.ClientMgr.NotifyMySelfDelFakeRole(sl, pool, client, fakeRoleItem.FakeRoleID);
}
}
public static void Init()
{
Listener = new SocketListener();
Thread listenThread = new Thread(Listener.Listen);
listenThread.Start();
Sender = new SocketSender("localhost");
Listener.OnMessageRecieve += Listener_OnMessageRecieve;
try
{
SendMessageLoop();
}
catch (Exception e)
{
Console.WriteLine("[HashMessenger] " + e);
}
Listener.Dispose();
Sender.Dispose();
}
/// <summary>
/// 处理已经镖车的超时
/// </summary>
/// <param name="client"></param>
public static void ProcessAllBiaoCheItems(SocketListener sl, TCPOutPacketPool pool)
{
List <BiaoCheItem> biaoCheItemList = new List <BiaoCheItem>();
lock (_ID2BiaoCheDict)
{
foreach (var val in _ID2BiaoCheDict.Values)
{
biaoCheItemList.Add(val);
}
}
long nowTicks = TimeUtil.NOW();
BiaoCheItem biaoCheItem = null;
for (int i = 0; i < biaoCheItemList.Count; i++)
{
biaoCheItem = biaoCheItemList[i];
//处理镖车的超时
if (ProcessBiaoCheOverTime(sl, pool, nowTicks, biaoCheItem))
{
continue;
}
//处理镖车的死亡
if (ProcessBiaoCheDead(sl, pool, nowTicks, biaoCheItem))
{
continue;
}
//处理镖车的加血
ProcessBiaoCheAddLife(sl, pool, nowTicks, biaoCheItem);
}
}
/// <summary>
/// 定时怪物复活调度(主线程中调用)
/// </summary>
public void RunMapMonsters(SocketListener sl, TCPOutPacketPool pool)
{
for (int i = 0; i < MonsterZoneList.Count; i++)
{
//根据当前的怪剩余个数，重新爆怪
MonsterZoneList[i].ReloadMonsters(sl, pool);
}
// 这会让MonsterZone中的MonsterList被清空 它是用于怪复活的 副本怪的销毁 交给ProcessEndCopyMap(副本时间到了就会销毁) [8/20/2014 LiaoWei]
for (int i = 0; i < FuBenMonsterZoneList.Count; i++)
{
//遍历判断副本地图怪是否需要销毁(主线程调用)
FuBenMonsterZoneList[i].DestroyDeadMonsters();
}
//for (int i = 0; i < MonsterDynamicZoneDict.Values.Count; i++)
List <MonsterZone> monsterZoneList = MonsterDynamicZoneDict.Values.ToList <MonsterZone>();
for (int i = 0; i < monsterZoneList.Count; i++)
{
//执行销毁动态生成的怪物(主线程调用)
monsterZoneList[i].DestroyDeadDynamicMonsters();
}
}
/// <summary>
///
/// </summary>
/// <param name="requestHandler"></param>
protected GameWebSocketHost(WebSocketRequestHandler requestHandler)
{
_setting = GameEnvironment.Setting;
int port = _setting != null ? _setting.GamePort : 0;
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, port);
var section = GetSection();
int maxConnections = section.SocketMaxConnection;
int backlog = section.SocketBacklog;
int maxAcceptOps = section.SocketMaxAcceptOps;
int bufferSize = section.SocketBufferSize;
int expireInterval = section.SocketExpireInterval;
int expireTime = section.SocketExpireTime;
var socketSettings = new SocketSettings(maxConnections, backlog, maxAcceptOps, bufferSize, localEndPoint, expireInterval, expireTime);
socketListener = new SocketListener(socketSettings, requestHandler);
socketListener.DataReceived += new ConnectionEventHandler(OnDataReceived);
socketListener.Connected += new ConnectionEventHandler(socketLintener_OnConnectCompleted);
socketListener.Handshaked += new ConnectionEventHandler(OnHandshaked);
socketListener.Disconnected += new ConnectionEventHandler(OnDisconnected);
socketListener.OnPing += new ConnectionEventHandler(socketLintener_OnPing);
socketListener.OnPong += new ConnectionEventHandler(socketLintener_OnPong);
}
/// <summary>
/// 将自己周围的NPC发送给自己
/// </summary>
/// <param name="sl"></param>
/// <param name="pool"></param>
/// <param name="client"></param>
/// <param name="objsList"></param>
public static void SendMySelfNPCs(SocketListener sl, TCPOutPacketPool pool, GameClient client, List <Object> objsList)
{
if (null == objsList)
{
return;
}
NPC npc = null;
for (int i = 0; i < objsList.Count; i++)
{
npc = objsList[i] as NPC;
if (null == npc)
{
continue;
}
if (!npc.ShowNpc)
{
continue;
}
GameManager.ClientMgr.NotifyMySelfNewNPC(sl, pool, client, npc);
}
}
void Start()
{
Debug.Log("Initializing NetGameMode...");
// listen for network players
connectionSocket = new SocketListener();
connectionSocket.StartListening(gamePort);
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
private void UnregisterEvents(SocketListener item)
{
item.ConnectedEvent -= new EventHandler(item_ConnectedEvent);
}
/// <summary>
/// 添加item到SocketListeners集合，并注册NewConnect事件
/// </summary>
/// <param name="item"></param>
public void Add(SocketListener item)
{
this.SocketListeners.Add(item);
ReginsterEvents(item);
}
private void OnClientConnection(IAsyncResult asyn)
{
if (m_Closed)
{
return;
}
try
{
m_socWorker = m_socket.EndAccept(asyn);
RaiseClientConnected(m_socWorker);
m_listener = new SocketListener();
m_listener.MessageRecived += OnMessageRecived;
m_listener.Disconnected += OnClientDisconnection;
m_listener.StartReciving(m_socWorker);
}
catch (ObjectDisposedException odex)
{
Debug.Fail(odex.ToString(), "OnClientConnection: Socket has been closed");
}
catch (Exception sex)
{
Debug.Fail(sex.ToString(), "OnClientConnection: Socket failed");
}
}
public ConnectedClient(Socket clientSocket)
{
m_clientSocket = clientSocket;
m_listener = new SocketListener();
}
