@Override
public synchronized boolean handleStartElectionRequest(L2StateMessage msg) {
Assert.assertEquals(L2StateMessage.START_ELECTION, msg.getType());
if (state == ELECTION_IN_PROGRESS
&& (myVote.isANewCandidate() || !msg.getEnrollment().isANewCandidate())) {
// Another node is also joining in the election process, Cast its vote and notify my vote
// Note : WE dont want to do this for new candidates when we are not new.
Enrollment vote = msg.getEnrollment();
Enrollment old = votes.put(vote.getNodeID(), vote);
boolean sendResponse = msg.inResponseTo().isNull();
if (old != null && !vote.equals(old)) {
logger.warn(
"Received duplicate vote : Replacing with new one : " + vote + " old one : " + old);
sendResponse = true;
}
if (sendResponse) {
// This is either not a response to this node initiating election or a duplicate vote.
// Either case notify this
// nodes vote
L2StateMessage response = createElectionStartedMessage(msg, myVote);
logger.info("Casted vote from " + msg + " My Response : " + response);
try {
groupManager.sendTo(msg.messageFrom(), response);
} catch (GroupException e) {
logger.error("Error sending Votes to : " + msg.messageFrom(), e);
}
} else {
logger.info("Casted vote from " + msg);
}
return true;
} else {
logger.info("Ignoring Start Election Request : " + msg + " My state = " + state);
return false;
}
}
public boolean isObserver() {
for (Enrollment enrollment : enrollments) {
if (enrollment.isObserver()) {
return true;
}
}
return false;
}
public boolean isStudent() {
for (Enrollment enrollment : enrollments) {
if (enrollment.isStudent()) {
return true;
}
}
return false;
}
private Enrollment countVotes() {
Enrollment computedWinner = null;
for (Enrollment e : votes.values()) {
if (computedWinner == null) {
computedWinner = e;
} else if (e.wins(computedWinner)) {
computedWinner = e;
}
}
Assert.assertNotNull(computedWinner);
return computedWinner;
}
public String getFinalGrade() {
if (!checkedFinalGrade) {
checkedFinalGrade = true;
for (Enrollment enrollment : enrollments) {
if (enrollment.isStudent()) {
finalGrade = enrollment.getFinalGrade();
}
}
}
return finalGrade;
}
public double getFinalScore() {
if (finalScore == null) {
for (Enrollment enrollment : enrollments) {
if (enrollment.isStudent()) {
finalScore = enrollment.getFinalScore();
return finalScore;
}
}
finalScore = 0.0;
}
return finalScore;
}
public String getCurrentGrade() {
if (!checkedCurrentGrade) {
checkedCurrentGrade = true;
for (Enrollment enrollment : enrollments) {
if (enrollment.isStudent()) {
currentGrade = enrollment.getCurrentGrade();
return currentGrade;
}
}
}
return currentGrade;
}
public double getCurrentScore() {
if (currentScore == null) {
for (Enrollment enrollment : enrollments) {
if (enrollment.isStudent()) {
currentScore = enrollment.getCurrentScore();
return currentScore;
}
}
currentScore = 0.0;
}
return currentScore;
}
public boolean isTA() {
if (enrollments == null) {
return false;
}
for (Enrollment enrollment : enrollments) {
if (enrollment.isTA()) {
return true;
}
}
return false;
}
private NodeID doElection(NodeID myNodeId, boolean isNew, WeightGeneratorFactory weightsFactory)
throws GroupException, InterruptedException {
// Step 1: publish to cluster NodeID, weight and election start
Enrollment e = EnrollmentFactory.createEnrollment(myNodeId, isNew, weightsFactory);
electionStarted(e);
L2StateMessage msg = createElectionStartedMessage(e);
debugInfo("Sending my election vote to all members");
groupManager.sendAll(msg);
// Step 2: Wait for election completion
waitTillElectionComplete();
// Step 3: Compute Winner
Enrollment lWinner = computeResult();
if (lWinner != e) {
logger.info("Election lost : Winner is : " + lWinner);
Assert.assertNotNull(lWinner);
return lWinner.getNodeID();
}
// Step 4 : local host won the election, so notify world for acceptance
msg = createElectionResultMessage(e);
debugInfo("Won election, announcing to world and waiting for response...");
GroupResponse<L2StateMessage> responses = groupManager.sendAllAndWaitForResponse(msg);
for (L2StateMessage response : responses.getResponses()) {
Assert.assertEquals(msg.getMessageID(), response.inResponseTo());
if (response.getType() == L2StateMessage.RESULT_AGREED) {
Assert.assertEquals(e, response.getEnrollment());
} else if (response.getType() == L2StateMessage.RESULT_CONFLICT) {
logger.info(
"Result Conflict: Local Result : "
+ e
+ " From : "
+ response.messageFrom()
+ " Result : "
+ response.getEnrollment());
return ServerID.NULL_ID;
} else {
throw new AssertionError(
"Node : "
+ response.messageFrom()
+ " responded neither with RESULT_AGREED or RESULT_CONFLICT :"
+ response);
}
}
// Step 5 : result agreed - I am the winner
return myNodeId;
}
@Test
public void shouldFulfillAMilestoneAndAlertsForTheOneDueNext() {
LocalDate enrollmentDate = LocalDate.now().minusWeeks(16);
LocalDate firstFulfillmentDate = LocalDate.now().minusWeeks(3);
Enrollment enrollment = schedule.newEnrollment("External ID", enrollmentDate);
String nextMilestone = enrollment.fulfillMilestone(schedule, firstFulfillmentDate);
assertThat(nextMilestone, is(equalTo("IPTI 2")));
List<Alert> alerts = enrollment.getAlerts(schedule);
assertThat(alerts.size(), is(equalTo(1)));
Alert alert = alerts.get(0);
assertThat(alert.windowName(), is(equalTo(WindowName.Due)));
Map<String, String> data = alert.data();
assertThat(data.get("doo"), is(equalTo("Bar")));
}
/** This method is called by the winner of the election to announce to the world */
@Override
public synchronized void declareWinner(NodeID myNodeId) {
Assert.assertEquals(winner.getNodeID(), myNodeId);
L2StateMessage msg = createElectionWonMessage(this.winner);
debugInfo("Announcing as winner: " + myNodeId);
this.groupManager.sendAll(msg);
logger.info("Declared as Winner: Winner is : " + this.winner);
reset(winner);
}
private synchronized void handleElectionWonMessage(L2StateMessage clusterMsg) {
debugInfo("Received election_won or election_already_won msg: " + clusterMsg);
Enrollment winningEnrollment = clusterMsg.getEnrollment();
if (state == ACTIVE_COORDINATOR) {
// Can't get Election Won from another node : Split brain
String error =
state
+ " Received Election Won Msg : "
+ clusterMsg
+ ". A Terracotta server tried to join the mirror group as a second ACTIVE";
logger.error(error);
if (clusterMsg.getType() == L2StateMessage.ELECTION_WON_ALREADY) {
sendNGResponse(clusterMsg.messageFrom(), clusterMsg);
}
groupManager.zapNode(
winningEnrollment.getNodeID(), L2HAZapNodeRequestProcessor.SPLIT_BRAIN, error);
} else if (activeNode.isNull()
|| activeNode.equals(winningEnrollment.getNodeID())
|| clusterMsg.getType() == L2StateMessage.ELECTION_WON) {
// There is no active server for this node or the other node just detected a failure of ACTIVE
// server and ran an
// election and is sending the results. This can happen if this node for some reason is not
// able to detect that
// the active is down but the other node did. Go with the new active.
setActiveNodeID(winningEnrollment.getNodeID());
moveToPassiveState(winningEnrollment);
if (clusterMsg.getType() == L2StateMessage.ELECTION_WON_ALREADY) {
sendOKResponse(clusterMsg.messageFrom(), clusterMsg);
}
} else {
// This is done to solve DEV-1532. Node sent ELECTION_WON_ALREADY message but our ACTIVE is
// intact.
logger.warn(
"Conflicting Election Won Msg : "
+ clusterMsg
+ " since I already have a ACTIVE Node : "
+ activeNode
+ ". Sending NG response");
// The reason we send a response for ELECTION_WON_ALREADY message is that if we don't agree we
// don't want the
// other server to send us cluster state messages.
sendNGResponse(clusterMsg.messageFrom(), clusterMsg);
}
}
private synchronized void electionStarted(Enrollment e) {
if (this.state == ELECTION_IN_PROGRESS) {
throw new AssertionError("Election Already in Progress");
}
this.state = ELECTION_IN_PROGRESS;
this.myVote = e;
this.winner = null;
this.votes.clear();
this.votes.put(e.getNodeID(), e); // Cast my vote
logger.info("Election Started : " + e);
}
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals(ACT_VERIFICATION)) {
try {
this.m_collection = UareUGlobal.GetReaderCollection();
m_collection.GetReaders();
} catch (UareUException e1) {
// TODO Auto-generated catch block
JOptionPane.showMessageDialog(null, "Error getting collection");
return;
}
if (m_collection.size() == 0) {
MessageBox.Warning("Reader is not selected");
return;
}
m_reader = m_collection.get(0);
if (null == m_reader) {
MessageBox.Warning("Reader is not selected");
} else {
Verification.Run(m_reader, this.enrollmentFMD);
}
} else if (e.getActionCommand().equals(ACT_ENROLLMENT)) {
try {
this.m_collection = UareUGlobal.GetReaderCollection();
m_collection.GetReaders();
} catch (UareUException e1) {
// TODO Auto-generated catch block
JOptionPane.showMessageDialog(null, "Error getting collection");
return;
}
if (m_collection.size() == 0) {
MessageBox.Warning("Reader is not selected");
return;
}
m_reader = m_collection.get(0);
if (null == m_reader) {
MessageBox.Warning("Reader is not selected");
} else {
this.enrollmentFMD = Enrollment.Run(m_reader, "1234");
}
} else if (e.getActionCommand().equals(ACT_EXIT)) {
m_dlgParent.setVisible(false);
}
}
public void gotoEnrollment(String barcode) {
try {
m_collection = UareUGlobal.GetReaderCollection();
m_collection.GetReaders();
} catch (UareUException e1) {
// TODO Auto-generated catch block
JOptionPane.showMessageDialog(null, "Error getting collection");
return;
}
if (m_collection.size() == 0) {
MessageBox.Warning("Reader is not selected");
return;
}
m_reader = m_collection.get(0);
if (null == m_reader) {
MessageBox.Warning("Reader is not selected");
} else {
this.enrollmentFMD = Enrollment.Run(m_reader, barcode);
}
}
@Test
public void test() throws Exception {
// Create Course instances and add to ArrayList
Course c1 = new Course(UUID.randomUUID(), "Chemistry", 4, eMajor.CHEM);
Course c2 = new Course(UUID.randomUUID(), "Math", 4, eMajor.BUSINESS);
Course c3 = new Course(UUID.randomUUID(), "Computer Science", 4, eMajor.COMPSI);
ArrayList<Course> courses = new ArrayList<Course>();
courses.add(c1);
courses.add(c2);
courses.add(c3);
// Create Semester instances and add to ArrayList
Semester fall = new Semester(UUID.randomUUID(), new Date(), new Date());
Semester spring = new Semester(UUID.randomUUID(), new Date(), new Date());
ArrayList<Semester> semesters = new ArrayList<Semester>();
semesters.add(fall);
semesters.add(spring);
// Create Section instances and add to ArrayList
UUID secID1 = UUID.randomUUID();
UUID secID2 = UUID.randomUUID();
UUID secID3 = UUID.randomUUID();
UUID secID4 = UUID.randomUUID();
UUID secID5 = UUID.randomUUID();
UUID secID6 = UUID.randomUUID();
Section falls1 = new Section(c1.getCourseID(), fall.getSemesterID(), secID1, 200);
Section falls2 = new Section(c2.getCourseID(), fall.getSemesterID(), secID2, 200);
Section falls3 = new Section(c3.getCourseID(), fall.getSemesterID(), secID3, 200);
Section spring1 = new Section(c1.getCourseID(), spring.getSemesterID(), secID4, 200);
Section spring2 = new Section(c2.getCourseID(), spring.getSemesterID(), secID5, 200);
Section spring3 = new Section(c3.getCourseID(), spring.getSemesterID(), secID6, 200);
ArrayList<Section> sections = new ArrayList<Section>();
sections.add(falls1);
sections.add(falls2);
sections.add(falls3);
sections.add(spring1);
sections.add(spring2);
sections.add(spring3);
// Create Student instances and add to ArrayList
Student s1 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s2 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s3 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s4 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s5 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s6 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s7 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s8 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s9 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
Student s10 =
new Student(
"Bob",
"Ex",
"Example",
new Date(),
eMajor.BUSINESS,
"10 Example Street",
"(302)-444-5555",
"*****@*****.**",
UUID.randomUUID());
ArrayList<Student> students = new ArrayList<Student>();
students.add(s1);
students.add(s2);
students.add(s3);
students.add(s4);
students.add(s5);
students.add(s6);
students.add(s7);
students.add(s8);
students.add(s9);
students.add(s10);
// Create ArrayList for Enrollment instances
ArrayList<Enrollment> enrollments = new ArrayList<Enrollment>();
// Create the 60 instances of Enrollment
for (Student stu : students) {
for (Section sec : sections) {
enrollments.add(new Enrollment(stu.getStudentID(), sec.getSectionID()));
}
}
// Set all the grades
for (Enrollment en : enrollments) {
en.setGrade(4);
}
// Calculate GPAs
double gpa1 = 0;
double gpa2 = 0;
double gpa3 = 0;
double gpa4 = 0;
double gpa5 = 0;
double gpa6 = 0;
double gpa7 = 0;
double gpa8 = 0;
double gpa9 = 0;
double gpa10 = 0;
double sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s1.getStudentID()) {
sum += en.getGrade();
}
gpa1 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s2.getStudentID()) {
sum += en.getGrade();
}
gpa2 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s3.getStudentID()) {
sum += en.getGrade();
}
gpa3 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s4.getStudentID()) {
sum += en.getGrade();
}
gpa4 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s5.getStudentID()) {
sum += en.getGrade();
}
gpa5 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s6.getStudentID()) {
sum += en.getGrade();
}
gpa6 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s7.getStudentID()) {
sum += en.getGrade();
}
gpa7 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s8.getStudentID()) {
sum += en.getGrade();
}
gpa8 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s9.getStudentID()) {
sum += en.getGrade();
}
gpa9 = sum / 6;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getStudentID() == s10.getStudentID()) {
sum += en.getGrade();
}
gpa10 = sum / 6;
}
// Test if the GPAs were correctly calculated
assertTrue(gpa1 == 4);
assertTrue(gpa2 == 4);
assertTrue(gpa3 == 4);
assertTrue(gpa4 == 4);
assertTrue(gpa5 == 4);
assertTrue(gpa6 == 4);
assertTrue(gpa7 == 4);
assertTrue(gpa8 == 4);
assertTrue(gpa9 == 4);
assertTrue(gpa10 == 4);
// Calculate average course grades
double ave1 = 0;
double ave2 = 0;
double ave3 = 0;
sum = 0;
for (Enrollment en : enrollments) {
if (en.getSectionID() == secID1 || en.getStudentID() == secID4) {
sum += en.getGrade();
}
ave1 = sum / 10;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getSectionID() == secID2 || en.getStudentID() == secID5) {
sum += en.getGrade();
}
ave2 = sum / 10;
}
sum = 0;
for (Enrollment en : enrollments) {
if (en.getSectionID() == secID3 || en.getStudentID() == secID6) {
sum += en.getGrade();
}
ave3 = sum / 10;
}
// Test if course averages were correctly calculated
assertTrue(ave1 == 4);
assertTrue(ave2 == 4);
assertTrue(ave3 == 4);
// Attempt to change a student's major
s1.setMajor(eMajor.CHEM);
assertTrue(s1.getMajor() == eMajor.CHEM);
}
private List<Alert> enrollAndGetAlerts(int numberOfWeeksSinceEnrollment) {
LocalDate fewWeeksAgo = LocalDate.now().minusWeeks(numberOfWeeksSinceEnrollment);
Enrollment enrollment = schedule.newEnrollment("External ID", fewWeeksAgo);
return enrollment.getAlerts(schedule);
}
