Crate tourniquet[][src]

Expand description

Easily round-robin between servers providing the same service, automatically reconnecting to the next server should an error happen.

This library facilitates resiliency to multiple service providers (e.g. servers) by connecting to the first available service from a list in a round-robin manner. If for some reason any provider goes down, any attempt to interact with it will reconnect to the next one, automatically.

Disclaimer: this library is not for load-balancing between a set of providers! It will connect to one provider, and only use this one provider as long as it is up. Tourniquet is meant for resiliency and not for load balancing.


use async_trait::async_trait;
use std::{io::Error, net::IpAddr};
use tokio::{io::AsyncReadExt, net::TcpStream, sync::Mutex};
use tourniquet::{Connector, RoundRobin};

struct Conn(u16);

impl Connector<IpAddr, Mutex<TcpStream>, Error> for Conn {
    async fn connect(&self, src: &IpAddr) -> Result<Mutex<TcpStream>, Error> {
        let Conn(ref port) = self;
        TcpStream::connect((*src, *port))

async fn main() {
    let rr = RoundRobin::new(
        vec!["".parse().unwrap(), "".parse().unwrap()],

    let hello =|sock| async move {
        let mut sock = sock.lock().await;
        let mut buf = [0; 50];
        sock.read_exact(&mut buf)|_| String::from_utf8(buf.to_vec()).unwrap())



Round Robin manager.


Trait to be implemented by connector types. Used to get a connected service from its connection information.

Trait indicating wether an error mandates trying the next service.

Attribute Macros