ExperimentRunner Class Reference

#include <ExperimentRunner.h>

Public Member Functions
	ExperimentRunner ()
	ExperimentRunner (LauncherConfig *config)
	~ExperimentRunner ()
bool	RunExperiment (const std::string &scriptPath, const std::vector< std::string > &args, const std::string &subjectCode="", const std::string &language="", bool fullscreen=false)
bool	IsRunning ()
int	WaitForCompletion ()
void	Terminate ()
std::string	GetStdout () const
std::string	GetStderr () const
int	GetExitCode () const
void	UpdateOutput ()

Static Public Member Functions
static std::string	GetLaunchLogPath ()

Detailed Description

Definition at line 14 of file ExperimentRunner.h.

Constructor & Destructor Documentation

ExperimentRunner() [1/2]

ExperimentRunner::ExperimentRunner

(

)

Definition at line 35 of file ExperimentRunner.cpp.

    : mConfig(nullptr)
    , mIsRunning(false)
    , mLaunchTime(0)
    , mCurrentFullscreen(false)
    , mExitCode(-1)
    , mProcessId(0)
{
#ifdef _WIN32
    mProcessHandle = nullptr;
    mStdoutReadPipe = nullptr;
    mStdoutWritePipe = nullptr;
    mStderrReadPipe = nullptr;
    mStderrWritePipe = nullptr;
#else
    mStdoutPipe[0] = -1;
    mStdoutPipe[1] = -1;
    mStderrPipe[0] = -1;
    mStderrPipe[1] = -1;
#endif
}

ExperimentRunner() [2/2]

ExperimentRunner::ExperimentRunner

(

LauncherConfig *

config

)

Definition at line 57 of file ExperimentRunner.cpp.

    : mConfig(config)
    , mIsRunning(false)
    , mLaunchTime(0)
    , mCurrentFullscreen(false)
    , mExitCode(-1)
    , mProcessId(0)
{
#ifdef _WIN32
    mProcessHandle = nullptr;
    mStdoutReadPipe = nullptr;
    mStdoutWritePipe = nullptr;
    mStderrReadPipe = nullptr;
    mStderrWritePipe = nullptr;
#else
    mStdoutPipe[0] = -1;
    mStdoutPipe[1] = -1;
    mStderrPipe[0] = -1;
    mStderrPipe[1] = -1;
#endif
}

~ExperimentRunner()

ExperimentRunner::~ExperimentRunner

(

)

Definition at line 79 of file ExperimentRunner.cpp.

{
    if (mIsRunning) {
        Terminate();
    }
}

References Terminate().

Member Function Documentation

GetExitCode()

int ExperimentRunner::GetExitCode ( ) const

inline

Definition at line 47 of file ExperimentRunner.h.

{ return mExitCode; }

Referenced by LauncherUI::Render().

GetLaunchLogPath()

std::string ExperimentRunner::GetLaunchLogPath ( )

static

Definition at line 475 of file ExperimentRunner.cpp.

{
    std::string logPath;
 
#ifdef _WIN32
    // Windows: Documents folder
    char docPath[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_PERSONAL, NULL, 0, docPath))) {
        logPath = std::string(docPath);
    }
#else
    // Linux/macOS: ~/Documents or ~ if Documents doesn't exist
    const char* homeDir = getenv("HOME");
    if (!homeDir) {
        struct passwd* pw = getpwuid(getuid());
        homeDir = pw->pw_dir;
    }
 
    std::string docDir = std::string(homeDir) + "/Documents";
    struct stat st;
    if (stat(docDir.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) {
        logPath = docDir;
    } else {
        logPath = homeDir;
    }
#endif
 
    // Look for pebl-exp.X.X directories (newest first)
    const char* versions[] = {
        "pebl-exp.2.4",
        "pebl-exp.2.3",
        "pebl-exp.2.2",
        "pebl-exp.2.1",
        "pebl-exp.2.0",
        "pebl-exp.0.14",
        "pebl-exp"
    };
 
#ifdef _WIN32
    const char* separator = "\\";
#else
    const char* separator = "/";
#endif
 
    for (const char* version : versions) {
        std::string peblPath = logPath + separator + version;
        struct stat st;
        if (stat(peblPath.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) {
            // Check if logs subdirectory exists, create if needed
            std::string logsPath = peblPath + separator + "logs";
            struct stat logsSt;
            if (stat(logsPath.c_str(), &logsSt) != 0 || !S_ISDIR(logsSt.st_mode)) {
                // Create logs directory
#ifdef _WIN32
                CreateDirectoryA(logsPath.c_str(), NULL);
#else
                mkdir(logsPath.c_str(), 0755);
#endif
            }
            return logsPath + separator + "launcher-log.csv";
        }
    }
 
    // Fallback to home directory
    return logPath + separator + "launcher-log.csv";
}

References NULL.

GetStderr()

std::string ExperimentRunner::GetStderr ( ) const

inline

Definition at line 43 of file ExperimentRunner.h.

{ return mStderrBuffer; }

Referenced by LauncherUI::Render().

GetStdout()

std::string ExperimentRunner::GetStdout ( ) const

inline

Definition at line 42 of file ExperimentRunner.h.

{ return mStdoutBuffer; }

Referenced by LauncherUI::Render().

IsRunning()

bool ExperimentRunner::IsRunning

(

)

Definition at line 691 of file ExperimentRunner.cpp.

{
    if (!mIsRunning) {
        return false;
    }
 
#ifdef _WIN32
    // Windows: Check if process handle is still valid and running
    if (!mProcessHandle) {
        mIsRunning = false;
        return false;
    }
 
    // Read any available output while process is running
    UpdateOutput();
 
    DWORD exitCode;
    if (GetExitCodeProcess(mProcessHandle, &exitCode)) {
        if (exitCode == STILL_ACTIVE) {
            return true;
        } else {
            // Process has finished
            mExitCode = static_cast<int>(exitCode);
            printf("Process %lu finished with exit code %d\n", mProcessId, mExitCode);
            fflush(stdout);
            // Also log to file for debugging
            FILE* f = fopen("chain_debug.log", "a");
            if (f) {
                fprintf(f, "ExperimentRunner: Process finished, exit code = %d\n", mExitCode);
                fclose(f);
            }
 
            // Do final read of any remaining output
            UpdateOutput();
 
            // Close pipe handles
            if (mStdoutReadPipe) {
                CloseHandle(static_cast<HANDLE>(mStdoutReadPipe));
                mStdoutReadPipe = nullptr;
            }
            if (mStderrReadPipe) {
                CloseHandle(static_cast<HANDLE>(mStderrReadPipe));
                mStderrReadPipe = nullptr;
            }
 
            CloseHandle(mProcessHandle);
            mProcessHandle = nullptr;
            mIsRunning = false;
            LogCompletion(mExitCode);
            return false;
        }
    } else {
        // Error querying process - assume it's dead
        // Close pipe handles
        if (mStdoutReadPipe) {
            CloseHandle(static_cast<HANDLE>(mStdoutReadPipe));
            mStdoutReadPipe = nullptr;
        }
        if (mStderrReadPipe) {
            CloseHandle(static_cast<HANDLE>(mStderrReadPipe));
            mStderrReadPipe = nullptr;
        }
        CloseHandle(mProcessHandle);
        mProcessHandle = nullptr;
        mIsRunning = false;
        return false;
    }
#else
    // Unix: Use waitpid with WNOHANG to check without blocking
    // This is exactly what PEBL's CheckProcessStatus() does
    int status;
    pid_t result = waitpid(mProcessId, &status, WNOHANG);
 
    if (result == 0) {
        // Process still running
        return true;
    }
    else if (result == mProcessId) {
        // Process has finished
        printf("Process %d finished\n", mProcessId);
 
        // Do final read of any remaining output
        UpdateOutput();
 
        // Close pipes
        if (mStdoutPipe[0] >= 0) {
            close(mStdoutPipe[0]);
            mStdoutPipe[0] = -1;
        }
        if (mStderrPipe[0] >= 0) {
            close(mStderrPipe[0]);
            mStderrPipe[0] = -1;
        }
 
        mIsRunning = false;
 
        mExitCode = -1;
        if (WIFEXITED(status)) {
            mExitCode = WEXITSTATUS(status);
            printf("  Exit code: %d\n", mExitCode);
        } else if (WIFSIGNALED(status)) {
            printf("  Terminated by signal %d\n", WTERMSIG(status));
        }
 
        LogCompletion(mExitCode);
        return false;
    }
    else {
        // Error or already reaped (result == -1)
        printf("waitpid error for PID %d (already reaped or error)\n", mProcessId);
        mIsRunning = false;
        return false;
    }
#endif
}

References UpdateOutput().

Referenced by LauncherUI::Render().

RunExperiment()

bool ExperimentRunner::RunExperiment	(	const std::string &	scriptPath,
		const std::vector< std::string > &	args,
		const std::string &	subjectCode = "",
		const std::string &	language = "",
		bool	fullscreen = false
	)

Definition at line 131 of file ExperimentRunner.cpp.

{
    if (mIsRunning) {
        printf("Warning: Experiment already running\n");
        return false;
    }
 
    std::string peblPath = GetPEBLExecutablePath();
 
    // Extract directory from script path
    std::string workingDir;
    size_t lastSlash = scriptPath.find_last_of("/\\");
    if (lastSlash != std::string::npos) {
        workingDir = scriptPath.substr(0, lastSlash);
    } else {
        workingDir = ".";
    }
 
    // Get just the filename for passing to PEBL
    std::string scriptFilename;
    if (lastSlash != std::string::npos) {
        scriptFilename = scriptPath.substr(lastSlash + 1);
    } else {
        scriptFilename = scriptPath;
    }
 
    // Build complete argument list with PEBL command-line flags
    std::vector<std::string> fullArgs;
 
    // Add user-provided args first (these may include -v for positional params)
    for (const auto& arg : args) {
        fullArgs.push_back(arg);
    }
 
    // Add subject code with -s flag
    if (!subjectCode.empty()) {
        fullArgs.push_back("-s");
        fullArgs.push_back(subjectCode);
    }
 
    // Add language if specified
    if (!language.empty()) {
        fullArgs.push_back("--language");
        fullArgs.push_back(language);
    }
 
    // Add fullscreen flag
    if (fullscreen) {
        fullArgs.push_back("--fullscreen");
    }
 
#ifdef _WIN32
    // Windows: Use CreateProcess with pipes for stdout/stderr capture
    // Normalize paths - convert forward slashes to backslashes for Windows API
    std::string winPeblPath = NormalizeWindowsPath(peblPath);
    std::string winWorkingDir = NormalizeWindowsPath(workingDir);
 
    std::string cmdLine = "\"" + winPeblPath + "\" \"" + scriptFilename + "\"";
 
    // Add all arguments
    for (const auto& arg : fullArgs) {
        cmdLine += " ";
        if (arg.find(' ') != std::string::npos) {
            cmdLine += "\"" + arg + "\"";
        } else {
            cmdLine += arg;
        }
    }
 
    printf("Windows CreateProcess: cmd=%s, workdir=%s\n", cmdLine.c_str(), winWorkingDir.c_str());
 
    // Clear output buffers
    mStdoutBuffer.clear();
    mStderrBuffer.clear();
 
    // Set up security attributes for pipe inheritance
    SECURITY_ATTRIBUTES sa;
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.bInheritHandle = TRUE;  // Child process inherits handles
    sa.lpSecurityDescriptor = NULL;
 
    // Create stdout pipe
    HANDLE hStdoutRead, hStdoutWrite;
    if (!CreatePipe(&hStdoutRead, &hStdoutWrite, &sa, 0)) {
        printf("Failed to create stdout pipe: %lu\n", GetLastError());
        return false;
    }
    // Ensure read end is not inherited by child
    SetHandleInformation(hStdoutRead, HANDLE_FLAG_INHERIT, 0);
 
    // Create stderr pipe
    HANDLE hStderrRead, hStderrWrite;
    if (!CreatePipe(&hStderrRead, &hStderrWrite, &sa, 0)) {
        printf("Failed to create stderr pipe: %lu\n", GetLastError());
        CloseHandle(hStdoutRead);
        CloseHandle(hStdoutWrite);
        return false;
    }
    // Ensure read end is not inherited by child
    SetHandleInformation(hStderrRead, HANDLE_FLAG_INHERIT, 0);
 
    // Store pipe handles
    mStdoutReadPipe = hStdoutRead;
    mStdoutWritePipe = hStdoutWrite;
    mStderrReadPipe = hStderrRead;
    mStderrWritePipe = hStderrWrite;
 
    STARTUPINFOA si;
    PROCESS_INFORMATION pi;
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    si.hStdOutput = hStdoutWrite;
    si.hStdError = hStderrWrite;
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    si.dwFlags |= STARTF_USESTDHANDLES;
    ZeroMemory(&pi, sizeof(pi));
 
    // Create the child process with working directory set
    if (!CreateProcessA(
            NULL,                       // Application name
            const_cast<char*>(cmdLine.c_str()),  // Command line
            NULL,                       // Process security attributes
            NULL,                       // Thread security attributes
            TRUE,                       // Inherit handles (must be TRUE for pipes)
            0,                          // Creation flags
            NULL,                       // Environment
            winWorkingDir.c_str(),     // Current directory (IMPORTANT!) - must use backslashes
            &si,                        // Startup info
            &pi))                       // Process info
    {
        printf("Failed to create process: %s\n", cmdLine.c_str());
        printf("Working directory was: %s\n", winWorkingDir.c_str());
        printf("GetLastError: %lu\n", GetLastError());
        // Clean up pipe handles
        CloseHandle(hStdoutRead);
        CloseHandle(hStdoutWrite);
        CloseHandle(hStderrRead);
        CloseHandle(hStderrWrite);
        mStdoutReadPipe = nullptr;
        mStdoutWritePipe = nullptr;
        mStderrReadPipe = nullptr;
        mStderrWritePipe = nullptr;
        return false;
    }
 
    mProcessHandle = pi.hProcess;
    mProcessId = pi.dwProcessId;
    CloseHandle(pi.hThread);
 
    // Close write ends in parent - child has copies
    CloseHandle(hStdoutWrite);
    CloseHandle(hStderrWrite);
    mStdoutWritePipe = nullptr;
    mStderrWritePipe = nullptr;
 
    mIsRunning = true;
 
#else
    // Unix: Create pipes for stdout/stderr capture
    if (pipe(mStdoutPipe) < 0 || pipe(mStderrPipe) < 0) {
        printf("Failed to create pipes\n");
        return false;
    }
 
    // Make read ends non-blocking
    fcntl(mStdoutPipe[0], F_SETFL, O_NONBLOCK);
    fcntl(mStderrPipe[0], F_SETFL, O_NONBLOCK);
 
    // Clear output buffers
    mStdoutBuffer.clear();
    mStderrBuffer.clear();
 
    pid_t pid = fork();
 
    if (pid < 0) {
        printf("Failed to fork process\n");
        close(mStdoutPipe[0]);
        close(mStdoutPipe[1]);
        close(mStderrPipe[0]);
        close(mStderrPipe[1]);
        return false;
    }
 
    if (pid == 0) {
        // Child process - redirect stdout/stderr to pipes
        close(mStdoutPipe[0]);  // Close read ends
        close(mStderrPipe[0]);
 
        dup2(mStdoutPipe[1], STDOUT_FILENO);
        dup2(mStderrPipe[1], STDERR_FILENO);
 
        close(mStdoutPipe[1]);
        close(mStderrPipe[1]);
 
        // Change to working directory
        if (chdir(workingDir.c_str()) != 0) {
            fprintf(stderr, "Failed to change directory to: %s\n", workingDir.c_str());
            exit(1);
        }
 
        std::vector<char*> argv;
        argv.push_back(const_cast<char*>(peblPath.c_str()));
        argv.push_back(const_cast<char*>(scriptFilename.c_str()));
 
        for (const auto& arg : fullArgs) {
            argv.push_back(const_cast<char*>(arg.c_str()));
        }
 
        argv.push_back(nullptr);
 
        execvp(peblPath.c_str(), argv.data());
 
        // If we get here, exec failed
        fprintf(stderr, "Failed to execute: %s\n", peblPath.c_str());
        exit(1);
    }
 
    // Parent process - close write ends
    close(mStdoutPipe[1]);
    close(mStderrPipe[1]);
    mStdoutPipe[1] = -1;
    mStderrPipe[1] = -1;
 
    mProcessId = pid;
    mIsRunning = true;
#endif
 
    printf("Launched experiment: %s (PID: %lu) in directory: %s\n",
           scriptFilename.c_str(), (unsigned long)mProcessId, workingDir.c_str());
 
    // Log the launch
    mCurrentScript = scriptPath;
    mCurrentSubject = subjectCode;
    mCurrentLanguage = language;
    mCurrentFullscreen = fullscreen;
    mLaunchTime = std::time(nullptr);
    LogLaunch(scriptPath, subjectCode, language, fullscreen);
 
    return true;
}

References NULL.

Terminate()

void ExperimentRunner::Terminate

(

)

Definition at line 437 of file ExperimentRunner.cpp.

{
    if (!mIsRunning) {
        return;
    }
 
#ifdef _WIN32
    TerminateProcess(mProcessHandle, 1);
    CloseHandle(mProcessHandle);
    mProcessHandle = nullptr;
    // Close pipe handles
    if (mStdoutReadPipe) {
        CloseHandle(static_cast<HANDLE>(mStdoutReadPipe));
        mStdoutReadPipe = nullptr;
    }
    if (mStderrReadPipe) {
        CloseHandle(static_cast<HANDLE>(mStderrReadPipe));
        mStderrReadPipe = nullptr;
    }
#else
    kill(mProcessId, SIGTERM);
 
    // Close pipes
    if (mStdoutPipe[0] >= 0) {
        close(mStdoutPipe[0]);
        mStdoutPipe[0] = -1;
    }
    if (mStderrPipe[0] >= 0) {
        close(mStderrPipe[0]);
        mStderrPipe[0] = -1;
    }
#endif
 
    mIsRunning = false;
    LogCompletion(-999);  // Log termination with special exit code
    printf("Terminated experiment (PID: %lu)\n", mProcessId);
}

Referenced by ~ExperimentRunner().

UpdateOutput()

void ExperimentRunner::UpdateOutput

(

)

Definition at line 632 of file ExperimentRunner.cpp.

{
#ifdef _WIN32
    // Read from stdout pipe (non-blocking using PeekNamedPipe)
    if (mStdoutReadPipe) {
        HANDLE hPipe = static_cast<HANDLE>(mStdoutReadPipe);
        DWORD bytesAvailable = 0;
        while (PeekNamedPipe(hPipe, NULL, 0, NULL, &bytesAvailable, NULL) && bytesAvailable > 0) {
            char buffer[4096];
            DWORD bytesToRead = (bytesAvailable < sizeof(buffer) - 1) ? bytesAvailable : sizeof(buffer) - 1;
            DWORD bytesRead = 0;
            if (ReadFile(hPipe, buffer, bytesToRead, &bytesRead, NULL) && bytesRead > 0) {
                buffer[bytesRead] = '\0';
                mStdoutBuffer.append(buffer);
            } else {
                break;
            }
        }
    }
 
    // Read from stderr pipe (non-blocking using PeekNamedPipe)
    if (mStderrReadPipe) {
        HANDLE hPipe = static_cast<HANDLE>(mStderrReadPipe);
        DWORD bytesAvailable = 0;
        while (PeekNamedPipe(hPipe, NULL, 0, NULL, &bytesAvailable, NULL) && bytesAvailable > 0) {
            char buffer[4096];
            DWORD bytesToRead = (bytesAvailable < sizeof(buffer) - 1) ? bytesAvailable : sizeof(buffer) - 1;
            DWORD bytesRead = 0;
            if (ReadFile(hPipe, buffer, bytesToRead, &bytesRead, NULL) && bytesRead > 0) {
                buffer[bytesRead] = '\0';
                mStderrBuffer.append(buffer);
            } else {
                break;
            }
        }
    }
#else
    // Read from stdout pipe (non-blocking)
    if (mStdoutPipe[0] >= 0) {
        char buffer[4096];
        ssize_t bytesRead;
        while ((bytesRead = read(mStdoutPipe[0], buffer, sizeof(buffer) - 1)) > 0) {
            buffer[bytesRead] = '\0';
            mStdoutBuffer.append(buffer);
        }
    }
 
    // Read from stderr pipe (non-blocking)
    if (mStderrPipe[0] >= 0) {
        char buffer[4096];
        ssize_t bytesRead;
        while ((bytesRead = read(mStderrPipe[0], buffer, sizeof(buffer) - 1)) > 0) {
            buffer[bytesRead] = '\0';
            mStderrBuffer.append(buffer);
        }
    }
#endif
}

References NULL.

Referenced by IsRunning(), LauncherUI::Render(), and WaitForCompletion().

WaitForCompletion()

int ExperimentRunner::WaitForCompletion

(

)

Definition at line 376 of file ExperimentRunner.cpp.

{
    if (!mIsRunning) {
        return -1;
    }
 
#ifdef _WIN32
    WaitForSingleObject(mProcessHandle, INFINITE);
 
    // Do final read of any remaining output
    UpdateOutput();
 
    // Close pipe read handles
    if (mStdoutReadPipe) {
        CloseHandle(static_cast<HANDLE>(mStdoutReadPipe));
        mStdoutReadPipe = nullptr;
    }
    if (mStderrReadPipe) {
        CloseHandle(static_cast<HANDLE>(mStderrReadPipe));
        mStderrReadPipe = nullptr;
    }
 
    DWORD exitCode;
    GetExitCodeProcess(mProcessHandle, &exitCode);
    mExitCode = static_cast<int>(exitCode);
    CloseHandle(mProcessHandle);
 
    mProcessHandle = nullptr;
    mIsRunning = false;
 
    LogCompletion(mExitCode);
    return mExitCode;
#else
    int status;
    waitpid(mProcessId, &status, 0);
 
    // Do final read of any remaining output
    UpdateOutput();
 
    // Close pipes
    if (mStdoutPipe[0] >= 0) {
        close(mStdoutPipe[0]);
        mStdoutPipe[0] = -1;
    }
    if (mStderrPipe[0] >= 0) {
        close(mStderrPipe[0]);
        mStderrPipe[0] = -1;
    }
 
    mIsRunning = false;
 
    mExitCode = -1;
    if (WIFEXITED(status)) {
        mExitCode = WEXITSTATUS(status);
    }
 
    LogCompletion(mExitCode);
    return mExitCode;
#endif
}

References UpdateOutput().

---

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

• ExperimentRunner.h
• ExperimentRunner.cpp