107 lines
3.6 KiB
C++
107 lines
3.6 KiB
C++
#pragma once
|
|
// Step 599: Incident Response Runbook Engine
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
struct RunbookStep {
|
|
std::string stepId;
|
|
std::string instruction;
|
|
bool required = true;
|
|
};
|
|
|
|
struct Runbook {
|
|
std::string runbookId;
|
|
std::string incidentType;
|
|
std::vector<RunbookStep> steps;
|
|
};
|
|
|
|
struct RunbookExecutionState {
|
|
std::string runbookId;
|
|
std::vector<std::string> completedStepIds;
|
|
bool closed = false;
|
|
};
|
|
|
|
class IncidentResponseRunbookEngine {
|
|
public:
|
|
bool registerRunbook(const Runbook& runbook, std::string* error) {
|
|
if (!error) return false;
|
|
error->clear();
|
|
if (runbook.runbookId.empty()) return fail(error, "runbook_id_missing");
|
|
if (runbook.incidentType.empty()) return fail(error, "incident_type_missing");
|
|
if (runbook.steps.empty()) return fail(error, "runbook_steps_missing");
|
|
if (runbooks_.count(runbook.runbookId) != 0) return fail(error, "runbook_duplicate");
|
|
runbooks_[runbook.runbookId] = runbook;
|
|
return true;
|
|
}
|
|
|
|
bool start(const std::string& runbookId, RunbookExecutionState* state, std::string* error) const {
|
|
if (!state || !error) return false;
|
|
error->clear();
|
|
if (runbooks_.count(runbookId) == 0) return fail(error, "runbook_missing");
|
|
state->runbookId = runbookId;
|
|
state->completedStepIds.clear();
|
|
state->closed = false;
|
|
return true;
|
|
}
|
|
|
|
bool completeStep(RunbookExecutionState* state,
|
|
const std::string& stepId,
|
|
std::string* error) const {
|
|
if (!state || !error) return false;
|
|
error->clear();
|
|
const auto* rb = findRunbook(state->runbookId);
|
|
if (!rb) return fail(error, "runbook_missing");
|
|
if (state->closed) return fail(error, "execution_closed");
|
|
if (!hasStep(*rb, stepId)) return fail(error, "step_missing");
|
|
for (const auto& s : state->completedStepIds) if (s == stepId) return fail(error, "step_already_completed");
|
|
state->completedStepIds.push_back(stepId);
|
|
return true;
|
|
}
|
|
|
|
bool closeIfReady(RunbookExecutionState* state, std::string* error) const {
|
|
if (!state || !error) return false;
|
|
error->clear();
|
|
const auto* rb = findRunbook(state->runbookId);
|
|
if (!rb) return fail(error, "runbook_missing");
|
|
for (const auto& step : rb->steps) {
|
|
if (!step.required) continue;
|
|
if (!isCompleted(*state, step.stepId)) return fail(error, "required_steps_incomplete");
|
|
}
|
|
state->closed = true;
|
|
return true;
|
|
}
|
|
|
|
int completionPercent(const RunbookExecutionState& state) const {
|
|
const auto* rb = findRunbook(state.runbookId);
|
|
if (!rb || rb->steps.empty()) return 0;
|
|
const int done = static_cast<int>(state.completedStepIds.size());
|
|
return (done * 100) / static_cast<int>(rb->steps.size());
|
|
}
|
|
|
|
private:
|
|
std::map<std::string, Runbook> runbooks_;
|
|
|
|
static bool fail(std::string* error, const char* code) {
|
|
*error = code;
|
|
return false;
|
|
}
|
|
|
|
const Runbook* findRunbook(const std::string& runbookId) const {
|
|
auto it = runbooks_.find(runbookId);
|
|
if (it == runbooks_.end()) return nullptr;
|
|
return &it->second;
|
|
}
|
|
|
|
static bool hasStep(const Runbook& runbook, const std::string& stepId) {
|
|
for (const auto& s : runbook.steps) if (s.stepId == stepId) return true;
|
|
return false;
|
|
}
|
|
|
|
static bool isCompleted(const RunbookExecutionState& state, const std::string& stepId) {
|
|
for (const auto& s : state.completedStepIds) if (s == stepId) return true;
|
|
return false;
|
|
}
|
|
};
|