rom_version_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_NET_ROM_VERSION_MANAGER_H_
#define YAZE_APP_NET_ROM_VERSION_MANAGER_H_
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "rom/rom.h"
 
#ifdef YAZE_WITH_JSON
#include "nlohmann/json.hpp"
#endif
 
namespace yaze {
 
namespace net {
 
struct RomSnapshot {
  std::string snapshot_id;
  std::string description;
  int64_t timestamp;
  std::string rom_hash;
  std::vector<uint8_t> rom_data;
  size_t compressed_size;
 
  // Metadata
  std::string creator;
  bool is_checkpoint;  // Manual checkpoint vs auto-backup
  bool is_safe_point;  // Marked as "known good" by host
 
#ifdef YAZE_WITH_JSON
  nlohmann::json metadata;  // Custom metadata (proposals applied, etc.)
#endif
};
 
struct VersionDiff {
  std::string from_snapshot_id;
  std::string to_snapshot_id;
  std::vector<std::pair<size_t, std::vector<uint8_t>>> changes;  // offset, data
  size_t total_bytes_changed;
  std::vector<std::string> proposals_applied;  // IDs of proposals in this diff
};
 
class RomVersionManager {
 public:
  struct Config {
    bool enable_auto_backup = true;
    int auto_backup_interval_seconds = 300;  // 5 minutes
    size_t max_snapshots = 50;
    size_t max_storage_mb = 500;  // 500MB max for all snapshots
    bool compress_snapshots = true;
    bool enable_corruption_detection = true;
  };
 
  explicit RomVersionManager(Rom* rom);
  ~RomVersionManager();
 
  absl::Status Initialize(const Config& config);
 
  absl::StatusOr<std::string> CreateSnapshot(const std::string& description,
                                             const std::string& creator,
                                             bool is_checkpoint = false);
 
  absl::Status RestoreSnapshot(const std::string& snapshot_id);
 
  absl::Status MarkAsSafePoint(const std::string& snapshot_id);
 
  std::vector<RomSnapshot> GetSnapshots(bool safe_points_only = false) const;
 
  absl::StatusOr<RomSnapshot> GetSnapshot(const std::string& snapshot_id) const;
 
  absl::Status DeleteSnapshot(const std::string& snapshot_id);
 
  absl::StatusOr<VersionDiff> GenerateDiff(const std::string& from_id,
                                           const std::string& to_id) const;
 
  absl::StatusOr<bool> DetectCorruption();
 
  absl::Status AutoRecover();
 
  absl::Status ExportSnapshot(const std::string& snapshot_id,
                              const std::string& filepath);
 
  absl::Status ImportSnapshot(const std::string& filepath);
 
  std::string GetCurrentHash() const;
 
  absl::Status CleanupOldSnapshots();
 
  struct Stats {
    size_t total_snapshots;
    size_t safe_points;
    size_t auto_backups;
    size_t manual_checkpoints;
    size_t total_storage_bytes;
    int64_t oldest_snapshot_timestamp;
    int64_t newest_snapshot_timestamp;
  };
  Stats GetStats() const;
 
 private:
  Rom* rom_;
  Config config_;
  std::map<std::string, RomSnapshot> snapshots_;
  std::string last_known_hash_;
  int64_t last_backup_time_;
 
  // Helper functions
  std::string ComputeRomHash() const;
  std::vector<uint8_t> CompressData(const std::vector<uint8_t>& data) const;
  std::vector<uint8_t> DecompressData(
      const std::vector<uint8_t>& compressed) const;
  absl::Status ValidateRomIntegrity() const;
  size_t GetTotalStorageUsed() const;
  void PruneOldSnapshots();
};
 
class ProposalApprovalManager {
 public:
  enum class ApprovalMode {
    kHostOnly,      // Only host can approve
    kMajorityVote,  // Majority of participants must approve
    kUnanimous,     // All participants must approve
    kAutoApprove    // No approval needed (dangerous!)
  };
 
  struct ApprovalStatus {
    std::string proposal_id;
    std::string status;  // "pending", "approved", "rejected", "applied"
    std::map<std::string, bool> votes;  // username -> approved
    int64_t created_at;
    int64_t decided_at;
    std::string snapshot_before;  // Snapshot ID before applying
    std::string snapshot_after;   // Snapshot ID after applying
  };
 
  explicit ProposalApprovalManager(RomVersionManager* version_mgr);
 
  void SetApprovalMode(ApprovalMode mode);
 
  void SetHost(const std::string& host_username);
 
  absl::Status SubmitProposal(const std::string& proposal_id,
                              const std::string& sender,
                              const std::string& description,
                              const nlohmann::json& proposal_data);
 
  absl::Status VoteOnProposal(const std::string& proposal_id,
                              const std::string& username, bool approved);
 
  absl::Status ApplyProposal(const std::string& proposal_id, Rom* rom);
 
  absl::Status RejectProposal(const std::string& proposal_id);
 
  absl::StatusOr<ApprovalStatus> GetProposalStatus(
      const std::string& proposal_id) const;
 
  std::vector<ApprovalStatus> GetPendingProposals() const;
 
  bool IsProposalApproved(const std::string& proposal_id) const;
 
  std::vector<ApprovalStatus> GetAuditLog() const;
 
 private:
  RomVersionManager* version_mgr_;
  ApprovalMode mode_;
  std::string host_username_;
  std::map<std::string, ApprovalStatus> proposals_;
  std::vector<std::string> participants_;
 
  bool CheckApprovalThreshold(const ApprovalStatus& status) const;
};
 
}  // namespace net
 
}  // namespace yaze
 
#endif  // YAZE_APP_NET_ROM_VERSION_MANAGER_H_