public RequestMsg ServerDispatchRequest(ServerEndPoint endpoint, RequestMsg request)
{
m_Log.Write(new Azos.Log.Message {
Type = MessageType.TraceA, From = "ServeInspector", Text = "Received " + request.ServerTransport.StatBytesReceived.ToString() + " bytes"
});
return(request);
}
public override async Task <ResponseMsg> GetBlogs(RequestMsg request, ServerCallContext context)
{
var blogs = await _blogService.Get(request.Limit);
return(new ResponseMsg
{
Blogs =
{
new RepeatedField <BlogDto>
{
blogs.Select(c => new BlogDto
{
Id = c.Id.ToString(),
Name = c.Name,
CreateAt = c.CreateAt.ToTimestamp(),
Posts =
{
c.Posts.Select(z => new PostDto
{
Id = z.Id.ToString(),
Name = z.Name,
CreateAt = z.CreateAt.ToTimestamp(),
Tags ={ z.Tags }
})
}
})
}
}
});
}
public RequestMsg ClientDispatchCall(ClientEndPoint endpoint, RequestMsg request)
{
request.Headers.Add(new TextInfoHeader {
Text = "Moscow time is " + m_App.LocalizedTime.ToString(), Info = @"/\EH|/|H }|{|/|B!"
});
return(request);
}
private CallSlot doRequest(ClientEndPoint endpoint, RequestMsg request, CallOptions options)
{
long actualStartTimeTicks = Binding.StatTimeTicks;
DateTime actualStartTimeUtc = DateTime.UtcNow;
if (m_PriorDispatchTimeoutMs != options.DispatchTimeoutMs)
{
m_Client.SendTimeout = options.DispatchTimeoutMs;
m_PriorDispatchTimeoutMs = options.DispatchTimeoutMs;
}
if (m_PriorTimeoutMs != options.TimeoutMs)
{
m_Client.ReceiveTimeout = options.TimeoutMs;
m_PriorTimeoutMs = options.TimeoutMs;
}
putRequest(request);
if (request.OneWay)
{
return(new CallSlot(endpoint, this, request, CallStatus.Dispatched, options.TimeoutMs));
}
var response = getResponse();
return(new CallSlot(endpoint,
this,
actualStartTimeTicks,
actualStartTimeUtc,
request,
response,
options.TimeoutMs));
}
public RequestMsg ServerDispatchRequest(ServerEndPoint endpoint, RequestMsg request)
{
NFX.ApplicationModel.ExecutionContext.Application.Log.Write(new NFX.Log.Message {
Type = NFX.Log.MessageType.TraceA, From = "ServeInspector", Text = "Received " + request.ServerTransport.StatBytesReceived.ToString() + " bytes"
});
return(request);
}
public ResponseMsg ServerReturnResponse(ServerEndPoint endpoint, RequestMsg request, ResponseMsg response)
{
response.Headers.Add(new TextInfoHeader {
Text = "Response generated at " + m_Log.LocalizedTime.ToString(), Info = "Serve Node: " + endpoint.Node
});
return(response);
}
protected override CallSlot DoSendRequest(ClientEndPoint endpoint, RequestMsg request, CallOptions options)
{
request.__setServerTransport(findServerTransport(endpoint));
//notice: no serialization because we are in the same address space
ResponseMsg response;
try
{
response = Glue.ServerHandleRequest(request);
}
catch (Exception e)
{
response = Glue.ServerHandleRequestFailure(request.RequestID, request.OneWay, e, request.BindingSpecificContext);
}
if (request.OneWay)
{
return(new CallSlot(endpoint, this, request, CallStatus.Dispatched, options.TimeoutMs));
}
var result = new CallSlot(endpoint, this, request, CallStatus.ResponseOK);
result.DeliverResponse(response);
return(result);
}
/// <summary>
/// Handles request synchronously in the context of the calling thread. Returns NULL for one-way calls
/// </summary>
public ResponseMsg HandleRequestSynchronously(RequestMsg request)
{
try
{
return(inspectAndHandleRequest(request));
}
catch (Exception error) //nothing may leak
{
if (request.OneWay)
{
//because it is one-way, the caller will never know about it
this.WriteLog(LogSrc.Server,
MessageType.Error,
string.Format(StringConsts.GLUE_SERVER_ONE_WAY_CALL_ERROR + error.ToMessageWithType()),
from: "SrvrHndlr.HandleRequestSynchronously(ReqMsg)",
exception: error
);
return(null);
}
else
{
//call goes via Glue because there may be some global event handlers
var response = Glue.ServerHandleRequestFailure(request.RequestID, request.OneWay, error, request.BindingSpecificContext);
return(response);
}
}
finally
{
NFX.ApplicationModel.ExecutionContext.__SetThreadLevelContext(null, null, null);
}
}
public void ClientDispatchedRequest(ClientEndPoint client, RequestMsg request, CallSlot callSlot)
{
if (client.Binding.OperationFlow == OperationFlow.Asynchronous)
{
m_Calls.Put(callSlot);
}
}
protected override CallSlot DoSendRequest(ClientEndPoint endpoint, RequestMsg request, CallOptions options)
{
try
{
ensureClient();
return(sendRequest(endpoint, request, options));
}
catch (Exception error)
{
var commError = error is SocketException ||
error is System.IO.IOException ||
(typeof(ProtocolException).IsAssignableFrom(error.GetType()) && ((ProtocolException)error).CloseChannel);
Binding.WriteLog(LogSrc.Client,
Log.MessageType.Error,
StringConsts.GLUE_CLIENT_CALL_ERROR + (commError ? "Socket error." : string.Empty) + error.Message,
from: "MpxClientTransport.SendRequest",
exception: error);
stat_Errors();
if (commError)
{
finClient();
}
throw error;
}
}
private object getServerInstance(serverImplementer server, RequestMsg request, out Guid?checkedOutID, out bool lockTaken)
{
object result = null;
checkedOutID = null;
lockTaken = false;
if (server.InstanceMode == ServerInstanceMode.Singleton)
{
if (!m_SingletonInstances.TryGetValue(server.Implementation, out result))
{
lock (m_SingletonInstancesLock)
{
if (!m_SingletonInstances.TryGetValue(server.Implementation, out result))
{
result = createInstance(server);
var dict = new Dictionary <Type, object>(m_SingletonInstances);
dict[server.Implementation] = result;
m_SingletonInstances = dict;//atomic
}
}
}
}
else
if (server.InstanceMode == ServerInstanceMode.Stateful ||
server.InstanceMode == ServerInstanceMode.AutoConstructedStateful)
{
if (request.RemoteInstance.HasValue)
{
result = App.ObjectStore.CheckOut(request.RemoteInstance.Value);
if (result == null || result.GetType() != server.Implementation)
{
throw new StatefulServerInstanceDoesNotExistException(StringConsts.GLUE_STATEFUL_SERVER_INSTANCE_DOES_NOT_EXIST_ERROR + server.Implementation.FullName);
}
checkedOutID = request.RemoteInstance.Value;
if (!server.ThreadSafe)
{
if (!Monitor.TryEnter(result, this.Glue.ServerInstanceLockTimeoutMs))
{
App.ObjectStore.CheckIn(checkedOutID.Value); //check it back in because we could not lock it
throw new StatefulServerInstanceLockTimeoutException(StringConsts.GLUE_STATEFUL_SERVER_INSTANCE_LOCK_TIMEOUT_ERROR + server.Implementation.FullName);
}
lockTaken = true;
}
}
else
{
result = createInstance(server); //no need to lock as instance is brand new
}
}
else // ServerInstanceMode.PerCall
{
result = createInstance(server);
}
return(result);
}
private RequestMsg deserialize(ref WireMsg wmsg)
{
var chunk = wmsg.Data;
chunk.Position = sizeof(int);
WireFrame frame;
RequestMsg result = null;
var arrivalTime = Binding.StatTimeTicks;
object received = null;
try
{
try
{
frame = new WireFrame(chunk);
wmsg.Frame = frame;
received = Binding.Serializer.Deserialize(chunk);
}
catch
{
Instrumentation.ServerDeserializationErrorEvent.Happened(Node);
throw;
}
if (received == null)
{
throw new ProtocolException(StringConsts.GLUE_UNEXPECTED_MSG_ERROR + "RequestMsg. Got <null>");
}
result = received as RequestMsg;
if (result == null)
{
throw new ProtocolException(StringConsts.GLUE_UNEXPECTED_MSG_ERROR + "RequestMsg");
}
stat_MsgReceived();
stat_BytesReceived(chunk.Position);
}
catch
{
stat_Errors();
throw;
}
finally
{
Binding.DumpMsg(true, received as Msg, chunk.GetBuffer(), 0, (int)chunk.Position);
}
result.__SetArrivalTimeStampTicks(arrivalTime);
return(result);
}
private void ResponseMsg(string weixin)// 服务器响应微信请求
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(weixin);//读取xml字符串
XmlElement root = doc.DocumentElement;
RequestMsg xmlMsg = GetExmlMsg(root);
//XmlNode MsgType = root.SelectSingleNode("MsgType");
//string messageType = MsgType.InnerText;
string messageType = xmlMsg.MsgType;//获取收到的消息类型。文本(text)，图片(image)，语音等。
try
{
switch (messageType)
{
//当消息为文本时
case "text":
textCase(xmlMsg);
break;
case "event":
if (!string.IsNullOrEmpty(xmlMsg.EventName) && xmlMsg.EventName.Trim() == "subscribe")
{
//刚关注时的时间，用于欢迎词
int nowtime = ConvertDateTimeInt(DateTime.Now);
string msg = "Hi~欢迎关注沃商通\r\n目前有超过百家商家正在使用的营销神器\r\n回复：1，了解沃商通\r\n回复：2，联系客服\r\n回复：3，了解收费";
string resxml = "<xml><ToUserName><![CDATA[" + xmlMsg.FromUserName + "]]></ToUserName><FromUserName><![CDATA[" + xmlMsg.ToUserName + "]]></FromUserName><CreateTime>" + nowtime + "</CreateTime><MsgType><![CDATA[text]]></MsgType><Content><![CDATA[" + msg + "]]></Content><FuncFlag>0</FuncFlag></xml>";
Response.Write(resxml);
}
break;
case "image":
break;
case "voice":
break;
case "vedio":
break;
case "location":
break;
case "link":
break;
default:
break;
}
Response.End();
}
catch (Exception)
{
}
}
private RequestMsg getRequest(TcpClient client, MemoryStream ms, SlimSerializer serializer)
{
var nets = client.GetStream();
var msb = ms.GetBuffer();
var frameBegin = Consts.PACKET_DELIMITER_LENGTH;
SyncBinding.socketRead(nets, msb, 0, frameBegin);
var size = msb.ReadBEInt32();
if (size < 1 || size > Binding.MaxMsgSize)
{
Instrumentation.ServerGotOverMaxMsgSizeErrorEvent.Happened(Node);
// This is unrecoverable error - close the channel!
throw new MessageSizeException(size, Binding.MaxMsgSize, "getRequest()", closeChannel: true);
}
ms.SetLength(Consts.PACKET_DELIMITER_LENGTH + size); //this may invalidate msb
SyncBinding.socketRead(nets, ms.GetBuffer(), Consts.PACKET_DELIMITER_LENGTH, size);
var arrivalTime = Binding.StatTimeTicks;
ms.Position = Consts.PACKET_DELIMITER_LENGTH;
RequestMsg result = null;
WireFrame frame;
try
{
try
{
frame = new WireFrame(ms);
result = DoDecodeRequest(frame, ms, serializer);
}
catch
{
Instrumentation.ServerDeserializationErrorEvent.Happened(Node);
throw;
}
}
finally
{
Binding.DumpMsg(true, result, ms.GetBuffer(), 0, size + Consts.PACKET_DELIMITER_LENGTH);
}
result.__SetArrivalTimeStampTicks(arrivalTime);
stat_MsgReceived();
stat_BytesReceived(size);
return(result);
}
public RequestMsg ClientDispatchingRequest(ClientEndPoint client, RequestMsg request)
{
//Glue level inspectors
foreach (var insp in ClientMsgInspectors.OrderedValues)
{
request = insp.ClientDispatchCall(client, request);
}
return(request);
}
private void textCase(RequestMsg xmlMsg)
{
int nowtime = ConvertDateTimeInt(DateTime.Now);
string msg = "";
msg = getText(xmlMsg);
if (msg.IsNotNullOrEmpty())
{
string resxml = "<xml><ToUserName><![CDATA[" + xmlMsg.FromUserName + "]]></ToUserName><FromUserName><![CDATA[" + xmlMsg.ToUserName + "]]></FromUserName><CreateTime>" + nowtime + "</CreateTime><MsgType><![CDATA[text]]></MsgType><Content><![CDATA[" + msg + "]]></Content><FuncFlag>0</FuncFlag></xml>";
Response.Write(resxml);
}
}
public async Task <ResponseMsg <JObject> > Handle(RequestMsg request, CancellationToken cancellationToken)
{
_logger.LogInformation("Start getting the matched handler", request);
var targetType = _queryRegister.Get(request.QueriedInstance.DbSettings.DatabaseType);
var targetRequest = Activator.CreateInstance(targetType, request);
var result = await _mediator.Send((IRequest <ResponseMsg <JObject> >) targetRequest, cancellationToken);
return(result);
}
/// <summary>
/// Dispatches a call allocating new or re-using existing transport if needed. The strategy depends on particular Binding implementation.
/// This call is thread-safe
/// </summary>
public CallSlot DispatchCall(ClientEndPoint client, RequestMsg request)
{
CheckRunningState();
//Binding level inspectors
foreach (var insp in m_ClientMsgInspectors.OrderedValues)
{
request = insp.ClientDispatchCall(client, request);
}
//Glue level inspectors
request = Glue.ClientDispatchingRequest(client, request);
//==============================================================
CallOptions options;
options.DispatchTimeoutMs = client.DispatchTimeoutMs;
options.TimeoutMs = client.TimeoutMs;
var reserve = client.ReserveTransport;
var transport = client.m_ReservedTransport ?? AcquireClientTransportForCall(client, request);
CallSlot slot = null;
try
{
if (reserve)
{
client.m_ReservedTransport = transport;
}
slot = transport.SendRequest(client, request, options);
// If execution pauses here and server sends response BEFORE call
//then Glue.Deliver response will retry to fimnd the missing call slot for some fixed interval
if (slot != null)
{
Glue.ClientDispatchedRequest(client, request, slot);
}
}
finally
{
if (!reserve)
{
ReleaseClientTransportAfterCall(transport);
}
}
return(slot);
}
private CallSlot sendRequest(ClientEndPoint endpoint, RequestMsg request, CallOptions options)
{
if (m_PriorDispatchTimeoutMs != options.DispatchTimeoutMs)
{
m_Client.Socket.SendTimeout = options.DispatchTimeoutMs;
m_PriorDispatchTimeoutMs = options.DispatchTimeoutMs;
}
if (m_PriorTimeoutMs != options.TimeoutMs)
{
m_Client.Socket.ReceiveTimeout = options.TimeoutMs;
m_PriorTimeoutMs = options.TimeoutMs;
}
var chunk = m_Client.GetSendChunk();
try
{
var frame = new WireFrame(WireFrame.SLIM_FORMAT, request.OneWay, request.RequestID);
var size = serialize(chunk, frame, request);
var wm = new WireMsg(chunk);
Binding.DumpMsg(false, request, chunk.GetBuffer(), 0, (int)chunk.Position);
if (size > Binding.MaxMsgSize)
{
Instrumentation.ClientSerializedOverMaxMsgSizeErrorEvent.Happened(Node);
throw new MessageSizeException(size, Binding.MaxMsgSize, "sendRequest(" + request.RequestID + ")");
}
m_Client.Send(wm);
stat_MsgSent();
stat_BytesSent(wm.BufferUsedSize);
}
catch
{
stat_Errors();
throw;
}
finally
{
m_Client.ReleaseSendChunk();
}
//regardless of (request.OneWay) we return callslot anyway
return(new CallSlot(endpoint, this, request, CallStatus.Dispatched, options.TimeoutMs));
}
/// <summary>
/// Dispatches a call into binding passing message through client inspectors on this endpoint
/// </summary>
protected CallSlot DispatchCall(RequestMsg request)
{
if (m_Headers.Count > 0)
{
request.Headers.AddRange(m_Headers);
}
foreach (var insp in m_MsgInspectors.OrderedValues)
{
request = insp.ClientDispatchCall(this, request);
}
return(Binding.DispatchCall(this, request));
}
/// <summary>
/// Handles request in the context of ServerHandler thread, replying back to result queue
/// </summary>
public void HandleRequestAsynchronously(RequestMsg request)
{
//todo In Future may supply Request.LongRunning to better predict thread allocation
Task.Factory.StartNew(
(r) => {
var req = (RequestMsg)r;
ResponseMsg response;
try
{
response = HandleRequestSynchronously(req);
}
catch (Exception e1)
{
try
{
//call goes via Glue because there may be some global event handlers
response = Glue.ServerHandleRequestFailure(req.RequestID, req.OneWay, e1, req.BindingSpecificContext);
}
catch (Exception e2)
{
this.WriteLog(LogSrc.Server,
MessageType.Error,
string.Format(StringConsts.GLUE_SERVER_HANDLER_ERROR + e2.ToMessageWithType()),
from: "SrvrHndlr.HndlReqAsnly(ReqMsg:A)",
exception: e2
);
return;
}
}
if (!req.OneWay)
{
try
{
req.ServerTransport.SendResponse(response);
}
catch (Exception error)
{
this.WriteLog(LogSrc.Server,
MessageType.Error,
string.Format(StringConsts.GLUE_SERVER_HANDLER_ERROR + error.ToMessageWithType()),
from: "SrvrHndlr.HndlReqAsnly(ReqMsg:B)",
exception: error
);
}
}
},
request);
}
private string getText(RequestMsg xmlMsg)
{
string con = xmlMsg.Content.Trim();
var content = IMpAutoReplyService.Find(x => !x.IsDelete && x.Keyword == con);
if (content != null)
{
return(content.Details);
}
else
{
return("");
}
}
/// <summary>
/// INTERNAL METHOD. Developers do not call!
/// This constructor is used by an Async binding that delivers response after call slot was created
/// </summary>
public CallSlot(ClientEndPoint client, ClientTransport clientTransport, RequestMsg request, CallStatus status, int timeoutMs = 0)
{
m_Client = client;
m_ClientTransport = clientTransport;
m_RequestID = request.RequestID;
m_CallStatus = status;
m_OneWay = request.OneWay;
m_StartTime = DateTime.UtcNow;
m_TimeoutMs = timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
if (!m_OneWay && client.Binding.MeasureStatTimes)
{
m_StatStartTimeTicks = client.Binding.StatTimeTicks;
m_StatRoundtripTimeKey = client.Binding.GetClientCallStatTimeKey(client, request);
}
}
public override string ToLogString()
{
string strRet = "---------------------------\n";
try
{
strRet += ("节点编号：" + NodeID + "\n");
strRet += ("消息类型：" + RequestType + "\n");
strRet += ("解析结果：" + (bSuccess ? "成功" : "失败") + "\n");
strRet += ("错误信息：" + ErrorStatus + " : " + ErrorMsg + "\n");
strRet += ("发送目标：" + ServerUrl + "\n");
strRet += ("发送内容：" + (RequestMsg.Length > 300 ? RequestMsg.Substring(0, 300) + "..." : RequestMsg) + "\n");
strRet += ("接收内容：" + ResponseMsg + "\n");
strRet += "---------------------------";
}
catch { }
return(strRet);
}
private ResponseMsg handleRequest(RequestMsg request)
{
try
{
ServerCallContext.__SetThreadLevelContext(request);
try
{
var response = doWork(request);
var rhdr = ServerCallContext.GetResponseHeadersOrNull();
if (rhdr != null && response != null)
{
response.Headers = rhdr;
}
return(response);
}
finally
{
ServerCallContext.__ResetThreadLevelContext();
}
}
catch (Exception error)
{
if (request.OneWay)
{ //because it is one-way, the caller will never know about it
this.WriteLog(LogSrc.Server,
MessageType.Error,
string.Format(StringConsts.GLUE_SERVER_ONE_WAY_CALL_ERROR + error.ToMessageWithType()),
from: "SrvrHndlr.handleRequest(ReqMsg)",
exception: error
);
return(null);
}
else
{
var red = new WrappedExceptionData(error);
var response = new ResponseMsg(request.RequestID, red);
response.__SetBindingSpecificContext(request);
return(response);
}
}
}
public ResponseMsg Send(RequestMsg msg)
{
if (_disposeCount != 0)
{
throw new ObjectDisposedException(this.GetType().Name);
}
try
{
_socket.Send(msg.SerializeMessage());
return(_socket.Receive().DeserializeMessage() as ResponseMsg);
}
catch (TerminatingException)
{
Debug.WriteLine(string.Format("TerminatingException: auto-disposing {0} ({1:x})...", this.GetType().Name, this.GetHashCode()));
((IDisposable)this).Dispose();
throw;
}
}
private RequestMsg GetExmlMsg(XmlElement root)
{
RequestMsg xmlMsg = new RequestMsg()
{
FromUserName = root.SelectSingleNode("FromUserName").InnerText,
ToUserName = root.SelectSingleNode("ToUserName").InnerText,
CreateTime = root.SelectSingleNode("CreateTime").InnerText,
MsgType = root.SelectSingleNode("MsgType").InnerText,
};
if (xmlMsg.MsgType.Trim().ToLower() == "text")
{
xmlMsg.Content = root.SelectSingleNode("Content").InnerText;
}
else if (xmlMsg.MsgType.Trim().ToLower() == "event")
{
xmlMsg.EventName = root.SelectSingleNode("Event").InnerText;
}
return(xmlMsg);
}
public async Task <IActionResult> QueryByText(string queryName, string queriedPhrase, int pageLimit)
{
var queryInst = _appConfigInstance.GetQueryInstance(queryName);
_logger.LogDebug("SearchByTextCtrl: Found the query {queryName}", queryName);
if (queryInst == null)
{
return(NotFound());
}
var requestMsg = new RequestMsg(queriedPhrase)
{
QueriedInstance = queryInst,
Limit = pageLimit,
Skip = 0
};
var result = await _mediator.Send(requestMsg);
return(result != null ? (IActionResult)Ok(result) : BadRequest());
}
private void interpretAuthenticationHeader(RequestMsg request)
{
if (!request.HasHeaders)
{
return;
}
var ah = request.Headers.FirstOrDefault(h => h is AuthenticationHeader) as AuthenticationHeader;
if (ah == null)
{
return;
}
if (ah.Credentials == null && ah.Token.Data == null)
{
return;
}
User user;
if (ah.Credentials != null)
{
user = App.SecurityManager.Authenticate(ah.Credentials);
}
else
{
user = App.SecurityManager.Authenticate(ah.Token);
}
if (NFX.ApplicationModel.ExecutionContext.HasThreadContextSession)
{
NFX.ApplicationModel.ExecutionContext.Session.User = user;
}
else
{
NFX.ApplicationModel.ExecutionContext.__SetThreadLevelSessionContext(App.Instance.MakeNewSessionInstance(Guid.NewGuid(), user));
}
}
private void button1_Click(object sender, EventArgs e)
{
ConnectionFactory factory = new ConnectionFactory();
factory.HostName = Constants.MqHost;
factory.Port = Constants.MqPort;
factory.UserName = Constants.MqUserName;
factory.Password = Constants.MqPwd;
using (IConnection conn = factory.CreateConnection())
{
using (IModel channel = conn.CreateModel())
{
//在MQ上定义一个持久化队列，如果名称相同不会重复创建
channel.QueueDeclare("MyFirstQueue", true, false, false, null);
//输入1，那如果接收一个消息，但是没有应答，则客户端不会收到下一个消息
channel.BasicQos(0, 1, false);
Console.WriteLine("Listening...");
//在队列上定义一个消费者
QueueingBasicConsumer consumer = new QueueingBasicConsumer(channel);
//消费队列，并设置应答模式为程序主动应答
channel.BasicConsume("MyFirstQueue", false, consumer);
while (true)
{
//阻塞函数，获取队列中的消息
BasicDeliverEventArgs ea = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
byte[] bytes = ea.Body;
string str = Encoding.UTF8.GetString(bytes);
RequestMsg msg = JsonConvert.DeserializeObject <RequestMsg>(str);
Console.WriteLine("HandleMsg:" + msg.ToString());
//回复确认
channel.BasicAck(ea.DeliveryTag, false);
}
}
}
}
