Files
metin2-server/tests/features/fixtures/cube_batch_probe.cpp
T

340 lines
36 KiB
C++

#include "src/server/common/cube_store.h"
#include "src/server/common/cube_fence.h"
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <sys/wait.h>
#include <spawn.h>
#include <unistd.h>
#ifdef PORT_CUBE_MYSQL
#include "src/server/common/economy_mysql.h"
#else
#include <sqlite3.h>
#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<char*> args={const_cast<char*>(executable.c_str()),const_cast<char*>(address.c_str()),const_cast<char*>(mode.c_str())};
if(!extra.empty())args.push_back(const_cast<char*>(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<void(const std::string&)> 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<<sqlite3_errmsg(db)<<" SQL "<<sql.substr(0,100)<<"\n";return false;}
int rc;while((rc=sqlite3_step(statement))==SQLITE_ROW){std::vector<std::string> row;for(int i=0;i<sqlite3_column_count(statement);++i){const char* p=static_cast<const char*>(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<TestDB>;
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<<query<<"\n";std::abort();}}
static std::string value(TestDB& db,const std::string& query){Rows rows;assert(db.Query(query,rows)&&rows.size()==1&&rows[0].size()==1);return rows[0][0];}
static uint64_t number(TestDB& db,const std::string& query){uint64_t n=0;assert(PortEconomy::Number(value(db,query),n));return n;}
static std::string hex(const void* data,size_t n){return PortEconomy::Hex(data,n);}
static Batch batch(){
Batch b;b.account=1;b.player=1;b.epoch=3;b.gold=1000;b.owner=std::string(32,'a');b.token=std::string(32,'b');b.attempts=3;
b.recipe.id=1;b.recipe.reward=19;b.recipe.rewardCount=1;b.recipe.gold=100;b.recipe.percent=50;b.recipe.npcs={20383};b.recipe.materials={{30006,2}};
Item item;item.value.id=10;item.value.vnum=30006;item.value.count=10;item.value.sockets[0]=-123;item.value.types[0]=255;item.value.values[0]=-321;item.value.extra[0]=1;item.value.extra[68]=255;b.inventory.push_back(item);
for(unsigned i=0;i<3;++i){PortEconomy::Reward r;r.id=100+i;r.vnum=19;r.count=1;r.sockets[0]=77;r.extra[0]=9;b.rewards.push_back(r);}return b;
}
static void initialize(TestDB& db,bool cube=true){
const std::string engine=
#ifdef PORT_CUBE_MYSQL
" ENGINE=InnoDB";
#else
"";
#endif
sql(db,"CREATE TABLE IF NOT EXISTS player(id INT PRIMARY KEY,account_id INT,gold BIGINT)"+engine);
std::string item="CREATE TABLE IF NOT EXISTS item(id INT PRIMARY KEY,owner_id INT,window VARCHAR(16),pos INT,count INT,vnum INT";
for(unsigned i=0;i<3;++i)item+=",socket"+std::to_string(i)+" INT NOT NULL DEFAULT 0";
for(unsigned i=0;i<7;++i)item+=",attrtype"+std::to_string(i)+" INT NOT NULL DEFAULT 0,attrvalue"+std::to_string(i)+" INT NOT NULL DEFAULT 0";
sql(db,item+",port_extra VARBINARY(69) NOT NULL)"+engine);
std::string custody=item;custody.replace(custody.find("item("),5,"port_economy_custody(");sql(db,custody+",port_extra VARBINARY(69) NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_economy_version(id INT PRIMARY KEY,version INT)"+engine);
if(cube)sql(db,"CREATE TABLE IF NOT EXISTS port_cube_version(id INT PRIMARY KEY,version INT)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_economy_account_lock(account INT PRIMARY KEY)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_economy_pending(pid INT PRIMARY KEY,token VARCHAR(32))"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_economy_item_reservations(id INT PRIMARY KEY,request VARCHAR(32))"+engine);
if(cube){sql(db,"CREATE TABLE IF NOT EXISTS port_cube_fences(pid INT PRIMARY KEY,account INT,epoch BIGINT,owner VARCHAR(32),request VARCHAR(32) UNIQUE,phase VARCHAR(16),body MEDIUMBLOB NOT NULL,image MEDIUMBLOB NOT NULL,drain_state INT NOT NULL DEFAULT 0)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_item_fences(id INT PRIMARY KEY,pid INT NOT NULL,epoch BIGINT NOT NULL,request VARCHAR(32) NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_requests(token VARCHAR(32) PRIMARY KEY,account INT,pid INT,body MEDIUMBLOB,rolls VARBINARY(100),state VARCHAR(16),result VARCHAR(64),successes INT,fee BIGINT,awards MEDIUMBLOB)"+engine);}
}
static void initializeGoldAddon(TestDB& db) {
const std::string engine=
#ifdef PORT_CUBE_MYSQL
" ENGINE=InnoDB";
#else
"";
#endif
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_gold_version(id INT PRIMARY KEY,version INT NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_gold_intents(event VARCHAR(32) PRIMARY KEY,request VARCHAR(32) NOT NULL,seq INT NOT NULL,account INT NOT NULL,pid INT NOT NULL,body VARBINARY(129) NOT NULL,state VARCHAR(16) NOT NULL,before_gold BIGINT NOT NULL,after_gold BIGINT NOT NULL,UNIQUE(request,seq))"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_gold_sources(request VARCHAR(32) PRIMARY KEY,account INT NOT NULL,pid INT NOT NULL,epoch BIGINT NOT NULL,owner VARCHAR(32) NOT NULL,session BIGINT NOT NULL,cookie INT NOT NULL,handle INT NOT NULL,manifest VARBINARY(32772) NOT NULL)"+engine);
sql(db,"DELETE FROM port_cube_gold_version");sql(db,"INSERT INTO port_cube_gold_version VALUES(1,2)");
}
static void initializeOwnerAddon(TestDB& db) {
const std::string engine=
#ifdef PORT_CUBE_MYSQL
" ENGINE=InnoDB";
#else
"";
#endif
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_owner_version(id INT PRIMARY KEY,version INT NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_owner_broker(id INT PRIMARY KEY,generation BIGINT NOT NULL,boot VARCHAR(32) NOT NULL,connection_id BIGINT NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_owner_leases(request VARCHAR(32) PRIMARY KEY,account INT NOT NULL UNIQUE,pid INT NOT NULL UNIQUE,body MEDIUMBLOB NOT NULL,revision BIGINT NOT NULL,generation BIGINT NOT NULL,boot VARCHAR(32) NOT NULL,connection_id BIGINT NOT NULL,peer INT NOT NULL,binding VARBINARY(96) NOT NULL,original_peer INT NOT NULL,original_binding VARBINARY(96) NOT NULL,phase VARCHAR(16) NOT NULL,revoked_generation BIGINT NOT NULL,reason INT NOT NULL)"+engine);
if(!number(db,"SELECT COUNT(*) FROM port_cube_owner_version"))sql(db,"INSERT INTO port_cube_owner_version VALUES(1,1)");
if(!number(db,"SELECT COUNT(*) FROM port_cube_owner_broker"))sql(db,"INSERT INTO port_cube_owner_broker VALUES(1,0,'00000000000000000000000000000000',0)");
}
static int draws=0;
static void initializeImageAckAddon(TestDB& db) {
const std::string engine=
#ifdef PORT_CUBE_MYSQL
" ENGINE=InnoDB";
#else
"";
#endif
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_image_ack_version(id INT PRIMARY KEY,version INT NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_image_acks(request VARCHAR(32) PRIMARY KEY,body MEDIUMBLOB NOT NULL,owner_grant VARBINARY(160) NOT NULL,image MEDIUMBLOB NOT NULL)"+engine);
if(!number(db,"SELECT COUNT(*) FROM port_cube_image_ack_version"))sql(db,"INSERT INTO port_cube_image_ack_version VALUES(1,1)");
}
static void initializeReleaseAddon(TestDB& db) {
const std::string engine=
#ifdef PORT_CUBE_MYSQL
" ENGINE=InnoDB";
#else
"";
#endif
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_release_version(id INT PRIMARY KEY,version INT NOT NULL)"+engine);
sql(db,"CREATE TABLE IF NOT EXISTS port_cube_releases(request VARCHAR(32) PRIMARY KEY,body MEDIUMBLOB NOT NULL,owner_grant VARBINARY(160) NOT NULL,image MEDIUMBLOB NOT NULL)"+engine);
if(!number(db,"SELECT COUNT(*) FROM port_cube_release_version"))sql(db,"INSERT INTO port_cube_release_version VALUES(1,1)");
}
static void reset(TestDB& db,const Batch& b){
draws=0;
db.failAt=db.warnAt=0;db.after={};db.ambiguous=db.rejectCommit=false;db.Rollback();
for(const char* table:{"port_cube_requests","port_cube_item_fences","port_cube_fences","port_economy_item_reservations","port_economy_pending","port_economy_account_lock","port_cube_version","port_economy_version","port_economy_custody","item","player"})sql(db,std::string("DELETE FROM ")+table);
sql(db,"INSERT INTO port_cube_version VALUES(1,2)");sql(db,"INSERT INTO port_economy_version VALUES(1,1)");sql(db,"INSERT INTO player VALUES(1,1,"+std::to_string(b.gold)+")");
const auto body=Encode(b);
sql(db,"INSERT INTO port_cube_fences VALUES(1,1,"+std::to_string(b.epoch)+",'"+b.owner+"','"+b.token+"','FROZEN',X'"+hex(body.data(),body.size())+"',X'',1)");
auto lock=[&](uint32_t id){sql(db,"INSERT INTO port_cube_item_fences VALUES("+std::to_string(id)+",1,"+std::to_string(b.epoch)+",'"+b.token+"')");};
for(const auto& i:b.inventory)lock(i.value.id);for(const auto& r:b.rewards)lock(r.id);
for(const auto& i:b.inventory){
const auto& r=i.value;std::string columns="id,owner_id,window,pos,count,vnum",values=std::to_string(r.id)+",1,'INVENTORY',"+std::to_string(i.cell)+","+std::to_string(r.count)+","+std::to_string(r.vnum);
for(unsigned n=0;n<3;++n){columns+=",socket"+std::to_string(n);values+=","+std::to_string(r.sockets[n]);}
for(unsigned n=0;n<7;++n){columns+=",attrtype"+std::to_string(n)+",attrvalue"+std::to_string(n);values+=","+std::to_string(r.types[n])+","+std::to_string(r.values[n]);}
sql(db,"INSERT INTO item("+columns+",port_extra) VALUES("+values+",X'"+hex(r.extra,69)+"')");
}
}
static unsigned draw(){return ++draws%2?25u:75u;}
static void unchanged(TestDB& db,const Batch& b){assert(number(db,"SELECT gold FROM player WHERE id=1")==b.gold);assert(number(db,"SELECT count FROM item WHERE id=10")==b.inventory[0].value.count);assert(number(db,"SELECT COUNT(*) FROM item WHERE id IN(100,101,102)")==0);}
static void basic(TestDB& db){
auto b=batch();Batch decoded;assert(Decode(Encode(b),decoded)&&Encode(b)==Encode(decoded));
for(size_t n=0;n<Encode(b).size();++n)assert(!Decode(Encode(b).substr(0,n),decoded));
assert(!Decode(Encode(b)+"x",decoded));auto invalid=b;invalid.recipe.copy=true;assert(!Validate(invalid));
Store store(db,proto);Store::Receipt receipt;reset(db,b);assert(store.Ready());
#ifdef PORT_CUBE_MYSQL
sql(db,"ALTER TABLE item ENGINE=MyISAM");assert(!store.Ready());sql(db,"ALTER TABLE item ENGINE=InnoDB");assert(store.Ready());
sql(db,"UPDATE port_cube_version SET version=3");assert(!store.Ready());sql(db,"UPDATE port_cube_version SET version=2");
sql(db,"ALTER TABLE item ADD COLUMN unknown_state INT");assert(!store.Ready());sql(db,"ALTER TABLE item DROP COLUMN unknown_state");assert(store.Ready());
#endif
sql(db,"UPDATE port_cube_fences SET phase='RESYNC'");draws=0;assert(store.Prepare(b,draw)==Store::Blocked&&draws==0);unchanged(db,b);
sql(db,"UPDATE port_cube_fences SET phase='FROZEN'");assert(store.Prepare(b,draw)==Store::Prepared&&draws==3);assert(store.Prepare(b,draw)==Store::Prepared&&draws==3);unchanged(db,b);
auto changed=b;changed.attempts=2;changed.rewards.pop_back();assert(store.Prepare(changed,draw)==Store::Rejected&&draws==3);
assert(store.Execute(b.token,2,1,receipt)==Store::Rejected);assert(store.Execute(b.token,1,1,receipt)==Store::Complete&&receipt.result=="ok"&&receipt.successes==2&&receipt.fee==300&&receipt.awards.size()==2);
assert(number(db,"SELECT gold FROM player WHERE id=1")==700);assert(number(db,"SELECT count FROM item WHERE id=10")==4);assert(number(db,"SELECT COUNT(*) FROM item WHERE id>=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<const char*>(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<TestDB>;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<next.rewards.size();++i)next.rewards[i].id=200+i;
assert(Validate(next)&&fence.Begin(next,{})==F::Done);assert(fence.Release(b,image)==F::Refused);assert(fence.FinishDrain(next,drain,17,11,22,true)==F::Refused);
// Failed SQL epochs or lost owner cannot advance to FROZEN or deduct.
for(unsigned reason=0;reason<3;++reason){reset(db,b);removeFence(db);assert(fence.Begin(b,{})==F::Done);Drain d;barriers(d,b,reason==0);assert(fence.FinishDrain(b,d,17,reason==1?12:11,22,reason!=2)==F::Done);assert(value(db,"SELECT phase FROM port_cube_fences")=="ABORTED");assert(store.Prepare(b,draw)==Store::Blocked&&draws==0);assert(fence.Resync(b,image)==F::Done);assert(fence.Resync(b,image)==F::Done);assert(fence.Release(b,image)==F::Done);unchanged(db,b);}
// Before any durable prepare, changed context can be refused without cost.
reset(db,b);assert(fence.AbortUnprepared(b)==F::Done);assert(fence.AbortUnprepared(b)==F::Done);assert(fence.Resync(b,image)==F::Done&&fence.Release(b,image)==F::Done);unchanged(db,b);
// Missing item locks or a changed frozen body must never authorize crafting.
reset(db,b);sql(db,"DELETE FROM port_cube_item_fences WHERE id=10");assert(store.Prepare(b,draw)==Store::Blocked&&draws==0);unchanged(db,b);
reset(db,b);sql(db,"UPDATE port_cube_fences SET body=X'00'");assert(store.Prepare(b,draw)==Store::Blocked&&draws==0);unchanged(db,b);
puts("PASS correlated two-main/async drain, owner/failure abort, durable item locks, canonical resync ACK and monotonic release");
// Inject a failure at every SQL statement in each lifecycle operation.
for(unsigned operation=0;operation<4;++operation){
auto setup=[&](){reset(db,b);if(operation==0)removeFence(db);if(operation>=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<TestDB> f(db,proto);Batch old;std::string phase,image;
assert(f.Recover(1,1,old,phase,image)==FenceStore<TestDB>::Done&&phase=="DRAINING");Drain d;barriers(d,old);assert(f.FinishDrain(old,d,17,11,22,false)==FenceStore<TestDB>::Done);return 77;
}
initialize(db);basic(db);faults(db);bounds(db);crash(db);return 0;
}