Example #1
0
        public AntdNetwork2Module()
        {
            Get["/network2"] = x => {
                var physicalInterfaces = Network2Configuration.InterfacePhysical.ToList();
                var bridgeInterfaces   = Network2Configuration.InterfaceBridge.ToList();
                var bondInterfaces     = Network2Configuration.InterfaceBond.ToList();
                var virtualInterfaces  = Network2Configuration.InterfaceVirtual.ToList();
                foreach (var vif in virtualInterfaces)
                {
                    if (physicalInterfaces.Any(_ => _ == vif) ||
                        bridgeInterfaces.Any(_ => _ == vif) ||
                        bondInterfaces.Any(_ => _ == vif))
                    {
                        virtualInterfaces.Remove(vif);
                    }
                }
                var allifs = new List <string>();
                allifs.AddRange(physicalInterfaces);
                allifs.AddRange(bridgeInterfaces);
                allifs.AddRange(bondInterfaces);
                var model = new PageNetwork2Model {
                    PhysicalIf = physicalInterfaces,
                    BridgeIf   = bridgeInterfaces,
                    BondIf     = bondInterfaces,
                    VirtualIf  = virtualInterfaces,
                    AllIfs     = allifs, //new List <string> { "dev1", "dev2", "dev3" },
                    InterfaceConfigurationList = Network2Configuration.InterfaceConfigurationList,
                    GatewayConfigurationList   = Network2Configuration.GatewayConfigurationList,
                    RouteConfigurationList     = Network2Configuration.RouteConfigurationList,
                    DnsConfigurationList       = Network2Configuration.DnsConfigurationList,
                    Configuration = Network2Configuration.Conf.Interfaces,
                    NetworkHardwareConfigurationList = Network2Configuration.NetworkHardwareConfigurationList,
                    LagConfigurationList             = Network2Configuration.NetworkAggregatedInterfaceConfigurationList,
                    Variables = Host2Configuration.Host,
                    //ActiveDnsConfiguration = Network2Configuration.Conf.ActiveDnsConfiguration
                };
                return(JsonConvert.SerializeObject(model));
            };

            Post["/network2/restart"] = x => {
                new Do().NetworkChanges();
                return(HttpStatusCode.OK);
            };

            Post["/network2/interfaceconfiguration"] = x => {
                string id        = Request.Form.Id;
                string type      = Request.Form.Type;
                var    typedType = type?.ToEnum <NetworkInterfaceType>() ?? NetworkInterfaceType.Null;
                if (typedType == NetworkInterfaceType.Null)
                {
                    return(HttpStatusCode.InternalServerError);
                }
                var    index       = Network2Configuration.InterfaceConfigurationList.Count(_ => _.Type == typedType);
                string description = Request.Form.Description;
                var    typedVerb   = typedType == NetworkInterfaceType.Internal ? NetworkRoleVerb.iif : NetworkRoleVerb.eif;
                var    alias       = $"{typedVerb.ToString()}{index:D2}";
                string mode        = Request.Form.Mode;
                var    typedMode   = mode?.ToEnum <NetworkInterfaceMode>() ?? NetworkInterfaceMode.Dynamic;
                string ip          = Request.Form.Ip;
                string range       = Request.Form.Range;
                var    vars        = Host2Configuration.Host;

                var hostname = "";
                var subnet   = "";
                if (typedType == NetworkInterfaceType.Internal)
                {
                    hostname = $"{vars.HostName}{typedVerb.ToString()}.{vars.InternalDomainPrimary}";
                    subnet   = vars.InternalNetPrimaryBits;
                }
                if (typedType == NetworkInterfaceType.External)
                {
                    hostname = $"{vars.HostName}{typedVerb.ToString()}.{vars.ExternalDomainPrimary}";
                    subnet   = vars.ExternalNetPrimaryBits;
                }

                var broadcast = "";
                try {
                    broadcast = Cidr.CalcNetwork(ip, subnet).Broadcast.ToString();
                }
                catch (Exception ex) {
                    ConsoleLogger.Error(ex.Message);
                }

                var model = new NetworkInterfaceConfiguration {
                    Id          = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    Type        = typedType,
                    Hostname    = hostname,
                    Index       = index,
                    Description = description,
                    RoleVerb    = typedVerb,
                    Alias       = alias,
                    Mode        = typedMode,
                    Ip          = ip,
                    Range       = range,
                    Subnet      = subnet,
                    Broadcast   = broadcast
                };
                Network2Configuration.AddInterfaceConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/interfaceconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveInterfaceConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/gatewayconfiguration"] = x => {
                string id             = Request.Form.Id;
                string description    = Request.Form.Description;
                string gatewayAddress = Request.Form.GatewayAddress;
                string def            = Request.Form.Default;
                var    model          = new NetworkGatewayConfiguration {
                    Id             = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    Description    = description,
                    GatewayAddress = gatewayAddress,
                    IsDefault      = !string.IsNullOrEmpty(def) && Convert.ToBoolean(def)
                };
                Network2Configuration.AddGatewayConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/gatewayconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveGatewayConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/lagconfiguration"] = x => {
                string id       = Request.Form.Id;
                string parent   = Request.Form.Parent;
                string children = Request.Form.Children;
                var    model    = new NetworkAggregatedInterfaceConfiguration {
                    Id       = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    Parent   = parent,
                    Children = string.IsNullOrEmpty(children) ? new List <string>() : children.SplitToList()
                };
                Network2Configuration.AddAggregatedInterfaceConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/lagconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveAggregatedInterfaceConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/routeconfiguration"] = x => {
                string id               = Request.Form.Id;
                string destinationIp    = Request.Form.DestinationIp;
                string destinationRange = Request.Form.DestinationRange;
                string gateway          = Request.Form.Gateway;
                var    model            = new NetworkRouteConfiguration {
                    Id               = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    DestinationIp    = destinationIp,
                    DestinationRange = destinationRange,
                    Gateway          = gateway
                };
                Network2Configuration.AddRouteConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/routeconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveRouteConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/dnsconfiguration"] = x => {
                string id        = Request.Form.Id;
                string type      = Request.Form.Type;
                var    typedType = type?.ToEnum <DnsType>() ?? DnsType.Null;
                if (typedType == DnsType.Null)
                {
                    return(HttpStatusCode.InternalServerError);
                }
                string domain = Request.Form.Domain;
                string ip     = Request.Form.Ip;
                var    model  = new DnsConfiguration {
                    Id     = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    Type   = typedType,
                    Domain = domain,
                    Ip     = ip
                };
                Network2Configuration.AddDnsConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/dnsconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveDnsConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/dnsconfiguration/active"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.SetDnsConfigurationActive(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/nsupdateconfiguration"] = x => {
                string id           = Request.Form.Id;
                string serverName   = Request.Form.ServerName;
                string serverPort   = Request.Form.ServerPort;
                string localAddress = Request.Form.LocalAddress;
                string localPort    = Request.Form.LocalPort;
                string zoneName     = Request.Form.ZoneName;
                string className    = Request.Form.ClassName;
                string nxDomain     = Request.Form.NxDomain;
                string yxDomain     = Request.Form.YxDomain;
                string nxRrset      = Request.Form.NxRrset;
                string yxRrset      = Request.Form.YxRrset;
                string delete       = Request.Form.Delete;
                string add          = Request.Form.Add;
                var    model        = new NsUpdateConfiguration {
                    Id           = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    ServerName   = serverName,
                    ServerPort   = serverPort,
                    LocalAddress = localAddress,
                    LocalPort    = localPort,
                    ZoneName     = zoneName,
                    ClassName    = className,
                    NxDomain     = nxDomain,
                    YxDomain     = yxDomain,
                    NxRrset      = nxRrset,
                    YxRrset      = yxRrset,
                    Delete       = delete,
                    Add          = add
                };
                Network2Configuration.AddNsUpdateConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/nsupdateconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveNsUpdateConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            Post["/network2/hardwareconfiguration"] = x => {
                string id         = Request.Form.Id;
                string txqueuelen = Request.Form.Txqueuelen;
                string mtu        = Request.Form.Mtu;
                string macAddress = Request.Form.MacAddress;
                var    model      = new NetworkHardwareConfiguration()
                {
                    Id         = string.IsNullOrEmpty(id) ? Random.ShortGuid() : id,
                    Txqueuelen = txqueuelen,
                    Mtu        = mtu,
                    MacAddress = macAddress
                };
                Network2Configuration.AddNetworkHardwareConfiguration(model);
                return(HttpStatusCode.OK);
            };

            Post["/network2/hardwareconfiguration/del"] = x => {
                string guid = Request.Form.Guid;
                Network2Configuration.RemoveNetworkHardwareConfiguration(guid);
                return(HttpStatusCode.OK);
            };

            //Post["/network2/interface"] = x => {
            //    string dev = Request.Form.Device;
            //    string conf = Request.Form.Configuration;
            //    string confs = Request.Form.AdditionalConfigurations;
            //    string gwConf = Request.Form.GatewayConfiguration;
            //    string hwConf = Request.Form.HardwareConfiguration;
            //    string status = Request.Form.Status;
            //    var typedStatus = status?.ToEnum<NetworkInterfaceStatus>() ?? NetworkInterfaceStatus.Down;
            //    var model = new NetworkInterface {
            //        Device = dev,
            //        Configuration = conf,
            //        HardwareConfiguration = hwConf,
            //        Status = typedStatus,
            //        AdditionalConfigurations = confs == null ? new List<string>() : StringExtensions.SplitToList(confs),
            //        GatewayConfiguration = gwConf
            //    };
            //    Network2Configuration.AddInterfaceSetting(model);
            //    return HttpStatusCode.OK;
            //};

            Post["/network2/interface2"] = x => {
                string conf  = Request.Form.Config;
                var    model = JsonConvert.DeserializeObject <List <NetworkInterface> >(conf);
                Network2Configuration.SaveInterfaceSetting(model);
                return(HttpStatusCode.OK);
            };

            //Post["/network2/interface/del"] = x => {
            //    string dev = Request.Form.Device;
            //    Network2Configuration.RemoveInterfaceSetting(dev);
            //    return HttpStatusCode.OK;
            //};

            Post["/network2/add/bond"] = x => {
                string name = Request.Form.Name;
                try {
                    CommandLauncher.Launch("bond-set", new Dictionary <string, string> {
                        { "$bond", name }
                    });
                    ConsoleLogger.Log($"created bond {name}");
                }
                catch (Exception ex) {
                    ConsoleLogger.Error(ex.Message);
                }
                return(HttpStatusCode.OK);
            };

            Post["/network2/add/bridge"] = x => {
                string name = Request.Form.Name;
                try {
                    CommandLauncher.Launch("brctl-add", new Dictionary <string, string> {
                        { "$bridge", name }
                    });
                    ConsoleLogger.Log($"created bridge {name}");
                }
                catch (Exception ex) {
                    ConsoleLogger.Error(ex.Message);
                }
                return(HttpStatusCode.OK);
            };
        }
Example #2
0
        private static void Main()
        {
            ConsoleLogger.Log("[boot step] starting antd");
            var startTime = DateTime.Now;

            ConsoleLogger.Log("[boot step] core procedures");

            #region [    os Rw    ]
            Bash.Execute("mount -o remount,rw /", false);
            Bash.Execute("mount -o remount,rw /mnt/cdrom", false);
            #endregion

            #region [    Remove Limits    ]
            const string limitsFile = "/etc/security/limits.conf";
            if (File.Exists(limitsFile))
            {
                if (!File.ReadAllText(limitsFile).Contains("root - nofile 1024000"))
                {
                    FileWithAcl.AppendAllLines(limitsFile, new[] { "root - nofile 1024000" }, "644", "root", "wheel");
                }
            }
            Bash.Execute("ulimit -n 1024000", false);
            #endregion

            #region [    Overlay Watcher    ]
            if (Directory.Exists(Parameter.Overlay))
            {
                new OverlayWatcher().StartWatching();
                ConsoleLogger.Log("overlay watcher ready");
            }
            #endregion

            #region [    Working Directories    ]
            Directory.CreateDirectory(Parameter.AntdCfg);
            Directory.CreateDirectory(Parameter.AntdCfgServices);
            Directory.CreateDirectory(Parameter.AntdCfgNetwork);
            Network2Configuration.CreateWorkingDirectories();
            Directory.CreateDirectory(Parameter.AntdCfgParameters);
            Directory.CreateDirectory(Parameter.AntdCfgCluster);
            Directory.CreateDirectory($"{Parameter.AntdCfgServices}/acls");
            Directory.CreateDirectory($"{Parameter.AntdCfgServices}/acls/template");
            Directory.CreateDirectory(Parameter.RepoConfig);
            Directory.CreateDirectory(Parameter.RepoDirs);
            Directory.CreateDirectory(Parameter.AnthillaUnits);
            Directory.CreateDirectory(Parameter.TimerUnits);
            Directory.CreateDirectory(Parameter.AntdCfgVfs);
            Directory.CreateDirectory(Parameter.AntdCfgRssdp);
            ConsoleLogger.Log("working directories created");
            MountManagement.WorkingDirectories();
            ConsoleLogger.Log("working directories mounted");
            #endregion

            #region [    Mounts    ]
            if (MountHelper.IsAlreadyMounted("/mnt/cdrom/Kernel/active-firmware", "/lib64/firmware") == false)
            {
                Bash.Execute("mount /mnt/cdrom/Kernel/active-firmware /lib64/firmware", false);
            }
            var kernelRelease = Bash.Execute("uname -r").Trim();
            var linkedRelease = Bash.Execute("file /mnt/cdrom/Kernel/active-modules").Trim();
            if (MountHelper.IsAlreadyMounted("/mnt/cdrom/Kernel/active-modules") == false &&
                linkedRelease.Contains(kernelRelease))
            {
                var moduleDir = $"/lib64/modules/{kernelRelease}/";
                DirectoryWithAcl.CreateDirectory(moduleDir);
                Bash.Execute($"mount /mnt/cdrom/Kernel/active-modules {moduleDir}", false);
            }
            Bash.Execute("systemctl restart systemd-modules-load.service", false);
            MountManagement.AllDirectories();
            ConsoleLogger.Log("mounts ready");
            #endregion

            #region [    Check Units Location    ]
            var anthillaUnits = Directory.EnumerateFiles(Parameter.AnthillaUnits, "*.*", SearchOption.TopDirectoryOnly);
            if (!anthillaUnits.Any())
            {
                var antdUnits = Directory.EnumerateFiles(Parameter.AntdUnits, "*.*", SearchOption.TopDirectoryOnly);
                foreach (var unit in antdUnits)
                {
                    var trueUnit = unit.Replace(Parameter.AntdUnits, Parameter.AnthillaUnits);
                    if (!File.Exists(trueUnit))
                    {
                        File.Copy(unit, trueUnit);
                    }
                    File.Delete(unit);
                    Bash.Execute($"ln -s {trueUnit} {unit}");
                }
                var appsUnits = Directory.EnumerateFiles(Parameter.AppsUnits, "*.*", SearchOption.TopDirectoryOnly);
                foreach (var unit in appsUnits)
                {
                    var trueUnit = unit.Replace(Parameter.AntdUnits, Parameter.AnthillaUnits);
                    if (!File.Exists(trueUnit))
                    {
                        File.Copy(unit, trueUnit);
                    }
                    File.Delete(unit);
                    Bash.Execute($"ln -s {trueUnit} {unit}");
                }
                var applicativeUnits = Directory.EnumerateFiles(Parameter.ApplicativeUnits, "*.*", SearchOption.TopDirectoryOnly);
                foreach (var unit in applicativeUnits)
                {
                    var trueUnit = unit.Replace(Parameter.AntdUnits, Parameter.AnthillaUnits);
                    if (!File.Exists(trueUnit))
                    {
                        File.Copy(unit, trueUnit);
                    }
                    File.Delete(unit);
                    Bash.Execute($"ln -s {trueUnit} {unit}");
                }
            }
            anthillaUnits = Directory.EnumerateFiles(Parameter.AnthillaUnits, "*.*", SearchOption.TopDirectoryOnly).ToList();
            if (!anthillaUnits.Any())
            {
                foreach (var unit in anthillaUnits)
                {
                    Bash.Execute($"chown root:wheel {unit}");
                    Bash.Execute($"chmod 644 {unit}");
                }
            }
            ConsoleLogger.Log("[check] units integrity");
            #endregion

            #region [    Application Keys    ]
            var ak  = new AsymmetricKeys(Parameter.AntdCfgKeys, KeyName);
            var pub = ak.PublicKey;
            #endregion

            #region [    Secret    ]
            if (!File.Exists(Parameter.AntdCfgSecret))
            {
                FileWithAcl.WriteAllText(Parameter.AntdCfgSecret, Secret.Gen(), "644", "root", "wheel");
            }

            if (string.IsNullOrEmpty(File.ReadAllText(Parameter.AntdCfgSecret)))
            {
                FileWithAcl.WriteAllText(Parameter.AntdCfgSecret, Secret.Gen(), "644", "root", "wheel");
            }
            #endregion

            #region [    License Management    ]
            var appconfig = new AppConfiguration().Get();
            ConsoleLogger.Log($"[cloud] {appconfig.CloudAddress}");
            try {
                var machineIds = Machine.MachineIds.Get;
                ConsoleLogger.Log($"[machineid] {machineIds.PartNumber}");
                ConsoleLogger.Log($"[machineid] {machineIds.SerialNumber}");
                ConsoleLogger.Log($"[machineid] {machineIds.MachineUid}");
                var licenseManagement = new LicenseManagement();
                licenseManagement.Download("Antd", machineIds, pub);
                var licenseStatus = licenseManagement.Check("Antd", machineIds, pub);
                ConsoleLogger.Log(licenseStatus == null
                    ? "[license] license results null"
                    : $"[license] {licenseStatus.Status} - {licenseStatus.Message}");
            }
            catch (Exception ex) {
                ConsoleLogger.Warn(ex.Message);
            }
            #endregion

            #region [    JournalD    ]
            if (JournaldConfiguration.IsActive())
            {
                JournaldConfiguration.Set();
            }
            #endregion

            #region [    Import Existing Configuration    ]

            Network2Configuration.SetWorkingDirectories();

            #region import host2model
            var tmpHost  = HostConfiguration.Host;
            var varsFile = Host2Configuration.FilePath;
            var vars     = new Host2Model {
                HostName              = tmpHost.HostName.StoredValues.FirstOrDefault().Value,
                HostChassis           = tmpHost.HostChassis.StoredValues.FirstOrDefault().Value,
                HostDeployment        = tmpHost.HostDeployment.StoredValues.FirstOrDefault().Value,
                HostLocation          = tmpHost.HostLocation.StoredValues.FirstOrDefault().Value,
                InternalDomainPrimary = tmpHost.InternalDomain,
                ExternalDomainPrimary = tmpHost.ExternalDomain,
                InternalHostIpPrimary = "",
                ExternalHostIpPrimary = "",
                Timezone              = tmpHost.Timezone.StoredValues.FirstOrDefault().Value,
                NtpdateServer         = tmpHost.NtpdateServer.StoredValues.FirstOrDefault().Value,
                MachineUid            = Machine.MachineIds.Get.MachineUid,
                Cloud = Parameter.Cloud
            };

            if (File.Exists(HostConfiguration.FilePath))
            {
                if (!File.Exists(varsFile))
                {
                    ConsoleLogger.Log("[data import] host configuration");
                    Host2Configuration.Export(vars);
                }
                else
                {
                    if (string.IsNullOrEmpty(File.ReadAllText(varsFile)))
                    {
                        ConsoleLogger.Log("[data import] host configuration");
                        Host2Configuration.Export(vars);
                    }
                }
            }
            #endregion

            #region import network2model
            var tmpNet   = NetworkConfiguration.Get();
            var tmpHost2 = Host2Configuration.Host;
            var niflist  = new List <NetworkInterface>();
            foreach (var cif in tmpNet.Interfaces)
            {
                ConsoleLogger.Log($"[data import] network configuration for '{cif.Interface}'");
                var broadcast = "";
                try {
                    broadcast = Cidr.CalcNetwork(cif.StaticAddress, cif.StaticRange).Broadcast.ToString();
                }
                catch (Exception ex) {
                    ConsoleLogger.Error($"[data import] {ex.Message}");
                }
                var hostname             = $"{vars.HostName}{NetworkInterfaceType.Internal}.{vars.InternalDomainPrimary}";
                var subnet               = tmpHost2.InternalNetPrimaryBits;
                var index                = Network2Configuration.InterfaceConfigurationList.Count(_ => _.Type == NetworkInterfaceType.Internal);
                var networkConfiguration = new NetworkInterfaceConfiguration {
                    Id          = cif.Interface + cif.Guid.Substring(0, 8),
                    Adapter     = cif.Type,
                    Alias       = "import " + cif.Interface,
                    Ip          = cif.StaticAddress,
                    Subnet      = subnet,
                    Mode        = cif.Mode,
                    ChildrenIf  = cif.InterfaceList,
                    Broadcast   = broadcast,
                    Type        = NetworkInterfaceType.Internal,
                    Hostname    = hostname,
                    Index       = index,
                    Description = "import " + cif.Interface,
                    RoleVerb    = NetworkRoleVerb.iif
                };

                var tryget = Network2Configuration.InterfaceConfigurationList.FirstOrDefault(_ => _.Id == networkConfiguration.Id);
                if (tryget == null)
                {
                    Network2Configuration.AddInterfaceConfiguration(networkConfiguration);
                }

                var ifConfig = new NetworkInterface {
                    Device                   = cif.Interface,
                    Configuration            = networkConfiguration.Id,
                    AdditionalConfigurations = new List <string>(),
                    GatewayConfiguration     = ""
                };

                var tryget2 = Network2Configuration.Conf.Interfaces.FirstOrDefault(_ => _.Device == cif.Interface);
                if (tryget2 == null)
                {
                    niflist.Add(ifConfig);
                }
            }
            if (niflist.Any())
            {
                Network2Configuration.SaveInterfaceSetting(niflist);
            }
            if (!Network2Configuration.GatewayConfigurationList.Any())
            {
                var defaultGatewayConfiguration = new NetworkGatewayConfiguration {
                    Id             = Random.ShortGuid(),
                    IsDefault      = true,
                    GatewayAddress = vars.InternalHostIpPrimary,
                    Description    = "DFGW"
                };
                Network2Configuration.AddGatewayConfiguration(defaultGatewayConfiguration);
            }
            #endregion

            #region import parameters
            if (!File.Exists($"{Parameter.AntdCfgParameters}/endcommands.conf"))
            {
                var tmpsetup = SetupConfiguration.Get();
                HostParametersConfiguration.SetEndCommandsList(tmpsetup);
            }
            if (!File.Exists($"{Parameter.AntdCfgParameters}/modprobes.conf"))
            {
                var ddd = EnumerableExtensions.Merge(tmpHost.Modprobes.Select(_ => _.StoredValues.Select(___ => ___.Value)));
                HostParametersConfiguration.SetModprobesList(ddd.ToList());
            }
            if (!File.Exists($"{Parameter.AntdCfgParameters}/rmmod.conf"))
            {
                var ddd = tmpHost.RemoveModules.StoredValues.FirstOrDefault().Value.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
                HostParametersConfiguration.SetRmmodList(ddd.ToList());
            }
            if (!File.Exists($"{Parameter.AntdCfgParameters}/modulesblacklist.conf"))
            {
                var ddd = tmpHost.ModulesBlacklist;
                HostParametersConfiguration.SetModulesBlacklistList(ddd.ToList());
            }
            if (!File.Exists($"{Parameter.AntdCfgParameters}/osparameters.conf"))
            {
                var list = new List <string> {
                    "/proc/sys/fs/file-max 1024000",
                    "/proc/sys/net/bridge/bridge-nf-call-arptables 0",
                    "/proc/sys/net/bridge/bridge-nf-call-ip6tables 0",
                    "/proc/sys/net/bridge/bridge-nf-call-iptables 0",
                    "/proc/sys/net/bridge/bridge-nf-filter-pppoe-tagged 0",
                    "/proc/sys/net/bridge/bridge-nf-filter-vlan-tagged 0",
                    "/proc/sys/net/core/netdev_max_backlog 300000",
                    "/proc/sys/net/core/optmem_max 40960",
                    "/proc/sys/net/core/rmem_max 268435456",
                    "/proc/sys/net/core/somaxconn 65536",
                    "/proc/sys/net/core/wmem_max 268435456",
                    "/proc/sys/net/ipv4/conf/all/accept_local 1",
                    "/proc/sys/net/ipv4/conf/all/accept_redirects 1",
                    "/proc/sys/net/ipv4/conf/all/accept_source_route 1",
                    "/proc/sys/net/ipv4/conf/all/rp_filter 0",
                    "/proc/sys/net/ipv4/conf/all/forwarding 1",
                    "/proc/sys/net/ipv4/conf/default/rp_filter 0",
                    "/proc/sys/net/ipv4/ip_forward 1",
                    "/proc/sys/net/ipv4/ip_local_port_range 1024 65000",
                    "/proc/sys/net/ipv4/ip_no_pmtu_disc 1",
                    "/proc/sys/net/ipv4/tcp_congestion_control htcp",
                    "/proc/sys/net/ipv4/tcp_fin_timeout 40",
                    "/proc/sys/net/ipv4/tcp_max_syn_backlog 3240000",
                    "/proc/sys/net/ipv4/tcp_max_tw_buckets 1440000",
                    "/proc/sys/net/ipv4/tcp_moderate_rcvbuf 1",
                    "/proc/sys/net/ipv4/tcp_mtu_probing 1",
                    "/proc/sys/net/ipv4/tcp_rmem 4096 87380 134217728",
                    "/proc/sys/net/ipv4/tcp_slow_start_after_idle 1",
                    "/proc/sys/net/ipv4/tcp_tw_recycle 0",
                    "/proc/sys/net/ipv4/tcp_tw_reuse 1",
                    "/proc/sys/net/ipv4/tcp_window_scaling 1",
                    "/proc/sys/net/ipv4/tcp_wmem 4096 65536 134217728",
                    "/proc/sys/net/ipv6/conf/br0/disable_ipv6 1",
                    "/proc/sys/net/ipv6/conf/eth0/disable_ipv6 1",
                    "/proc/sys/net/ipv6/conf/wlan0/disable_ipv6 1",
                    "/proc/sys/vm/swappiness 0"
                };
                HostParametersConfiguration.SetOsParametersList(list);

                ConsoleLogger.Log("[data import] parameters");
            }
            #endregion

            #endregion

            #region [    Adjustments    ]
            new Do().ParametersChangesPre();
            ConsoleLogger.Log("modules, services and os parameters ready");
            #endregion

            ConsoleLogger.Log("[boot step] procedures");

            #region [    Users    ]
            var manageMaster = new ManageMaster();
            manageMaster.Setup();
            UserConfiguration.Import();
            UserConfiguration.Set();
            ConsoleLogger.Log("users config ready");
            #endregion

            #region [    Host Configuration & Name Service    ]
            new Do().HostChanges();
            ConsoleLogger.Log("host configured");
            ConsoleLogger.Log("name service ready");
            #endregion

            #region [    Network    ]
            new Do().NetworkChanges();
            if (File.Exists("/cfg/antd/services/network.conf"))
            {
                File.Delete("/cfg/antd/services/network.conf");
            }
            if (File.Exists("/cfg/antd/services/network.conf.bck"))
            {
                File.Delete("/cfg/antd/services/network.conf.bck");
            }
            ConsoleLogger.Log("network ready");
            #endregion

            #region [    Firewall    ]
            if (FirewallConfiguration.IsActive())
            {
                FirewallConfiguration.Set();
            }
            #endregion

            #region [    Dhcpd    ]
            DhcpdConfiguration.TryImport();
            if (DhcpdConfiguration.IsActive())
            {
                DhcpdConfiguration.Set();
            }
            #endregion

            #region [    Bind    ]
            BindConfiguration.TryImport();
            BindConfiguration.DownloadRootServerHits();
            if (BindConfiguration.IsActive())
            {
                BindConfiguration.Set();
            }
            #endregion

            ConsoleLogger.Log("[boot step] post procedures");

            #region [    Apply Setup Configuration    ]
            new Do().ParametersChangesPost();
            ConsoleLogger.Log("machine configured (apply setup.conf)");
            #endregion

            #region [    Nginx    ]
            NginxConfiguration.TryImport();
            if (NginxConfiguration.IsActive())
            {
                NginxConfiguration.Set();
            }
            #endregion

            #region [    Ssh    ]
            if (SshdConfiguration.IsActive())
            {
                SshdConfiguration.Set();
            }
            DirectoryWithAcl.CreateDirectory(Parameter.RootSsh, "755", "root", "wheel");
            DirectoryWithAcl.CreateDirectory(Parameter.RootSshMntCdrom, "755", "root", "wheel");
            if (!MountHelper.IsAlreadyMounted(Parameter.RootSsh))
            {
                MountManagement.Dir(Parameter.RootSsh);
            }
            var rk = new RootKeys();
            if (rk.Exists == false)
            {
                rk.Create();
            }
            var authorizedKeysConfiguration = new AuthorizedKeysConfiguration();
            var storedKeys = authorizedKeysConfiguration.Get().Keys;
            foreach (var storedKey in storedKeys)
            {
                var home = storedKey.User == "root" ? "/root/.ssh" : $"/home/{storedKey.User}/.ssh";
                var authorizedKeysPath = $"{home}/authorized_keys";
                if (!File.Exists(authorizedKeysPath))
                {
                    File.Create(authorizedKeysPath);
                }
                FileWithAcl.AppendAllLines(authorizedKeysPath, new List <string> {
                    $"{storedKey.KeyValue} {storedKey.RemoteUser}"
                }, "644", "root", "wheel");
                Bash.Execute($"chmod 600 {authorizedKeysPath}");
                Bash.Execute($"chown {storedKey.User}:{storedKey.User} {authorizedKeysPath}");
            }
            ConsoleLogger.Log("ssh ready");
            #endregion

            #region [    Service Discovery    ]
            try {
                ServiceDiscovery.Rssdp.PublishThisDevice();
                ConsoleLogger.Log("[rssdp] published device");
            }
            catch (Exception ex) {
                ConsoleLogger.Log($"[rssdp] {ex.Message}");
            }
            #endregion

            #region [    AntdUI    ]
            UiService.Setup();
            ConsoleLogger.Log("antduisetup");
            #endregion

            ConsoleLogger.Log("[boot step] managed procedures");

            #region [    Samba    ]
            if (SambaConfiguration.IsActive())
            {
                SambaConfiguration.Set();
            }
            #endregion

            #region [    Syslog    ]
            if (SyslogNgConfiguration.IsActive())
            {
                SyslogNgConfiguration.Set();
            }
            #endregion

            #region [    Storage - Zfs   ]
            foreach (var pool in Zpool.ImportList().ToList())
            {
                if (string.IsNullOrEmpty(pool))
                {
                    continue;
                }
                ConsoleLogger.Log($"pool {pool} imported");
                Zpool.Import(pool);
            }
            ConsoleLogger.Log("storage ready");
            #endregion

            #region [    Scheduler    ]
            Timers.MoveExistingTimers();
            Timers.Setup();
            Timers.Import();
            Timers.Export();
            foreach (var zp in Zpool.List())
            {
                Timers.Create(zp.Name.ToLower() + "snap", "hourly", $"/sbin/zfs snap -r {zp.Name}@${{TTDATE}}");
            }
            Timers.StartAll();
            new SnapshotCleanup().Start(new TimeSpan(2, 00, 00));
            new SyncTime().Start(new TimeSpan(0, 42, 00));
            new RemoveUnusedModules().Start(new TimeSpan(2, 15, 00));

            JobManager jobManager = new JobManager();
            jobManager.ExecuteAllJobs();

            ConsoleLogger.Log("scheduled events ready");
            #endregion

            #region [    Acl    ]
            if (AclConfiguration.IsActive())
            {
                AclConfiguration.Set();
                AclConfiguration.ScriptSetup();
            }
            #endregion

            #region [    C A    ]
            if (CaConfiguration.IsActive())
            {
                CaConfiguration.Set();
            }
            #endregion

            #region [    Host Init    ]
            var app  = new AppConfiguration().Get();
            var port = app.AntdPort;
            var uri  = $"http://localhost:{app.AntdPort}/";
            var host = new NancyHost(new Uri(uri));
            host.Start();
            ConsoleLogger.Log("host ready");
            StaticConfiguration.DisableErrorTraces = false;
            ConsoleLogger.Log($"http port: {port}");
            ConsoleLogger.Log("[boot step] antd is running");
            #endregion

            ConsoleLogger.Log("[boot step] working procedures");

            #region [    Apps    ]
            AppTarget.Setup();
            var apps = AppsConfiguration.Get().Apps;
            foreach (var mapp in apps)
            {
                var units = mapp.UnitLauncher;
                foreach (var unit in units)
                {
                    if (Systemctl.IsActive(unit) == false)
                    {
                        Systemctl.Restart(unit);
                    }
                }
            }
            //AppTarget.StartAll();
            ConsoleLogger.Log("apps ready");
            #endregion

            #region [    Sync / Gluster   ]
            if (GlusterConfiguration.IsActive())
            {
                GlusterConfiguration.Launch();
            }
            if (RsyncConfiguration.IsActive())
            {
                RsyncConfiguration.Set();
            }
            #endregion

            #region [    Storage Server    ]
            VfsConfiguration.SetDefaults();
            new Thread(() => {
                try {
                    var srv = new StorageServer(VfsConfiguration.GetSystemConfiguration());
                    srv.Start();
                }
                catch (Exception ex) {
                    ConsoleLogger.Error(ex.Message);
                }
            }).Start();
            #endregion

            #region [    Tor    ]
            if (TorConfiguration.IsActive())
            {
                TorConfiguration.Start();
            }
            #endregion

            #region [    Cluster    ]
            VfsWatcher = new VfsWatcher();
            ClusterConfiguration.Prepare();
            new Do().ClusterChanges();
            ConsoleLogger.Log("[cluster] active");
            #endregion

            #region [    Directory Watchers    ]
            DirectoryWatcherCluster.Start();
            DirectoryWatcherRsync.Start();
            #endregion

            #region [    Check Application File Acls    ]
            var files = Directory.EnumerateFiles(Parameter.RepoApps, "*.squashfs.xz", SearchOption.AllDirectories);
            foreach (var file in files)
            {
                Bash.Execute($"chmod 644 {file}");
                Bash.Execute($"chown root:wheel {file}");
            }
            ConsoleLogger.Log("[check] app-file acl");
            #endregion

            #region [    Check System Components    ]
            MachineInfo.CheckSystemComponents();
            ConsoleLogger.Log("[check] system components health");
            #endregion

            #region [    Test    ]
#if DEBUG
            Test();
#endif
            #endregion

            ConsoleLogger.Log($"loaded in: {DateTime.Now - startTime}");
            KeepAlive();
            ConsoleLogger.Log("antd is closing");
            host.Stop();
            Console.WriteLine("host shutdown");
        }