Prepare next lecture: Distributed Computing

Author: s-macke

docs/08-Distributed-Programming-Raft.slide

@@ -151,12 +151,15 @@ Requirements and Decisions
 - Design: Timer implementation
 
 * Exercise 8.2: Be Creative!
-- Write your own Raft Implementation!
 
-.link https://github.com/s-macke/concepts-of-programming-languages/blob/master/docs/exercises/Exercise8.md
+Three armies, each led by a general, plan to attack a fortified city. The armies may arrive at different times to surround the city, and none of the generals can be certain whether all the armies will arrive at all. Consequently, they have not appointed a single leader.
+For the attack to succeed, at least two armies must strike simultaneously. Therefore, the generals need to coordinate and agree on a precise time to launch the attack.
+To achieve this, they decide to use a simplified version of the Raft algorithm.
 
 - Write your own Raft Implementation!
 
+.link https://github.com/s-macke/concepts-of-programming-languages/blob/master/docs/exercises/Exercise8.md
+
 * Summary
 - Go is an excellent choice to implement an distributed protocol like Raft
 - You can implement the Raft specification with ca 1000-2000 Loc 

docs/exercises/Exercise8.md

@@ -16,7 +16,7 @@ Three armies, each led by a general, plan to attack a fortified city. The armies
 For the attack to succeed, at least two armies must strike simultaneously. Therefore, the generals need to coordinate and agree on a precise time to launch the attack.
 To achieve this, they decide to use a simplified version of the Raft algorithm.
 
-In the following, we will represent the armies as nodes and facilitate communication between them using REST.
+In the following, we will represent the armies as nodes and facilitate communication between them using REST APIs.
 
 ### Define list of servers (nodes)
 
@@ -35,7 +35,7 @@ var nodePortList = []string{
 On start of the program the node id should be read as argument from the console.
 ```raft --node 0```
 
-Use the `flag` package to read the arguments.
+Use the `flag` [package](https://pkg.go.dev/flag) to read the arguments.
 
 ### State
 
@@ -45,47 +45,50 @@ Define an [enum](https://gobyexample.com/enums] containin) for the node state
 * Candidate
 * Leader
 
-Implement the [stringer](https://go.dev/tour/methods/17) interface for the enum.
 Write a function to switch the state of the node.
 It should apply the following rules, otherwise stop the program.
 
 * A leader can never change
-* A candidate can only change to leader or follower
-* A follower can only change to candidate
+* A candidate can only change to a leader or follower
+* A follower can only change to a candidate
 
-For now, node 0 start as the leader, the others as followers.
+For now, node 0 starts as a leader, the others as followers.
 
 ### Attack Endpoint
 
-Implement an "attack" endpoint and start an asynchronous running server on the port defined by the port list.
-The attack endpoint receives the time of the attack as string, prints the attack time on screen and returns a 200 status code.
+Implement an "attack" endpoint and start the server on the port defined by the port list.
+The "attack" endpoint uses the REST Method POST, receives the time of the attack as string, prints the attack time on screen and returns a 200 status code.
 You can test it via curl, httpie or wget.
 
 ```
 curl -X POST http://localhost:10000/attack -d "midnight"
 ```
 
-After a few seconds (e. g. 30 seconds) the leader should send an attack request to the other nodes to attack at the same time.
+If the node is the leader: After a few seconds (e.g. 30 seconds) the leader should send an attack request to the other nodes to attack at the same time.
 Only when the leader receives an OK response from at least one other node, the attack is successful.
 
-Optional task: You can send a commit message to the followers to confirm the attack.
+Optional task: You can send a commit message to the followers to confirm the attack. You just have to implement a commit endpoint.
 
-### Heartbeat Endpoint
+### Simplified Heartbeat Endpoint
 
-Implement the heartbeat mechanism.
-Implement a heartbeat endpoint. It should just return a 200 status code.
-Only the leader should send a heartbeat to the other nodes in intervals of 1 second.
+Implement the heartbeat mechanism. Implement a heartbeat endpoint via a GET method. It should just return a 200 status code and turn the node into a follower.
+The leader node should send a heartbeat to the other nodes in intervals of 1 second.
+
+### Simplified Vote Endpoint
+
+Implement a vote endpoint. 
+The vote endpoint uses the REST Method GET.
+If the node is the leader, it should return "no" to the other nodes, otherwise "yes" and turn into a "follower".
 
 ### Simplified Leader Election
 
-From now on all nodes start from the follower state. No one is the leader
+From now on all nodes start from the follower state. No one is the leader.
 
-- The nodes wait for heartbeats from the leader. E.g. for two seconds.
+- The nodes wait for heartbeats from the leader. E.g. for two seconds.(Example via the time.After function: [heartbeat.go](../../src/distributed/byzantine/heartbeat.go))
 - Because there is no leader, the nodes become candidates and start an election. 
-- The nodes wait for a random time between 1 and 5 seconds and start a voting process.
-- for the voting they send a request to all other nodes.
-- The nodes vote for the candidate and become followers.
-- If an heartbeat is received, the nodes become followers as well and the voting stops.
+- The nodes wait for a random time between 1 and 3 seconds and start a voting process.
+- For the voting they send a request to all other nodes to the voting endpoint.
+- If they receive a majority of "yes" votes, they become the leader and start the heartbeats.
 
 **Examples:**