private void Cancel(IUntypedPublisher target, TimeSpan timeout)
{
var typedTarget = UntypedPublisher.ToTyped <T>(target);
if (
typedTarget.GetType()
.GetInterfaces()
.Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IProcessor <,>)))
{
if (Log.IsDebugEnabled)
{
Log.Debug(
$"Cancelling {typedTarget} Processor's publisher and subscriber sides (after {timeout.TotalMilliseconds} ms)");
}
HandleSubscriptionTimeout(target, new SubscriptionTimeoutException(
$"Publisher was not attached to upstream within deadline {timeout.TotalMilliseconds} ms"));
}
else
if (Log.IsDebugEnabled)
{
Log.Debug(
$"Cancelling {typedTarget} (after {timeout.TotalMilliseconds} ms)");
}
HandleSubscriptionTimeout(target, new SubscriptionTimeoutException(
$"Publisher {typedTarget} you are trying to subscribe to has been shut-down because exceeing its subscription timeout"));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="untypedPublisher">TBD</param>
/// <returns>TBD</returns>
public static object ToTyped(IUntypedPublisher untypedPublisher)
{
if (untypedPublisher is UntypedPublisher)
{
return(((UntypedPublisher)untypedPublisher).Unwrap());
}
return(untypedPublisher);
}
private void Warn(IUntypedPublisher target, TimeSpan timeout)
{
var typedTarget = UntypedPublisher.ToTyped <T>(target);
Log.Warning(
"Timed out {0} detected (after {1})! You should investigate if you either cancel or consume all {2} instances",
typedTarget, timeout, typedTarget.GetType().Name);
}
public void SubscriptionTimedOut(IUntypedPublisher target)
{
switch (SubscriptionTimeoutSettings.Mode)
{
case StreamSubscriptionTimeoutTerminationMode.CancelTermination: Cancel(target, SubscriptionTimeoutSettings.Timeout); break;
case StreamSubscriptionTimeoutTerminationMode.WarnTermination: Warn(target, SubscriptionTimeoutSettings.Timeout); break;
}
}
/// <summary>
/// Callback that should ensure that the target is canceled with the given cause.
/// </summary>
public void HandleSubscriptionTimeout(IUntypedPublisher target, Exception cause)
{
SubstreamOutput output;
if ((output = UntypedPublisher.ToTyped <T>(target) as SubstreamOutput) != null)
{
output.Error(cause);
output.AttachSubscriber(CancelingSubscriber <T> .Instance);
}
}
/// <summary> /// TBD /// </summary> /// <param name="publisher">TBD</param> public abstract void RegisterPublisher(IUntypedPublisher publisher);
/// <summary>
/// TBD
/// </summary>
/// <param name="publisher">TBD</param>
public override void RegisterPublisher(IUntypedPublisher publisher)
{
_publisher.RegisterPublisher(UntypedPublisher.ToTyped <T>(publisher));
}
/// <summary>
/// TBD
/// </summary>
/// <typeparam name="T">TBD</typeparam>
/// <param name="untypedPublisher">TBD</param>
/// <returns>TBD</returns>
public static IPublisher <T> ToTyped <T>(IUntypedPublisher untypedPublisher)
{
return((IPublisher <T>)ToTyped(untypedPublisher));
}
