Пример #1
0
        public AntdBindModule()
        {
            Get["/bind"] = x => {
                var model             = new PageBindModel();
                var bindConfiguration = new BindConfiguration();
                var bindIsActive      = bindConfiguration.IsActive();
                model.BindIsActive = bindIsActive;
                model.BindOptions  = bindConfiguration.Get() ?? new BindConfigurationModel();
                model.BindZones    = bindConfiguration.Get()?.Zones;
                return(JsonConvert.SerializeObject(model));
            };

            Post["/bind/set"] = x => {
                var bindConfiguration = new BindConfiguration();
                bindConfiguration.Set();
                return(HttpStatusCode.OK);
            };

            Post["/bind/restart"] = x => {
                var bindConfiguration = new BindConfiguration();
                bindConfiguration.Start();
                bindConfiguration.RndcReconfig();
                bindConfiguration.RndcReload();
                return(HttpStatusCode.OK);
            };

            Post["/bind/stop"] = x => {
                var bindConfiguration = new BindConfiguration();
                bindConfiguration.Stop();
                return(HttpStatusCode.OK);
            };

            Post["/bind/enable"] = x => {
                var dhcpdConfiguration = new BindConfiguration();
                dhcpdConfiguration.Enable();
                dhcpdConfiguration.Start();
                return(HttpStatusCode.OK);
            };

            Post["/bind/disable"] = x => {
                var dhcpdConfiguration = new BindConfiguration();
                dhcpdConfiguration.Disable();
                dhcpdConfiguration.Stop();
                return(HttpStatusCode.OK);
            };

            Post["/bind/options"] = x => {
                string notify                = Request.Form.Notify;
                string maxCacheSize          = Request.Form.MaxCacheSize;
                string maxCacheTtl           = Request.Form.MaxCacheTtl;
                string maxNcacheTtl          = Request.Form.MaxNcacheTtl;
                string forwarders            = Request.Form.Forwarders;
                string allowNotify           = Request.Form.AllowNotify;
                string allowTransfer         = Request.Form.AllowTransfer;
                string recursion             = Request.Form.Recursion;
                string transferFormat        = Request.Form.TransferFormat;
                string querySourceAddress    = Request.Form.QuerySourceAddress;
                string querySourcePort       = Request.Form.QuerySourcePort;
                string version               = Request.Form.Version;
                string allowQuery            = Request.Form.AllowQuery;
                string allowRecursion        = Request.Form.AllowRecursion;
                string ixfrFromDifferences   = Request.Form.IxfrFromDifferences;
                string listenOnV6            = Request.Form.ListenOnV6;
                string listenOnPort53        = Request.Form.ListenOnPort53;
                string dnssecEnabled         = Request.Form.DnssecEnabled;
                string dnssecValidation      = Request.Form.DnssecValidation;
                string dnssecLookaside       = Request.Form.DnssecLookaside;
                string authNxdomain          = Request.Form.AuthNxdomain;
                string keyName               = Request.Form.KeyName;
                string keySecret             = Request.Form.KeySecret;
                string controlAcl            = Request.Form.ControlAcl;
                string controlIp             = Request.Form.ControlIp;
                string controlPort           = Request.Form.ControlPort;
                string controlAllow          = Request.Form.ControlAllow;
                string loggingChannel        = Request.Form.LoggingChannel;
                string loggingDaemon         = Request.Form.LoggingDaemon;
                string loggingSeverity       = Request.Form.LoggingSeverity;
                string loggingPrintCategory  = Request.Form.LoggingPrintCategory;
                string loggingPrintSeverity  = Request.Form.LoggingPrintSeverity;
                string loggingPrintTime      = Request.Form.LoggingPrintTime;
                string trustedKeys           = Request.Form.TrustedKey;
                string aclLocalInterfaces    = Request.Form.AclLocalInterfaces;
                string aclInternalInterfaces = Request.Form.AclInternalInterfaces;
                string aclExternalInterfaces = Request.Form.AclExternalInterfaces;
                string aclLocalNetworks      = Request.Form.AclLocalNetworks;
                string aclInternalNetworks   = Request.Form.AclInternalNetworks;
                string aclExternalNetworks   = Request.Form.AclExternalNetworks;
                var    model = new BindConfigurationModel {
                    Notify                = notify,
                    MaxCacheSize          = maxCacheSize,
                    MaxCacheTtl           = maxCacheTtl,
                    MaxNcacheTtl          = maxNcacheTtl,
                    Forwarders            = forwarders.SplitToList().Select(_ => _.Trim()).ToList(),
                    AllowNotify           = allowNotify.SplitToList().Select(_ => _.Trim()).ToList(),
                    AllowTransfer         = allowTransfer.SplitToList().Select(_ => _.Trim()).ToList(),
                    Recursion             = recursion,
                    TransferFormat        = transferFormat,
                    QuerySourceAddress    = querySourceAddress,
                    QuerySourcePort       = querySourcePort,
                    Version               = version,
                    AllowQuery            = allowQuery.SplitToList().Select(_ => _.Trim()).ToList(),
                    AllowRecursion        = allowRecursion.SplitToList().Select(_ => _.Trim()).ToList(),
                    IxfrFromDifferences   = ixfrFromDifferences,
                    ListenOnV6            = listenOnV6.SplitToList().Select(_ => _.Trim()).ToList(),
                    ListenOnPort53        = listenOnPort53.SplitToList().Select(_ => _.Trim()).ToList(),
                    DnssecEnabled         = dnssecEnabled,
                    DnssecValidation      = dnssecValidation,
                    DnssecLookaside       = dnssecLookaside,
                    AuthNxdomain          = authNxdomain,
                    KeyName               = keyName,
                    KeySecret             = keySecret,
                    ControlAcl            = controlAcl,
                    ControlIp             = controlIp,
                    ControlPort           = controlPort,
                    ControlAllow          = controlAllow.SplitToList().Select(_ => _.Trim()).ToList(),
                    LoggingChannel        = loggingChannel,
                    LoggingDaemon         = loggingDaemon,
                    LoggingSeverity       = loggingSeverity,
                    LoggingPrintCategory  = loggingPrintCategory,
                    LoggingPrintSeverity  = loggingPrintSeverity,
                    LoggingPrintTime      = loggingPrintTime,
                    TrustedKeys           = trustedKeys,
                    AclLocalInterfaces    = aclLocalInterfaces.SplitToList().Select(_ => _.Trim()).ToList(),
                    AclInternalInterfaces = aclInternalInterfaces.SplitToList().Select(_ => _.Trim()).ToList(),
                    AclExternalInterfaces = aclExternalInterfaces.SplitToList().Select(_ => _.Trim()).ToList(),
                    AclLocalNetworks      = aclLocalNetworks.SplitToList().Select(_ => _.Trim()).ToList(),
                    AclInternalNetworks   = aclInternalNetworks.SplitToList().Select(_ => _.Trim()).ToList(),
                    AclExternalNetworks   = aclExternalNetworks.SplitToList().Select(_ => _.Trim()).ToList()
                };
                var bindConfiguration = new BindConfiguration();
                bindConfiguration.Save(model);
                return(HttpStatusCode.OK);
            };

            Post["/bind/zone"] = x => {
                string name = Request.Form.Name;
                string type = Request.Form.Type;
                string file = Request.Form.File;
                string serialUpdateMethod = Request.Form.NameSerialUpdateMethod;
                string allowUpdate        = Request.Form.AllowUpdate;
                string allowQuery         = Request.Form.AllowQuery;
                string allowTransfer      = Request.Form.AllowTransfer;
                var    model = new BindConfigurationZoneModel {
                    Name = name,
                    Type = type,
                    File = file,
                    SerialUpdateMethod = serialUpdateMethod,
                    AllowQuery         = allowQuery.SplitToList().Select(_ => _.Trim()).ToList(),
                    AllowUpdate        = allowUpdate.SplitToList().Select(_ => _.Trim()).ToList(),
                    AllowTransfer      = allowTransfer.SplitToList().Select(_ => _.Trim()).ToList()
                };
                var bindConfiguration = new BindConfiguration();
                bindConfiguration.AddZone(model);
                return(HttpStatusCode.OK);
            };

            Post["/bind/zone/del"] = x => {
                string guid = Request.Form.Guid;
                var    bindConfiguration = new BindConfiguration();
                bindConfiguration.RemoveZone(guid);
                return(HttpStatusCode.OK);
            };
        }
Пример #2
0
 private static void Action()
 {
     BindConfiguration.DownloadRootServerHits();
 }
Пример #3
0
        private void SaveNamedFile()
        {
            Directory.CreateDirectory(BindDirectory);
            Directory.CreateDirectory(BindZonesDirectory);
            var newModel = BindConfiguration.Get();

            if (!newModel.Forwarders.Contains(_host.InternalHostIpPrimary))
            {
                newModel.Forwarders.Add(_host.InternalHostIpPrimary);
            }
            if (!newModel.Forwarders.Contains(_host.ExternalHostIpPrimary))
            {
                newModel.Forwarders.Add(_host.ExternalHostIpPrimary);
            }
            newModel.ControlIp = _host.InternalHostIpPrimary;
            //if(!newModel.AclInternalInterfaces.Contains(_host.InternalHostIpPrimary)) {
            //    newModel.AclInternalInterfaces.Add(_host.InternalHostIpPrimary);
            //}
            //if(!newModel.AclExternalInterfaces.Contains(_host.ExternalHostIpPrimary)) {
            //    newModel.AclExternalInterfaces.Add(_host.ExternalHostIpPrimary);
            //}
            //if(!newModel.AclInternalNetworks.Contains(_host.InternalNetPrimary)) {
            //    newModel.AclInternalNetworks.Add(_host.InternalNetPrimary);
            //}
            //if(!newModel.AclExternalNetworks.Contains(_host.ExternalNetPrimary)) {
            //    newModel.AclExternalNetworks.Add(_host.ExternalNetPrimary);
            //}
            var zones            = newModel.Zones;
            var internalZoneName = _host.InternalDomainPrimary;

            if (newModel.Zones.FirstOrDefault(_ => _.Name == internalZoneName) == null)
            {
                var filePath = $"{BindZonesDirectory}/host.{internalZoneName}.db";
                var z        = new BindConfigurationZoneModel {
                    Guid = Guid.NewGuid().ToString(),
                    File = filePath,
                    SerialUpdateMethod = "unixtime",
                    AllowUpdate        = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet", "key updbindkey"
                    },
                    AllowQuery = new List <string> {
                        "any"
                    },
                    AllowTransfer = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet"
                    }
                };
                zones.Add(z);
            }
            var internalReverseZoneName = _host.InternalArpaPrimary;

            if (newModel.Zones.FirstOrDefault(_ => _.Name == internalReverseZoneName) == null)
            {
                var filePath = $"{BindZonesDirectory}/rev.{internalReverseZoneName}.db";
                var z        = new BindConfigurationZoneModel {
                    Guid = Guid.NewGuid().ToString(),
                    File = filePath,
                    SerialUpdateMethod = "unixtime",
                    AllowUpdate        = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet", "key updbindkey"
                    },
                    AllowQuery = new List <string> {
                        "any"
                    },
                    AllowTransfer = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet"
                    }
                };
                zones.Add(z);
            }
            var externalZoneName = _host.ExternalDomainPrimary;

            if (newModel.Zones.FirstOrDefault(_ => _.Name == externalZoneName) == null)
            {
                var filePath = $"{BindZonesDirectory}/host.{externalZoneName}.db";
                var z        = new BindConfigurationZoneModel {
                    Guid = Guid.NewGuid().ToString(),
                    File = filePath,
                    SerialUpdateMethod = "unixtime",
                    AllowUpdate        = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet", "key updbindkey"
                    },
                    AllowQuery = new List <string> {
                        "any"
                    },
                    AllowTransfer = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet"
                    }
                };
                zones.Add(z);
            }
            var externalReverseZoneName = _host.ExternalArpaPrimary;

            if (newModel.Zones.FirstOrDefault(_ => _.Name == externalReverseZoneName) == null)
            {
                var filePath = $"{BindZonesDirectory}/rev.{externalReverseZoneName}.db";
                var z        = new BindConfigurationZoneModel {
                    Guid = Guid.NewGuid().ToString(),
                    File = filePath,
                    SerialUpdateMethod = "unixtime",
                    AllowUpdate        = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet", "key updbindkey"
                    },
                    AllowQuery = new List <string> {
                        "any"
                    },
                    AllowTransfer = new List <string> {
                        "loif", "iif", "lonet", "inet", "onet"
                    }
                };
                zones.Add(z);
            }
            newModel.Zones = zones;

            var zonesFile = newModel.ZoneFiles;

            if (newModel.ZoneFiles.FirstOrDefault(_ => _.Name == $"{BindZonesDirectory}/host.{internalZoneName}.db") == null)
            {
                var filePath = $"{BindZonesDirectory}/host.{internalZoneName}.db";
                var z        = new BindConfigurationZoneFileModel {
                    Guid          = Guid.NewGuid().ToString(),
                    Name          = filePath,
                    Configuration = "unixtime"
                };
                zonesFile.Add(z);
                File.WriteAllLines(filePath, BindConfiguration.GetHostZoneText(_host.HostName, _host.InternalDomainPrimary, _host.InternalHostIpPrimary));
            }
            if (newModel.ZoneFiles.FirstOrDefault(_ => _.Name == $"{BindZonesDirectory}/rev.{internalReverseZoneName}.db") == null)
            {
                var filePath = $"{BindZonesDirectory}/rev.{internalReverseZoneName}.db";
                var z        = new BindConfigurationZoneFileModel {
                    Guid          = Guid.NewGuid().ToString(),
                    Name          = filePath,
                    Configuration = "unixtime"
                };
                zonesFile.Add(z);
                File.WriteAllLines(filePath, BindConfiguration.GetReverseZoneText(_host.HostName, _host.InternalDomainPrimary, _host.InternalArpaPrimary, _host.InternalHostIpPrimary.Split('.').Skip(2).JoinToString(".")));
            }
            if (newModel.ZoneFiles.FirstOrDefault(_ => _.Name == $"{BindZonesDirectory}/host.{externalZoneName}.db") == null)
            {
                var filePath = $"{BindZonesDirectory}/host.{externalZoneName}.db";
                var z        = new BindConfigurationZoneFileModel {
                    Guid          = Guid.NewGuid().ToString(),
                    Name          = filePath,
                    Configuration = "unixtime"
                };
                zonesFile.Add(z);
                File.WriteAllLines(filePath, BindConfiguration.GetHostZoneText(_host.HostName, _host.ExternalDomainPrimary, _host.ExternalHostIpPrimary));
            }
            if (newModel.ZoneFiles.FirstOrDefault(_ => _.Name == $"{BindZonesDirectory}/rev.{externalReverseZoneName}.db") == null)
            {
                var filePath = $"{BindZonesDirectory}/rev.{externalReverseZoneName}.db";
                var z        = new BindConfigurationZoneFileModel {
                    Guid          = Guid.NewGuid().ToString(),
                    Name          = filePath,
                    Configuration = "unixtime"
                };
                zonesFile.Add(z);
                File.WriteAllLines(filePath, BindConfiguration.GetReverseZoneText(_host.HostName, _host.ExternalDomainPrimary, _host.ExternalArpaPrimary, _host.ExternalHostIpPrimary.Split('.').Skip(2).JoinToString(".")));
            }
            newModel.ZoneFiles = zonesFile;
            BindConfiguration.Save(newModel);
            BindConfiguration.Set();
        }
Пример #4
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");
        }