This library provides a way easily to implement Connection Pools for any [thrift::TThriftClient], which can then be used alongside [bb8] and/or [r2d2]


Usage

There are 2 possible use cases

As a library

If you're implementing a library that provides a (possibly generated) thrift client, you should implement the [ThriftConnection] and [FromProtocol] traits for that client

```rust // A typical generated client looks like this struct MyThriftClient { iprot: Ip, oprot: Op, }

impl FromProtocol for MyThriftClient { type InputProtocol = Ip;

type OutputProtocol = Op;

fn from_protocol(
    input_protocol: Self::InputProtocol,
    output_protocol: Self::OutputProtocol,
) -> Self {
    MyThriftClient {
        i_prot: input_protocol,
        o_prot: output_protocol,
    }
}

}

impl ThriftConnection for MyThriftClient { type Error = thrift::Error; fn isvalid(&mut self) -> Result<(), Self::Error> { Ok(()) } fn hasbroken(&mut self) -> bool { false } }

```

As an application

If you're implementing an application that uses a (possibly generated) thrift client that implements [FromProtocol] and [ThriftConnection] (see previous section), you can use [r2d2] or [bb8] (make sure to read their documentations) along with [ThriftConnectionManager] to create Connection Pools for the client

```rust should_panic

use thrift::protocol::{TInputProtocol, TOutputProtocol};

use thrift_pool::{FromProtocol, ThriftConnection};

#

struct MyThriftClient {

i_prot: Ip,

o_prot: Op,

}

#

impl FromProtocol for MyThriftClient {

type InputProtocol = Ip;

#

type OutputProtocol = Op;

#

fn from_protocol(

input_protocol: Self::InputProtocol,

output_protocol: Self::OutputProtocol,

) -> Self {

MyThriftClient {

iprot: inputprotocol,

oprot: outputprotocol,

}

}

}

#

impl ThriftConnection for MyThriftClient {

type Error = thrift::Error;

fn is_valid(&mut self) -> Result<(), Self::Error> {

Ok(())

}

fn has_broken(&mut self) -> bool {

false

}

}

use thrift_pool::{MakeThriftConnectionFromAddrs};

use thrift::protocol::{TCompactInputProtocol, TCompactOutputProtocol};

use thrift::transport::{

ReadHalf, TFramedReadTransport, TFramedWriteTransport, TTcpChannel, WriteHalf,

};

# type Client = MyThriftClient< TCompactInputProtocol>>, TCompactOutputProtocol>>,

;

#[tokio::main]

async fn main() -> Result<(), Box> {

// create a connection manager let manager = MakeThriftConnectionFromAddrs::::new("localhost:9090").intoconnectionmanager();

// we're able to create bb8 and r2d2 Connection Pools let bb8 = bb8::Pool::builder().build(manager.clone()).await?; let r2d2 = r2d2::Pool::builder().build(manager)?;

// get a connection let conn1 = bb8.get().await?; let conn2 = r2d2.get()?;

Ok(())

}

```


More examples