Installation

TaskDaemon installation guide

Installation

TaskDaemon needs a running Docker engine and handler images available to that engine. Check docker info before starting the daemon; start Docker yourself if the engine is unavailable.

Docker Image

Create handlers.toml and build its handler images first. Keep SQLite on a persistent volume:

docker pull mshelia/taskdaemon:0.2.0-alpha
docker run -d --name taskdaemon \
  -p 8080:8080 -p 50051:50051 \
  -e DAEMON_DB_PATH=/data/tasks.db \
  -v task-data:/data \
  -v "$(pwd)/handlers.toml:/app/handlers.toml:ro" \
  -v /var/run/docker.sock:/var/run/docker.sock \
  mshelia/taskdaemon:0.2.0-alpha

Use a release tag or digest validated for your deployment. An existing published image may lag the source changes described by these docs; build locally to run the current checkout.

Build from Source

The TaskDaemon repository is currently private, so source builds and the library Git dependency require authenticated GitHub access. The released Docker Hub image is the public installation path.

Install Rust 1.91.0 (the verified toolchain for this release) and protoc (the Protocol Buffers compiler).

git clone https://github.com/jona62/TaskDaemon.git
cd TaskDaemon
cargo build --release --bin task-daemon
./target/release/task-daemon --config handlers.toml --db-path ./tasks.db

The CLI defaults to 2 workers and a batch size of 5. See environment variables for all defaults and overrides.

Build Docker Image Locally

docker build -t taskdaemon:local .
docker run -d --name taskdaemon \
  -p 8080:8080 -p 50051:50051 \
  -e DAEMON_DB_PATH=/data/tasks.db \
  -v task-data:/data \
  -v "$(pwd)/handlers.toml:/app/handlers.toml:ro" \
  -v /var/run/docker.sock:/var/run/docker.sock \
  taskdaemon:local

As a Library

[dependencies]
task-daemon = { git = "https://github.com/jona62/TaskDaemon" }
anyhow = "1"
tokio = { version = "1", features = ["full"] }

This example exposes HTTP and shuts down the workers when Ctrl+C arrives:

use std::sync::Arc;
use task_daemon::{
    core::{Queue, TaskDaemon},
    handler::{ContainerRegistry, HandlerConfig},
    protocol::http,
    storage::SqliteQueue,
};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let queue: Arc<dyn Queue> = Arc::new(SqliteQueue::new("tasks.db").await?);
    let containers = Arc::new(
        ContainerRegistry::from_config(HandlerConfig::from_file("handlers.toml")?).await?,
    );
    let daemon = TaskDaemon::builder()
        .queue(queue)
        .containers(containers)
        .num_workers(4)
        .batch_size(5)
        .timeout_secs(30)
        .max_retries(3)
        .build();
    let (service, handle) = daemon.start_workers();
    let result = tokio::select! {
        result = http::serve_on(service, "127.0.0.1", 8080) => result,
        result = tokio::signal::ctrl_c() => result.map_err(Into::into),
    };
    handle.shutdown().await;
    result
}

The library builder defaults to 5 workers and batch size 5. Keep its returned handle alive for the worker and metrics lifecycle, and call shutdown().await to finish active work and release unexecuted claims. grpc::serve(service, 50051) is available from task_daemon::protocol::grpc when adding a gRPC server.

CLI Options

-w, --workers <WORKERS>
    --http-port <HTTP_PORT>
    --grpc-port <GRPC_PORT>
    --db-path <DB_PATH>
    --log-level <LOG_LEVEL>
    --config <CONFIG>
    --task-selection <TASK_SELECTION>   fifo, lifo, priority
-h, --help
-V, --version

Batch size uses DAEMON_BATCH_SIZE; there is no batch-size CLI flag.

Verify Installation

./target/release/task-daemon --version
# Or, for the image you chose:
docker run --rm taskdaemon:local --version