Exemplo n.º 1
0
        /// <summary>
        /// Rebuilds the CohortCompiler diagram which shows all the currently configured tasks
        /// </summary>
        /// <param name="cancelTasks"></param>
        private void RecreateAllTasks(bool cancelTasks = true)
        {
            if (cancelTasks)
            {
                Compiler.CancelAllTasks(false);
            }

            tlvConfiguration.ClearObjects();

            tlvConfiguration.Enabled = true;

            _cic.CreateRootContainerIfNotExists();
            //if there is no root container,create one
            _root    = _cic.RootCohortAggregateContainer;
            _globals = _cic.GetAllParameters();

            //Could have configured/unconfigured a joinable state
            foreach (var j in Compiler.Tasks.Keys.OfType <JoinableTask>())
            {
                j.RefreshIsUsedState();
            }

            try
            {
                tlvConfiguration.AddObject(new CohortIdentificationHeader());
                tlvConfiguration.AddObject(new JoinableCollectionNode(_cic, _cic.GetAllJoinables()));
                tlvConfiguration.ExpandAll();
            }
            catch (Exception e)
            {
                tlvConfiguration.Enabled = false;
                ExceptionViewer.Show("Failed to populate tree of Tasks", e);
            }
        }
Exemplo n.º 2
0
        public ICompileable Run(CancellationToken token)
        {
            try
            {
                var globals = _cic.GetAllParameters();

                //clear compiler list
                Compiler.CancelAllTasks(true);

                SetPhase(Phase.RunningJoinableTasks);

                Parallel.ForEach(_cic.GetAllJoinables(), (j) => Compiler.AddTask(j, globals));

                Compiler.CancelAllTasks(false);

                RunAsync(Compiler.Tasks.Keys.Where(c => c is JoinableTask && c.State == CompilationState.NotScheduled), token);

                SetPhase(Phase.CachingJoinableTasks);

                CacheAsync(Compiler.Tasks.Keys.OfType <JoinableTask>().Where(c => c.State == CompilationState.Finished && c.IsCacheableWhenFinished()), token);

                SetPhase(Phase.RunningAggregateTasks);

                // Add all aggregates
                Parallel.ForEach(_cic.RootCohortAggregateContainer.GetAllAggregateConfigurationsRecursively(), (c) => Compiler.AddTask(c, globals));

                Compiler.CancelAllTasks(false);

                RunAsync(Compiler.Tasks.Keys.Where(c => c is AggregationTask && c.IsEnabled() && c.State == CompilationState.NotScheduled), token);

                SetPhase(Phase.CachingAggregateTasks);

                CacheAsync(Compiler.Tasks.Keys.OfType <AggregationTask>().Where(c => c.State == CompilationState.Finished && c.IsCacheableWhenFinished()), token);

                SetPhase(Phase.RunningFinalTotals);

                var toReturn = Compiler.AddTask(_cic.RootCohortAggregateContainer, globals);

                if (RunSubcontainers)
                {
                    Parallel.ForEach(
                        _cic.RootCohortAggregateContainer.GetAllSubContainersRecursively().Where(c => !c.IsDisabled),
                        (a) => Compiler.AddTask(a, globals));
                }


                Compiler.CancelAllTasks(false);

                RunAsync(Compiler.Tasks.Keys.Where(c => c.State == CompilationState.NotScheduled && c.IsEnabled()), token);

                SetPhase(Phase.Finished);

                return(toReturn);
            }
            catch (OperationCanceledException)
            {
                SetPhase(Phase.None);
                return(null);
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Adds all subqueries and containers that are below the current CohortIdentificationConfiguration as tasks to the compiler
        /// </summary>
        /// <param name="addSubcontainerTasks">The root container is always added to the task list but you could skip subcontainer totals if all you care about is the final total for the cohort
        /// and you don't have a dependant UI etc.  Passing false will add all joinables, subqueries etc and the root container (final answer for who is in cohort) only.</param>
        /// <returns></returns>
        public List <ICompileable> AddAllTasks(bool addSubcontainerTasks = true)
        {
            var toReturn = new List <ICompileable>();
            var globals  = CohortIdentificationConfiguration.GetAllParameters();

            CohortIdentificationConfiguration.CreateRootContainerIfNotExists();

            foreach (var joinable in CohortIdentificationConfiguration.GetAllJoinables())
            {
                toReturn.Add(AddTask(joinable, globals));
            }

            toReturn.AddRange(AddTasksRecursively(globals, CohortIdentificationConfiguration.RootCohortAggregateContainer, addSubcontainerTasks));

            return(toReturn);
        }
        /// <summary>
        /// Rebuilds the CohortCompiler diagram which shows all the currently configured tasks
        /// </summary>
        /// <param name="cancelTasks"></param>
        private void RecreateAllTasks(bool cancelTasks = true)
        {
            if (cancelTasks)
            {
                Compiler.CancelAllTasks(false);
            }

            _configuration.CreateRootContainerIfNotExists();
            //if there is no root container,create one
            _root    = _configuration.RootCohortAggregateContainer;
            _globals = _configuration.GetAllParameters();

            //Could have configured/unconfigured a joinable state
            foreach (var j in Compiler.Tasks.Keys.OfType <JoinableTask>())
            {
                j.RefreshIsUsedState();
            }
        }
Exemplo n.º 5
0
        public CohortQueryBuilder(CohortIdentificationConfiguration configuration, ICoreChildProvider childProvider) : this(configuration.GetAllParameters(), childProvider)
        {
            if (configuration == null)
            {
                throw new QueryBuildingException("Configuration has not been set yet");
            }

            if (configuration.RootCohortAggregateContainer_ID == null)
            {
                throw new QueryBuildingException("Root container not set on CohortIdentificationConfiguration " + configuration);
            }

            if (configuration.QueryCachingServer_ID != null)
            {
                CacheServer = configuration.QueryCachingServer;
            }

            //set ourselves up to run with the root container
            container = configuration.RootCohortAggregateContainer;

            SetChildProviderIfNull();
        }
Exemplo n.º 6
0
        private ICompileable RunRootContainerOnlyNoCaching(CohortCompiler cohortCompiler)
        {
            //add root container task
            var task = cohortCompiler.AddTask(_cohortIdentificationConfiguration.RootCohortAggregateContainer, _cohortIdentificationConfiguration.GetAllParameters());

            cohortCompiler.LaunchSingleTask(task, Timeout, false);

            //timeout is in seconds
            int countDown = Math.Max(5000, Timeout * 1000);

            while (
                //hasn't timed out
                countDown > 0 &&
                (
                    //state isn't a final state
                    task.State == CompilationState.Executing || task.State == CompilationState.NotScheduled || task.State == CompilationState.Scheduled)
                )
            {
                Task.Delay(100).Wait();
                countDown -= 100;
            }


            if (countDown <= 0)
            {
                try
                {
                    throw new Exception("Cohort failed to reach a final state (Finished/Crashed) after " + Timeout + " seconds. Current state is " + task.State + ".  The task will be cancelled");
                }
                finally
                {
                    cohortCompiler.CancelAllTasks(true);
                }
            }

            return(task);
        }