Rust Integration Services

A modern, fast, and lightweight integration library written in Rust, designed for memory safety and stability. It simplifies the development of scalable integrations for receiving and sending data, with built-in support for common protocols.

Installation

Add rust-integration-services to your project Cargo.toml and select features.

[dependencies]
rust-integration-services = { version = "0", features = ["http", "file", "schedule", "sftp"] }

Features

File

FileReceiver

Poll the directory ./io/in/ and receive a callback with the path of a matching file using regular expression.

let result = FileReceiver::new("./io/in/")
.filter(".*", async move |_uuid, path| {
    println!("Callback: {:?}", path);
})
.receive()
.await;

FileSender

Move a file from one directory to another.

let result = FileSender::new("./io/out/file.txt")
.send_move("./io/in/file.txt")
.await;

Copy the contents from a file to another.

let result = FileSender::new("./io/out/file.txt")
.send_copy("./io/in/file.txt")
.await;

Write a string to a file, appending the text.

let result = FileSender::new("./io/out/file.txt")
.send_string("text")
.await;

Schedule

ScheduleReceiver

Run a task once every hour and receive an event when it triggers.

let result = ScheduleReceiver::new()
.interval(ScheduleInterval::Hours(1))
.on_event(async move |event| {
    match event {
        ScheduleReceiverEventSignal::OnTrigger(uuid) => println!("{}", uuid),
    }
})
.receive()
.await;

Run a task once every day at 03:00 UTC and receive an event when it triggers.

let result = ScheduleReceiver::new()
.start_time(03, 00, 00)
.interval(ScheduleInterval::Days(1))
.on_event(async move |event| {
    match event {
        ScheduleReceiverEventSignal::OnTrigger(uuid) => println!("{}", uuid),
    }
})
.receive()
.await;

HTTP

HttpReceiver

Run a HTTP receiver listening on 127.0.0.1:8080 that handles GET and POST requests on the root path.

HttpReceiver::new("127.0.0.1:8080")
.route("GET", "/", async move |_uuid, _request| {
    HttpResponse::ok()
})
.route("POST", "/", async move |_uuid, _request| {
    HttpResponse::ok()
})
.receive()
.await;

HttpSender

Send a HTTP GET request to 127.0.0.1:8080.

let response = HttpSender::new("https://127.0.0.1:8080")
.send(HttpRequest::get())
.await
.unwrap();

SFTP

Using SFTP requires openssl to be installed on the system.
Make sure you also have the development packages of openssl installed. For example, libssl-dev on Ubuntu or openssl-devel on Fedora.

SftpReceiver

Download all files from 127.0.0.1:22 user remote directory upload and delete files after successful download.
Using on_event callback to print on download start and success.
That way files can be processed asyncronously without blocking other downloads.

let result = SftpReceiver::new("127.0.0.1:22", "user")
.auth_password("pass")
.remote_dir("upload")
.delete_after(true)
.on_event(async move |event| {
    match event {
        SftpReceiverEventSignal::OnDownloadStart(_uuid, path) => println!("Download started: {:?}", path),
        SftpReceiverEventSignal::OnDownloadSuccess(_uuid, path) => println!("Download complete: {:?}", path),
    }
})
.receive_files("/home/user/files")
.await;

SftpSender

Send a file to 127.0.0.1:22 user remote path upload keeping the same file name.
A private key with a passphrase is used as authentication in this example.

let result = SftpSender::new("127.0.0.1:22", "user")
.private_key("/home/user/.ssh/id_rsa", Some("secret"))
.remote_path("upload")
.send_file("/home/user/files/data.txt")
.await;

Send a string as a file to 127.0.0.1:22 user remote path upload with a new file name.
A basic password is used as authentication in this example.

let result = SftpSender::new("127.0.0.1:22", "user")
.password("secret")
.remote_path("upload")
.file_name("data.txt")
.send_string("a very beautiful important string")
.await;

rust-integration-services 0.1.0