New Setup?

Ramses/home/RamsesUtils.js

@@ -0,0 +1,278 @@
+/** @param {NS} ns */
+export async function main(ns) {
+  ns.tprint("This is just a function library, it doesn't do anything.");
+}
+
+/** @param {NS} ns */
+export function getCracks(ns) {
+  let cracks = {};
+  if (ns.fileExists("BruteSSH.exe", "home")) {
+    cracks["BruteSSH.exe"] = ns.brutessh;
+  };
+  if (ns.fileExists("FTPCrack.exe", "home")) {
+    cracks["FTPCrack.exe"] = ns.ftpcrack;
+  };
+  if (ns.fileExists("relaySMTP.exe", "home")) {
+    cracks["relaySMTP.exe"] = ns.relaysmtp;
+  };
+  if (ns.fileExists("HTTPWorm.exe", "home")) {
+    cracks["HTTPWorm.exe"] = ns.httpworm;
+  };
+  if (ns.fileExists("SQLInject.exe", "home")) {
+    cracks["SQLInject.exe"] = ns.sqlinject;
+  };
+  return cracks;
+}
+
+/** @param {NS} ns */
+export function scanServerList(ns) {
+  const home = "home";
+  let serverList = {};
+  let unscanned = [];
+  unscanned.push(home);
+  while (unscanned.length > 0) {
+    let currentServer = unscanned.pop();
+    if (!serverList[currentServer]) {
+      let maxRam = ns.getServerMaxRam(currentServer);
+      let minPorts = ns.getServerNumPortsRequired(currentServer);
+      let minSecLevel = ns.getServerMinSecurityLevel(currentServer);
+      let minHackLevel = ns.getServerRequiredHackingLevel(currentServer);
+      let rootAccess = ns.hasRootAccess(currentServer);
+      let serverMoney = ns.getServerMaxMoney(currentServer);
+      let serverFiles = ns.ls(currentServer);
+      let skillFactor = (2.5 * minHackLevel * minSecLevel + 500) / (ns.getHackingLevel() + 50);
+      let compareTimeFactor = serverMoney / skillFactor / 10e7;
+      serverList[currentServer] =
+      {
+        serverName: currentServer,
+        maxRam: maxRam,
+        maxMoney: serverMoney,
+        minSec: minSecLevel,
+        minPorts: minPorts,
+        minHackLvl: minHackLevel,
+        rootAccess: rootAccess,
+        factorMoneyPerTime: compareTimeFactor,
+        openPorts: 0,
+        serverFiles: serverFiles,
+      };
+      let neighbours = ns.scan(currentServer);
+      for (let i = 0; i < neighbours.length; i++) {
+        let neighbour = neighbours[i];
+        if (serverList[neighbour]) {
+          continue
+        }
+        unscanned.push(neighbour);
+      }
+    }
+  }
+  ns.write("serverList.txt", JSON.stringify(serverList), "w");
+}
+
+/** @param {NS} ns */
+export function findBestTarget(ns, maxSec, maxPorts, currentHackLevel, manualTargetOverride) {
+  if (!ns.fileExists("serverList.txt", "home")) scanServerList();
+  let serverList = JSON.parse(ns.read("serverList.txt"));
+  let bestEntry = null;
+  let compareTime = 0;
+  for (const [name, entry] of Object.entries(serverList)) {
+    if (entry.minSec <= maxSec && entry.minPorts <= maxPorts && entry.minHackLvl < currentHackLevel) {
+      if (entry.factorMoneyPerTime > compareTime) {
+        compareTime = entry.factorMoneyPerTime;
+        bestEntry = name;
+      }
+    }
+  }
+  if (manualTargetOverride.length > 0) {
+    bestEntry = manualTargetOverride;
+  }
+  ns.write("bestTarget.txt", JSON.stringify(serverList[bestEntry]), "w");
+}
+
+
+/** @param {NS} ns */
+export function crackingAndRooting(ns, cracks, funnyScript, copy) {
+  if (!ns.fileExists("serverList.txt", "home")) scanServerList();
+  let serverList = JSON.parse(ns.read("serverList.txt"));
+  for (const [name, entry] of Object.entries(serverList)) {
+    let cracked = false;
+    let openPorts = serverList[name].openPorts || 0;
+    if (entry.minPorts === 0 || (entry.minPorts > openPorts && entry.minPorts <= Object.keys(cracks).length)) {
+      for (let k = 0; k < entry.minPorts; k++) {
+        cracks[Object.keys(cracks)[k]](name);
+        serverList[name].openPorts = k;
+      }
+      cracked = true;
+    }
+    if (!ns.hasRootAccess(name) && cracked === true) {
+      ns.nuke(name);
+      if (ns.hasRootAccess(name)) {
+        serverList[name].rootAccess = true;
+        if (serverList[name].maxRam > 0 && copy === true) {
+          copyAndRunScript(ns, funnyScript, name);
+        }
+      }
+    }
+    ns.write("serverList.txt", JSON.stringify(serverList), "w");
+  }
+  ns.tprint("Cracking and rooting done");
+}
+
+
+/** @param {NS} ns */
+export function copyAndRunScript(ns, funnyScript, currentServer) {
+  // change to run for one specific server with bestTarget from file
+  //let minRam = ns.getScriptRam(funnyScript);
+  let bestTarget = JSON.parse(ns.read("bestTarget.txt"));
+
+  let name = currentServer;
+  let serverList = JSON.parse(ns.read("serverList.txt"));
+  ns.print(name);
+  if (serverList[name].rootAccess === true && serverList[bestTarget.serverName].rootAccess === true) {
+    if (name !== "home") {
+      ns.print("killed threads on: " + name + ns.killall(name, true));
+    } else {
+      ns.print("killed threads on: " + name + ns.scriptKill(funnyScript[0], name));
+    };
+    //move script and run
+    if (serverList[name].maxRam > 0) {
+      ns.scp(funnyScript, name, "home");
+      let maxProcesses = 1;
+      if (serverList[name].maxRam >= 8) {
+        maxProcesses = Math.max(Math.floor((serverList[name].maxRam) / 8), 1);
+      } else {
+        maxProcesses = 1
+      };
+
+      for (let n = 1; n <= maxProcesses; n++) {
+        ns.exec(funnyScript[0], name, 1, bestTarget.serverName);
+      }
+
+      /*let maxThreads = 0;
+      if (name === "home") {
+        maxThreads = Math.floor((serverList[name].maxRam - ns.getServerUsedRam(name) - 32) / minRam);
+        ns.print(name + " " + maxThreads);
+      } else {
+        ns.print(name);
+        maxThreads = Math.floor(serverList[name].maxRam / minRam);
+        ns.print(name + " " + maxThreads);
+      };
+      while (maxThreads > 0) {
+        let threadsToAssign = maxThreads < 500 ? maxThreads : 500;
+        if (ns.exec(funnyScript, name, threadsToAssign, bestTarget.serverName, serverList[bestTarget.serverName].minSec, serverList[bestTarget.serverName].maxMoney, JSON.stringify(serverList[bestTarget.serverName])) !== 0) {
+          ns.print("Executing script on: " + name + " with: " + threadsToAssign + " threads out of " + maxThreads + " total threads");
+          maxThreads = maxThreads - threadsToAssign;
+        } else {
+          ns.tprint("Error running script on: " + name);
+          maxThreads = -1;
+        };
+      }*/
+    }
+  }
+}
+
+/** @param {NS} ns */
+export async function purchaseAndUpgradeServers(ns) {
+  ns.disableLog("sleep");
+  ns.disableLog("getServerMoneyAvailable");
+  ns.disableLog("getServerMaxRam");
+  let maxPurchasedServers = ns.getPurchasedServerLimit();
+  let purchasedServers = [];
+  let count = listPurchasedServers(ns).length;
+  let currentMoney = 0;
+  let serverList = {};
+  while (count < maxPurchasedServers) {
+    purchasedServers = listPurchasedServers(ns);
+    currentMoney = ns.getServerMoneyAvailable("home");
+    let targetRamInitial = 16;
+    if (ns.getPurchasedServerCost(targetRamInitial) < currentMoney) {
+      let hostname = ns.purchaseServer("pserv-" + purchasedServers.length, 16);
+
+      count = listPurchasedServers(ns).length;
+      serverList = JSON.parse(ns.read("serverList.txt"));
+      serverList[hostname] = {
+        serverName: hostname,
+        maxRam: 16,
+        maxMoney: 0,
+        minSec: 0,
+        minPorts: 5,
+        minHackLvl: 1,
+        rootAccess: true,
+        factorMoneyPerTime: 99999999,
+        openPorts: 0,
+      };
+      ns.write("serverList.txt", JSON.stringify(serverList), "w");
+      continue
+    } else {
+      await ns.sleep(5000);
+    }
+  }
+
+  let i = 5;
+  while (i < 21) {
+    let targetRam = 2 ** i;
+    purchasedServers = listPurchasedServers(ns);
+    for (let currentServer of purchasedServers) {
+      currentMoney = ns.getServerMoneyAvailable("home");
+
+      if (ns.getServerMaxRam(currentServer) < targetRam && ns.getPurchasedServerUpgradeCost(currentServer, targetRam) < currentMoney) {
+        if (ns.upgradePurchasedServer(currentServer, targetRam)) {
+          ns.print(currentServer + " upgraded to " + targetRam + " GB RAM");
+          serverList = JSON.parse(ns.read("serverList.txt"));
+          serverList[currentServer].maxRam = targetRam;
+          ns.write("serverList.txt", JSON.stringify(serverList), "w");
+        }
+      } else {
+        await ns.sleep(5000);
+        continue
+      };
+    }
+    ++i;
+  }
+  ns.tprint("Extiting purchaseServers script!")
+}
+
+/** @param {NS} ns */
+function listPurchasedServers(ns) {
+  return ns.getPurchasedServers();
+}
+
+/** @param {NS} ns */
+export async function runControllerOnPserv(ns) {
+  let purchasedServers = listPurchasedServers(ns);
+  let nPID = 0;
+  nPID = ns.exec("S2controller.js", "home");
+  ns.tprint("Started S2controller.js on " + "home" + " with PID " + nPID)
+  for (let currentServer of purchasedServers) {
+    ns.scp(["S2tGrow.js", "S2tWeaken.js", "S2tHack.js", "S2controller.js", "S2utils.js"], currentServer, "home");
+    nPID = ns.exec("S2controller.js", currentServer);
+    if (nPID > 0) {
+      ns.tprint("Started S2controller.js on " + currentServer + " with PID " + nPID)
+    }
+  }
+}
+
+/** @param {NS} ns */
+export async function backdoor(ns) {
+  let serverList = JSON.parse(ns.read("serverList.txt"));
+  let lasthackingLevel = 0;
+  let currentHackingLevel = 0;
+  while (true) {
+    currentHackingLevel = ns.getHackingLevel();
+    if (currentHackingLevel > lasthackingLevel) {
+      lasthackingLevel = currentHackingLevel;
+      for (const [name, entry] of Object.entries(serverList)) {
+        if (entry.minHackLvl <= lasthackingLevel && entry.hasBackdoor !== true) {
+          ns.singularity.connect(name);
+          await ns.singularity.installBackdoor();
+          ns.singularity.connect("home");
+          serverList[name].hasBackdoor = true;
+          ns.tprint("Backdoor on: " + name);
+        }
+      }
+      ns.write("serverList.txt", JSON.stringify(serverList), "w");
+    } else {
+      await ns.sleep(30000)
+    };
+
+  }
+}