Initial commit
This commit is contained in:
rudder
@@ -0,0 +1,42 @@
|
||||
using System.Collections.Generic;
|
||||
using RudderSdk.Core.Models;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Snapshot of one running scenario plan.</summary>
|
||||
public sealed class PlanRun
|
||||
{
|
||||
internal PlanRun(
|
||||
string runId,
|
||||
string planId,
|
||||
string scenarioId,
|
||||
string userId,
|
||||
IReadOnlyList<string> activeNodeIds,
|
||||
ExecutionPlan plan)
|
||||
{
|
||||
RunId = runId;
|
||||
PlanId = planId;
|
||||
ScenarioId = scenarioId;
|
||||
UserId = userId;
|
||||
ActiveNodeIds = activeNodeIds;
|
||||
Plan = plan;
|
||||
}
|
||||
|
||||
/// <summary>Server-issued run id.</summary>
|
||||
public string RunId { get; }
|
||||
|
||||
/// <summary>Plan id.</summary>
|
||||
public string PlanId { get; }
|
||||
|
||||
/// <summary>Scenario id.</summary>
|
||||
public string ScenarioId { get; }
|
||||
|
||||
/// <summary>Player the run belongs to.</summary>
|
||||
public string UserId { get; }
|
||||
|
||||
/// <summary>Ids of the currently active nodes.</summary>
|
||||
public IReadOnlyList<string> ActiveNodeIds { get; }
|
||||
|
||||
/// <summary>The execution plan being run.</summary>
|
||||
public ExecutionPlan Plan { get; }
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
using System;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Payload of <see cref="ScenarioService.OnScenarioFailed"/>.</summary>
|
||||
public sealed class ScenarioFailedEvent
|
||||
{
|
||||
internal ScenarioFailedEvent(PlanRun run, string nodeId, Exception exception)
|
||||
{
|
||||
Run = run;
|
||||
NodeId = nodeId;
|
||||
Exception = exception;
|
||||
}
|
||||
|
||||
/// <summary>The failed run.</summary>
|
||||
public PlanRun Run { get; }
|
||||
|
||||
/// <summary>Node the failure happened at.</summary>
|
||||
public string NodeId { get; }
|
||||
|
||||
/// <summary>The error that failed the run.</summary>
|
||||
public Exception Exception { get; }
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using Newtonsoft.Json.Linq;
|
||||
using RudderSdk.Core.Models;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Context of the scenario node a session was created for.</summary>
|
||||
public class ScenarioNodeContext
|
||||
{
|
||||
private readonly ScenarioService _service;
|
||||
|
||||
internal ScenarioNodeContext(ScenarioService service, PlanRun run, ExecutionPlanNode node)
|
||||
{
|
||||
_service = service;
|
||||
Run = run;
|
||||
Node = node;
|
||||
Data = node?.Data as JObject ?? new JObject();
|
||||
}
|
||||
|
||||
/// <summary>The run this node belongs to.</summary>
|
||||
public PlanRun Run { get; }
|
||||
|
||||
/// <summary>The plan node.</summary>
|
||||
public ExecutionPlanNode Node { get; }
|
||||
|
||||
/// <summary>Run id.</summary>
|
||||
public string RunId => Run.RunId;
|
||||
|
||||
/// <summary>Plan id.</summary>
|
||||
public string PlanId => Run.PlanId;
|
||||
|
||||
/// <summary>Scenario id.</summary>
|
||||
public string ScenarioId => Run.ScenarioId;
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string NodeId => Node.Id;
|
||||
|
||||
/// <summary>Node type.</summary>
|
||||
public string Type => Node.Type;
|
||||
|
||||
/// <summary>Node data payload.</summary>
|
||||
public JObject Data { get; }
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!)
|
||||
{
|
||||
if (Data == null || !Data.TryGetValue(key, out var value))
|
||||
return defaultValue;
|
||||
try { return value.ToObject<T>() ?? defaultValue; }
|
||||
catch { return defaultValue; }
|
||||
}
|
||||
|
||||
/// <summary>Deserializes the whole node data payload.</summary>
|
||||
public T Get<T>()
|
||||
{
|
||||
try { return Data == null ? default! : Data.ToObject<T>() ?? default!; }
|
||||
catch { return default!; }
|
||||
}
|
||||
|
||||
/// <summary>Returns the node data as a plain dictionary.</summary>
|
||||
public Dictionary<string, object> AsObjectDictionary()
|
||||
{
|
||||
return Data?.ToObject<Dictionary<string, object>>() ?? new Dictionary<string, object>();
|
||||
}
|
||||
|
||||
internal Task CompleteAsync(string handle, CancellationToken cancellationToken = default)
|
||||
=> _service.CompleteNodeAsync(RunId, NodeId, handle, cancellationToken);
|
||||
|
||||
internal void Complete(string handle)
|
||||
{
|
||||
_ = CompleteAsync(handle);
|
||||
}
|
||||
|
||||
internal Task AddProgressAsync(string counterKey, long amount, CancellationToken cancellationToken = default)
|
||||
=> _service.UpdateProgressAsync(RunId, NodeId, counterKey, amount, cancellationToken);
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
using System;
|
||||
using System.Globalization;
|
||||
using System.Linq;
|
||||
using Newtonsoft.Json;
|
||||
using Newtonsoft.Json.Linq;
|
||||
using RudderSdk.Core.Abstractions;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
public sealed partial class ScenarioService
|
||||
{
|
||||
private void DispatchActiveNode(RuntimeRun run, ActiveNodeState state, bool restored)
|
||||
{
|
||||
var node = FindNode(run.Plan, state.NodeId);
|
||||
if (node == null)
|
||||
{
|
||||
run.ActiveNodes.Remove(state.NodeId);
|
||||
CheckRunCompleted(run);
|
||||
return;
|
||||
}
|
||||
|
||||
var context = new ScenarioNodeContext(this, ToPlanRun(run), node);
|
||||
switch (node.Type ?? string.Empty)
|
||||
{
|
||||
case WaitNode:
|
||||
DispatchWait(run, state, context);
|
||||
break;
|
||||
case RemoteConfigOverrideNode:
|
||||
DispatchRemoteConfigOverride(run, state, context);
|
||||
break;
|
||||
case NotificationNode:
|
||||
EmitNotification(context);
|
||||
break;
|
||||
case StoreNode:
|
||||
EmitStoreOffer(context);
|
||||
break;
|
||||
case QuestNode:
|
||||
EmitQuest(context);
|
||||
break;
|
||||
case LeaderboardNode:
|
||||
EmitLeaderboard(context);
|
||||
break;
|
||||
case BattlePassNode:
|
||||
EmitBattlePass(context);
|
||||
break;
|
||||
case BattlePassLevelNode:
|
||||
EmitBattlePassLevel(context);
|
||||
break;
|
||||
default:
|
||||
_client.Options.Logger?.Log(RudderLogLevel.Warning, $"[Rudder] Unsupported scenario node type '{node.Type}' ({node.Id}).");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private void DispatchWait(RuntimeRun run, ActiveNodeState state, ScenarioNodeContext context)
|
||||
{
|
||||
if (!state.WaitDeadlineUtc.HasValue)
|
||||
{
|
||||
// Prefer server-provided WaitDeadline from the plan boundary over local calculation.
|
||||
// The server stamps WaitDeadline on server-enforced wait boundaries (see StampBoundaries).
|
||||
var boundary = run.Plan.BoundaryNodes?.FirstOrDefault(
|
||||
b => b.SourceNodeId == state.NodeId && !string.IsNullOrEmpty(b.WaitDeadline)
|
||||
);
|
||||
if (boundary != null && DateTimeOffset.TryParse(boundary.WaitDeadline, null, DateTimeStyles.RoundtripKind, out var parsed))
|
||||
{
|
||||
state.WaitDeadlineUtc = parsed;
|
||||
}
|
||||
else
|
||||
{
|
||||
var delay = GetWaitDelay(context.Data);
|
||||
state.WaitDeadlineUtc = _client.Clock.UtcNow.Add(delay);
|
||||
}
|
||||
Persist();
|
||||
}
|
||||
|
||||
var session = new WaitSession(context, state.WaitDeadlineUtc.Value);
|
||||
OnWait?.Invoke(session);
|
||||
|
||||
if (_client.Clock.UtcNow >= state.WaitDeadlineUtc.Value)
|
||||
_ = CompleteNodeAsync(run.RunId, state.NodeId, "onComplete");
|
||||
}
|
||||
|
||||
private void DispatchRemoteConfigOverride(RuntimeRun run, ActiveNodeState state, ScenarioNodeContext context)
|
||||
{
|
||||
var patches = context.Data["patches"] as JArray;
|
||||
if (patches != null)
|
||||
{
|
||||
foreach (var patchToken in patches.OfType<JObject>())
|
||||
{
|
||||
var key = patchToken.Value<string>("path");
|
||||
if (string.IsNullOrEmpty(key))
|
||||
continue;
|
||||
|
||||
var valueType = patchToken.Value<string>("valueType") ?? "json";
|
||||
var value = SerializeRemoteConfigValue(patchToken["value"], valueType);
|
||||
_client.RemoteConfig.ApplyOverride(key, value, valueType);
|
||||
}
|
||||
}
|
||||
|
||||
var session = new ConfigChangedSession(context);
|
||||
OnConfigChanged?.Invoke(session);
|
||||
_ = CompleteNodeAsync(run.RunId, state.NodeId, "output");
|
||||
}
|
||||
|
||||
private void EmitNotification(ScenarioNodeContext context)
|
||||
{
|
||||
OnNotification?.Invoke(new NotificationSession(context));
|
||||
}
|
||||
|
||||
private void EmitStoreOffer(ScenarioNodeContext context)
|
||||
{
|
||||
OnStoreOffer?.Invoke(new StoreOfferSession(context));
|
||||
}
|
||||
|
||||
private void EmitQuest(ScenarioNodeContext context)
|
||||
{
|
||||
OnQuest?.Invoke(new QuestSession(context));
|
||||
}
|
||||
|
||||
private void EmitLeaderboard(ScenarioNodeContext context)
|
||||
{
|
||||
OnLeaderboard?.Invoke(new LeaderboardSession(context));
|
||||
}
|
||||
|
||||
private void EmitBattlePass(ScenarioNodeContext context)
|
||||
{
|
||||
OnBattlePass?.Invoke(new BattlePassSession(context));
|
||||
}
|
||||
|
||||
private void EmitBattlePassLevel(ScenarioNodeContext context)
|
||||
{
|
||||
OnBattlePassLevel?.Invoke(new BattlePassLevelSession(context));
|
||||
}
|
||||
|
||||
private static TimeSpan GetWaitDelay(JObject data)
|
||||
{
|
||||
var duration = data.Value<double?>("duration") ?? 0;
|
||||
var unit = data.Value<string>("unit") ?? "seconds";
|
||||
if (duration <= 0)
|
||||
return TimeSpan.Zero;
|
||||
|
||||
switch (unit)
|
||||
{
|
||||
case "days":
|
||||
case "day":
|
||||
case "d":
|
||||
return TimeSpan.FromDays(duration);
|
||||
case "hours":
|
||||
case "hour":
|
||||
case "hr":
|
||||
case "h":
|
||||
return TimeSpan.FromHours(duration);
|
||||
case "minutes":
|
||||
case "minute":
|
||||
case "min":
|
||||
case "m":
|
||||
return TimeSpan.FromMinutes(duration);
|
||||
case "seconds":
|
||||
case "second":
|
||||
case "sec":
|
||||
case "s":
|
||||
return TimeSpan.FromSeconds(duration);
|
||||
default:
|
||||
return TimeSpan.FromSeconds(duration);
|
||||
}
|
||||
}
|
||||
|
||||
private static string? SerializeRemoteConfigValue(JToken? token, string valueType)
|
||||
{
|
||||
if (token == null || token.Type == JTokenType.Null)
|
||||
return null;
|
||||
|
||||
switch ((valueType ?? string.Empty).ToLowerInvariant())
|
||||
{
|
||||
case "string":
|
||||
return token.Type == JTokenType.String ? token.Value<string>() : token.ToString(Formatting.None);
|
||||
case "bool":
|
||||
case "boolean":
|
||||
return token.Value<bool>().ToString().ToLowerInvariant();
|
||||
case "int":
|
||||
case "integer":
|
||||
return token.Value<long>().ToString(CultureInfo.InvariantCulture);
|
||||
case "float":
|
||||
case "double":
|
||||
return token.Value<double>().ToString(CultureInfo.InvariantCulture);
|
||||
default:
|
||||
return token.Type == JTokenType.String ? token.Value<string>() : token.ToString(Formatting.None);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
public sealed partial class ScenarioService
|
||||
{
|
||||
private const string NotificationNode = "notification";
|
||||
private const string StoreNode = "store";
|
||||
private const string WaitNode = "wait";
|
||||
private const string RemoteConfigOverrideNode = "remote_config_override";
|
||||
private const string QuestNode = "quest";
|
||||
private const string LeaderboardNode = "leaderboard";
|
||||
private const string BattlePassNode = "battlepass";
|
||||
private const string BattlePassLevelNode = "battlepass_level";
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using Newtonsoft.Json;
|
||||
using RudderSdk.Core.Models;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
public sealed partial class ScenarioService
|
||||
{
|
||||
private void Persist()
|
||||
{
|
||||
var store = _client.Options.PlanStateStore;
|
||||
if (store == null)
|
||||
return;
|
||||
|
||||
if (_runs.Count == 0)
|
||||
{
|
||||
store.State = null;
|
||||
return;
|
||||
}
|
||||
|
||||
var state = new PersistedScenarioState
|
||||
{
|
||||
Runs = _runs.Values.Select(run => run.ToPersisted()).ToList()
|
||||
};
|
||||
store.State = JsonConvert.SerializeObject(state);
|
||||
}
|
||||
|
||||
private sealed class RuntimeRun
|
||||
{
|
||||
public RuntimeRun(string runId, ExecutionPlan plan)
|
||||
{
|
||||
RunId = runId;
|
||||
Plan = plan;
|
||||
}
|
||||
|
||||
public string RunId { get; }
|
||||
public ExecutionPlan Plan { get; }
|
||||
public Dictionary<string, ActiveNodeState> ActiveNodes { get; } = new();
|
||||
public HashSet<string> CompletedHandles { get; } = new(StringComparer.Ordinal);
|
||||
|
||||
public PersistedRun ToPersisted()
|
||||
{
|
||||
return new PersistedRun
|
||||
{
|
||||
RunId = RunId,
|
||||
Plan = Plan,
|
||||
ActiveNodes = ActiveNodes.Values.ToList(),
|
||||
CompletedHandles = CompletedHandles.ToList()
|
||||
};
|
||||
}
|
||||
|
||||
public static RuntimeRun FromPersisted(PersistedRun saved)
|
||||
{
|
||||
var run = new RuntimeRun(saved.RunId, saved.Plan);
|
||||
if (saved.ActiveNodes != null)
|
||||
{
|
||||
foreach (var node in saved.ActiveNodes)
|
||||
{
|
||||
if (!string.IsNullOrEmpty(node?.NodeId))
|
||||
run.ActiveNodes[node.NodeId] = node;
|
||||
}
|
||||
}
|
||||
if (saved.CompletedHandles != null)
|
||||
{
|
||||
foreach (var handle in saved.CompletedHandles)
|
||||
run.CompletedHandles.Add(handle);
|
||||
}
|
||||
return run;
|
||||
}
|
||||
}
|
||||
|
||||
private sealed class PersistedScenarioState
|
||||
{
|
||||
public List<PersistedRun>? Runs { get; set; }
|
||||
}
|
||||
|
||||
private sealed class PersistedRun
|
||||
{
|
||||
public string RunId { get; set; } = string.Empty;
|
||||
public ExecutionPlan Plan { get; set; } = null!;
|
||||
public List<ActiveNodeState>? ActiveNodes { get; set; }
|
||||
public List<string>? CompletedHandles { get; set; }
|
||||
}
|
||||
|
||||
private sealed class ActiveNodeState
|
||||
{
|
||||
public string NodeId { get; set; } = string.Empty;
|
||||
public DateTimeOffset? WaitDeadlineUtc { get; set; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,341 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
using RudderSdk.Core.Abstractions;
|
||||
using RudderSdk.Core.Models;
|
||||
using RudderSdk.Core.Models.Scenarios;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>
|
||||
/// Thrown when a boundary HTTP call fails with a transient error
|
||||
/// (network failure, timeout, or server 5xx). The caller should NOT advance
|
||||
/// the run; the node stays active and the handle stays pending for retry.
|
||||
/// </summary>
|
||||
public sealed class TransientBoundaryException : Exception
|
||||
{
|
||||
/// <summary>Creates the exception.</summary>
|
||||
public TransientBoundaryException(string message, Exception inner)
|
||||
: base(message, inner)
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>Creates the exception wrapping the transport error.</summary>
|
||||
public TransientBoundaryException(Exception inner)
|
||||
: base($"Transient boundary error: {inner.Message}", inner)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
public sealed partial class ScenarioService
|
||||
{
|
||||
/// <summary>
|
||||
/// Returns true for exceptions that may succeed on retry
|
||||
/// (timeout / network failures).
|
||||
/// </summary>
|
||||
private static bool IsTransientException(Exception ex)
|
||||
{
|
||||
return ex is OperationCanceledException || ex is RudderNetworkException;
|
||||
}
|
||||
|
||||
private IReadOnlyList<PlanRun> StartPlans(IEnumerable<ExecutionPlan>? plans)
|
||||
{
|
||||
var started = new List<PlanRun>();
|
||||
if (plans == null)
|
||||
return started;
|
||||
|
||||
foreach (var plan in plans)
|
||||
{
|
||||
var run = StartPlan(plan);
|
||||
if (run != null)
|
||||
started.Add(ToPlanRun(run));
|
||||
}
|
||||
|
||||
return started;
|
||||
}
|
||||
|
||||
private RuntimeRun? StartPlan(ExecutionPlan? plan)
|
||||
{
|
||||
if (plan?.Nodes == null || plan.Nodes.Count == 0)
|
||||
return null;
|
||||
|
||||
// Dedup: server returned same runId — skip without restarting.
|
||||
if (!string.IsNullOrEmpty(plan.RunId) && _runs.ContainsKey(plan.RunId))
|
||||
return null;
|
||||
|
||||
if (plan.BoundaryNodes?.Count > 0 && string.IsNullOrEmpty(plan.RunId))
|
||||
throw new InvalidOperationException("ExecutionPlan has boundaryNodes but missing RunId.");
|
||||
|
||||
var runId = plan.RunId ?? Guid.NewGuid().ToString("N");
|
||||
var startNode = FindNode(plan, plan.StartNodeId) ?? plan.Nodes[0];
|
||||
var run = new RuntimeRun(runId, plan);
|
||||
_runs[run.RunId] = run;
|
||||
ActivateNode(run, startNode.Id);
|
||||
Persist();
|
||||
return run;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Replaces an existing run's plan with a server-provided continuation (same RunId):
|
||||
/// the previous segment is done, the new segment's start node becomes active.
|
||||
/// Idempotent: if the continuation was already applied, nothing is re-dispatched.
|
||||
/// </summary>
|
||||
private void ReplaceRun(ExecutionPlan? plan, string? fallbackRunId = null)
|
||||
{
|
||||
if (plan?.Nodes == null || plan.Nodes.Count == 0)
|
||||
return;
|
||||
|
||||
var runId = plan.RunId ?? fallbackRunId;
|
||||
if (string.IsNullOrEmpty(runId))
|
||||
return;
|
||||
|
||||
var startNode = FindNode(plan, plan.StartNodeId) ?? plan.Nodes[0];
|
||||
if (startNode == null)
|
||||
return;
|
||||
|
||||
if (_runs.TryGetValue(runId, out var existing) && existing.ActiveNodes.ContainsKey(startNode.Id))
|
||||
return; // continuation already applied (idempotent callback echo)
|
||||
|
||||
var run = new RuntimeRun(runId, plan);
|
||||
_runs[runId] = run;
|
||||
ActivateNode(run, startNode.Id);
|
||||
Persist();
|
||||
}
|
||||
|
||||
private void ActivateNode(RuntimeRun run, string nodeId, ActiveNodeState? restoredState = null)
|
||||
{
|
||||
var node = FindNode(run.Plan, nodeId);
|
||||
if (node == null)
|
||||
return;
|
||||
|
||||
var state = restoredState ?? new ActiveNodeState { NodeId = nodeId };
|
||||
run.ActiveNodes[nodeId] = state;
|
||||
DispatchActiveNode(run, state, restored: restoredState != null);
|
||||
}
|
||||
|
||||
internal Task CompleteNodeAsync(
|
||||
string runId,
|
||||
string nodeId,
|
||||
string handle,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
return CompleteNodeAsync(runId, nodeId, handle, continueOnBoundary: true, cancellationToken);
|
||||
}
|
||||
|
||||
private async Task CompleteNodeAsync(
|
||||
string runId,
|
||||
string nodeId,
|
||||
string handle,
|
||||
bool continueOnBoundary,
|
||||
CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (!_runs.TryGetValue(runId, out var run))
|
||||
return;
|
||||
|
||||
var key = CompletedHandleKey(nodeId, handle);
|
||||
if (run.CompletedHandles.Contains(key))
|
||||
return; // idempotent
|
||||
|
||||
try
|
||||
{
|
||||
var continuedOnBoundary = false;
|
||||
if (continueOnBoundary)
|
||||
{
|
||||
try
|
||||
{
|
||||
continuedOnBoundary = await ContinueBoundaryAsync(
|
||||
run, nodeId, handle, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
catch (TransientBoundaryException)
|
||||
{
|
||||
// Transient error — don't advance the run.
|
||||
// Node stays active, handle stays pending for retry on reconnect.
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (continuedOnBoundary)
|
||||
{
|
||||
// The boundary may have replaced or removed the run (continuation plan
|
||||
// or reconcile). The transferred run owns the state — touching the stale
|
||||
// object here would complete or delete the new run.
|
||||
if (!_runs.TryGetValue(runId, out var currentRun) || !ReferenceEquals(currentRun, run))
|
||||
return;
|
||||
}
|
||||
|
||||
// Only now — after the server has confirmed — mark the handle and node.
|
||||
run.CompletedHandles.Add(key);
|
||||
run.ActiveNodes.Remove(nodeId);
|
||||
Persist();
|
||||
|
||||
if (!continuedOnBoundary)
|
||||
{
|
||||
foreach (var edge in MatchingEdges(run.Plan, nodeId, handle))
|
||||
ActivateNode(run, edge.Target);
|
||||
}
|
||||
|
||||
CheckRunCompleted(run);
|
||||
Persist();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
FailRun(run, nodeId, ex);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<bool> ContinueBoundaryAsync(
|
||||
RuntimeRun run,
|
||||
string nodeId,
|
||||
string handle,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var boundaries = MatchingBoundaryNodes(run.Plan, nodeId, handle).ToList();
|
||||
if (boundaries.Count == 0)
|
||||
return false;
|
||||
|
||||
foreach (var boundary in boundaries)
|
||||
{
|
||||
try
|
||||
{
|
||||
var response = await _client.SendAsync<HandleScenarioCallbackRequest, HandleScenarioCallbackResponse>(
|
||||
"POST",
|
||||
"/sdk/v1/scenarios/callback",
|
||||
new HandleScenarioCallbackRequest
|
||||
{
|
||||
ScenarioId = run.Plan.ScenarioId,
|
||||
NodeId = boundary.SourceNodeId,
|
||||
Handle = boundary.SourceHandle,
|
||||
RunId = run.RunId
|
||||
},
|
||||
cancellationToken).ConfigureAwait(false);
|
||||
|
||||
if (response?.Plan != null)
|
||||
{
|
||||
// Continuation of the current run (server keeps the RunId) replaces
|
||||
// the run's plan; fresh/terminal plans start as new runs.
|
||||
if (_runs.ContainsKey(response.Plan.RunId ?? string.Empty))
|
||||
ReplaceRun(response.Plan);
|
||||
else
|
||||
StartPlan(response.Plan);
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Boundary call failed — try to reconcile with server.
|
||||
var reconciled = false;
|
||||
try
|
||||
{
|
||||
var reconcile = await _client.SendAsync<GetScenarioRunRequest, GetScenarioRunResponse>(
|
||||
"POST",
|
||||
"/sdk/v1/scenarios/run",
|
||||
new GetScenarioRunRequest { RunId = run.RunId },
|
||||
cancellationToken).ConfigureAwait(false);
|
||||
|
||||
if (reconcile?.Status == "unknown_run" || reconcile?.Status == "expired")
|
||||
{
|
||||
_runs.Remove(run.RunId);
|
||||
Persist();
|
||||
reconciled = true;
|
||||
}
|
||||
|
||||
if (reconcile?.Plan != null)
|
||||
{
|
||||
ReplaceRun(reconcile.Plan, run.RunId);
|
||||
reconciled = true;
|
||||
}
|
||||
}
|
||||
catch
|
||||
{
|
||||
// Reconciliation also failed.
|
||||
}
|
||||
|
||||
if (!reconciled)
|
||||
{
|
||||
// Reconcile did not resolve — distinguish transient from terminal.
|
||||
if (IsTransientException(ex))
|
||||
throw new TransientBoundaryException(ex);
|
||||
// Terminal error — let the caller fail the run.
|
||||
throw;
|
||||
}
|
||||
// If reconciled, the boundary was handled (run corrected or removed).
|
||||
// Fall through to continue to the next boundary.
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private void CheckRunCompleted(RuntimeRun run)
|
||||
{
|
||||
if (run.ActiveNodes.Count > 0)
|
||||
return;
|
||||
|
||||
_runs.Remove(run.RunId);
|
||||
Persist();
|
||||
OnScenarioCompleted?.Invoke(ToPlanRun(run));
|
||||
}
|
||||
|
||||
private void FailRun(RuntimeRun run, string nodeId, Exception ex)
|
||||
{
|
||||
_client.Options.Logger?.Log(RudderLogLevel.Error, $"[Rudder] Scenario run {run.RunId} failed at node {nodeId}: {ex.Message}");
|
||||
_runs.Remove(run.RunId);
|
||||
Persist();
|
||||
OnScenarioFailed?.Invoke(new ScenarioFailedEvent(ToPlanRun(run), nodeId, ex));
|
||||
}
|
||||
|
||||
private static PlanRun ToPlanRun(RuntimeRun run)
|
||||
{
|
||||
return new PlanRun(
|
||||
run.RunId,
|
||||
run.Plan.PlanId,
|
||||
run.Plan.ScenarioId,
|
||||
run.Plan.UserId,
|
||||
run.ActiveNodes.Keys.ToList(),
|
||||
run.Plan);
|
||||
}
|
||||
|
||||
private static ExecutionPlanNode? FindNode(ExecutionPlan? plan, string? nodeId)
|
||||
{
|
||||
if (plan?.Nodes == null || plan.Nodes.Count == 0)
|
||||
return null;
|
||||
|
||||
if (!string.IsNullOrEmpty(nodeId))
|
||||
{
|
||||
foreach (var node in plan.Nodes)
|
||||
{
|
||||
if (node.Id == nodeId)
|
||||
return node;
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
private static IEnumerable<PlanEdge> MatchingEdges(ExecutionPlan plan, string sourceNodeId, string sourceHandle)
|
||||
{
|
||||
if (plan?.Edges == null)
|
||||
yield break;
|
||||
|
||||
foreach (var edge in plan.Edges)
|
||||
{
|
||||
if (edge.Source == sourceNodeId && string.Equals(edge.SourceHandle ?? string.Empty, sourceHandle ?? string.Empty, StringComparison.Ordinal))
|
||||
yield return edge;
|
||||
}
|
||||
}
|
||||
|
||||
private static IEnumerable<BoundaryNode> MatchingBoundaryNodes(ExecutionPlan plan, string sourceNodeId, string sourceHandle)
|
||||
{
|
||||
if (plan?.BoundaryNodes == null)
|
||||
yield break;
|
||||
|
||||
foreach (var boundary in plan.BoundaryNodes)
|
||||
{
|
||||
if (boundary.SourceNodeId == sourceNodeId && string.Equals(boundary.SourceHandle ?? string.Empty, sourceHandle ?? string.Empty, StringComparison.Ordinal))
|
||||
yield return boundary;
|
||||
}
|
||||
}
|
||||
|
||||
private static string CompletedHandleKey(string nodeId, string? handle) => nodeId + ":" + (handle ?? string.Empty);
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario battle-pass-level node.</summary>
|
||||
public sealed class BattlePassLevelSession
|
||||
{
|
||||
internal BattlePassLevelSession(ScenarioNodeContext context) => Context = context;
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string Id => Context.NodeId;
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!) => Context.Get(key, defaultValue);
|
||||
|
||||
/// <summary>Advances the run through the onComplete handle.</summary>
|
||||
public Task CompleteAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onComplete", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onComplete handle (fire-and-forget).</summary>
|
||||
public void Complete() => Context.Complete("onComplete");
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario battle-pass node.</summary>
|
||||
public sealed class BattlePassSession
|
||||
{
|
||||
internal BattlePassSession(ScenarioNodeContext context) => Context = context;
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string Id => Context.NodeId;
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!) => Context.Get(key, defaultValue);
|
||||
|
||||
/// <summary>Advances the run through the onLevelUp handle.</summary>
|
||||
public Task LevelUpAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onLevelUp", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onLevelUp handle (fire-and-forget).</summary>
|
||||
public void LevelUp() => Context.Complete("onLevelUp");
|
||||
|
||||
/// <summary>Advances the run through the onMaxLevel handle.</summary>
|
||||
public Task MaxLevelAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onMaxLevel", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onMaxLevel handle (fire-and-forget).</summary>
|
||||
public void MaxLevel() => Context.Complete("onMaxLevel");
|
||||
|
||||
/// <summary>Advances the run through the onPremiumPurchase handle.</summary>
|
||||
public Task PremiumPurchaseAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onPremiumPurchase", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onPremiumPurchase handle (fire-and-forget).</summary>
|
||||
public void PremiumPurchase() => Context.Complete("onPremiumPurchase");
|
||||
|
||||
/// <summary>Advances the run through the onComplete handle.</summary>
|
||||
public Task CompleteAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onComplete", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onComplete handle (fire-and-forget).</summary>
|
||||
public void Complete() => Context.Complete("onComplete");
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>
|
||||
/// Session of a scenario remote-config-override node. The patches are already
|
||||
/// applied to <see cref="RemoteConfigService"/> when the event fires.
|
||||
/// </summary>
|
||||
public sealed class ConfigChangedSession
|
||||
{
|
||||
internal ConfigChangedSession(ScenarioNodeContext context) => Context = context;
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario leaderboard node.</summary>
|
||||
public sealed class LeaderboardSession
|
||||
{
|
||||
internal LeaderboardSession(ScenarioNodeContext context) => Context = context;
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string Id => Context.NodeId;
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!) => Context.Get(key, defaultValue);
|
||||
|
||||
/// <summary>Advances the run through the onEnd handle.</summary>
|
||||
public Task EndAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onEnd", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onEnd handle (fire-and-forget).</summary>
|
||||
public void End() => Context.Complete("onEnd");
|
||||
|
||||
/// <summary>Advances the run through the onRewardClaimed handle.</summary>
|
||||
public Task RewardClaimedAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onRewardClaimed", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onRewardClaimed handle (fire-and-forget).</summary>
|
||||
public void RewardClaimed() => Context.Complete("onRewardClaimed");
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario notification node.</summary>
|
||||
public sealed class NotificationSession
|
||||
{
|
||||
internal NotificationSession(ScenarioNodeContext context) => Context = context;
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string Id => Context.NodeId;
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!) => Context.Get(key, defaultValue);
|
||||
|
||||
/// <summary>Advances the run through the output handle.</summary>
|
||||
public Task CompleteAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("output", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the output handle (fire-and-forget).</summary>
|
||||
public void Complete() => Context.Complete("output");
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario quest node.</summary>
|
||||
public sealed class QuestSession
|
||||
{
|
||||
internal QuestSession(ScenarioNodeContext context) => Context = context;
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string Id => Context.NodeId;
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!) => Context.Get(key, defaultValue);
|
||||
|
||||
/// <summary>Adds progress to one of the node's counters.</summary>
|
||||
public Task AddProgressAsync(string counterKey, long amount, CancellationToken cancellationToken = default) => Context.AddProgressAsync(counterKey, amount, cancellationToken);
|
||||
|
||||
/// <summary>Adds progress to one of the node's counters (fire-and-forget).</summary>
|
||||
public void AddProgress(string counterKey, long amount) => _ = AddProgressAsync(counterKey, amount);
|
||||
|
||||
/// <summary>Advances the run through the onComplete handle.</summary>
|
||||
public Task CompleteAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onComplete", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onComplete handle (fire-and-forget).</summary>
|
||||
public void Complete() => Context.Complete("onComplete");
|
||||
|
||||
/// <summary>Advances the run through the onFail handle.</summary>
|
||||
public Task FailAsync(CancellationToken cancellationToken = default) => Context.CompleteAsync("onFail", cancellationToken);
|
||||
|
||||
/// <summary>Advances the run through the onFail handle (fire-and-forget).</summary>
|
||||
public void Fail() => Context.Complete("onFail");
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Threading;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario store-offer node; resolve it with a purchase or a decline.</summary>
|
||||
public sealed class StoreOfferSession
|
||||
{
|
||||
internal StoreOfferSession(ScenarioNodeContext context)
|
||||
{
|
||||
Context = context;
|
||||
Data = context.AsObjectDictionary();
|
||||
}
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>Node id.</summary>
|
||||
public string Id => Context.NodeId;
|
||||
|
||||
/// <summary>Node data payload.</summary>
|
||||
public IReadOnlyDictionary<string, object> Data { get; }
|
||||
|
||||
/// <summary>True after the session was resolved once.</summary>
|
||||
public bool IsResolved { get; private set; }
|
||||
|
||||
/// <summary>Reads a typed value from the node data.</summary>
|
||||
public T Get<T>(string key, T defaultValue = default!) => Context.Get(key, defaultValue);
|
||||
|
||||
/// <summary>Resolves the offer as purchased.</summary>
|
||||
public Task PurchaseAsync(CancellationToken cancellationToken = default) => ResolveAsync("onPurchase", cancellationToken);
|
||||
|
||||
/// <summary>Resolves the offer as purchased (fire-and-forget).</summary>
|
||||
public void Purchase() => Resolve("onPurchase");
|
||||
|
||||
/// <summary>Resolves the offer as declined.</summary>
|
||||
public Task DeclineAsync(CancellationToken cancellationToken = default) => ResolveAsync("onDecline", cancellationToken);
|
||||
|
||||
/// <summary>Resolves the offer as declined (fire-and-forget).</summary>
|
||||
public void Decline() => Resolve("onDecline");
|
||||
|
||||
private async Task ResolveAsync(string handle, CancellationToken cancellationToken)
|
||||
{
|
||||
if (IsResolved) return;
|
||||
IsResolved = true;
|
||||
await Context.CompleteAsync(handle, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private void Resolve(string handle)
|
||||
{
|
||||
if (IsResolved) return;
|
||||
IsResolved = true;
|
||||
Context.Complete(handle);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using System;
|
||||
|
||||
namespace RudderSdk.Core;
|
||||
|
||||
/// <summary>Session of a scenario wait node; the run continues automatically at the deadline.</summary>
|
||||
public sealed class WaitSession
|
||||
{
|
||||
internal WaitSession(ScenarioNodeContext context, DateTimeOffset deadlineUtc)
|
||||
{
|
||||
Context = context;
|
||||
DeadlineUtc = deadlineUtc;
|
||||
}
|
||||
|
||||
/// <summary>Underlying node context.</summary>
|
||||
public ScenarioNodeContext Context { get; }
|
||||
|
||||
/// <summary>When the wait ends (UTC).</summary>
|
||||
public DateTimeOffset DeadlineUtc { get; }
|
||||
}
|
||||
Reference in New Issue
Block a user