Logic For Processing Pending Justifications.
Introduction
In a distributed system, justifications are used to validate the state of the network. When a node receives a justification or a result from a justification request, it needs to process it accordingly. However, there are situations where the justification is not ready to be processed immediately, and it needs to be added to a pending list. In this article, we will discuss the logic for processing pending justifications, which is crucial for maintaining the health and consistency of the network.
Understanding Pending Justifications
When a node receives a justification or a result from a justification request, it needs to determine whether the justification is ready to be processed or not. If the justification is ready, it can be finalized and processed immediately. However, if it's not ready, it needs to be added to a pending list. The pending list is a collection of justifications that are waiting to be processed.
Implementing the Pending Justification Map
To implement the pending justification map, we need to add a collection of justifications inside the BeefyService class. This collection will hold the pending justifications that need to be processed. The pending justification map will be used to store the justifications that are waiting to be processed.
public class BeefyService {
// ...
private Map<String, Justification> pendingJustifications = new HashMap<>();
// ...
}
Determining Stale, Future, and Processable Justifications
Before starting a beefy voting process, we need to determine which of the pending justifications are stale, future, and processable. This can be done by checking the current round range and comparing it with the round range of each pending justification.
public void processPendingJustifications() {
// Get the current round range
int currentRoundRange = getRoundRange();
// Iterate over the pending justifications
for (Map.Entry<String, Justification> entry : pendingJustifications.entrySet()) {
Justification justification = entry.getValue();
// Check if the justification is stale
if (justification.getRoundRange() < currentRoundRange - 1) {
// Remove the stale justification from the pending list
pendingJustifications.remove(entry.getKey());
}
// Check if the justification is future
else if (justification.getRoundRange() > currentRoundRange + 1) {
// Remove the future justification from the pending list
pendingJustifications.remove(entry.getKey());
}
// Check if the justification is processable
else if (justification.getRoundRange() == currentRoundRange) {
// Finalize the processable justification
finalizeJustification(justification);
}
}
}
Finalizing Processable Justifications
Once we have determined which justifications are processable, we need to finalize them. Finalizing a justification means that it is ready to be processed and can be used to validate the state of the network.
public void finalizeJustification(Justification justification) {
// Update the justification's status to finalized
justification.setStatus(JustificationStatus.FINALIZED);
// Remove the justification from the pending list
pendingJustifications.remove(justification.getRoundRange());
}
Conclusion
In this article, we discussed the logic for processing pending justifications in a distributed system. We implemented a pending justification map to store the justifications that are waiting to be processed and developed a method to determine which justifications are stale, future, and processable. We also finalized the processable justifications to ensure that they are ready to be processed and can be used to validate the state of the network. By following this logic, we can maintain the health and consistency of the network and ensure that the justifications are processed correctly.
Future Work
In the future, we can improve the logic for processing pending justifications by adding more features, such as:
- Implementing a timeout mechanism to remove stale justifications from the pending list
- Adding a mechanism to handle duplicate justifications
- Developing a method to handle justifications that are not processable
By improving the logic for processing pending justifications, we can further enhance the health and consistency of the network and ensure that the justifications are processed correctly.
References
- [1] Beefy Service Documentation
- [2] Justification Protocol Specification
Appendix
The following is a sample implementation of the BeefyService class:
public class BeefyService {
// ...
private Map<String, Justification> pendingJustifications = new HashMap<>();
public void processPendingJustifications() {
// Get the current round range
int currentRoundRange = getRoundRange();
// Iterate over the pending justifications
for (Map.Entry<String, Justification> entry : pendingJustifications.entrySet()) {
Justification justification = entry.getValue();
// Check if the justification is stale
if (justification.getRoundRange() < currentRoundRange - 1) {
// Remove the stale justification from the pending list
pendingJustifications.remove(entry.getKey());
}
// Check if the justification is future
else if (justification.getRoundRange() > currentRoundRange + 1) {
// Remove the future justification from the pending list
pendingJustifications.remove(entry.getKey());
}
// Check if the justification is processable
else if (justification.getRoundRange() == currentRoundRange) {
// Finalize the processable justification
finalizeJustification(justification);
}
}
}
public void finalizeJustification(Justification justification) {
// Update the justification's status to finalized
justification.setStatus(JustificationStatus.FINALIZED);
// Remove the justification from the pending list
pendingJustifications.remove(justification.getRoundRange());
}
}
Introduction
In our previous article, we discussed the logic for processing pending justifications in a distributed system. We implemented a pending justification map to store the justifications that are waiting to be processed and developed a method to determine which justifications are stale, future, and processable. We also finalized the processable justifications to ensure that they are ready to be processed and can be used to validate the state of the network. In this article, we will answer some frequently asked questions about the logic for processing pending justifications.
Q: What is the purpose of the pending justification map?
A: The pending justification map is used to store the justifications that are waiting to be processed. It allows us to keep track of the justifications that are pending and to determine which ones are stale, future, and processable.
Q: How do you determine which justifications are stale, future, and processable?
A: We determine which justifications are stale, future, and processable by checking the current round range and comparing it with the round range of each pending justification. If the justification's round range is less than the current round range minus one, it is considered stale. If the justification's round range is greater than the current round range plus one, it is considered future. If the justification's round range is equal to the current round range, it is considered processable.
Q: What happens to a justification that is stale or future?
A: A justification that is stale or future is removed from the pending list. This is because stale and future justifications are no longer relevant and can be discarded.
Q: What happens to a justification that is processable?
A: A justification that is processable is finalized. This means that it is ready to be processed and can be used to validate the state of the network.
Q: Can you provide an example of how the pending justification map is used?
A: Here is an example of how the pending justification map is used:
Suppose we have a pending justification map that contains the following justifications:
| Round Range | Justification |
|---|---|
| 10 | Justification 1 |
| 12 | Justification 2 |
| 15 | Justification 3 |
The current round range is 11. We would iterate over the pending justifications and determine which ones are stale, future, and processable. In this case, Justification 1 is stale, Justification 2 is future, and Justification 3 is processable. We would remove Justification 1 and Justification 2 from the pending list and finalize Justification 3.
Q: How does the pending justification map handle duplicate justifications?
A: The pending justification map handles duplicate justifications by removing the duplicate justification from the pending list. This is because duplicate justifications are not necessary and can be discarded.
Q: Can you provide an example of how the pending justification map handles duplicate justifications?
A: Here is an example of how the pending justification map handles duplicate justifications:
Suppose we have a pending justification map that contains the following justifications:
| Round Range | Justification |
|---|---|
| 10 | Justification 1 |
| 10 | Justification 1 (duplicate) |
The pending justification map would remove the duplicate justification from the pending list, leaving only one instance of Justification 1.
Q: How does the pending justification map handle justifications that are not processable?
A: The pending justification map handles justifications that are not processable by leaving them in the pending list. This is because justifications that are not processable are still relevant and need to be processed at a later time.
Q: Can you provide an example of how the pending justification map handles justifications that are not processable?
A: Here is an example of how the pending justification map handles justifications that are not processable:
Suppose we have a pending justification map that contains the following justifications:
| Round Range | Justification |
|---|---|
| 10 | Justification 1 |
| 12 | Justification 2 |
The current round range is 11. We would iterate over the pending justifications and determine which ones are stale, future, and processable. In this case, Justification 1 is processable, but Justification 2 is not. We would finalize Justification 1 and leave Justification 2 in the pending list.
Conclusion
In this article, we answered some frequently asked questions about the logic for processing pending justifications. We discussed how the pending justification map is used to store the justifications that are waiting to be processed, how to determine which justifications are stale, future, and processable, and how to handle duplicate and non-processable justifications. By understanding how the pending justification map works, we can ensure that our distributed system is functioning correctly and efficiently.