public async Task Invoke(DataModel model, PipelineDelegate <DataModel> next) { if (_providers.ContainsKey(model.Guid) && model.RadioModel.Tone) { var token = _providers[model.Guid]; var current = DateTime.UtcNow.TimeOfDay; if ((current - token.TimeStamp) > TimeDifferencePlaying) { _mixer.RemoveMixerInput(token.Provider); var updatedSample = _toneProvider.CreateSampleProvider(); _providers[model.Guid] = new PlayerSampleToken { Provider = updatedSample, TimeStamp = current }; _mixer.AddMixerInput(updatedSample); } } else if (model.RadioModel.Tone) { var sample = _toneProvider.CreateSampleProvider(); var timeStamp = DateTime.UtcNow.TimeOfDay; var token = new PlayerSampleToken { Provider = sample, TimeStamp = timeStamp }; _providers[model.Guid] = token; _mixer.AddMixerInput(token.Provider); } await next.Invoke(model); }
private void Build() { _pipeline = _builder.Use(async(model, next) => { bool isInListeningRange = Math.Abs(model.RadioModel.Frequency - _model.Frequency) < _model.FrequencyListeningRange; bool isInValidRadioRange = _model.MinFrequency <= model.RadioModel.Frequency && model.RadioModel.Frequency <= _model.MaxFrequency; if (isInValidRadioRange && isInListeningRange) { await next.Invoke(model); } }) .Use(async(model, next) => { if (_model.Power == PowerLevel.Low) { var volume = VolumeSamplesHelper.LogVolumeApproximation(LowPowerLevelVolume); VolumeSamplesHelper.SetVolume(model.RawAudioSample, volume); } await next.Invoke(model); }) .Use(async(model, next) => { float deltaAbs = 1 - (float)Math.Abs(model.RadioModel.Frequency - _model.Frequency) / _model.FrequencyListeningRange; float volume = VolumeSamplesHelper.LogVolumeApproximation(deltaAbs); VolumeSamplesHelper.SetVolume(model.RawAudioSample, volume); await next.Invoke(model); }) .UseMiddleware <RemoteToneHandler>() .UseMiddleware <AudioMixerHandler>() .UseMiddleware <NetworkTaskPipelineHandler>() .Build(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpRequestMessage httpRequestMessage)) { throw new PipelineDependencyException <HttpRequestMessage>(this); } HttpClientRequest request = new HttpClientRequest(httpRequestMessage); CancellationTokenSource cts = new CancellationTokenSource(RequestTimeout); var cancellationTokens = context.Get <CancellationToken>(); var token = cancellationTokens.Any() ? CancellationTokenSource.CreateLinkedTokenSource( cancellationTokens.Concat(new[] { cts.Token }).ToArray() ).Token : cts.Token; try { var result = await request.InvokeAsync(token); context.Add(result); await next.Invoke(); } catch (HttpRequestException ex) { throw new PipelineException(this, ex.Message, ex); } catch (Exception ex) { throw new PipelineException(this, ex.Message, ex); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { var concurrentPipelineCount = ConcurrentPipelineCount < 1 ? 1 : ConcurrentPipelineCount; foreach (var requestAndPipeline in _requestAndPipeline) { context.Add(requestAndPipeline.Context); } var remainingItems = _requestAndPipeline .Skip(concurrentPipelineCount) .Select(x => x); var runningTasks = _requestAndPipeline .Take(concurrentPipelineCount) .Select(x => x.InvokeAsync()) .ToList(); while (runningTasks.Any()) { var task = await Task.WhenAny(runningTasks.ToArray()); runningTasks.Remove(task); var nextTask = remainingItems.FirstOrDefault(); if (nextTask != null) { runningTasks.Add(nextTask.InvokeAsync()); remainingItems = remainingItems.Skip(1); } } await next.Invoke(); }
public IPipelineBuilder <T> Use(Func <PipelineDelegate <T>, PipelineDelegate <T> > middleware) { _components.Add(middleware); _builtPipeline = null; return(this); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { var response = await responseMessage.Content.ReadAsStringAsync(); if (string.Compare("Exception:", response.Substring(0, 10), true) == 0) { context.AddNotification(this, response); return; } } else { context.AddNotification(this, $"Unsuccessful Response: {responseMessage.StatusCode}"); } await next.Invoke(); } else { throw new PipelineDependencyException <HttpRequestMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { await next.Invoke(); if (context.GetFirst(out HttpResponseMessage httpResponseMessage)) { var code = (int)httpResponseMessage.StatusCode; if ((Sanitize500s && Between(code, 500, 599)) || (Sanitize400s && Between(code, 400, 499)) || (Sanitize300s && Between(code, 300, 399)) || SanitizeResponseCodes.Contains(code)) { if (SaveOriginalContent) { var originalResponse = new ResponseSanitizerContent(); originalResponse.Copy(httpResponseMessage); context.Add(originalResponse); } HttpResponseBuilder.HttpResponseMessage(httpResponseMessage) .WithNoContent() .WithReasonPhrase(string.Empty) .If(ReturnErrorReference, resp => resp.WithStringContent($"{{\"errorReference\":\"{context.Id}\"}}")) .If(ReplacementResponseCode.HasValue, resp => resp.WithStatusCode(ReplacementResponseCode.Value)); } } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { context.Remove(CircuitBreakerEnum.OpenState); CircuitState.State currentState = CircuitState.State.Closed; _circuitState.Invoke(x => currentState = x.GetState()); var activeStates = new[] { CircuitState.State.Closed, CircuitState.State.Half_Open }; if (activeStates.Any(x => x == currentState)) { await next.Invoke(); if (!context.GetFirst(out HttpResponseMessage httpResponseMessage)) { throw new PipelineDependencyException <HttpResponseMessage>(this); } _circuitState.Invoke(x => x.Update(!httpResponseMessage.IsTransientFailure())); } else { context.Add(CircuitBreakerEnum.OpenState); } }
public async Task <PipelineContext> InvokeAsync(PipelineContext context, Action <PipelineContext> invokeAction = null) { int index = 0; var ctx = context ?? new PipelineContext(); PipelineDelegate pipelineDelegate = null; pipelineDelegate = async() => { var nextHandler = _pipelineHandlers.Skip(index).FirstOrDefault(); index += 1; if (nextHandler != null) { await nextHandler.InvokeAsync(ctx, pipelineDelegate); } }; try { invokeAction?.Invoke(ctx); await pipelineDelegate.Invoke(); } catch (Exception ex) { var handler = _pipelineHandlers.Skip(index - 1).FirstOrDefault(); ctx .AddNotification(handler, $"Unhandled Exception: {ex.Message}") .AddNotification(handler, ex.ToString()); } return(ctx); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (_queryParameters.Any()) { if (!context.GetFirst(out Uri uri)) { throw new PipelineDependencyException <Uri>(this); } var keyValuePairs = NameValueToKeyValuePairs(HttpUtility.ParseQueryString(uri.Query)); foreach (var queryParameter in _queryParameters) { if (context.Get(queryParameter.ContextVariableName, out string contextParameterValue) && !string.IsNullOrEmpty(contextParameterValue)) { keyValuePairs.Add(new KeyValuePair <string, string>(queryParameter.ContextVariableName, contextParameterValue)); } else if (!queryParameter.Optional) { context.AddNotification(this, $"Context variable '{queryParameter.ContextVariableName}' was not found or does not contain a value and is not optional"); return; } } var ub = new UriBuilder(uri); QueryBuilder qb = new QueryBuilder(keyValuePairs); ub.Query = qb.ToString(); context.AddOrReplace(ub.Uri); await next.Invoke(); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpRequestMessage httpRequestMessage)) { //var match = MethodsAndRoutes.FirstOrDefault(x => ) } await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { await next.Invoke(); if (BeforeAdditionalBranchAction?.Invoke(context) ?? true) { await AdditionalBranch?.InvokeAsync(context); } }
public async Task Invoke(DataModel model, PipelineDelegate <DataModel> next) { if (model.NetworkTask != null && Math.Abs(model.NetworkTask.Frequency - model.RadioModel.Frequency) < 0.001) { OnDataAvailable?.Invoke(this, new DataEventArgs <NetworkTaskData>(model.NetworkTask)); } await next.Invoke(model); }
public PipelineDelegate <TContext> Build() { PipelineDelegate <TContext> app = context => Task.CompletedTask; foreach (var component in _components.Reverse()) { app = component(app); } return(app); }
private async Task Handle(MessagingEnvelope <TMessage> message, string topicName, PipelineDelegate <MessagingContext> pipeline, CancellationToken cancellationToken) { using var scope = _serviceProvider.CreateScope(); var context = new MessagingContext(message, topicName, scope.ServiceProvider); _messagingContextAccessor.MessagingContext = context; await pipeline(context, cancellationToken); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { try { BeforeNextInvokeAction?.Invoke(context); await next.Invoke(); } finally { AfterNextInvokeAction?.Invoke(context); } }
public async Task Invoke(DataModel model, PipelineDelegate <DataModel> next) { var buffer = _buffers.GetOrAdd(model.Guid, (guid) => { var dictionaryBuffer = new BufferedWaveProvider(_format); _mixer.AddMixerInput(dictionaryBuffer); return(dictionaryBuffer); }); buffer.AddSamples(model.RawAudioSample, 0, model.RawAudioSample.Length); await next.Invoke(model); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { bool useAlternateBranch = UseAlternateBranchAction?.Invoke(context) ?? false; if (useAlternateBranch) { await AlternateBranch.InvokeAsync(context); } else { await next.Invoke(); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpContext httpContext)) { throw new PipelineDependencyException <HttpContext>(this); } PipelineConverters.Convert(httpContext.Request, out HttpRequestMessage httpRequestMessage, HeadersToRemove); context .Add(httpRequestMessage) .Add(httpContext.RequestAborted); await next.Invoke(); }
public static void Run <TContext>(this IApplicationBuilder <TContext> app, PipelineDelegate <TContext> handler) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (handler == null) { throw new ArgumentNullException(nameof(handler)); } app.Use(_ => handler); }
public virtual PipelineDelegate <T> Build() { PipelineDelegate <T> currentDelegate = delegate { return(TaskEx.FromResult(0)); }; foreach (var action in _actions) { var prevDelegate = currentDelegate; currentDelegate = async context => { await action(context, prevDelegate); }; } return(currentDelegate); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpContext httpContext)) { throw new PipelineDependencyException <HttpContext>(this); } var(result, versionNo) = GetVersionHeader(httpContext.Request.Headers); if (result) { context.Add(versionNo); } await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { var stopWatch = new System.Diagnostics.Stopwatch(); try { stopWatch.Start(); await next.Invoke(); } finally { context.Add(stopWatch.Elapsed); stopWatch.Stop(); } }
public async Task <HostedSubscription> SubscribeAsync(PipelineDelegate <MessagingContext> pipeline, MessagingSubscriberOptions options = null, CancellationToken cancellationToken = default) { var topicName = _topicRegistry.GetTopicForName(options?.TopicName, false) ?? _topicRegistry.GetTopicForMessageType(typeof(TMessage), false); Task HandleMsg(MessagingEnvelope <TMessage> msg) => _executionMonitor.Handle(() => Handle(msg, topicName, pipeline, cancellationToken)); _logger.LogInformation("Messaging subscriber for topic {TopicName} is starting", topicName); var subscription = await _messageBus.SubscribeAsync <TMessage>(HandleMsg, options, cancellationToken); return(new HostedSubscription(subscription, topicName, _logger)); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (!context.GetFirst(out HttpRequestMessage httpRequestMessage)) { throw new PipelineDependencyException <HttpRequestMessage>(this); } var parameters = HttpUtility.ParseQueryString(httpRequestMessage.RequestUri.Query); var paramNameAndValue = parameters.Cast <string>() .Where(key => string.Compare(key, ParamName, true) == 0) .Select(key => new { key, value = parameters[key] }) .FirstOrDefault(); var matched = false; switch (ParamEvaluation) { case ParamEvaluationEnum.ParamExists: matched = paramNameAndValue != null; break; case ParamEvaluationEnum.ParamDoesNotExist: matched = paramNameAndValue == null; break; case ParamEvaluationEnum.ParamValueMatches: matched = string.Compare(paramNameAndValue?.value, ParamValue, true) == 0; break; case ParamEvaluationEnum.ParamValueDoesNotMatch: matched = (paramNameAndValue != null) && string.Compare(paramNameAndValue?.value, ParamValue, true) != 0; break; } if (matched) { UriBuilder builder = new UriBuilder(RedirectUrl) { Query = httpRequestMessage.RequestUri.Query }; var redirectedUri = builder.Uri; context.Add(new Redirected(httpRequestMessage, redirectedUri)); httpRequestMessage.RequestUri = redirectedUri; } await next.Invoke(); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { await next.Invoke(); if (!context.GetFirst(out HttpContext httpContext)) { throw new PipelineDependencyException <HttpContext>(this); } if (!context.GetFirst(out HttpResponseMessage httpResponseMessage)) { throw new PipelineDependencyException <HttpResponseMessage>(this); } await PipelineConverters.Convert(httpResponseMessage, httpContext.Response, HeadersToRemove); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { var response = await responseMessage.Content.ReadAsStringAsync(); context.Add("response", response); } } else { throw new PipelineDependencyException <HttpResponseMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { PipelineContext parallelContext = new PipelineContext(); Task parallelTask = new Task(async() => await ParallelPipelineRequest.InvokeAsync(parallelContext)); parallelTask.Start(); context.Add(new ParallelPipelineInfo() { Context = parallelContext, ParallelTask = parallelTask }); await Task.WhenAll(new Task[] { next.Invoke(), parallelTask }); }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpResponseMessage responseMessage)) { if (responseMessage.IsSuccessStatusCode) { //var response = await responseMessage.Content.ReadAsStringAsync(); XmlSerializer serializer = new XmlSerializer(typeof(LuasLines)); var response = serializer.Deserialize(await responseMessage.Content.ReadAsStreamAsync()); context.Add("response", (LuasLines)response); } } else { throw new PipelineDependencyException <HttpResponseMessage>(this); } }
public async Task InvokeAsync(PipelineContext context, PipelineDelegate next) { if (context.GetFirst(out HttpRequestMessage httpRequestMessage)) { UriBuilder builder = new UriBuilder(httpRequestMessage.RequestUri) { Host = RedirectHost, Port = RedirectPort }; var redirectUri = builder.Uri; context.Add(new Redirected(httpRequestMessage, builder.Uri)); httpRequestMessage.RequestUri = redirectUri; await next.Invoke(); } else throw new PipelineDependencyException<HttpRequestMessage>(this); }