//For test
        private void testButton1_Click(object sender, RoutedEventArgs e)
        {
            /*Type  t = dataGrid.ItemsSource.GetType().GetGenericArguments().Single();
             * var inst = Activator.CreateInstance(t);
             * Console.WriteLine(inst.ToString());*/

            //So decimal in 20.00 will parse correctly

            var _inventory = new Inventory();

            _inventory.AddBottle("Whiskey", 0, 50, 0, 60);
            _inventory.AddBottle("Cola", 1, 50, 1, 60);
            _inventory.AddBottle("Juice", 2, 50, 2, 60);
            _inventory.AddBottle("Rum", 3, 50, 3, 60);

            Debug.WriteLine(_inventory.ToString());

            var jf            = new JobFactory(_inventory);
            var ingredientsWC = new Dictionary <string, int>
            {
                { "Whiskey", 6 }, { "Cola", 12 }
            };
            var ingredientsRC = new Dictionary <string, int>
            {
                { "Rum", 4 }, { "Cola", 6 }
            };
            var ingredientsJW = new Dictionary <string, int>
            {
                { "Juice", 10 }, { "Whiskey", 10 }
            };
            var jobW  = jf.CreateDrinkByIngredients(1, ingredientsWC);
            var jobR  = jf.CreateDrinkByIngredients(2, ingredientsRC);
            var jobJW = jf.CreateDrinkByIngredients(0, ingredientsJW);


            var jc = new JobCoordinator();

            jc.AddJob(jobW);
            jc.AddJob(jobR);
            jc.AddJob(jobJW);


            var controller = new DrinkRobotController(jc, _inventory, new WorldPositions(), RobotSend);

            controller.RunJobs();
        }
Example #2
0
        public IScheduler CreateScheduler()
        {
            Func <DateTime> now = () => DateTime.Now;

            var eventStream                = new EventStream(_eventSinks, _exceptionLogger, now);
            var recoverableAction          = new RecoverableAction(this, eventStream);
            var delegatingPersistenceStore = new DelegatingPersistenceStore(_persistenceProvider);
            var jobMutation                = new JobMutator(eventStream, delegatingPersistenceStore);

            var queueConfiguration = new JobQueueFactory(
                delegatingPersistenceStore, this, eventStream, recoverableAction, jobMutation).Create();

            var router       = new JobRouter(queueConfiguration);
            var methodBinder = new MethodBinder();

            var continuationDispatcher = new ContinuationDispatcher(router, jobMutation,
                                                                    delegatingPersistenceStore, recoverableAction);
            var activityToContinuationConverter = new ActivityToContinuationConverter(now);

            var runningTransition = new RunningTransition(jobMutation);
            var failedTransition  = new FailedTransition(this, jobMutation, now);
            var endTransition     = new EndTransition(delegatingPersistenceStore, jobMutation,
                                                      continuationDispatcher);

            var continuationLiveness = new ContinuationLiveness(delegatingPersistenceStore, continuationDispatcher);

            var coordinator = new JobCoordinator(eventStream, recoverableAction);

            var waitingForChildrenTransition = new WaitingForChildrenTransition(
                delegatingPersistenceStore,
                continuationDispatcher,
                activityToContinuationConverter,
                recoverableAction,
                jobMutation);

            var changeState = new StatusChanger(eventStream, runningTransition, failedTransition,
                                                endTransition, waitingForChildrenTransition, jobMutation);

            var failedJobQueue = new FailedJobQueue(this, delegatingPersistenceStore, now, eventStream, router);

            var errorHandlingPolicy = new ErrorHandlingPolicy(this, coordinator, changeState,
                                                              failedJobQueue, recoverableAction);

            var exceptionFilterDispatcher = new ExceptionFilterDispatcher(eventStream);

            var jobDispatcher = new Dispatcher.Dispatcher(_dependencyResolver,
                                                          coordinator,
                                                          errorHandlingPolicy,
                                                          methodBinder,
                                                          eventStream,
                                                          recoverableAction,
                                                          changeState,
                                                          continuationLiveness,
                                                          exceptionFilterDispatcher);

            var jobPumps =
                queueConfiguration
                .ActivitySpecificQueues
                .Values
                .Select(q => new JobPump(jobDispatcher, eventStream, q))
                .ToList();

            jobPumps.Add(new JobPump(jobDispatcher, eventStream, queueConfiguration.Default));

            return(new Scheduler(
                       queueConfiguration,
                       this,
                       delegatingPersistenceStore,
                       now,
                       failedJobQueue,
                       recoverableAction,
                       router,
                       activityToContinuationConverter,
                       jobPumps,
                       jobMutation));
        }