コード例 #1
0
ファイル: Application.cs プロジェクト: diycp/Antd
        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");
        }
コード例 #2
0
ファイル: AssetClusterModule.cs プロジェクト: diycp/Antd
        public AssetClusterModule()
        {
            Get["/cluster"] = x => {
                var syncedMachines = ClusterConfiguration.GetNodes();
                var config         = ClusterConfiguration.GetClusterInfo();
                foreach (var node in syncedMachines)
                {
                    var services = _api.Get <List <RssdpServiceModel> >(node.ModelUrl + "device/services");
                    node.Services = services;
                }
                var importPortMapping = syncedMachines
                                        .Select(_ => _.Services)
                                        .Merge()
                                        .Select(_ => _.Name)
                                        .ToHashSet()
                                        .Select(_ => new Cluster.PortMapping {
                    ServiceName = _, ServicePort = "", VirtualPort = ""
                })
                                        .ToList()
                ;
                var existingPortMapping = config.PortMapping.ToList();
                foreach (var i in importPortMapping)
                {
                    if (existingPortMapping.FirstOrDefault(_ => _.ServiceName == i.ServiceName) == null)
                    {
                        existingPortMapping.Add(i);
                    }
                }
                config.PortMapping = existingPortMapping.ToList();
                var model = new PageAssetClusterModel {
                    Info            = config,
                    ClusterNodes    = syncedMachines.OrderBy(_ => _.Hostname).ThenBy(_ => _.PublicIp).ToList(),
                    NetworkAdapters = IPv4.GetAllLocalDescription().ToList()
                };
                return(JsonConvert.SerializeObject(model));
            };

            Post["/cluster/save"] = x => {
                string config = Request.Form.Config;
                string ip     = Request.Form.Ip;
                var    model  = JsonConvert.DeserializeObject <List <NodeModel> >(config);
                var    model2 = JsonConvert.DeserializeObject <Cluster.Configuration>(ip);
                ClusterConfiguration.SaveNodes(model);
                ClusterConfiguration.SaveConfiguration(model2);
                new Do().ClusterChanges();
                DeployClusterConfiguration();
                return(HttpStatusCode.OK);
            };

            Post["Accept Configuration", "/cluster/accept"] = x => {
                string file    = Request.Form.File;
                string content = Request.Form.Content;
                if (string.IsNullOrEmpty(file))
                {
                    return(HttpStatusCode.BadRequest);
                }
                if (string.IsNullOrEmpty(content))
                {
                    return(HttpStatusCode.BadRequest);
                }
                ConsoleLogger.Log($"[cluster] received config for file: {file}");

                DirectoryWatcherCluster.Stop();
                try {
                    FileWithAcl.WriteAllText(file, content, "644", "root", "wheel");
                }
                catch (Exception) {
                    ConsoleLogger.Warn("");
                    DirectoryWatcherCluster.Start();
                    return(HttpStatusCode.InternalServerError);
                }
                DirectoryWatcherCluster.Start();

                var dict = Dicts.DirsAndServices;
                if (dict.ContainsKey(file))
                {
                    ConsoleLogger.Log("[cluster] restart service bind to config file");
                    var services = dict[file];
                    foreach (var svc in services)
                    {
                        Systemctl.Enable(svc);
                        Systemctl.Restart(svc);
                    }
                }
                ConsoleLogger.Log("[cluster] apply changes after new config");
                new Do().HostChanges();
                new Do().NetworkChanges();
                DeployClusterConfiguration();
                return(HttpStatusCode.OK);
            };

            #region [    Handshake + cluster init    ]
            Post["/asset/handshake/start", true] = async(x, ct) => {
                string conf       = Request.Form.HostJson;
                var    remoteNode = JsonConvert.DeserializeObject <NodeModel>(conf);
                if (remoteNode == null)
                {
                    return(HttpStatusCode.InternalServerError);
                }
                const string pathToPrivateKey = "/root/.ssh/id_rsa";
                const string pathToPublicKey  = "/root/.ssh/id_rsa.pub";
                if (!File.Exists(pathToPublicKey))
                {
                    var k = Bash.Execute($"ssh-keygen -t rsa -N '' -f {pathToPrivateKey}");
                    ConsoleLogger.Log(k);
                }
                var key = File.ReadAllText(pathToPublicKey);
                if (string.IsNullOrEmpty(key))
                {
                    return(HttpStatusCode.InternalServerError);
                }
                var dict = new Dictionary <string, string> {
                    { "ApplePie", key }
                };
                var r = new ApiConsumer().Post($"{remoteNode.ModelUrl}asset/handshake", dict);
                if (r != HttpStatusCode.OK)
                {
                    return(HttpStatusCode.InternalServerError);
                }
                //ho fatto l'handshake, quindi il nodo richiesto è pronto per essere integrato nel cluster
                //1. controllo la configurazione
                var clusterConfiguration = ClusterConfiguration.GetClusterInfo();
                if (string.IsNullOrEmpty(clusterConfiguration.Guid))
                {
                    clusterConfiguration.Guid = Guid.NewGuid().ToString();
                }
                if (string.IsNullOrEmpty(clusterConfiguration.Priority))
                {
                    clusterConfiguration.Priority = "100";
                }
                if (string.IsNullOrEmpty(clusterConfiguration.NetworkInterface))
                {
                    clusterConfiguration.NetworkInterface = "";
                }
                if (string.IsNullOrEmpty(clusterConfiguration.VirtualIpAddress))
                {
                    clusterConfiguration.VirtualIpAddress = "";
                }
                //2. salvo la configurazione
                ClusterConfiguration.SaveConfiguration(clusterConfiguration);
                //3. controllo i nodi presenti nella configurazione
                var clusterNodes = ClusterConfiguration.GetNodes();
                var iplocals     = IPv4.GetAllLocalAddress().ToList();
                var disc         = await ServiceDiscovery.Rssdp.Discover();

                //4. per prima cosa controllo l'host locale
                var localNode = disc.FirstOrDefault(_ => iplocals.Contains(_.PublicIp));
                //5. se non c'è lo aggiungo
                if (clusterNodes.FirstOrDefault(_ => _.MachineUid == localNode.MachineUid && _.PublicIp == localNode.PublicIp) == null)
                {
                    clusterNodes.Add(localNode);
                }
                //7. se non c'è lo aggiungo
                if (clusterNodes.FirstOrDefault(_ => _.MachineUid == remoteNode.MachineUid && _.PublicIp == remoteNode.PublicIp) == null)
                {
                    clusterNodes.Add(remoteNode);
                }
                //8. salvo la configurazione dei nodi
                ClusterConfiguration.SaveNodes(clusterNodes);
                //9. riavvio/avvio il servizio di cluster
                new Do().ClusterChanges();
                DeployClusterConfiguration();
                return(HttpStatusCode.OK);
            };

            Post["/asset/handshake"] = x => {
                string apple = Request.Form.ApplePie;
                var    info  = apple.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
                if (info.Length < 2)
                {
                    return(HttpStatusCode.InternalServerError);
                }
                var          key        = info[0];
                var          remoteUser = info[1];
                const string user       = "******";
                var          model      = new AuthorizedKeyModel {
                    RemoteUser = remoteUser,
                    User       = user,
                    KeyValue   = key
                };
                var authorizedKeysConfiguration = new AuthorizedKeysConfiguration();
                authorizedKeysConfiguration.AddKey(model);
                try {
                    DirectoryWithAcl.CreateDirectory("/root/.ssh");
                    const string authorizedKeysPath = "/root/.ssh/authorized_keys";
                    if (File.Exists(authorizedKeysPath))
                    {
                        var f = File.ReadAllText(authorizedKeysPath);
                        if (!f.Contains(apple))
                        {
                            FileWithAcl.AppendAllLines(authorizedKeysPath, new List <string> {
                                apple
                            }, "644", "root", "wheel");
                        }
                    }
                    else
                    {
                        FileWithAcl.WriteAllLines(authorizedKeysPath, new List <string> {
                            apple
                        }, "644", "root", "wheel");
                    }
                    Bash.Execute($"chmod 600 {authorizedKeysPath}", false);
                    Bash.Execute($"chown {user}:{user} {authorizedKeysPath}", false);
                    return(HttpStatusCode.OK);
                }
                catch (Exception ex) {
                    ConsoleLogger.Log(ex);
                    return(HttpStatusCode.InternalServerError);
                }
            };

            Post["/cluster/deploy"] = x => {
                var clusterConfiguration = Request.Form.Cluster;
                Cluster.DeployConf model = Newtonsoft.Json.JsonConvert.DeserializeObject <Cluster.DeployConf>(clusterConfiguration);
                ClusterConfiguration.SaveConfiguration(model.Configuration);
                ClusterConfiguration.SaveNodes(model.Nodes);
                new Do().ClusterChanges();
                return(HttpStatusCode.OK);
            };

            //Post["/asset/wol"] = x => {
            //    string mac = Request.Form.MacAddress;
            //    CommandLauncher.Launch("wol", new Dictionary<string, string> { { "$mac", mac } });
            //    return HttpStatusCode.OK;
            //};

            //Get["/asset/nmasp/{ip}"] = x => {
            //    string ip = x.ip;
            //    var result = CommandLauncher.Launch("nmap-ip-fast", new Dictionary<string, string> { { "$ip", ip } }).Where(_ => !_.Contains("MAC Address")).Skip(5).Reverse().Skip(1).Reverse();
            //    var list = new List<NmapScanStatus>();
            //    foreach(var r in result) {
            //        var a = r.SplitToList(" ").ToArray();
            //        var mo = new NmapScanStatus {
            //            Protocol = a[0],
            //            Status = a[1],
            //            Type = a[2]
            //        };
            //        list.Add(mo);
            //    }
            //    list = list.OrderBy(_ => _.Protocol).ToList();
            //    return JsonConvert.SerializeObject(list);
            //};
            #endregion
        }