Implement Echo Service with Proper Acknowledgment - The Messenger

                      TASK
                    

Implementation

The echo workload is the simplest Maelstrom workload. Clients send echo messages containing a value, and your node must echo that value back.

Request format:

{
  "type": "echo",
  "msg_id": 1,
  "echo": "Please echo 35"
}

Expected response:

{
  "type": "echo_ok",
  "msg_id": 1,
  "in_reply_to": 1,
  "echo": "Please echo 35"
}

Combine your init handling from the previous task with a new echo handler. Your node should handle both message types.

Sample Test Cases

Echo responseTimeout: 5000ms

Input

{"src":"c0","dest":"n1","body":{"type":"init","msg_id":1,"node_id":"n1","node_ids":["n1"]}}
{"src":"c1","dest":"n1","body":{"type":"echo","msg_id":2,"echo":"hello"}}

Expected Output

{"src": "n1", "dest": "c0", "body": {"type": "init_ok", "in_reply_to": 1, "msg_id": 0}}
{"src": "n1", "dest": "c1", "body": {"type": "echo_ok", "echo": "hello", "in_reply_to": 2, "msg_id": 1}}

Hints

Hint 1▾

Echo messages contain an "echo" field with the value to echo back

Hint 2▾

Response type is "echo_ok"

Hint 3▾

Include the original echo value in your response

Resources

Echo Workload

Fly.io Gossip Glomers Echo challenge walkthrough

                      OVERVIEW
                    

Theoretical Hub

Remote Procedure Calls (RPC)

Echo is the simplest form of RPC: a client sends a request and expects a response. While trivial, this pattern forms the basis of all distributed communication.

The Request-Response Pattern

Complex systems like Raft are built from many request-response interactions:

Client                          Server
  |                               |
  |------- Request (echo) ------->|
  |                               |
  |<------ Response (echo_ok) ----|
  |                               |

Handler Dispatch

Your node needs to dispatch messages to appropriate handlers based on type. This is a pattern you will use throughout:

Examine the message type field
Route to the correct handler function
Generate and send the appropriate response

Pseudocode

for each message from stdin:
    parse JSON
    switch message.body.type:
        case "init":
            store node_id and node_ids
            reply with init_ok
        case "echo":
            reply with echo_ok containing the echo value
        default:
            log unknown message type

Idempotency

Echo is naturally idempotent - calling it multiple times with the same input produces the same output. This property is valuable in distributed systems where messages may be retried.

Key Concepts

RPCrequest-responsemessage handling

main.py

python

#!/usr/bin/env python3
import sys
import json
class Node:
    def __init__(self):
        self.node_id = None
        self.node_ids = []
        self.next_msg_id = 0
    
    def send(self, dest, body):
        body["msg_id"] = self.next_msg_id
        self.next_msg_id += 1
        message = {"src": self.node_id, "dest": dest, "body": body}
        print(json.dumps(message), flush=True)
    
    def reply(self, request, body):
        body["in_reply_to"] = request["body"]["msg_id"]
        self.send(request["src"], body)
def main():
    node = Node()
    
    for line in sys.stdin:
        message = json.loads(line)
        body = message["body"]
        msg_type = body["type"]
        
        if msg_type == "init":
            node.node_id = body["node_id"]
            node.node_ids = body["node_ids"]
            node.reply(message, {"type": "init_ok"})
        elif msg_type == "echo":
            # TODO: Handle echo message
            # Reply with echo_ok containing the same echo value
            pass
if __name__ == "__main__":
    main()