Пример #1
0
        public Bootstrapper(ILogger <Bootstrapper> logger, IEnumerable <IInitializer> initializers, IInitializersValidator validator, IProcessConstructor builder)
        {
            Logger = logger ?? throw new ArgumentNullException(nameof(logger));
            var immutableInitializers = initializers?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(initializers));

            if (validator == null)
            {
                throw new ArgumentNullException(nameof(validator));
            }

            if (builder == null)
            {
                throw new ArgumentNullException(nameof(builder));
            }

            var result = validator.Validate(immutableInitializers);

            if (!result.IsValid)
            {
                throw new ValidationException(result);
            }

            AdditionalTime = TimeSpan.FromSeconds(5);

            StartProcess = new Lazy <IProcess>(() => builder.BuildStartupProcess(immutableInitializers));
            StopProcess  = new Lazy <IProcess>(() => builder.BuildShutdownProcess(immutableInitializers));
        }
        private IProcess BuildProcess(IReadOnlyCollection <IInitializer> initializers, InitializerExtractor extractor)
        {
            var result = _validator.Validate(initializers);

            if (!result.IsValid)
            {
                throw new ValidationException(result);
            }

            var firstInitializer      = initializers.SingleOrDefault(x => extractor.WhereModeEquals(x, RunModes.First));
            var lastInitializer       = initializers.SingleOrDefault(x => extractor.WhereModeEquals(x, RunModes.Last));
            var beginningInitializers = initializers.Where(x => extractor.WhereModeEquals(x, RunModes.Beginning)).ToArray();
            var endingInitializers    = initializers.Where(x => extractor.WhereModeEquals(x, RunModes.Ending)).ToArray();

            var mainProcess = new SequentialProcess();

            if (firstInitializer != null)
            {
                mainProcess.Add(extractor.AsSingleProcess(firstInitializer));
            }

            var sequence = BuildSequence(beginningInitializers, extractor);

            if (sequence != null)
            {
                mainProcess.Add(sequence);
            }

            sequence = BuildSequence(endingInitializers, extractor);
            if (sequence != null)
            {
                mainProcess.Add(sequence);
            }

            if (lastInitializer != null)
            {
                mainProcess.Add(extractor.AsSingleProcess(lastInitializer));
            }

            var optimizedProcess = _optimizer.OptimizeProcess(mainProcess);

            return(optimizedProcess);
        }