FCCLite/Edge.Core/Processor/Dispatcher/DefaultDispatcher.cs

using AutoMapper;
using Edge.Core.Configuration;
using Edge.Core.Database.Configuration.Models;
using Edge.Core.Processor.Communicator;
using Edge.Core.Processor.Dispatcher.Attributes;
using Edge.Core.UniversalApi;
using Edge.Core.UniversalApi.CommunicationProvider;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Newtonsoft.Json.Schema;
using Newtonsoft.Json.Schema.Generation;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Loader;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Edge.Core.Processor.Dispatcher
{
    [UniversalApi(Name = DefaultDispatcher.OnProcessorsLifeCycleChangedEventApiName,
        EventDataType = typeof(OnProcessorsLifeCycleChangedEventArg),
        Description = "When life cycle of processors are changed, an event will fired with details for each processor.")]
    [UniversalApi(Name = GenericAlarm.UniversalApiEventName, EventDataType = typeof(object), Description = "Fire GenericAlarm which mostly used in Alarm UI Bar for attracting users.")]
    [MetaPartsDescriptor("DefaultDispatcher", "Processors' life cycle manager.",
        new[] { "Managment" },
        IsSystemInternalComponent = true)]
    public partial class DefaultDispatcher : IAppProcessor
    {
        public const string OnProcessorsLifeCycleChangedEventApiName = "OnProcessorsLifeCycleChanged";
        private List<OnProcessorsLifeCycleChangedEventArg> historyProcessorsLifeCycleChangedEvents
            = new List<OnProcessorsLifeCycleChangedEventArg>();
        public event EventHandler<OnProcessorsInstantiatedEventArg> OnProcessorInstantiated;

        /// <summary>
        /// latest instantiated processor result.
        /// </summary>
        private IEnumerable<ProcessorInstanceOperatingResult> currentProcessorInstantiatedOperatingResults;
        //public static EventHandler OnRequestDispatch;
        protected IServiceProvider services;
        protected static ILogger mainLogger = NullLogger.Instance;

        public string MetaConfigName { get; set; } = "ProcessorsDispatcher";
        public static string DefaultClientAcceptLanguage = "zh-cn";
        static DefaultDispatcher()
        {
            // replace with your license key, https://www.newtonsoft.com/jsonschema
            string licenseKey = "4278-fsXeHk11Z1h23Ki2z21y8tDMv43+eMW7Gcnv6caaGWz6w8Q4xrsg/Ow/moZc6GrkgjCaiq33yzr/meweRwNrPHsfqTc1rgpJu385YKKqMbJ5UKUDV1csm5ZwpMBIc1JJDbQwVZuDqUyOFqLZ31uk+10j9i8uMTPGEzLI729edmx7IklkIjo0Mjc4LCJFeHBpcnlEYXRlIjoiMjAyMS0wNy0wNFQwNjoxMjozMC43Mzc1NTE1WiIsIlR5cGUiOiJKc29uU2NoZW1hQnVzaW5lc3MifQ==";
            License.RegisterLicense(licenseKey);
            //AppDomain.CurrentDomain.TypeResolve += (s, args) =>
            //{
            //    var type = ObjectInstanceCreator.DefaultSearchLocalAssemblyFileTypeResolver(args.Name);
            //    return type?.Assembly;
            //};
            //AppDomain.CurrentDomain.AssemblyResolve += (s, args) =>
            //{
            //    return ObjectInstanceCreator.DefaultSearchLocalAssemblyFileAssemblyResolver(args.Name);
            //};
        }

        public DefaultDispatcher(IServiceProvider services)
        {
            this.services = services;
            var loggerFactory = services.GetRequiredService<ILoggerFactory>();
            mainLogger = loggerFactory.CreateLogger("Main");
            ObjectInstanceCreator.mainLogger = mainLogger;
            mainLogger.LogInformation("AppDomain.CurrentDomain.CurrentDomainAssemblies: " +
               ObjectInstanceCreator.CurrentDomainAssemblies?.Select(ass => ass.FullName + "      " + (!ass.IsDynamic ? ass.Location ?? "" : "")).OrderBy(o => o)
                   .Aggregate(Environment.NewLine, (acc, n) => acc + n + Environment.NewLine) ?? "");
            //route this special event into this processor rather than from different processors to form an unified api entrance.
            //this.services.GetRequiredService<UniversalApiHub>().OnUniversalGenericAlarmEventFired += async (s, a) =>
            //{
            //    await this.services.GetRequiredService<UniversalApiHub>().FireEvent(this,
            //        GenericAlarm.UniversalApiEventName, new
            //        {
            //            Title = a.GenericAlarm.Title.LocalizedContent(DefaultClientAcceptLanguage),
            //            Category = a.GenericAlarm.Category?.LocalizedContent(DefaultClientAcceptLanguage),
            //            SubCategory = a.GenericAlarm.SubCategory?.LocalizedContent(DefaultClientAcceptLanguage),
            //            Detail = a.GenericAlarm.Detail?.LocalizedContent(DefaultClientAcceptLanguage),
            //            a.GenericAlarm.Severity,
            //            a.PersistId
            //        });
            //};
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="reason"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<ProcessorInstanceOperatingResult>> CreateProcessorsAsync(string reason, bool enableSafeBoot = false)
        {
            var processorLoader = this.services.GetRequiredService<IProcessorLoader>();
            var defaultDispatcherProcessorInstanceOperatingResult = new ProcessorInstanceOperatingResult()
            {
                Succeed = true,
                ProcessorInstance = this,
                //for this special AppProcessor as it's included in Edge.Core, so both version are the same
                HostVersion = Assembly.GetAssembly(this.GetType()).GetName().Version.ToString(),
                CoreVersion = Assembly.GetAssembly(this.GetType()).GetName().Version.ToString(),
            };
            if (enableSafeBoot)
                this.currentProcessorInstantiatedOperatingResults = new[] { defaultDispatcherProcessorInstanceOperatingResult };
            else
                this.currentProcessorInstantiatedOperatingResults =
                    new[] { defaultDispatcherProcessorInstanceOperatingResult }.Concat(processorLoader.CreateAll()).ToList();

            this.OnProcessorInstantiated?.Invoke(this, new OnProcessorsInstantiatedEventArg(this.currentProcessorInstantiatedOperatingResults));
            var createEvtArg = new OnProcessorsLifeCycleChangedEventArg(
                this.currentProcessorInstantiatedOperatingResults.Select(i => ProcessorLifeCycleOperationResult.From(i)).ToList(),
                "ProcessorsInstantiate",
                reason);
            this.historyProcessorsLifeCycleChangedEvents.Add(createEvtArg);
            return this.currentProcessorInstantiatedOperatingResults;
        }

        public virtual async Task<IEnumerable<ProcessorInstanceOperatingResult>> StartProcessorsAsync(
            IEnumerable<IProcessor> processorInstances, string reason)
        {
            //App will call Init(...) before Start()
            var initOrStartResults = new List<ProcessorInstanceOperatingResult>();

            mainLogger.LogInformation("==============Start Processors (total: " + processorInstances.Count() + ")==============");
            Console.WriteLine();
            Console.WriteLine("==============Start Processors (total: " + processorInstances.Count() + ")==============");

            var pendingForStartInstances = processorInstances.ToList();

            // call App.Init(...), and only succeed ones will call its Start() later.
            processorInstances.OfType<IAppProcessor>().ToList().ForEach(app =>
            {
                try
                {
                    app.Init(processorInstances);
                }
                catch (Exception eee)
                {
                    //remove it for avoid call Start()
                    pendingForStartInstances.Remove(app);
                    initOrStartResults.Add(new ProcessorInstanceOperatingResult()
                    {
                        //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                        ProcessorInstance = app,
                        Succeed = false,
                        FailedReason = "Call App.Init(...) exceptioned: " + eee.ToString(),
                        //Description = $"Ordinary start a processor but failed with an unexpected fatal error",
                    });
                    mainLogger.LogError("Initing [" + (app.MetaConfigName ?? "") + "] failed and will skip its Start: " + eee.ToString());
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.WriteLine("Initing [" + (app.MetaConfigName ?? "") + "] failed: " + Environment.NewLine + "   " + eee.ToString().Substring(0, 70) + "...");
                    Console.ResetColor();
                }
            });
            for (int i = 0; i < pendingForStartInstances.Count(); i++)
            {
                var p = pendingForStartInstances.ElementAt(i);
                try
                {
                    mainLogger.LogInformation("Starting [" + (p.MetaConfigName ?? "") + "]: ");
                    Console.WriteLine("Starting [" + (p.MetaConfigName ?? "") + "]: ");
                    bool r = await p.Start();
                    if (r)
                    {
                        initOrStartResults.Add(new ProcessorInstanceOperatingResult()
                        {
                            //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                            ProcessorInstance = p,
                            Succeed = true,
                            //Description = $"Ordinary start a processor and succeed.",
                        });
                        mainLogger.LogInformation("   Started");
                        Console.WriteLine("   Started");
                    }
                    else
                    {
                        initOrStartResults.Add(new ProcessorInstanceOperatingResult()
                        {
                            //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                            ProcessorInstance = p,
                            Succeed = false,
                            //Description = $"Ordinary start a processor but failed with a graceful reason",
                        });
                        mainLogger.LogInformation("   Failed for starting");
                        Console.BackgroundColor = ConsoleColor.Red;
                        Console.ForegroundColor = ConsoleColor.Black;
                        Console.WriteLine("   !!!Failed for starting!!!");
                        Console.ResetColor();
                    }
                }
                catch (Exception eee)
                {
                    initOrStartResults.Add(new ProcessorInstanceOperatingResult()
                    {
                        //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                        ProcessorInstance = p,
                        Succeed = false,
                        FailedReason = eee.ToString(),
                        //Description = $"Ordinary start a processor but failed with an unexpected fatal error",
                    });
                    mainLogger.LogError(" - Failed for start: [" + p.MetaConfigName + "]" + Environment.NewLine + "   " + eee.ToString());
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.WriteLine(" - Failed for start: [" + p.MetaConfigName + "]" + Environment.NewLine + "   " + eee.ToString().Substring(0, 70) + "...");
                    Console.ResetColor();
                }
            }

            mainLogger.LogInformation("==============Start Processors End==============\r\n");
            Console.WriteLine("==============Start Processors End==============\r\n");

            var startEvtArg = new OnProcessorsLifeCycleChangedEventArg(
                initOrStartResults.Select(i => ProcessorLifeCycleOperationResult.From(i)).ToList(),
                "ProcessorsStart",
                reason);
            //var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
            //await universalApiHub.FireEvent(this, DefaultDispatcher.OnProcessorsLifeCycleChangedEventApiName, startEvtArg);
            this.historyProcessorsLifeCycleChangedEvents.Add(startEvtArg);
            return initOrStartResults;
        }

        /// <summary>
        /// Call Stop() on target processors, and correlated life cycle operation results will be recorded.
        /// </summary>
        /// <param name="processors"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<ProcessorInstanceOperatingResult>> StopProcessorsAsync(
            IEnumerable<IProcessor> processors, string reason)
        {
            if (processors == null || !processors.Any()) return Enumerable.Empty<ProcessorInstanceOperatingResult>();

            var stopResults = new List<ProcessorInstanceOperatingResult>();
            foreach (var p in processors)
            {
                try
                {
                    Console.WriteLine("     stopping " + p.MetaConfigName + "..." + " by reason: " + (reason ?? ""));
                    mainLogger.LogInformation("     stopping " + p.MetaConfigName + " by reason: " + (reason ?? ""));
                    bool r = await p.Stop();
                    if (r)
                    {
                        stopResults.Add(new ProcessorInstanceOperatingResult()
                        {
                            //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                            //ProcessorMetaConfigName = p.MetaConfigName,
                            ProcessorInstance = p,
                            Succeed = true,
                            //Description = $"Ordinary stop a processor and succeed.",
                        });

                        Console.WriteLine("         Stopped");
                        mainLogger.LogInformation("         Stopped");
                    }
                    else
                    {
                        stopResults.Add(new ProcessorInstanceOperatingResult()
                        {
                            //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                            //ProcessorMetaConfigName = p.MetaConfigName,
                            ProcessorInstance = p,
                            Succeed = false,
                            //Description = $"Ordinary stop a processor but failed with a graceful reason",
                        });
                    }
                }
                catch (Exception xxxx)
                {
                    stopResults.Add(new ProcessorInstanceOperatingResult()
                    {
                        //WhatThisProcessorUsedFor = p.ProcessorDescriptor().DeviceHandlerOrApp.GetType().GetCustomAttributes<MetaPartsDescriptor>()?.FirstOrDefault()?.Description,
                        //ProcessorMetaConfigName = p.MetaConfigName,
                        Succeed = false,
                        FailedReason = xxxx.ToString(),
                        //Description = $"Ordinary stop a processor but failed with an unexpected fatal error",
                    });
                    Console.BackgroundColor = ConsoleColor.Red;
                    Console.ForegroundColor = ConsoleColor.Black;
                    Console.WriteLine("         stopping " + p.MetaConfigName + " failed.");
                    Console.ResetColor();
                    mainLogger.LogInformation("         stopping " + p.MetaConfigName + " failed: "
                        + Environment.NewLine
                        + xxxx);
                }
            }

            var stopEvtArg = new OnProcessorsLifeCycleChangedEventArg(
                stopResults.Select(i => ProcessorLifeCycleOperationResult.From(i)).ToList(),
                "ProcessorsStop",
                reason);
            this.historyProcessorsLifeCycleChangedEvents.Add(stopEvtArg);
            var universalApiHub = this.services.GetRequiredService<UniversalApiHub>();
            await universalApiHub.FireEvent(this, DefaultDispatcher.OnProcessorsLifeCycleChangedEventApiName,
                stopEvtArg);
            return stopResults;
        }

        [UniversalApi(Description = "Get history datas for Processors' LifeCycle Changed Event")]
        public Task<List<OnProcessorsLifeCycleChangedEventArg>> GetHistoryProcessorsLifeCycleChangedEvents()
        {
            return Task.FromResult(this.historyProcessorsLifeCycleChangedEvents);
        }

        [UniversalApi]
        public async Task<ProcessorMetaConfig> UpsertProcessorMetaConfigAsync(ProcessorMetaConfig input)
        {
            var accessor = this.services.GetService<IProcessorMetaConfigAccessor>();
            if (accessor == null) throw new NotSupportedException("Could not find ProcessorMetaConfigAccessor, may current ProcessorLoader does not support the MetaConfig Upsert???");
            return await accessor.UpsertMetaConfigAsync(input);
        }

        [UniversalApi(Description = "Get all ProcessorMetaConfigs with endPointFullTypeStr qualified with input parameter, or leave null or empty to get all")]
        public async Task<IEnumerable<ProcessorMetaConfig>> GetProcessorMetaConfigAsync(string sourceEndpointFullTypeStr)
        {
            var accessor = this.services.GetService<IProcessorMetaConfigAccessor>();
            if (accessor == null) throw new NotSupportedException("Could not find ProcessorMetaConfigAccessor, may current ProcessorLoader does not support the MetaConfig Get???");
            return await accessor.GetMetaConfigAsync(sourceEndpointFullTypeStr);
        }

        [UniversalApi(InputParametersExampleJson = "[121]", Description = "Remove a ProcessorMetaConfig and all its MetaPartsConfigs")]
        public async Task<bool> RemoveProcessorMetaConfigAsync(int metaConfigId)
        {
            var accessor = this.services.GetService<IProcessorMetaConfigAccessor>();
            if (accessor == null) throw new NotSupportedException("Could not find ProcessorMetaConfigAccessor, may current ProcessorLoader does not support the MetaConfig Remove???");
            return await accessor.RemoveMetaConfigAsync(metaConfigId);
        }

        [UniversalApi(InputParametersExampleJson = "[\"wayne dart pump configuration 1\"]",
            Description = "Test by constructing a Processor instance on the air from specified metaConfig, start, test and then stop it, any error will treat as test failed.")]
        public async Task<bool> TestProcessorMetaConfigAsync(string configName, string[] parameters)
        {
            var processorLoader = this.services.GetRequiredService<IProcessorLoader>();
            IProcessor p = null;
            try
            {
                p = processorLoader.Create(configName);
                if (p == null) throw new InvalidOperationException($"Test failed on constructing processor.");//: {p.MetaConfigName}");

                var startResult = false;
                try
                {
                    startResult = await p.Start();
                    if (!startResult)
                        throw new InvalidOperationException($"Test failed on starting processor.");
                    await p.Test(parameters);
                }
                catch (Exception eee)
                {
                    throw;// new InvalidOperationException($"Test failed on pre-starting processor with error: {eee}");
                }
            }
            finally
            {
                if (p != null)
                {
                    var stopResult = false;
                    try
                    {
                        stopResult = await p.Stop();
                    }
                    catch (Exception eee)
                    {
                        throw;// new InvalidOperationException($"Test failed on pre-stop processor with error: {eee}");
                    }

                    if (!stopResult)
                        throw new InvalidOperationException($"Test failed on stopping processor.");
                }
            }

            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="processorMetaPartsConfigId"></param>
        /// <returns>the original ParametersJsonArrayStr if no resolve method defined in target meta part type, or updated value by call the resolve method</returns>
        [UniversalApi]
        public async Task<string> ResolveProcessorMetaPartsConfigCompatibilityAsync(int processorMetaPartsConfigId)
        {
            var accessor = this.services.GetService<IProcessorMetaConfigAccessor>();
            if (accessor == null) throw new NotSupportedException("Could not find ProcessorMetaConfigAccessor, may current ProcessorLoader does not support the MetaConfig Get???");
            var allMetaConfigs = await accessor.GetMetaConfigAsync();
            var targetMetaPartsInfo = allMetaConfigs.SelectMany(mc => mc.Parts,
                    (metaConfig, metaPartsConfig) => new { metaConfig, metaPartsConfig })
                .FirstOrDefault(p => p.metaPartsConfig.Id == processorMetaPartsConfigId);
            if (targetMetaPartsInfo == null) throw new ArgumentException("Could not find processorMetaPartsConfig with id: " + processorMetaPartsConfigId);

            if (targetMetaPartsInfo.metaPartsConfig.TryCallMetaPartsConfigCompatibilityMethodAndUpdate())
            {
                //targetMetaPartsInfo.metaConfig.Parts.First(p => p.Id == targetMetaPartsInfo.metaPartsConfig.Id)
                //    .ParametersJsonArrayStr = reformatParamsStr;
                //await accessor.UpsertMetaConfigAsync(targetMetaPartsInfo.metaConfig);
            }

            return targetMetaPartsInfo.metaPartsConfig.ParametersJsonArrayStr;
        }

        [UniversalApi(Description = "Stop all exist non-system processors, and re-instantiate, re-start them again")]
        public async Task<IEnumerable<ProcessorLifeCycleOperationResult>> ReloadProcessorsAsync(string reason = "")
        {
            try
            {
                mainLogger.LogInformation($"Stop Non-System Processors is on requesting by reason: {reason}");
                Console.BackgroundColor = ConsoleColor.Yellow;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + $"=====>Stop All Processors is on requesting by reason: {reason}");
                Console.ResetColor();
                var stopResults = await this.StopProcessorsAsync(
                    this.currentProcessorInstantiatedOperatingResults.Where(r => r.ProcessorInstance != null)
                        .Select(r => r.ProcessorInstance).Except(new[] { this }),
                    reason);
                mainLogger.LogInformation("     Stop Non-System Processors done successfully");
                Console.BackgroundColor = ConsoleColor.Green;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "<=====Stop All Processors done successfully");
                Console.ResetColor();
                //return stopResults;
            }
            catch (Exception exx)
            {
                mainLogger.LogError("******Stop Non-System Processors got internal error!\r\n" + exx.ToString());
                Console.BackgroundColor = ConsoleColor.Red;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "******Stop All Processors got internal error: " + exx.ToString().Substring(0, 70) + "...");
                Console.ResetColor();
                throw;
            }

            try
            {
                mainLogger.LogInformation($"Create All Processors is on requesting by reason: {reason}");
                Console.BackgroundColor = ConsoleColor.Yellow;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + $"=====>Create All Processors is on requesting by reason: {reason}");
                Console.ResetColor();
                var createResults = await this.CreateProcessorsAsync(reason);

                mainLogger.LogInformation("     Create All Processors done successfully");
                Console.BackgroundColor = ConsoleColor.Green;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "<=====Create All Processors done successfully");
                Console.ResetColor();
                //return createResults;
            }
            catch (Exception exx)
            {
                mainLogger.LogError("******Create All Processors got internal error!\r\n" + exx.ToString());
                Console.BackgroundColor = ConsoleColor.Red;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "******Create All Processors got internal error: " + exx.ToString().Substring(0, 70) + "...");
                Console.ResetColor();
                throw;
            }

            try
            {
                mainLogger.LogInformation($"Start All Processors is on requesting by reason: {reason}");
                Console.BackgroundColor = ConsoleColor.Yellow;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + $"=====>Start All Processors is on requesting by reason: {reason}");
                Console.ResetColor();
                var startResults = await this.StartProcessorsAsync(
                    this.currentProcessorInstantiatedOperatingResults.Where(r => r.Succeed).Select(r => r.ProcessorInstance),
                    reason);

                mainLogger.LogInformation("     Start All Processors done successfully");
                Console.BackgroundColor = ConsoleColor.Green;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "<=====Start All Processors done successfully");
                Console.ResetColor();
                return startResults.Select(r => ProcessorLifeCycleOperationResult.From(r));
            }
            catch (Exception exx)
            {
                mainLogger.LogError("******Start All Processors got internal error!\r\n" + exx.ToString());
                Console.BackgroundColor = ConsoleColor.Red;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff") + "******Start All Processors got internal error: " + exx.ToString().Substring(0, 70) + "...");
                Console.ResetColor();
                throw;
            }
        }



        /// <summary>
        /// 
        /// </summary>
        /// <param name="apiType">localmqtt, remotemqtt, webapi</param>
        /// <param name="tags"></param>
        /// <returns></returns>
        [UniversalApi(InputParametersExampleJson = "[\"localMqtt\",[\"Pump\",\"ATG\"]]")]
        public async Task<IEnumerable<UniversalApiInfoDoc>> ShowMeApi(string apiType, string[] tags)
        {
            var communicationProvider =
                this.services.GetService<UniversalApiHub>()?.CommunicationProviders?.Where(p => p.GetType().Name.Contains(apiType, StringComparison.OrdinalIgnoreCase))?.FirstOrDefault();
            if (communicationProvider == null)
                return Enumerable.Empty<UniversalApiInfoDoc>();
            return communicationProvider.GetApiDocuments().FilterByTags(tags);
        }

        public void Init(IEnumerable<IProcessor> processors)
        {
        }

        public async Task<bool> Start()
        {
            try
            {
                Console.WriteLine("      Setup Universal Api communicators...");
                await services.GetRequiredService<UniversalApiHub>()
                    .InitAsync(this.currentProcessorInstantiatedOperatingResults.Where(r => r.Succeed).Select(r => r.ProcessorInstance));
                Console.WriteLine("         Setup finished.");
            }
            catch (Exception exxx)
            {
                mainLogger.LogInformation("     Setup UniversalApiHub Failed: " + exxx);
                Console.BackgroundColor = ConsoleColor.Red;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine("     Setup UniversalApiHub Failed: " + exxx);
                Console.ResetColor();
                throw;
            }

            return true;
        }

        public Task<bool> Stop()
        {
            mainLogger.LogError("Stopping DefaultDispatcher processor...");
            Console.BackgroundColor = ConsoleColor.Red;
            Console.ForegroundColor = ConsoleColor.Black;
            Console.WriteLine("             FATAL, Stopping DefaultDispatcher will lose major functions...");
            Console.ResetColor();

            this.services.GetRequiredService<UniversalApiHub>().CommunicationProviders.ToList().ForEach(c => c.Dispose());
            return Task.FromResult(true);
        }
    }
}