RestApiSolver.cpp

Go to the documentation of this file.

 
 
#include "RestApiSolver.h"
#include "../Global/fmodule.h"
 
#include <httplib.h>
#include <json.hpp>
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <cstring>
using namespace std;
 
using json = nlohmann::json;
 
RestApiSolver::RestApiSolver(const std::string& base_url)
    : base_url_(base_url) {}
 
// ---- HTTP helpers ----
 
std::string RestApiSolver::httpPost(const std::string& path, const std::string& body) {
    // Parse base_url_ into host:port
    std::string host = base_url_;
    int port = 80;
 
    // Strip http://
    auto pos = host.find("://");
    if (pos != std::string::npos) host = host.substr(pos + 3);
    // Extract port
    pos = host.find(':');
    if (pos != std::string::npos) {
        port = std::stoi(host.substr(pos + 1));
        host = host.substr(0, pos);
    }
 
    httplib::Client cli(host, port);
    cli.set_connection_timeout(5);
    cli.set_read_timeout(30);
 
    auto res = cli.Post(path, body, "application/json");
    if (!res) {
        throw std::runtime_error("HTTP POST failed: " + path + " error=" + httplib::to_string(res.error()));
    }
    if (res->status >= 400) {
        throw std::runtime_error("HTTP POST " + path + " returned " + std::to_string(res->status) + ": " + res->body);
    }
    return res->body;
}
 
std::string RestApiSolver::httpGet(const std::string& path) {
    std::string host = base_url_;
    int port = 80;
    auto pos = host.find("://");
    if (pos != std::string::npos) host = host.substr(pos + 3);
    pos = host.find(':');
    if (pos != std::string::npos) {
        port = std::stoi(host.substr(pos + 1));
        host = host.substr(0, pos);
    }
 
    httplib::Client cli(host, port);
    cli.set_connection_timeout(5);
    cli.set_read_timeout(30);
 
    auto res = cli.Get(path);
    if (!res) {
        throw std::runtime_error("HTTP GET failed: " + path);
    }
    return res->body;
}
 
std::string RestApiSolver::httpDelete(const std::string& path) {
    std::string host = base_url_;
    int port = 80;
    auto pos = host.find("://");
    if (pos != std::string::npos) host = host.substr(pos + 3);
    pos = host.find(':');
    if (pos != std::string::npos) {
        port = std::stoi(host.substr(pos + 1));
        host = host.substr(0, pos);
    }
 
    httplib::Client cli(host, port);
    auto res = cli.Delete(path);
    if (!res) return "{}";
    return res->body;
}
 
// ---- Session management ----
 
void RestApiSolver::createSession(bool fresh) {
    json body = {{"mode", fresh ? "fresh" : "restart"}};
    auto resp_str = httpPost("/api/v1/sessions", body.dump());
    auto resp = json::parse(resp_str);
    session_id_ = resp["session_id"].get<std::string>();
    std::cout << "[RestApiSolver] Created session: " << session_id_ << std::endl;
}
 
void RestApiSolver::destroySession() {
    if (!session_id_.empty()) {
        httpDelete("/api/v1/sessions/" + session_id_);
        session_id_.clear();
    }
}
 
// ---- Populate r5pars_ from JSON ----
 
void RestApiSolver::populateR5Pars(const std::string& json_str) {
    auto resp = json::parse(json_str);
 
    r5pars_.timesno = resp["time"].get<double>();
 
    // Volumes
    if (resp.contains("volumes")) {
        for (auto& v : resp["volumes"]) {
            int i = v["index"].get<int>();
            if (i >= 0 && i < 500) {
                r5pars_.liq_t[i] = v["liq_t"].get<double>();
                r5pars_.vap_t[i] = v["vap_t"].get<double>();
                r5pars_.sat_t[i] = v["sat_t"].get<double>();
                r5pars_.sys_pressure[i] = v["pressure"].get<double>();
                r5pars_.boron_d[i] = v["boron_d"].get<double>();
                r5pars_.quality[i] = v["quality"].get<double>();
                r5pars_.flow_reg[i] = v["flow_reg"].get<double>();
            }
        }
    }
 
    // Junctions
    if (resp.contains("junctions")) {
        for (auto& j : resp["junctions"]) {
            int i = j["index"].get<int>();
            if (i >= 0 && i < 500) {
                r5pars_.mass_fr[i] = j["mass_fr"].get<double>();
                r5pars_.liq_vel[i] = j["liq_vel"].get<double>();
                r5pars_.vap_vel[i] = j["vap_vel"].get<double>();
            }
        }
    }
 
    // Variable trips
    if (resp.contains("variable_trips")) {
        for (auto& t : resp["variable_trips"]) {
            int i = t["index"].get<int>();
            if (i >= 0 && i < 500) {
                r5pars_.vartrip_t[i] = t["trip_time"].get<double>();
            }
        }
    }
 
    // Logical trips
    if (resp.contains("logical_trips")) {
        for (auto& t : resp["logical_trips"]) {
            int i = t["index"].get<int>();
            if (i >= 0 && i < 500) {
                r5pars_.logtrip_t[i] = t["trip_time"].get<double>();
            }
        }
    }
 
    // Control variables
    if (resp.contains("control_variables")) {
        for (auto& c : resp["control_variables"]) {
            int i = c["index"].get<int>();
            if (i >= 0 && i < 500) {
                r5pars_.ctrl_var_val[i] = c["value"].get<double>();
            }
        }
    }
 
    // Stop flag
    if (resp.contains("stop_flag")) {
        r5pars_.csnostop = resp["stop_flag"].get<int>();
    }
}
 
// ---- Send interventions ----
 
void RestApiSolver::sendInterventions() {
    // Compare current inter_val[] with last snapshot to find changes
    json actions = json::array();
    int n = r5pars_.n_interact;
    for (int i = 0; i < n; i++) {
        double current = r5pars_.inter_val[i];
        auto it = last_inter_val_.find(i);
        if (it == last_inter_val_.end() || std::abs(it->second - current) > 1e-10) {
            actions.push_back({{"index", i}, {"value", current}});
            last_inter_val_[i] = current;
        }
    }
 
    if (!actions.empty()) {
        json body = {{"actions", actions}};
        httpPost("/api/v1/sessions/" + session_id_ + "/intervene", body.dump());
    }
}
 
// ---- Sequence execution ----
 
void RestApiSolver::runSequence(SolverCallback& cb) {
    // Create session on first call; reuse for subsequent sequences
    if (session_id_.empty()) {
        createSession(true);
    } else if (!restore_checkpoints_.empty()) {
        // Restore from checkpoint for branching restart.
        // Read ncount from indeck.i (written by restartForNewSequence)
        // to select the correct checkpoint from the map.
        int ncount = parseNcountFromIndeck("indeck.i");
        std::string ckpt_id;
        auto it = restore_checkpoints_.find(ncount);
        if (it != restore_checkpoints_.end()) {
            ckpt_id = it->second;
        } else if (!restore_checkpoints_.empty()) {
            // Fallback: use the last checkpoint in the map
            ckpt_id = restore_checkpoints_.rbegin()->second;
            std::cerr << "[RestApiSolver] WARNING: ncount=" << ncount
                      << " not found in checkpoint map, using fallback" << std::endl;
        }
        if (!ckpt_id.empty()) {
            json restore_body = {{"checkpoint_id", ckpt_id}};
            auto resp = httpPost("/api/v1/sessions/" + session_id_ + "/restore",
                                 restore_body.dump());
            auto rj = json::parse(resp);
            double restored_time = rj["time"].get<double>();
            // Reset r5pars_ state that RELAP5's resetini.for would normally clear.
            // Without this, csnostop/timesno from the previous sequence persist
            // and the while loop never enters.
            r5pars_.csnostop = 0;
            r5pars_.timesno = restored_time;
            r5pars_.cgennode = false;
            r5pars_.cnbranch = 0;
            std::cout << "[RestApiSolver] Restored checkpoint " << ckpt_id
                      << " (ncount=" << ncount << ") t=" << restored_time << std::endl;
        }
        restore_checkpoints_.clear();
    }
 
    // Callbacks: first-init on first sequence, scenario start always
    if (first_sequence_) {
        cb.onFirstInit(*this);
        first_sequence_ = false;
    }
    cb.onScenarioStart(*this);
 
    // Clear per-sequence state
    last_inter_val_.clear();
    seq_checkpoints_.clear();
 
    // Main simulation loop — advance 0.5s per iteration
    while (r5pars_.csnostop == 0 && !r5pars_.terminateall) {
        // Advance the remote solver
        json advance_body = {{"dt", 0.5}};
        auto resp = httpPost("/api/v1/sessions/" + session_id_ + "/advance",
                             advance_body.dump());
        populateR5Pars(resp);
 
        // Set cncount before onEvaluationPoint so BranchCluster records it
        // (mirrors RELAP5 setting cncount on restart record writes)
        r5pars_.cncount = ++checkpoint_counter_;
 
        // Engine evaluation point (crew scanning, branching decisions)
        cb.onEvaluationPoint(*this);
 
        // Send any crew actions that changed during evaluation
        sendInterventions();
 
        // Handle branching checkpoint request
        if (r5pars_.cgennode && r5pars_.cnbranch > 1) {
            auto ckpt_resp = httpPost("/api/v1/sessions/" + session_id_ + "/checkpoint");
            auto ckpt = json::parse(ckpt_resp);
            std::string ckpt_id = ckpt["checkpoint_id"].get<std::string>();
 
            // Map this ncount to the checkpoint ID for later restore
            seq_checkpoints_[r5pars_.cncount] = ckpt_id;
            last_checkpoint_id_ = ckpt_id;
            r5pars_.cgennode = false;
 
            std::cout << "[RestApiSolver] Checkpoint " << ckpt_id
                      << " ncount=" << r5pars_.cncount
                      << " t=" << r5pars_.timesno << std::endl;
 
            cb.onBranchingPoint(*this);
        }
    }
 
    // Session stays alive for potential checkpoint restore on next sequence
}
 
// ---- State accessors ----
 
double RestApiSolver::currentTime() const { return r5pars_.timesno; }
int RestApiSolver::stopFlag() const { return r5pars_.csnostop; }
bool RestApiSolver::isTerminateAll() const { return r5pars_.terminateall; }
void RestApiSolver::setTerminateAll(bool v) { r5pars_.terminateall = v; }
 
// ---- Branch control ----
 
void RestApiSolver::setBranchCount(int n) { r5pars_.cnbranch = n; }
void RestApiSolver::setGenNode(bool v) { r5pars_.cgennode = v; }
 
// ---- Restart lifecycle ----
 
void RestApiSolver::setNewRestart(bool v) { r5pars_.cnewrst = v; }
 
void RestApiSolver::setInputDeck(const std::string& path) {
    // REST solver doesn't use input deck files; the mock generates its own state.
    // We still store the path in r5pars_ for compatibility.
    strncpy(r5pars_.carg2, path.c_str(), sizeof(r5pars_.carg2) - 1);
    r5pars_.carg2[sizeof(r5pars_.carg2) - 1] = '\0';
    r5pars_.carg2len = static_cast<int>(path.size());
}
 
// ---- Checkpoint/restore ----
 
std::vector<char> RestApiSolver::checkpoint() {
    // Serialize the ncount→checkpoint_id map as JSON.
    // restartForNewSequence stores this per source-sequence, and restore()
    // later parses it to select the right checkpoint by ncount.
    if (seq_checkpoints_.empty()) return {};
    json j;
    for (auto& [ncount, ckpt_id] : seq_checkpoints_) {
        j[std::to_string(ncount)] = ckpt_id;
    }
    std::string s = j.dump();
    return std::vector<char>(s.begin(), s.end());
}
 
void RestApiSolver::restore(const std::vector<char>& data) {
    if (data.empty()) return;
    // Parse the ncount→checkpoint_id map from JSON buffer.
    // The actual server-side restore happens in runSequence() after
    // reading the target ncount from indeck.i.
    std::string s(data.begin(), data.end());
    auto j = json::parse(s);
    restore_checkpoints_.clear();
    for (auto& [key, val] : j.items()) {
        restore_checkpoints_[std::stoi(key)] = val.get<std::string>();
    }
}
 
// ---- Configuration ----
 
void RestApiSolver::setThermoCacheMode(int) { /* no-op for REST solver */ }
void RestApiSolver::setMembufMode(int) { /* no-op for REST solver */ }
 
// ---- Helpers ----
 
int RestApiSolver::parseNcountFromIndeck(const std::string& path) {
    // indeck.i format:
    //   100 restart  transnt
    //   101 run
    //   103 <ncount>
    //   .
    std::ifstream ifs(path);
    std::string line;
    while (std::getline(ifs, line)) {
        if (line.size() >= 4 && line.substr(0, 3) == "103") {
            auto pos = line.find_first_of("0123456789", 3);
            if (pos != std::string::npos) {
                return std::stoi(line.substr(pos));
            }
        }
    }
    return -1;
}