/// <summary> /// Fork an orchestration. /// </summary> /// <param name="orchestration">The orchestration to perform.</param> /// <returns>a task that completes when the orchestration has been durably queued.</returns> public Task ForkOrchestration(IOrchestration orchestration) { var requestMessage = application.MakeRequest(orchestration); requestSender.Add(requestMessage); return(requestSender.NotifyAndWaitForWorkToBeServiced()); }
public void ForkOrchestration <TReturn2>(IOrchestration <TReturn2> orchestration) { if (!RecordOrReplayCall(MessageType.ForkOperation, out var opid, out var clock, out var instanceId)) { if (!process.Orchestrations.TryGetValue(orchestration.GetType(), out var orchestrationInfo)) { throw new BuilderException($"undefined orchestration type {orchestration.GetType().FullName}."); } orchestrationInfo.CanExecuteLocally(orchestration, out var destination); (ForkedDestinations ?? (ForkedDestinations = new SortedSet <uint>())).Add(destination); var message = orchestrationInfo.CreateForkMessage(orchestration); message.Opid = opid; message.Clock = clock; message.Parent = this.Opid; message.LockedByCaller = false; process.Send(destination, message); process.Telemetry?.OnApplicationEvent( processId: process.ProcessId, id: opid.ToString(), name: orchestration.ToString(), parent: Opid.ToString(), opSide: OperationSide.Fork, opType: OperationType.Orchestration, duration: 0 ); } }
public RequestMessage CreateForkMessage(IOrchestration orchestration) { return(new ForkOperation <TRequest>() { Request = (TRequest)orchestration }); }
public IMessage MakeRequest(IOrchestration orchestration) { return new ExternalRequest() { Orchestration = orchestration }; }
public Task <TReturn2> PerformOrchestration <TReturn2>(IOrchestration <TReturn2> orchestration) { if (!RecordOrReplayCall(MessageType.RequestOperation, out var opid, out var clock, out var instanceId)) { if (!process.Orchestrations.TryGetValue(orchestration.GetType(), out var orchestrationInfo)) { throw new BuilderException($"undefined orchestration type {orchestration.GetType().FullName}."); } if (LockSet != null) { if (!orchestrationInfo.RequiresLocks(orchestration, out var locks)) { throw new SynchronizationDisciplineException("an orchestration called from a locked context must be locked also"); } foreach (var l in locks) { if (!LockSet.Contains(l)) { throw new SynchronizationDisciplineException("to perform an orchestration in a locked context, the caller's affinities must contain the callee's affinities"); } } } orchestrationInfo.CanExecuteLocally(orchestration, out uint destination); var message = orchestrationInfo.CreateRequestMessage(orchestration); message.Opid = opid; message.Clock = clock; message.Parent = this.Opid; message.LockedByCaller = (LockSet != null); process.Send(destination, message); } if (!ReplayReturn(MessageType.RespondToOperation, opid, out var result)) { var continuationInfo = new ContinuationInfo <TReturn2>(orchestration.ToString(), OperationType.Orchestration); Continuations[opid] = continuationInfo; return(continuationInfo.Tcs.Task); } else { if (process.Serializer.DeserializeException(result, out var e)) { return(Task.FromException <TReturn2>(e)); } else { return(Task.FromResult((TReturn2)result)); } } }
/// <summary> /// Perform an orchestration. /// </summary> /// <typeparam name="TReturn">The type of the result</typeparam> /// <param name="orchestration">The orchestration to perform</param> /// <returns>a task that completes after the orchestration has finished, with the result.</returns> public Task <TReturn> PerformOrchestration <TReturn>(IOrchestration <TReturn> orchestration) { var co = new ClientRequestOrchestration <TStaticApplicationInfo, TReturn>() { Orchestration = orchestration, ClientRequestId = Guid.NewGuid(), ResponsePartition = responsePartition }; var continuation = new TaskCompletionSource <TReturn>(); continuations.TryAdd(co.ClientRequestId, continuation); var requestMessage = application.MakeRequest(co); requestSender.Add(requestMessage); requestSender.Notify(); return(continuation.Task); }
void IContextWithForks.ForkOrchestration <TReturn>(IOrchestration <TReturn> orchestration) { if (!process.Orchestrations.TryGetValue(orchestration.GetType(), out var orchestrationInfo)) { throw new BuilderException($"undefined orchestration type {orchestration.GetType().FullName}."); } orchestrationInfo.CanExecuteLocally(orchestration, out uint destination); var opid = process.NextOpid; var message = orchestrationInfo.CreateForkMessage(orchestration); message.Opid = opid; message.Parent = CurrentOpid; process.Send(destination, message); process.Telemetry?.OnApplicationEvent( processId: process.ProcessId, id: opid.ToString(), name: orchestration.ToString(), parent: CurrentOpid.ToString(), opSide: OperationSide.Fork, opType: OperationType.Orchestration, duration: 0 ); }
IServiceBuilder IServiceBuilder.OnFirstStart(IOrchestration orchestration) { process.StartupOrchestrations.Add(orchestration); return(this); }
public static void ScheduleOrchestration <TReturn>(this IContextWithForks context, TimeSpan delay, IOrchestration <TReturn> orchestration) { CheckTimeArgument(delay); context.ForkOrchestration(new Extensions.ForkedOrchestration <TReturn>() { Delay = delay, Orchestration = orchestration }); }
public static List <QueueMetadata> RunTask(QueueMetadata metadata, JObject taskProperties, string identifier, IOrchestration orchestration) { List <QueueMetadata> result = null; try { if (taskProperties == null) { throw new Exception("TaskProperties for Transformer cannot be NULL"); } TransformerConfiguration taskConfig = taskProperties.ToObject <TransformerConfiguration>(); JObject transformerJson = orchestration.GetTransformer(taskConfig.TransformerID); QueueMetadata transformedMetadata = new QueueMetadata() { CustomPropertiesJson = metadata.CustomPropertiesJson, ID = Guid.NewGuid(), MessageBodyJson = metadata.MessageBodyJson, Retries = metadata.Retries, SplitID = metadata.SplitID, StepIdentifier = identifier, Success = true, Timestamp = DateTime.UtcNow }; transformedMetadata.MessageBodyJson = JUST.JsonTransformer.Transform(transformerJson, metadata.MessageBodyJson); result = new List <QueueMetadata>(); result.Add(transformedMetadata); } catch (Exception ex) { result = new List <QueueMetadata>(); QueueMetadata errorMetaData = new QueueMetadata() { CustomPropertiesJson = metadata.CustomPropertiesJson, ID = Guid.NewGuid(), MessageBodyJson = metadata.MessageBodyJson, Retries = metadata.Retries, SplitID = metadata.SplitID, StepIdentifier = identifier, Success = false, Timestamp = DateTime.UtcNow }; Dictionary <string, string> customPropertiesSerialized = errorMetaData.CustomPropertiesJson.ToObject <Dictionary <string, string> >(); if (customPropertiesSerialized.ContainsKey("Error")) { customPropertiesSerialized.Remove("Error"); } customPropertiesSerialized.Add("Error", ex.Message); errorMetaData.CustomPropertiesJson = JObject.FromObject(customPropertiesSerialized); result.Add(errorMetaData); } return(result); }
public OrchestrationController(IOptions <MySqlConfiguration> mySqlModel) { _connectionString = mySqlModel.Value.ConnectionString; _orchestration = new MySqlOrchestration(_connectionString); }
public static async Task ForkOrchestration(IOrchestration orchestration, IStaticApplicationInfo applicationInfo, ILogger logger) { var client = ClientConnection.Get(applicationInfo, logger); await client.Fork(orchestration); }
public OrchestrationController(IOptions <DynamoDBConfiguration> model) { _model = model.Value; _orchestration = new DynamoDBOchestration(_model); }
public OrchestrationEngine(IOrchestration orchestration) { _orchestration = orchestration; }