"""Execute production final CPC cleanup before actual Main teardown sequence.""" from pathlib import Path import subprocess, tempfile root = Path(__file__).resolve().parents[2] world = (root/'src/server/game/World/World.cpp').read_text() mgr = (root/'src/server/game/World/ClientlessPlayerMgr.cpp').read_text() main = (root/'src/server/worldserver/Main.cpp').read_text() def function(source, signature): a=source.index(signature);i=source.index('{',a)+1;depth=1 while depth: depth+=(source[i]=='{')-(source[i]=='}');i+=1 return source[a:i] a=main.index('std::shared_ptr mapManagementHandle(') a=main.index('{',a)+1;b=main.index('\n });',a) teardown=main[a:b] processor=(root/'src/common/Utilities/AsyncCallbackProcessor.h').read_text() processor='\n'.join(l for l in processor.splitlines() if not l.startswith('#include')) code=r''' #include #include #include #include #include #include #include #include using uint32=unsigned; #define TC_LOG_INFO(...) ((void)0) #define TC_LOG_ERROR(...) ((void)0) '''+processor+r''' bool mapsAlive=true;unsigned players=0,pets=0,passengers=0,deleted=0,acks=0,notifications=0,delivered=0; struct Player{unsigned guid;bool pet=false,transport=false,pending=false;Player(unsigned g):guid(g){++players;}~Player(){assert(mapsAlive);--players;}}; struct Callback{std::futurefuture;std::functiondone;bool InvokeIfReady(){if(future.wait_for(std::chrono::seconds(0))!=std::future_status::ready)return false;done();return true;}}; struct Session{Player*p=nullptr;bool clientless=true;AsyncCallbackProcessorcallbacks; Player*GetPlayer(){return p;}bool IsClientless(){return clientless;}unsigned GetGUIDLow(){return p?p->guid:0;}unsigned GetAccountId(){return 8;} void CompleteClientlessTeleport(){if(p&&p->pending){assert(mapsAlive);p->pending=false;++acks;}} ~Session(){if(p){assert(mapsAlive);if(p->pet)--pets;if(p->transport)--passengers;delete p;}++deleted;} }; using WorldSession=Session; enum class ClientlessPlayerState{Loading,Online,Removing}; struct World{using SessionMap=std::map; bool m_clientlessSessionsFinalized=false;SessionMap m_clientlessSessions,m_sessions; std::mapm_clientlessPlayerStates; unsigned GetClientlessSessionCount(){return m_clientlessSessions.size();} Session*FindClientlessSession(unsigned g){auto i=m_clientlessSessions.find(g);return i==m_clientlessSessions.end()?nullptr:i->second;} bool AddClientlessSession(unsigned,Session*);void ShutdownClientlessSessions(); }world;auto sWorld=&world; struct Controller{void OnPlayerLogout(Player*p){assert(mapsAlive&&p);assert(!p->pending);++notifications; Session late;assert(!world.AddClientlessSession(999,&late)); // no reentrant login during teardown }}controller; struct Executor{unsigned clears=0;void Clear(unsigned){++clears;}}executor;auto sClientlessActionExecutorMgr=&executor; struct Flight{unsigned clears=0;void Clear(unsigned){++clears;}}flight;auto sClientlessFlightMgr=&flight; struct ClientlessPlayerMgr{ bool _shutdownDraining=false,_shutdownSnapshotDone=false;unsigned snapshots=0; struct Record{struct Controller*Controller=nullptr;bool LogoutNotified=false;}; std::map_records;std::map_safeLogouts; void BeginShutdown(){_shutdownDraining=true;}void WriteShutdownSnapshot(char const*event){assert(std::string(event)=="finalize");++snapshots;} void FinalizeShutdown(); }manager;auto sClientlessPlayerMgr=&manager; struct Factory{static void Shutdown(){assert(world.m_clientlessSessions.empty());}};using ClientlessCharacterFactory=Factory; struct BG{void DeleteAllBattlegrounds(){assert(players==0&&pets==0&&passengers==0);}}bg;auto sBattlegroundMgr=&bg; struct Saves{void Unload(){assert(players==0);}}saves;auto sInstanceSaveMgr=&saves; struct Outdoor{void Die(){assert(players==0);}}outdoor;auto sOutdoorPvPMgr=&outdoor; struct Maps{void UnloadAll(){assert(players==0&&pets==0&&passengers==0);mapsAlive=false;}}maps;auto sMapMgr=&maps; struct Terrain{void UnloadAll(){assert(!mapsAlive);}}sTerrainMgr; '''+function(world,'bool World::AddClientlessSession(')+function(world,'void World::ShutdownClientlessSessions(')+function(mgr,'void ClientlessPlayerMgr::FinalizeShutdown(')+r''' void teardown(){ '''+teardown+r''' } int main(){ // Pet owner, transport passenger and a pending native teleport survive grace. for(unsigned i=1;i<=3;++i){auto s=new Session;s->p=new Player(i);assert(world.AddClientlessSession(i,s));manager._records[i]={&controller,false};manager._safeLogouts[i]=true;} world.FindClientlessSession(1)->p->pet=true;++pets; world.FindClientlessSession(2)->p->transport=true;++passengers; world.FindClientlessSession(3)->p->pending=true; // Already notified Removing sessions must not notify a second time. manager._records[2].LogoutNotified=true; // Both ready and still-running login callbacks are discarded, not delivered. std::promiseready,slow;ready.set_value(); auto loading=new Session;loading->callbacks.AddCallback({ready.get_future(),[]{++delivered;}}); loading->callbacks.AddCallback({slow.get_future(),[]{++delivered;}}); assert(world.AddClientlessSession(4,loading));manager._records[4]={&controller,false}; // Low-level clientless sessions without a managed controller also log out. auto unmanaged=new Session;unmanaged->p=new Player(5);assert(world.AddClientlessSession(5,unmanaged)); world.m_clientlessSessions[6]=nullptr;world.m_clientlessPlayerStates[6]=ClientlessPlayerState::Loading; Session network;network.clientless=false;world.m_sessions[8]=&network; teardown();slow.set_value(); assert(!mapsAlive&&players==0&&pets==0&&passengers==0&&acks==1&¬ifications==2&&delivered==0); assert(world.m_clientlessSessions.empty()&&world.m_clientlessPlayerStates.empty()); assert(manager._records.empty()&&manager._safeLogouts.empty()&&manager._shutdownDraining&&manager.snapshots==1); assert(world.m_sessions.size()==1&&executor.clears==4&&flight.clears==4); auto before=deleted;world.ShutdownClientlessSessions();assert(deleted==before&&manager.snapshots==1); Session late;assert(!world.AddClientlessSession(6,&late)); // A normal shutdown that already wrote the deadline audit retains that audit. manager.FinalizeShutdown();assert(manager.snapshots==1); } ''' # The native session destructor owns LogoutPlayer; no custom pet/passenger deletion. session=(root/'src/server/game/Server/WorldSession.cpp').read_text() assert 'LogoutPlayer(true)' in function(session,'WorldSession::~WorldSession(') with tempfile.TemporaryDirectory(prefix='vcore-final-shutdown-') as directory: p=Path(directory);(p/'test.cpp').write_text(code) subprocess.run(['c++','-std=c++17',str(p/'test.cpp'),'-o',str(p/'test')],check=True) subprocess.run([str(p/'test')],check=True) print('Final shutdown: real World/manager/Main sequence; pet/transport/teleport cleanup before maps, pending callbacks cancelled, no new sessions, exactly-once notifications, audit and idempotence PASS')