private void __ActiveMiddlewareMessageWattinghere(MiddlewareTransferPackage mtPkg)
{
lock (_synWriteLockObject)
{
_asynWattingMiddlewareReplyMessages[mtPkg.MessageId] = mtPkg;
}
}
internal MiddlewareTransferPackage SynSendMessage(MiddlewareTransferPackage mtPkg, int timeoutMilliseconds)
{
if (mtPkg is RequestMTPackage)
{
return(__SendMessageAndWattingForResponse(mtPkg, timeoutMilliseconds));
}
else
{
throw new MiddlewareCommunicatErrorExcetion("不能尝试同步一份应答报文");
}
}
/// <summary>
/// 非阻塞式执行一次消息发送请求
/// </summary>
/// <param name="mtPkg">发往远程中间件设备的消息包</param>
internal void AsynSendMessage(MiddlewareTransferPackage mtPkg)
{
//will send a message
if ((mtPkg is RequestMTPackage) && ((mtPkg as RequestMTPackage).WattingResponse))
{
__ActiveMiddlewareMessageWattinghere(mtPkg);
}
bool mustWaitReponse = true;
ServerRequestPackage wilSendScsMsg = new ServerRequestPackage(mustWaitReponse);
//配置为Middleware传输包
IMiddleware2MiddlewareCommunicatRequest statSeter = wilSendScsMsg.Active_MiddlewareCommunicatRequest();
statSeter.WilSendMiddleware2MiddlewareMessage(mtPkg.TargetDevice, mtPkg);
BinTransferLayer btlprocessor = _middlewareCorelogicLayer.BinTransferProcessor;
ServerReplyPackage replyServPkg = null;
try
{
replyServPkg = btlprocessor.SynSendMessage(wilSendScsMsg, 100000);
}
catch (System.Exception ex)
{
//TODO
throw new MiddlewareTransferErrorExcetion(ex);
}
//分析服务端报文
IMiddleware2MiddlewareCommunicatReply replyInterface = replyServPkg.Active_Middleware2MiddlewareCommunicatReply();
bool ret;
string detail;
try
{
replyInterface.SendMiddlewareMsgOprRet(out ret, out detail);
}
catch (Exception ex)
{
throw new MiddlewareTransferErrorExcetion(ex.ToString());
}
if (true == ret)
{
//noting to do
}
else
{
throw new MiddlewareTransferErrorExcetion(detail);
}
}
protected void CoSynSendRequest(RequestCommunicatePackage communicator, int timeMillionsecond)
{
if (communicator.WaitResponse)
{
RequestPackage reqtPkg = new RequestPackage(_selfDevice,
communicator.CommunicationName,
communicator.WaitResponse,
communicator.ParamPackage.ParamDefalutValues);
C2CRequestPackage c2cReqtPkg = new C2CRequestPackage(_selfDevice,
"outside message sent",
communicator.WaitResponse,
null);
c2cReqtPkg.OutSideMessage = reqtPkg;
RequestMTPackage mtReqtPkg = new RequestMTPackage(c2cReqtPkg,
_selfDevice,
communicator.TargetDevice,
c2cReqtPkg.WaittingResponse);
MiddlewareTransferPackage mtReplyBasePkg = null;
//set param-time to wait this c2c response.
mtReplyBasePkg = _middlewareCommunicateProcessor.SynSendMessage(mtReqtPkg, timeMillionsecond);
if (null != (mtReplyBasePkg as ReplyMTPackage))
{
ReplyMTPackage mtReplyPkg = mtReplyBasePkg as ReplyMTPackage;
C2CReplyPackage c2cReplyPkg = mtReplyPkg.C2CReplyPackage;
if ((null != c2cReplyPkg) && (null != c2cReplyPkg.OutSideMessage))
{
ReplyPackage outsideReplyPkg = c2cReplyPkg.OutSideMessage;
communicator.ResponsePackage = outsideReplyPkg;
}
else
{
throw new ArgumentNullException("应答报文C2CReplyPackage/C2CReplyPackage.OutSideMessage字段空");
}
}
else
{
throw new NotImplementedException("暂不支持打回RequestMTPackage类型");
}
}
else
{
throw new MiddlewareCommunicatErrorExcetion("同步调用而不请求应答是一个错误");
}
}
internal MiddlewareTransferPackage DeserializeMessage(byte[] bytes)
{
if ((null == bytes) || (0 == bytes.Length))
{
throw new Exception("Bin数据不存在或为空");
}
byte bytOpjTypeCodec = bytes[0];
switch (bytOpjTypeCodec)
{
case (byte)SerializObjectType.MiddlewareTransferPackage:
{
try
{
byte[] bytObjContent = new byte[bytes.Length - 1];
Buffer.BlockCopy(bytes, 1, bytObjContent, 0, bytObjContent.Length);
CCCommunicateClass.Seria_MiddlewareTransferPackage middlewareSerializeObj = null;
MiddlewareTransferPackage retPkg = new MiddlewareTransferPackage();
using (MemoryStream m = new MemoryStream(bytObjContent))
{
CJNet_SerializeTool deSerializeTool = new CJNet_SerializeTool();
middlewareSerializeObj = deSerializeTool.Deserialize(m, null, typeof(CCCommunicateClass.Seria_MiddlewareTransferPackage))
as CCCommunicateClass.Seria_MiddlewareTransferPackage;
}
retPkg.ParseSerializeData(middlewareSerializeObj);
return(retPkg);
}
catch (System.Exception ex)
{
throw new Exception("针对Bin数据尝试反序列失败，请检验数据格式: " + ex.ToString());
}
}
case (byte)SerializObjectType.RequestMTPackage:
{
try
{
byte[] bytObjContent = new byte[bytes.Length - 1];
Buffer.BlockCopy(bytes, 1, bytObjContent, 0, bytObjContent.Length);
CCCommunicateClass.Seria_RequestMTPackage reqtMTPSerializeObj = null;
RequestMTPackage retPkg = new RequestMTPackage();
using (MemoryStream m = new MemoryStream(bytObjContent))
{
CJNet_SerializeTool deSerializeTool = new CJNet_SerializeTool();
reqtMTPSerializeObj = deSerializeTool.Deserialize(m, null, typeof(CCCommunicateClass.Seria_RequestMTPackage)) as CCCommunicateClass.Seria_RequestMTPackage;
}
retPkg.ParseSerializeData(reqtMTPSerializeObj);
return(retPkg);
}
catch (System.Exception ex)
{
throw new Exception("针对Bin数据尝试反序列失败，请检验数据格式: " + ex.ToString());
}
}
case (byte)SerializObjectType.ReplyMTPackage:
{
try
{
byte[] bytObjContent = new byte[bytes.Length - 1];
Buffer.BlockCopy(bytes, 1, bytObjContent, 0, bytObjContent.Length);
CCCommunicateClass.Seria_ReplyMTPackage replyMTPSerializeObj = null;
ReplyMTPackage retPkg = new ReplyMTPackage();
using (MemoryStream m = new MemoryStream(bytObjContent))
{
CJNet_SerializeTool deSerializeTool = new CJNet_SerializeTool();
replyMTPSerializeObj = deSerializeTool.Deserialize(m, null, typeof(CCCommunicateClass.Seria_ReplyMTPackage)) as CCCommunicateClass.Seria_ReplyMTPackage;
}
retPkg.ParseSerializeData(replyMTPSerializeObj);
return(retPkg);
}
catch (System.Exception ex)
{
throw new Exception("针对Bin数据尝试反序列失败，请检验数据格式: " + ex.ToString());
}
}
default:
{
throw new NotImplementedException("二进制数据指向无法识别的类型");
}
}
}
private MiddlewareTransferPackage __SendMessageAndWattingForResponse(MiddlewareTransferPackage msg, int timeoutMilliseconds)
{
WaitingMessage waitMsg = new WaitingMessage();
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages[msg.MessageId] = waitMsg;
}
//send message
bool mustWaitReponse = true;
ServerRequestPackage wilSendServMsg = new ServerRequestPackage(mustWaitReponse);
//配置为中间件传输包
IMiddleware2MiddlewareCommunicatRequest statSetter = wilSendServMsg.Active_MiddlewareCommunicatRequest();
statSetter.WilSendMiddleware2MiddlewareMessage(msg.TargetDevice, msg);
BinTransferLayer btlpeocessor = _middlewareCorelogicLayer.BinTransferProcessor;
ServerReplyPackage replyServPkg = null;
try
{
replyServPkg = btlpeocessor.SynSendMessage(wilSendServMsg, 100000);
}
catch (System.Exception ex)
{
//释放锁记录
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages.Remove(msg.MessageId);
}
throw new MiddlewareTransferErrorExcetion(ex.ToString());
}
//分析服务端报文
IMiddleware2MiddlewareCommunicatReply replyInterface = replyServPkg.Active_Middleware2MiddlewareCommunicatReply();
bool ret;
string detail;
replyInterface.SendMiddlewareMsgOprRet(out ret, out detail);
if (true == ret)
{
//noting to do
}
else
{
throw new MiddlewareTransferErrorExcetion(detail);
}
//wait for the recived event
waitMsg.WaitEvent.Wait(timeoutMilliseconds);
//Check for exceptions
switch (waitMsg.State)
{
case MiddlewareTransferServerStateInfo.WaittingForResponse:
{
//同步超时
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages.Remove(msg.MessageId);
}
throw new MiddlewareTransferErrorExcetion(MiddlewareTransferServerStateInfo.TimeOut.ToString());
}
case MiddlewareTransferServerStateInfo.ResponseReceived:
{
lock (_synWriteLockObject)
{
_synWattingMiddlewareReplyMessages.Remove(msg.MessageId);
}
break;
}
}
return(waitMsg.ResponseMessage);
}
/// <summary>
/// 阻塞式执行一次中间层报文通讯
/// </summary>
/// <param name="msg">发起方报文</param>
/// <returns>远程中间件响应报文</returns>
private MiddlewareTransferPackage __SendMessageAndWattingForResponse(MiddlewareTransferPackage msg)
{
return(__SendMessageAndWattingForResponse(msg, -1));
}
private void __ProcessMiddlewareMessageRecived(MiddlewareTransferPackage mtMsg)
{
if (mtMsg is RequestMTPackage)
{
//向上请求消息
_middlewareCorelogicLayer.MiddlewareTransferMessageRecived(mtMsg as RequestMTPackage);
}
if (mtMsg is ReplyMTPackage)
{
//Noting to do, push up
ReplyMTPackage mtReplyPkg = mtMsg as ReplyMTPackage;
bool bAsynArrIndexExist = false;
bool bSynArrIndexExist = false;
lock (_synReadLockObject)
{
if (false == string.IsNullOrEmpty(mtReplyPkg.RepliedMessageId))
{
bAsynArrIndexExist = _asynWattingMiddlewareReplyMessages.ContainsKey(mtReplyPkg.RepliedMessageId);
bSynArrIndexExist = _synWattingMiddlewareReplyMessages.ContainsKey(mtReplyPkg.RepliedMessageId);
}
}
if ((false == bAsynArrIndexExist) &&
(false == bSynArrIndexExist))
{
//一个未知的应答消息，没有索引，丢弃
}
else
{
if (true == bSynArrIndexExist)
{
//处理同步消息
WaitingMessage waitingMessage = null;
lock (_synReadLockObject)
{
if (_synWattingMiddlewareReplyMessages.ContainsKey(mtReplyPkg.RepliedMessageId))
{
waitingMessage = _synWattingMiddlewareReplyMessages[mtReplyPkg.RepliedMessageId] as WaitingMessage;
}
}
//If there is a thread waiting for this response message, pulse it
if (waitingMessage != null)
{
waitingMessage.ResponseMessage = mtReplyPkg;
waitingMessage.State = MiddlewareTransferServerStateInfo.ResponseReceived;
waitingMessage.WaitEvent.Set();
return;
}
}
else
{
//处理异步消息
MiddlewareTransferPackage sourMtPkg = _asynWattingMiddlewareReplyMessages[mtReplyPkg.RepliedMessageId] as MiddlewareTransferPackage;
_middlewareCorelogicLayer.MiddlewareTransferMessageRecived(sourMtPkg, mtReplyPkg);
//清理资源
bool havWattingRecored;
lock (_synReadLockObject)
{
havWattingRecored = _asynWattingMiddlewareReplyMessages.ContainsKey(mtReplyPkg.RepliedMessageId);
}
if (havWattingRecored)
{
_asynWattingMiddlewareReplyMessages.Remove(mtReplyPkg.RepliedMessageId);
}
}
}
}
}
/// <summary>
/// 阻塞式执行一次消息发送请求
/// </summary>
/// <param name="mtPkg">发往远程中间件设备的消息包</param>
/// <returns>远程中间件返回的报文包</returns>
///
internal MiddlewareTransferPackage SynSendMessage(MiddlewareTransferPackage mtPkg)
{
return(SynSendMessage(mtPkg, -1));
}
/// <summary>
/// 中间件传输层Error信息通知
/// </summary>
/// <param name="sourMtPkg">该错误匹配的一次中间件通讯发起报文</param>
/// <param name="errorInfoPkg">错误信息包装类</param>
internal void MiddlewareTransferErrorRecived(MiddlewareTransferPackage sourMtPkg, MiddlewareTransferErrorExcetion errExInfo)
{
throw new NotImplementedException("目前的调用机制暂时使用同步接口对BinLayer进行操作,故不应触发到该分支");
}
/// <summary>
/// 中间件传输层消息通知
/// </summary>
/// <param name="sourMtPkg">发起中间件通讯的数据包</param>
/// <param name="targtMtPkh">匹配的应答包</param>
internal void MiddlewareTransferMessageRecived(MiddlewareTransferPackage sourMtPkg, MiddlewareTransferPackage targtMtPkh)
{
throw new NotImplementedException("目前的调用机制暂时不需要使用MiddlewareCommunicat的异步接口,故不应触发到该分支");
}
private void __CoAsynSendRequestRunning(RequestCommunicatePackage communicator)
{
RequestPackage reqtPkg = new RequestPackage(_selfDevice,
communicator.CommunicationName,
communicator.WaitResponse,
communicator.ParamPackage.ParamDefalutValues);
C2CRequestPackage c2cReqtPkg = new C2CRequestPackage(_selfDevice,
"outside message sent",
communicator.WaitResponse,
null);
c2cReqtPkg.OutSideMessage = reqtPkg;
RequestMTPackage mtReqtPkg = new RequestMTPackage(c2cReqtPkg,
_selfDevice,
communicator.TargetDevice,
c2cReqtPkg.WaittingResponse);
if (communicator.WaitResponse)
{
MiddlewareTransferPackage mtReplyBasePkg = null;
try
{
//100s limited time to wait this c2c response.
mtReplyBasePkg = _middlewareCommunicateProcessor.SynSendMessage(mtReqtPkg, 10000);
}
catch (System.Exception ex)
{
//throw new MiddlewareCommunicatErrorExcetion(ex.ToString());
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
if (null != (mtReplyBasePkg as ReplyMTPackage))
{
ReplyMTPackage mtReplyPkg = mtReplyBasePkg as ReplyMTPackage;
C2CReplyPackage c2cReplyPkg = mtReplyPkg.C2CReplyPackage;
if ((null != c2cReplyPkg) && (null != c2cReplyPkg.OutSideMessage))
{
ReplyPackage outsideReplyPkg = c2cReplyPkg.OutSideMessage;
communicator.ResponsePackage = outsideReplyPkg;
//asyn outside notify
if (null != communicator.AsynchronousReponseCame)
{
communicator.AsynchronousReponseCame(communicator, new AsynReplyCommunicatePackage(outsideReplyPkg));
}
}
else
{
ArgumentNullException ex = new ArgumentNullException("应答报文C2CReplyPackage/C2CReplyPackage.OutSideMessage字段空");
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
}
else
{
NotImplementedException ex = new NotImplementedException("暂不支持打回RequestMTPackage类型");
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
}
else
{
try
{
_middlewareCommunicateProcessor.AsynSendMessage(mtReqtPkg);
}
catch (System.Exception ex)
{
//throw new MiddlewareCommunicatErrorExcetion(ex.ToString());
this.CoMiddleware2MiddlewareAsynReqtCommunicatErrorRecived_OutsideNotify(communicator,
new MiddlewareCommunicatErrorExcetion(ex.ToString()));
}
}
}
public void Listen(ClientDevice messenger, BaseMessageType typMsg)
{
if (mListeningDevice2MsgID.ContainsKey(messenger.Detail) &&
(mListeningDevice2MsgID[messenger.Detail] as List <uint>).Contains(typMsg.Id))
{
throw new InvalidOperationException("该设备消息已被监听");
}
C2CRequestPackage listenerVertificationRequestPkg =
new C2CRequestPackage(mCoreLogicProcessor.SelfDevice,
"ListenerVertificationRequest",
true,
new Dictionary <string, byte[]>()
{
{ "MessageType",
BitConverter.GetBytes(typMsg.Id) }
});
RequestMTPackage mtReqtPkg = new RequestMTPackage(listenerVertificationRequestPkg,
mCoreLogicProcessor.SelfDevice,
messenger,
true);
//验证流程
MiddlewareTransferPackage mtReplyBasePkg = null;
try
{
//100s limited time to wait this c2c response.
mtReplyBasePkg = mMiddlewareCommunicateProcessor.SynSendMessage(mtReqtPkg, 10000);
}catch (Exception ex)
{
throw new Exception("尝试监听一个设备消息时遭遇网络异常：" + ex.ToString());
}
ReplyMTPackage mtReplyPkg = mtReplyBasePkg as ReplyMTPackage;
C2CReplyPackage c2cReplyPkg = mtReplyPkg.C2CReplyPackage;
if (Communication.Package.ReplyPackage.Middleware_ReplyInfo.S_OK == c2cReplyPkg.ReplyState)
{
//加入监听群组
string gourp_detail = Encoding.ASCII.GetString(c2cReplyPkg.ParamDefalutValues["group_detail"]);
GroupDevice wilListenGroup = null;
try
{
wilListenGroup = mGroupCommunicateProcessor.GetGroup(gourp_detail);
mGroupCommunicateProcessor.JoinGroup(wilListenGroup,
Communication.CommunicationConfig.GroupMemberRole.Listener);
}catch (Exception ex)
{
throw new Exception("尝试监听一个设备消息时遭遇网络异常：" + ex.ToString());
}
if (!mListeningDevice2MsgID.ContainsKey(messenger.Detail))
{
mListeningDevice2MsgID.Add(messenger.Detail, new List <uint>());
}
(mListeningDevice2MsgID[messenger.Detail] as List <uint>).Add(typMsg.Id);
mListeningGroup2Device.Add(wilListenGroup.Detail, messenger);
}
else
{
throw new Exception("尝试监听一个设备消息时遭遇网络异常：" +
Encoding.UTF8.GetString(c2cReplyPkg.ParamDefalutValues["excetion_detail"]));
}
}
