Page History

How it works:

1. The upstream tasks will send out control message to all the downstream intermediate topic partition. The control message will be serialized and sent out with user messages in the same stream.

2. Downstream Samza processor will consume the intermediate streams, and deserialize both user messages and control messages in SystemConsumers.

3. The control messages will be reconciled based on the count from all the producers (tasks) from the upstream. See below for more details of different control message reconsiliation. 

Intermediate Stream Message Format:

The format of the intermediate stream message:

IntermediateMessage =>  [MessageType MessageData]
  MessageType => byte
  MessageData => byte[]

  MessageType => [0(UserMessage), 1(Watermark), 2(EndOfStream)]
  MessageData => [UserMessage/ControlMessage]
  ControlMessage => [EndOfStreamMessage/WatermarkMessage]
     Version => int
     TaskName => String
     TaskCount => int
     Other Message Data (based on different types of control message) 

For user message, we will use the user provided serde (default is the system serde). For control message, we will use JSON serde since it is built in Samza and easy to parse.

Reconciliation

The reconciliation of control messages happens inside TaskInstance after the message is delivered to it from the chooser.  For the scope of this proposal, we support two kinds of control messages: end-of-stream and watermark. 

• End-of-stream Message: This message contains a streamId that indicate the upstream task has been consumed to the end. ended producing to this stream.
• Watermark Message: This message contains a timestamp of the upstream task has processed so far. The downstream Samza processor counts the number of upstream tasks it receives the messages from. Once the task count matches the total count, the downstream Samza processor will emit a watermark with the earliest timestamp across all the upstream tasks.

The reconciliation process works as follows:

1. The downstream TaskInstance receives the control message, and update the internal bookkeeping of the messages. For end-of-stream, it keeps the set of upstream tasks for the intermediate stream. For watermark, it keeps the mapping from task to its latest timestamp.

2. Once the task count in the bookkeeping matches the total count, the TaskInstance will emit a single IncomingMessageEnvelope containing the intermediate stream and partition, and the message itself. The timestamp in the watermark message will be: 

   InputWatermark = min { OutputWatermark(task) for each task in upstream tasks }

3. After reconsiliation, the control message evelope will be sent to the task to process.
   

The TaskInstance uses the following maps for bookkeeping received end-of-stream and watermark messages:

EndOfStream Bookkeeping: Map( streamId -> { Set<TaskName>, totalTasks } )
 
Watermark Bookkeeping: Map( streamId -> { Map<TaskName, Timestamp>, totalTasks, timestampOfLastEmission } )

Checkpoint control messages

For failure scenario, we need to keep the state of bookkeeping so we can restore it during recovery. This can be done by checkpointing the bookkeeping states with the input messages offset. The checkpoint for EndOfStream message:

EndOfStreamCheckpoint =>
 streamId => String
 totalTasks => int
 tasks => Set<String>

The checkpoint for end-of-stream is:

WatermarkCheckpoint =>
 streamId => String
 totalTasks => int
 tasksToEventTime => Map<String, Long>

Detail details

public abstract class ControlMessage {
  private final String taskName;
  private final int taskCount;
  private int version = 1;

  public ControlMessage(String taskName, int taskCount) {
    this.taskName = taskName;
    this.taskCount = taskCount;
  }

  public String getTaskName() {
    return taskName;
  }

  public int getTaskCount() {
    return taskCount;
  }

  public void setVersion(int version) {
    this.version = version;
  }

  public int getVersion() {
    return version;
  }  
}
 
public class EndOfStreamMessage extends ControlMessage{
 private final String streamId;

 private EndOfStreamMessage(String streamId, String taskName, int taskCount) {
   super(taskName, taskCount);
   this.streamId = streamId;
 }

 public String getStreamId() {
   return streamId;
 }
}

public class WatermarkMessage extends ControlMessage{
 private final long timestamp;

 private WatermarkMessage(long timestamp, String taskName, int taskCount) {
   super(taskName, taskCount);
   this.timestamp = timestamp;
 }

 public long getTimestamp() {   return timestamp;  }
}