private void EndConnect(IAsyncResult ar)
{
try
{
var s = (System.Net.Sockets.Socket)ar.AsyncState;
s.EndConnect(ar);
if (s.Connected)
{
if (ClientConnected != null)
{
ClientConnected(this, null);
}
}
}
catch (Exception ex)
{
if (Error != null)
{
Error(null, new DataEventArgs <Exception>(ex));
}
Csl.Wl(ex.StackTrace);
}
}
/// <summary>
/// 开启服务器，开始接受连接
/// <seealso cref="ServerBase.Stop"/>
/// </summary>
public virtual void Start()
{
try
{
if (!_running)
{
Log.Info("ServerBase started");
IsRunning = true;
if (_tcpEndpoint == null)
{
_tcpEndpoint = new IPEndPoint(GetDefaultExternalIpAddress(), 0);
}
StartTCP();
Log.Info("ServerBase ready for connections");
}
}
catch (InvalidEndpointException ex)
{
Csl.WlEx(ex);
Log.Error(string.Format("InvalidEndpoint,{0}", ex.Endpoint));
Stop();
}
catch (NoAvailableAdaptersException ex)
{
Csl.WlEx(ex);
Log.Error("NoNetworkAdapters");
Stop();
}
}
/// <summary>
/// 订阅者模式受到消息
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _client_OnReceive(object sender, Core.Args.DataEventArgs <NetMQ.NetMQSocket, NetMQ.NetMQMessage> e)
{
var msg = e.Arg2;
Csl.Wl("主题：" + msg.Pop().ConvertToString(Encoding.UTF8));
Csl.Wl("内容：" + msg.Pop().ConvertToString(Encoding.UTF8));
}
public void Do()
{
try
{
if (dealtime == DateTime.MinValue)
{
dealtime = DateTime.Now;
if (_firstDo)
{
_sw.Restart();
_action();
_sw.Stop();
_lastCostTime = _sw.ElapsedMilliseconds;
_sw.Reset();
}
return;
}
if ((DateTime.Now - dealtime).TotalMilliseconds >= _baseTime)
{
dealtime = DateTime.Now;
_sw.Restart();
_action();
_sw.Stop();
_lastCostTime = _sw.ElapsedMilliseconds;
_sw.Reset();
}
}
catch (Exception ex)
{
LogHelper.Error(ex);
Csl.WlEx(ex);
}
}
private void btnAsync_Click(object sender, EventArgs e)
{
var count = int.Parse(txtCount.Text);
Csl.Wl("----------------------------------------------");
Parallel.For(0, count, (x) =>
{
try
{
using (var sclient = new OctMQClient())
{
sclient.Init(txtip.Text, int.Parse(txtport.Text), ClientType.Request);
var msg = sclient.CreateMessage();
msg.Append(int.Parse(txtSeat.Text));
msg.Append(txtName.Text, Encoding.UTF8);
sclient.Send(msg);
var rmsg = sclient.ReceiveMessage();
var ret = rmsg.Pop().ConvertToInt32();
var reqStr = rmsg.Pop().ConvertToString(Encoding.UTF8);
Csl.Wl(string.Format("判断值：{0}，结果：{1},第几个进程:{2}", ret, reqStr, x));
}
}
catch (Exception)
{
}
});
Csl.Wl("----------------------------------------------");
}
public void Send(byte[] packet, int offset, int length)
{
if (_tcpSock != null && _tcpSock.Connected)
{
SocketAsyncEventArgs args = SocketHelpers.AcquireSocketArg();
if (args != null)
{
args.Completed += SendAsyncComplete;
args.SetBuffer(packet, offset, length);
args.UserToken = this;
_tcpSock.SendAsync(args);
//unchecked
//{
// _bytesSent += (uint)length;
//}
//Interlocked.Add(ref _totalBytesSent, length);
}
else
{
Csl.Wl(string.Format("Client {0}'s SocketArgs are null", this));
}
}
}
/// <summary>
/// 选择类型
/// </summary>
private static void CreateCmd()
{
Csl.Wl(ConsoleColor.Red, "请选择您要创建的MQ服务端类型");
Csl.Wl(ConsoleColor.Yellow, "1.PUB 2.REP");
var key = System.Console.ReadLine();
switch (key)
{
case "1":
{
_type = ServerType.XPub;
Create();
Cmd();
}
break;
case "2":
_type = ServerType.Response;
Create();
InitQueue();
Cmd();
break;
default:
{
CreateCmd();
}
break;
}
}
internal static void Initialize(Kernel knl, LogicMgr logicMgr)
{
lock (syncRoot)
{
var itasks = container.GetExportedValues <IServise>();
foreach (var servise in itasks)
{
var lgc = (CoreLogic)servise;
lgc.Ctor(knl);
logicMgr.Add(lgc);
LogHelper.Info(lgc.Name + " loading...");
Csl.Wl(lgc.Name + " loading...");
}
knl.Ctor(logicMgr);
var batch = new CompositionBatch();
foreach (var logic in knl.GetLgcs())
{
batch.AddPart(logic);
}
try
{
container.Compose(batch);
}
catch (CompositionException compositionException)
{
Debug.WriteLine(compositionException.ToString());
throw;
}
}
}
/// <summary>
/// 接收消息
/// </summary>
private static void Cmd()
{
if (_type == ServerType.Pub)
{
Csl.Wl(ConsoleColor.Red, "请输入您要发个订阅者的信息主题与信息用空格分开");
}
else
{
Csl.Wl(ConsoleColor.Red, "等待消息");
}
var cmd = System.Console.ReadLine();
switch (cmd)
{
case "exit":
Csl.Wl("正在关闭应用程序。。。等待最后一个心跳执行完成。。。");
_server.Dispose();
break;
default:
{
var str = cmd.Split(' ');
var msg = _server.CreateMessage();
msg.Append(str[0], Encoding.UTF8);
msg.Append(str[1], Encoding.UTF8);
_server.Send(msg);
Cmd();
break;
}
return;
}
}
/// <summary>
/// 断开客户端
/// </summary>
/// <param name="client"></param>
/// <param name="forced"></param>
public void DisconnectClient(IClient client, bool forced)
{
RemoveClient(client);
try
{
//if (_theMaxConnectionsEnforcer.Release(1) == CfgMgr.BasicCfg.MaxNumberOfConnections - 1)
//{
// Csl.Wl("计数器已达上限");
//}
if (client != null && client.TcpSocket != null)
{
OnClientDisconnected(client, forced);
//client.Dispose();
}
}
catch (ObjectDisposedException e)
{
Csl.WlEx(e);
Log.Error("Could not disconnect client", e);
// Connection was already closed (probably by the remote side)
}
catch (Exception e)
{
Csl.WlEx(e);
Log.Error("Could not disconnect client", e);
}
}
//private Thread _thThread;
/// <summary>
/// 开启TCP服务
/// </summary>
protected void StartTCP()
{
if (!_tcpEnabled && _running)
{
VerifyEndpointAddress(TcpEndPoint);
_tcpListen = new System.Net.Sockets.Socket(TcpEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
_tcpListen.Bind(TcpEndPoint);
}
catch (Exception ex)
{
Log.Error(string.Format("Could not bind to Address {0}: {1}", TcpEndPoint, ex));
Csl.Wl(string.Format("Could not bind to Address {0}: {1}", TcpEndPoint, ex));
return;
}
_tcpListen.Listen(CfgMgr.BasicCfg.MaxSimultaneousAcceptOps);
SocketHelpers.SetListenSocketOptions(_tcpListen);
_tcpEnabled = true;
StartAccept(null);
Log.Info(string.Format("Endpoint {0} start listening", TcpEndPoint));
}
}
private void LoadLgcs()
{
foreach (var lgc in _lgcs.GetAllLgcs())
{
lgc.Load();
LogHelper.Info(lgc.Name + " loading...");
Csl.Wl(lgc.Name + " loading...");
}
}
private static void CurrentDomainUnhandledException(object sender, UnhandledExceptionEventArgs e)
{
var ex = (Exception)e.ExceptionObject;
if (ex != null)
{
LogHelper.Error(ex);
Csl.WlEx(ex);
}
}
/// <summary>
/// 发送响应消息
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnSend_Click(object sender, EventArgs e)
{
using (_client = new OctMQClient())
{
_client.Init(txtip.Text, int.Parse(txtport.Text), ClientType.Request);
var content = txtContent.Text;
var msg = _client.CreateMessage();
msg.Append(content, Encoding.UTF8);
_client.Send(msg);
var rmsg = _client.ReceiveMessage();
var reqStr = rmsg.Pop().ConvertToString(Encoding.UTF8);
Csl.Wl(reqStr);
}
}
private void button1_Click(object sender, EventArgs e)
{
using (_client = new OctMQClient())
{
_client.Init(txtip.Text, int.Parse(txtport.Text), ClientType.Request);
var msg = _client.CreateMessage();
msg.Append(int.Parse(txtSeat.Text));
msg.Append(txtName.Text, Encoding.UTF8);
_client.Send(msg);
var rmsg = _client.ReceiveMessage();
var ret = rmsg.Pop().ConvertToInt32();
var reqStr = rmsg.Pop().ConvertToString(Encoding.UTF8);
Csl.Wl(string.Format("判断值：{0}，结果：{1}", ret, reqStr));
}
}
public FrameworkServer()
{
Bootstrapper.Initialise();
Csl.Wl("开始构建内核...");
_knl = new Kernel();
_lgcs = new LogicMgr();
Composition.Initialize(_knl, _lgcs);
Csl.Wl("开始进行MEF注入，可能需要1-5秒。。。");
Csl.Wl("开始加载模块...");
LoadLgcs();
Csl.Wl("模块加载完成。");
Csl.Wl("内核构建完成。");
LogHelper.Info("内核构建完成。");
Csl.Wl(ConsoleColor.Yellow, "输入help查看相关command操作。");
Csl.Wl(ConsoleColor.Yellow, "输入exit退出。");
}
private static void Cmd()
{
var key = System.Console.ReadLine();
var cmds = key.ToLower().Split(' ');
if (cmds.Length == 0)
{
return;
}
var cmd = cmds[0];
switch (cmd)
{
case "exit":
Csl.Wl("正在关闭应用程序。。。等待最后一个心跳执行完成。。。");
Server.Close();
Csl.Wl("2秒后关闭应用程序。。。");
Thread.Sleep(2000);
Process.GetCurrentProcess().CloseMainWindow();
break;
case "start":
Server.Start();
Cmd();
break;
case "gc":
{
Stopwatch sw = new Stopwatch();
sw.Start();
GC.Collect();
sw.Stop();
Cmd();
break;
}
default:
{
Server.Cmd(cmd);
Cmd();
break;
}
return;
}
}
private void ShowQueue()
{
Console.CursorTop = 5;
Csl.Wl("---------------------------------------------------");
for (int i = 0; i < _count; i++)
{
var idx = i + 1;
var name = string.IsNullOrEmpty(_queue[idx]) ? "____" : _queue[idx];
Csl.WlInLine(ConsoleColor.Green, idx + "." + name + "\t");
if (idx % 4 == 0 && idx != 0)
{
Csl.WlInLine("\n");
}
}
Csl.Wl("---------------------------------------------------");
}
static void server_OnReceive(object sender, DataEventArgs <NetMQ.NetMQSocket, NetMQ.NetMQMessage> e)
{
var msg = e.Arg2;
var server = e.Arg1;
if (msg.FrameCount != 2)
{
Csl.Wl(msg.Pop().ConvertToString(Encoding.UTF8));
server.Send("你好,您的请求已处理，并返回消息及处理结果", Encoding.UTF8);
return;
}
SeatCommand cmd = new SeatCommand();
var back = cmd.Exec(msg);
server.SendMessage(back);
}
//Stopwatch sw1 = new Stopwatch();
/// <summary>
/// 延迟拼包发送
/// </summary>
/// <param name="msg"></param>
public override void SendDelay(IEnumerable <VarList> msgs)
{
//sw1.Restart();
if (_tcpSock == null || !_tcpSock.Connected)
{
return;
}
try
{
using (var ms = new MemoryStream())
{
long lastPosition = 0;
foreach (var msg in msgs)
{
//包头定义
var ph = new PackageHead();
ms.Position = lastPosition;
ph.GetHeadBytes(ms);
ms.Position = lastPosition + ph.HEADSIZE + ph.BODYLENGTH;
Serializer.Serialize(ms, msg);
var count = Convert.ToInt32(ms.Position - ph.HEADSIZE - ph.BODYLENGTH - lastPosition);
lastPosition = ms.Position;
ms.Position = lastPosition - count - ph.BODYLENGTH;
ph.Write(ms, count);
ph.Dispose();
}
Send(ms.GetBuffer(), 0, (int)lastPosition);
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
Log.Error(ex.StackTrace);
Csl.Wl(ConsoleColor.Red, ex.StackTrace);
}
//sw1.Stop();
//if (sw1.ElapsedMilliseconds > 50)
//{
// Csl.Wl(ConsoleColor.Red, "Send msgs " + sw1.ElapsedMilliseconds);
//}
}
private void ProcessAccept(SocketAsyncEventArgs args)
{
try
{
if (!_running)
{
Csl.Wl("Server closed...");
return;
}
IClient client = CreateClient();
client.TcpSocket = args.AcceptSocket;
client.BeginReceive();
StartAccept(args);
if (OnClientConnected(client))
{
lock (_clients)
{
_clients.Add(client);
}
}
else
{
client.TcpSocket.Shutdown(SocketShutdown.Both);
client.TcpSocket.Close();
}
}
catch (ObjectDisposedException)
{
}
catch (SocketException e)
{
Csl.Wl(e.StackTrace);
}
catch (Exception e)
{
Csl.Wl(e.StackTrace);
}
}
/// <summary>
/// 移除所有客户端
/// </summary>
public void RemoveAllClients()
{
lock (_clients)
{
foreach (IClient client in _clients)
{
try
{
OnClientDisconnected(client, true);
}
catch (ObjectDisposedException)
{
}
catch (Exception e)
{
Csl.WlEx(e);
Log.Error(e.ToString());
}
}
_clients.Clear();
}
}
//Stopwatch sw = new Stopwatch();
public override void Send(VarList msg)
{
//sw.Restart();
if (_tcpSock == null || !_tcpSock.Connected)
{
return;
}
try
{
using (var ms = new MemoryStream())
{
//sw.Stop();
//if (sw.ElapsedMilliseconds > 50)
//{
// Csl.Wl("memory msg " + sw.ElapsedMilliseconds);
//}
//sw.Restart();
//包头定义
//包头定义
//using (var ph = new PackageHead())
//{
//sw.Stop();
//if (sw.ElapsedMilliseconds > 50)
//{
// Csl.Wl("head msg " + sw.ElapsedMilliseconds);
//}
//sw.Restart();
ms.WriteByte((byte)SocketHelper.H1);
ms.WriteByte((byte)SocketHelper.H2);
ms.WriteByte((byte)SocketHelper.H3);
ms.WriteByte((byte)SocketHelper.H4);
//ph.GetHeadBytes(ms);
ms.Position = 8;
//消息序列化
Serializer.Serialize(ms, msg);
int count = Convert.ToInt32(ms.Position - 8);
//设置包体长度
ms.Position = 4;
ms.Write(BitConverter.GetBytes(count), 0, 4);
//ph.Write(ms, count);
//sw.Stop();
//if (sw.ElapsedMilliseconds > 50)
//{
// msg.ToString();
// Csl.Wl("Serialize msg " + sw.ElapsedMilliseconds);
//}
//sw.Restart();
Send(ms.GetBuffer(), 0, count + 8);
//}
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
Log.Error(ex.StackTrace);
Csl.Wl(ConsoleColor.Red, ex.StackTrace);
}
//sw.Stop();
//if (sw.ElapsedMilliseconds > 50)
//{
// Csl.Wl("Send msg " + sw.ElapsedMilliseconds);
//}
}
static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
Csl.WlEx((Exception)e.ExceptionObject);
}
public void Start()
{
_trunkBeat.Start();
Csl.Wl("程序启动成功，心跳开始执行");
LogHelper.Info("程序启动成功，心跳开始执行");
}
static void InitQueue()
{
queue = new SeatQueue();
queue.Init(20);
Csl.Wl("初始化队列完成");
}
//Stopwatch sw = new Stopwatch();
protected void QueueUpdateCallback(object state, bool timeOut)
{
if (!_running)
{
return;
}
CurrentThreadId = Thread.CurrentThread.ManagedThreadId;
var timerStart = QueueTimer.ElapsedMilliseconds;
var updateDt = (timerStart - LastUpdate) / 1000.0f;
//Parallel.ForEach(Updatables, (x, y) => x.Update(updateDt));
//sw.Restart();
var gcupdates = Updatables.Where(p => !p.IsRunning).ToList();
foreach (var updatable in gcupdates)
{
Updatables.Remove(updatable);
}
foreach (var updatable in Updatables)
{
try
{
updatable.Update(updateDt);
}
catch (Exception e)
{
Log.Error(e);
Csl.WlEx(e);
}
}
//sw.Stop();
//if (sw.ElapsedMilliseconds > 100)
//{
// Csl.Wl("Heart:" + sw.ElapsedMilliseconds.ToString());
//}
LastUpdate = QueueTimer.ElapsedMilliseconds;
//sw.Restart();
IMessage msg;
//if (flag ==1)
//{
while (LogicQueue.TryDequeue(out msg))
{
try
{
msg.Execute();
if (!_running)
{
return;
}
}
catch (Exception ex)
{
Log.Error(ex);
Csl.WlEx(ex);
}
}
// Interlocked.Exchange(ref flag, 0);
//}
//else
//{
// while (MessageQueue.TryDequeue(out msg))
// {
// try
// {
// msg.Execute();
// if (!_running)
// {
// return;
// }
// }
// catch (Exception ex)
// {
// Log.Error(ex);
// Csl.WlEx(ex);
// }
// }
// Interlocked.Exchange(ref flag, 1);
//}
//sw.Stop();
//if (sw.ElapsedMilliseconds > 100)
//{
// Csl.Wl("Msg: " + sw.ElapsedMilliseconds.ToString());
//}
long timerStop = QueueTimer.ElapsedMilliseconds;
bool updateLagged = timerStop - timerStart > UpdateFrequency;
long callbackTimeout = updateLagged ? 0 : ((timerStart + UpdateFrequency) - timerStop);
CurrentThreadId = 0;
//if (_running)
//{
// // re-register the Update-callback
// _updateTask = Task.Factory.StartNewDelayed((int)callbackTimeout, QueueUpdateCallback, this);
//}
if (_running)
{
//Csl.Wl(ConsoleColor.Blue, string.Format("LogicQueue: {0},MessageQueue: {1}", LogicQueue.Count, MessageQueue.Count));
MessageQueue = Interlocked.Exchange(ref LogicQueue, MessageQueue);
//Swap(ref LogicQueue, ref MessageQueue);
//Csl.Wl(ConsoleColor.DarkRed, string.Format("LogicQueue: {0},MessageQueue: {1}",LogicQueue.Count,MessageQueue.Count));
if (callbackTimeout < 0)
{
callbackTimeout = 0;
}
ThreadPool.RegisterWaitForSingleObject(WaitHandle, QueueUpdateCallback, null, callbackTimeout, true);
}
}
public Form1()
{
InitializeComponent();
Csl.Init();
}
private void ProcessRecieve(SocketAsyncEventArgs args)
{
try
{
int bytesReceived = args.BytesTransferred;
recvDataBuffer.SetCount(recvDataBuffer.Count + bytesReceived);
if (bytesReceived == 0)
{
// no bytes means the client disconnected, so clean up!
_server.DisconnectClient(this, true);
}
else
{
// increment our counters
//unchecked
//{
// _bytesReceived += (uint)bytesReceived;
//}
//Interlocked.Add(ref _totalBytesReceived, bytesReceived);
_remainingLength += bytesReceived;
if (OnReceive(recvDataBuffer))
{
_offset = 0;
recvDataBuffer.Clear();
}
else
{
//var newBuffer = new DataBuffer(BufferSize);
// Array.Copy(recvDataBuffer.Data, _offset, newBuffer.Data, 0, _remainingLength);
Array.Copy(recvDataBuffer.Data, _offset, recvDataBuffer.Data, 0, _remainingLength);
recvDataBuffer.SetPostion(_remainingLength);
recvDataBuffer.SetCount(_remainingLength);
//recvDataBuffer = newBuffer;
_offset = 0;
//_receBufferCount++;
}
ResumeReceive();
}
}
catch (ObjectDisposedException)
{
if (_server != null)
{
_server.DisconnectClient(this, true);
}
}
catch (Exception e)
{
if (_server != null)
{
//_server.Warning(this, e);
_server.DisconnectClient(this, true);
Csl.Wl(e);
}
}
finally
{
args.Completed -= ReceiveAsyncComplete;
SocketHelpers.ReleaseSocketArg(args);
}
}
