anarchon

Anarchon: Leaderless Distributed Scheduling

Anarchon provides a sophisticated framework for distributed cron and interval scheduling without the need for a centralized leader or distributed locks. This project enables seamless execution of jobs across multiple instances, ensuring that only one instance handles each scheduled task through an atomic claim. The scheduling strategy guarantees reliable job execution, even in the face of instance failures or network issues.

Key Features

• Leaderless Management: Run the same jobs in every instance without a single point of failure. An atomic claim using Redis, Valkey, PostgreSQL, or SQLite selects which instance will execute a scheduled job.
• Robust Scheduling: Handles various edge cases such as jobs exceeding their scheduled intervals and instances crashing or freezing. Rolling deployments and simultaneous instance restarts are also accommodated seamlessly.

How It Works

1. Job Scheduling: Jobs can be scheduled using various intervals, cron expressions, and one-off timings. Instances compute the same run times and execute with some randomness to prevent contention.

2. Atomic Claims: Each instance tries to claim a job, ensuring that only one runs the task while others act as backups ready to take over in case the primary instance fails.

3. Lease Mechanism: A lease strategy ensures that in the event of a failure, another instance can take over the job after a specified duration.

   import { RedisBackend, Scheduler } from 'anarchon';
   
   const scheduler = new Scheduler({ backend: new RedisBackend({ redis: 'redis://localhost:6379' }) });
   
   scheduler
       .every('sync', '10s', async (ctx) => { /* task implementation */ })
       .cron('digest', '0 */2 * * *', async (ctx) => { /* task implementation */ });
   
   await scheduler.start();
   

Practical Example

A demonstration with three instances showcases the behavior of Anarchon:

• Single Winner: Only one process will start the job while the others skip it.
• Graceful Shutdown: If the runner is gracefully stopped, another process will seamlessly take over.
• Crash Recovery: In the event of a crash, a backup process resumes the job on the next opportunity.

Use Cases

• Scheduled tasks in microservices architectures needing reliable executions without centralized controls.
• Environments where rolling updates could disrupt scheduled job executions.
• Systems requiring fault-tolerant job runners capable of recovering lost executions.

For complete documentation, including setup guides, examples, and advanced configuration options, visit the official Anarchon documentation.

By adopting Anarchon, developers gain an efficient, leaderless scheduling system that enhances the reliability and maintainability of distributed applications.