scawful/yaze
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Integrate unified gRPC server for enhanced service management

Browse Source 
- Added `UnifiedGRPCServer` class to host both ImGuiTestHarness and ROM service, allowing simultaneous access to GUI automation and ROM manipulation.
- Implemented necessary header and source files for the unified server, including initialization, start, and shutdown functionalities.
- Updated CMake configurations to include new source files and link required gRPC libraries for the unified server.
- Enhanced existing services with gRPC support, improving overall system capabilities and enabling real-time collaboration.
- Added integration tests for AI-controlled tile placement, validating command parsing and execution via gRPC.
This commit is contained in:
scawful
2025-10-04 23:14:09 -04:00
parent 398b878c26
commit 429506e503
7 changed files with 632 additions and 491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/app/net/net_library.cmake
View File

@@ -17,9 +17,8 @@ set(
)
if(YAZE_WITH_GRPC)
# ROM service implementation ready but not compiled yet
# Will be integrated with test harness proto build system
# Files created: protos/rom_service.proto, app/net/rom_service_impl.{h,cc}
# Add ROM service implementation
list(APPEND YAZE_NET_SRC app/net/rom_service_impl.cc)
endif()
add_library(yaze_net STATIC ${YAZE_NET_SRC})
@@ -66,6 +65,19 @@ if(YAZE_WITH_JSON)
endif()
endif()
# Add gRPC support for ROM service
if(YAZE_WITH_GRPC)
target_add_protobuf(yaze_net ${CMAKE_SOURCE_DIR}/protos/rom_service.proto)
target_link_libraries(yaze_net PUBLIC
grpc++
grpc++_reflection
libprotobuf
)
message(STATUS " - gRPC ROM service enabled")
endif()
set_target_properties(yaze_net PROPERTIES
POSITION_INDEPENDENT_CODE ON
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"

501
src/app/net/rom_service_impl.cc
View File

@@ -1,428 +1,207 @@
#include "app/net/rom_service_impl.h"
#ifdef YAZE_WITH_GRPC
#include "absl/strings/str_format.h"
#include "app/rom.h"
#include "app/net/rom_version_manager.h"
namespace yaze {
namespace app {
namespace net {
#ifdef YAZE_WITH_GRPC
RomServiceImpl::RomServiceImpl(
Rom* rom,
RomVersionManager* version_mgr,
ProposalApprovalManager* approval_mgr)
RomVersionManager* version_manager,
ProposalApprovalManager* approval_manager)
: rom_(rom),
version_mgr_(version_mgr),
approval_mgr_(approval_mgr) {
// Set default config
config_.require_approval_for_writes = (approval_mgr != nullptr);
config_.enable_version_management = (version_mgr != nullptr);
version_manager_(version_manager),
approval_manager_(approval_manager) {
}
// ============================================================================
// Basic ROM Operations
// ============================================================================
void RomServiceImpl::SetConfig(const Config& config) {
config_ = config;
}
grpc::Status RomServiceImpl::ReadBytes(
grpc::ServerContext* context,
const proto::ReadBytesRequest* request,
proto::ReadBytesResponse* response) {
const rom_service::ReadBytesRequest* request,
rom_service::ReadBytesResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
if (!rom_ || !rom_->is_loaded()) {
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "ROM not loaded");
}
uint32_t offset = request->offset();
uint32_t address = request->address();
uint32_t length = request->length();
// Validate bounds
if (length > config_.max_read_size_bytes) {
return grpc::Status(
grpc::StatusCode::INVALID_ARGUMENT,
absl::StrFormat("Read size %d exceeds maximum %d",
length, config_.max_read_size_bytes));
}
if (offset + length > rom_->size()) {
// Validate range
if (address + length > rom_->size()) {
return grpc::Status(
grpc::StatusCode::OUT_OF_RANGE,
"Read would exceed ROM bounds");
absl::StrFormat("Read beyond ROM: 0x%X+%d > %d",
address, length, rom_->size()));
}
// Read data
const uint8_t* rom_data = rom_->data();
response->set_data(reinterpret_cast<const char*>(rom_data + offset), length);
const auto* data = rom_->data() + address;
response->set_data(data, length);
response->set_success(true);
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::WriteBytes(
grpc::ServerContext* context,
const proto::WriteBytesRequest* request,
proto::WriteBytesResponse* response) {
const rom_service::WriteBytesRequest* request,
rom_service::WriteBytesResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
if (!rom_ || !rom_->is_loaded()) {
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "ROM not loaded");
}
uint32_t offset = request->offset();
uint32_t address = request->address();
const std::string& data = request->data();
// Validate bounds
if (offset + data.size() > rom_->size()) {
response->set_success(false);
response->set_error("Write would exceed ROM bounds");
return grpc::Status::OK;
// Validate range
if (address + data.size() > rom_->size()) {
return grpc::Status(
grpc::StatusCode::OUT_OF_RANGE,
absl::StrFormat("Write beyond ROM: 0x%X+%zu > %d",
address, data.size(), rom_->size()));
}
// Check if approval required
if (config_.require_approval_for_writes || request->require_approval()) {
// TODO: Submit as proposal
response->set_success(false);
response->set_error("Proposal submission not yet implemented");
return grpc::Status::OK;
if (config_.require_approval_for_writes && approval_manager_) {
// Create a proposal for this write
std::string proposal_id = absl::StrFormat(
"write_0x%X_%zu_bytes", address, data.size());
if (request->has_proposal_id()) {
proposal_id = request->proposal_id();
}
// Check if proposal is approved
auto status = approval_manager_->GetProposalStatus(proposal_id);
if (status != ProposalApprovalManager::ApprovalStatus::kApproved) {
response->set_success(false);
response->set_message("Write requires approval");
response->set_proposal_id(proposal_id);
return grpc::Status::OK; // Not an error, just needs approval
}
}
// Create snapshot before write
if (config_.enable_version_management && version_mgr_) {
auto snapshot_status = MaybeCreateSnapshot(
absl::StrFormat("gRPC write at 0x%X (%d bytes)", offset, data.size()));
if (!snapshot_status.ok()) {
response->set_success(false);
response->set_error("Failed to create backup snapshot");
return grpc::Status::OK;
if (version_manager_) {
std::string snapshot_desc = absl::StrFormat(
"Before write to 0x%X (%zu bytes)", address, data.size());
auto snapshot_result = version_manager_->CreateSnapshot(snapshot_desc);
if (snapshot_result.ok()) {
response->set_snapshot_id(std::to_string(snapshot_result.value()));
}
}
// Perform write
uint8_t* rom_data = rom_->mutable_data();
std::memcpy(rom_data + offset, data.data(), data.size());
std::memcpy(rom_->mutable_data() + address, data.data(), data.size());
response->set_success(true);
response->set_message("Write successful");
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::GetRomInfo(
grpc::ServerContext* context,
const proto::GetRomInfoRequest* request,
proto::GetRomInfoResponse* response) {
const rom_service::GetRomInfoRequest* request,
rom_service::GetRomInfoResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
}
response->set_title(rom_->title());
response->set_size(rom_->size());
response->set_is_expanded(rom_->is_expanded());
// Calculate checksum if available
if (version_mgr_) {
response->set_checksum(version_mgr_->GetCurrentHash());
}
return grpc::Status::OK;
}
// ============================================================================
// Overworld Operations
// ============================================================================
grpc::Status RomServiceImpl::ReadOverworldMap(
grpc::ServerContext* context,
const proto::ReadOverworldMapRequest* request,
proto::ReadOverworldMapResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
}
uint32_t map_id = request->map_id();
if (map_id >= 160) {
response->set_error("Invalid map ID (must be 0-159)");
return grpc::Status::OK;
}
// TODO: Read actual overworld map data
// For now, return placeholder
response->set_map_id(map_id);
response->set_error("Not yet implemented");
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::WriteOverworldTile(
grpc::ServerContext* context,
const proto::WriteOverworldTileRequest* request,
proto::WriteOverworldTileResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
}
// Validate coordinates
if (request->x() >= 32 || request->y() >= 32) {
response->set_success(false);
response->set_error("Invalid tile coordinates (must be 0-31)");
return grpc::Status::OK;
}
if (request->map_id() >= 160) {
response->set_success(false);
response->set_error("Invalid map ID (must be 0-159)");
return grpc::Status::OK;
}
// TODO: Implement actual overworld tile writing
response->set_success(false);
response->set_error("Not yet implemented");
return grpc::Status::OK;
}
// ============================================================================
// Dungeon Operations
// ============================================================================
grpc::Status RomServiceImpl::ReadDungeonRoom(
grpc::ServerContext* context,
const proto::ReadDungeonRoomRequest* request,
proto::ReadDungeonRoomResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
}
uint32_t room_id = request->room_id();
if (room_id >= 296) {
response->set_error("Invalid room ID (must be 0-295)");
return grpc::Status::OK;
}
// TODO: Read actual dungeon room data
response->set_room_id(room_id);
response->set_error("Not yet implemented");
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::WriteDungeonTile(
grpc::ServerContext* context,
const proto::WriteDungeonTileRequest* request,
proto::WriteDungeonTileResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
}
// TODO: Implement dungeon tile writing
response->set_success(false);
response->set_error("Not yet implemented");
return grpc::Status::OK;
}
// ============================================================================
// Sprite Operations
// ============================================================================
grpc::Status RomServiceImpl::ReadSprite(
grpc::ServerContext* context,
const proto::ReadSpriteRequest* request,
proto::ReadSpriteResponse* response) {
auto status = ValidateRomLoaded();
if (!status.ok()) {
return status;
}
// TODO: Implement sprite reading
response->set_error("Not yet implemented");
return grpc::Status::OK;
}
// ============================================================================
// Proposal System
// ============================================================================
grpc::Status RomServiceImpl::SubmitRomProposal(
grpc::ServerContext* context,
const proto::SubmitRomProposalRequest* request,
proto::SubmitRomProposalResponse* response) {
if (!approval_mgr_) {
response->set_success(false);
response->set_error("Proposal system not enabled");
return grpc::Status::OK;
}
// TODO: Implement proposal submission
response->set_success(false);
response->set_error("Not yet implemented");
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::GetProposalStatus(
grpc::ServerContext* context,
const proto::GetProposalStatusRequest* request,
proto::GetProposalStatusResponse* response) {
if (!approval_mgr_) {
return grpc::Status(
grpc::StatusCode::FAILED_PRECONDITION,
"Proposal system not enabled");
}
std::string proposal_id = request->proposal_id();
auto status_result = approval_mgr_->GetProposalStatus(proposal_id);
if (!status_result.ok()) {
return grpc::Status(
grpc::StatusCode::NOT_FOUND,
"Proposal not found");
}
const auto& status_info = *status_result;
response->set_proposal_id(proposal_id);
response->set_status(status_info.status);
// TODO: Add vote information
return grpc::Status::OK;
}
// ============================================================================
// Version Management
// ============================================================================
grpc::Status RomServiceImpl::CreateSnapshot(
grpc::ServerContext* context,
const proto::CreateSnapshotRequest* request,
proto::CreateSnapshotResponse* response) {
if (!version_mgr_) {
response->set_success(false);
response->set_error("Version management not enabled");
return grpc::Status::OK;
}
auto snapshot_result = version_mgr_->CreateSnapshot(
request->description(),
request->username(),
request->is_checkpoint()
);
if (snapshot_result.ok()) {
response->set_success(true);
response->set_snapshot_id(*snapshot_result);
} else {
response->set_success(false);
response->set_error(std::string(snapshot_result.status().message()));
}
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::RestoreSnapshot(
grpc::ServerContext* context,
const proto::RestoreSnapshotRequest* request,
proto::RestoreSnapshotResponse* response) {
if (!version_mgr_) {
response->set_success(false);
response->set_error("Version management not enabled");
return grpc::Status::OK;
}
auto status = version_mgr_->RestoreSnapshot(request->snapshot_id());
if (status.ok()) {
response->set_success(true);
} else {
response->set_success(false);
response->set_error(std::string(status.message()));
}
return grpc::Status::OK;
}
grpc::Status RomServiceImpl::ListSnapshots(
grpc::ServerContext* context,
const proto::ListSnapshotsRequest* request,
proto::ListSnapshotsResponse* response) {
if (!version_mgr_) {
response->set_error("Version management not enabled");
return grpc::Status::OK;
}
auto snapshots = version_mgr_->GetSnapshots();
uint32_t max_results = request->max_results();
if (max_results == 0) {
max_results = snapshots.size();
}
for (size_t i = 0; i < std::min(max_results, static_cast<uint32_t>(snapshots.size())); ++i) {
const auto& snapshot = snapshots[i];
auto* info = response->add_snapshots();
info->set_snapshot_id(snapshot.snapshot_id);
info->set_description(snapshot.description);
info->set_username(snapshot.username);
info->set_timestamp(snapshot.timestamp);
info->set_is_checkpoint(snapshot.is_checkpoint);
info->set_is_safe_point(snapshot.is_safe_point);
info->set_size_bytes(snapshot.compressed_size);
}
return grpc::Status::OK;
}
// ============================================================================
// Private Helpers
// ============================================================================
grpc::Status RomServiceImpl::ValidateRomLoaded() {
if (!rom_ || !rom_->is_loaded()) {
return grpc::Status(
grpc::StatusCode::FAILED_PRECONDITION,
"ROM not loaded");
return grpc::Status(grpc::StatusCode::FAILED_PRECONDITION, "ROM not loaded");
}
auto* info = response->mutable_info();
info->set_title(rom_->title());
info->set_size(rom_->size());
info->set_is_loaded(rom_->is_loaded());
info->set_filename(rom_->filename());
return grpc::Status::OK;
}
absl::Status RomServiceImpl::MaybeCreateSnapshot(
const std::string& description) {
grpc::Status RomServiceImpl::GetTileData(
grpc::ServerContext* context,
const rom_service::GetTileDataRequest* request,
rom_service::GetTileDataResponse* response) {
if (!version_mgr_) {
return absl::OkStatus();
}
auto snapshot_result = version_mgr_->CreateSnapshot(
description,
"grpc_service",
false // not a checkpoint
);
return snapshot_result.status();
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"GetTileData not yet implemented");
}
#endif // YAZE_WITH_GRPC
grpc::Status RomServiceImpl::SetTileData(
grpc::ServerContext* context,
const rom_service::SetTileDataRequest* request,
rom_service::SetTileDataResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"SetTileData not yet implemented");
}
grpc::Status RomServiceImpl::GetMapData(
grpc::ServerContext* context,
const rom_service::GetMapDataRequest* request,
rom_service::GetMapDataResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"GetMapData not yet implemented");
}
grpc::Status RomServiceImpl::SetMapData(
grpc::ServerContext* context,
const rom_service::SetMapDataRequest* request,
rom_service::SetMapDataResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"SetMapData not yet implemented");
}
grpc::Status RomServiceImpl::GetSpriteData(
grpc::ServerContext* context,
const rom_service::GetSpriteDataRequest* request,
rom_service::GetSpriteDataResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"GetSpriteData not yet implemented");
}
grpc::Status RomServiceImpl::SetSpriteData(
grpc::ServerContext* context,
const rom_service::SetSpriteDataRequest* request,
rom_service::SetSpriteDataResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"SetSpriteData not yet implemented");
}
grpc::Status RomServiceImpl::GetDialogue(
grpc::ServerContext* context,
const rom_service::GetDialogueRequest* request,
rom_service::GetDialogueResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"GetDialogue not yet implemented");
}
grpc::Status RomServiceImpl::SetDialogue(
grpc::ServerContext* context,
const rom_service::SetDialogueRequest* request,
rom_service::SetDialogueResponse* response) {
return grpc::Status(grpc::StatusCode::UNIMPLEMENTED,
"SetDialogue not yet implemented");
}
} // namespace net
} // namespace app
} // namespace yaze
#endif // YAZE_WITH_GRPC