/// <summary> /// This method processes the returning messages. /// </summary> /// <param name="payload">The incoming payload.</param> /// <param name="responses">The responses collection is not currently used.</param> protected virtual Task OutgoingRequestResponseIn(TransmissionPayload payload, List <TransmissionPayload> responses) { try { string id = payload?.Message?.CorrelationKey?.ToUpperInvariant(); //Get the original request. OutgoingRequestTracker holder; if (id == null || !mOutgoingRequests.TryRemove(id, out holder)) { //If there is not a match key then quit. Collector?.LogMessage(LoggingLevel.Warning, $"OutgoingRequestResponseIn - id {id ?? "is null"} not matched for {payload?.Message?.ProcessCorrelationKey}", "RqRsMismatch"); payload.SignalSuccess(); return(Task.FromResult(0)); } holder.Tcs.SetResult(payload); FireAndDecorateEventArgs(OnOutgoingRequestComplete, () => new OutgoingRequestEventArgs(holder)); } catch (Exception ex) { Collector?.LogException("OutgoingRequestResponseIn unexpected exception", ex); } finally { //Signal to the listener to release the message. payload?.SignalSuccess(); } return(Task.FromResult(0)); }
/// <summary> /// This method processes the returning messages. /// </summary> /// <param name="payload">The incoming payload.</param> /// <param name="responses">The responses collection is not currently used.</param> protected virtual async Task OutgoingRequestResponseProcess(TransmissionPayload payload, List <TransmissionPayload> responses) { string id = payload?.Message?.CorrelationKey?.ToUpperInvariant();; //If there is not a correlation key then quit. if (id == null) { Logger?.LogMessage(LoggingLevel.Warning, "OutgoingRequestsProcessResponse - id is null"); return; } //This method signals the request as completed or failed and sets the incoming payload. if (!OutgoingRequestRemove(id, payload)) { try { OnTimedOutResponse?.Invoke(this, payload); } catch (Exception ex) { Logger?.LogException("OnTimedOutResponse", ex); //We do not want to throw exceptions here. } } //Signal to the listener to release the message. payload.SignalSuccess(); }
private void Sender_OnProcess(object sender, TransmissionPayload e) { try { if (mActiveListeners.Length == 0) { e.SignalSuccess(); return; } OnReceiveInvoke(sender, e); long count = Interlocked.Increment(ref mSendCount); switch (Mode) { case FabricMode.Queue: Sender_TransmitRoundRobin(e, count); break; case FabricMode.Broadcast: Sender_TransmitBroadcast(e, count); break; } } catch (Exception ex) { OnExceptionInvoke(sender, e, ex); } }
/// <summary> /// Processes the exception. /// </summary> /// <param name="ex">The exception raised.</param> /// <param name="rq">The incoming request.</param> /// <param name="responses">The responses.</param> protected virtual Task ProcessRequestException(Exception ex, TransmissionPayload rq, List <TransmissionPayload> responses) { if (Policy.OnProcessRequestExceptionLog) { Collector?.LogException($"{FriendlyName}/ProcessRequest unhandled exception: {rq.Message.ToKey()}", ex); } switch (Policy.OnProcessRequestException) { case ProcessRequestExceptionBehaviour.DoNothing: break; case ProcessRequestExceptionBehaviour.SignalSuccessAndSend500ErrorResponse: rq.SignalSuccess(); var rs = rq.ToResponse(); rs.Message.Status = "500"; rs.Message.StatusDescription = ex.Message; responses.Add(rs); break; case ProcessRequestExceptionBehaviour.SignalFailAndDoNothing: rq.SignalFail(); break; default: throw ex; } return(Task.FromResult(0)); }
/// <summary> /// This method injects a service message manually in to the Microservice. /// </summary> /// <param name="payload">The message payload.</param> /// <param name="priority">The optional priority. The default is 1.</param> public void Inject(TransmissionPayload payload, int?priority = null) { if (this.Status != ServiceStatus.Running) { payload.SignalSuccess(); payload.TraceWrite($"Failed: {Status}", "ManualChannelListener/Inject"); return; } try { var client = ClientResolve(priority ?? mDefaultPriority ?? 1); client.Inject(payload); payload.TraceWrite($"Success: {client.Name}", "ManualChannelListener/Inject"); } catch (Exception ex) { payload.TraceWrite($"Error: {ex.Message}", "ManualChannelListener/Inject"); } }