230 lines
8.4 KiB
C++
230 lines
8.4 KiB
C++
#include "docker_manager.hpp"
|
|
|
|
#include "process_runner.hpp"
|
|
#include "container_parser.hpp"
|
|
#include "stop_waiter.hpp"
|
|
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <system_error>
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
using json = nlohmann::json;
|
|
|
|
namespace {
|
|
|
|
std::string apiError(const EngineResponse& response, const std::string& fallback) {
|
|
if (!response.error.empty()) return response.error;
|
|
return fallback;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
std::string DockerManager::processError(const std::string& fallback,
|
|
const std::string& stderr_text) {
|
|
return stderr_text.empty() ? fallback : stderr_text;
|
|
}
|
|
|
|
bool DockerManager::runProcess(const std::vector<std::string>& args,
|
|
std::string& message,
|
|
bool inherit_stdio) {
|
|
ProcessOptions options;
|
|
options.inherit_stdio = inherit_stdio;
|
|
options.capture_stdout = !inherit_stdio;
|
|
options.capture_stderr = !inherit_stdio;
|
|
const ProcessResult result = ProcessRunner::run(args, options);
|
|
if (!result.ok()) {
|
|
message = processError("Docker command failed.", result.stderr_text);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DockerManager::checkConnection(std::string& error) const {
|
|
return engine_.checkConnection(error);
|
|
}
|
|
|
|
DockerManager::ListResult<DockerManager::ContainerInfo> DockerManager::getContainerList() const {
|
|
ListResult<ContainerInfo> result;
|
|
const EngineResponse response = engine_.request("GET", "/containers/json?all=true");
|
|
if (!response.ok()) {
|
|
result.error = apiError(response, "Could not list containers.");
|
|
return result;
|
|
}
|
|
|
|
return parseContainerList(response.body);
|
|
}
|
|
|
|
DockerManager::ListResult<DockerManager::ImageInfo> DockerManager::getImageList() const {
|
|
ListResult<ImageInfo> result;
|
|
const EngineResponse response = engine_.request("GET", "/images/json");
|
|
if (!response.ok()) {
|
|
result.error = apiError(response, "Could not list images.");
|
|
return result;
|
|
}
|
|
|
|
try {
|
|
for (const auto& item : json::parse(response.body)) {
|
|
const std::string id = item.value("Id", "");
|
|
const auto tags = item.value("RepoTags", std::vector<std::string>{});
|
|
if (id.empty()) continue;
|
|
if (tags.empty()) result.items.emplace_back(id, "<untagged>");
|
|
else for (const auto& tag : tags) result.items.emplace_back(id, tag);
|
|
}
|
|
} catch (const json::exception& error) {
|
|
result.items.clear();
|
|
result.error = std::string("Could not parse image data: ") + error.what();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool DockerManager::pullImage(const std::string& image, std::string& message) const {
|
|
if (image.empty()) {
|
|
message = "Please provide an image name.";
|
|
return false;
|
|
}
|
|
const bool ok = runProcess({"docker", "pull", image}, message);
|
|
if (ok) message = "Image pulled successfully.";
|
|
return ok;
|
|
}
|
|
|
|
bool DockerManager::createContainer(const std::string& name,
|
|
const std::string& image,
|
|
const std::vector<std::string>& ports,
|
|
std::string& message) const {
|
|
if (name.empty() || image.empty()) {
|
|
message = "Please provide a container name and choose an image first.";
|
|
return false;
|
|
}
|
|
|
|
// Resolve host path to tuxreaperd binary: prefer the current directory,
|
|
// then fall back to the directory holding the tux-dock executable
|
|
// (e.g. build/tuxreaperd next to build/tux-dock).
|
|
std::filesystem::path hostReaperPath = std::filesystem::current_path() / "tuxreaperd";
|
|
if (!std::filesystem::exists(hostReaperPath)) {
|
|
std::error_code ec;
|
|
const auto exe = std::filesystem::read_symlink("/proc/self/exe", ec);
|
|
if (!ec) {
|
|
hostReaperPath = exe.parent_path() / "tuxreaperd";
|
|
}
|
|
}
|
|
if (!std::filesystem::exists(hostReaperPath)) {
|
|
message = "Failed to create container: tuxreaperd binary not found in the current directory or next to the tux-dock executable.";
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::string> args{"docker", "create", "--name", name};
|
|
|
|
// Port mappings
|
|
for (const auto& port : ports) {
|
|
args.push_back("-p");
|
|
args.push_back(port);
|
|
}
|
|
|
|
// Mount host tuxreaperd into container target path (read-only for security)
|
|
args.push_back("-v");
|
|
args.push_back(hostReaperPath.string() + ":/usr/local/bin/tuxreaperd:ro");
|
|
|
|
// Target image and entry command with tuxreaperd as PID 1
|
|
args.insert(args.end(), {image, "/usr/local/bin/tuxreaperd", "sleep", "infinity"});
|
|
|
|
const bool ok = runProcess(args, message);
|
|
if (ok) {
|
|
message = "Container created with tuxreaperd PID 1 supervisor and ready to start.";
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool DockerManager::startDetached(const std::string& id, std::string& message) const {
|
|
const EngineResponse response = engine_.request("POST", "/containers/" + id + "/start");
|
|
if (!response.ok()) {
|
|
message = apiError(response, "Could not start that container.");
|
|
return false;
|
|
}
|
|
message = "Container started in detached mode.";
|
|
return true;
|
|
}
|
|
|
|
bool DockerManager::deleteImage(const std::string& id, std::string& message) const {
|
|
const EngineResponse response = engine_.request("DELETE", "/images/" + id);
|
|
if (!response.ok()) {
|
|
message = apiError(response, "Could not delete that image.");
|
|
return false;
|
|
}
|
|
message = "Image deleted.";
|
|
return true;
|
|
}
|
|
|
|
bool DockerManager::stopContainer(const std::string& id, std::string& message) const {
|
|
const auto stop_request = [this, &id] { return engine_.request("POST", "/containers/" + id + "/stop"); };
|
|
const auto acceptable = [](const EngineResponse& response) {
|
|
return response.status_code == 204 || response.status_code == 304 || response.status_code == 404 || response.ok();
|
|
};
|
|
const auto probe = [this, &id] {
|
|
const EngineResponse state = engine_.request("GET", "/containers/" + id + "/json");
|
|
if (!state.ok()) return StopProbe::Unknown;
|
|
try {
|
|
const bool running = nlohmann::json::parse(state.body)
|
|
.value("State", nlohmann::json::object())
|
|
.value("Running", true);
|
|
return running ? StopProbe::Running : StopProbe::Stopped;
|
|
} catch (const nlohmann::json::exception&) {
|
|
return StopProbe::Unknown;
|
|
}
|
|
};
|
|
|
|
const EngineResponse first = stop_request();
|
|
const bool first_timed_out = first.error == "Docker Engine response timed out.";
|
|
if (!acceptable(first) && !first_timed_out) {
|
|
message = apiError(first, "Could not stop that container.");
|
|
return false;
|
|
}
|
|
|
|
StopProbe state = first_timed_out ? StopProbe::Unknown : waitForStopped(probe);
|
|
if (state != StopProbe::Stopped) {
|
|
const EngineResponse retry = stop_request();
|
|
const bool retry_timed_out = retry.error == "Docker Engine response timed out.";
|
|
if (!acceptable(retry) && !retry_timed_out) {
|
|
message = apiError(retry, "Could not confirm that container stopped.");
|
|
return false;
|
|
}
|
|
state = waitForStopped(probe);
|
|
}
|
|
|
|
if (state != StopProbe::Stopped) {
|
|
message = "Stop requested, but container state could not be confirmed.";
|
|
return false;
|
|
}
|
|
message = "Container stopped.";
|
|
return true;
|
|
}
|
|
|
|
bool DockerManager::removeContainer(const std::string& id, std::string& message) const {
|
|
const EngineResponse response = engine_.request("DELETE", "/containers/" + id);
|
|
if (!response.ok()) {
|
|
message = apiError(response, "Could not remove that container.");
|
|
return false;
|
|
}
|
|
message = "Container removed.";
|
|
return true;
|
|
}
|
|
|
|
bool DockerManager::execShell(const std::string& id, std::string& message) const {
|
|
const bool ok = runProcess({"docker", "exec", "-it", id, "/bin/sh"}, message, true);
|
|
if (ok) message = "Shell session finished.";
|
|
return ok;
|
|
}
|
|
|
|
bool DockerManager::execDetachedCommand(const std::string& id,
|
|
const std::string& command,
|
|
std::string& message) const {
|
|
if (command.empty()) {
|
|
message = "Please provide a command to run.";
|
|
return false;
|
|
}
|
|
const bool ok = runProcess({"docker", "exec", "-d", id, "/bin/sh", "-c", command}, message);
|
|
if (ok) message = "Command dispatched in detached mode.";
|
|
return ok;
|
|
}
|