#include "src/server/common/cube_store.h" #include "src/server/common/cube_fence.h" #include #include #include #include #include #include #include #include #ifdef PORT_CUBE_MYSQL #include "src/server/common/economy_mysql.h" #else #include #endif using namespace PortCube; using Rows=PortEconomy::Rows; static std::string address; static std::string executable; extern char** environ; static pid_t spawnWorker(const std::string& mode,const std::string& extra=""){ std::vector args={const_cast(executable.c_str()),const_cast(address.c_str()),const_cast(mode.c_str())}; if(!extra.empty())args.push_back(const_cast(extra.c_str()));args.push_back(nullptr); pid_t child=0;assert(posix_spawn(&child,executable.c_str(),nullptr,nullptr,args.data(),environ)==0);return child; } struct TestDB { uint64_t affected=0,inserted=0,warnings=0; bool active=false,engine=true,extra=true,ambiguous=false,rejectCommit=false; unsigned cubeTables=3; int statements=0,failAt=0,warnAt=0; std::function after; #ifdef PORT_CUBE_MYSQL MYSQL handle;PortEconomy::Mysql* db; TestDB(){mysql_init(&handle);assert(mysql_real_connect(&handle,"localhost","root","","cube_batch_test",0,address.c_str(),0));db=new PortEconomy::Mysql(&handle);} ~TestDB(){delete db;mysql_close(&handle);} bool Native(const std::string& sql,Rows& rows){bool ok=db->Query(sql,rows);affected=db->affected;inserted=db->inserted;warnings=db->warnings;return ok;} bool Begin(){if(active)return false;active=db->Begin();return active;} bool Commit(){if(rejectCommit){rejectCommit=false;return false;}bool ok=db->Commit();if(ok){active=false;if(after)after("COMMIT");}if(ambiguous&&ok){ambiguous=false;return false;}return ok;} void Rollback(){if(active){db->Rollback();active=false;}} #else sqlite3* db=nullptr; // Explicit SQLite-only substitutes for connection-scoped MySQL authority. // Real advisory-lock competition is exercised by the MySQL owner probe. uint64_t ownerConnection=1,ownerHolder=0; TestDB(){assert(sqlite3_open(address.c_str(),&db)==SQLITE_OK);sqlite3_busy_timeout(db,5000);} ~TestDB(){Rollback();sqlite3_close(db);} static void replace(std::string& text,const std::string& from,const std::string& to){size_t pos;while((pos=text.find(from))!=std::string::npos)text.replace(pos,from.size(),to);} bool Native(std::string sql,Rows& rows){ rows.clear();affected=inserted=warnings=0; if(sql=="SELECT CONNECTION_ID(),IS_USED_LOCK(CONCAT('m2_cube:',DATABASE()))"){rows={{std::to_string(ownerConnection),ownerHolder?std::to_string(ownerHolder):""}};return true;} if(sql=="SELECT GET_LOCK(CONCAT('m2_cube:',DATABASE()),0)"){const bool ok=!ownerHolder||ownerHolder==ownerConnection;if(ok)ownerHolder=ownerConnection;rows={{ok?"1":"0"}};return true;} if(sql=="SELECT RELEASE_LOCK(CONCAT('m2_cube:',DATABASE()))"){const bool ok=ownerHolder==ownerConnection;if(ok)ownerHolder=0;rows={{ok?"1":"0"}};return true;} if(sql.find("information_schema.tables")!=std::string::npos){ if(sql.find("('port_cube_release_version','port_cube_releases')")!=std::string::npos) { if(!Native("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN ('port_cube_release_version','port_cube_releases')",rows))return false; if(sql.find("ENGINE='InnoDB'")!=std::string::npos&&!engine&&rows[0][0]=="2")rows[0][0]="1"; return true; } if(sql.find("('port_cube_image_ack_version','port_cube_image_acks')")!=std::string::npos) { if(!Native("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN ('port_cube_image_ack_version','port_cube_image_acks')",rows))return false; if(sql.find("ENGINE='InnoDB'")!=std::string::npos&&!engine&&rows[0][0]=="2")rows[0][0]="1"; return true; } if(sql.find("('port_cube_owner_version','port_cube_owner_broker','port_cube_owner_leases')")!=std::string::npos) { if(!Native("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN ('port_cube_owner_version','port_cube_owner_broker','port_cube_owner_leases')",rows))return false; if(sql.find("ENGINE='InnoDB'")!=std::string::npos&&!engine&&rows[0][0]=="3")rows[0][0]="2"; return true; } if(sql.find("('port_cube_gold_version','port_cube_gold_intents','port_cube_gold_sources')")!=std::string::npos) { if(!Native("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name IN ('port_cube_gold_version','port_cube_gold_intents','port_cube_gold_sources')",rows))return false; if(sql.find("ENGINE='InnoDB'")!=std::string::npos&&!engine&&rows[0][0]=="3")rows[0][0]="2"; return true; } rows={{sql.find("TABLE_NAME IN ('port_cube_version','port_cube_fences','port_cube_item_fences')")!=std::string::npos?std::to_string(cubeTables):(engine?"11":"10")}};return true; } if(sql=="SHOW COLUMNS FROM item"){ Rows columns;if(!Native("PRAGMA table_info(item)",columns))return false; for(const auto& column:columns)rows.push_back({column[1],column[1]=="port_extra"?(extra?"varbinary(69)":"varbinary(10)"):column[2],"NO"});return true; } replace(sql," FOR UPDATE","");replace(sql,"ON DUPLICATE KEY UPDATE account=VALUES(account)","ON CONFLICT(account) DO NOTHING"); sqlite3_stmt* statement=nullptr; if(sqlite3_prepare_v2(db,sql.c_str(),-1,&statement,nullptr)!=SQLITE_OK){std::cerr< row;for(int i=0;i(sqlite3_column_blob(statement,i));row.emplace_back(p?std::string(p,sqlite3_column_bytes(statement,i)):std::string());}rows.push_back(row);} sqlite3_finalize(statement);if(rc!=SQLITE_DONE)return false;affected=uint64_t(sqlite3_changes(db));inserted=uint64_t(sqlite3_last_insert_rowid(db));return true; } bool Begin(){if(active)return false;Rows rows;active=Native("BEGIN IMMEDIATE",rows);return active;} bool Commit(){if(rejectCommit){rejectCommit=false;return false;}Rows rows;bool ok=Native("COMMIT",rows);if(ok){active=false;if(after)after("COMMIT");}if(ambiguous&&ok){ambiguous=false;return false;}return ok;} void Rollback(){if(active){Rows rows;Native("ROLLBACK",rows);active=false;}} #endif bool Query(const std::string& sql,Rows& rows){ ++statements;if(failAt==statements){rows.clear();return false;} bool ok=Native(sql,rows);if(warnAt==statements)warnings=1;if(ok&&after)after(sql);return ok; } }; using Store=BatchStore; static Proto proto(uint32_t vnum){return {vnum==333?3u:vnum==999?0u:1u,vnum!=19};} static void sql(TestDB& db,const std::string& query){Rows rows;if(!db.Query(query,rows)){std::cerr<=100")==2); assert(number(db,"SELECT socket0 FROM item WHERE id=100")==77);assert(value(db,"SELECT hex(port_extra) FROM item WHERE id=100").substr(0,2)=="09"); assert(value(db,"SELECT port_extra FROM item WHERE id=10")==std::string(reinterpret_cast(b.inventory[0].value.extra),69)); assert(value(db,"SELECT socket0 FROM item WHERE id=10")=="-123"&&value(db,"SELECT attrvalue0 FROM item WHERE id=10")=="-321"); sql(db,"DELETE FROM port_cube_fences");assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.successes==2);assert(store.Prepare(b,draw)==Store::Prepared&&draws==3); assert(number(db,"SELECT gold FROM player WHERE id=1")==700&&number(db,"SELECT COUNT(*) FROM item WHERE id>=100")==2); // All-fail is a successful paid batch, not a refund or leaked item object. b.recipe.percent=0;reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="ok"&&receipt.successes==0&&receipt.awards.empty()&&receipt.fee==300);assert(number(db,"SELECT count FROM item WHERE id=10")==4&&number(db,"SELECT gold FROM player")==700&&number(db,"SELECT COUNT(*) FROM item WHERE id>=100")==0); b=batch();reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);sql(db,"UPDATE item SET socket0=1 WHERE id=10");assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="inventory_changed"&&receipt.fee==0);unchanged(db,b); reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);sql(db,"UPDATE port_cube_fences SET epoch=4");assert(store.Execute(b.token,1,1,receipt)==Store::Blocked);unchanged(db,b);sql(db,"UPDATE port_cube_fences SET epoch=3"); sql(db,"INSERT INTO port_economy_pending VALUES(1,'other')");assert(store.Execute(b.token,1,1,receipt)==Store::Blocked);unchanged(db,b); // Full grid remains full after partial consumption: reject without charging. b.inventory[0].value.count=100;for(unsigned i=1;i<225;++i){Item item;item.cell=uint16_t(i);item.value.id=1000+i;item.value.vnum=30007;item.value.count=1;b.inventory.push_back(item);}reset(db,b);assert(store.Prepare(b,[]{return 1;})==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="capacity_full");unchanged(db,b); // Zero fee and full consumption free a grid cell for successful output. b=batch();b.attempts=1;b.rewards.resize(1);b.recipe.gold=0;b.inventory[0].value.count=2;reset(db,b);assert(store.Prepare(b,[]{return 1;})==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.fee==0&&receipt.awards[0].cell==0);assert(number(db,"SELECT COUNT(*) FROM item WHERE id=10")==0&&number(db,"SELECT gold FROM player")==1000); // Rollback of accepted RNG callback exceptions leaves no partial intent. b=batch();reset(db,b);try{store.Prepare(b,[]{throw std::runtime_error("rng");return 1u;});assert(false);}catch(const std::runtime_error&){}assert(!db.active);assert(number(db,"SELECT COUNT(*) FROM port_cube_requests")==0&&number(db,"SELECT COUNT(*) FROM port_economy_item_reservations")==0);unchanged(db,b); puts("PASS batch codec, fixed outcomes, paid failures, exact successful rewards, grid/copy/state/fence rejection"); } static void faults(TestDB& db){ const auto b=batch();Store store(db,proto);Store::Receipt receipt; reset(db,b);db.statements=0;assert(store.Prepare(b,draw)==Store::Prepared);const int prepareCount=db.statements; for(int fault=1;fault<=prepareCount;++fault){reset(db,b);db.statements=0;db.failAt=fault;auto result=store.Prepare(b,draw);db.failAt=0;assert(result==Store::Retry);unchanged(db,b);assert(number(db,"SELECT COUNT(*) FROM port_cube_requests")==0&&number(db,"SELECT COUNT(*) FROM port_economy_item_reservations")==0);assert(store.Prepare(b,draw)==Store::Prepared);} reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);db.statements=0;assert(store.Execute(b.token,1,1,receipt)==Store::Complete);const int count=db.statements; for(int fault=1;fault<=count;++fault){reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);db.statements=0;db.failAt=fault;auto result=store.Execute(b.token,1,1,receipt);db.failAt=0;assert(result==Store::Retry);unchanged(db,b);assert(value(db,"SELECT state FROM port_cube_requests")=="PREPARED");assert(store.Execute(b.token,1,1,receipt)==Store::Complete);assert(number(db,"SELECT gold FROM player")==700);} reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);db.ambiguous=true;assert(store.Execute(b.token,1,1,receipt)==Store::Retry);assert(store.Execute(b.token,1,1,receipt)==Store::Complete);assert(number(db,"SELECT gold FROM player")==700&&number(db,"SELECT count FROM item WHERE id=10")==4); reset(db,b);db.ambiguous=true;draws=0;assert(store.Prepare(b,draw)==Store::Retry&&draws==3);assert(store.Prepare(b,draw)==Store::Prepared&&draws==3); reset(db,b);db.rejectCommit=true;assert(store.Prepare(b,draw)==Store::Retry);assert(number(db,"SELECT COUNT(*) FROM port_cube_requests")==0&&number(db,"SELECT COUNT(*) FROM port_economy_item_reservations")==0);unchanged(db,b); assert(store.Prepare(b,draw)==Store::Prepared);db.rejectCommit=true;assert(store.Execute(b.token,1,1,receipt)==Store::Retry);unchanged(db,b);assert(store.Execute(b.token,1,1,receipt)==Store::Complete); // SQL warning after a tentative item write is an error, not silent loss. reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);db.statements=0;int update=0;db.after=[&](const std::string& q){if(q.find("UPDATE item SET count=")==0)update=db.statements;};assert(store.Execute(b.token,1,1,receipt)==Store::Complete);db.after={};assert(update); reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);db.statements=0;db.warnAt=update;assert(store.Execute(b.token,1,1,receipt)==Store::Retry);db.warnAt=0;unchanged(db,b); #ifdef PORT_CUBE_MYSQL auto overflow=b;overflow.rewards[0].sockets[0]=1000;reset(db,overflow);assert(store.Prepare(overflow,draw)==Store::Prepared); const auto mode=value(db,"SELECT @@session.sql_mode");sql(db,"SET SESSION sql_mode=''");sql(db,"ALTER TABLE item MODIFY socket0 TINYINT NOT NULL DEFAULT 0"); assert(store.Execute(overflow.token,1,1,receipt)==Store::Retry);unchanged(db,overflow); sql(db,"ALTER TABLE item MODIFY socket0 INT NOT NULL DEFAULT 0");sql(db,"SET SESSION sql_mode='"+mode+"'"); assert(store.Execute(overflow.token,1,1,receipt)==Store::Complete);assert(number(db,"SELECT socket0 FROM item WHERE id=100")==1000); #endif puts("PASS every SQL failure boundary, ambiguous prepare/commit recovery, warning rollback"); } static void bounds(TestDB& db){ auto b=batch();Store store(db,proto);Store::Receipt receipt; b.recipe.reward=200;b.recipe.rewardCount=2000;b.recipe.stackable=true;for(auto& r:b.rewards)r.vnum=200; reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.successes==2&&receipt.awards.size()==2);assert(number(db,"SELECT SUM(count) FROM item WHERE vnum=200")==4000); b=batch();b.recipe.gold=UINT32_MAX;b.gold=uint64_t(UINT32_MAX)*3+1000;reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.fee==uint64_t(UINT32_MAX)*3);assert(number(db,"SELECT gold FROM player")==1000); b=batch();b.inventory[0].value.count=4;auto second=b.inventory[0];second.cell=5;second.value.id=11;b.inventory.push_back(second); reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete);assert(number(db,"SELECT COUNT(*) FROM item WHERE id=10")==0&&number(db,"SELECT count FROM item WHERE id=11")==2); b=batch();b.inventory[0].usable=false;reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="materials_missing");unchanged(db,b); b=batch();b.gold=299;reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="gold_missing");unchanged(db,b); b=batch();reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);sql(db,"UPDATE player SET gold=777");assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="gold_changed");assert(number(db,"SELECT gold FROM player")==777&&number(db,"SELECT count FROM item WHERE id=10")==10); reset(db,b);auto another=b;another.token=std::string(32,'c');assert(store.Prepare(another,draw)==Store::Blocked&&draws==0);sql(db,"UPDATE port_cube_fences SET owner='wrong'");assert(store.Prepare(b,draw)==Store::Blocked&&draws==0);unchanged(db,b); reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);sql(db,"UPDATE port_cube_requests SET rolls=X'000000'");assert(store.Execute(b.token,1,1,receipt)==Store::Retry);unchanged(db,b); reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);sql(db,"UPDATE port_cube_requests SET body=X'00'");assert(store.Execute(b.token,1,1,receipt)==Store::Retry);unchanged(db,b); reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete);sql(db,"UPDATE port_cube_requests SET fee=301");assert(store.Execute(b.token,1,1,receipt)==Store::Retry);assert(number(db,"SELECT gold FROM player")==700);sql(db,"UPDATE port_cube_requests SET fee=300,awards=X'0000'");assert(store.Execute(b.token,1,1,receipt)==Store::Retry);assert(number(db,"SELECT gold FROM player")==700); #ifndef PORT_CUBE_MYSQL reset(db,b);db.engine=false;assert(!store.Ready()&&store.Prepare(b,draw)==Store::Retry);db.engine=true;db.extra=false;assert(!store.Ready()&&store.Prepare(b,draw)==Store::Retry);db.extra=true;unchanged(db,b); #endif // Physical height validation must reject overlap, not create phantom cells. b=batch();Item tall;tall.value.id=20;tall.value.vnum=333;tall.value.count=1;tall.cell=1;b.inventory.push_back(tall);tall.value.id=21;tall.cell=6;b.inventory.push_back(tall);reset(db,b);assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="inventory_invalid");unchanged(db,b); puts("PASS stack splitting, uint64 fees, multi-stack consumption, locked/missing inputs, corrupt journal and grid overlap"); } static void crash(TestDB& db){ const auto b=batch();Store store(db,proto);Store::Receipt receipt; for(int point=0;point<3;++point){ reset(db,b);assert(store.Prepare(b,[]{return 1;})==Store::Prepared); const pid_t child=spawnWorker("crash",std::to_string(point)); int status=0;assert(waitpid(child,&status,0)==child&&WIFEXITED(status)&&WEXITSTATUS(status)==77); assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.successes==3);assert(number(db,"SELECT gold FROM player")==700&&number(db,"SELECT count FROM item WHERE id=10")==4&&number(db,"SELECT COUNT(*) FROM item WHERE id>=100")==3); assert(store.Execute(b.token,1,1,receipt)==Store::Complete);assert(number(db,"SELECT gold FROM player")==700); } puts("PASS process exit after material write, receipt write, commit; identity-only exactly-once recovery"); reset(db,b);assert(store.Prepare(b,[]{return 1;})==Store::Prepared); pid_t children[2];for(auto& child:children)child=spawnWorker("repeat"); for(auto child:children){int status=0;assert(waitpid(child,&status,0)==child&&WIFEXITED(status)&&WEXITSTATUS(status)==0);} assert(number(db,"SELECT gold FROM player")==700&&number(db,"SELECT count FROM item WHERE id=10")==4&&number(db,"SELECT COUNT(*) FROM item WHERE id>=100")==3); puts("PASS simultaneous duplicate batch execution across two processes"); } static void removeFence(TestDB& db){sql(db,"DELETE FROM port_cube_item_fences");sql(db,"DELETE FROM port_cube_fences");} static void barriers(Drain& d,const Batch& b,bool failed=false){assert(d.Start(b,17,11,22));assert(!d.Async(b,17,false));assert(d.Main(b,17,2,false)==0);assert(d.Main(b,18,1,false)==0);assert(d.Main(b,17,1,false)==1);assert(d.Main(b,17,1,false)==0);assert(d.Async(b,17,false));assert(!d.Async(b,17,false));assert(d.Main(b,17,2,failed)==2);assert(d.Complete());} static void fenceTests(TestDB& db){ using F=FenceStore;auto b=batch();F fence(db,proto);Store store(db,proto);Store::Receipt receipt;std::string image,phase;Batch recovered; reset(db,b);removeFence(db);db.ambiguous=true;assert(fence.Begin(b,{9000})==F::Retry);assert(fence.Begin(b,{9000})==F::Done);assert(value(db,"SELECT phase FROM port_cube_fences")=="DRAINING");assert(number(db,"SELECT COUNT(*) FROM port_cube_item_fences WHERE id=9000")==1);assert(number(db,"SELECT MAX(id) FROM port_cube_item_fences")==9000);assert(number(db,"SELECT COUNT(*) FROM port_economy_item_reservations")==3); assert(store.Prepare(b,draw)==Store::Blocked&&draws==0);assert(fence.AbortUnprepared(b)==F::Refused);assert(fence.Recover(2,1,recovered,phase,image)==F::Refused); assert(fence.Recover(1,1,recovered,phase,image)==F::Done&&Encode(recovered)==Encode(b)&&phase=="DRAINING"&&image.empty()); Drain drain;assert(drain.Start(b,17,11,22));assert(fence.FinishDrain(b,drain,17,11,22,true)==F::Refused); assert(drain.Main(b,17,1,false)==1);assert(drain.Async(b,17,false));assert(fence.FinishDrain(b,drain,17,11,22,true)==F::Refused);assert(drain.Main(b,17,2,false)==2); db.ambiguous=true;assert(fence.FinishDrain(b,drain,17,11,22,true)==F::Retry);assert(fence.FinishDrain(b,drain,17,11,22,true)==F::Done); assert(fence.Begin(b,{})==F::Done&&value(db,"SELECT phase FROM port_cube_fences")=="FROZEN"); assert(store.Prepare(b,draw)==Store::Prepared);assert(fence.AbortUnprepared(b)==F::Refused);assert(fence.Resync(b,image)==F::Refused); assert(store.Execute(b.token,1,1,receipt)==Store::Complete);db.ambiguous=true;assert(fence.Resync(b,image)==F::Retry&&image.empty());assert(fence.Resync(b,image)==F::Done); Reader decoded(image);assert(decoded.n(8)==700);const auto items=decoded.items();assert(decoded.ok&&decoded.at==image.size()&&items.size()==3&&items[0].value.count==4); assert(store.Prepare(b,draw)==Store::Prepared); // identity replay only; no new draw or asset mutation assert(fence.Release(b,image+"x")==F::Refused);sql(db,"UPDATE player SET gold=699");assert(fence.Release(b,image)==F::Refused);assert(value(db,"SELECT phase FROM port_cube_fences")=="RESYNC");sql(db,"UPDATE player SET gold=700"); auto wrong=b;wrong.epoch++;assert(fence.Release(wrong,image)==F::Refused);db.ambiguous=true;assert(fence.Release(b,image)==F::Retry);assert(fence.Release(b,image)==F::Done);assert(number(db,"SELECT COUNT(*) FROM port_cube_item_fences")==0&&value(db,"SELECT phase FROM port_cube_fences")=="RELEASED");assert(number(db,"SELECT COUNT(*) FROM port_economy_item_reservations")==3); auto next=b;next.epoch++;next.token=std::string(32,'c');next.gold=700;next.inventory=items;for(unsigned i=0;i=1){assert(store.Prepare(b,draw)==Store::Prepared);assert(store.Execute(b.token,1,1,receipt)==Store::Complete);}if(operation>=2)assert(fence.Resync(b,image)==F::Done);}; auto action=[&](){if(operation==0)return fence.Begin(b,{});if(operation==1)return fence.Resync(b,image);if(operation==2)return fence.Release(b,image);return fence.Recover(1,1,recovered,phase,image);}; setup();db.statements=0;assert(action()==F::Done);const int count=db.statements; for(int at=1;at<=count;++at){setup();db.statements=0;db.failAt=at;assert(action()==F::Retry);db.failAt=0;assert(!db.active);if(operation==0){assert(number(db,"SELECT COUNT(*) FROM port_cube_fences")==0);unchanged(db,b);}else {assert(number(db,"SELECT gold FROM player")==700);assert(value(db,"SELECT phase FROM port_cube_fences")!="RELEASED");}} } // A second process can reconstruct persisted DRAINING after loss of adapter // memory; absent old-owner proof, the new correlation must abort, not charge. reset(db,b);removeFence(db);assert(fence.Begin(b,{})==F::Done); const pid_t child=spawnWorker("recover-drain");int status=0;assert(waitpid(child,&status,0)==child&&WIFEXITED(status)&&WEXITSTATUS(status)==77);assert(value(db,"SELECT phase FROM port_cube_fences")=="ABORTED");assert(fence.Resync(b,image)==F::Done&&fence.Release(b,image)==F::Done);unchanged(db,b); puts("PASS lifecycle SQL failure boundaries and separate-process fail-closed drain recovery"); } int main(int argc,char** argv){ assert(argc>=2&&argc<=4);executable=argv[0];address=argv[1];TestDB db; if(argc>=3){const std::string mode=argv[2]; if(mode=="base"){initialize(db,false);return 0;} if(mode=="fence"){initialize(db);fenceTests(db);return 0;} Store s(db,proto);Store::Receipt receipt;const auto b=batch(); if(mode=="repeat")return s.Execute(b.token,1,1,receipt)==Store::Complete?0:1; if(mode=="crash") {assert(argc==4);const int point=std::stoi(argv[3]);db.after=[&](const std::string& q){if((point==0&&q.find("UPDATE item SET count=")==0)||(point==1&&q.find("UPDATE port_cube_requests SET state='DONE'")==0)||(point==2&&q=="COMMIT"))_exit(77);};s.Execute(b.token,1,1,receipt);return 78;} assert(mode=="recover-drain");FenceStore f(db,proto);Batch old;std::string phase,image; assert(f.Recover(1,1,old,phase,image)==FenceStore::Done&&phase=="DRAINING");Drain d;barriers(d,old);assert(f.FinishDrain(old,d,17,11,22,false)==FenceStore::Done);return 77; } initialize(db);basic(db);faults(db);bounds(db);crash(db);return 0; }