mirror of https://github.com/Squidex/squidex.git
Sebastian Stehle
3 weeks ago
30 changed files with 1072 additions and 564 deletions
@ -0,0 +1,33 @@ |
|||||
|
// ==========================================================================
|
||||
|
// Squidex Headless CMS
|
||||
|
// ==========================================================================
|
||||
|
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
||||
|
// All rights reserved. Licensed under the MIT license.
|
||||
|
// ==========================================================================
|
||||
|
|
||||
|
using Squidex.Domain.Apps.Core.Contents; |
||||
|
using Squidex.Infrastructure.Json.Objects; |
||||
|
|
||||
|
namespace Squidex.Domain.Apps.Core.Scripting; |
||||
|
|
||||
|
public interface IAsyncScript : IDisposable |
||||
|
{ |
||||
|
ValueTask<ContentData> TransformAsync(DataScriptVars vars, |
||||
|
CancellationToken ct = default); |
||||
|
|
||||
|
ValueTask<JsonValue> ExecuteAsync(ScriptVars vars, |
||||
|
CancellationToken ct = default); |
||||
|
|
||||
|
async ValueTask<bool> EvaluateAsync(ScriptVars vars, |
||||
|
CancellationToken ct = default) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
return (await ExecuteAsync(vars, ct)).Equals(true); |
||||
|
} |
||||
|
catch |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,30 @@ |
|||||
|
// ==========================================================================
|
||||
|
// Squidex Headless CMS
|
||||
|
// ==========================================================================
|
||||
|
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
||||
|
// All rights reserved. Licensed under the MIT license.
|
||||
|
// ==========================================================================
|
||||
|
|
||||
|
using Squidex.Domain.Apps.Core.Contents; |
||||
|
using Squidex.Infrastructure.Json.Objects; |
||||
|
|
||||
|
namespace Squidex.Domain.Apps.Core.Scripting; |
||||
|
|
||||
|
public interface IScript : IDisposable |
||||
|
{ |
||||
|
ContentData Transform(DataScriptVars vars); |
||||
|
|
||||
|
JsonValue Execute(ScriptVars vars); |
||||
|
|
||||
|
bool Evaluate(ScriptVars vars) |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
return Execute(vars).Equals(true); |
||||
|
} |
||||
|
catch |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,171 @@ |
|||||
|
// ==========================================================================
|
||||
|
// Squidex Headless CMS
|
||||
|
// ==========================================================================
|
||||
|
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
||||
|
// All rights reserved. Licensed under the MIT license.
|
||||
|
// ==========================================================================
|
||||
|
|
||||
|
using Jint; |
||||
|
using Squidex.Infrastructure.Tasks; |
||||
|
|
||||
|
namespace Squidex.Domain.Apps.Core.Scripting.Internal; |
||||
|
|
||||
|
internal sealed class AsyncScriptExecutionContext<T> : ScriptExecutionContext |
||||
|
{ |
||||
|
private readonly TaskCompletionSource<CompletedValue?> tcs = new TaskCompletionSource<CompletedValue?>(TaskCreationOptions.RunContinuationsAsynchronously); |
||||
|
private readonly CancellationTokenRegistration cancellationRegistration; |
||||
|
private readonly CancellationToken cancellationToken; |
||||
|
private readonly JintScript script; |
||||
|
private readonly Engine engine; |
||||
|
private int pendingTasks = 1; |
||||
|
|
||||
|
private sealed class CompletedValue |
||||
|
{ |
||||
|
public T Value { get; init; } |
||||
|
} |
||||
|
|
||||
|
public bool IsCompleted |
||||
|
{ |
||||
|
get => tcs.Task.IsCompleted; |
||||
|
} |
||||
|
|
||||
|
internal AsyncScriptExecutionContext(Engine engine, JintScript script, CancellationToken ct) |
||||
|
: base(engine) |
||||
|
{ |
||||
|
this.engine = engine; |
||||
|
|
||||
|
// The lock belongs to the script, because the engine is shared between all executions.
|
||||
|
this.script = script; |
||||
|
|
||||
|
cancellationToken = ct; |
||||
|
|
||||
|
// Settle the source on cancellation, so that pending callbacks do not enter the engine anymore.
|
||||
|
cancellationRegistration = cancellationToken.Register(static state => |
||||
|
{ |
||||
|
var self = (AsyncScriptExecutionContext<T>)state!; |
||||
|
|
||||
|
self.tcs.TrySetCanceled(self.cancellationToken); |
||||
|
}, |
||||
|
this); |
||||
|
} |
||||
|
|
||||
|
public async Task<T> WaitForCompletionAsync(Func<T> fallback) |
||||
|
{ |
||||
|
TryComplete(); |
||||
|
try |
||||
|
{ |
||||
|
var result = await tcs.Task; |
||||
|
if (result != null) |
||||
|
{ |
||||
|
return result.Value; |
||||
|
} |
||||
|
|
||||
|
return await script.RunLockedAsync(() => fallback(), cancellationToken); |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
await cancellationRegistration.DisposeAsync(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void Complete(T value) |
||||
|
{ |
||||
|
tcs.TrySetResult(new CompletedValue { Value = value }); |
||||
|
} |
||||
|
|
||||
|
public override void Fail(Exception exception) |
||||
|
{ |
||||
|
TryFail(exception); |
||||
|
} |
||||
|
|
||||
|
public override void Schedule(Func<CancellationToken, Task> action) |
||||
|
{ |
||||
|
ScheduleCoreAsync(async ct => |
||||
|
{ |
||||
|
await action(ct); |
||||
|
return true; |
||||
|
}, |
||||
|
null); |
||||
|
} |
||||
|
|
||||
|
public override void Schedule<TResult>(Func<CancellationToken, Task<TResult>> action, Action<TResult>? callback) |
||||
|
{ |
||||
|
ScheduleCoreAsync(async ct => |
||||
|
{ |
||||
|
var result = await action(ct); |
||||
|
return result; |
||||
|
}, |
||||
|
callback); |
||||
|
} |
||||
|
|
||||
|
private void ScheduleCoreAsync<TResult>(Func<CancellationToken, Task<TResult>> action, Action<TResult>? callback) |
||||
|
{ |
||||
|
if (IsCompleted) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
async Task ScheduleAsync() |
||||
|
{ |
||||
|
TryStart(); |
||||
|
try |
||||
|
{ |
||||
|
// The action must not touch the engine, so that parallel tasks do not block each other.
|
||||
|
var result = await action(cancellationToken); |
||||
|
|
||||
|
// The callback converts javascript values and is therefore the only part that needs the lock.
|
||||
|
await RunLockedAsync(() => callback?.Invoke(result)); |
||||
|
|
||||
|
TryComplete(); |
||||
|
} |
||||
|
catch (Exception ex) |
||||
|
{ |
||||
|
TryFail(ex); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
ScheduleAsync().Forget(); |
||||
|
} |
||||
|
|
||||
|
private Task<bool> RunLockedAsync(Action action) |
||||
|
{ |
||||
|
// The lock is owned by the script, because the engine is shared between all executions.
|
||||
|
return script.RunLockedAsync(() => |
||||
|
{ |
||||
|
// Late callbacks must not touch the engine anymore, the next execution might have started.
|
||||
|
if (IsCompleted) |
||||
|
{ |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
// The task can take a while, therefore the action gets a fresh timeout.
|
||||
|
engine.Constraints.Reset(); |
||||
|
|
||||
|
action(); |
||||
|
|
||||
|
// The evaluation does not wait for the promises anymore, therefore the continuations that
|
||||
|
// the callback has unblocked have to be executed here, while the lock is still held.
|
||||
|
engine.Advanced.ProcessTasks(); |
||||
|
return true; |
||||
|
}, |
||||
|
cancellationToken); |
||||
|
} |
||||
|
|
||||
|
private void TryFail(Exception exception) |
||||
|
{ |
||||
|
tcs.TrySetException(exception); |
||||
|
} |
||||
|
|
||||
|
private void TryStart() |
||||
|
{ |
||||
|
Interlocked.Increment(ref pendingTasks); |
||||
|
} |
||||
|
|
||||
|
private void TryComplete(CompletedValue? result = null) |
||||
|
{ |
||||
|
if (Interlocked.Decrement(ref pendingTasks) <= 0) |
||||
|
{ |
||||
|
tcs.TrySetResult(result); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,366 @@ |
|||||
|
// ==========================================================================
|
||||
|
// Squidex Headless CMS
|
||||
|
// ==========================================================================
|
||||
|
// Copyright (c) Squidex UG (haftungsbeschraenkt)
|
||||
|
// All rights reserved. Licensed under the MIT license.
|
||||
|
// ==========================================================================
|
||||
|
|
||||
|
using System.Diagnostics; |
||||
|
using Acornima; |
||||
|
using Acornima.Ast; |
||||
|
using Jint; |
||||
|
using Jint.Constraints; |
||||
|
using Jint.Native; |
||||
|
using Jint.Native.Promise; |
||||
|
using Jint.Runtime; |
||||
|
using Squidex.Domain.Apps.Core.Contents; |
||||
|
using Squidex.Domain.Apps.Core.Scripting.ContentWrapper; |
||||
|
using Squidex.Domain.Apps.Core.Scripting.Internal; |
||||
|
using Squidex.Infrastructure; |
||||
|
using Squidex.Infrastructure.Json.Objects; |
||||
|
using Squidex.Infrastructure.Translations; |
||||
|
using Squidex.Infrastructure.Validation; |
||||
|
|
||||
|
namespace Squidex.Domain.Apps.Core.Scripting; |
||||
|
|
||||
|
internal sealed class JintScript : IScript, IAsyncScript, IDisposable |
||||
|
{ |
||||
|
// The engine is shared between all executions, therefore only one of them can run at a time.
|
||||
|
private readonly SemaphoreSlim executionGate = new SemaphoreSlim(1); |
||||
|
|
||||
|
// The engine is also shared with the callbacks of the scheduled tasks, which run on other threads.
|
||||
|
private readonly SemaphoreSlim engineLock = new SemaphoreSlim(1); |
||||
|
|
||||
|
// Jint only creates the constraint for a token that can actually be cancelled, therefore the engine is
|
||||
|
// built with a placeholder that is never cancelled and repointed for each execution.
|
||||
|
private readonly CancellationTokenSource placeholder = new CancellationTokenSource(); |
||||
|
private readonly CancellationConstraint? cancellation; |
||||
|
private readonly Engine engine; |
||||
|
private readonly Prepared<Script> parsed; |
||||
|
private readonly ScriptOptions scriptOptions; |
||||
|
private readonly JintScriptOptions engineOptions; |
||||
|
private readonly GlobalSnapshot snapshot; |
||||
|
|
||||
|
public JintScript( |
||||
|
Prepared<Script> parsed, |
||||
|
ScriptOptions scriptOptions, |
||||
|
JintScriptOptions engineOptions, |
||||
|
IJintExtension[] extensions, |
||||
|
bool allowAsync) |
||||
|
{ |
||||
|
this.parsed = parsed; |
||||
|
this.scriptOptions = scriptOptions; |
||||
|
this.engineOptions = engineOptions; |
||||
|
|
||||
|
engine = new Engine(options => |
||||
|
{ |
||||
|
options.AddObjectConverter(JintObjectConverter.Instance); |
||||
|
options.AllowOperatorOverloading(); |
||||
|
options.AllowClrWrite(!scriptOptions.Readonly); |
||||
|
options.SetTypeConverter(engine => new CustomClrConverter(engine)); |
||||
|
options.SetReferencesResolver(NullPropagation.Instance); |
||||
|
options.Strict(); |
||||
|
|
||||
|
if (!Debugger.IsAttached) |
||||
|
{ |
||||
|
options.Constraints.PromiseTimeout = engineOptions.TimeoutPromise; |
||||
|
options.TimeoutInterval(engineOptions.TimeoutScript); |
||||
|
options.CancellationToken(placeholder.Token); |
||||
|
} |
||||
|
}); |
||||
|
|
||||
|
cancellation = engine.Constraints.Find<CancellationConstraint>(); |
||||
|
|
||||
|
// The extensions resolve the variables from the context of the current execution, therefore they
|
||||
|
// are registered once, even though the variables are different for each execution.
|
||||
|
foreach (var extension in extensions) |
||||
|
{ |
||||
|
extension.Extend(engine); |
||||
|
} |
||||
|
|
||||
|
if (allowAsync) |
||||
|
{ |
||||
|
foreach (var extension in extensions) |
||||
|
{ |
||||
|
extension.ExtendAsync(engine); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (scriptOptions.CanDisallow) |
||||
|
{ |
||||
|
engine.AddDisallow(); |
||||
|
} |
||||
|
|
||||
|
if (scriptOptions.CanReject) |
||||
|
{ |
||||
|
engine.AddReject(); |
||||
|
} |
||||
|
|
||||
|
// The evaluation does not wait for the promises anymore, therefore an unhandled rejection would be
|
||||
|
// swallowed. The tracker only fires when nothing handles the rejection.
|
||||
|
engine.Advanced.PromiseRejectionTracker += (_, args) => |
||||
|
{ |
||||
|
if (args.Operation == PromiseRejectionOperation.Reject) |
||||
|
{ |
||||
|
ScriptExecutionContext.GetContext(engine).Fail( |
||||
|
new JavaScriptException($"Promise was rejected with value {args.Value}.")); |
||||
|
} |
||||
|
}; |
||||
|
|
||||
|
snapshot = engine.Advanced.CaptureGlobalSnapshot(); |
||||
|
} |
||||
|
|
||||
|
public JsonValue Execute(ScriptVars vars) |
||||
|
{ |
||||
|
Guard.NotNull(vars); |
||||
|
|
||||
|
return Run(vars, (vars, _) => |
||||
|
{ |
||||
|
JsonValue? completed = null; |
||||
|
|
||||
|
engine.SetValue("complete", new Action<JsValue?>(value => |
||||
|
{ |
||||
|
completed ??= JsonMapper.Map(value); |
||||
|
})); |
||||
|
|
||||
|
var result = engine.Evaluate(parsed); |
||||
|
|
||||
|
return completed ?? JsonMapper.Map(result); |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
public ValueTask<JsonValue> ExecuteAsync(ScriptVars vars, |
||||
|
CancellationToken ct = default) |
||||
|
{ |
||||
|
Guard.NotNull(vars); |
||||
|
|
||||
|
return RunAsync<JsonValue, ScriptVars>(vars, async (vars, context, ct) => |
||||
|
{ |
||||
|
engine.SetValue("complete", new Action<JsValue?>(value => |
||||
|
{ |
||||
|
context.Complete(JsonMapper.Map(value)); |
||||
|
})); |
||||
|
|
||||
|
// The evaluation holds the lock, but returns without waiting for the pending promises.
|
||||
|
var result = await RunLockedAsync(() => engine.Evaluate(parsed), ct); |
||||
|
|
||||
|
return await context.WaitForCompletionAsync(() => JsonMapper.Map(result)); |
||||
|
}, ct); |
||||
|
} |
||||
|
|
||||
|
public ContentData Transform(DataScriptVars vars) |
||||
|
{ |
||||
|
Guard.NotNull(vars); |
||||
|
|
||||
|
return Run(vars, (vars, _) => |
||||
|
{ |
||||
|
ContentData? result = null; |
||||
|
|
||||
|
engine.SetValue("complete", new Action<JsValue?>(_ => |
||||
|
{ |
||||
|
result ??= vars.Data; |
||||
|
})); |
||||
|
|
||||
|
engine.SetValue("replace", new Action(() => |
||||
|
{ |
||||
|
if (result == null && TransformData(out var modified)) |
||||
|
{ |
||||
|
result = modified; |
||||
|
} |
||||
|
})); |
||||
|
|
||||
|
engine.Evaluate(parsed); |
||||
|
|
||||
|
return result ?? vars.Data!; |
||||
|
}); |
||||
|
} |
||||
|
|
||||
|
public ValueTask<ContentData> TransformAsync(DataScriptVars vars, |
||||
|
CancellationToken ct = default) |
||||
|
{ |
||||
|
Guard.NotNull(vars); |
||||
|
|
||||
|
return RunAsync<ContentData, DataScriptVars>(vars, async (vars, context, ct) => |
||||
|
{ |
||||
|
var data = vars.Data!; |
||||
|
|
||||
|
engine.SetValue("complete", new Action<JsValue?>(_ => |
||||
|
{ |
||||
|
if (!context.IsCompleted) |
||||
|
{ |
||||
|
context.Complete(data); |
||||
|
} |
||||
|
})); |
||||
|
|
||||
|
engine.SetValue("replace", new Action(() => |
||||
|
{ |
||||
|
if (!context.IsCompleted && TransformData(out var modified)) |
||||
|
{ |
||||
|
context.Complete(modified); |
||||
|
} |
||||
|
})); |
||||
|
|
||||
|
// The evaluation holds the lock, but returns without waiting for the pending promises.
|
||||
|
await RunLockedAsync(() => engine.Evaluate(parsed), ct); |
||||
|
|
||||
|
return await context.WaitForCompletionAsync(() => data); |
||||
|
}, ct); |
||||
|
} |
||||
|
|
||||
|
private T Run<T, TVars>(TVars vars, Func<TVars, ScriptExecutionContext, T> action) where TVars : ScriptVars |
||||
|
{ |
||||
|
executionGate.Wait(); |
||||
|
try |
||||
|
{ |
||||
|
// The extensions resolve the variables over the context, therefore it is also needed here.
|
||||
|
var context = new ScriptExecutionContext(engine); |
||||
|
context.CopyFrom(vars); |
||||
|
|
||||
|
PrepareEngine(vars, default); |
||||
|
return action(vars, context); |
||||
|
} |
||||
|
catch (Exception ex) |
||||
|
{ |
||||
|
throw MapException(ex); |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
executionGate.Release(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private async ValueTask<T> RunAsync<T, TVars>(TVars vars, Func<TVars, AsyncScriptExecutionContext<T>, CancellationToken, ValueTask<T>> action, |
||||
|
CancellationToken ct) where TVars : ScriptVars |
||||
|
{ |
||||
|
using var combined = CancellationTokenSource.CreateLinkedTokenSource(ct); |
||||
|
|
||||
|
// Enforce a timeout after a configured time span.
|
||||
|
combined.CancelAfter(engineOptions.TimeoutExecution); |
||||
|
|
||||
|
await executionGate.WaitAsync(ct); |
||||
|
try |
||||
|
{ |
||||
|
PrepareEngine(vars, combined.Token); |
||||
|
|
||||
|
// The extensions resolve the variables over the context, therefore it is also needed here.
|
||||
|
var context = new AsyncScriptExecutionContext<T>(engine, this, combined.Token); |
||||
|
context.CopyFrom(vars); |
||||
|
|
||||
|
return await action(vars, context, combined.Token); |
||||
|
} |
||||
|
catch (Exception ex) |
||||
|
{ |
||||
|
throw MapException(ex); |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
// Stop pending tasks before the token source is disposed, they must not touch the engine anymore.
|
||||
|
await combined.CancelAsync(); |
||||
|
|
||||
|
// The next execution reuses the engine, therefore we wait until no callback is inside anymore.
|
||||
|
// Callbacks that are still waiting for the lock are rejected, because the token is cancelled by now.
|
||||
|
await engineLock.WaitAsync(default(CancellationToken)); |
||||
|
engineLock.Release(); |
||||
|
|
||||
|
executionGate.Release(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
engine.Dispose(); |
||||
|
engineLock.Dispose(); |
||||
|
executionGate.Dispose(); |
||||
|
placeholder.Dispose(); |
||||
|
} |
||||
|
|
||||
|
internal async Task<T> RunLockedAsync<T>(Func<T> action, CancellationToken ct) |
||||
|
{ |
||||
|
// Only one thread is allowed inside the engine, no matter whether it is an execution or a callback.
|
||||
|
// A callback that is reached synchronously from the engine thread asks for the lock while the
|
||||
|
// evaluation still holds it. That is not a deadlock, because the wait yields instead of blocking and
|
||||
|
// the callback continues on another thread once the evaluation is done. It must not be made
|
||||
|
// reentrant, that would run the promise jobs in the middle of a statement.
|
||||
|
await engineLock.WaitAsync(ct); |
||||
|
try |
||||
|
{ |
||||
|
return action(); |
||||
|
} |
||||
|
finally |
||||
|
{ |
||||
|
engineLock.Release(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private bool TransformData(out ContentData result) |
||||
|
{ |
||||
|
var dataInstance = |
||||
|
scriptOptions.AsContext ? |
||||
|
engine.GetValue("ctx").AsObject().Get("data") : |
||||
|
engine.GetValue("data"); |
||||
|
|
||||
|
if (dataInstance != null && |
||||
|
dataInstance.IsObject() && |
||||
|
dataInstance.AsObject() is ContentDataObject dataObject && |
||||
|
dataObject.TryUpdate(out var modified)) |
||||
|
{ |
||||
|
result = modified; |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
result = null!; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
private void PrepareEngine(ScriptVars vars, CancellationToken ct) |
||||
|
{ |
||||
|
// Removes everything the previous execution has declared, including global const and let.
|
||||
|
engine.Advanced.RestoreGlobalSnapshot(snapshot); |
||||
|
engine.Constraints.Reset(); |
||||
|
|
||||
|
// The engine is created once, therefore the token of the current execution is assigned here.
|
||||
|
// The generic reset above does not clear it, so the callbacks keep the token as well.
|
||||
|
cancellation?.Reset(ct); |
||||
|
|
||||
|
if (scriptOptions.AsContext) |
||||
|
{ |
||||
|
var contextInstance = new WritableContext(engine, vars); |
||||
|
|
||||
|
engine.SetValue("ctx", contextInstance); |
||||
|
engine.SetValue("context", contextInstance); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
foreach (var (key, item) in vars) |
||||
|
{ |
||||
|
engine.SetValue(key, item); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
internal static Exception MapException(Exception inner) |
||||
|
{ |
||||
|
static Exception BuildException(string errorKey, string message, Exception? inner = null) |
||||
|
{ |
||||
|
return new ValidationException(T.Get(errorKey, new { message }), inner); |
||||
|
} |
||||
|
|
||||
|
switch (inner) |
||||
|
{ |
||||
|
case ArgumentException: |
||||
|
return BuildException("common.jsParseError", inner.Message); |
||||
|
case ParseErrorException: |
||||
|
return BuildException("common.jsError", inner.Message); |
||||
|
case ScriptPreparationException: |
||||
|
return BuildException("common.jsError", inner.Message); |
||||
|
case JavaScriptException: |
||||
|
return BuildException("common.jsError", inner.Message); |
||||
|
case JintException: |
||||
|
return BuildException("common.jsError", inner.Message); |
||||
|
case DomainException: |
||||
|
return inner; |
||||
|
default: |
||||
|
return BuildException("common.jsError", inner.GetType().Name, inner); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue