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