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); } } } }