xd
/
odroid_go_server_manager
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

structs, better error checking, number conversion

Browse Source
main
xad1 3 years ago
parent 9c40400d26
commit 427aab95ea
10 changed files with 370 additions and 167 deletions
Show Stats Download Patch File Download Diff File

52
.vscode/settings.json vendored
Unescape View File

@ -0,0 +1,52 @@
{
"files.associations": {
"stdexcept": "cpp",
"array": "cpp",
"atomic": "cpp",
"*.tcc": "cpp",
"cctype": "cpp",
"clocale": "cpp",
"cmath": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdint": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cstring": "cpp",
"ctime": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"deque": "cpp",
"unordered_map": "cpp",
"unordered_set": "cpp",
"vector": "cpp",
"exception": "cpp",
"algorithm": "cpp",
"functional": "cpp",
"iterator": "cpp",
"map": "cpp",
"memory": "cpp",
"memory_resource": "cpp",
"numeric": "cpp",
"optional": "cpp",
"random": "cpp",
"string": "cpp",
"string_view": "cpp",
"system_error": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"fstream": "cpp",
"initializer_list": "cpp",
"iomanip": "cpp",
"iosfwd": "cpp",
"istream": "cpp",
"limits": "cpp",
"new": "cpp",
"ostream": "cpp",
"sstream": "cpp",
"streambuf": "cpp",
"cinttypes": "cpp",
"typeinfo": "cpp"
}
}

4
include/global.h
Unescape View File

@ -4,6 +4,8 @@
extern String selectedNode; extern String selectedNode;
extern int selectedItem; extern int selectedItem;
extern int selectedLXC;
extern int selectedVM;
// TODO remove later
#endif #endif

39
include/json/retrieve.h
Unescape View File

@ -2,8 +2,41 @@
#define JSON_RETRIEVE_H #define JSON_RETRIEVE_H
#include <ArduinoJson.h> #include <ArduinoJson.h>
JsonArray getNodeInfo(); typedef struct {
JsonArray getContainerInfo(String node); String name;
JsonArray getVMInfo(String node); int cpu;
int threads;
String onlineStatus;
long long mem;
long long maxmem;
long long disk;
long long maxdisk;
long long uptime;
} Node;
typedef struct {
String name;
int id;
String onlineStatus;
long long maxmem;
long long maxdisk;
long long uptime;
} Container;
typedef struct {
String name;
int id;
String onlineStatus;
long long maxmem;
long long maxdisk;
long long uptime;
long long netin;
long long netout;
} VM;
Node *getNodeInfo(int *numNodes);
Container *getContainerInfo(int *numContainers, String node);
VM *getVMInfo(int *numVMs, String node);
#endif /* JSON_RETRIEVE_H */ #endif /* JSON_RETRIEVE_H */

8
include/json/utils.h
Unescape View File

@ -1,8 +1,10 @@
#ifndef JSON_UTILS_H #ifndef JSON_UTILS_H
#define JSON_UTILS_H #define JSON_UTILS_H
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <json/retrieve.h>
JsonObject getNode(String name, JsonArray nodes); //JsonObject getNode(String name, JsonArray nodes);
JsonObject getContainer(int id, JsonArray containers); Node getNode(String name);
Container getContainer(int id, String node);
VM getVM(int id, String node);
#endif /* JSON_UTILS_H */ #endif /* JSON_UTILS_H */

6
include/menu.h
Unescape View File

@ -2,14 +2,16 @@
#define MENU_H_ #define MENU_H_
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <Arduino.h> #include <Arduino.h>
#include <json/retrieve.h>
// Struct for static menu items such as on the main menu. Has the name of the menu item and a function to run when it is selected. // Struct for static menu items such as on the main menu. Has the name of the menu item and a function to run when it is selected.
typedef struct { typedef struct {
String name; String name;
void (*function)(); void (*function)();
} MenuItem; } MenuItem;
void listNodes(JsonArray nodes); void listNodes(Node* nodes, int numItems);
int listContainers(JsonArray containers); void listContainers(Container* containers, int numItems);
void listVMs(VM* vms, int numItems);
void mainMenu(); void mainMenu();
extern int selectedItem; extern int selectedItem;

96
src/json/retrieve.cpp
Unescape View File

@ -2,14 +2,11 @@
#include <HTTPClient.h> #include <HTTPClient.h>
#include <server.h> #include <server.h>
#include <utils.h> #include <utils.h>
#include <json/retrieve.h>
#include <stdexcept>
// todo make the bottom part of these into one function Node *getNodeInfo(int *numNodes)
// ###################################### {
// ######################################
// ######################################
// ######################################
// ######################################
JsonArray getNodeInfo() {
HTTPClient http; HTTPClient http;
String apiAddress = PROXMOX_ADDRESS + "/api2/json/nodes/"; String apiAddress = PROXMOX_ADDRESS + "/api2/json/nodes/";
String auth = "PVEAPIToken=" + PROXMOX_TOKEN_USER + "!" + PROXMOX_TOKEN_NAME + "=" + PROXMOX_TOKEN_SECRET; String auth = "PVEAPIToken=" + PROXMOX_TOKEN_USER + "!" + PROXMOX_TOKEN_NAME + "=" + PROXMOX_TOKEN_SECRET;
@ -19,19 +16,36 @@ JsonArray getNodeInfo() {
http.setAuthorization(authc); http.setAuthorization(authc);
int httpCode = http.GET(); int httpCode = http.GET();
if (httpCode > 0) { if (httpCode > 0)
{
String json = http.getString(); String json = http.getString();
DynamicJsonDocument doc(1024); DynamicJsonDocument doc(6144);
deserializeJson(doc, json); deserializeJson(doc, json);
JsonArray nodes = doc["data"].as<JsonArray>(); JsonArray nodes = doc["data"].as<JsonArray>();
return nodes; Node *nodeArray = new Node[nodes.size()];
}
for (int i = 0; i < nodes.size(); i++)
{
nodeArray[i].name = nodes[i]["node"].as<String>();
nodeArray[i].cpu = nodes[i]["cpu"].as<int>();
nodeArray[i].threads = nodes[i]["maxcpu"].as<int>();
nodeArray[i].onlineStatus = nodes[i]["status"].as<String>();
nodeArray[i].mem = nodes[i]["mem"].as<long long>();
nodeArray[i].maxmem = nodes[i]["maxmem"].as<long long>();
nodeArray[i].disk = nodes[i]["disk"].as<long long>();
nodeArray[i].maxdisk = nodes[i]["maxdisk"].as<long long>();
nodeArray[i].uptime = nodes[i]["uptime"].as<long long>();
}
displayError("Error getting data."); *numNodes = nodes.size();
return getNodeInfo(); return nodeArray;
}
throw std::runtime_error("Can't get node info: HTTP request failed with code: " + httpCode);
} }
JsonArray getContainerInfo(String node) { Container *getContainerInfo(int *numContainers, String node)
{
HTTPClient http; HTTPClient http;
String apiAddress = PROXMOX_ADDRESS + "/api2/json/nodes/" + node + "/lxc"; String apiAddress = PROXMOX_ADDRESS + "/api2/json/nodes/" + node + "/lxc";
String auth = "PVEAPIToken=" + PROXMOX_TOKEN_USER + "!" + PROXMOX_TOKEN_NAME + "=" + PROXMOX_TOKEN_SECRET; String auth = "PVEAPIToken=" + PROXMOX_TOKEN_USER + "!" + PROXMOX_TOKEN_NAME + "=" + PROXMOX_TOKEN_SECRET;
@ -41,19 +55,33 @@ JsonArray getContainerInfo(String node) {
http.setAuthorization(authc); http.setAuthorization(authc);
int httpCode = http.GET(); int httpCode = http.GET();
if (httpCode > 0) { if (httpCode > 0)
{
String json = http.getString(); String json = http.getString();
DynamicJsonDocument doc(1024); DynamicJsonDocument doc(1024);
deserializeJson(doc, json); deserializeJson(doc, json);
JsonArray nodes = doc["data"].as<JsonArray>(); JsonArray containers = doc["data"].as<JsonArray>();
return nodes; Container *containerArray = new Container[containers.size()];
for (int i = 0; i < containers.size(); i++)
{
containerArray[i].name = containers[i]["name"].as<String>();
containerArray[i].id = containers[i]["vmid"].as<int>();
containerArray[i].onlineStatus = containers[i]["status"].as<String>();
containerArray[i].maxmem = containers[i]["maxmem"].as<long long>();
containerArray[i].maxdisk = containers[i]["maxdisk"].as<long long>();
containerArray[i].uptime = containers[i]["uptime"].as<long long>();
}
*numContainers = containers.size();
return containerArray;
} }
displayError("Error getting data."); throw std::runtime_error("Can't get container info: HTTP request failed with code: " + httpCode);
return getNodeInfo();
} }
JsonArray getVMInfo(String node) { VM *getVMInfo(int *numVMs, String node)
{
HTTPClient http; HTTPClient http;
String apiAddress = PROXMOX_ADDRESS + "/api2/json/nodes/" + node + "/qemu"; String apiAddress = PROXMOX_ADDRESS + "/api2/json/nodes/" + node + "/qemu";
String auth = "PVEAPIToken=" + PROXMOX_TOKEN_USER + "!" + PROXMOX_TOKEN_NAME + "=" + PROXMOX_TOKEN_SECRET; String auth = "PVEAPIToken=" + PROXMOX_TOKEN_USER + "!" + PROXMOX_TOKEN_NAME + "=" + PROXMOX_TOKEN_SECRET;
@ -63,14 +91,28 @@ JsonArray getVMInfo(String node) {
http.setAuthorization(authc); http.setAuthorization(authc);
int httpCode = http.GET(); int httpCode = http.GET();
if (httpCode > 0) { if (httpCode > 0)
{
String json = http.getString(); String json = http.getString();
DynamicJsonDocument doc(1024); DynamicJsonDocument doc(1024);
deserializeJson(doc, json); deserializeJson(doc, json);
JsonArray nodes = doc["data"].as<JsonArray>(); JsonArray vms = doc["data"].as<JsonArray>();
return nodes; VM *vmArray = new VM[vms.size()];
}
displayError("Error getting data."); for (int i = 0; i < vms.size(); i++)
return getNodeInfo(); {
} vmArray[i].name = vms[i]["name"].as<String>();
vmArray[i].id = vms[i]["vmid"].as<int>();
vmArray[i].onlineStatus = vms[i]["status"].as<String>();
vmArray[i].maxmem = vms[i]["maxmem"].as<long long>();
vmArray[i].maxdisk = vms[i]["maxdisk"].as<long long>();
vmArray[i].uptime = vms[i]["uptime"].as<long long>();
vmArray[i].netin = vms[i]["netin"].as<long long>();
vmArray[i].netout = vms[i]["netout"].as<long long>();
}
*numVMs = vms.size();
return vmArray;
}
throw std::runtime_error("Can't get VM info: HTTP request failed with code: " + httpCode);
}

55
src/json/utils.cpp
Unescape View File

@ -1,27 +1,52 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <json/utils.h>
#include <utils.h> #include <utils.h>
#include <stdexcept>
/** Node getNode(String name)
Get a specific node from an array of nodes {
*/ int numNodes;
JsonObject getNode(String name, JsonArray nodes) {
for (JsonObject node : nodes) { Node *nodes = getNodeInfo(&numNodes);
if (node["node"] == name) { for (int i = 0; i < numNodes; i++)
return node; {
if (nodes[i].name == name)
{
return nodes[i];
}
}
throw std::runtime_error("Can't find the requested node in the array");
}
Container getContainer(int id, String node)
{
int numContainers;
Container *containers = getContainerInfo(&numContainers, node);
for (int i = 0; i < numContainers; i++)
{
if (containers[i].id == id)
{
return containers[i];
} }
} }
displayError("Node not found!");
throw std::runtime_error("Can't find the requested container in the array");
} }
JsonObject getContainer(int id, JsonArray containers) { VM getVM(int id, String node)
for (JsonObject container : containers) { {
Serial.println(id); int numVMs;
Serial.println(container["vmid"].as<int>());
if (container["vmid"].as<int>() == id) { VM *vms = getVMInfo(&numVMs, node);
return container; for (int i = 0; i < numVMs; i++)
{
if (vms[i].id == id)
{
return vms[i];
} }
} }
displayError("Machine not found!");
throw std::runtime_error("Can't find the requested vm in the array");
} }

28
src/main.cpp
Unescape View File

@ -7,22 +7,34 @@
#include <menu.h> #include <menu.h>
#include <json/retrieve.h> #include <json/retrieve.h>
void setup() { void setup()
{
Serial.begin(115200); Serial.begin(115200);
GO.begin(); GO.begin();
connectWiFi(); connectWiFi();
} }
void loop()
{
void loop() { if (WiFi.status() != WL_CONNECTED)
{
if (WiFi.status() != WL_CONNECTED) {
displayError("WiFi Connection Lost"); displayError("WiFi Connection Lost");
connectWiFi(); connectWiFi();
} }
listNodes(getNodeInfo());
selectedItem = 0;
mainMenu();
try
{
int numNodes;
Node *nodes = getNodeInfo(&numNodes);
listNodes(nodes, numNodes);
selectedItem = 0;
mainMenu();
}
catch (const std::exception &e)
{
Serial.println(e.what());
displayError(e.what());
}
} }

75
src/menu.cpp
Unescape View File

@ -2,11 +2,19 @@
#include <Arduino.h> #include <Arduino.h>
#include <odroid_go.h> #include <odroid_go.h>
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <global.h>
#include <statistics.h> #include <statistics.h>
#include <global.h>
const int MAIN_TEXT_COLOR = WHITE;
const int MAIN_TEXT_SIZE = 2;
int selectedItem = 0; int selectedItem = 0;
String selectedNode = ""; String selectedNode = "";
int selectedLXC = 0;
int selectedVM = 0;
@ -24,10 +32,12 @@ int buttonListener(int numItems) {
GO.update(); GO.update();
if (GO.JOY_Y.isAxisPressed() == 1 && selectedItem < (numItems - 1)) { if (GO.JOY_Y.isAxisPressed() == 1 && selectedItem < (numItems - 1)) {
selectedItem++; selectedItem++;
Serial.println(selectedItem);
break; break;
} }
if (GO.JOY_Y.isAxisPressed() == 2 && selectedItem > 0) { if (GO.JOY_Y.isAxisPressed() == 2 && selectedItem > 0) {
selectedItem--; selectedItem--;
Serial.println(selectedItem);
break; break;
} }
if (GO.BtnA.isPressed() == 1) { if (GO.BtnA.isPressed() == 1) {
@ -46,6 +56,8 @@ int buttonListener(int numItems) {
void drawMenu(MenuItem menuItems[], int numItems) { void drawMenu(MenuItem menuItems[], int numItems) {
GO.lcd.clearDisplay(); GO.lcd.clearDisplay();
GO.lcd.setCursor(0, 0); GO.lcd.setCursor(0, 0);
GO.lcd.setTextColor(MAIN_TEXT_COLOR);
GO.lcd.setTextSize(MAIN_TEXT_SIZE);
for (int i = 0; i < numItems; i++) { for (int i = 0; i < numItems; i++) {
@ -65,6 +77,7 @@ void drawMenu(MenuItem menuItems[], int numItems) {
break; break;
default: default:
drawMenu(menuItems, numItems); drawMenu(menuItems, numItems);
break;
} }
} }
@ -74,56 +87,84 @@ void mainMenu(){
drawMenu(mainMenuItems, numItems); drawMenu(mainMenuItems, numItems);
} }
void listNodes(JsonArray nodes) { void listNodes(Node* nodes, int numItems) {
GO.lcd.clearDisplay(); GO.lcd.clearDisplay();
GO.lcd.setTextColor(MAIN_TEXT_COLOR);
GO.lcd.setTextSize(MAIN_TEXT_SIZE);
GO.lcd.setCursor(0, 0); GO.lcd.setCursor(0, 0);
int numItems = nodes.size();
for (int i = 0; i < numItems; i++) { for (int i = 0; i < numItems; i++) {
if (selectedItem == i) { if (selectedItem == i) {
GO.lcd.print("> "); GO.lcd.print("> ");
} }
GO.lcd.println(nodes[i]["node"].as<String>()); GO.lcd.println(nodes[i].name);
} }
switch (buttonListener(numItems)) { switch (buttonListener(numItems)) {
case 1: case 1:
Serial.println("selected " + selectedItem); Serial.println("selected " + selectedItem);
selectedNode = nodes[selectedItem]["node"].as<String>(); selectedNode = nodes[selectedItem].name;
break; break;
case 2: case 2:
Serial.println("back"); Serial.println("back");
break; break;
default: default:
listNodes(nodes); listNodes(nodes, numItems);
break;
} }
} }
int listContainers(JsonArray containers) { void listContainers(Container* containers, int numItems) {
GO.lcd.clearDisplay(); GO.lcd.clearDisplay();
GO.lcd.setCursor(0, 0); GO.lcd.setCursor(0, 0);
int numItems = containers.size(); GO.lcd.setTextColor(MAIN_TEXT_COLOR);
int selectedLXC = 0; GO.lcd.setTextSize(MAIN_TEXT_SIZE);
for (int i = 0; i < numItems; i++) { for (int i = 0; i < numItems; i++) {
if (selectedItem == i) { if (selectedItem == i) {
GO.lcd.print("> "); GO.lcd.print("> ");
} }
GO.lcd.println(containers[i]["vmid"].as<String>() + ": " + containers[i]["name"].as<String>()); GO.lcd.println(String(containers[i].id) + ": " + containers[i].name);
} }
switch (buttonListener(numItems)) { switch (buttonListener(numItems)) {
case 1: case 1:
selectedLXC = containers[selectedItem]["vmid"].as<int>(); selectedLXC = containers[selectedItem].id;
Serial.println(selectedLXC);
break; break;
case 2: case 2:
Serial.println("back"); Serial.println("back");
break; break;
default: default:
listContainers(containers); listContainers(containers, numItems);
break;
}
}
void listVMs(VM* vms, int numItems) {
GO.lcd.clearDisplay();
GO.lcd.setCursor(0, 0);
GO.lcd.setTextColor(MAIN_TEXT_COLOR);
GO.lcd.setTextSize(MAIN_TEXT_SIZE);
for (int i = 0; i < numItems; i++) {
if (selectedItem == i) {
GO.lcd.print("> ");
}
GO.lcd.println(String(vms[i].id) + ": " + vms[i].name);
}
switch (buttonListener(numItems)) {
case 1:
selectedVM = vms[selectedItem].id;
break;
case 2:
Serial.println("back");
break;
default:
listVMs(vms, numItems);
break;
} }
Serial.println(selectedLXC);
Serial.println("end");
return selectedLXC;
} }

174
src/statistics.cpp
Unescape View File

@ -3,139 +3,131 @@
#include <global.h> #include <global.h>
#include <menu.h> #include <menu.h>
#include <odroid_go.h> #include <odroid_go.h>
#include <utils.h>
String convertBytes(long long value) {
if (value > 1099511627776) {
return String(value / 1099511627776) + " TB";
}
if (value > 1073741824) {
return String(value / 1073741824) + " GB";
}
if (value > 1048576) {
return String(value / 1048576) + " MB";
}
if (value > 1024) {
return String(value / 1024) + " KB";
}
return String(value) + " Bytes";
}
void printNodeStats(JsonObject node) {
String name = node["node"].as<String>();
int cpu = round(node["cpu"].as<float>() * 100);
int threads = node["maxcpu"].as<int>();
String onlineStatus = node["status"].as<String>();
String mem = node["mem"].as<String>();
String maxmem = node["maxmem"].as<String>();
String disk = node["disk"].as<String>();
String maxdisk = node["maxdisk"].as<String>();
String uptime = node["uptime"].as<String>();
// these are strings for now because they could be way too big
String convertTime(long long value) {
if (value > 3600) {
return String(value / 3600) + " hrs";
}
if (value > 60) {
return String(value / 60) + " mins";
}
return String(value) + " secs";
}
void printNodeStats(Node node)
{
GO.lcd.fillScreen(WHITE); GO.lcd.fillScreen(WHITE);
GO.lcd.setCursor(0, 0); GO.lcd.setCursor(0, 0);
GO.lcd.setTextColor(BLACK); GO.lcd.setTextColor(BLACK);
GO.lcd.setTextSize(3); GO.lcd.setTextSize(3);
GO.lcd.println(name); GO.lcd.println(node.name);
GO.lcd.setTextSize(2); GO.lcd.setTextSize(2);
GO.lcd.println("--------------------------"); GO.lcd.println("--------------------------");
GO.lcd.println("Status: " + onlineStatus); GO.lcd.println("Status: " + node.onlineStatus);
GO.lcd.println("Uptime: " + uptime + "s"); GO.lcd.println("Uptime: " + convertTime(node.uptime));
GO.lcd.println("CPU: " + String(cpu) + "%"); GO.lcd.println("CPU: " + String(node.cpu) + "%");
GO.lcd.println("Threads: " + String(threads)); GO.lcd.println("Threads: " + String(node.threads));
GO.lcd.println("RAM: " + mem); GO.lcd.println("RAM: " + convertBytes(node.mem));
GO.lcd.println("Max RAM: " + maxmem); GO.lcd.println("Max RAM: " + convertBytes(node.maxmem));
GO.lcd.println("Disk: " + disk); GO.lcd.println("Disk: " + convertBytes(node.disk));
GO.lcd.println("Max Disk: " + maxdisk); GO.lcd.println("Max Disk: " + convertBytes(node.maxdisk));
} }
void printContainerStats(JsonObject container) { void printContainerStats(Container container)
String name = container["name"].as<String>(); {
String id = container["vmid"].as<String>();
String onlineStatus = container["status"].as<String>();
String maxmem = container["maxmem"].as<String>();
String maxdisk = container["maxdisk"].as<String>();
String uptime = container["uptime"].as<String>();
// these are strings for now because they could be way too big
GO.lcd.fillScreen(WHITE); GO.lcd.fillScreen(WHITE);
GO.lcd.setCursor(0, 0); GO.lcd.setCursor(0, 0);
GO.lcd.setTextColor(BLACK); GO.lcd.setTextColor(BLACK);
GO.lcd.setTextSize(3); GO.lcd.setTextSize(3);
GO.lcd.println(id + ": " + name); GO.lcd.println(String(container.id) + ": " + container.name);
GO.lcd.setTextSize(2); GO.lcd.setTextSize(2);
GO.lcd.println("--------------------------"); GO.lcd.println("--------------------------");
GO.lcd.println("Status: " + onlineStatus); GO.lcd.println("Status: " + container.onlineStatus);
GO.lcd.println("Uptime: " + uptime + "s"); GO.lcd.println("Uptime: " + convertTime(container.uptime));
GO.lcd.println("Max RAM: " + maxmem); GO.lcd.println("Max RAM: " + convertBytes(container.maxmem));
GO.lcd.println("Max Disk: " + maxdisk); GO.lcd.println("Max Disk: " + convertBytes(container.maxdisk));
} }
void printVMStats(JsonObject vm) { void printVMStats(VM vm)
String name = vm["name"].as<String>(); {
String id = vm["vmid"].as<String>();
int cpu = round(vm["cpu"].as<float>() * 100);
int cores = vm["cpus"].as<int>();
String onlineStatus = vm["status"].as<String>();
String mem = vm["mem"].as<String>();
String maxmem = vm["maxmem"].as<String>();
String maxdisk = vm["maxdisk"].as<String>();
String uptime = vm["uptime"].as<String>();
String netin = vm["netin"].as<String>();
String netout = vm["netout"].as<String>();
// these are strings for now because they could be way too big
GO.lcd.fillScreen(WHITE); GO.lcd.fillScreen(WHITE);
GO.lcd.setCursor(0, 0); GO.lcd.setCursor(0, 0);
GO.lcd.setTextColor(BLACK); GO.lcd.setTextColor(BLACK);
GO.lcd.setTextSize(3); GO.lcd.setTextSize(3);
GO.lcd.println(id + ": " + name); GO.lcd.println(String(vm.id) + ": " + vm.name);
GO.lcd.setTextSize(2); GO.lcd.setTextSize(2);
GO.lcd.println("--------------------------"); GO.lcd.println("--------------------------");
GO.lcd.println("Status: " + onlineStatus); GO.lcd.println("Status: " + vm.onlineStatus);
GO.lcd.println("Uptime: " + uptime + "s"); GO.lcd.println("Uptime: " + convertTime(vm.uptime));
GO.lcd.println("CPU: " + String(cpu) + "%"); GO.lcd.println("Max RAM: " + convertBytes(vm.maxmem));
GO.lcd.println("Cores: " + String(cores)); GO.lcd.println("Max Disk: " + convertBytes(vm.maxdisk));
GO.lcd.println("RAM: " + mem);
GO.lcd.println("Max RAM: " + maxmem);
GO.lcd.println("Max Disk: " + maxdisk);
GO.lcd.println("Net In: " + netin);
GO.lcd.println("Net Out: " + netout);
} }
void nodeInfo()
void nodeInfo() { {
Serial.println("nodeinfo"); Serial.println("nodeinfo");
while (true) { while (true)
printNodeStats(getNode(selectedNode, getNodeInfo())); {
printNodeStats(getNode(selectedNode));
delay(2000); delay(2000);
} }
} }
void containerInfo() { void containerInfo()
{
Serial.println("container info"); Serial.println("container info");
JsonArray containerArray = getContainerInfo(selectedNode);
selectedItem = 0; selectedItem = 0;
int selectedLXC = listContainers(containerArray); int numContainers;
JsonObject container = getContainer(selectedLXC, containerArray);
printContainerStats(container); Container *containers = getContainerInfo(&numContainers, selectedNode);
delay(1000);
listContainers(containers, numContainers);
// only redraw screen if changed
while (true) { while (true)
if (getContainer(selectedLXC, containerArray) != container) { {
containerInfo(); printContainerStats(getContainer(selectedLXC, selectedNode));
} delay(5000);
} }
} }
void vmInfo() { void vmInfo()
{
Serial.println("vm info"); Serial.println("vm info");
JsonArray vmArray = getVMInfo(selectedNode);
selectedItem = 0; selectedItem = 0;
int selectedVM = listContainers(vmArray); int numVMs;
Serial.println("vm"); VM *vms = getVMInfo(&numVMs, selectedNode);
Serial.println(selectedVM); if (vms != NULL)
Serial.println(selectedVM); {
Serial.println(selectedVM); listVMs(vms, numVMs);
Serial.println(selectedVM);
while (true)
while (true) { {
printVMStats(getContainer(selectedVM, vmArray)); printVMStats(getVM(selectedVM, selectedNode));
delay(2000); delay(5000);
}
} }
}
}

Write Preview
Loading…
Cancel
Save