public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { // do not validated against empty string here. if (null == Match) { throw new ArgumentNullException("string match (left)"); } if (null == MatchTo) { throw new ArgumentNullException("string match to(right)"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } return(MatchString(Match, MatchTo, MatchType)); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } var LeftResults = null == Left ? true : await Left.MatchAsync(routingContext, sAddress, Context, Body); // short circut if (!LeftResults) { return(false); } var rightResults = null == Right ? true : await Right.MatchAsync(routingContext, sAddress, Context, Body); // short circut if (!rightResults) { return(false); } return(true); }
protected virtual void OnTelemetryResolve(RoutingContextBase routingContext, double totalms) { mMinClicker.Click(new RouterClickBase() { ClickType = RouterClickBase.Resolve_ClickType, Value = totalms }); }
protected virtual void OnTelemetryExecute(RoutingContextBase routingContext, RoutingResultBase routingResults, double totalms) { mMinClicker.Click(new RouterClickBase() { ClickType = RouterClickBase.Execute_ClickType, Value = totalms }); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } routingContext.SourceBody = NewBody; return(true); }
protected virtual async Task <RoutingContextBase> ResolveAsync(RoutingContextBase re, string sAddress, IDictionary <string, object> Context, Stream Body) { bool bMatched = false; while (0 != Interlocked.CompareExchange(ref Changing, 1, 0)) { locker.SpinOnce(); } try { // can not do matching on empty list if (0 == mMatchList.Count) { throw new InvalidOperationException("Resolver can not work empty matchers!"); } // try to match foreach (var matcher in mMatchList.Values) { bMatched = await matcher.MatchAsync(re, sAddress, Context, Body); if (bMatched) { break; } } } finally { Changing = 0; } if (!bMatched) { return(null); } return((RoutingContextBase)re); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (string.IsNullOrEmpty(ExpectedHostAddress)) { throw new ArgumentNullException("ExpectedHostAddress"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } return(MatchString(sAddress, ExpectedHostAddress, HostAddressMatchType)); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (null == Predicate) { throw new ArgumentNullException("Predicate"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } return(Predicate(KeyName, Context[KeyName])); }
public async virtual Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (null == Next) { // only the last (linked list tail) matcher sets the id. // copy the matcherTreeId to context; routingContext.MatcherTreeId = this.MatcherTreeId; } else { if (null != Next) { return(await Next.MatchAsync(routingContext, sAddress, Context, Body)); } } return(true); }
public override async Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { // validate, null list is bad if (null == this.TargetHostAddressList) { throw new ArgumentNullException("TargetHostAddresses"); } // a list that has a null or empty is also bad var nullAddresses = TargetHostAddressList.Where(s => string.IsNullOrEmpty(s)); if (0 != nullAddresses.Count()) { throw new ArgumentNullException("TargetHostAddresses contains null or empty host addresses"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } if (Clear) { routingContext.TargetHostAddressList.Clear(); } routingContext.TargetHostAddressList.AddRange(TargetHostAddressList); routingContext.RouteExecuteType = this.RoutingType; return(true); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } foreach (var p in mPredicates) { var success = await p.MatchAsync(routingContext, sAddress, Context, Body); if (success) { return(true); } } return(false); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (null == Predicate) { throw new ArgumentNullException("Predicate"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } if (true == await Predicate.MatchAsync(routingContext, sAddress, Context, Body)) { if (null != True) { return(await True.MatchAsync(routingContext, sAddress, Context, Body)); } } else { if (null != False) { return(await False.MatchAsync(routingContext, sAddress, Context, Body)); } } return(true); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (string.IsNullOrEmpty(KeyName)) { throw new ArgumentNullException("KeyName"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } // short circut, if comparison is exact check that the dictionary // contains exact key & we are done. if (MatchType == StringMatchType.Exact) { return(Context.ContainsKey(KeyName)); } foreach (var key in Context.Keys) { if (MatchString(key, KeyName, MatchType)) { return(true); } } return(false); }
public async override Task <bool> MatchAsync(RoutingContextBase routingContext, string sAddress, IDictionary <string, object> Context, Stream Body) { if (null == Predicates) { throw new ArgumentNullException("Predicates"); } var anyNull = Predicates.Where(p => null == p); if (0 != anyNull.Count()) { throw new ArgumentNullException("one or more predicates ids null"); } if (false == await base.MatchAsync(routingContext, sAddress, Context, Body)) { return(false); } foreach (var p in Predicates) { var success = await p.MatchAsync(routingContext, sAddress, Context, Body); if (!success) { return(false); } } return(true); }
protected virtual async Task <RER> ExecuteContextAsync(RoutingContextBase re, ContextExecuteStrategyBase chs) { RER rer = null; Stopwatch sw = new Stopwatch(); var currentChs = chs; ContextExecuteModeBase ExecuteMode = new DoNotRetryMode(); var TryCount = 1; var bSucess = false; while (true) { try { sw.Start(); rer = (RER)await re.ExecuteAsync(ExecuteMode); sw.Stop(); bSucess = true; } catch (Exception e) { if (null == currentChs) { throw; } TryCount++; // circut breaker if (TryCount > mMaxRetryCount) { throw new RouterMaxedRetryException(new AggregateException(e)) { RetryCount = (TryCount - 1), RoutingContext = re } } ; try { // execute current strategy; ExecuteMode = await currentChs.ExecuteStrategyAsync(TryCount, re, new AggregateException(e)); } catch (Exception StrategyExecuteFail) { // if we failed to execute strategy we just wrap the exception // along with the orginal execution one. throw new FailedToExecuteStrategyException(StrategyExecuteFail, e) { TryCount = TryCount, RoutingContext = re }; } // move to next strategy currentChs = currentChs.Next; if (!ExecuteMode.ShouldRouterTryAgain) { throw new AggregateException(e); } } finally { OnTelemetryExecute(re, rer, sw.Elapsed.TotalMilliseconds); Trace.WriteLine(string.Format("Execute in {0} Call Count {1} Routing Type:{2}", sw.Elapsed.TotalMilliseconds, TryCount, re.RouteExecuteType), "Verbose"); sw.Reset(); // reset the clock } if (bSucess) { break; // exit the loop } } return(rer); }
public override async Task <ContextExecuteModeBase> ExecuteStrategyAsync(int CallCount, RoutingContextBase re, AggregateException ae) { await Task.Delay(mDelayMs); return(new RetryMode()); }
public override Task <ContextExecuteModeBase> ExecuteStrategyAsync(int CallCount, RoutingContextBase re, AggregateException ae) { var exps = (null == Exceptions) ? new List <Exception>() : Exceptions; if (0 == exps.Count()) { return(Task.FromResult((ContextExecuteModeBase) new DoNotRetryMode())); } var aex = ae.Flatten(); if (exps.Contains(aex.InnerException)) { return(Task.FromResult((ContextExecuteModeBase) new RetryMode())); } return(Task.FromResult((ContextExecuteModeBase) new DoNotRetryMode())); }
public abstract Task <ContextExecuteModeBase> ExecuteStrategyAsync(int CallCount, RoutingContextBase re, AggregateException ae);