public static void initiateElection() throws Exception {
hasElectionHappened = true;
System.out.println("Process " + processId + " is initiating election protocol");
int oldCoordinatorId = coordinatorId;
int newCoordinatorId = (coordinatorId + 1) % (NUM_PARTICIPANTS + 1);
previousCoordinatorId = coordinatorId;
coordinatorId = newCoordinatorId;
System.out.println("removing processes " + oldCoordinatorId);
System.out.println("active processes " + activeProcesses);
activeProcesses.remove((Object) new Integer(oldCoordinatorId));
ThreePhaseCommitUtility.saveActiveProcess(coordinatorId, activeProcesses);
System.out.println("active processes " + activeProcesses);
if (processId == newCoordinatorId) {
System.out.println(
"Process "
+ processId
+ " has selected "
+ newCoordinatorId
+ " as the new co-ordinator");
Message newCood = new Message();
newCood.setProcessId(processId);
newCood.setMessage(NEW_CO_OD);
System.out.println("Process " + processId + " sends NEW_CO_OD message to other participants");
List<Integer> participants = new ArrayList<Integer>(activeProcesses);
for (Integer parts : participants) {
if (parts == oldCoordinatorId) {
continue;
}
if (parts == newCoordinatorId) continue;
System.out.println("Sending the new co-od message to the process " + parts);
netController.sendMsg(parts, ThreePhaseCommitUtility.serializeMessage(newCood));
}
}
System.out.println("Process " + processId + " has ended the election protocol");
}
public static void handleGetDecision(Message msg) throws Exception {
System.out.println("Starting to handle GET_DECISION message");
LogRecord log =
ThreePhaseCommitUtility.fetchRecordForTransaction(processId, msg.getTransactionId());
Message decision = new Message();
decision.setMessage(log.getMessage());
decision.setProcessId(processId);
decision.setTransactionId(log.getTransactionId());
decision.setPlaylistCommand(log.getPlayListCommand());
if (COMMIT.equals(decision.getMessage()) || ABORT.equals(decision.getMessage())) {
netController.sendMsg(msg.getProcessId(), ThreePhaseCommitUtility.serializeMessage(decision));
System.out.println(
"Process " + processId + " has sent a response to a GET_DECISION " + decision);
}
}
public static void handleGetDecision(List<String> msgs) throws Exception {
List<String> toBeRemoved = new ArrayList<String>();
for (String msg : msgs) {
Message m = ThreePhaseCommitUtility.deserializeMessage(msg);
if (GET_DECISION.equals(m.getMessage())) {
handleGetDecision(m);
toBeRemoved.add(msg);
}
}
msgs.removeAll(toBeRemoved);
}
public static void executeCommand(PlaylistCommand playlistCommand) throws IOException {
if ("ADD".equals(playlistCommand.getAction())) {
playList.put(playlistCommand.getSongName(), playlistCommand.getUrl());
} else if ("REMOVE".equals(playlistCommand.getAction())) {
playList.remove(playlistCommand.getSongName());
} else {
if (playList.get(playlistCommand.getSongName()) != null) {
playList.remove(playlistCommand.getSongName());
playList.put(playlistCommand.getSongName(), playlistCommand.getUrl());
} else {
String keyToRemove = null;
for (Entry<String, String> entry : playList.entrySet()) {
if (entry.getValue().equals(playlistCommand.getUrl())) {
keyToRemove = entry.getKey();
break;
}
}
playList.remove(keyToRemove);
playList.put(playlistCommand.getSongName(), playlistCommand.getUrl());
}
}
ThreePhaseCommitUtility.saveLocalState(processId, playList);
}
public static void main(String args[]) {
if (args.length < 3) {
throw new IllegalArgumentException(
"please provide intial co-ordinator id and current process id");
}
try {
String t = null;
if (args.length == 4) t = args[3];
delay = Integer.parseInt(args[2]);
COORDINATOR_TIME_OUT_IN_SECONDS += delay * NUM_PARTICIPANTS;
PARTICIPANT_TIME_OUT_IN_SECONDS += delay * NUM_PARTICIPANTS;
GET_DECISION_TIME_OUT_IN_SECONDS += delay * NUM_PARTICIPANTS;
netController =
new NetController(
new Config("bin/com/tpc/util/" + "config_" + args[1] + ".txt"),
new FaultModel(t),
delay * 1000);
processId = Integer.parseInt(args[1]);
coordinatorId = -1;
String myVote = YES;
activeProcesses = ThreePhaseCommitUtility.getActiveProcess(processId);
System.out.println("active processes list obtained from log is" + activeProcesses);
playList = ThreePhaseCommitUtility.fetchLocalState(processId);
// read the recent log record for any change of state
LogRecord recentLog = ThreePhaseCommitUtility.fetchMessageFromDTLog(processId);
if (recentLog != null) {
System.out.println("Process " + processId + " has the recentLog of " + recentLog);
if (recentLog.getMessage().equals(YES) || recentLog.getMessage().equals(START_3PC)) {
boolean gotDecision = false;
while (!gotDecision) {
List<Integer> participants = new ArrayList<Integer>(activeProcesses);
participants.remove((Object) new Integer(processId));
Message getDecision = new Message();
getDecision.setProcessId(processId);
getDecision.setMessage(GET_DECISION);
getDecision.setTransactionId(recentLog.getTransactionId());
for (Integer partcipant : participants) {
netController.sendMsg(
partcipant, ThreePhaseCommitUtility.serializeMessage(getDecision));
}
System.out.println(
"Process " + processId + " has sent a GET_DECISION message to " + activeProcesses);
List<String> receivedMsgs = new ArrayList<String>();
Timer getDecisionTimer = new Timer(GET_DECISION_TIME_OUT_IN_SECONDS);
getDecisionTimer.start();
while (receivedMsgs.isEmpty() && !getDecisionTimer.hasTimedOut()) {
receivedMsgs.addAll(netController.getReceivedMsgs());
}
System.out.println("Received messages while waiting for decision:" + receivedMsgs);
for (String message : receivedMsgs) {
Message msg = ThreePhaseCommitUtility.deserializeMessage(message);
if (msg.getTransactionId() == recentLog.getTransactionId()
&& (msg.getMessage().equals(COMMIT) || msg.getMessage().equals(ABORT))) {
ThreePhaseCommitUtility.writeMessageToDTLog(
processId,
new LogRecord(
msg.getTransactionId(), msg.getMessage(), msg.getPlaylistCommand()));
gotDecision = true;
if (msg.getMessage().equals(COMMIT)) {
executeCommand(msg.getPlaylistCommand());
}
}
}
}
} else {
canParticipate = true;
}
} else {
coordinatorId = Integer.parseInt(args[0]);
canParticipate = true;
}
int cnt = 0;
// current process is the initial co-ordinator
while (true) {
if (processId == coordinatorId) {
while (ThreePhaseCommitUtility.getPlaylistCommand() != null
&& ThreePhaseCommitUtility.getPlaylistCommand().getAction() != null) {
currentCommand = ThreePhaseCommitUtility.getPlaylistCommand();
cnt++;
Thread.sleep(5000);
System.out.println("current cnt:" + cnt);
currTrans++;
List<Integer> totalParticipants = new ArrayList<Integer>();
System.out.println("reinitializing active processes");
for (int i = 0; i <= NUM_PARTICIPANTS; i++) {
if (i != processId) totalParticipants.add(i);
activeProcesses.add(i);
}
ThreePhaseCommitUtility.saveActiveProcess(processId, activeProcesses);
Message message =
new Message(
processId, currTrans, VOTE_REQ, ThreePhaseCommitUtility.getPlaylistCommand());
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, START_3PC, message.getPlaylistCommand()));
List<Integer> participants = new ArrayList<Integer>(totalParticipants);
System.out.println("starting new transaction!");
participants.remove((Object) new Integer(processId));
// Send VOTE REQ to all participants
System.out.println("sending vote requests!");
for (Integer participant : participants) {
boolean sendStatus =
netController.sendMsg(
participant, ThreePhaseCommitUtility.serializeMessage(message));
if (!sendStatus) {
log.log(Level.INFO, "send to process" + participant + " failed");
}
}
// Get VOTE responses from participants.
Timer timer = new Timer(COORDINATOR_TIME_OUT_IN_SECONDS);
timer.start();
List<String> reportMessages = new ArrayList<String>();
while (reportMessages.size() < totalParticipants.size() && !timer.hasTimedOut()) {
List<String> recMsgs = netController.getReceivedMsgs();
handleGetDecision(recMsgs);
reportMessages.addAll(recMsgs);
}
// some process timed out. aborting
if (timer.hasTimedOut()) {
System.out.println("a few processes timedout. Hence aborting the transaction");
System.out.println("received messages:" + reportMessages);
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, ABORT, currentCommand));
for (String rawMessage : reportMessages) {
Message msg = ThreePhaseCommitUtility.deserializeMessage(rawMessage);
if (msg.getMessage().equals(YES)) {
netController.sendMsg(
msg.getProcessId(),
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, ABORT, currentCommand)));
}
}
continue;
}
// abort if some process sends no.
boolean abortFlag = false;
List<Message> forMessages = new ArrayList<Message>();
List<Message> againstMessages = new ArrayList<Message>();
for (String reportMessage : reportMessages) {
Message msg = ThreePhaseCommitUtility.deserializeMessage(reportMessage);
if (msg.getMessage().equals(NO)) {
System.out.println("process " + msg.getProcessId() + "has decided abort");
abortFlag = true;
} else if (msg.getMessage().equals(YES)) {
System.out.println("process " + msg.getProcessId() + "is ok with commiting");
forMessages.add(msg);
}
}
// some processes have decided to abort. ABORT
if (abortFlag || !myVote.equals(YES)) {
System.out.println("coordinator has decided to abort");
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, ABORT, currentCommand));
for (Message msg : forMessages) {
Message abortMessage = new Message(processId, currTrans, ABORT, currentCommand);
netController.sendMsg(
msg.getProcessId(), ThreePhaseCommitUtility.serializeMessage(abortMessage));
}
}
// all processes have sent yes! COMMIT away
if (!abortFlag && myVote.equals(YES)) {
System.out.println("everyone has sent yes. sending PRE COMMIT");
Message preCommitMessage = new Message(processId, currTrans, PRE_COMMIT);
for (Integer parts : participants) {
netController.sendMsg(
parts, ThreePhaseCommitUtility.serializeMessage(preCommitMessage));
}
List<String> ackMessages = new ArrayList<String>();
Timer ackTimer = new Timer(COORDINATOR_TIME_OUT_IN_SECONDS);
ackTimer.start();
while (ackMessages.size() < activeProcesses.size() - 1 && !ackTimer.hasTimedOut()) {
List<String> recMsgs = netController.getReceivedMsgs();
handleGetDecision(recMsgs);
ackMessages.addAll(recMsgs);
}
// just a simple check. Ideally should never happen.
for (String ackMessage : ackMessages) {
Message ackMsg = ThreePhaseCommitUtility.deserializeMessage(ackMessage);
if (!ackMsg.getMessage().equals("ACK")) {
throw new IllegalStateException("din receive ack");
}
}
// write commit to DT log
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, COMMIT, currentCommand));
executeCommand(currentCommand);
// send COMMIT to everyone
System.out.println("sending commit to everyone!");
for (Integer parts : participants) {
netController.sendMsg(
parts,
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, COMMIT, currentCommand)));
}
ThreePhaseCommitUtility.removeTopPlaylistCommand();
}
}
} else { // current process is a participant.
List<String> receivedMsgs = new ArrayList<String>();
while (processId != coordinatorId) {
Timer timer = new Timer(PARTICIPANT_TIME_OUT_IN_SECONDS);
timer.start();
System.out.println("Process " + processId + " is waiting for some message");
while (receivedMsgs.isEmpty() && !timer.hasTimedOut()) {
receivedMsgs.addAll(netController.getReceivedMsgs());
}
// if time-out has happened
if (timer.hasTimedOut()
&& (participant_waiting_for.equals(COMMIT)
|| participant_waiting_for.equals(PRE_COMMIT)
|| participant_waiting_for.equals(ABORT))) {
System.out.println(
"Process "
+ processId
+ " has encountered a time out and the participant is waiting for "
+ participant_waiting_for);
initiateElection();
System.out.println("active processes" + activeProcesses);
List<Integer> currentActiveParticipants = new ArrayList<Integer>(activeProcesses);
if (coordinatorId == processId) {
// invoke co-ordinator's termination protocol
currentActiveParticipants.remove((Object) new Integer(processId));
coordinatorTerminationProtocol(currentActiveParticipants);
break;
}
}
// if there is some message received
System.out.println("Received messages :" + receivedMsgs);
for (String message : receivedMsgs) {
Message msg = ThreePhaseCommitUtility.deserializeMessage(message);
if (msg.getMessage().equals(VOTE_REQ)) {
// set this as the new co-ordinator
if (msg.getProcessId() != coordinatorId) {
coordinatorId = msg.getProcessId();
}
System.out.println("Process " + processId + " received a vote request");
currTrans = msg.getTransactionId();
currentCommand = msg.getPlaylistCommand();
Message voteYes = new Message();
voteYes.setProcessId(processId);
voteYes.setMessage(YES);
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(msg.getTransactionId(), YES));
netController.sendMsg(
coordinatorId, ThreePhaseCommitUtility.serializeMessage(voteYes));
System.out.println("Process " + processId + " waiting for a pre_commit");
participant_waiting_for = PRE_COMMIT;
canParticipate = true;
my_current_state = YES;
} else if (canParticipate
&& msg.getProcessId() == coordinatorId
&& msg.getMessage().equals(ABORT)
&& currTrans == msg.getTransactionId()) {
ThreePhaseCommitUtility.writeMessageToDTLog(
processId,
new LogRecord(msg.getTransactionId(), ABORT, msg.getPlaylistCommand()));
System.out.println("Process " + processId + " received an abort");
participant_waiting_for = VOTE_REQ;
my_current_state = ABORT;
} else if (canParticipate
&& msg.getProcessId() == coordinatorId
&& msg.getMessage().equals(COMMIT)
&& currTrans == msg.getTransactionId()) {
executeCommand(msg.getPlaylistCommand());
ThreePhaseCommitUtility.writeMessageToDTLog(
processId,
new LogRecord(msg.getTransactionId(), COMMIT, msg.getPlaylistCommand()));
System.out.println("Process " + processId + " received a commit");
participant_waiting_for = VOTE_REQ;
my_current_state = COMMIT;
} else if (canParticipate
&& msg.getProcessId() == coordinatorId
&& msg.getMessage().equals(PRE_COMMIT)
&& currTrans == msg.getTransactionId()) {
System.out.println("Process " + processId + " received a pre-commit");
Message ack = new Message();
ack.setProcessId(processId);
ack.setMessage(ACK);
ack.setTransactionId(currTrans);
netController.sendMsg(coordinatorId, ThreePhaseCommitUtility.serializeMessage(ack));
participant_waiting_for = COMMIT;
my_current_state = PRE_COMMIT;
System.out.println(
"Process "
+ processId
+ " voted with an ACK and waiting for "
+ participant_waiting_for);
// ThreePhaseCommitUtility.writeMessageToDTLog(processId, COMMIT);
} else if (canParticipate && msg.getMessage().equals(NEW_CO_OD)) {
System.out.println(
"Process " + processId + " got a NEW_CO_OD from process " + msg.getProcessId());
if (!hasElectionHappened) {
System.out.println("removing processes " + coordinatorId);
System.out.println("active processes " + activeProcesses);
activeProcesses.remove((Object) new Integer(coordinatorId));
System.out.println("active processes " + activeProcesses);
ThreePhaseCommitUtility.saveActiveProcess(processId, activeProcesses);
hasElectionHappened = false;
}
coordinatorId = msg.getProcessId();
participantTerminationProtocol();
} else if (canParticipate && msg.getMessage().equals(GET_DECISION)) {
System.out.println(
"Process "
+ processId
+ " got a GET_DECISION from process "
+ msg.getProcessId());
activeProcesses.add(msg.getProcessId());
ThreePhaseCommitUtility.saveActiveProcess(coordinatorId, activeProcesses);
handleGetDecision(msg);
}
}
receivedMsgs.clear();
}
}
}
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
public static void coordinatorTerminationProtocol(List<Integer> participants) throws Exception {
int totalParticipants = participants.size();
// send STATE_REQ to all processes.
System.out.println("Starting termination protocol. Co-ordinator is" + processId);
System.out.println("sending state request to" + participants);
for (Integer participant : participants) {
System.out.println("sending state req to :" + participant + "for trans" + currTrans);
netController.sendMsg(
participant,
ThreePhaseCommitUtility.serializeMessage(
new Message(coordinatorId, currTrans, STATE_REQ)));
}
// Wait for all responses or until timeout
Timer stateReqTimer = new Timer(COORDINATOR_TIME_OUT_IN_SECONDS);
stateReqTimer.start();
List<String> stateReqresponses = new ArrayList<String>();
while (stateReqresponses.size() < totalParticipants && !stateReqTimer.hasTimedOut()) {
stateReqresponses.addAll(netController.getReceivedMsgs());
}
// get co-ordinators state.
LogRecord recentLogRecord = ThreePhaseCommitUtility.fetchMessageFromDTLog(processId);
String state = recentLogRecord.getMessage();
boolean abortFlag, uncertainFlag, commitFlag, commitableFlag;
abortFlag = uncertainFlag = commitFlag = false;
abortFlag = state.equals(ABORT);
commitFlag = state.equals(COMMIT);
commitableFlag = my_current_state.equals(PRE_COMMIT);
uncertainFlag = abortFlag == false && commitFlag == false;
System.out.println("parsing participant states..." + stateReqresponses);
// get participant state
List<Integer> uncertainProcesses = new ArrayList<Integer>();
if (!abortFlag && !commitFlag) {
for (String resp : stateReqresponses) {
Message msg = ThreePhaseCommitUtility.deserializeMessage(resp);
if (msg.getMessage().equals(ABORTED)) {
abortFlag = true;
break;
} else if (msg.getMessage().equals(COMMITTED)) {
commitFlag = true;
break;
} else if (msg.getMessage().equals(COMMITTABLE)) {
commitableFlag = true;
} else if (msg.getMessage().equals(UNCERTAIN)) {
uncertainFlag = true;
uncertainProcesses.add(msg.getProcessId());
}
}
}
if (abortFlag) {
System.out.println("deciding to abort!");
if (!state.equals(ABORT)) {
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, ABORT, currentCommand));
}
for (Integer participant : participants) {
netController.sendMsg(
participant,
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, ABORT, currentCommand)));
}
} else if (commitFlag) {
System.out.println("deciding to commit!");
if (!state.equals(COMMIT)) {
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, COMMIT, currentCommand));
executeCommand(currentCommand);
}
for (Integer participant : participants) {
netController.sendMsg(
participant,
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, COMMIT, currentCommand)));
}
ThreePhaseCommitUtility.removeTopPlaylistCommand();
} else if (commitableFlag || COMMIT.equals(participant_waiting_for)) {
System.out.println("commitable, sending pre commit to uncertain processes.");
for (Integer participant : uncertainProcesses) {
netController.sendMsg(
participant,
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, PRE_COMMIT)));
}
Timer ackTimer = new Timer(COORDINATOR_TIME_OUT_IN_SECONDS);
ackTimer.start();
List<String> ackMsgs = new ArrayList<String>();
while (ackMsgs.size() != uncertainProcesses.size() || !ackTimer.hasTimedOut()) {
ackMsgs.addAll(netController.getReceivedMsgs());
}
System.out.println("sending commit to all processes");
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, COMMIT, currentCommand));
ThreePhaseCommitUtility.removeTopPlaylistCommand();
executeCommand(currentCommand);
for (Integer participant : participants) {
netController.sendMsg(
participant,
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, COMMIT, currentCommand)));
}
System.out.println("sent commit to all processes");
} else {
System.out.println("all of em are uncertain. aborting transaction");
if (!state.equals(ABORT)) {
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(currTrans, ABORT, currentCommand));
}
System.out.println("sending abort to" + participants);
for (Integer participant : participants) {
netController.sendMsg(
participant,
ThreePhaseCommitUtility.serializeMessage(
new Message(processId, currTrans, ABORT, currentCommand)));
}
}
System.out.println("completing termination protocol");
}
public static void participantTerminationProtocol() throws Exception {
System.out.println("Process " + processId + " is initiating participant termination protocol");
List<String> receivedMsgs = new ArrayList<String>();
boolean notCommitted = true;
System.out.println("Process " + processId + " is waiting for STATE_REQ");
while (notCommitted && processId != coordinatorId) {
Timer timer = new Timer(PARTICIPANT_TIME_OUT_IN_SECONDS);
timer.start();
while (receivedMsgs.isEmpty() && !timer.hasTimedOut()) {
receivedMsgs.addAll(netController.getReceivedMsgs());
}
// if time-out has happened
if (timer.hasTimedOut() && (participant_waiting_for.equals(STATE_RESP))) {
System.out.println(
"Process " + processId + " has timed out while waiting for response from co-ordinator");
initiateElection();
if (coordinatorId == processId) {
// invoke co-ordinator's termination protocol
List<Integer> participants = new ArrayList<Integer>(activeProcesses);
System.out.println("active processes!" + activeProcesses);
participants.remove((Object) new Integer(processId));
coordinatorTerminationProtocol(participants);
}
}
for (String message : receivedMsgs) {
Message msg = ThreePhaseCommitUtility.deserializeMessage(message);
if (msg.getProcessId() == coordinatorId && msg.getMessage().equals(STATE_REQ)) {
Message state = new Message();
state.setProcessId(processId);
state.setTransactionId(msg.getTransactionId());
System.out.println("msg of process " + processId + " is " + msg);
if (my_current_state.equals(ABORTED)) {
state.setMessage(ABORTED);
} else if (my_current_state.equals(COMMIT)) {
state.setMessage(COMMITTED);
} else if (my_current_state.equals(PRE_COMMIT)) {
state.setMessage(COMMITTABLE);
} else {
state.setMessage(UNCERTAIN);
}
netController.sendMsg(coordinatorId, ThreePhaseCommitUtility.serializeMessage(state));
participant_waiting_for = STATE_RESP;
System.out.println(
"Process " + processId + " sends its current state " + state.getMessage());
} else if (msg.getProcessId() == coordinatorId && msg.getMessage().equals(ABORT)) {
LogRecord myState =
ThreePhaseCommitUtility.fetchRecordForTransaction(processId, msg.getTransactionId());
if (!myState.getMessage().equals(ABORT))
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(msg.getTransactionId(), ABORT, msg.getPlaylistCommand()));
System.out.println(
"Process " + processId + " received abort during the termination protocol");
participant_waiting_for = "";
notCommitted = false;
my_current_state = ABORTED;
} else if (msg.getProcessId() == coordinatorId && msg.getMessage().equals(COMMIT)) {
LogRecord myState =
ThreePhaseCommitUtility.fetchRecordForTransaction(processId, msg.getTransactionId());
if (!myState.getMessage().equals(COMMIT)) {
ThreePhaseCommitUtility.writeMessageToDTLog(
processId, new LogRecord(msg.getTransactionId(), COMMIT, msg.getPlaylistCommand()));
executeCommand(msg.getPlaylistCommand());
}
participant_waiting_for = "";
my_current_state = COMMIT;
System.out.println(
"Process " + processId + " received commit during the termination protocol");
notCommitted = false;
} else if (msg.getMessage().equals(GET_DECISION)) {
System.out.println(
"Process " + processId + " got a GET_DECISION from process " + msg.getProcessId());
handleGetDecision(msg);
} else if (msg.getMessage().equals(PRE_COMMIT)) {
my_current_state = PRE_COMMIT;
Message ack = new Message();
ack.setProcessId(processId);
ack.setMessage(ACK);
netController.sendMsg(coordinatorId, ThreePhaseCommitUtility.serializeMessage(ack));
System.out.println(
"Process "
+ processId
+ " received pre_commit during the termination protocol and has sent ACK");
}
}
receivedMsgs.clear();
}
System.out.println("Process " + processId + " has completed participant termination protocol");
}