SnapshotManager Class Reference

#include <SnapshotManager.h>

Classes
struct	SnapshotInfo
struct	ValidationResult

Public Member Functions
	SnapshotManager ()
	~SnapshotManager ()
std::string	CreateSnapshot (const std::string &studyPath, const std::string &snapshotsDir)
ValidationResult	ValidateSnapshot (const std::string &snapshotPath)
bool	ImportSnapshot (const std::string &snapshotPath, const std::string &studiesDir, const std::string &newStudyName)
SnapshotInfo	GetSnapshotInfo (const std::string &snapshotPath)
bool	ConvertSnapshotFormat (const std::string &studyPath)

Static Public Member Functions
static std::string	GenerateSnapshotName (const std::string &studyName, int version)

Detailed Description

Definition at line 15 of file SnapshotManager.h.

Constructor & Destructor Documentation

SnapshotManager()

SnapshotManager::SnapshotManager

(

)

Definition at line 43 of file SnapshotManager.cpp.

                                 {
}

~SnapshotManager()

SnapshotManager::~SnapshotManager

(

)

Definition at line 46 of file SnapshotManager.cpp.

                                  {
}

Member Function Documentation

ConvertSnapshotFormat()

bool SnapshotManager::ConvertSnapshotFormat

(

const std::string &

studyPath

)

Convert PEBLOnlinePlatform snapshot format to launcher format Platform format has:

• version: string (e.g., "Version 3")
• test_id instead of test_name in tests array
• test_name as display name Launcher format needs:
• version: integer
• test_name as identifier
• display_name as readable name

Definition at line 321 of file SnapshotManager.cpp.

                                                                      {
    try {
        std::string jsonPath = studyPath + "/study-info.json";
 
        // Read existing study-info.json
        std::ifstream file(jsonPath);
        if (!file.is_open()) {
            return false;
        }
 
        json platformJson;
        file >> platformJson;
        file.close();
 
        // Create launcher-compatible JSON
        json launcherJson;
 
        // Convert metadata
        launcherJson["study_name"] = platformJson.value("study_name", "Imported Study");
        launcherJson["description"] = platformJson.value("description", "");
        launcherJson["author"] = platformJson.value("created_by", "");
 
        // Convert version from string to integer
        std::string versionStr = platformJson.value("version", "1");
        int versionInt = 1;
        // Try to extract number from strings like "Version 3"
        size_t lastSpace = versionStr.rfind(' ');
        if (lastSpace != std::string::npos) {
            std::string numPart = versionStr.substr(lastSpace + 1);
            versionInt = std::atoi(numPart.c_str());
            if (versionInt == 0) versionInt = 1;
        }
        launcherJson["version"] = versionInt;
 
        // Convert tests array
        json testsArray = json::array();
        if (platformJson.contains("tests") && platformJson["tests"].is_array()) {
            for (const auto& platformTest : platformJson["tests"]) {
                json launcherTest;
 
                // In platform format: test_id is the identifier, test_name is display name
                std::string testId = platformTest.value("test_id", "");
                std::string testDisplayName = platformTest.value("test_name", testId);
 
                launcherTest["test_name"] = testId;  // Launcher uses test_name as identifier
                launcherTest["display_name"] = testDisplayName;
                launcherTest["test_path"] = testId;  // Path is same as identifier
                launcherTest["included"] = true;
 
                // Build parameter_variants by scanning params/ directory for .par.json files
                json paramVariants = json::object();
                std::string paramsDir = studyPath + "/tests/" + testId + "/params";
                if (DirectoryExists(paramsDir)) {
                    // Always add a "default" variant
                    json defaultVariant;
                    defaultVariant["description"] = "Default parameters";
                    defaultVariant["file"] = nullptr;
                    paramVariants["default"] = defaultVariant;
 
                    // Scan for .par.json files
                    for (const auto& entry : fs::directory_iterator(paramsDir)) {
                        if (entry.is_regular_file()) {
                            std::string filename = entry.path().filename().string();
                            // Look for .par.json files
                            if (filename.size() > 9 && filename.substr(filename.size() - 9) == ".par.json") {
                                // Extract variant name (remove .par.json extension)
                                std::string variantName = filename.substr(0, filename.size() - 9);
                                json variant;
                                variant["description"] = variantName;
                                variant["file"] = filename;
                                paramVariants[variantName] = variant;
                                printf("Found parameter variant: %s -> %s\n", variantName.c_str(), filename.c_str());
                            }
                        }
                    }
                }
                launcherTest["parameter_variants"] = paramVariants;
 
                testsArray.push_back(launcherTest);
            }
        }
        launcherJson["tests"] = testsArray;
 
        // Upload config must be set intentionally via Study Settings;
        // do not auto-populate from upload.json files in test directories
        launcherJson["study_token"] = "";
        launcherJson["upload_server_url"] = "";
        launcherJson["created_date"] = platformJson.value("created_at", "");
        launcherJson["modified_date"] = platformJson.value("created_at", "");
 
        // Write converted JSON back to file
        std::ofstream outFile(jsonPath);
        if (!outFile.is_open()) {
            return false;
        }
 
        outFile << launcherJson.dump(2);  // 2-space indentation
        outFile.close();
 
        printf("Converted snapshot format to launcher format\n");
        return true;
 
    } catch (const std::exception& e) {
        printf("Error converting snapshot format: %s\n", e.what());
        return false;
    }
}

CreateSnapshot()

std::string SnapshotManager::CreateSnapshot	(	const std::string &	studyPath,
		const std::string &	snapshotsDir
	)

Definition at line 49 of file SnapshotManager.cpp.

                                                                            {
    // Load study to get metadata
    auto study = Study::LoadFromDirectory(studyPath);
    if (!study) {
        return "";
    }
 
    // Generate snapshot name: studyname_vN_YYYY-MM-DD
    std::string snapshotName = GenerateSnapshotName(study->GetName(), study->GetVersion());
    std::string snapshotPath = snapshotsDir + "/" + snapshotName;
 
    // Check if snapshot already exists
    if (DirectoryExists(snapshotPath)) {
        // Append timestamp to make unique
        auto now = std::time(nullptr);
        std::ostringstream oss;
        oss << snapshotPath << "_" << now;
        snapshotPath = oss.str();
    }
 
    // Copy study directory, excluding data/ directories
    if (!CopyDirectory(studyPath, snapshotPath, true)) {
        return "";
    }
 
    return snapshotName;
}

References GenerateSnapshotName(), and Study::LoadFromDirectory().

GenerateSnapshotName()

std::string SnapshotManager::GenerateSnapshotName ( const std::string &  studyName, int  version  )

static

Definition at line 166 of file SnapshotManager.cpp.

                                                                                       {
    // Replace spaces with hyphens, convert to lowercase
    std::string safeName = studyName;
    for (char& c : safeName) {
        if (c == ' ') c = '-';
        else c = std::tolower(c);
    }
 
    // Get current date
    auto now = std::time(nullptr);
    auto tm = *std::localtime(&now);
 
    std::ostringstream oss;
    oss << safeName << "_v" << version << "_"
        << std::put_time(&tm, "%Y-%m-%d");
 
    return oss.str();
}

Referenced by CreateSnapshot().

GetSnapshotInfo()

SnapshotManager::SnapshotInfo SnapshotManager::GetSnapshotInfo

(

const std::string &

snapshotPath

)

Definition at line 185 of file SnapshotManager.cpp.

                                                                                          {
    SnapshotInfo info;
    info.version = 0;
    info.testCount = 0;
    info.chainCount = 0;
 
    auto study = Study::LoadFromDirectory(snapshotPath);
    if (!study) {
        return info;
    }
 
    info.studyName = study->GetName();
    info.version = study->GetVersion();
    info.description = study->GetDescription();
    info.author = study->GetAuthor();
    info.createdDate = study->GetCreatedDate();
    info.testCount = static_cast<int>(study->GetTests().size());
    info.chainCount = study->GetChainCount();
 
    return info;
}

References SnapshotManager::SnapshotInfo::author, SnapshotManager::SnapshotInfo::chainCount, SnapshotManager::SnapshotInfo::createdDate, SnapshotManager::SnapshotInfo::description, Study::LoadFromDirectory(), SnapshotManager::SnapshotInfo::studyName, SnapshotManager::SnapshotInfo::testCount, and SnapshotManager::SnapshotInfo::version.

ImportSnapshot()

bool SnapshotManager::ImportSnapshot	(	const std::string &	snapshotPath,
		const std::string &	studiesDir,
		const std::string &	newStudyName
	)

Definition at line 140 of file SnapshotManager.cpp.

                                                                     {
    std::string studyPath = studiesDir + "/" + newStudyName;
 
    // Check if study already exists
    if (DirectoryExists(studyPath)) {
        return false;
    }
 
    // Copy snapshot to studies directory
    // Note: For ZIP imports, format conversion happens before this is called
    // For directory imports, we need to convert after copying
    if (!CopyDirectory(snapshotPath, studyPath, false)) {
        return false;
    }
 
    // Create data/ directory (snapshots don't have it)
    std::string dataDir = studyPath + "/data";
    if (!DirectoryExists(dataDir)) {
        mkdir(dataDir.c_str(), 0755);
    }
 
    return true;
}

ValidateSnapshot()

SnapshotManager::ValidationResult SnapshotManager::ValidateSnapshot

(

const std::string &

snapshotPath

)

Definition at line 78 of file SnapshotManager.cpp.

                                                                                               {
    ValidationResult result;
    result.isValid = true;
 
    // Check if directory exists
    if (!DirectoryExists(snapshotPath)) {
        result.isValid = false;
        result.errors.push_back("Snapshot directory does not exist");
        return result;
    }
 
    // Check for study-info.json
    std::string studyInfoPath = snapshotPath + "/study-info.json";
    if (!FileExists(studyInfoPath)) {
        result.isValid = false;
        result.errors.push_back("study-info.json not found");
        return result;
    }
 
    // Try to load study
    auto study = Study::LoadFromDirectory(snapshotPath);
    if (!study) {
        result.isValid = false;
        result.errors.push_back("Failed to parse study-info.json");
        return result;
    }
 
    // Validate study structure
    auto studyValidation = study->Validate();
    result.errors.insert(result.errors.end(), studyValidation.errors.begin(), studyValidation.errors.end());
    result.warnings.insert(result.warnings.end(), studyValidation.warnings.begin(), studyValidation.warnings.end());
 
    // Check for chains/ directory
    std::string chainsDir = snapshotPath + "/chains";
    if (!DirectoryExists(chainsDir)) {
        result.warnings.push_back("chains/ directory not found");
    }
 
    // Check for tests/ directory
    std::string testsDir = snapshotPath + "/tests";
    if (!DirectoryExists(testsDir)) {
        result.warnings.push_back("tests/ directory not found");
    }
 
    // Verify no data/ directories (snapshots shouldn't have data)
    std::string dataDir = snapshotPath + "/data";
    if (DirectoryExists(dataDir)) {
        result.warnings.push_back("Snapshot contains data/ directory (should be excluded)");
    }
 
    // Check each test for data/ subdirectories
    for (const auto& test : study->GetTests()) {
        std::string testDataDir = snapshotPath + "/tests/" + test.testPath + "/data";
        if (DirectoryExists(testDataDir)) {
            result.warnings.push_back("Test " + test.testName + " contains data/ directory");
        }
    }
 
    result.isValid = result.errors.empty();
    return result;
}

References SnapshotManager::ValidationResult::errors, SnapshotManager::ValidationResult::isValid, Study::LoadFromDirectory(), and SnapshotManager::ValidationResult::warnings.

---

The documentation for this class was generated from the following files:

• SnapshotManager.h
• SnapshotManager.cpp