Which to prefer, next or next_connected?

[banool]

I'm migrating from deadpool_redis. There they have a get method to get a client from the pool. I see fred makes you decide whether you want just the next client or specifically the next connected client. Which should you use? If no client is connected will next_connected connect one? Similarly when building the client, should I set prefer_connected?

[aembke]

Under the hood they're very similar, but next_connected() briefly acquires a lock to check the connection state. If all the clients are disconnected it does the same thing as next(). In terms of connecting/reconnecting - the pool doesn't drive this but if you provide a ReconnectPolicy then everything should reconnect asynchronously without surfacing errors in your app code. I'd recommend using something like ReconnectPolicy::new_exponential(0, 20, 30_000, 5) when creating the pool.

For my use cases I usually set prefer_connected(false). In my experience if one connection in a pool closes it usually means everything else is going to briefly close in the near future too (for example a cluster rebalance, node failover, etc), so trying to avoid waiting on a reconnection often doesn't help in practice. It depends on your use case though, and if you think there are failure modes where individual connections in a pool could close for long periods then it may be worth using prefer_connected(true).

There's several ways to use the interfaces here, but the most flexible option involves setting prefer_connected once and then relying on the ClientLike traits rather than calling next or next_connected directly. For example:

let config = create_redis_config();
let pool = Builder::from_config(config)
    .set_policy(ReconnectPolicy::new_exponential(0, 20, 30_000, 5))
    .build_pool(13)?;
    
pool.prefer_connected(false);

// then use the `ClientLike` interfaces rather than directly calling `next()` or `next_connected()`.
let foo: Option<String> = pool.get("foo").await?;
// this is equivalent to
let foo: Option<String> = pool.next().get("foo").await?:

// if prefer_conneted is true
pool.prefer_connected(true);
// then the `ClientLike` interfaces call `next_connected()` under the hood
let foo: Option<String> = pool.get("foo").await?;
// is now equivalent to
let foo: Option<String> = pool.next_connected().get("foo").await?:

[banool]

Awesome, thanks for the detailed answer. I wasn't aware of ClientLike, this makes much more sense now. As for prefer_connected, I'll stick with leaving it as-is (false) for now.