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

131 lines
11 KiB
C++

#define main cubeBaseMain
#include "cube_batch_probe.cpp"
#undef main
#include "src/server/common/cube_owner.h"
#include "src/server/common/cube_gold_store.h"
using O=OwnerStore<TestDB>;
using F=FenceStore<TestDB>;
using G=GoldIntentStore<TestDB>;
static OwnerGrant original(const Batch& b,const OwnerLeader& l){return {l,GoldSourceFor(b,17,7,6),5,1};}
static GoldSourceSeal source(const Batch& b){GoldSourceSeal s;static_cast<GoldSourceBinding&>(s)=GoldSourceFor(b,17,7,6);return s;}
static void fresh(TestDB& db,const Batch& b) {
reset(db,b);sql(db,"DELETE FROM port_cube_owner_leases");sql(db,"DELETE FROM port_cube_gold_sources");sql(db,"DELETE FROM port_cube_gold_intents");removeFence(db);
}
static F::Result bind(TestDB& db,const Batch& b,const OwnerGrant& grant) {
O owner(db,proto);F fence(db,proto);return fence.Begin(b,{},[&](bool replay){return owner.BindWithin(b,grant,replay);});
}
static void frozen(TestDB& db,const Batch& b,const OwnerLeader& leader,bool done=true,bool close=true) {
fresh(db,b);assert(bind(db,b,original(b,leader))==F::Done);Drain d;barriers(d,b);F fence(db,proto);assert(fence.FinishDrain(b,d,17,11,22,true)==F::Done);
if(done){Store craft(db,proto);Store::Receipt receipt;assert(craft.Prepare(b,[]{return 1u;})==Store::Prepared&&craft.Execute(b.token,1,1,receipt)==Store::Complete);}
if(close){G gold(db,proto);assert(gold.CloseSource(b,source(b))==G::Stored);}
}
static void revoke(TestDB& db,const Batch& b,const OwnerLeader& l,OwnerGrant& receipt) {
O owner(db,proto);const auto old=original(b,l);assert(owner.Revoke(b,l,1,&old,receipt)==O::Revoked);
}
#ifndef PORT_CUBE_OWNER_EMBED
int main(int argc,char** argv) {
assert(argc==2||argc==3);address=argv[1];executable=argv[0];auto b=batch();TestDB db;O owner(db,proto);OwnerLeader leader;
if(argc==3) {
const std::string mode=argv[2];assert(owner.Acquire(std::string(32,'c'),leader)==O::Acquired);
db.after=[&](const std::string& q){if((mode=="lease-insert"&&q.find("INSERT INTO port_cube_owner_leases")==0)||(mode=="lease-commit"&&q=="COMMIT"))_Exit(92);};
bind(db,b,original(b,leader));assert(false);
}
initialize(db);initializeGoldAddon(db);initializeOwnerAddon(db);reset(db,b);assert(owner.Ready());
assert(owner.Acquire(std::string(32,'d'),leader)==O::Acquired&&owner.Current(leader));
const auto generation=leader.generation;OwnerLeader replay;
assert(owner.Acquire(leader.boot,replay)==O::Acquired&&replay.generation==generation);
#ifdef PORT_CUBE_MYSQL
{TestDB competitor;O other(competitor,proto);OwnerLeader next;
assert(other.Acquire(std::string(32,'e'),next)==O::Busy);
sql(db,"SELECT RELEASE_LOCK(CONCAT('m2_cube:',DATABASE()))");
assert(other.Acquire(std::string(32,'e'),next)==O::Acquired&&next.generation>generation&&!owner.Current(leader));
assert(owner.Acquire(std::string(32,'d'),replay)==O::Busy);}
assert(owner.Acquire(std::string(32,'d'),leader)==O::Acquired&&leader.generation>generation);
puts("PASS actual MySQL connection-scoped advisory lock: competing connection denied, disconnect releases, generation advances and old broker fails");
#else
db.ownerHolder=99;assert(owner.Acquire(leader.boot,replay)==O::Busy);db.ownerHolder=db.ownerConnection;
db.ownerConnection=2;db.ownerHolder=0;assert(!owner.Current(leader));assert(owner.Acquire(leader.boot,leader)==O::Acquired&&leader.generation>generation);
puts("PASS SQLite-only explicit connection/advisory substitute; no real MySQL lock claim");
#endif
fresh(db,b);const auto grant=original(b,leader);
db.ambiguous=true;assert(bind(db,b,grant)==F::Retry);assert(bind(db,b,grant)==F::Done&&owner.Check(b,grant));
auto changed=grant;changed.binding.cookie++;assert(bind(db,b,changed)==F::Refused);
sql(db,"DELETE FROM port_cube_owner_leases");assert(bind(db,b,grant)==F::Refused&&number(db,"SELECT COUNT(*) FROM port_cube_owner_leases")==0);
puts("PASS atomic Begin+lease, lost COMMIT acknowledgement, immutable binding replay and no invented missing owner on old fence");
frozen(db,b,leader);OwnerGrant revoked,adopted;revoke(db,b,leader,revoked);assert(!owner.Check(b,grant));
const auto target=GoldSourceFor(b,18,8,9);
assert(owner.Revoke(b,leader,1,&grant,revoked)==O::Revoked&&revoked.revision==2);
assert(owner.Adopt(b,leader,revoked.revision,6,grant.binding,adopted)==O::Refused);
db.ambiguous=true;assert(owner.Adopt(b,leader,2,6,target,adopted)==O::Retry);
assert(owner.Adopt(b,leader,2,6,target,adopted)==O::Adopted&&adopted.revision==3&&owner.Check(b,adopted));
auto wrong=target;wrong.session++;OwnerGrant denied;assert(owner.Adopt(b,leader,2,6,wrong,denied)==O::Refused);
F fence(db,proto);std::string image;auto ownedImage=[&](const std::string& current){return owner.ImageWithin(b,adopted,current);};
assert(fence.Resync(b,image)==F::Refused&&fence.Resync(b,image,ownedImage)==F::Done&&fence.Release(b,image)==F::Refused);
assert(number(db,"SELECT gold FROM player")==700&&number(db,"SELECT COUNT(*) FROM port_cube_item_fences")>0);
puts("PASS persisted revoke, fresh-session adoption, lost adoption ACK replay, no new payment/load/thaw and old release remains blocked");
frozen(db,b,leader,true,false);G gold(db,proto);GoldIntent credit;
credit.account=b.account;credit.player=b.player;credit.epoch=b.epoch;credit.owner=b.owner;credit.request=b.token;credit.amount=250;credit.source=1;
credit.sequence=1;credit.event=std::string(32,'1');assert(gold.Enqueue(b,credit)==G::Stored);
const auto first=credit.event;credit.sequence=2;credit.event=std::string(32,'2');assert(gold.Enqueue(b,credit)==G::Stored);
auto seal=source(b);seal.events={first,credit.event};assert(gold.CloseSource(b,seal)==G::Stored);
G::Receipt goldReceipt;assert(gold.Apply(first,1,1,goldReceipt)==G::Applied);revoke(db,b,leader,revoked);
assert(owner.Adopt(b,leader,revoked.revision,6,target,adopted)==O::Adopted&&number(db,"SELECT gold FROM player")==950);
assert(fence.Resync(b,image)==F::Refused); // adoption does not secretly settle queued rewards
assert(gold.Apply(credit.event,1,1,goldReceipt)==G::Applied&&fence.Resync(b,image,ownedImage)==F::Done&&fence.Release(b,image)==F::Refused);
puts("PASS exact original source and applied-prefix/pending-credit recovery: no implicit credit on adoption, no early resync or thaw");
frozen(db,b,leader);revoke(db,b,leader,revoked);assert(owner.Adopt(b,leader,revoked.revision,6,target,adopted)==O::Adopted);
const auto originalBinding=EncodeGoldSourceBinding(original(b,leader).binding);
for(unsigned session=19;session<=21;++session) {
const auto lost=adopted;
if(session==19)db.rejectCommit=true;else if(session==20)db.ambiguous=true;else db.warnAt=db.statements+1;
assert(owner.Revoke(b,leader,2,&lost,revoked)==O::Retry);db.warnAt=0;
assert(owner.Revoke(b,leader,2,&lost,revoked)==O::Revoked&&!owner.Check(b,lost));
const auto next=GoldSourceFor(b,session,session,session);
assert(owner.Adopt(b,leader,revoked.revision,6,next,adopted)==O::Adopted&&adopted.revision==lost.revision+2);
assert(value(db,"SELECT original_binding FROM port_cube_owner_leases")==originalBinding&&number(db,"SELECT gold FROM player")==700&&number(db,"SELECT COUNT(*) FROM port_cube_requests")==1);
}
assert(fence.Resync(b,image,ownedImage)==F::Done&&fence.Release(b,image)==F::Refused);
puts("PASS repeated adopted-owner logout/revoke/readopt with rejected/lost COMMIT and warning; original source immutable, same single settlement, still no thaw");
for(unsigned problem=0;problem<5;++problem) {
frozen(db,b,leader,problem!=0,problem!=1);revoke(db,b,leader,revoked);
if(problem==2)sql(db,"UPDATE player SET gold=gold+1");
if(problem==3)sql(db,"UPDATE port_cube_fences SET phase='ABORTED',drain_state=2");
if(problem==4)sql(db,"UPDATE port_cube_gold_sources SET cookie=cookie+1");
assert(owner.Adopt(b,leader,revoked.revision,6,target,adopted)!=O::Adopted);
assert(value(db,"SELECT phase FROM port_cube_owner_leases")=="REVOKED");
}
frozen(db,b,leader);const auto previous=leader;const auto previousGrant=original(b,leader);
assert(owner.Acquire(std::string(32,'f'),leader)==O::Acquired&&!owner.Check(b,previousGrant));
assert(owner.Revoke(b,leader,1,&previousGrant,revoked)==O::Refused);
assert(owner.Revoke(b,leader,3,nullptr,revoked)==O::Revoked&&owner.Adopt(b,leader,revoked.revision,6,target,adopted)==O::Adopted);
assert(owner.Revoke(b,leader,3,nullptr,revoked)==O::Refused);
puts("PASS absent DONE/source, mismatched wallet/binding, aborted drain and same-generation takeover refused; strictly newer broker can revoke original held owner");
for(unsigned operation=0;operation<3;++operation) {
auto setup=[&](){if(!operation)fresh(db,b);else frozen(db,b,leader);if(operation==2)revoke(db,b,leader,revoked);};
auto action=[&](){if(!operation)return int(bind(db,b,original(b,leader)))==int(F::Done);if(operation==1){const auto old=original(b,leader);return owner.Revoke(b,leader,1,&old,revoked)==O::Revoked;}return owner.Adopt(b,leader,2,6,target,adopted)==O::Adopted;};
setup();db.statements=0;assert(action());const auto count=db.statements;
for(unsigned warning=0;warning<2;++warning)for(int at=1;at<=count;++at) {
setup();db.statements=0;if(warning)db.warnAt=at;else db.failAt=at;assert(!action());db.failAt=db.warnAt=0;
if(!operation)assert(number(db,"SELECT COUNT(*) FROM port_cube_fences")==0&&number(db,"SELECT COUNT(*) FROM port_cube_owner_leases")==0&&number(db,"SELECT COUNT(*) FROM port_cube_item_fences")==0);
else assert(value(db,"SELECT phase FROM port_cube_owner_leases")==std::string(operation==1?"LIVE":"REVOKED"));
assert(action());
}
}
puts("PASS every binding/revocation/adoption SQL failure and warning boundary rolls back atomically and retries without new currency");
for(const auto& mode:{"lease-insert","lease-commit"}) {
fresh(db,b);sql(db,"SELECT RELEASE_LOCK(CONCAT('m2_cube:',DATABASE()))");
const auto child=spawnWorker(mode);int status=0;assert(waitpid(child,&status,0)==child&&WIFEXITED(status)&&WEXITSTATUS(status)==92);
const auto expected=std::string(mode)=="lease-commit"?1:0;
assert(number(db,"SELECT COUNT(*) FROM port_cube_owner_leases")==expected&&number(db,"SELECT COUNT(*) FROM port_cube_fences")==expected);
assert(owner.Acquire(std::string(32,'d'),leader)==O::Acquired);
}
sql(db,"UPDATE port_cube_owner_version SET version=2");assert(!owner.Ready());sql(db,"UPDATE port_cube_owner_version SET version=1");
puts("PASS process exit before/after owner transaction COMMIT preserves fence+lease together; unknown owner schema refused; no runtime gates enabled");
}
#endif