// Service =========================================================================
protected virtual void SessOpenService(ServiceRequest request, ref ServiceResponse response)
{
IDictionary <string, dynamic> dc = Newtonsoft.Json.JsonConvert.DeserializeObject
<Dictionary <string, dynamic> >((string)request.data);
// find session and open
IPEndPoint ep = new IPEndPoint(IPAddress.Parse(dc["ip"]), Convert.ToInt32(dc["port"]));
SockSess sess = null;
if (dc["type"] == SockType.listen.ToString() && sessctl.FindSession(SockType.listen, ep, null) == null)
{
sess = sessctl.MakeListen(ep);
}
else if (dc["type"] == SockType.connect.ToString())
{
sess = sessctl.AddConnect(ep);
}
else
{
sess = null;
}
if (sess != null)
{
response.errcode = 0;
response.errmsg = dc["type"] + " " + ep.ToString();
}
else
{
response.errcode = 1;
response.errmsg = "cannot find " + ep.ToString();
}
}
private void OnSessOpen(object sender, SockSess sess)
{
if (sess is SockSessServer)
{
uidata.OpenSockUnit(SockType.listen, sess.lep, sess.rep, sess.id);
}
else if (sess is SockSessClient)
{
uidata.OpenSockUnit(SockType.connect, sess.lep, sess.rep, sess.id);
}
else
{
SockUnit sockUnit = new SockUnit()
{
ID = "at" + sess.rep.ToString(),
SESSID = sess.id,
Name = "accept",
Type = SockType.accept,
Lep = sess.lep,
Rep = sess.rep,
State = SockState.Opened,
};
uidata.AddSockUnit(sockUnit);
}
}
void OnAccept(SockSessServer server)
{
SockSess accept = server.Accept();
accept.recv_event += new SockSess.SockSessDelegate(OnRecv);
Loop.default_loop.Add(accept);
}
protected virtual void OnSessCreate(object sender, SockSess sess)
{
if (sess.type == SockType.accept)
{
Dictionary <string, string> sd = new Dictionary <string, string>();
sd.Add("sessid", sess.id);
sd.Add("lep", sess.lep.ToString());
sd.Add("rep", sess.rep.ToString());
sess.sdata = sd;
}
}
// session events =======================================================
protected virtual void OnRecvEvent(SockSess sess)
{
while (sess.rfifo.Size() != 0)
{
ServiceRequest request = ServiceRequest.Parse(sess.rfifo.Peek());
if (request.packlen == 0)
{
break;
}
sess.rfifo.Skip(request.packlen);
AddServiceRequest(request);
}
}
private void OnSessClose(object sender, SockSess sess)
{
if (sess is SockSessServer)
{
uidata.CloseSockUnit(SockType.listen, sess.lep, sess.rep);
}
else if (sess is SockSessClient)
{
uidata.CloseSockUnit(SockType.connect, sess.lep, sess.rep);
}
else
{
uidata.DelSockUnit(SockType.accept, sess.lep, sess.rep);
}
}
protected override void OnServiceDone(ServiceRequest request, ServiceResponse response)
{
sessstate.PackDecrease();
Dictionary <string, string> sd = request.sessdata;
if (sd != null && response != null)
{
SockSess sess = FindSockSessFromSessGroup(sd["sessid"]);
if (sess != null)
{
sess.sdata = request.sessdata;
sess.wfifo.Append(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
}
}
protected virtual void OnRecvEvent(SockSess sess)
{
while (sess.rfifo.Size() != 0)
{
ServiceRequest request = ServiceRequest.Parse(sess.rfifo.Peek());
if (request.packlen == 0)
{
break;
}
sess.rfifo.Skip(request.packlen);
request.sessdata = sess.sdata as Dictionary <string, string>;
AddServiceRequest(request);
sessstate.PackIncrease();
}
}
// Session Event ==================================================================================
protected virtual void OnSessParse(object sender, SockSess sess)
{
// init request
ServiceRequest request = ServiceRequest.Parse(sess.RfifoTake());
request.sessdata = sess.sdata as Dictionary <string, string>;
request.sessdata["sessid"] = sess.id;
request.sessdata["lep"] = sess.lep.ToString();
request.sessdata["rep"] = sess.rep.ToString();
// rfifo skip
sess.RfifoSkip(request.packlen);
// add request to service core
AddServiceRequest(request);
}
protected virtual void SessConnectService(ServiceRequest request, ref ServiceResponse response)
{
// parse to dictionary
IDictionary <string, dynamic> dc = Newtonsoft.Json.JsonConvert.DeserializeObject
<Dictionary <string, dynamic> >((string)request.data);
IPEndPoint ep = new IPEndPoint(IPAddress.Parse(dc["ip"]), Convert.ToInt32(dc["port"]));
try {
SockSess sess = MakeConnect(ep);
response.errcode = 0;
response.errmsg = "connect to " + ep.ToString();
} catch (Exception) {
response.errcode = 1;
response.errmsg = "can't connect to " + ep.ToString();
}
}
protected override void OnServiceDone(ServiceRequest request, ServiceResponse response)
{
if (request.sessdata == null)
{
return;
}
sessctl.BeginInvoke(new Action(() =>
{
SockSess sess = sessctl.FindSession(request.sessdata["sessid"]);
if (sess != null)
{
sess.sdata = request.sessdata;
sessctl.SendSession(sess, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(response)));
}
}));
}
protected virtual void SessCloseService(ServiceRequest request, ref ServiceResponse response)
{
// parse to dictionary
IDictionary <string, dynamic> dc = Newtonsoft.Json.JsonConvert.DeserializeObject
<Dictionary <string, dynamic> >((string)request.data);
SockSess sess = FindSockSessFromSessGroup(dc["sessid"]);
if (sess != null)
{
sess.Close();
response.errcode = 0;
response.errmsg = "shutdown " + dc["sessid"];
}
else
{
response.errcode = 1;
response.errmsg = "can't find " + dc["sessid"];
}
}
// Session Event ====================================================================
private void OnSessCreate(object sender, SockSess sess)
{
log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
if (sess is SockSessServer)
{
log.Info(String.Format("Session #L listened at {0}.", sess.lep.ToString()));
}
else if (sess is SockSessClient)
{
log.Info(String.Format("Session #C connected to {0}.", sess.rep.ToString()));
}
else
{
log.Info(String.Format("Session #A accepted to {0}.", sess.rep.ToString()));
}
ServiceResponse response = new ServiceResponse();
if (sess is SockSessServer)
{
response.id = "notice.sesslisten";
}
else if (sess is SockSessClient)
{
response.id = "notice.sessconnect";
}
else
{
response.id = "notice.sessaccept";
}
response.data = new {
sessid = sess.id,
type = sess.GetType().Name,
localip = sess.lep.ToString(),
remoteip = sess.rep == null ? "0:0" : sess.rep.ToString(),
tick = sess.tick,
conntime = sess.conntime,
};
NoticeAdmin(response);
}
private void OnSessDelete(object sender, SockSess sess)
{
log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
if (sess is SockSessServer)
{
log.Info(String.Format("Session #* deleted from {0}.", sess.lep.ToString()));
}
else
{
log.Info(String.Format("Session #* deleted from {0}.", sess.rep.ToString()));
}
ServiceResponse response = new ServiceResponse();
response.id = "notice.sessclose";
response.data = new {
sessid = sess.id,
};
NoticeAdmin(response);
}
protected virtual void SessSendService(ServiceRequest request, ref ServiceResponse response)
{
IDictionary <string, dynamic> dc = Newtonsoft.Json.JsonConvert.DeserializeObject
<Dictionary <string, dynamic> >((string)request.data);
// find session
IPEndPoint ep = new IPEndPoint(IPAddress.Parse(dc["ip"]), Convert.ToInt32(dc["port"]));
SockSess sess = null;
if (dc["type"] == SockType.listen.ToString())
{
sess = sessctl.FindSession(SockType.listen, ep, null);
}
else if (dc["type"] == SockType.connect.ToString())
{
sess = sessctl.FindSession(SockType.connect, ep, null);
}
else// if (dc["type"] == SockType.accept.ToString())
{
sess = sessctl.FindSession(SockType.accept, null, ep);
}
// send message
if (sess != null)
{
sessctl.SendSession(sess, Encoding.UTF8.GetBytes(dc["data"]));
}
if (sess != null)
{
response.errcode = 0;
response.errmsg = "send to " + ep.ToString();
}
else
{
response.errcode = 1;
response.errmsg = "cannot find " + ep.ToString();
}
}
protected virtual void SessSendService(ServiceRequest request, ref ServiceResponse response)
{
// parse to dictionary
IDictionary <string, dynamic> dc = Newtonsoft.Json.JsonConvert.DeserializeObject
<Dictionary <string, dynamic> >((string)request.data);
SockSess sess = FindSockSessFromSessGroup(dc["sessid"]);
if (sess != null)
{
if (!(sess is SockSessServer))
{
sess.wfifo.Append(Convert.FromBase64String(dc["data"]));
}
response.errcode = 0;
response.errmsg = "send to " + dc["sessid"];
}
else
{
response.errcode = 0;
response.errmsg = "can't find " + dc["sessid"];
}
}
// SockSess Event ======================================================================
protected virtual void OnAcceptEvent(SockSessServer server)
{
SockSess accept = server.Accept();
Loop.default_loop.Add(accept);
Dictionary <string, string> sd = new Dictionary <string, string>();
sd.Add("sessid", accept.id);
sd.Add("lep", accept.lep.ToString());
sd.Add("rep", accept.rep.ToString());
accept.sdata = sd;
accept.close_event += new SockSess.SockSessDelegate(OnCloseEvent);
accept.recv_event += new SockSess.SockSessDelegate(OnRecvEvent);
sesstab.Add(accept);
if (sess_accept_event != null)
{
sess_accept_event(this, accept);
}
sessstate.AcceptIncrease();
}
protected virtual void OnCloseEvent(object sender)
{
SockSess sess = sender as SockSess;
sesstab.Remove(sess);
if (sess_close_event != null)
{
sess_close_event(this, sess);
}
if (sess is SockSessServer)
{
sessstate.ListenCount--;
}
else if (sess is SockSessClient)
{
sessstate.ConnectCount--;
}
else
{
sessstate.AcceptDecrease();
}
}
protected virtual void OnSessDelete(object sender, SockSess sess)
{
}
void OnRecv(SockSess sess)
{
string msg = Encoding.UTF8.GetString(sess.rfifo.Take());
Console.Write(msg);
}
