// [1] J.E. Johnson, D.E. Langworthy, L.Lamport, F.H. Vogt. "Formal specification of a Web services protocol"
//Participant declaration - Corresponding TLA description on page-40
const int NO_OF_PARTICIPANTS = 2;
typedef int[0,NO_OF_PARTICIPANTS-1] Participant;
//States of the Initiator. Corresponding TLA description on page-40 in [1]
typedef int[0,3] StateI;
const StateI I_ACTIVE = 0;
const StateI I_COMMITTED = 1;
const StateI I_ABORTED = 2;
const StateI I_COMPLETING = 3;
//initial predicate for Initiator. Corresponding TLA description on page-42 in [1]
StateI iState = I_ACTIVE;
//States of the TC. Corresponding TLA description on page-41 in [1]
typedef int[0,5] StateTC;
const StateTC TC_ACTIVE = 0;
const StateTC TC_PREPARING_VOLATILE = 1;
const StateTC TC_PREPARING_DURABLE = 2;
const StateTC TC_ABORTING = 3;
const StateTC TC_COMMITTING =4;
const StateTC TC_ENDED = 5;
//TC's knowledge of the registratin states of the participant. Corresponding TLA description on page-41 in [1]
typedef int[0,5] RegTC;
const RegTC TC_UNREGISTERED = 0;
const RegTC TC_VOLATILE = 1;
const RegTC TC_DURABLE = 2;
const RegTC TC_PREPARED = 3;
const RegTC TC_READ_ONLY = 4;
const RegTC TC_COMMITTED = 5;
//TC's outcome for the protocol. Corresponding TLA description on page-41 in [1]
typedef int[0,1] ResTC;
const ResTC TC_ABORTED_RES = 0;
const ResTC TC_COMMITTED_RES = 1;
typedef struct {StateTC st; RegTC reg[Participant]; ResTC res;} DataTC;
DataTC tcData;
//States of the Participant. Corresponding TLA description on page-41 in [1]
typedef int[0,5] StateP;
const StateP P_UNREGISTERED = 0;
const StateP P_PREPARED = 1;
const StateP P_REGISTERING = 2;
const StateP P_ACTIVE = 3;
const StateP P_PREPARING = 4;
const StateP P_ENDED = 5;
//Registration types of the Participant. Corresponding TLA description on page-41 in [1]
typedef int[0,1] RegP;
const RegP P_VOLATILE = 0;
const RegP P_DURABLE = 1;
//Participants outcome for the protocol. Corresponding TLA description on page-41 in [1]
typedef int[0,2] ResP;
const ResP P_READ_ONLY = 0;
const ResP P_COMMITTED = 1;
const ResP P_ABORTED = 2;
typedef struct {StateP st; RegP reg; ResP res;} DataP;
DataP pData[Participant];
/** Boolean Arrays */
//Messages sent from TC to Participant. Corresponding TLA description on page-40 in [1]
typedef int[0,3] MsgsTC;
const MsgsTC REGISTER_RESPONSE = 0;
const MsgsTC PREPARE = 1;
const MsgsTC COMMIT = 2;
const MsgsTC ROLLBACK =3;
bool msgDest[Participant][MsgsTC] ;
//Messages sent from Participant to TC. Corresponding TLA description on page-40 in [1]
typedef int[0,5] MsgsP;
const MsgsP PREPARED = 0;
const MsgsP READ_ONLY = 1;
const MsgsP COMMITTED = 2;
const MsgsP ABORTED = 3;
const MsgsP REGISTER_VOLATILE = 4;
const MsgsP REGISTER_DURABLE = 5;
bool msgSrc[Participant][MsgsP];
typedef int[REGISTER_VOLATILE,REGISTER_DURABLE] Reg;
Reg regMsgType;
/** Consistency Checking **/
//Corresponding Consistency property on page-42 in [1]
bool AllParticipantsCommitted() {
int p;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (!(pData[p].st == P_UNREGISTERED ||
(pData[p].st == P_ENDED && (pData[p].res == P_READ_ONLY || pData[p].res == P_COMMITTED)))) return false;
return true; }
bool AllParticipantsCommitting() {
int p;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (!((pData[p].st == P_UNREGISTERED || pData[p].st == P_PREPARED) ||
(pData[p].st == P_ENDED && (pData[p].res == P_READ_ONLY || pData[p].res == P_COMMITTED)))) return false;
return true; }
bool InitiatorCommittedOK() {
return iState != I_COMMITTED ||
(tcData.st == TC_ENDED && tcData.res == TC_COMMITTED_RES && AllParticipantsCommitted()) ||
(tcData.st == TC_COMMITTING && AllParticipantsCommitting());
}
bool InitCoorCommittedOrCommitting() {
return iState == I_COMMITTED && ((tcData.st == TC_ENDED && tcData.res == TC_COMMITTED_RES) || tcData.st == TC_COMMITTING);
}
bool ParticipantCommittedOK() {
int p;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (pData[p].st == P_ENDED && pData[p].res == P_COMMITTED) {
if (!InitCoorCommittedOrCommitting() || !AllParticipantsCommitting()) return false;
}
return true; }
bool Consistency() {
return InitiatorCommittedOK() && ParticipantCommittedOK();
}InitCoor// [1] J.E. Johnson, D.E. Langworthy, L.Lamport, F.H. Vogt. "Formal specification of a Web services protocol"
//initial predicate for TC. page-42 in [1]
void initial() {
int p;
tcData.st = TC_ACTIVE;
tcData.res = TC_COMMITTED_RES;
for(p=0; p<NO_OF_PARTICIPANTS; p++)
tcData.reg[p] = TC_UNREGISTERED;
}
//1st TLA rule on page-43 in [1]
bool guard1_1() {
int pp;
for(pp=0; pp<NO_OF_PARTICIPANTS; pp++)
if ((pData[pp].st == P_ACTIVE || pData[pp].st == P_PREPARING) && pData[pp].reg == P_VOLATILE) return true;
return false;
}
bool guard1() {
int p;
if (iState != I_ACTIVE) return false;
for(p=0; p<NO_OF_PARTICIPANTS; p++)
if (pData[p].st == P_REGISTERING) {
if ( !( pData[p].reg == P_DURABLE && guard1_1() ) ) return false;
}
return true;
}
//2nd TLA rule on page-43 in [1]
void action1() {
int p;
iState = I_COMPLETING;
tcData.st = TC_PREPARING_VOLATILE;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] == TC_VOLATILE)
msgDest[p][PREPARE] = true;
}
//3rd TLA rule on page-43 in [1]
bool guard2() {
if (iState == I_ACTIVE || (tcData.st == TC_PREPARING_VOLATILE || tcData.st == TC_PREPARING_DURABLE)) return true;
return false;
}
void action2() {
int p;
iState = I_ABORTED;
tcData.st = TC_ABORTING;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] != TC_UNREGISTERED && tcData.reg[p] != TC_READ_ONLY)
msgDest[p][ROLLBACK] = true;
}
//4th TLA rule on page-43 in [1]
bool guard3() {
int p;
if (tcData.st != TC_PREPARING_VOLATILE) return false;
for(p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] == TC_VOLATILE) return false;
return true;
}
void action3() {
int p;
tcData.st = TC_PREPARING_DURABLE;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] == TC_DURABLE)
msgDest[p][PREPARE] = true;
}
//5th TLA rule on page-43 in [1]
bool guard4() {
int p;
if (tcData.st != TC_PREPARING_DURABLE) return false;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] == TC_DURABLE) return false;
return true;
}
void action4() {
int p;
tcData.st = TC_COMMITTING;
iState = I_COMMITTED;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] == TC_PREPARED)
msgDest[p][COMMIT] = true;
}
//1st TLA rule on page-44 in [1]
bool guard5() {
int p;
if (tcData.st == TC_ABORTING) return true;
if (tcData.st != TC_COMMITTING) return false;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (tcData.reg[p] != TC_UNREGISTERED && tcData.reg[p] != TC_READ_ONLY && tcData.reg[p] != TC_COMMITTED)
return false;
return true;
}
void action5() {
tcData.res = TC_COMMITTED_RES;
if (tcData.st == TC_ABORTING) tcData.res = TC_ABORTED_RES;
tcData.st = TC_ENDED;
}
/*********************** m is a "Register" message ********************************************************/
//2nd TLA rule on page-44 in [1]
bool guard6(Participant parId, Reg regMsgType) {
if ((msgSrc[parId][regMsgType] == true)
&& (tcData.st == TC_ACTIVE || (tcData.st == TC_PREPARING_VOLATILE && regMsgType == REGISTER_DURABLE)))
return true;
return false;
}
void action6(Participant parId, Reg regMsgType) {
msgDest[parId][REGISTER_RESPONSE] = true;
if (regMsgType == REGISTER_VOLATILE) tcData.reg[parId] = TC_VOLATILE;
if (regMsgType == REGISTER_DURABLE) tcData.reg[parId] = TC_DURABLE;
}
//2nd TLA rule on page-45 in [1]
bool guard7(Participant parId, Reg regMsgType) {
if ((msgSrc[parId][regMsgType] == true)
&&
(tcData.st == TC_ABORTING &&
((tcData.reg[parId] == TC_UNREGISTERED || tcData.reg[parId] == TC_READ_ONLY) ||
((tcData.reg[parId] == TC_VOLATILE || tcData.reg[parId] == TC_DURABLE || tcData.reg[parId] == TC_PREPARED) &&
msgDest[parId][ROLLBACK] == true) ) ) ) return true;
return false;
}
void action7(Participant parId, Reg regMsgType) {
if (tcData.reg[parId] == TC_UNREGISTERED)
msgDest[parId][ROLLBACK] = true;
}
//3rd TLA rule on page-45 in [1]
bool guard8(Participant parId, Reg regMsgType) {
if ((msgSrc[parId][regMsgType] == true)
&&
(tcData.st == TC_ENDED && (tcData.res == TC_ABORTED_RES || pData[parId].st == P_ENDED))) return true;
return false;
}
void action8(Participant parId, Reg regMsgType) {
msgDest[parId][ROLLBACK] = true;
}
/*********************** m is a "Prepared" message ********************************/
//4th TLA rule on page-45 in [1]
bool guard9(Participant parId) {
if ((msgSrc[parId][PREPARED] == true)
&&
((tcData.st == TC_PREPARING_VOLATILE && tcData.reg[parId] == TC_VOLATILE) ||
(tcData.st == TC_PREPARING_DURABLE && tcData.reg[parId] == TC_DURABLE))) return true;
return false;
}
void action9(Participant parId) {
tcData.reg[parId] = TC_PREPARED;
}
//1st TLA rule on page-46 in [1]
bool guard10(Participant parId) {
if (msgSrc[parId][PREPARED] == true && tcData.st == TC_ENDED) return true;
return false;
}
void action10(Participant parId) {
msgDest[parId][ROLLBACK] = true;
}
/*********************** m is a "ReadOnly" message **************************************************/
//3rd TLA rule on page-46 in [1]
bool guard11(Participant parId) {
if ((msgSrc[parId][READ_ONLY] == true)
&&
((tcData.st == TC_PREPARING_VOLATILE && tcData.reg[parId] == TC_VOLATILE) ||
(tcData.st == TC_PREPARING_DURABLE && tcData.reg[parId] == TC_DURABLE)) ) return true;
return false;
}
void action11(Participant parId) {
tcData.reg[parId] = TC_READ_ONLY;
}
/*********************** m is an "Aborted" message ***************************************************/
//1st TLA rule on page-47 in [1]
bool guard12(Participant parId) {
if ((msgSrc[parId][ABORTED] == true)
&&
((tcData.st == TC_ACTIVE || tcData.st == TC_PREPARING_VOLATILE || tcData.st == TC_PREPARING_DURABLE) &&
(tcData.reg[parId] == TC_UNREGISTERED || tcData.reg[parId] == TC_VOLATILE || tcData.reg[parId] == TC_DURABLE)))
return true;
return false;
}
void action12(Participant parId) {
int p;
iState = I_ABORTED;
tcData.st = TC_ABORTING;
for (p=0; p<NO_OF_PARTICIPANTS; p++)
if (msgSrc[parId][ABORTED] == true && (tcData.reg[parId] != TC_UNREGISTERED && tcData.reg[parId] != TC_READ_ONLY))
msgDest[parId][ROLLBACK] = true;
}
/************************* m is a "Committed" message *******************************************************/
//1st TLA rule on page-48 in [1]
bool guard13(Participant parId) {
if (msgSrc[parId][COMMITTED] == true && tcData.st == TC_COMMITTING) return true;
return false;
}
void action13(Participant parId) {
tcData.reg[parId] = TC_COMMITTED;
}STARTParticipant_Tconst Participant id// [1] J.E. Johnson, D.E. Langworthy, L.Lamport, F.H. Vogt. "Formal specification of a Web services protocol"
//initial predicate for Participant on page-42 in [1]
void initial() {
int p;
for(p=0; p<NO_OF_PARTICIPANTS; p++) {
pData[p].st = P_UNREGISTERED;
pData[p].reg = P_VOLATILE;
pData[p].res = P_READ_ONLY; }
}
/** Internal */
//3rd TLA rule on page-48 in [1]
bool guard14() {
if (pData[id].st == P_UNREGISTERED && iState == I_ACTIVE) return true;
return false;
}
void action14() {
pData[id].st = P_REGISTERING;
pData[id].reg = P_VOLATILE;
msgSrc[id][REGISTER_VOLATILE] = true;
}
//4th TLA rule on page-48 & 49 in [1]
bool guard15_1() {
int pp;
for (pp=0; pp<NO_OF_PARTICIPANTS; pp++)
if ((pData[pp].st == P_ACTIVE || pData[pp].st == P_PREPARING) && pData[pp].reg == P_VOLATILE) return true;
return false;
}
bool guard15() {
if (pData[id].st != P_UNREGISTERED) return false;
if (iState == I_ACTIVE || guard15_1()) return true;
return false;
}
void action15() {
pData[id].st = P_REGISTERING;
pData[id].reg = P_DURABLE;
msgSrc[id][REGISTER_DURABLE] = true;
}
//1st TLA rule on page-49 in [1]
bool guard16() {
if (pData[id].st == P_ACTIVE || pData[id].st == P_PREPARING) return true;
return false;
}
void action16() {
pData[id].st = P_ENDED;
pData[id].res = P_ABORTED;
msgSrc[id][ABORTED] = true;
}
//2nd TLA rule on page-49 in [1]
bool AnyRegistering() {
int dp;
for(dp=0; dp<NO_OF_PARTICIPANTS; dp++)
if (pData[dp].st == P_REGISTERING && pData[dp].reg == P_DURABLE) return true;
return false;
}
bool AnyActive() {
int vp;
for(vp=0; vp<NO_OF_PARTICIPANTS; vp++)
if (vp != id && (pData[vp].st == P_ACTIVE && pData[vp].reg == P_VOLATILE)) return true;
return false;
}
bool guard17() {
if (pData[id].st != P_PREPARING) return false;
if (pData[id].reg == P_DURABLE || !(AnyRegistering()) || AnyActive()) return true;
return false;
}
void action17_1() {
pData[id].st = P_PREPARED;
msgSrc[id][PREPARED] = true;
}
void action17_2() {
pData[id].st = P_ENDED;
pData[id].res = P_READ_ONLY;
msgSrc[id][READ_ONLY] = true;
}
/***************************** m is a "RegisterResponse message "************************************/
//1st TLA rule on page-50 in [1]
bool guard18() {
if (msgDest[id][REGISTER_RESPONSE] == true && pData[id].st == P_REGISTERING) return true;
return false;
}
void action18() {
pData[id].st = P_ACTIVE;
}
/************************* m is a "Prepare message" ********************************************/
//3rd TLA rule on page-50 in [1]
bool guard19() {
if ((msgDest[id][PREPARE] == true)
&&
(pData[id].st == P_REGISTERING || pData[id].st == P_ACTIVE)) return true;
return false;
}
void action19() {
pData[id].st = P_PREPARING;
}
//5th TLA rule on page-50 in [1]
bool guard20() {
if ((msgDest[id][PREPARE] == true)
&&
(pData[id].st == P_ENDED &&
((pData[id].res == P_COMMITTED && msgSrc[id][COMMITTED] == true) ||
(pData[id].res == P_ABORTED &&
(msgSrc[id][ABORTED] == true || (tcData.st == TC_ENDED && tcData.res == TC_COMMITTED_RES))) ||
(pData[id].res == P_READ_ONLY && msgSrc[id][READ_ONLY] == true)))) return true;
return false;
}
void action20() {
msgSrc[id][ABORTED] = true;
}
/***************** m is a "Commit" message ***********************************************/
//6th TLA rule on page-50 in [1]
bool guard21() {
if ((msgDest[id][COMMIT] == true)
&&
(pData[id].st == P_PREPARED))
{
return true; }
return false;
}
void action21() {
pData[id].st = P_ENDED;
pData[id].res = P_COMMITTED;
msgSrc[id][COMMITTED] = true;
}
/************************ m is a "Rollback" message*******************************************/
//2nd TLA rule on page-51 in [1]
bool guard22() {
if ((msgDest[id][ROLLBACK] == true)
&&
(pData[id].st == P_REGISTERING || pData[id].st == P_ACTIVE ||
pData[id].st == P_PREPARING || pData[id].st == P_PREPARED)) return true;
return false;
}
void action22() {
pData[id].st = P_ENDED;
pData[id].res = P_ABORTED;
msgSrc[id][ABORTED] = true;
}STARTsystem InitCoor, Participant_T;