public override void DoJob()
{
if (Application.CurrentConfiguration.Cluster.Active == false)
{
return;
}
var clusterStatus = Application.ClusterChecklist;
if (clusterStatus == null)
{
return;
}
if (clusterStatus.Length < 1)
{
return;
}
var nodesKnownHosts = new List <KnownHost>();
for (var i = 0; i < clusterStatus.Length; i++)
{
var nodeIPs = clusterStatus[i].DiscoveredIpsReach;
var nodeName = clusterStatus[i].Hostname;
var commonNames = new string[] {
CommonString.Append(nodeName, "int", i.ToString())
};
for (var p = 0; p < nodeIPs.Length; p++)
{
var knownHost = new KnownHost()
{
IpAddr = nodeIPs[p].IpAddress,
CommonNames = commonNames
};
nodesKnownHosts.Add(knownHost);
}
}
var currentKnownHosts = Application.CurrentConfiguration.Network.KnownHosts.ToList();
foreach (var nodeHost in nodesKnownHosts)
{
//i casi possono essere tre:
// 1) l'ip non è presente nella CurrentConfiguration -> aggiungo il nuovo KnownHost
// 2) l'ip è presente ma i CommonNames sono differenti -> aggiorno solamente i CommonNames del KnownHost corrispondente
// 3) l'ip è presente e i CommonNames coincidono -> non faccio nulla
if (!currentKnownHosts.Any(_ => CommonString.AreEquals(_.IpAddr, nodeHost.IpAddr) == true))
{
currentKnownHosts.Add(nodeHost);
}
else
{
var existingCn = currentKnownHosts.FirstOrDefault(_ => CommonString.AreEquals(_.IpAddr, nodeHost.IpAddr) == true).CommonNames;
if (CommonString.AreEquals(CommonString.Build(existingCn), CommonString.Build(nodeHost.CommonNames)) == false)
{
currentKnownHosts.FirstOrDefault(_ => CommonString.AreEquals(_.IpAddr, nodeHost.IpAddr) == true).CommonNames = nodeHost.CommonNames;
}
}
}
Application.CurrentConfiguration.Network.KnownHosts = currentKnownHosts.ToArray();
ConfigRepo.Save();
Dns.Set();
}
public static bool Apply()
{
var current = Application.CurrentConfiguration.Host;
var running = Application.RunningConfiguration.Host;
if (CommonString.AreEquals(current.HostName, running.HostName) == false)
{
ConsoleLogger.Log($"[host] name: {current.HostName}");
SetHostname(current.HostName);
}
if (CommonString.AreEquals(current.HostDeployment, running.HostDeployment) == false)
{
ConsoleLogger.Log($"[host] deployment: {current.HostDeployment}");
SetDeployment(current.HostDeployment);
}
if (CommonString.AreEquals(current.HostChassis, running.HostChassis) == false)
{
ConsoleLogger.Log($"[host] chassis: {current.HostChassis}");
SetChassis(current.HostChassis);
}
if (CommonString.AreEquals(current.HostLocation, running.HostLocation) == false)
{
ConsoleLogger.Log($"[host] location: {current.HostLocation}");
SetLocation(current.HostLocation);
}
return(true);
}
public static void ParsePayload(string topic, byte[] payload)
{
if (topic.StartsWith("/control"))
{
var controlData = topic.Split(new[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
if (controlData.Length != 4)
{
Console.WriteLine("Invalid topic");
return;
}
if (CommonString.AreEquals(Application.MACHINE_ID.MachineUid.ToString(), controlData[1]) == true &&
CommonString.AreEquals(Application.MACHINE_ID.PartNumber.ToString(), controlData[2]) == true &&
CommonString.AreEquals(Application.MACHINE_ID.SerialNumber.ToString(), controlData[3]))
{
Console.WriteLine(string.Join(" ", payload));
if (!COMMANDS.ContainsKey(payload))
{
Console.WriteLine("Invalid command");
return;
}
Console.WriteLine("Executing command");
Console.WriteLine(COMMANDS[payload]);
ExecuteCommand(COMMANDS[payload]);
}
}
}
/// <summary>
/// Meccanismo di autenticazione centralizzato
/// Prende i parametri id e password e li confronta coi dati di Application.CurrentConfiguration.Users.ApplicativeUsers
/// Flusso:
/// - ci sono utenti?
/// - c'è l'utente richiesto?
/// - l'utente trovato è abilitato a fare l'autenticazione?
/// - il parametro password corrisponde?
/// </summary>
/// <param name="id">Parametro dell'utente, es: username</param>
/// <param name="claims">Parametri dell'utente, es: hashing della password</param>
/// <returns>Restituisce un HttpStatusCode, solo se l'autenticazione è andata a buon fine restituisce OK</returns>
public static HttpStatusCode Authenticate(string id, string[] claims)
{
var current = Application.CurrentConfiguration.Users.ApplicativeUsers;
if (!current.Any())
{
return(HttpStatusCode.Unauthorized);
}
var method = current.FirstOrDefault(_ => CommonString.AreEquals(_.Id, id) == true);
if (method == null)
{
return(HttpStatusCode.Unauthorized);
}
if (!method.Active)
{
return(HttpStatusCode.Unauthorized);
}
switch (method.Type)
{
case AuthenticationType.none:
return(HttpStatusCode.Unauthorized);
case AuthenticationType.simple:
return(SimpleAuthentication(claims, method.Claims));
default:
return(HttpStatusCode.Unauthorized);
}
}
public static bool Set()
{
var currentConfig = Application.CurrentConfiguration.Network.InternalNetwork;
var parsedNetworkParameter = LukeSkywalker.IPNetwork.IPNetwork.Parse(currentConfig.IpAddress, currentConfig.NetworkRange);
var network = parsedNetworkParameter.Network.ToString();
var mask = parsedNetworkParameter.Netmask.ToString();
var lines = new string[] {
"interface ignore wildcard",
$"interface listen {currentConfig.IpAddress}",
$"restrict {network} mask {mask} nomodify",
"",
"server 0.it.pool.ntp.org",
"server 1.it.pool.ntp.org",
"server 2.it.pool.ntp.org",
"server 3.it.pool.ntp.org",
"server 193.204.114.232",
"server 193.204.114.233",
"server ntp1.ien.it",
"server ntp2.ien.it",
"",
"statistics loopstats",
"driftfile /var/lib/ntp/ntp.drift",
"logfile /var/log/ntp/ntpd.log",
"statsdir /var/log/ntp/",
"filegen peerstats file peers type day link enable",
"filegen loopstats file loops type day link enable"
};
File.WriteAllLines(ntpConfFileTmp, lines);
if (File.Exists(ntpConfFile))
{
var existingFileHash = CommonFile.GetHash(ntpConfFile);
var newFileHash = CommonFile.GetHash(ntpConfFileTmp);
if (CommonString.AreEquals(existingFileHash, newFileHash) == true)
{
return(true);
}
else
{
File.Copy(ntpConfFileTmp, ntpConfFile, true);
}
}
else
{
File.WriteAllLines(ntpConfFile, lines);
}
if (File.Exists(ntpConfFileTmp))
{
File.Delete(ntpConfFileTmp);
}
Systemctl.Start(ntpdService);
return(true);
}
public static void Apply(string key, string value)
{
if (!File.Exists(key))
{
return;
}
var runningValue = File.ReadAllText(key).Trim();
if (CommonString.AreEquals(value.Trim(), runningValue) == true)
{
return;
}
ConsoleLogger.Log($"[sysctl] {key} = {value}");
File.WriteAllText(key, value);
}
private static void FileChanged(object source, FileSystemEventArgs e)
{
var fileName = Path.GetFileName(e.FullPath);
if (CommonString.AreEquals(fileName, setupFilename) == false)
{
return;
}
if (!File.Exists(e.FullPath))
{
return;
}
ConsoleLogger.Log($"[watcher] file '{e.FullPath}' changed");
var result = File.ReadAllLines(e.FullPath).Where(_ => !_.Contains(comment)).ToArray();
SetupCommands.Import(result);
SetupCommands.Set();
}
public static bool Set()
{
var current = Application.CurrentConfiguration.Users.SystemUsers;
var running = Application.CurrentConfiguration.Users.SystemUsers;
for (var i = 0; i < current.Length; i++)
{
var currentUser = current[i];
var runningUser = running.FirstOrDefault(_ => _.Alias == currentUser.Alias);
if (runningUser == null)
{
AddUser(currentUser.Alias);
}
if (CommonString.AreEquals(currentUser.Password, runningUser.Password) == false)
{
SetPassword(currentUser.Alias, currentUser.Password);
}
}
return(true);
}
public static bool Apply()
{
var current = Application.CurrentConfiguration.Network.Bonds;
var running = Application.RunningConfiguration.Network.Bonds;
for (var i = 0; i < current.Length; i++)
{
var br = current[i];
var run = running.FirstOrDefault(_ => _.Id == br.Id)?.ToString();
if (CommonString.AreEquals(run, br.ToString()) == false)
{
Set(br.Id);
for (var l = 0; l < br.Lower.Length; l++)
{
AddNetworkAdapter(br.Id, br.Lower[l]);
}
}
}
return(true);
}
/// <summary>
/// Quando un file viene modificato lo invio agli altri nodi del cluster
/// E verrà salvato nella cartella /cfg/antd/cluster/{machineUid}/DIR_etc_libvirt_qemu
/// </summary>
/// <param name="source"></param>
/// <param name="e"></param>
private void FileChanged(object source, FileSystemEventArgs e)
{
var fileName = Path.GetFileName(e.FullPath);
if (!File.Exists(e.FullPath))
{
return;
}
ConsoleLogger.Log($"[watcher] file '{e.FullPath}' changed");
var nodes = Application.CurrentConfiguration.Cluster.Nodes;
for (var i = 0; i < nodes.Length; i++)
{
if (CommonString.AreEquals(nodes[i].MachineUid, Application.CurrentConfiguration.Host.MachineUid.ToString()) == true)
{
continue;
}
var destinationPath = CommonString.Append(clusterCfgFolder, "/", Application.CurrentConfiguration.Host.MachineUid.ToString(), "/", destinationFolderName, "/", e.Name);
ConsoleLogger.Log($"sync '{e.FullPath}' -> '{destinationPath}'");
StorageClient.CreateFile(nodes[i], e.FullPath, destinationPath);
}
}
private static void WriteSclFile()
{
var lines = new string[] {
"@define scl-root \"`syslog-ng-data`/include/scl\"",
"@define include-path \"`include-path`:`syslog-ng-data`/include\"",
"",
"@include 'scl/*/*.conf'"
};
File.WriteAllLines(sclTmpConfFile, lines);
var newHash = CommonFile.GetHash(sclTmpConfFile);
var existingHash = File.Exists(sclConfFile) ? CommonFile.GetHash(sclConfFile) : string.Empty;
if (CommonString.AreEquals(existingHash, newHash) == false)
{
File.Copy(sclTmpConfFile, sclConfFile, true);
}
if (File.Exists(sclTmpConfFile))
{
File.Delete(sclTmpConfFile);
}
}
public static bool SetInterfaceHardwareConfiguration(NetInterface netInterface)
{
if (netInterface.Active != true)
{
Ip.EnableNetworkAdapter(netInterface.Id);
ConsoleLogger.Log($"[network] enabling '{netInterface.Id}'");
}
if (netInterface.HardwareConfiguration.Promisc != true)
{
Ip.SetNetworkAdapterPromiscOn(netInterface.Id);
ConsoleLogger.Log($"[network] set '{netInterface.Id}' promisc to on");
}
if (CommonString.AreEquals(netInterface.HardwareConfiguration.Mtu.ToString(), defaultMtu) == false)
{
Ip.SetNetworkAdapterMTU(netInterface.Id, defaultMtu);
ConsoleLogger.Log($"[network] set '{netInterface.Id}' mtu to {defaultMtu}");
}
if (CommonString.AreEquals(netInterface.HardwareConfiguration.Txqueuelen.ToString(), defaultTxqueuelen) == false)
{
Ip.SetNetworkAdapterTxqueuelen(netInterface.Id, defaultTxqueuelen);
ConsoleLogger.Log($"[network] set '{netInterface.Id}' txqueuelen to {defaultTxqueuelen}");
}
return(true);
}
public static void Set()
{
var currentResolv = Application.CurrentConfiguration.Network.KnownDns;
var runningResolv = Application.RunningConfiguration.Network.KnownDns;
if (CommonString.AreEquals(currentResolv.ToString(), runningResolv.ToString()) == false)
{
if (File.Exists(etcResolv))
{
File.Copy(etcResolv, etcResolvBackup, true);
}
var nameserverLines = new string[currentResolv.Nameserver.Length];
for (var i = 0; i < currentResolv.Nameserver.Length; i++)
{
nameserverLines[i] = CommonString.Append(nameserver, " ", currentResolv.Nameserver[i]);
}
File.WriteAllLines(etcResolv, nameserverLines);
if (!string.IsNullOrEmpty(currentResolv.Search))
{
var newLines = new string[] { CommonString.Append(search, " ", currentResolv.Search) };
File.AppendAllLines(etcResolv, newLines);
}
if (!string.IsNullOrEmpty(currentResolv.Domain))
{
var newLines = new string[] { CommonString.Append(domain, " ", currentResolv.Domain) };
File.AppendAllLines(etcResolv, newLines);
}
}
var currentHosts = CommonArray.Merge(DefaultHosts, Application.CurrentConfiguration.Network.KnownHosts);
var runningHosts = Application.RunningConfiguration.Network.KnownHosts;
if (currentHosts.Select(_ => _.ToString()).SequenceEqual(runningHosts.Select(_ => _.ToString())) == false)
{
if (File.Exists(etcHosts))
{
File.Copy(etcHosts, etcHostsBackup, true);
}
var lines = new string[currentHosts.Length];
for (var i = 0; i < currentHosts.Length; i++)
{
lines[i] = CommonString.Append(currentHosts[i].IpAddr, " ", CommonString.Build(currentHosts[i].CommonNames, ' '));
}
File.WriteAllLines(etcHosts, lines);
}
var currentNetworks = CommonArray.Merge(DefaultNetworks, Application.CurrentConfiguration.Network.KnownNetworks);
var runningNetworks = Application.RunningConfiguration.Network.KnownNetworks;
if (currentNetworks.Select(_ => _.ToString()).SequenceEqual(runningNetworks.Select(_ => _.ToString())) == false)
{
if (File.Exists(etcNetworks))
{
File.Copy(etcNetworks, etcNetworksBackup, true);
}
var lines = new string[currentNetworks.Length];
for (var i = 0; i < currentNetworks.Length; i++)
{
lines[i] = CommonString.Append(currentNetworks[i].Label, " ", currentNetworks[i].NetAddr);
}
File.WriteAllLines(etcNetworks, lines);
}
}
public ClusterModule() : base("/cluster")
{
Get["/"] = x => {
return(JsonConvert.SerializeObject(Application.CurrentConfiguration.Cluster));
};
Get["/status"] = x => {
var nodes = Application.CurrentConfiguration.Cluster.Nodes;
var nodesStatus = new ClusterNodeStatusModel[nodes.Length];
for (var i = 0; i < nodes.Length; i++)
{
var status = Application.ClusterChecklist.FirstOrDefault(_ => _.TargetNodeMachineUid == nodes[i].MachineUid);
nodesStatus[i] = new ClusterNodeStatusModel()
{
Node = nodes[i],
Status = status
};
}
return(JsonConvert.SerializeObject(nodesStatus));
};
Post["/save"] = x => {
string data = Request.Form.Data;
var objects = JsonConvert.DeserializeObject <Cluster>(data);
Application.CurrentConfiguration.Cluster = objects;
ConfigRepo.Save();
ConsoleLogger.Log("[cluster] save local configuration");
return(HttpStatusCode.OK);
};
Post["/import"] = x => {
string data = Request.Form.Data;
var objects = JsonConvert.DeserializeObject <Cluster>(data);
Application.CurrentConfiguration.Cluster = objects;
ConfigRepo.Save();
ConsoleLogger.Log("[cluster] save cluster configuration");
return(HttpStatusCode.OK);
};
/// <summary>
/// Inizia ANCHE la procedura di "condivisione della configurazione nel cluster"
/// In questo contesto passerà SOLO la configurazione relativa al cluster stesso
/// Questa API viene richiesta da antdui
/// Per ogni nodo configurato (escludendo se stesso -> vedi uid) invia la conf
/// </summary>
Post["/apply"] = x => {
//Inizio ad applicarla localmente
cmds.Cluster.ApplyNetwork();
cmds.Cluster.ApplyServices();
cmds.Cluster.ApplyFs();
ConsoleLogger.Log("[cluster] apply local configuration");
return(HttpStatusCode.OK);
};
Post["/deploy"] = x => {
//Poi aggiorno gli altri nodi
var nodes = Application.CurrentConfiguration.Cluster.Nodes;
var configuration = JsonConvert.SerializeObject(Application.CurrentConfiguration.Cluster);
var localMachineUid = Application.CurrentConfiguration.Host.MachineUid.ToString();
for (var i = 0; i < nodes.Length; i++)
{
var node = nodes[i];
if (CommonString.AreEquals(localMachineUid, node.MachineUid))
{
continue;
}
ConsoleLogger.Log($"[cluster] deploy configuration on node: {node.Hostname}");
var dict = new Dictionary <string, string> {
{ "Data", configuration }
};
ConsoleLogger.Log($"[cluster] {node.Hostname}: send configuration to node");
var status = ApiConsumer.Post(CommonString.Append(node.EntryPoint, "cluster/import"), dict);
if (status == HttpStatusCode.OK)
{
ConsoleLogger.Log($"[cluster] {node.Hostname}: send apply command to node");
ApiConsumer.Post(CommonString.Append(node.EntryPoint, "cluster/apply"));
}
}
return(HttpStatusCode.OK);
};
#region [ Handshake + cluster init ]
Post["/handshake/begin"] = x => {
string conf = Request.Form.Data;
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 }
};
//1. controllo la configurazione
var cluster = Application.CurrentConfiguration.Cluster;
if (cluster == null)
{
cluster = new Cluster();
cluster.Label = CommonString.Append("AntdCluster-", cluster.Id.ToString().Substring(0, 8));
}
var nodes = cluster.Nodes.ToList();
for (var i = 0; i < remoteNode.Length; i++)
{
var handshakeResult = ApiConsumer.Post($"{remoteNode[i].ModelUrl}cluster/handshake", dict);
if (handshakeResult != HttpStatusCode.OK)
{
return(HttpStatusCode.InternalServerError);
}
//ottengo i servizi pubblicati da quel nodo
var publishedServices = ApiConsumer.Get <ClusterNodeService[]>($"{remoteNode[i].ModelUrl}device/services");
nodes.Add(new ClusterNode()
{
MachineUid = remoteNode[i].MachineUid,
Hostname = remoteNode[i].Hostname,
PublicIp = remoteNode[i].PublicIp,
EntryPoint = remoteNode[i].ModelUrl,
Services = publishedServices
});
}
//ho fatto gli handshake, quindi il nodo richiesto è pronto per essere integrato nel cluster
cluster.Active = true;
if (cluster.Id == Guid.Empty)
{
cluster.Id = Guid.NewGuid();
}
cluster.Nodes = nodes.ToArray();
cluster.SharedNetwork.Active = false;
var virtualPorts = cluster.SharedNetwork.PortMapping.ToList();
foreach (var node in nodes)
{
foreach (var svc in node.Services)
{
var checkPort = virtualPorts.FirstOrDefault(_ => _.ServicePort == svc.Port.ToString());
if (checkPort == null)
{
virtualPorts.Add(new PortMapping()
{
ServiceName = svc.Name,
ServicePort = svc.Port.ToString(),
VirtualPort = string.Empty
});
}
}
}
cluster.SharedNetwork.PortMapping = virtualPorts.ToArray();
Application.CurrentConfiguration.Cluster = cluster;
ConfigRepo.Save();
return(HttpStatusCode.OK);
};
Post["/handshake"] = x => {
string apple = Request.Form.ApplePie;
var info = apple.Split(new[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
var key = info[0];
var keys = Application.CurrentConfiguration.Services.Ssh.AuthorizedKey.ToList();
if (!keys.Any(_ => _.Key == key))
{
var userInfo = info[1].Split(new[] { '@' }, StringSplitOptions.RemoveEmptyEntries);
var model = new AuthorizedKey {
User = userInfo[0],
Host = userInfo[1],
Key = key
};
keys.Add(model);
}
Application.CurrentConfiguration.Services.Ssh.AuthorizedKey = keys.ToArray();
ConfigRepo.Save();
Directory.CreateDirectory("/root/.ssh");
const string authorizedKeysPath = "/root/.ssh/authorized_keys";
if (File.Exists(authorizedKeysPath))
{
var f = File.ReadAllText(authorizedKeysPath);
if (!f.Contains(apple))
{
File.AppendAllLines(authorizedKeysPath, new List <string> {
apple
});
}
}
else
{
File.WriteAllLines(authorizedKeysPath, new List <string> {
apple
});
}
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
}
private string GetValueFromHeader(RequestHeaders headers, string key)
{
var headerKVP = headers.FirstOrDefault(_ => CommonString.AreEquals(_.Key, key));
return(headerKVP.Value.FirstOrDefault());
}
public static bool SetInterface(NetInterface netInterface, NetInterface running)
{
var name = netInterface.Id;
if (netInterface.Active == false)
{
ConsoleLogger.Log($"[network] disabling '{name}'");
Ip.DisableNetworkAdapter(name);
return(true);
}
else
{
ConsoleLogger.Log($"[network] enabling '{name}'");
Ip.EnableNetworkAdapter(name);
}
if (CommonString.AreEquals(netInterface.ToString(), running.ToString()) == false)
{
if (CommonString.AreEquals(netInterface.HardwareConfiguration.ToString(), running.HardwareConfiguration.ToString()) == false)
{
Ip.SetNetworkAdapterMTU(name, netInterface.HardwareConfiguration.Mtu.ToString());
ConsoleLogger.Log($"[network] set '{name}' mtu to {netInterface.HardwareConfiguration.Mtu}");
Ip.SetNetworkAdapterTxqueuelen(name, netInterface.HardwareConfiguration.Txqueuelen.ToString());
ConsoleLogger.Log($"[network] set '{name}' txqueuelen to {netInterface.HardwareConfiguration.Txqueuelen}");
}
if (CommonString.AreEquals(netInterface.PrimaryAddressConfiguration.ToString(), running.PrimaryAddressConfiguration.ToString()) == false)
{
if (!string.IsNullOrEmpty(netInterface.PrimaryAddressConfiguration.IpAddr))
{
if (netInterface.PrimaryAddressConfiguration.StaticAddress)
{
Ip.AddAddress(name, netInterface.PrimaryAddressConfiguration.IpAddr, netInterface.PrimaryAddressConfiguration.NetworkRange.ToString());
ConsoleLogger.Log($"[network] set '{name}' address to {netInterface.PrimaryAddressConfiguration.IpAddr}/{netInterface.PrimaryAddressConfiguration.NetworkRange}");
}
else
{
Dhclient.Start(name);
ConsoleLogger.Log($"[network] dinamically set '{name}' address");
}
}
}
var currentSecondaryAddressConfiguration = netInterface.SecondaryAddressConfigurations;
if (currentSecondaryAddressConfiguration.Length < 1)
{
return(true);
}
var runningSecondaryAddressConfiguration = running.SecondaryAddressConfigurations;
// quelli unici di currentSecondaryAddressConfiguration sono da applicare
var add = currentSecondaryAddressConfiguration.Except(runningSecondaryAddressConfiguration).ToArray();
for (var s = 0; s < add.Length; s++)
{
if (!string.IsNullOrEmpty(add[s].IpAddr))
{
Ip.AddAddress(name, add[s].IpAddr, add[s].NetworkRange.ToString());
ConsoleLogger.Log($"[network] set '{name}' secondary address to {add[s].IpAddr}/{add[s].NetworkRange}");
}
}
// quelli unici di runningSecondaryAddressConfiguration sono da togliere
var del = runningSecondaryAddressConfiguration.Except(currentSecondaryAddressConfiguration).ToArray();
for (var s = 0; s < del.Length; s++)
{
if (!string.IsNullOrEmpty(del[s].IpAddr))
{
Ip.DeleteAddress(name, del[s].IpAddr, del[s].NetworkRange.ToString());
}
}
}
return(true);
}
public static bool Set()
{
var current = Application.CurrentConfiguration.NsSwitch;
var running = Application.RunningConfiguration.NsSwitch.ToString();
if (CommonString.AreEquals(current.ToString(), running))
{
return(true);
}
var lines = new List <string>();
if (!string.IsNullOrEmpty(current.Aliases))
{
lines.Add(CommonString.Append("aliases ", current.Aliases));
}
if (!string.IsNullOrEmpty(current.Ethers))
{
lines.Add(CommonString.Append("ethers ", current.Ethers));
}
if (!string.IsNullOrEmpty(current.Group))
{
lines.Add(CommonString.Append("group ", current.Group));
}
if (!string.IsNullOrEmpty(current.Hosts))
{
lines.Add(CommonString.Append("hosts ", current.Hosts));
}
if (!string.IsNullOrEmpty(current.Initgroups))
{
lines.Add(CommonString.Append("initgroups ", current.Initgroups));
}
if (!string.IsNullOrEmpty(current.Netgroup))
{
lines.Add(CommonString.Append("netgroup ", current.Netgroup));
}
if (!string.IsNullOrEmpty(current.Networks))
{
lines.Add(CommonString.Append("networks ", current.Networks));
}
if (!string.IsNullOrEmpty(current.Passwd))
{
lines.Add(CommonString.Append("passwd ", current.Passwd));
}
if (!string.IsNullOrEmpty(current.Protocols))
{
lines.Add(CommonString.Append("protocols ", current.Protocols));
}
if (!string.IsNullOrEmpty(current.Publickey))
{
lines.Add(CommonString.Append("publickey ", current.Publickey));
}
if (!string.IsNullOrEmpty(current.Rpc))
{
lines.Add(CommonString.Append("rpc ", current.Rpc));
}
if (!string.IsNullOrEmpty(current.Services))
{
lines.Add(CommonString.Append("services ", current.Services));
}
if (!string.IsNullOrEmpty(current.Shadow))
{
lines.Add(CommonString.Append("shadow ", current.Services));
}
if (!string.IsNullOrEmpty(current.Netmasks))
{
lines.Add(CommonString.Append("netmasks ", current.Netmasks));
}
if (!string.IsNullOrEmpty(current.Bootparams))
{
lines.Add(CommonString.Append("bootparams ", current.Bootparams));
}
if (!string.IsNullOrEmpty(current.Automount))
{
lines.Add(CommonString.Append("automount ", current.Automount));
}
if (File.Exists(nsswitchFile))
{
File.Copy(nsswitchFile, nsswitchFileBackup, true);
}
File.WriteAllLines(nsswitchFile, lines);
return(true);
}
