Skip to content
This repository was archived by the owner on Jul 4, 2025. It is now read-only.

Commit 1db42eb

Browse files
github-roushangithub-roushan
committed
chore: refactor code for readability and leverage C++17 features
1 parent 161de9c commit 1db42eb

2 files changed

Lines changed: 147 additions & 131 deletions

File tree

‎engine/cli/commands/hardware_list_cmd.cc‎

Lines changed: 126 additions & 128 deletions
Original file line numberDiff line numberDiff line change
@@ -9,15 +9,16 @@
99
#include "utils/logging_utils.h"
1010
// clang-format off
1111
#include <tabulate/table.hpp>
12+
#include<numeric>
1213
// clang-format on
1314

1415
namespace commands {
15-
using namespace tabulate;
16-
using Row_t =
17-
std::vector<variant<std::string, const char*, string_view, Table>>;
16+
using Row_t = std::vector<
17+
variant<std::string, const char*, string_view, tabulate::Table>>;
1818

19-
bool HardwareListCmd::Exec(const std::string& host, int port,
20-
const std::optional<HarwareOptions>& ho) {
19+
bool HardwareListCmd::Exec(
20+
const std::string& host, int port,
21+
const std::optional<HardwareQueryFlags>& query_flags) {
2122
// Start server if server is not started yet
2223
if (!commands::IsServerAlive(host, port)) {
2324
CLI_LOG("Starting server ...");
@@ -33,149 +34,146 @@ bool HardwareListCmd::Exec(const std::string& host, int port,
3334
/* .pathParams = */ {"v1", "hardware"},
3435
/* .queries = */ {},
3536
};
36-
auto result = curl_utils::SimpleGetJson(url.ToFullPath());
37-
if (result.has_error()) {
38-
CTL_ERR(result.error());
37+
38+
auto hardware_json_response = curl_utils::SimpleGetJson(url.ToFullPath());
39+
if (hardware_json_response.has_error()) {
40+
CTL_ERR(hardware_json_response.error());
3941
return false;
4042
}
4143

42-
if (!ho.has_value() || ho.value().show_cpu) {
44+
// CPU Section
45+
if (!query_flags.has_value() || query_flags.value().show_cpu) {
4346
std::cout << "CPU Information:" << std::endl;
44-
Table table;
45-
std::vector<std::string> column_headers{"#", "Arch", "Cores",
46-
"Model", "Usage", "Instructions"};
47-
48-
Row_t header{column_headers.begin(), column_headers.end()};
49-
table.add_row(header);
50-
table.format().font_color(Color::green);
51-
std::vector<std::string> row = {"1"};
52-
cortex::hw::CPU cpu = cortex::hw::cpu::FromJson(result.value()["cpu"]);
53-
row.emplace_back(cpu.arch);
54-
row.emplace_back(std::to_string(cpu.cores));
55-
row.emplace_back(cpu.model);
56-
row.emplace_back(std::to_string(cpu.usage));
57-
std::string insts;
58-
for (auto const& i : cpu.instructions) {
59-
insts += i + " ";
60-
};
61-
row.emplace_back(insts);
62-
table.add_row({row.begin(), row.end()});
63-
std::cout << table << std::endl;
64-
std::cout << std::endl;
47+
tabulate::Table cpu_table;
48+
cpu_table.add_row(Row_t(CPU_INFO_HEADERS.begin(), CPU_INFO_HEADERS.end()));
49+
cpu_table.format()
50+
.font_style({tabulate::FontStyle::bold})
51+
.font_align(tabulate::FontAlign::center)
52+
.padding_left(1)
53+
.padding_right(1);
54+
55+
cortex::hw::CPU cpu =
56+
cortex::hw::cpu::FromJson(hardware_json_response.value()["cpu"]);
57+
std::vector<std::string> cpu_row = {
58+
"1",
59+
cpu.arch,
60+
std::to_string(cpu.cores),
61+
cpu.model,
62+
std::to_string(cpu.usage),
63+
std::accumulate(cpu.instructions.begin(), cpu.instructions.end(),
64+
std::string{},
65+
[](const std::string& a, const std::string& b) {
66+
return a + (a.empty() ? "" : " ") + b;
67+
})};
68+
cpu_table.add_row(Row_t(cpu_row.begin(), cpu_row.end()));
69+
std::cout << cpu_table << std::endl << std::endl;
6570
}
6671

67-
if (!ho.has_value() || ho.value().show_os) {
72+
// OS Section
73+
if (!query_flags.has_value() || query_flags.value().show_os) {
6874
std::cout << "OS Information:" << std::endl;
69-
Table table;
70-
std::vector<std::string> column_headers{"#", "Version", "Name"};
71-
72-
Row_t header{column_headers.begin(), column_headers.end()};
73-
table.add_row(header);
74-
table.format().font_color(Color::green);
75-
std::vector<std::string> row = {"1"};
76-
cortex::hw::OS os = cortex::hw::os::FromJson(result.value()["os"]);
77-
row.emplace_back(os.version);
78-
row.emplace_back(os.name);
79-
table.add_row({row.begin(), row.end()});
80-
std::cout << table << std::endl;
81-
std::cout << std::endl;
75+
tabulate::Table os_table;
76+
os_table.add_row(Row_t(OS_INFO_HEADERS.begin(), OS_INFO_HEADERS.end()));
77+
os_table.format()
78+
.font_style({tabulate::FontStyle::bold})
79+
.font_align(tabulate::FontAlign::center)
80+
.padding_left(1)
81+
.padding_right(1);
82+
83+
cortex::hw::OS os =
84+
cortex::hw::os::FromJson(hardware_json_response.value()["os"]);
85+
std::vector<std::string> os_row = {"1", os.version, os.name};
86+
os_table.add_row(Row_t(os_row.begin(), os_row.end()));
87+
std::cout << os_table << std::endl << std::endl;
8288
}
8389

84-
if (!ho.has_value() || ho.value().show_ram) {
90+
// RAM Section
91+
if (!query_flags.has_value() || query_flags.value().show_ram) {
8592
std::cout << "RAM Information:" << std::endl;
86-
Table table;
87-
std::vector<std::string> column_headers{"#", "Total (MiB)",
88-
"Available (MiB)"};
89-
90-
Row_t header{column_headers.begin(), column_headers.end()};
91-
table.add_row(header);
92-
table.format().font_color(Color::green);
93-
std::vector<std::string> row = {"1"};
94-
cortex::hw::Memory m = cortex::hw::memory::FromJson(result.value()["ram"]);
95-
row.emplace_back(std::to_string(m.total_MiB));
96-
row.emplace_back(std::to_string(m.available_MiB));
97-
table.add_row({row.begin(), row.end()});
98-
std::cout << table << std::endl;
99-
std::cout << std::endl;
93+
tabulate::Table ram_table;
94+
ram_table.add_row(Row_t(RAM_INFO_HEADERS.begin(), RAM_INFO_HEADERS.end()));
95+
ram_table.format()
96+
.font_style({tabulate::FontStyle::bold})
97+
.font_align(tabulate::FontAlign::center)
98+
.padding_left(1)
99+
.padding_right(1);
100+
101+
cortex::hw::Memory ram =
102+
cortex::hw::memory::FromJson(hardware_json_response.value()["ram"]);
103+
std::vector<std::string> ram_row = {"1", std::to_string(ram.total_MiB),
104+
std::to_string(ram.available_MiB)};
105+
ram_table.add_row(Row_t(ram_row.begin(), ram_row.end()));
106+
std::cout << ram_table << std::endl << std::endl;
100107
}
101108

102-
if (!ho.has_value() || ho.value().show_gpu) {
109+
// GPU Section
110+
if (!query_flags.has_value() || query_flags.value().show_gpu) {
103111
std::cout << "GPU Information:" << std::endl;
104-
Table table;
105-
std::vector<std::string> column_headers{"#",
106-
"GPU ID",
107-
"Name",
108-
"Version",
109-
"Total (MiB)",
110-
"Available (MiB)",
111-
"Driver Version",
112-
"Compute Capability",
113-
"Activated"};
114-
115-
Row_t header{column_headers.begin(), column_headers.end()};
116-
table.add_row(header);
117-
table.format().font_color(Color::green);
118-
int count = 1;
112+
tabulate::Table gpu_table;
113+
gpu_table.add_row(Row_t(GPU_INFO_HEADERS.begin(), GPU_INFO_HEADERS.end()));
114+
gpu_table.format()
115+
.font_style({tabulate::FontStyle::bold})
116+
.font_align(tabulate::FontAlign::center)
117+
.padding_left(1)
118+
.padding_right(1);
119119

120120
std::vector<cortex::hw::GPU> gpus =
121-
cortex::hw::gpu::FromJson(result.value()["gpus"]);
122-
for (auto const& gpu : gpus) {
123-
std::vector<std::string> row = {std::to_string(count)};
124-
row.emplace_back(gpu.id);
125-
row.emplace_back(gpu.name);
126-
row.emplace_back(gpu.version);
127-
row.emplace_back(std::to_string(gpu.total_vram));
128-
row.emplace_back(std::to_string(gpu.free_vram));
129-
row.emplace_back(
130-
std::get<cortex::hw::NvidiaAddInfo>(gpu.add_info).driver_version);
131-
row.emplace_back(
132-
std::get<cortex::hw::NvidiaAddInfo>(gpu.add_info).compute_cap);
133-
row.emplace_back(gpu.is_activated ? "Yes" : "No");
134-
table.add_row({row.begin(), row.end()});
135-
count++;
121+
cortex::hw::gpu::FromJson(hardware_json_response.value()["gpus"]);
122+
int gpu_index = 1;
123+
for (const auto& gpu : gpus) {
124+
std::vector<std::string> gpu_row = {
125+
std::to_string(gpu_index),
126+
gpu.id,
127+
gpu.name,
128+
gpu.version,
129+
std::to_string(gpu.total_vram),
130+
std::to_string(gpu.free_vram),
131+
std::get<cortex::hw::NvidiaAddInfo>(gpu.add_info).driver_version,
132+
std::get<cortex::hw::NvidiaAddInfo>(gpu.add_info).compute_cap,
133+
gpu.is_activated ? "Yes" : "No"};
134+
gpu_table.add_row(Row_t(gpu_row.begin(), gpu_row.end()));
135+
gpu_index++;
136136
}
137-
138-
std::cout << table << std::endl;
139-
std::cout << std::endl;
137+
std::cout << gpu_table << std::endl << std::endl;
140138
}
141-
142-
if (!ho.has_value() || ho.value().show_storage) {
139+
140+
// Storage Section
141+
if (!query_flags.has_value() || query_flags.value().show_storage) {
143142
std::cout << "Storage Information:" << std::endl;
144-
Table table;
145-
std::vector<std::string> column_headers{"#", "Total (GiB)",
146-
"Available (GiB)"};
147-
148-
Row_t header{column_headers.begin(), column_headers.end()};
149-
table.add_row(header);
150-
table.format().font_color(Color::green);
151-
std::vector<std::string> row = {"1"};
152-
cortex::hw::StorageInfo si =
153-
cortex::hw::storage::FromJson(result.value()["storage"]);
154-
row.emplace_back(std::to_string(si.total));
155-
row.emplace_back(std::to_string(si.available));
156-
table.add_row({row.begin(), row.end()});
157-
std::cout << table << std::endl;
158-
std::cout << std::endl;
143+
tabulate::Table storage_table;
144+
storage_table.add_row(Row_t(STORAGE_INFO_HEADERS.begin(), STORAGE_INFO_HEADERS.end()));
145+
storage_table.format()
146+
.font_style({tabulate::FontStyle::bold})
147+
.font_align(tabulate::FontAlign::center)
148+
.padding_left(1)
149+
.padding_right(1);
150+
151+
cortex::hw::StorageInfo storage = cortex::hw::storage::FromJson(
152+
hardware_json_response.value()["storage"]);
153+
std::vector<std::string> storage_row = {"1", std::to_string(storage.total),
154+
std::to_string(storage.available)};
155+
storage_table.add_row(Row_t(storage_row.begin(), storage_row.end()));
156+
std::cout << storage_table << std::endl << std::endl;
159157
}
160-
161-
if (!ho.has_value() || ho.value().show_power) {
158+
159+
// Power Section
160+
if (!query_flags.has_value() || query_flags.value().show_power) {
162161
std::cout << "Power Information:" << std::endl;
163-
Table table;
164-
std::vector<std::string> column_headers{"#", "Battery Life",
165-
"Charging Status", "Power Saving"};
166-
167-
Row_t header{column_headers.begin(), column_headers.end()};
168-
table.add_row(header);
169-
table.format().font_color(Color::green);
170-
std::vector<std::string> row = {"1"};
171-
cortex::hw::PowerInfo pi =
172-
cortex::hw::power::FromJson(result.value()["power"]);
173-
row.emplace_back(std::to_string(pi.battery_life));
174-
row.emplace_back(pi.charging_status);
175-
row.emplace_back(pi.is_power_saving ? "Yes" : "No");
176-
table.add_row({row.begin(), row.end()});
177-
std::cout << table << std::endl;
178-
std::cout << std::endl;
162+
tabulate::Table power_table;
163+
power_table.add_row(Row_t(POWER_INFO_HEADERS.begin(), POWER_INFO_HEADERS.end()));
164+
power_table.format()
165+
.font_style({tabulate::FontStyle::bold})
166+
.font_align(tabulate::FontAlign::center)
167+
.padding_left(1)
168+
.padding_right(1);
169+
170+
cortex::hw::PowerInfo power =
171+
cortex::hw::power::FromJson(hardware_json_response.value()["power"]);
172+
std::vector<std::string> power_row = {
173+
"1", std::to_string(power.battery_life), power.charging_status,
174+
power.is_power_saving ? "Yes" : "No"};
175+
power_table.add_row(Row_t(power_row.begin(), power_row.end()));
176+
std::cout << power_table << std::endl << std::endl;
179177
}
180178

181179
return true;

‎engine/cli/commands/hardware_list_cmd.h‎

Lines changed: 21 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,10 @@
11
#pragma once
22
#include <optional>
33
#include <string>
4+
#include <array>
45

56
namespace commands {
6-
struct HarwareOptions {
7+
struct HardwareQueryFlags {
78
bool show_cpu = false;
89
bool show_os = false;
910
bool show_ram = false;
@@ -20,7 +21,24 @@ struct HarwareOptions {
2021

2122
class HardwareListCmd {
2223
public:
23-
bool Exec(const std::string& host, int port,
24-
const std::optional<HarwareOptions>& ho);
24+
bool Exec(const std::string& server_host, int server_port,
25+
const std::optional<HardwareQueryFlags>& query_flags);
26+
27+
private:
28+
// Static constexpr arrays for column headers
29+
static constexpr std::array<const char*, 6> CPU_INFO_HEADERS = {
30+
"#", "Arch", "Cores", "Model", "Usage", "Instructions"};
31+
static constexpr std::array<const char*, 3> OS_INFO_HEADERS = {"#", "Version",
32+
"Name"};
33+
static constexpr std::array<const char*, 3> RAM_INFO_HEADERS = {"#", "Total (MiB)",
34+
"Available (MiB)"};
35+
static constexpr std::array<const char*, 9> GPU_INFO_HEADERS = {
36+
"#", "GPU ID", "Name", "Version",
37+
"Total (MiB)", "Available (MiB)", "Driver Version", "Compute Capability",
38+
"Activated"};
39+
static constexpr std::array<const char*, 3> STORAGE_INFO_HEADERS = {
40+
"#", "Total (GiB)", "Available (GiB)"};
41+
static constexpr std::array<const char*, 4> POWER_INFO_HEADERS = {
42+
"#", "Battery Life", "Charging Status", "Power Saving"};
2543
};
2644
} // namespace commands

0 commit comments

Comments
 (0)