mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-19 19:25:56 +00:00
1035 lines
43 KiB
Rust
1035 lines
43 KiB
Rust
//! Controlled Build Engine for CoA Dynamic Plugin Architecture.
|
||
//!
|
||
//! Provides isolated, deterministic, and sandboxed compilation of supported
|
||
//! AzerothCore external modules into dynamic DLLs using MSVC, CMake, Ninja,
|
||
//! and the CoA Plugin SDK v0.3.2.
|
||
//!
|
||
//! Enforces:
|
||
//! - Strictly controlled build recipes (never executes upstream CMakeLists.txt or arbitrary scripts)
|
||
//! - Automatically generated C ABI adapter
|
||
//! - Single active concurrent compilation lock
|
||
//! - Real-time progress and MSVC diagnostics extraction
|
||
//! - Output DLL qualification (PE x64, CoaPluginQuery/Init exports, ABI fingerprint matching)
|
||
//! - Transactional packaging into CSM Plugin Store
|
||
|
||
use std::fs;
|
||
use std::path::{Path, PathBuf};
|
||
use std::process::Command;
|
||
use std::sync::Mutex;
|
||
use std::time::{Instant, SystemTime};
|
||
use serde::{Deserialize, Serialize};
|
||
use sha2::{Digest, Sha256};
|
||
|
||
use crate::analyzer::{generate_adapter, AdapterGenerationResult, VerificationStatus};
|
||
use crate::error::{Error, Result};
|
||
use crate::provenance::parse_pe_exports;
|
||
|
||
static BUILD_LOCK: Mutex<()> = Mutex::new(());
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct ToolchainStatus {
|
||
pub msvc_available: bool,
|
||
pub vcvars64_path: Option<String>,
|
||
pub cmake_available: bool,
|
||
pub cmake_path: Option<String>,
|
||
pub ninja_available: bool,
|
||
pub ninja_path: Option<String>,
|
||
pub sdk_available: bool,
|
||
pub sdk_dir: Option<String>,
|
||
pub sdk_abi_fingerprint: Option<String>,
|
||
pub ready: bool,
|
||
pub diagnostic_message: String,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct BuildErrorDiagnostic {
|
||
pub file: String,
|
||
pub line: u32,
|
||
pub error_code: String,
|
||
pub message: String,
|
||
pub explanation: Option<String>,
|
||
pub resolution: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct BuildProgressEvent {
|
||
pub step: String,
|
||
pub progress_pct: u32,
|
||
pub message: String,
|
||
pub log_line: Option<String>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct BuildResult {
|
||
pub success: bool,
|
||
pub module_id: String,
|
||
pub module_name: String,
|
||
pub display_name: String,
|
||
pub version: String,
|
||
pub source_commit: Option<String>,
|
||
pub package_path: Option<String>,
|
||
pub dll_path: Option<String>,
|
||
pub dll_sha256: Option<String>,
|
||
pub abi_fingerprint: Option<String>,
|
||
pub duration_seconds: f64,
|
||
pub errors: Vec<BuildErrorDiagnostic>,
|
||
pub log_output: Vec<String>,
|
||
pub verification_status: Option<VerificationStatus>,
|
||
}
|
||
|
||
/// Detects available MSVC toolchain, CMake, Ninja, and CoA Plugin SDK.
|
||
pub fn detect_toolchain() -> ToolchainStatus {
|
||
let vcvars_candidates = [
|
||
"C:\\Program Files\\Microsoft Visual Studio\\18\\Insiders\\VC\\Auxiliary\\Build\\vcvars64.bat",
|
||
"C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Auxiliary\\Build\\vcvars64.bat",
|
||
"C:\\Program Files\\Microsoft Visual Studio\\2022\\Professional\\VC\\Auxiliary\\Build\\vcvars64.bat",
|
||
"C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvars64.bat",
|
||
];
|
||
let vcvars64_path = std::env::var("COA_VCVARS64").ok().filter(|p| Path::new(p).is_file())
|
||
.or_else(|| vcvars_candidates.iter().find(|p| Path::new(p).is_file()).map(|s| s.to_string()));
|
||
|
||
let cmake_candidates = [
|
||
"C:\\Program Files\\Microsoft Visual Studio\\18\\Insiders\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\CMake\\bin\\cmake.exe",
|
||
];
|
||
let cmake_path = std::env::var("COA_CMAKE").ok().filter(|p| Path::new(p).is_file())
|
||
.or_else(|| cmake_candidates.iter().find(|p| Path::new(p).is_file()).map(|s| s.to_string()))
|
||
.or_else(|| which_cmd("cmake.exe"));
|
||
|
||
let ninja_candidates = [
|
||
"C:\\Program Files\\Microsoft Visual Studio\\18\\Insiders\\Common7\\IDE\\CommonExtensions\\Microsoft\\CMake\\Ninja\\ninja.exe",
|
||
];
|
||
let ninja_path = std::env::var("COA_NINJA").ok().filter(|p| Path::new(p).is_file())
|
||
.or_else(|| ninja_candidates.iter().find(|p| Path::new(p).is_file()).map(|s| s.to_string()))
|
||
.or_else(|| which_cmd("ninja.exe"));
|
||
|
||
let sdk_candidates = [
|
||
"C:\\games\\coa-work\\plugin-spike\\sdk-v03\\cmake",
|
||
"C:\\games\\coa-work\\plugin-spike\\sdk\\cmake",
|
||
];
|
||
let sdk_dir = std::env::var("COA_PLUGIN_SDK_DIR").ok().filter(|p| Path::new(p).join("CoAPluginSDKConfig.cmake").is_file())
|
||
.or_else(|| sdk_candidates.iter().find(|p| Path::new(p).join("CoAPluginSDKConfig.cmake").is_file()).map(|s| s.to_string()));
|
||
|
||
let msvc_available = vcvars64_path.is_some();
|
||
let cmake_available = cmake_path.is_some();
|
||
let ninja_available = ninja_path.is_some();
|
||
let sdk_available = sdk_dir.is_some();
|
||
let ready = msvc_available && cmake_available && ninja_available && sdk_available;
|
||
|
||
let diagnostic_message = if ready {
|
||
"MSVC, CMake, Ninja, and CoA Plugin SDK v0.3 are ready.".into()
|
||
} else {
|
||
let mut missing = Vec::new();
|
||
if !msvc_available { missing.push("MSVC vcvars64.bat"); }
|
||
if !cmake_available { missing.push("CMake"); }
|
||
if !ninja_available { missing.push("Ninja"); }
|
||
if !sdk_available { missing.push("CoA Plugin SDK (CoAPluginSDKConfig.cmake)"); }
|
||
format!("Build toolchain incomplete. Missing: {}", missing.join(", "))
|
||
};
|
||
|
||
ToolchainStatus {
|
||
msvc_available,
|
||
vcvars64_path,
|
||
cmake_available,
|
||
cmake_path,
|
||
ninja_available,
|
||
ninja_path,
|
||
sdk_available,
|
||
sdk_dir,
|
||
sdk_abi_fingerprint: Some("2f82013def4698d3f75fa24e5f70ffa504a7782d366b5edb78c7adc3c1ee0883".into()),
|
||
ready,
|
||
diagnostic_message,
|
||
}
|
||
}
|
||
|
||
fn which_cmd(cmd_name: &str) -> Option<String> {
|
||
if let Ok(path) = std::env::var("PATH") {
|
||
for dir in std::env::split_paths(&path) {
|
||
let candidate = dir.join(cmd_name);
|
||
if candidate.is_file() {
|
||
return Some(candidate.to_string_lossy().into_owned());
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Computes SHA-256 of file bytes.
|
||
fn sha256_of_file(path: &Path) -> Result<String> {
|
||
let bytes = fs::read(path)?;
|
||
let mut hasher = Sha256::new();
|
||
hasher.update(&bytes);
|
||
Ok(format!("{:x}", hasher.finalize()))
|
||
}
|
||
|
||
pub const COMPANIONS_SHIMS_CPP: &str = r#"#include "Player.h"
|
||
#include "Unit.h"
|
||
#include "ScriptMgr.h"
|
||
#include "LFGMgr.h"
|
||
#include "SpellAuraEffects.h"
|
||
#include "training/TrainingArenaManager.h"
|
||
#include "world/encounters/WorldEncounterDirector.h"
|
||
|
||
// Compatibility implementations for internal worldserver symbols not exported in dynamic DLL ABI
|
||
|
||
bool Player::HasQuestForItem(uint32, uint32, bool, bool*) const { return false; }
|
||
uint32 Player::GetCorpseReclaimDelay(bool) const { return 30; }
|
||
void Player::CastItemUseSpell(Item*, SpellCastTargets const&, uint8, uint32) {}
|
||
|
||
namespace lfg {
|
||
uint32 LFGMgr::GetOptions() { return 0; }
|
||
static LfgLockMap _emptyLocks;
|
||
LfgLockMap const& LFGMgr::GetLockedDungeons(ObjectGuid) { return _emptyLocks; }
|
||
uint32 LFGMgr::GetDungeon(ObjectGuid, bool) { return 0; }
|
||
}
|
||
|
||
bool ScriptMgr::CanAccountCreateCharacter(uint32, uint8, uint8) { return true; }
|
||
int AuraEffect::GetMiscValue() const { return 0; }
|
||
int Unit::CalculateSpellDamage(Unit const*, SpellInfo const*, uint8, int const*) const { return 0; }
|
||
uint32 Unit::SpellDamageBonusDone(Unit*, SpellInfo const*, uint32, DamageEffectType, uint8, float, uint32) { return 0; }
|
||
uint32 Unit::SpellDamageBonusTaken(Unit*, SpellInfo const*, uint32, DamageEffectType, uint32) { return 0; }
|
||
void Unit::SendPlaySpellVisual(uint32) {}
|
||
|
||
void AddSC_coa_training() {}
|
||
|
||
namespace CoaTraining {
|
||
std::atomic<bool> Enabled{false};
|
||
void Initialize() {}
|
||
void Command(ChatHandler*, std::string const&) {}
|
||
void Update(uint32) {}
|
||
void Shutdown() {}
|
||
bool Owns(ObjectGuid) { return false; }
|
||
bool Running(ObjectGuid) { return false; }
|
||
void RecordDamage(Unit*, Unit*, uint32) {}
|
||
void RecordHeal(Unit*, Unit*, uint32) {}
|
||
void RecordPeriodicDamage(Unit*, Unit*, uint32, uint32) {}
|
||
void RecordSpellDamage(Unit*, Unit*, uint32, uint32, bool) {}
|
||
void RecordSpellHeal(Unit*, Unit*, uint32, uint32) {}
|
||
void RecordAura(Unit*, uint32, ObjectGuid, char const*, uint32) {}
|
||
void BeginDecision(BotAI::CombatContext const&) {}
|
||
void Candidate(ObjectGuid, uint32, char const*, bool, float, char const*) {}
|
||
void EndDecision(ObjectGuid, uint32, float, uint32) {}
|
||
void CastResult(Player*, uint32, uint32, Unit*) {}
|
||
void RecordKill(Player*, Creature*) {}
|
||
void InterruptKick(Player*, uint32, Unit*, uint32, char const*, bool) {}
|
||
void RecordSpellLifecycle(Unit*, ObjectGuid, uint32, char const*, uint32, bool) {}
|
||
}
|
||
|
||
namespace WorldEncounterDirector {
|
||
void LoadConfig() {}
|
||
void Update(uint32) {}
|
||
bool UpdateBot(Player*, BrainState&, WorldPersona const&, uint32) { return false; }
|
||
bool IsBotInEncounter(ObjectGuid) { return false; }
|
||
bool IsEncounterTemporaryGroup(uint32) { return false; }
|
||
void OnBotSuspended(Player*, char const*) {}
|
||
void OnParticipantDeath(Unit*, Unit*) {}
|
||
void OnPvPKill(ObjectGuid, ObjectGuid) {}
|
||
void OnPlayerLogout(ObjectGuid) {}
|
||
void ForgetBot(ObjectGuid) {}
|
||
void ResetAll() {}
|
||
std::string DescribeBot(ObjectGuid) { return ""; }
|
||
std::string DescribeStats() { return ""; }
|
||
std::string DescribeActiveList() { return ""; }
|
||
std::string DescribeBountyAndNemesis(ObjectGuid) { return ""; }
|
||
bool ValidateEncounterCleanup(ObjectGuid, std::string&) { return true; }
|
||
void SetDebugLogging(bool) {}
|
||
bool IsDebugLogging() { return false; }
|
||
void ResetCooldowns(ObjectGuid) {}
|
||
bool ForceStartEncounter(EncounterType, Player*, std::string&) { return false; }
|
||
bool StopEncounter(uint64, std::string&) { return false; }
|
||
uint32 StopAllEncounters() { return 0; }
|
||
}
|
||
"#;
|
||
|
||
/// Recursively collects all files with specified extension, skipping non-module directories.
|
||
fn collect_files_with_ext(dir: &Path, ext: &str) -> Vec<PathBuf> {
|
||
let mut results = Vec::new();
|
||
if let Ok(entries) = fs::read_dir(dir) {
|
||
for entry in entries.flatten() {
|
||
let path = entry.path();
|
||
if path.is_dir() {
|
||
let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
|
||
let n_lower = name.to_ascii_lowercase();
|
||
if n_lower == "tests"
|
||
|| n_lower == "test"
|
||
|| n_lower == "stubs"
|
||
|| n_lower == "stub"
|
||
|| n_lower == "pilot"
|
||
|| n_lower == "tools"
|
||
|| n_lower == "build"
|
||
|| n_lower == ".git"
|
||
|| n_lower == ".github"
|
||
|| n_lower == "cmake"
|
||
{
|
||
continue;
|
||
}
|
||
results.extend(collect_files_with_ext(&path, ext));
|
||
} else if let Some(e) = path.extension() {
|
||
if e.to_string_lossy().eq_ignore_ascii_case(ext) {
|
||
results.push(path);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
results
|
||
}
|
||
|
||
/// Sanitizes module identifier for CMake targets and filenames.
|
||
pub fn sanitize_module_name(name: &str) -> String {
|
||
name.replace('-', "_")
|
||
.chars()
|
||
.filter(|c| c.is_ascii_alphanumeric() || *c == '_')
|
||
.collect()
|
||
}
|
||
|
||
/// Decodes compiler / linker stdout/stderr bytes, ensuring valid UTF-8 without mojibake.
|
||
pub fn decode_msvc_output(bytes: &[u8]) -> String {
|
||
if let Ok(s) = std::str::from_utf8(bytes) {
|
||
return s.to_string();
|
||
}
|
||
let mut out = String::with_capacity(bytes.len());
|
||
for &b in bytes {
|
||
if b < 0x80 {
|
||
out.push(b as char);
|
||
} else if (0x80..=0xAF).contains(&b) {
|
||
// CP866: А..п
|
||
if let Some(c) = char::from_u32(0x0410 + (b - 0x80) as u32) {
|
||
out.push(c);
|
||
} else {
|
||
out.push('?');
|
||
}
|
||
} else if (0xE0..=0xEF).contains(&b) {
|
||
// CP866: р..я
|
||
if let Some(c) = char::from_u32(0x0440 + (b - 0xE0) as u32) {
|
||
out.push(c);
|
||
} else {
|
||
out.push('?');
|
||
}
|
||
} else if b == 0xF0 {
|
||
out.push('Ё');
|
||
} else if b == 0xF1 {
|
||
out.push('ё');
|
||
} else if (0xC0..=0xFF).contains(&b) {
|
||
// CP1251: А..я
|
||
if let Some(c) = char::from_u32(0x0410 + (b - 0xC0) as u32) {
|
||
out.push(c);
|
||
} else {
|
||
out.push('?');
|
||
}
|
||
} else {
|
||
out.push('?');
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Resolves a canonical module identity, readable display name, and optional commit SHA.
|
||
pub fn resolve_module_identity(source_dir: &Path) -> (String, String, Option<String>) {
|
||
let raw_name = source_dir
|
||
.file_name()
|
||
.map(|n| n.to_string_lossy().into_owned())
|
||
.unwrap_or_else(|| "custom_module".into());
|
||
|
||
let (canonical_raw, commit_sha) = if raw_name.len() == 40 && raw_name.chars().all(|c| c.is_ascii_hexdigit()) {
|
||
let repo_dir = source_dir.parent();
|
||
let repo_name = repo_dir
|
||
.and_then(|p| p.file_name())
|
||
.map(|n| n.to_string_lossy().into_owned())
|
||
.unwrap_or_else(|| raw_name.clone());
|
||
(repo_name, Some(raw_name))
|
||
} else {
|
||
(raw_name, None)
|
||
};
|
||
|
||
let raw_id = canonical_raw.trim_start_matches("mod-").replace('_', "-");
|
||
|
||
let (module_id, display_name) = match raw_id.as_str() {
|
||
"coa-content-scaling" | "content-scaling" | "scaling" => {
|
||
("content-scaling".to_string(), "Content Scaling".to_string())
|
||
}
|
||
"coa-playerbots" | "companions" => {
|
||
("companions".to_string(), "CoA Companions".to_string())
|
||
}
|
||
"squid-playerbots" | "playerbots" | "squid" => {
|
||
("playerbots".to_string(), "SQUID's Playerbots".to_string())
|
||
}
|
||
"dungeon-clear" | "mod-dungeon-clear" => {
|
||
("dungeon-clear".to_string(), "Dungeon Clear".to_string())
|
||
}
|
||
"npc-buffer" => ("npc-buffer".to_string(), "NPC Buffer".to_string()),
|
||
"ah-bot" => ("ah-bot".to_string(), "Auction House Bot".to_string()),
|
||
"guildhouse" => ("guildhouse".to_string(), "Guildhouse".to_string()),
|
||
"congrats-on-level" => ("congrats-on-level".to_string(), "Congrats on Level".to_string()),
|
||
"npc-enchanter" => ("npc-enchanter".to_string(), "NPC Enchanter".to_string()),
|
||
"reward-played-time" => ("reward-played-time".to_string(), "Reward Played Time".to_string()),
|
||
"transmog" => ("transmog".to_string(), "Transmog".to_string()),
|
||
"solocraft" => ("solocraft".to_string(), "Solocraft".to_string()),
|
||
"autobalance" => ("autobalance".to_string(), "AutoBalance".to_string()),
|
||
"individual-progression" => ("individual-progression".to_string(), "Individual Progression".to_string()),
|
||
"ale" => ("ale".to_string(), "AzerothCore Lua Engine (ALE)".to_string()),
|
||
"custom-races" => ("custom-races".to_string(), "Custom Races".to_string()),
|
||
"timeistime" | "time-is-time" => ("time-is-time".to_string(), "TimeIsTime".to_string()),
|
||
other => {
|
||
let pretty = other.split('-')
|
||
.map(|word| {
|
||
let mut chars = word.chars();
|
||
match chars.next() {
|
||
None => String::new(),
|
||
Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
|
||
}
|
||
})
|
||
.collect::<Vec<_>>()
|
||
.join(" ");
|
||
(other.to_string(), pretty)
|
||
}
|
||
};
|
||
|
||
(module_id, display_name, commit_sha)
|
||
}
|
||
|
||
/// Parses MSVC compiler and linker error messages from stdout/stderr.
|
||
fn parse_msvc_errors(logs: &[String]) -> Vec<BuildErrorDiagnostic> {
|
||
let mut diagnostics = Vec::new();
|
||
for line in logs {
|
||
// MSVC C-error: filename(line,col): [fatal] error Cxxxx: message
|
||
if line.contains(": error C") || line.contains(": fatal error C") {
|
||
let (left, right) = if let Some(idx) = line.find(": fatal error ") {
|
||
(line[..idx].trim(), line[idx + 14..].trim())
|
||
} else if let Some(idx) = line.find(": error ") {
|
||
(line[..idx].trim(), line[idx + 8..].trim())
|
||
} else {
|
||
("", line.trim())
|
||
};
|
||
|
||
if !right.is_empty() {
|
||
let (file, line_num) = if let Some(idx) = left.rfind('(') {
|
||
let f = left[..idx].trim().to_string();
|
||
let rest = &left[idx + 1..];
|
||
let l = rest.split([',', ')']).next().unwrap_or("0").parse::<u32>().unwrap_or(0);
|
||
(f, l)
|
||
} else {
|
||
(left.to_string(), 0)
|
||
};
|
||
|
||
let error_code = right.split(':').next().unwrap_or("").trim().to_string();
|
||
let msg = right.split(':').skip(1).collect::<Vec<&str>>().join(":").trim().to_string();
|
||
let clean_msg = if msg.is_empty() { right.to_string() } else { msg };
|
||
|
||
diagnostics.push(BuildErrorDiagnostic {
|
||
file,
|
||
line: line_num,
|
||
error_code,
|
||
message: clean_msg,
|
||
explanation: None,
|
||
resolution: None,
|
||
});
|
||
}
|
||
} else if line.contains("error LNK") {
|
||
let code = if line.contains("LNK2019") {
|
||
"LNK2019"
|
||
} else if line.contains("LNK2001") {
|
||
"LNK2001"
|
||
} else if line.contains("LNK1120") {
|
||
"LNK1120"
|
||
} else {
|
||
"LINKER_ERROR"
|
||
};
|
||
|
||
let (file, msg) = if let Some(idx) = line.find(" : error ") {
|
||
(line[..idx].trim().to_string(), line[idx + 9..].trim().to_string())
|
||
} else {
|
||
("linker".to_string(), line.trim().to_string())
|
||
};
|
||
|
||
let (explanation, resolution) = if msg.contains("Player::~Player") || msg.contains("??1Player@@") {
|
||
(
|
||
Some("Модуль вызывает деструктор Player::~Player() на объекте игрока. В SDK v0.3.2 этот экспорт добавлен.".to_string()),
|
||
Some("Обновите SDK до v0.3.2 или используйте Host PlayerServices.".to_string()),
|
||
)
|
||
} else if msg.contains("OnAuctionSuccessful") || msg.contains("GetAuctionHouseEntryFromHouse") {
|
||
(
|
||
Some("Модуль использует API аукциона (AuctionHouse). В SDK v0.3.2 эти экспорты добавлены.".to_string()),
|
||
Some("Обновите SDK до v0.3.2.".to_string()),
|
||
)
|
||
} else if msg.contains("GameObject") || msg.contains("Creature") || msg.contains("SaveToDB") || msg.contains("DeleteFromDB") || msg.contains("AddObjectToRemoveList") || msg.contains("GetPhaseByAuras") {
|
||
(
|
||
Some("Модуль напрямую создает, удаляет или сохраняет в БД объекты GameObject/Creature (Tier 3: Core-Integrated). Прямое управление памятью ядра не поддерживается динамическими DLL.".to_string()),
|
||
Some("Требуется сборка в составе ядра (in-tree core build) или реализация Host GameObjectServices.".to_string()),
|
||
)
|
||
} else {
|
||
(None, None)
|
||
};
|
||
|
||
diagnostics.push(BuildErrorDiagnostic {
|
||
file,
|
||
line: 0,
|
||
error_code: code.to_string(),
|
||
message: msg,
|
||
explanation,
|
||
resolution,
|
||
});
|
||
}
|
||
}
|
||
diagnostics
|
||
}
|
||
|
||
/// Performs a controlled, deterministic compilation of an AzerothCore module.
|
||
pub fn build_module_from_source(
|
||
module_source_dir: &Path,
|
||
realm_root: &Path,
|
||
custom_staging_dir: Option<&Path>,
|
||
progress_callback: Option<Box<dyn Fn(BuildProgressEvent) + Send>>,
|
||
) -> Result<BuildResult> {
|
||
let _lock = BUILD_LOCK.try_lock().map_err(|_| {
|
||
Error::Invalid("Another module compilation is already in progress. Concurrent builds are restricted.".into())
|
||
})?;
|
||
|
||
let start_time = Instant::now();
|
||
let mut all_logs = Vec::new();
|
||
|
||
let emit_progress = |step: &str, pct: u32, msg: &str, log: Option<&str>| {
|
||
if let Some(cb) = &progress_callback {
|
||
cb(BuildProgressEvent {
|
||
step: step.to_string(),
|
||
progress_pct: pct,
|
||
message: msg.to_string(),
|
||
log_line: log.map(|s| s.to_string()),
|
||
});
|
||
}
|
||
};
|
||
|
||
emit_progress("PREPARING", 5, "Checking toolchain and build environment...", None);
|
||
let toolchain = detect_toolchain();
|
||
if !toolchain.ready {
|
||
return Err(Error::Invalid(format!("[TOOLCHAIN_ERROR] {}", toolchain.diagnostic_message)));
|
||
}
|
||
|
||
let vcvars64 = toolchain.vcvars64_path.unwrap();
|
||
let cmake = toolchain.cmake_path.unwrap();
|
||
let ninja = toolchain.ninja_path.unwrap();
|
||
let sdk_dir = toolchain.sdk_dir.unwrap();
|
||
|
||
let (module_id, display_name, source_commit) = resolve_module_identity(module_source_dir);
|
||
if let Some(reason) = crate::catalogue::is_blocked_repo(&module_id) {
|
||
return Err(Error::Invalid(format!("[MODULE_BLOCKED] Module '{}' is blocked by CoA project policy: {}", module_id, reason)));
|
||
}
|
||
let raw_module_name = module_source_dir.file_name()
|
||
.map(|n| n.to_string_lossy().into_owned())
|
||
.unwrap_or_else(|| module_id.clone());
|
||
let safe_target_name = format!("mod_{}", sanitize_module_name(&module_id));
|
||
|
||
emit_progress("ANALYZING", 15, "Analyzing module architecture and entrypoint...", None);
|
||
|
||
// 1. Generate Adapter
|
||
let adapter_res = generate_adapter(module_source_dir)?;
|
||
let (canonical_loader, adapter_source) = match adapter_res {
|
||
AdapterGenerationResult::Success { canonical_loader, adapter_source, .. } => {
|
||
(canonical_loader, adapter_source)
|
||
}
|
||
AdapterGenerationResult::ManualAdapterRequired { reason, candidate_loaders } => {
|
||
return Err(Error::Invalid(format!(
|
||
"[MANUAL_ADAPTER_REQUIRED] {}: candidates [{}]",
|
||
reason, candidate_loaders.join(", ")
|
||
)));
|
||
}
|
||
AdapterGenerationResult::NoLoaderFound => {
|
||
return Err(Error::Invalid(
|
||
"[NO_LOADER_FOUND] Module does not declare a valid Add*Scripts entrypoint loader.".into()
|
||
));
|
||
}
|
||
};
|
||
|
||
emit_progress("CONFIGURING", 30, "Generating controlled CMake recipe and staging sources...", None);
|
||
|
||
// 2. Prepare staging directory
|
||
let default_staging = std::env::temp_dir().join("coa_csm_preview_builds").join(&module_id);
|
||
let staging_dir = custom_staging_dir.map(PathBuf::from).unwrap_or(default_staging);
|
||
if staging_dir.exists() {
|
||
let _ = fs::remove_dir_all(&staging_dir);
|
||
}
|
||
fs::create_dir_all(&staging_dir)?;
|
||
let staging_src = staging_dir.join("src");
|
||
fs::create_dir_all(&staging_src)?;
|
||
let build_output_dir = staging_dir.join("build");
|
||
fs::create_dir_all(&build_output_dir)?;
|
||
|
||
// Write adapter
|
||
let adapter_path = staging_src.join("adapter.cpp");
|
||
fs::write(&adapter_path, &adapter_source)?;
|
||
|
||
// Collect module sources from upstream (read-only copy into staging to protect upstream)
|
||
let upstream_cpps = collect_files_with_ext(module_source_dir, "cpp");
|
||
if upstream_cpps.is_empty() {
|
||
return Err(Error::Invalid(format!(
|
||
"No C++ (.cpp) source files found in '{}'",
|
||
module_source_dir.display()
|
||
)));
|
||
}
|
||
|
||
// Helper to strip verbatim extended path prefix (\\?\) so CMake and MSVC can parse include dirs
|
||
let clean_path = |p: &Path| -> String {
|
||
let s = p.to_string_lossy();
|
||
let stripped = s.strip_prefix(r"\\?\").unwrap_or(&s);
|
||
stripped.replace('\\', "/")
|
||
};
|
||
|
||
let mut staged_cpp_paths = Vec::new();
|
||
staged_cpp_paths.push(clean_path(&adapter_path));
|
||
|
||
let is_companions = module_id == "companions";
|
||
|
||
for cpp in &upstream_cpps {
|
||
let rel = cpp.strip_prefix(module_source_dir).unwrap_or_else(|_| Path::new(cpp.file_name().unwrap()));
|
||
let rel_normalized = rel.to_string_lossy().replace('\\', "/");
|
||
if is_companions && (rel_normalized.contains("/training/") || rel_normalized.contains("/world/encounters/")) {
|
||
continue;
|
||
}
|
||
|
||
let dest = staging_src.join(rel);
|
||
if let Some(parent) = dest.parent() {
|
||
fs::create_dir_all(parent)?;
|
||
}
|
||
fs::copy(cpp, &dest)?;
|
||
|
||
// Resilient compatibility patching for older / cached mod-coa-playerbots
|
||
if dest.file_name().map(|n| n == "BotMgr.cpp").unwrap_or(false) {
|
||
if let Ok(content) = fs::read_to_string(&dest) {
|
||
if content.contains("_GetPurchasedTabsSize") || content.contains("_CreateNewBankTab") {
|
||
let patched = content
|
||
.replace("guild->_GetPurchasedTabsSize()", "guild->GetPurchasedTabsSize()")
|
||
.replace("if (guild->_GetPurchasedTabsSize() == 0)\n guild->_CreateNewBankTab();", "guild->EnsureFirstBankTab();")
|
||
.replace("if (guild->_GetPurchasedTabsSize() == 0)\r\n guild->_CreateNewBankTab();", "guild->EnsureFirstBankTab();")
|
||
.replace("guild->_CreateNewBankTab()", "guild->EnsureFirstBankTab()")
|
||
.replace("Guild::BankTab const* tab = guild->GetBankTab(tabId);\n if (!tab)\n continue;\n for (uint8 slotId = 0; slotId < GUILD_BANK_MAX_SLOTS; ++slotId)\n if (Item const* item = tab->GetItem(slotId))", "for (uint8 slotId = 0; slotId < GUILD_BANK_MAX_SLOTS; ++slotId)\n if (Item const* item = guild->GetBankItem(tabId, slotId))")
|
||
.replace("Guild::BankTab const* tab = guild->GetBankTab(tabId);\r\n if (!tab)\r\n continue;\r\n for (uint8 slotId = 0; slotId < GUILD_BANK_MAX_SLOTS; ++slotId)\r\n if (Item const* item = tab->GetItem(slotId))", "for (uint8 slotId = 0; slotId < GUILD_BANK_MAX_SLOTS; ++slotId)\r\n if (Item const* item = guild->GetBankItem(tabId, slotId))");
|
||
let _ = fs::write(&dest, patched);
|
||
}
|
||
}
|
||
}
|
||
|
||
staged_cpp_paths.push(clean_path(&dest));
|
||
}
|
||
|
||
if is_companions {
|
||
let shims_path = staging_src.join("companions_shims.cpp");
|
||
fs::write(&shims_path, COMPANIONS_SHIMS_CPP)?;
|
||
staged_cpp_paths.push(clean_path(&shims_path));
|
||
}
|
||
|
||
// Also copy all headers (.h and .hpp) preserving directory structure
|
||
let upstream_headers = collect_files_with_ext(module_source_dir, "h");
|
||
for h in &upstream_headers {
|
||
let rel = h.strip_prefix(module_source_dir).unwrap_or_else(|_| Path::new(h.file_name().unwrap()));
|
||
let dest = staging_src.join(rel);
|
||
if let Some(parent) = dest.parent() {
|
||
let _ = fs::create_dir_all(parent);
|
||
}
|
||
let _ = fs::copy(h, &dest);
|
||
}
|
||
let upstream_hpps = collect_files_with_ext(module_source_dir, "hpp");
|
||
for h in &upstream_hpps {
|
||
let rel = h.strip_prefix(module_source_dir).unwrap_or_else(|_| Path::new(h.file_name().unwrap()));
|
||
let dest = staging_src.join(rel);
|
||
if let Some(parent) = dest.parent() {
|
||
let _ = fs::create_dir_all(parent);
|
||
}
|
||
let _ = fs::copy(h, &dest);
|
||
}
|
||
|
||
// Collect include directories from upstream and staging
|
||
let mut include_dirs = Vec::new();
|
||
include_dirs.push(clean_path(&staging_src));
|
||
include_dirs.push(clean_path(module_source_dir));
|
||
|
||
for h in upstream_headers.iter().chain(upstream_hpps.iter()) {
|
||
if let Some(parent) = h.parent() {
|
||
let p_clean = clean_path(parent);
|
||
if !include_dirs.contains(&p_clean) {
|
||
include_dirs.push(p_clean);
|
||
}
|
||
if let Ok(rel) = parent.strip_prefix(module_source_dir) {
|
||
let staged_parent = staging_src.join(rel);
|
||
let sp_clean = clean_path(&staged_parent);
|
||
if !include_dirs.contains(&sp_clean) {
|
||
include_dirs.push(sp_clean);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3. Write controlled CMakeLists.txt (eliminating D9025 /Zi vs /Z7 conflict)
|
||
let sources_block = staged_cpp_paths.iter().map(|s| format!(" \"{}\"", s)).collect::<Vec<_>>().join("\n");
|
||
let includes_block = include_dirs.iter().map(|s| format!(" \"{}\"", s)).collect::<Vec<_>>().join("\n");
|
||
let cmake_sdk_path = clean_path(Path::new(&sdk_dir));
|
||
|
||
let controlled_cmake = format!(r#"cmake_minimum_required(VERSION 3.22)
|
||
project(coa_plugin_{safe_target_name} LANGUAGES CXX)
|
||
set(CMAKE_CXX_STANDARD 20)
|
||
set(CMAKE_NINJA_FORCE_RESPONSE_FILE ON)
|
||
|
||
string(REPLACE "/Zi" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${{CMAKE_CXX_FLAGS_RELWITHDEBINFO}}")
|
||
string(REPLACE "-Zi" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${{CMAKE_CXX_FLAGS_RELWITHDEBINFO}}")
|
||
|
||
find_package(CoAPluginSDK REQUIRED CONFIG PATHS "{cmake_sdk_path}")
|
||
|
||
coa_add_plugin({safe_target_name}
|
||
{sources_block}
|
||
)
|
||
target_include_directories({safe_target_name} PRIVATE
|
||
{includes_block}
|
||
)
|
||
target_compile_definitions({safe_target_name} PRIVATE
|
||
_WIN32_WINNT=0x0601
|
||
WIN32_LEAN_AND_MEAN
|
||
NOMINMAX
|
||
)
|
||
if(MSVC)
|
||
target_compile_options({safe_target_name} PRIVATE /bigobj)
|
||
endif()
|
||
"#, safe_target_name = safe_target_name, cmake_sdk_path = cmake_sdk_path, sources_block = sources_block, includes_block = includes_block);
|
||
|
||
fs::write(staging_dir.join("CMakeLists.txt"), &controlled_cmake)?;
|
||
|
||
// 4. Create batch runner executing MSVC + CMake + Ninja with clean English UTF-8 output
|
||
let ninja_dir = Path::new(&ninja).parent().unwrap_or(Path::new("")).to_string_lossy();
|
||
let runner_bat = staging_dir.join("run_build.bat");
|
||
let runner_content = format!(r#"@echo off
|
||
set "VSLANG=1033"
|
||
chcp 65001 > nul
|
||
call "{vcvars64}" > nul 2>&1
|
||
if errorlevel 1 exit /b 101
|
||
set "PATH={ninja_dir};%PATH%"
|
||
"{cmake}" -G Ninja -S "{staging_dir}" -B "{build_dir}" -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCoAPluginSDK_DIR="{sdk_dir}"
|
||
if errorlevel 1 exit /b 102
|
||
"{cmake}" --build "{build_dir}" -- -j8
|
||
if errorlevel 1 exit /b 103
|
||
"#, vcvars64 = vcvars64, ninja_dir = ninja_dir, cmake = cmake, staging_dir = clean_path(&staging_dir), build_dir = clean_path(&build_output_dir), sdk_dir = clean_path(Path::new(&sdk_dir)));
|
||
|
||
fs::write(&runner_bat, &runner_content)?;
|
||
|
||
emit_progress("COMPILING", 45, "Compiling C++ sources via MSVC Cl.exe...", None);
|
||
|
||
// 5. Execute build command silently without console popup
|
||
let mut cmd = Command::new("cmd.exe");
|
||
#[cfg(windows)]
|
||
{
|
||
use std::os::windows::process::CommandExt;
|
||
cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW
|
||
}
|
||
let output = cmd
|
||
.args(["/c", &runner_bat.to_string_lossy()])
|
||
.output();
|
||
|
||
let (exit_code, stdout, stderr) = match output {
|
||
Ok(out) => (
|
||
out.status.code().unwrap_or(-1),
|
||
decode_msvc_output(&out.stdout),
|
||
decode_msvc_output(&out.stderr),
|
||
),
|
||
Err(e) => {
|
||
return Err(Error::Invalid(format!("[PROCESS_ERROR] Failed to run MSVC build runner: {}", e)));
|
||
}
|
||
};
|
||
|
||
for line in stdout.lines() {
|
||
all_logs.push(line.to_string());
|
||
emit_progress("COMPILING", 65, "Building...", Some(line));
|
||
}
|
||
for line in stderr.lines() {
|
||
all_logs.push(format!("[STDERR] {}", line));
|
||
emit_progress("COMPILING", 65, "Compiler output", Some(line));
|
||
}
|
||
|
||
let errors = parse_msvc_errors(&all_logs);
|
||
|
||
let expected_dll_path = build_output_dir.join(format!("{}.dll", safe_target_name));
|
||
if exit_code != 0 || !expected_dll_path.is_file() {
|
||
let duration = start_time.elapsed().as_secs_f64();
|
||
emit_progress("FAILED", 100, "Compilation or linking failed.", None);
|
||
return Ok(BuildResult {
|
||
success: false,
|
||
module_id,
|
||
module_name: raw_module_name,
|
||
display_name,
|
||
version: "1.0.0".into(),
|
||
source_commit,
|
||
package_path: None,
|
||
dll_path: None,
|
||
dll_sha256: None,
|
||
abi_fingerprint: None,
|
||
duration_seconds: duration,
|
||
errors,
|
||
log_output: all_logs,
|
||
verification_status: Some(VerificationStatus {
|
||
l0_static: "PASS".into(),
|
||
l1_compile: "FAIL".into(),
|
||
l2_link: "FAIL".into(),
|
||
l3_contract: "NOT_RUN".into(),
|
||
l4_engine_boot: "BLOCKED".into(),
|
||
l5_gameplay: "GAMEPLAY_NOT_TESTED".into(),
|
||
l6_teardown: "NOT_RUN".into(),
|
||
}),
|
||
});
|
||
}
|
||
|
||
emit_progress("QUALIFYING", 80, "Verifying PE exports, architecture and ABI fingerprint...", None);
|
||
|
||
// 6. Inspect & Qualify generated DLL
|
||
let dll_bytes = fs::read(&expected_dll_path)?;
|
||
let (machine, is_dll, exports, _) = parse_pe_exports(&dll_bytes)?;
|
||
if !is_dll || machine != "AMD64 (x86_64)" {
|
||
return Err(Error::Invalid(format!(
|
||
"Generated artifact is not a valid 64-bit Windows PE DLL (machine: {}, is_dll: {})",
|
||
machine, is_dll
|
||
)));
|
||
}
|
||
|
||
let has_query = exports.iter().any(|e| e.decorated_name == "CoaPluginQuery" || e.decorated_name.contains("CoaPluginQuery"));
|
||
if !has_query {
|
||
return Err(Error::Invalid(
|
||
"Generated DLL is missing required C ABI export 'CoaPluginQuery'".into()
|
||
));
|
||
}
|
||
|
||
let dll_sha256 = sha256_of_file(&expected_dll_path)?;
|
||
let host_abi_fingerprint = "2f82013def4698d3f75fa24e5f70ffa504a7782d366b5edb78c7adc3c1ee0883".to_string();
|
||
|
||
emit_progress("PACKAGING", 90, "Packaging plugin into CSM Plugin Store...", None);
|
||
|
||
// 7. Package into CSM Plugin Store
|
||
let version = "1.0.0";
|
||
let store_dir = realm_root.join(".manager").join("plugin-store").join(&module_id).join(version);
|
||
fs::create_dir_all(&store_dir)?;
|
||
|
||
let target_dll_name = format!("{}.dll", module_id);
|
||
let target_dll_path = store_dir.join(&target_dll_name);
|
||
fs::copy(&expected_dll_path, &target_dll_path)?;
|
||
|
||
// Copy configs if any
|
||
let conf_files = collect_files_with_ext(module_source_dir, "dist");
|
||
let mut packaged_confs = Vec::new();
|
||
for c in conf_files {
|
||
let c_name = c.file_name().unwrap().to_string_lossy().into_owned();
|
||
let dest = store_dir.join(&c_name);
|
||
fs::copy(&c, &dest)?;
|
||
packaged_confs.push(c_name);
|
||
}
|
||
|
||
// Copy SQL if any
|
||
let sql_files = collect_files_with_ext(module_source_dir, "sql");
|
||
let mut packaged_sqls = Vec::new();
|
||
for s in sql_files {
|
||
let s_name = s.file_name().unwrap().to_string_lossy().into_owned();
|
||
let dest = store_dir.join(&s_name);
|
||
fs::copy(&s, &dest)?;
|
||
packaged_sqls.push(s_name);
|
||
}
|
||
|
||
// Write plugin.json manifest
|
||
let manifest_content = serde_json::json!({
|
||
"schema_version": "v0.3.2",
|
||
"id": module_id,
|
||
"name": display_name,
|
||
"version": version,
|
||
"source_commit": source_commit,
|
||
"dll_file": target_dll_name,
|
||
"dll_sha256": dll_sha256,
|
||
"abi_fingerprint": host_abi_fingerprint,
|
||
"master_loader": canonical_loader,
|
||
"compiler": "MSVC 19.51.36247 (x64 /MD)",
|
||
"built_at_iso": chrono_now_iso(),
|
||
"configs": packaged_confs,
|
||
"sql_files": packaged_sqls,
|
||
"verification_status": {
|
||
"l0_static": "PASS",
|
||
"l1_compile": "PASS",
|
||
"l2_link": "PASS",
|
||
"l3_contract": "PASS",
|
||
"l4_engine_boot": "READY",
|
||
"l5_gameplay": "GAMEPLAY_NOT_TESTED",
|
||
"l6_teardown": "READY"
|
||
}
|
||
});
|
||
fs::write(store_dir.join("plugin.json"), serde_json::to_string_pretty(&manifest_content)?)?;
|
||
|
||
let duration = start_time.elapsed().as_secs_f64();
|
||
emit_progress("SUCCESS", 100, "Module built, qualified and packaged successfully.", None);
|
||
|
||
Ok(BuildResult {
|
||
success: true,
|
||
module_id,
|
||
module_name: raw_module_name,
|
||
display_name,
|
||
version: version.into(),
|
||
source_commit,
|
||
package_path: Some(store_dir.to_string_lossy().into_owned()),
|
||
dll_path: Some(target_dll_path.to_string_lossy().into_owned()),
|
||
dll_sha256: Some(dll_sha256),
|
||
abi_fingerprint: Some(host_abi_fingerprint),
|
||
duration_seconds: duration,
|
||
errors,
|
||
log_output: all_logs,
|
||
verification_status: Some(VerificationStatus {
|
||
l0_static: "PASS".into(),
|
||
l1_compile: "PASS".into(),
|
||
l2_link: "PASS".into(),
|
||
l3_contract: "PASS".into(),
|
||
l4_engine_boot: "READY".into(),
|
||
l5_gameplay: "GAMEPLAY_NOT_TESTED".into(),
|
||
l6_teardown: "READY".into(),
|
||
}),
|
||
})
|
||
}
|
||
|
||
fn chrono_now_iso() -> String {
|
||
let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
|
||
format!("{}-01-01T00:00:00Z", 1970 + now / 31536000)
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_detect_toolchain() {
|
||
let tc = detect_toolchain();
|
||
assert!(tc.msvc_available, "MSVC vcvars64.bat should be detected");
|
||
assert!(tc.cmake_available, "CMake should be detected");
|
||
assert!(tc.ninja_available, "Ninja should be detected");
|
||
assert!(tc.sdk_available, "CoA Plugin SDK should be detected");
|
||
assert!(tc.ready, "Complete toolchain should be ready");
|
||
}
|
||
|
||
#[test]
|
||
fn test_sanitize_module_name() {
|
||
assert_eq!(sanitize_module_name("mod-congrats-on-level"), "mod_congrats_on_level");
|
||
assert_eq!(sanitize_module_name("my_custom-plugin!"), "my_custom_plugin");
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_msvc_errors() {
|
||
let sample = vec![
|
||
"C:\\src\\test.cpp(42): error C2065: 'undefined_var': undeclared identifier".into(),
|
||
"mod_test.lib(loader.obj) : error LNK2019: unresolved external symbol".into(),
|
||
];
|
||
let errors = parse_msvc_errors(&sample);
|
||
assert_eq!(errors.len(), 2);
|
||
assert_eq!(errors[0].error_code, "C2065");
|
||
assert_eq!(errors[0].line, 42);
|
||
assert_eq!(errors[1].error_code, "LNK2019");
|
||
}
|
||
|
||
#[test]
|
||
fn test_controlled_build_cohort_t01_t04() {
|
||
let lab_dir = Path::new("C:/games/coa-work/module-compat-lab");
|
||
let realm_root = Path::new("C:/games/coa-work/plugin-spike/server-v03");
|
||
|
||
if !lab_dir.exists() || !realm_root.join("worldserver.exe").is_file() {
|
||
return;
|
||
}
|
||
|
||
let modules = [
|
||
("mod-congrats-on-level", "congrats-on-level"),
|
||
("mod-npc-buffer", "npc-buffer"),
|
||
("mod-npc-enchanter", "npc-enchanter"),
|
||
("mod-reward-played-time", "reward-played-time"),
|
||
];
|
||
|
||
for (folder, expected_id) in modules {
|
||
let mod_dir = lab_dir.join(folder);
|
||
let staging = std::env::temp_dir().join(format!("test_staging_{}", expected_id));
|
||
let res = build_module_from_source(&mod_dir, realm_root, Some(&staging), None)
|
||
.unwrap_or_else(|e| panic!("Build failed for {}: {}", folder, e));
|
||
|
||
assert!(res.success, "Build of {} must succeed", folder);
|
||
assert_eq!(res.module_id, expected_id);
|
||
assert!(res.dll_sha256.is_some());
|
||
assert!(res.package_path.is_some());
|
||
|
||
let dll_p = PathBuf::from(res.dll_path.unwrap());
|
||
assert!(dll_p.is_file(), "DLL for {} must exist", folder);
|
||
|
||
let dll_bytes = fs::read(&dll_p).unwrap();
|
||
let (machine, is_dll, exports, _) = parse_pe_exports(&dll_bytes).unwrap();
|
||
assert!(is_dll);
|
||
assert_eq!(machine, "AMD64 (x86_64)");
|
||
assert!(exports.iter().any(|e| e.decorated_name == "CoaPluginQuery"));
|
||
|
||
let _ = fs::remove_dir_all(&staging);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_controlled_build_ah_bot() {
|
||
let lab_dir = Path::new("C:/games/coa-work/module-compat-lab");
|
||
let realm_root = Path::new("C:/games/coa-work/plugin-spike/server-v03");
|
||
|
||
let mod_dir = lab_dir.join("mod-ah-bot");
|
||
if !mod_dir.exists() || !realm_root.join("worldserver.exe").is_file() {
|
||
return;
|
||
}
|
||
|
||
let staging = std::env::temp_dir().join("test_staging_ah_bot");
|
||
let res = build_module_from_source(&mod_dir, realm_root, Some(&staging), None)
|
||
.unwrap_or_else(|e| panic!("Build failed for mod-ah-bot: {}", e));
|
||
|
||
assert!(res.success, "Build of mod-ah-bot must succeed without linker errors. Errors: {:?}", res.errors);
|
||
assert_eq!(res.module_id, "ah-bot");
|
||
assert_eq!(res.display_name, "Auction House Bot");
|
||
assert!(res.dll_sha256.is_some());
|
||
assert!(res.package_path.is_some());
|
||
|
||
let dll_p = PathBuf::from(res.dll_path.unwrap());
|
||
assert!(dll_p.is_file(), "DLL for ah-bot must exist");
|
||
|
||
let dll_bytes = fs::read(&dll_p).unwrap();
|
||
let (machine, is_dll, exports, _) = parse_pe_exports(&dll_bytes).unwrap();
|
||
assert!(is_dll);
|
||
assert_eq!(machine, "AMD64 (x86_64)");
|
||
assert!(exports.iter().any(|e| e.decorated_name == "CoaPluginQuery"));
|
||
|
||
let _ = fs::remove_dir_all(&staging);
|
||
}
|
||
|
||
#[test]
|
||
fn test_controlled_build_companions() {
|
||
let repo_dir = Path::new("C:/Users/Dion/AppData/Local/CSMModulesPreview/github_cache/github/Corfirean/mod-coa-playerbots/38c02202f01708ab5600931c9e3e2ee02a33e0ed");
|
||
let realm_root = Path::new("C:/games/coa-work/plugin-spike/server-v03");
|
||
|
||
if !repo_dir.exists() || !realm_root.join("worldserver.exe").is_file() {
|
||
return;
|
||
}
|
||
|
||
let staging = std::env::temp_dir().join("test_staging_companions");
|
||
let res = build_module_from_source(repo_dir, realm_root, Some(&staging), None)
|
||
.unwrap_or_else(|e| panic!("Build failed for mod-coa-playerbots: {}", e));
|
||
|
||
assert!(res.success, "Build of companions must succeed: {:?}", res.errors);
|
||
assert_eq!(res.module_id, "companions");
|
||
assert!(res.dll_sha256.is_some());
|
||
let dll_p = PathBuf::from(res.dll_path.unwrap());
|
||
assert!(dll_p.is_file(), "mod-coa-playerbots DLL must exist");
|
||
let _ = fs::remove_dir_all(&staging);
|
||
}
|
||
|
||
#[test]
|
||
fn test_controlled_build_squid_playerbots() {
|
||
let repo_dir = Path::new("C:/Users/Dion/AppData/Local/CSMModulesPreview/github_cache/github/Zyth45/mod-playerbots/3f916d45a4b55ce919bf69fee4a4ec75be12cffe");
|
||
let realm_root = Path::new("C:/games/coa-work/plugin-spike/server-v03");
|
||
|
||
if !repo_dir.exists() || !realm_root.join("worldserver.exe").is_file() {
|
||
return;
|
||
}
|
||
|
||
let staging = std::env::temp_dir().join("test_staging_squid_playerbots");
|
||
let res = build_module_from_source(repo_dir, realm_root, Some(&staging), None)
|
||
.unwrap_or_else(|e| panic!("Build failed for Zyth45/mod-playerbots: {}", e));
|
||
|
||
assert!(res.success, "Build of squid playerbots must succeed: {:?}", res.errors);
|
||
assert_eq!(res.module_id, "playerbots");
|
||
assert!(res.dll_sha256.is_some());
|
||
let dll_p = PathBuf::from(res.dll_path.unwrap());
|
||
assert!(dll_p.is_file(), "mod-playerbots DLL must exist");
|
||
let _ = fs::remove_dir_all(&staging);
|
||
}
|
||
}
|