Rust Bind Autorun

rust-bind-autorun is a Rust library that provides an easy way to bind a Rust function to a system service that runs on startup. This library allows you to create a daemon service that will automatically start on boot and run your Rust code.

How It Works

The rust-bind-autorun library works by creating a systemd service file and registering it with the operating system. The service file is then configured to run the Rust code using the systemd-run command.

To use this library, you simply need to create a Rust function that you want to have run on startup. You can then use rust-bind-autorun to bind this function to a systemd service:

#[autorun::main]
fn my_function() {
    println!("Hello, world!");
}

This code will automatically create a systemd service file that runs the my_function function on startup.

Installation

To use this library, add rust-bind-autorun to your Cargo.toml file:

[dependencies]
rust-bind-autorun = "0.1"

Usage

The rust-bind-autorun library provides a procedural macro that you can use to bind a Rust function to a systemd service:

#[autorun::main]
fn my_function() {
    // Your code here
}

The autorun::main macro generates a function that will run your Rust code in a systemd service. Here's what the generated code looks like:

use rust_bind_autorun::BindAutorun;

fn main() {
    let service_file = "[Unit]\nDescription=Rust Service\n[Service]\nExecStart=<path-to-binary>";
    let service_name = "my-function";
    let binary_path = std::env::current_exe().expect("Could not determine binary path");

    BindAutorun::new(service_name, service_file, &|_| {
        let _ = std::process::Command::new("systemd-run")
            .arg("--unit")
            .arg(service_name)
            .arg(binary_path)
            .spawn();
    })
    .bind();
}

The BindAutorun::new method creates a new BindAutorun object, which will generate a systemd service file for your Rust code. The bind method registers the service with systemd.

Examples

Here's an example of how to use rust-bind-autorun:

#[autorun::main]
fn my_function() {
    println!("Hello, world!");
}

This code will create a systemd service file that will run my_function on startup. The generated service file will look like this:

[Unit]
Description=Rust Service

[Service]
ExecStart=<path-to-binary>

Conclusion

rust-bind-autorun is a useful library for creating system services in Rust. It's easy to use and provides a simple way to run your Rust code on startup. With rust-bind-autorun, you can create robust, reliable, and performant system services in Rust.