# Meltdown

A lightweight service manager to help with graceful shutdown of asynchronous
applications.

## Overview

Meltdown provides a simple way to manage multiple asynchronous services and
coordinate their graceful shutdown. Perfect for web servers, background workers,
or any async application that needs clean shutdown handling.

## Features

- **Lightweight** - Minimal dependencies and simple implementation
- **Runtime Agnostic** - Works with any async runtime (tokio, async-std, smol, etc.)
- **Flexible** - Works with any async service that can handle shutdown signals
- **Simple API** - Easy to use with plain async functions and custom service types

## Quick Start

Add this to your `Cargo.toml`:

```toml
[dependencies]
meltdown = "0.3.0"
```

Basic usage example with `tokio` and `axum`:

```rust
use axum::{routing, Router};
use meltdown::{Meltdown, Token};

async fn api_service(token: Token) -> Result<(), Box<dyn std::error::Error>> {
    let router = Router::new().route("/", routing::get("Hello!"));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await?;

    axum::serve(listener, router)
        .with_graceful_shutdown(token)
        .await
        .map_err(Into::into)
}

async fn signal_service(token: Token) -> Result<(), Box<dyn std::error::Error>> {
    tokio::select! {
        () = token => Ok(()),
        result = tokio::signal::ctrl_c() => result.map_err(Into::into),
    }
}

#[tokio::main]
async fn main() {
    let mut meltdown = Meltdown::new()
        .register(api_service)
        .register(signal_service);

    // Trigger shutdown when first service completes
    if let Some(result) = meltdown.next().await {
        println!("Got {result:?}, shutting down");
        meltdown.trigger();
    }

    // Wait for remaining services
    while let Some(result) = meltdown.next().await {
        println!("Got {result:?}");
    }
}
```

For detailed usage and examples, check out [the documentation](https://docs.rs/meltdown).

## License

Licensed under the [0BSD](LICENSE) license.