Blocking pull subscriptions

[estephinson]

We should look at introducing blocking functionality to pull subscriptions. Currently, this behaviour can be mimicked, but it's less-than-ideal implementation.

The reasons for this not being included in the MVP is fairly simple - focus on serverless patterns. However, as the product matures, basic features like this need to be introduced.

Current best equivalent

Introducing an infinite (while to everyone but go) loop to constantly pull events, wait an arbitrary short time, and then poll again is an easy way of introducing this behaviour.

Frankly, this could be implemented in the SDKs as a short-term solution, but it's not an effective approach.

// Infinite loop for a long-lived application to subscribe to events
for {
    events, err := client.GetEvents("topic", "subscription")
    if err != nil {
        panic(err)
    }

    if len(events.Events) > 0 {
        // Do things
    }

    time.Sleep(5 * time.Second)
}

What we should implement

• Implementing HTTP streaming functionality to the API so we can stream events as they come in back to the clients
  • Clients will still need to have looping to handle server-drops due to restarts etc. but looping on error is far better than polling for events
• Introduce a streaming-friendly API in the SDKs to consume these events
• Documentation etc. etc.

---

Req from @huantt

[huantt]

I'd like to introduce an alternative approach that removes the need for users to manually set up polling loops for pull subscriptions:

1. Subscription Initialization: Clients can initiate a subscription by calling the Subscribe method, providing parameters like the topic and subscription details.

2. Event Handling Registration: Instead of relying on users to pull new events, clients can now register an event handler using the Consume method. This involves passing a Consume function or an interface responsible for processing new events.

3. Automated Event Retrieval: In the implementation of the Subscribe method, we create a goroutine that periodically polls for new events. This ensures that clients receive notifications about new events without manually querying the server. When a new event is detected, the subscribed event handler (Consume function or interface) will be called back.

[huantt]

In Subscription Initialization, the client can also pass pullDuration to indicate the interval.