Example #1
0
 public OrchestrationTestHost()
 {
     dataConverter = new JsonDataConverter();
     orchestrationObjectManager = new NameVersionObjectManager <TaskOrchestration>();
     activityObjectManager      = new NameVersionObjectManager <TaskActivity>();
     orchestrationExecutor      = new FakeOrchestrationExecutor(orchestrationObjectManager);
     taskActivityExecutor       = new FakeTaskActivityExecutor(activityObjectManager);
     clock = new FakeOrchestrationClock();
     ClockSpeedUpFactor = 1;
 }
Example #2
0
 public FakeOrchestrationContext(TaskScheduler scheduler, OrchestrationInstance instance,
                                 FakeTaskActivityExecutor taskActivityExecutor,
                                 FakeOrchestrationExecutor orchestrationExecutor, FakeOrchestrationClock clock)
 {
     IsReplaying           = false;
     this.scheduler        = scheduler;
     OrchestrationInstance = instance;
     TaskActivityExecutor  = taskActivityExecutor;
     OrchestrationExecutor = orchestrationExecutor;
     Clock = clock;
 }
        public async Task <T> ExecuteOrchestration <T>(OrchestrationInstance instance,
                                                       FakeTaskActivityExecutor taskActivityExecutor,
                                                       FakeOrchestrationClock clock, string name, string version, object input)
        {
            string actualVersion = version;

            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }

            if (string.IsNullOrWhiteSpace(instance.InstanceId))
            {
                instance.InstanceId = Guid.NewGuid().ToString("N");
            }

            if (string.IsNullOrWhiteSpace(instance.ExecutionId))
            {
                instance.ExecutionId = Guid.NewGuid().ToString("N");
            }

            if (currentExecutions.ContainsKey(instance.InstanceId))
            {
                throw new OrchestrationFrameworkException("Orchestration instance with id '" + instance.InstanceId +
                                                          "' already running.");
            }

            T result = default(T);
            FakeOrchestrationContext context;

            do
            {
                context = new FakeOrchestrationContext(scheduler, instance, taskActivityExecutor, this, clock);
                result  = await Execute <T>(context, name, actualVersion, input);

                if (context.StartNew)
                {
                    actualVersion = context.NewVersion ?? actualVersion;

                    while (clock.HasPendingTimers || taskActivityExecutor.HasPendingExecutions)
                    {
                        // wait for pending tasks to complete before starting new generation
                        await Task.Delay(10);
                    }

                    input = context.ContinueAsNewInput;
                    instance.ExecutionId = Guid.NewGuid().ToString("N");
                }
            } while (context.StartNew);

            return(result);
        }