public void Configure(IApplicationBuilder app, IHostingEnvironment env) { app.UseDeveloperExceptionPage(); app.UseMetadata(new MetadataOptions { BeforeInvoke = BeforeInvoke.LocalOnly, Path = "_meta", IndentJson = env.IsDevelopment(), IncludeNullProperties = true, Name = "SimpleSoft Middleware ExampleApi", Environment = env.EnvironmentName }); app.UseHealthCheck(new HealthCheckOptions { BeforeInvoke = BeforeInvoke.IsLocalOrHasAnyRole("admin"), Path = "_health", IndentJson = env.IsDevelopment(), StringEnum = true, ParallelExecution = true }); app.Run(async context => { await context.Response.WriteAsync(IndexHtml); }); }
private void OnTriggerExecute(TriggerBase trigger) { if (Action is null) { return; } lock (_localSync) { _tokenSource = new CancellationTokenSource(); var token = _tokenSource.Token; _triggerTask = Task.Run(() => { if (Core.Now - _lastUpdateTime > WaitTime) { _lastUpdateTime = Core.Now; BeforeInvoke?.Invoke(this, new TriggeredEventArgs <Action>(trigger, Action)); var loadOk = true; var sw = Stopwatch.StartNew(); try { if (CancellationToken.IsCancellationRequested) { return; } Action(); if (CancellationToken.IsCancellationRequested) { return; } sw.Stop(); } catch (Exception ex) { sw.Stop(); loadOk = false; OnException?.Invoke(this, new ExceptionEventArgs(ex, sw.Elapsed.TotalMilliseconds)); } if (loadOk) { AfterInvoke?.Invoke(this, new TriggeredEventArgs <Action>(trigger, Action, sw.Elapsed.TotalMilliseconds)); } } else { NotInvokedTooRecent?.Invoke(this, new TriggeredEventArgs <Action>(trigger, Action)); } }, token); try { _triggerTask.Wait(token); } catch { // ignored } _triggerTask = null; _tokenSource = null; } }
/// <summary> /// Fires the BeforeInvoke event. /// </summary> /// <param name="e">Event arguments.</param> protected internal virtual void OnBeforeInvoke(BeforeInvokeEventArgs e) { BeforeInvoke?.Invoke(this, e); }
protected override object Invoke(MethodInfo targetMethod, object[] args) { Log.Debug("[MethodProxy.Invoke] " + (new MethodCallInfo() { Name = targetMethod.Name, Args = args.ToList() }).ToString()); bool IsIInvokeProxy = _invokeType == InvokeType.Proxy || _invokeType == InvokeType.ProxyFunc; IInvokerProxy invoker; switch (_invokeType) { case InvokeType.Proxy: invoker = _invokerProxy; break; case InvokeType.ProxyFunc: invoker = GetIInvokerProxyFunc(); break; default: invoker = null; break; } if (IsIInvokeProxy || BeforeInvoke != null) { BeforeInvokeEventArgs beforeArgs = new BeforeInvokeEventArgs() { MethodInfo = targetMethod, Args = args, }; BeforeInvoke?.Invoke(this, beforeArgs); invoker?.BeforeInvoke(this, beforeArgs); if (beforeArgs.Handled) { return(beforeArgs.FakeResult); } } object result; if (IsIInvokeProxy) { result = invoker.Invoke(targetMethod, args); } else if (_invokeType == InvokeType.Object) { result = targetMethod.Invoke(_invokeObject, args); } else { throw new Exception("InvokeProxy: unknown InvokeType"); } if (result is Task task) { if (targetMethod.ReturnType.IsGenericType) { Type type = targetMethod.ReturnType.GetGenericArguments()[0]; if (TypeHelper.IsType(task, typeof(Task <object>))) { result = TaskHelper.ConvertTaskObject((Task <object>)task, type); } else { // e.g. UnwrapPromise<object> var generic_task = TaskHelper.ConvertTaskReturnObject(task); result = TaskHelper.ConvertTaskObject(generic_task, type); } } else { Task.Run(async() => await task); result = Task.CompletedTask; } } TypeHelper.AssertType(result, targetMethod.ReturnType); if (IsIInvokeProxy || AfterInvoke != null) { AfterInvokeEventArgs afterArgs = new AfterInvokeEventArgs() { MethodInfo = targetMethod, Args = args, Result = result, }; AfterInvoke?.Invoke(this, afterArgs); invoker?.AfterInvoke(this, afterArgs); } return(result); }