unified_grpc_server.cc

Go to the documentation of this file.

#include "app/service/unified_grpc_server.h"
 
#ifdef YAZE_WITH_GRPC
 
#include "util/grpc_win_compat.h"
 
#include <grpcpp/grpcpp.h>
 
#include <iostream>
#include <thread>
 
#include "absl/strings/str_format.h"
#include "app/service/canvas_automation_service.h"
#include "app/service/emulator_service_impl.h"
#include "app/service/imgui_test_harness_service.h"
#include "app/service/rom_service_impl.h"
#include "protos/canvas_automation.grpc.pb.h"
#include "rom/rom.h"
 
#include "app/editor/editor_manager.h"
 
namespace yaze {
 
YazeGRPCServer::YazeGRPCServer() : is_running_(false) {}
 
YazeGRPCServer::~YazeGRPCServer() {
  Shutdown();
}
 
absl::Status YazeGRPCServer::Initialize(
    int port, emu::IEmulator* emulator, RomGetter rom_getter,
    RomLoader rom_loader, test::TestManager* test_manager,
    net::RomVersionManager* version_mgr,
    net::ProposalApprovalManager* approval_mgr,
    CanvasAutomationServiceImpl* canvas_service) {
  if (is_running_) {
    return absl::FailedPreconditionError("Server is already running");
  }
 
  config_.port = port;
 
  // Create ImGuiTestHarness service if test_manager provided
  if (config_.enable_test_harness && test_manager) {
    test_harness_service_ =
        std::make_unique<test::ImGuiTestHarnessServiceImpl>(test_manager);
    std::cout << "✓ ImGuiTestHarness service initialized\n";
  }
 
  // Create Emulator service if emulator provided
  if (config_.enable_emulator_service && emulator) {
    emulator_service_ = std::make_unique<net::EmulatorServiceImpl>(
        emulator, rom_getter, rom_loader);
    std::cout << "✓ Emulator service initialized\n";
  } else if (config_.enable_emulator_service) {
    std::cout << "⚠ Emulator service requested but no emulator provided\n";
  }
 
  // Create ROM service if rom_getter provided
  if (config_.enable_rom_service && rom_getter) {
    rom_service_ = std::make_unique<net::RomServiceImpl>(
        rom_getter, version_mgr, approval_mgr);
 
    // Configure ROM service
    net::RomServiceImpl::Config rom_config;
    rom_config.require_approval_for_writes =
        config_.require_approval_for_rom_writes;
    rom_service_->SetConfig(rom_config);
 
    std::cout << "✓ ROM service initialized\n";
  } else if (config_.enable_rom_service) {
    std::cout << "⚠ ROM service requested but no ROM provided\n";
  }
 
  // Create Canvas Automation service if canvas_service provided
  if (config_.enable_canvas_automation && canvas_service) {
    // Store the provided service (not owned by us)
    canvas_service_ = canvas_service;
    std::cout << "✓ Canvas Automation service initialized\n";
  } else if (config_.enable_canvas_automation) {
    std::cout << "⚠ Canvas Automation requested but no service provided\n";
  }
 
  if (!test_harness_service_ && !rom_service_ && !canvas_service_ &&
      !emulator_service_) {
    return absl::InvalidArgumentError(
        "At least one service must be enabled and initialized");
  }
 
  return absl::OkStatus();
}
 
void YazeGRPCServer::SetEmulatorScreenshotCapturer(
    std::function<absl::StatusOr<test::ScreenshotArtifact>()> capturer) {
  if (emulator_service_) {
    emulator_service_->SetScreenshotCapturer(std::move(capturer));
  }
}
 
absl::Status YazeGRPCServer::Start() {
  auto status = BuildServer();
  if (!status.ok()) {
    return status;
  }
 
  std::cout << "✓ YAZE gRPC automation server listening on "
            << config_.bind_address << ":" << config_.port << "\n";
 
  if (test_harness_service_) {
    std::cout << "  ✓ ImGuiTestHarness available\n";
  }
  if (emulator_service_) {
    std::cout << "  ✓ EmulatorService available\n";
  }
  if (rom_service_) {
    std::cout << "  ✓ ROM service available\n";
  }
  if (canvas_service_) {
    std::cout << "  ✓ Canvas Automation available\n";
  }
 
  std::cout << "\nServer is ready to accept requests...\n";
 
  // Block until server is shut down
  server_->Wait();
  is_running_ = false;
 
  return absl::OkStatus();
}
 
absl::Status YazeGRPCServer::StartAsync() {
  auto status = BuildServer();
  if (!status.ok()) {
    return status;
  }
 
  std::cout << "✓ Unified gRPC server started on port " << config_.port << "\n";
 
  // Server runs in background, doesn't block
  return absl::OkStatus();
}
 
absl::Status YazeGRPCServer::AddService(
    std::unique_ptr<grpc::Service> service) {
  if (!service) {
    return absl::InvalidArgumentError("Service is null");
  }
  if (is_running_) {
    return absl::FailedPreconditionError(
        "Cannot add services after the server has started");
  }
  extra_services_.push_back(std::move(service));
  return absl::OkStatus();
}
 
void YazeGRPCServer::Shutdown() {
  if (server_) {
    std::cout << "⏹ Shutting down unified gRPC server...\n";
    if (is_running_) {
      server_->Shutdown();
    }
    server_->Wait();
    server_.reset();
    is_running_ = false;
    ReleaseRegisteredServices();
    std::cout << "✓ Server stopped\n";
  }
}
 
bool YazeGRPCServer::IsRunning() const {
  return is_running_;
}
 
absl::Status YazeGRPCServer::BuildServer() {
  if (is_running_) {
    return absl::FailedPreconditionError("Server already running");
  }
 
  std::string server_address =
      absl::StrFormat("%s:%d", config_.bind_address, config_.port);
 
  grpc::ServerBuilder builder;
 
  int selected_port = 0;
  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials(),
                           &selected_port);
 
  // Register services
  if (test_harness_service_) {
    // Create gRPC wrapper for the test harness service
    test_harness_grpc_wrapper_ =
        test::CreateImGuiTestHarnessServiceGrpc(test_harness_service_.get());
    std::cout << "  Registering ImGuiTestHarness service...\n";
    builder.RegisterService(test_harness_grpc_wrapper_.get());
  }
 
  if (emulator_service_) {
    std::cout << "  Registering EmulatorService...\n";
    builder.RegisterService(emulator_service_.get());
  }
 
  if (rom_service_) {
    std::cout << "  Registering ROM service...\n";
    builder.RegisterService(rom_service_.get());
  }
 
  if (canvas_service_) {
    std::cout << "  Registering Canvas Automation service...\n";
    // Create gRPC wrapper using factory function
    canvas_grpc_service_ = CreateCanvasAutomationServiceGrpc(canvas_service_);
    builder.RegisterService(canvas_grpc_service_.get());
  }
 
  for (auto& service : extra_services_) {
    builder.RegisterService(service.get());
  }
 
  // Build and start
  server_ = builder.BuildAndStart();
 
  if (!server_) {
    return absl::InternalError(
        absl::StrFormat("Failed to start server on %s", server_address));
  }
 
  is_running_ = true;
  if (selected_port > 0) {
    config_.port = selected_port;
  }
 
  return absl::OkStatus();
}
 
void YazeGRPCServer::ReleaseRegisteredServices() {
  canvas_grpc_service_.reset();
  test_harness_grpc_wrapper_.reset();
  extra_services_.clear();
  emulator_service_.reset();
  rom_service_.reset();
  test_harness_service_.reset();
  canvas_service_ = nullptr;
}
 
}  // namespace yaze
 
#endif  // YAZE_WITH_GRPC