Coordination support between multiple FTP listeners

[niveathika]

Area

Area/FileIntegration

Problem

We need coordination support between distributed nodes running ftp:Listener

Proposed Solution

Multiple ways to achieve this,

1. Custom implementation where coordination is through a file on the FTP server
2. Look into any libraries which provides this support

Alternatives

No response

Version

No response

[niveathika]

Proposal: High Availability & Coordination for FTP Listeners

1. Problem Statement

Running multiple replicas of a service with an FTP listener in a clustered environment (e.g., Kubernetes or multiple VMs) introduces several risks:

• Duplicate Processing: Multiple nodes polling the same directory may pick up and process the same file simultaneously.
• Resource Contention: Concurrent connections may exceed FTP server limits or trigger security bans.
• Race Conditions: Multiple nodes racing to delete or move a file after processing leads to "File Not Found" errors.

Goal: Implement a coordination mechanism ensuring only one node (the Leader) actively polls and processes files at any given time, while providing automatic failover if the Leader fails.

---

2. Coordination Strategy: Active-Passive (Recommended)

We propose an Active-Passive (Listener-Level) strategy. This aligns with the existing logic in the ballerina/task module.

• Model: "Bearer" (Active) vs. "Candidate" (Passive) nodes.
• Mechanism: Nodes compete for a distributed lock (Token) in a shared database. The Bearer updates a heartbeat; if the heartbeat ceases, a Candidate assumes the "Term" (epoch) and becomes the new Bearer.
• Why Option A over Active-Active?
  • FTP Safety: Guarantees a single connection, preventing "max connection" errors.
  • Predictability: Easier to debug and monitor which node is currently responsible for the integration.
  • Precedent: Reuses the proven logic already established in the Ballerina Standard Library.

---

3. Implementation Path

We should avoid duplicating the task module's code within the FTP module. We have two logical paths:

1. Reuse Task Logic: Since FTP listeners often offload scheduling to the task module, leverage the existing task coordination internally. -> This is blocked due to task module NOT having cron support.

2. Universal Coordination Module: Extract the clustering/locking logic from ballerina/task into ballerina/coordination. This allows FTP, Email, Kafka, and others to support HA through a unified interface. -> High resource allocation. Also as a ballerina language does it need clustering support as a standard library?

[niveathika]

This task is pending due to discussion ongoing to select the implementation path

[niveathika]

We had an internal discussion and decided to go with the first path. The FTP module will expose coordination configs and reuse the coordination available in the task module.

Cron expression support will be worked on separately. As an addition to the task module and reused in ftp module.