Ejemplo n.º 1
0
        /// <summary>
        /// Find and block any module whose prerequisites for operation are not present.  This minimises the damage caused by
        /// inconsistent module configuration.  Sets up the ModuleSequence property with the operating modules.
        /// </summary>
        public void ValidateModules()
        {
            foreach (Module module in Modules.Values)
            {
                if (module.DependentOn.Any(mn => !Modules.Keys.Any(k => k.StartsWith(mn) && k != module.Name)))
                {
                    module.Blocked = true;
                    log.ErrorFormat("Module {0} blocked, missing module it depends on", module.Name);
                    module.Error = "Missing module depended on: " + module.Name;
                }
                else if (module.IncompatibleWith.Any(mn => Modules.Keys.Any(k => k.StartsWith(mn) && k != module.Name)))
                {
                    module.Blocked = true;
                    log.ErrorFormat("Module {0} blocked, incompatible module exists", module.Name);
                    module.Error = "Incompatible module exists: " + module.Name;
                }
            }
            var moduleDict    = Modules.Values.Where(m => !m.Blocked).ToDictionary(m => m.Name, m => m);
            var sortedModules = new ConstraintOrderedCollection <Module>(m => m.Name);

            moduleDict.Values
            .Do(m => sortedModules.Add(m, new OrderConstraint(m.Name, m.MustFollow, m.MustPrecede)));
            this.Modules        = moduleDict;
            this.ModuleSequence = sortedModules;
        }
        /// <summary>
        /// Copy a ConstraintOrderedCollection with all its constraints
        /// </summary>
        /// <returns>The copied ConstraintOrderedCollection</returns>
        public ConstraintOrderedCollection <T> Copy()
        {
            var coc = new ConstraintOrderedCollection <T>(this.nameSelector);

            coc.innerList.AddRange(this.innerList);
            coc.orderConstraint.AddAnd(this.orderConstraint);
            return(coc);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Register a function to process event data on raising of an event elsewhere ensuring specified processes on which it
        /// is dependent are performed first
        /// </summary>
        /// <param name="eventName">The name of the event being raised</param>
        /// <param name="processor">A delegate which takes the current event data and the sender and returns the processed event data</param>
        /// <param name="moduleId">The name of the module. This can be moduletype.module</param>
        /// <param name="constraint">An order constraint specifying restrictions on the relative position of this processor in any chain of processors</param>
        public void RegisterEventProcessor(
            string eventName,
            Func <EventHubData, object> processor,
            string moduleId,
            OrderConstraint constraint)
        {
            var newProcessor = new ProcessorInfo
            {
                EventName = eventName,
                ModuleId  = moduleId,
                Processor = processor
            };

            // register processor on all processor queues where event is or covers a subset of this event
            var  subEvents = Processors.Keys.Where(k => k.StartsWith(eventName)).ToList();
            bool matched   = false;

            foreach (string subEvent in subEvents)
            {
                if (Processors[subEvent].Any(p => p.ModuleId == newProcessor.ModuleId))
                {
                    throw new Exception("Trying to add more than 1 processor for module " + newProcessor.ModuleId + " to event queue " + subEvent);
                }
                Processors[subEvent].Add(newProcessor, constraint);
                matched = (subEvent == eventName);
            }

            // if not regstered anywhere, create a new processor queue containing the processes from the least super event of this one
            if (!matched)
            {
                var leastSuperEvent = LeastSuperEvent(eventName);

                var pList = new ConstraintOrderedCollection <ProcessorInfo>(pi => pi.ModuleId);
                if (leastSuperEvent != null)
                {
                    pList = Processors[leastSuperEvent].Copy();
                }

                pList.Add(newProcessor, constraint);

                Processors.Add(eventName, pList);
            }
        }