public void OrchestrationInstanceComparer_DifferentOrchestrationInstances() { var first = new OrchestrationInstance() { InstanceId = "InstanceId1", ExecutionId = "ExecutionId1" }; var second = new OrchestrationInstance() { InstanceId = "InstanceId2", ExecutionId = "ExecutionId2" }; Assert.IsFalse(OrchestrationInstanceComparer.Default.Equals(first, second)); }
public void SessionNotExceededLimitTest() { taskHub.AddTaskOrchestrations(typeof(LargeSessionOrchestration)) .AddTaskActivities(typeof(LargeSessionTaskActivity)) .Start(); OrchestrationInstance id = client.CreateOrchestrationInstance(typeof(LargeSessionOrchestration), 15); bool isCompleted = TestHelpers.WaitForInstance(client, id, 90, true); Thread.Sleep(20000); OrchestrationState state = client.GetOrchestrationState(id); Assert.AreEqual(OrchestrationStatus.Completed, state.OrchestrationStatus); }
public void AsyncGreetingsTest() { AsyncGreetingsOrchestration.Result = null; taskHub.AddTaskOrchestrations(typeof(AsyncGreetingsOrchestration)) .AddTaskActivities(typeof(AsyncGetUserTask), typeof(AsyncSendGreetingTask)) .Start(); OrchestrationInstance id = client.CreateOrchestrationInstance(typeof(AsyncGreetingsOrchestration), null); bool isCompleted = TestHelpers.WaitForInstance(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual("Greeting send to Gabbar", AsyncGreetingsOrchestration.Result, "Orchestration Result is wrong!!!"); }
public async Task GenerationBasicNoCompressionTest() { GenerationBasicOrchestration.Result = 0; GenerationBasicTask.GenerationCount = 0; await this.taskHubNoCompression.AddTaskOrchestrations(typeof(GenerationBasicOrchestration)) .AddTaskActivities(new GenerationBasicTask()) .StartAsync(); OrchestrationInstance id = await this.client.CreateOrchestrationInstanceAsync(typeof(GenerationBasicOrchestration), 4); bool isCompleted = await TestHelpers.WaitForInstanceAsync(this.client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(this.client, id, 60)); Assert.AreEqual(4, GenerationBasicOrchestration.Result, "Orchestration Result is wrong!!!"); }
public async Task FailingInstanceStoreTest() { await taskHub.AddTaskOrchestrations(typeof(InstanceStoreTestOrchestration)) .AddTaskActivities(new Activity1()) .StartAsync(); OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(InstanceStoreTestOrchestration), "THROW"); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); var status = await client.GetOrchestrationStateAsync(id); Assert.IsTrue(status.OrchestrationStatus == OrchestrationStatus.Failed); }
public async Task GreetingsDynamicProxyTest() { await taskHub.AddTaskOrchestrations(typeof(GreetingsOrchestration)) .AddTaskActivities( new NameValueObjectCreator <TaskActivity>(GET_USER_NAME, GET_USER_VERSION, new GetUserTask()), new NameValueObjectCreator <TaskActivity>(SEND_GREETING_NAME, SEND_GREETING_VERSION, new SendGreetingTask())) .StartAsync(); OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(GreetingsOrchestration), null); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual("Greeting send to Gabbar", GreetingsOrchestration.Result, "Orchestration Result is wrong!!!"); }
public async Task MoreParamsOrchestrationTest() { await taskHub.AddTaskOrchestrations(typeof(MoreParamsOrchestration)) .AddTaskActivitiesFromInterface <IMoreParamsActivities>(new MoreParamsActivities()) .StartAsync(); OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(MoreParamsOrchestration), new MoreParamsOrchestrationInput { Str = "Hello" }); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual("Hello00Hello1015", MoreParamsOrchestration.Result); }
/// <summary> /// Starts a new execution of the specified orchestrator function. /// </summary> /// <param name="orchestratorFunctionName">The name of the orchestrator function to start.</param> /// <param name="instanceId">A unique ID to use for the new orchestration instance.</param> /// <param name="input">JSON-serializeable input value for the orchestrator function.</param> /// <returns>A task that completes when the start message is enqueued.</returns> public async Task <string> StartNewAsync(string orchestratorFunctionName, string instanceId, object input) { OrchestrationInstance instance = await this.client.CreateOrchestrationInstanceAsync( orchestratorFunctionName, DefaultVersion, instanceId, input); this.traceHelper.FunctionScheduled( this.hubName, orchestratorFunctionName, DefaultVersion, instance.InstanceId, reason: "NewInstance", isOrchestrator: true, isReplay: false); return(instance.InstanceId); }
public void GenerationBasicTest() { GenerationBasicOrchestration.Result = 0; GenerationBasicTask.GenerationCount = 0; taskHub.AddTaskOrchestrations(typeof(GenerationBasicOrchestration)) .AddTaskActivities(new GenerationBasicTask()) .Start(); OrchestrationInstance id = client.CreateOrchestrationInstance(typeof(GenerationBasicOrchestration), 4); bool isCompleted = TestHelpers.WaitForInstance(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual(4, GenerationBasicOrchestration.Result, "Orchestration Result is wrong!!!"); }
public async Task ErrorHandlingTest() { await taskHub.AddTaskOrchestrations(typeof(ErrorHandlingOrchestration)) .AddTaskActivities(typeof(GoodTask), typeof(BadTask), typeof(CleanupTask)) .StartAsync(); taskHub.TaskActivityDispatcher.IncludeDetails = true; OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(typeof(ErrorHandlingOrchestration), null); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual("CleanupResult", ErrorHandlingOrchestration.Result, "Orchestration Result is wrong!!!"); }
static async Task Main(string[] args) { //Use Azurite emulator string storageConnectionString = "DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;" + "BlobEndpoint=http://127.0.0.1:10000/devstoreaccount1;QueueEndpoint=http://127.0.0.1:10001/devstoreaccount1;TableEndpoint=http://127.0.0.1:10002/devstoreaccount1"; string taskHubName = "RetryTest"; var settings = new AzureStorageOrchestrationServiceSettings(); settings.StorageConnectionString = storageConnectionString; settings.TaskHubName = taskHubName; settings.UseDataContractSerialization = true; var orchestrationServiceAndClient = new AzureStorageOrchestrationService(settings); await orchestrationServiceAndClient.CreateIfNotExistsAsync(); var taskHubClient = new TaskHubClient(orchestrationServiceAndClient); var taskHub = new TaskHubWorker(orchestrationServiceAndClient); // add instance _ = Task.Run(async() => { OrchestrationInstance ins = await taskHubClient.CreateOrchestrationInstanceAsync(typeof(HelloOrchestration), "b", ""); }); // add worker try { taskHub.AddTaskOrchestrations( typeof(HelloOrchestration) ); taskHub.AddTaskActivitiesFromInterface <IFailedTask>(new FailedTask()); await taskHub.StartAsync(); //Console.WriteLine("Press any key to quit."); Console.ReadLine(); taskHub.StopAsync(true).Wait(); } catch (Exception e) { // silently eat any unhandled exceptions. Console.WriteLine($"worker exception: {e}"); } }
internal void RescheduleMessages(OrchestrationContext innerContext, List <RequestMessage> messages) { if (messages != null) { foreach (var message in messages) { var instance = new OrchestrationInstance { InstanceId = this.InstanceId }; DateTime adjustedDeliveryTime = message.GetAdjustedDeliveryTime(this.durabilityProvider); var eventName = EntityMessageEventNames.ScheduledRequestMessageEventName(adjustedDeliveryTime); innerContext.SendEvent(instance, eventName, message); } messages.Clear(); } }
/// <summary> /// Creates a <see cref="OrchestrationInstanceEx"/> from the provided /// <see cref="OrchestrationRuntimeState"/>, using its extension data if available. /// </summary> /// <param name="runtimeState">The runtime state to create this instance from.</param> /// <returns>A new or deserialized instance.</returns> public static OrchestrationInstanceEx Initialize(OrchestrationRuntimeState runtimeState) { if (runtimeState == null) { throw new ArgumentNullException(nameof(runtimeState)); } OrchestrationInstance instance = runtimeState.OrchestrationInstance; if (instance is OrchestrationInstanceEx custom) { return(custom); } custom = Get(instance); return(custom); }
public void SignalTest() { taskHub.AddTaskOrchestrations(typeof(SignalOrchestration)) .AddTaskActivities(typeof(SendGreetingTask)) .Start(); OrchestrationInstance id = client.CreateOrchestrationInstance(typeof(SignalOrchestration), null); Thread.Sleep(2 * 1000); client.RaiseEvent(id, "GetUser", "Gabbar"); bool isCompleted = TestHelpers.WaitForInstance(client, id, 60); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 60)); Assert.AreEqual("Greeting send to Gabbar", SignalOrchestration.Result, "Orchestration Result is wrong!!!"); }
public async Task RetryFailProxyTest() { var retryOptions = new RetryOptions(TimeSpan.FromSeconds(3), 3); var retryTask = new RetryTask(3); await taskHub.AddTaskOrchestrations(new TestObjectCreator <TaskOrchestration>(RETRY_NAME, RETRY_VERSION, () => new RetryOrchestration(retryOptions))) .AddTaskActivitiesFromInterface <IRetryTask>(retryTask) .StartAsync(); RetryOrchestration.Result = null; OrchestrationInstance id = await client.CreateOrchestrationInstanceAsync(RETRY_NAME, RETRY_VERSION, null); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 120); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 120)); Assert.AreEqual("RetryCount is: 3", RetryOrchestration.Result, "Orchestration Result is wrong!!!"); }
public async Task SubOrchestrationRetryExhaustedTest() { ArgumentException argumentException = null; try { // ReSharper disable once ObjectCreationAsStatement new RetryOptions(TimeSpan.Zero, 10); } catch (ArgumentException ex) { argumentException = ex; } Assert.IsNotNull(argumentException); Assert.AreEqual( "Invalid interval. Specify a TimeSpan value greater then TimeSpan.Zero.\r\nParameter name: firstRetryInterval", argumentException.Message); var parentRetryOptions = new RetryOptions(TimeSpan.FromSeconds(3), 2) { BackoffCoefficient = 2.0, MaxRetryInterval = TimeSpan.FromSeconds(4), }; var retryOptions = new RetryOptions(TimeSpan.FromSeconds(3), 2); var retryTask = new RetryTask(4); RetryOrchestration.RethrowException = true; await this.taskHub.AddTaskOrchestrations(new TestObjectCreator <TaskOrchestration>(RetryName, RetryVersion, () => new RetryOrchestration(retryOptions))) .AddTaskOrchestrations(new TestObjectCreator <TaskOrchestration>(RetryParentName, RetryParentVersion, () => new ParentOrchestration(parentRetryOptions))) .AddTaskActivitiesFromInterface <IRetryTask>(retryTask) .StartAsync(); ParentOrchestration.Result = null; RetryOrchestration.Result = null; OrchestrationInstance id = await this.client.CreateOrchestrationInstanceAsync(RetryParentName, RetryParentVersion, false); bool isCompleted = await TestHelpers.WaitForInstanceAsync(this.client, id, 90); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(this.client, id, 90)); Assert.AreEqual("DoWork Failed. RetryCount is: 4", ParentOrchestration.Result, "Orchestration Result is wrong!!!"); }
internal void SendOperationMessage(OrchestrationInstance target, string eventName, object message) { lock (this.outbox) { if (message is RequestMessage requestMessage) { this.State.MessageSorter.LabelOutgoingMessage(requestMessage, target.InstanceId, DateTime.UtcNow, this.EntityMessageReorderWindow); } this.outbox.Add(new OperationMessage() { Target = target, EventName = eventName, EventContent = message, }); } }
public void TryUnlockSession(OrchestrationInstance instance, bool abandon = false, bool isComplete = false) { ServiceFabricProviderEventSource.Tracing.TraceMessage(instance.InstanceId, $"Session Unlock Begin, Abandon = {abandon}"); if (!this.lockedSessions.TryRemove(instance.InstanceId, out LockState lockState) || lockState == LockState.InFetchQueue) { var errorMessage = $"{nameof(SessionProvider)}.{nameof(TryUnlockSession)} : Trying to unlock the session {instance.InstanceId} which was not locked."; ServiceFabricProviderEventSource.Tracing.UnexpectedCodeCondition(errorMessage); throw new Exception(errorMessage); } if (!isComplete && (abandon || lockState == LockState.NewMessagesWhileLocked)) { this.TryEnqueueSession(instance); } ServiceFabricProviderEventSource.Tracing.TraceMessage(instance.InstanceId, $"Session Unlock End, Abandon = {abandon}, removed lock state = {lockState}"); }
public void SessionExceededLimitNoCompressionTest() { taskHubNoCompression.AddTaskOrchestrations(typeof(LargeSessionOrchestration)) .AddTaskActivities(typeof(LargeSessionTaskActivity)) .Start(); OrchestrationInstance id = client.CreateOrchestrationInstance(typeof(LargeSessionOrchestration), 15); bool isCompleted = TestHelpers.WaitForInstance(client, id, 60, true); Thread.Sleep(20000); OrchestrationState state = client.GetOrchestrationState(id); Assert.AreEqual(OrchestrationStatus.Terminated, state.OrchestrationStatus); Assert.IsTrue(state.Output.Contains("exceeded")); }
public async Task SimplestGreetingsJumpStartDelayTest() { var sbService = (ServiceBusOrchestrationService)taskHub.orchestrationService; string name = NameVersionHelper.GetDefaultName(typeof(SimplestGreetingsOrchestration)); string version = NameVersionHelper.GetDefaultVersion(typeof(SimplestGreetingsOrchestration)); await taskHub.AddTaskOrchestrations(typeof(SimplestGreetingsOrchestration)) .AddTaskActivities(typeof(SimplestGetUserTask), typeof(SimplestSendGreetingTask)) .StartAsync(); OrchestrationInstance id = await TestHelpers.CreateOrchestrationInstanceAsync(sbService, name, version, null, null, true, false); // Wait only 8 seconds, the jumptstartinterval is set to 10 bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, id, 8); Assert.IsFalse(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 8)); }
public async Task WaitForOrchestration_Returns_Null_When_Orchestration_Not_Started() { var instance = new OrchestrationInstance() { InstanceId = "NonExisting", ExecutionId = "NonExisting" }; OrchestrationState result = null; var waitTime = TimeSpan.FromMinutes(1); var time = await Utilities.MeasureAsync(async() => { result = await this.taskHubClient.WaitForOrchestrationAsync(instance, waitTime); }); Assert.IsNull(result); Assert.IsTrue(time < waitTime + waitTime); Console.WriteLine($"Full WaitTime : {waitTime}, Actual time taken for Wait {time}"); }
public void OrchestrationInstanceComparer_SameOrchestrationInstances() { var first = new OrchestrationInstance() { InstanceId = "InstanceId", ExecutionId = "ExecutionId" }; var second = new OrchestrationInstance() { InstanceId = "InstanceId", ExecutionId = "ExecutionId" }; Assert.IsTrue(OrchestrationInstanceComparer.Default.Equals(first, first)); Assert.IsTrue(OrchestrationInstanceComparer.Default.Equals(first, second)); }
public void Messages_With_Different_FiredAt_Value_Are_Sorted_Based_On_FiredAt() { ImmutableSortedSet <Message <Guid, TaskMessageItem> > timerMessages = ImmutableSortedSet <Message <Guid, TaskMessageItem> > .Empty.WithComparer(TimerFiredEventComparer.Instance); var instance = new OrchestrationInstance() { InstanceId = "InstanceId", }; var currentTime = DateTime.UtcNow; var builder = timerMessages.ToBuilder(); int numberOfMessages = 5; var guids = Enumerable.Range(0, numberOfMessages).Select(x => Guid.NewGuid()).ToList(); // Add them in reverse order to expected order just to make the test case more interesting. for (int i = numberOfMessages - 1; i >= 0; i--) { builder.Add(new Message <Guid, TaskMessageItem>(guids[i], new TaskMessageItem(new TaskMessage() //Let the key values be in reverse order to fired at values again to make test more interesting. { SequenceNumber = i, OrchestrationInstance = instance, Event = new TimerFiredEvent(i) { FireAt = currentTime + TimeSpan.FromSeconds(i) } }))); } Assert.AreEqual(numberOfMessages, builder.Count); timerMessages = builder.ToImmutableSortedSet(TimerFiredEventComparer.Instance); Assert.AreEqual(numberOfMessages, timerMessages.Count); // Now enumerating the items should result in right order. for (int i = 0; i < numberOfMessages; i++) { var min = timerMessages.Min; timerMessages = timerMessages.Remove(min); var firedAt = (min.Value.TaskMessage.Event as TimerFiredEvent)?.FireAt; Assert.AreEqual(currentTime + TimeSpan.FromSeconds(i), firedAt, "Ordering seems to be broken"); Assert.AreEqual(guids[i], min.Key); } Assert.AreEqual(0, timerMessages.Count); }
public async Task ScheduledStart() { const int MaxSecondsToCompleteNotDelayedOrchestration = 10; await this.taskHub.AddTaskOrchestrations(typeof(StartAtTimeOrchestration)) .StartAsync(); // orchestrationId1 has delayed start var delay = TimeSpan.FromSeconds(30); var expectedStartTime = DateTime.UtcNow.Add(delay); OrchestrationInstance orchestrationId1 = await this.client.CreateScheduledOrchestrationInstanceAsync(typeof(StartAtTimeOrchestration), null, expectedStartTime); // orchestrationId2 can start immediately OrchestrationInstance orchestrationId2 = await this.client.CreateOrchestrationInstanceAsync(typeof(StartAtTimeOrchestration), null); // Ensure that the orchestration with delay has been created properly var orchestration1StateAfterCreation = await this.client.GetOrchestrationStateAsync(orchestrationId1); Assert.AreEqual(OrchestrationStatus.Pending, orchestration1StateAfterCreation.OrchestrationStatus); // Ensure that the orchestration without delay has been created properly var orchestration2StateAfterCreation = await this.client.GetOrchestrationStateAsync(orchestrationId2); Assert.IsTrue(new[] { OrchestrationStatus.Pending, OrchestrationStatus.Running, OrchestrationStatus.Completed }.Contains(orchestration2StateAfterCreation.OrchestrationStatus)); // Wait until orchestration 2 (not delayed) is complete bool isOrchestration2Complete = await TestHelpers.WaitForInstanceAsync(this.client, orchestrationId2, 60); Assert.IsTrue(isOrchestration2Complete, TestHelpers.GetInstanceNotCompletedMessage(this.client, orchestrationId2, 60)); var orchestration2CompletedState = await client.GetOrchestrationStateAsync(orchestrationId2); var orchestration2TimeToCompleteInSeconds = (int)orchestration2CompletedState.CompletedTime.Subtract(orchestration2CompletedState.CreatedTime).TotalSeconds; Assert.IsTrue(orchestration2TimeToCompleteInSeconds < MaxSecondsToCompleteNotDelayedOrchestration, $"Expected not delayed orchestration to be complete in under {MaxSecondsToCompleteNotDelayedOrchestration} secs, but was {orchestration2TimeToCompleteInSeconds}"); // Wait until orchestration 1 (delayed) is complete bool isOrchestration1Complete = await TestHelpers.WaitForInstanceAsync(this.client, orchestrationId1, 60); Assert.IsTrue(isOrchestration1Complete, TestHelpers.GetInstanceNotCompletedMessage(this.client, orchestrationId1, 60)); var orchestration1CompletedState = await client.GetOrchestrationStateAsync(orchestrationId1); var orchestration1TimeToCompleteInSeconds = (int)orchestration1CompletedState.CompletedTime.Subtract(orchestration1CompletedState.CreatedTime).TotalSeconds; Assert.IsTrue(orchestration1TimeToCompleteInSeconds >= delay.TotalSeconds, $"Expected delayed orchestration to be completed after {delay.TotalSeconds} seconds or more relative to the creation time, but was {orchestration1TimeToCompleteInSeconds} seconds"); }
public async Task NonDeterministicOrchestrationTest() { await taskHub.AddTaskOrchestrations(typeof(NonDeterministicOrchestration)) .AddTaskActivities(typeof(FirstTask)) .StartAsync(); taskHub.TaskActivityDispatcher.IncludeDetails = true; OrchestrationInstance instance = await client.CreateOrchestrationInstanceAsync(typeof(NonDeterministicOrchestration), "FAILTIMER"); bool isCompleted = await TestHelpers.WaitForInstanceAsync(client, instance, 60); OrchestrationState state = await client.GetOrchestrationStateAsync(instance); Assert.AreEqual(OrchestrationStatus.Failed, state.OrchestrationStatus); Assert.IsTrue(state.Output.Contains("TimerCreatedEvent")); instance = await client.CreateOrchestrationInstanceAsync(typeof(NonDeterministicOrchestration), "FAILTASK"); isCompleted = await TestHelpers.WaitForInstanceAsync(client, instance, 60); state = await client.GetOrchestrationStateAsync(instance); Assert.AreEqual(OrchestrationStatus.Failed, state.OrchestrationStatus); Assert.IsTrue(state.Output.Contains("TaskScheduledEvent")); instance = await client.CreateOrchestrationInstanceAsync(typeof(NonDeterministicOrchestration), "FAILSUBORCH"); isCompleted = await TestHelpers.WaitForInstanceAsync(client, instance, 60); state = await client.GetOrchestrationStateAsync(instance); Assert.AreEqual(OrchestrationStatus.Failed, state.OrchestrationStatus); Assert.IsTrue(state.Output.Contains("SubOrchestrationInstanceCreatedEvent")); instance = await client.CreateOrchestrationInstanceAsync(typeof(NonDeterministicOrchestration), "PARENTORCH"); isCompleted = await TestHelpers.WaitForInstanceAsync(client, instance, 60); state = await client.GetOrchestrationStateAsync(instance); Assert.AreEqual(OrchestrationStatus.Completed, state.OrchestrationStatus); Assert.IsTrue(state.Output.Contains("Non-Deterministic workflow detected")); }
public async Task DispatchMiddlewareContextBuiltInProperties() { TaskOrchestration orchestration = null; OrchestrationRuntimeState state = null; OrchestrationInstance instance1 = null; TaskActivity activity = null; TaskScheduledEvent taskScheduledEvent = null; OrchestrationInstance instance2 = null; this.worker.AddOrchestrationDispatcherMiddleware((context, next) => { orchestration = context.GetProperty <TaskOrchestration>(); state = context.GetProperty <OrchestrationRuntimeState>(); instance1 = context.GetProperty <OrchestrationInstance>(); return(next()); }); this.worker.AddActivityDispatcherMiddleware((context, next) => { activity = context.GetProperty <TaskActivity>(); taskScheduledEvent = context.GetProperty <TaskScheduledEvent>(); instance2 = context.GetProperty <OrchestrationInstance>(); return(next()); }); var instance = await this.client.CreateOrchestrationInstanceAsync(typeof(SimplestGreetingsOrchestration), null); TimeSpan timeout = TimeSpan.FromSeconds(Debugger.IsAttached ? 1000 : 10); await this.client.WaitForOrchestrationAsync(instance, timeout); Assert.IsNotNull(orchestration); Assert.IsNotNull(state); Assert.IsNotNull(instance1); Assert.IsNotNull(activity); Assert.IsNotNull(taskScheduledEvent); Assert.IsNotNull(instance2); Assert.AreNotSame(instance1, instance2); Assert.AreEqual(instance1.InstanceId, instance2.InstanceId); }
private async Task SignalEntityAsyncInternal(TaskHubClient client, string hubName, EntityId entityId, DateTime?scheduledTimeUtc, string operationName, object operationInput) { if (operationName == null) { throw new ArgumentNullException(nameof(operationName)); } if (this.client.Equals(client)) { this.config.ThrowIfFunctionDoesNotExist(entityId.EntityName, FunctionType.Entity); } var guid = Guid.NewGuid(); // unique id for this request var instanceId = EntityId.GetSchedulerIdFromEntityId(entityId); var instance = new OrchestrationInstance() { InstanceId = instanceId }; var request = new RequestMessage() { ParentInstanceId = null, // means this was sent by a client ParentExecutionId = null, Id = guid, IsSignal = true, Operation = operationName, ScheduledTime = scheduledTimeUtc, }; if (operationInput != null) { request.SetInput(operationInput, this.messageDataConverter); } var jrequest = JToken.FromObject(request, this.messageDataConverter.JsonSerializer); var eventName = scheduledTimeUtc.HasValue ? EntityMessageEventNames.ScheduledRequestMessageEventName(scheduledTimeUtc.Value) : EntityMessageEventNames.RequestMessageEventName; await client.RaiseEventAsync(instance, eventName, jrequest); this.traceHelper.FunctionScheduled( hubName, entityId.EntityName, EntityId.GetSchedulerIdFromEntityId(entityId), reason: $"EntitySignal:{operationName}", functionType: FunctionType.Entity, isReplay: false); }
protected async Task JumpStartOrchestrationAsync(OrchestrationJumpStartInstanceEntity jumpStartEntity) { OrchestrationInstance instance = jumpStartEntity.State.OrchestrationInstance; OrchestrationStateInstanceEntity stateEntity = (await this.service.InstanceStore.GetEntitiesAsync(instance.InstanceId, instance.ExecutionId))?.FirstOrDefault(); if (stateEntity != null) { // It seems orchestration started, delete entity from JumpStart table await this.service.InstanceStore.DeleteJumpStartEntitiesAsync(new[] { jumpStartEntity }); } else if (!jumpStartEntity.JumpStartTime.IsSet() && jumpStartEntity.State.CreatedTime + this.ignoreWindow < DateTime.UtcNow) { // JumpStart orchestration var startedEvent = new ExecutionStartedEvent(-1, jumpStartEntity.State.Input) { Tags = jumpStartEntity.State.Tags, Name = jumpStartEntity.State.Name, Version = jumpStartEntity.State.Version, OrchestrationInstance = jumpStartEntity.State.OrchestrationInstance }; var taskMessage = new TaskMessage { OrchestrationInstance = jumpStartEntity.State.OrchestrationInstance, Event = startedEvent }; await this.service.SendTaskOrchestrationMessageAsync(taskMessage); TraceHelper.Trace( TraceEventType.Information, "JumpStartManager-SendTaskOrchestrationMessage", $"JumpStartManager: SendTaskOrchestrationMessageAsync({instance.InstanceId}, {instance.ExecutionId}) success!"); // Now update the JumpStart table jumpStartEntity.JumpStartTime = DateTime.UtcNow; await this.service.InstanceStore.WriteJumpStartEntitiesAsync(new[] { jumpStartEntity }); TraceHelper.Trace( TraceEventType.Information, "JumpStartManager-WriteJumpStartEntities", $"JumpStartManager: WriteJumpStartEntitiesAsync({instance.InstanceId}, {instance.ExecutionId}) success!"); } }
public void SubOrchestrationRetryExhaustedTest() { ArgumentException argumentException = null; try { new RetryOptions(TimeSpan.Zero, 10); } catch (ArgumentException ex) { argumentException = ex; } Assert.IsNotNull(argumentException); Assert.AreEqual( "Invalid interval. Specify a TimeSpan value greater then TimeSpan.Zero.\r\nParameter name: firstRetryInterval", argumentException.Message); var parentRetryOptions = new RetryOptions(TimeSpan.FromSeconds(3), 2) { BackoffCoefficient = 2.0, MaxRetryInterval = TimeSpan.FromSeconds(4), }; var retryOptions = new RetryOptions(TimeSpan.FromSeconds(3), 2); var retryTask = new RetryTask(4); RetryOrchestration.rethrowException = true; taskHub.AddTaskOrchestrations(new TestObjectCreator <TaskOrchestration>(RETRY_NAME, RETRY_VERSION, () => new RetryOrchestration(retryOptions))) .AddTaskOrchestrations(new TestObjectCreator <TaskOrchestration>(RETRY_PARENT_NAME, RETRY_PARENT_VERSION, () => new ParentOrchestration(parentRetryOptions))) .AddTaskActivitiesFromInterface <IRetryTask>(retryTask) .Start(); ParentOrchestration.Result = null; RetryOrchestration.Result = null; OrchestrationInstance id = client.CreateOrchestrationInstance(RETRY_PARENT_NAME, RETRY_PARENT_VERSION, false); bool isCompleted = TestHelpers.WaitForInstance(client, id, 90); Assert.IsTrue(isCompleted, TestHelpers.GetInstanceNotCompletedMessage(client, id, 90)); Assert.AreEqual("DoWork Failed. RetryCount is: 4", ParentOrchestration.Result, "Orchestration Result is wrong!!!"); }
/// <summary> /// Starts a new execution of the specified orchestrator function. /// </summary> /// <param name="orchestratorFunctionName">The name of the orchestrator function to start.</param> /// <param name="instanceId">A unique ID to use for the new orchestration instance.</param> /// <param name="input">JSON-serializeable input value for the orchestrator function.</param> /// <returns>A task that completes when the start message is enqueued.</returns> /// <exception cref="ArgumentException"> /// The specified function does not exist, is disabled, or is not an orchestrator function. /// </exception> public async Task <string> StartNewAsync(string orchestratorFunctionName, string instanceId, object input) { this.config.AssertOrchestratorExists(orchestratorFunctionName, DefaultVersion); OrchestrationInstance instance = await this.client.CreateOrchestrationInstanceAsync( orchestratorFunctionName, DefaultVersion, instanceId, input); this.traceHelper.FunctionScheduled( this.hubName, orchestratorFunctionName, DefaultVersion, instance.InstanceId, reason: "NewInstance", functionType: FunctionType.Orchestrator, isReplay: false); return(instance.InstanceId); }
public TaskContext(OrchestrationInstance orchestrationInstance) { OrchestrationInstance = orchestrationInstance; }
// have both iid and eid public static void TraceInstance(TraceEventType eventType, OrchestrationInstance orchestrationInstance, string format, params object[] args) { if (source.Switch.ShouldTrace(eventType)) { ExceptionHandlingWrapper( () => source.TraceEvent(eventType, 0, GetFormattedString( orchestrationInstance == null ? string.Empty : orchestrationInstance.InstanceId, orchestrationInstance == null ? string.Empty : orchestrationInstance.ExecutionId, format, args))); } }
public static void TraceInstance(TraceEventType eventType, OrchestrationInstance orchestrationInstance, Func<string> generateMessage) { if (source.Switch.ShouldTrace(eventType)) { ExceptionHandlingWrapper( () => source.TraceEvent(eventType, 0, GetFormattedString( orchestrationInstance == null ? string.Empty : orchestrationInstance.InstanceId, orchestrationInstance == null ? string.Empty : orchestrationInstance.ExecutionId, generateMessage()))); } }
// instance tracing methods public static Exception TraceExceptionInstance(TraceEventType eventType, OrchestrationInstance orchestrationInstance, Exception exception) { return TraceExceptionCore(eventType, orchestrationInstance.InstanceId, orchestrationInstance.ExecutionId, exception, string.Empty); }
public static Exception TraceExceptionInstance(TraceEventType eventType, OrchestrationInstance orchestrationInstance, Exception exception, Func<string> generateMessage) { return TraceExceptionCore(eventType, orchestrationInstance.InstanceId, orchestrationInstance.ExecutionId, exception, generateMessage); }
public static Exception TraceExceptionInstance(TraceEventType eventType, OrchestrationInstance orchestrationInstance, Exception exception, string format, params object[] args) { return TraceExceptionCore(eventType, orchestrationInstance.InstanceId, orchestrationInstance.ExecutionId, exception, format, args); }