Redis client for Scala built on top of Cats Effect, Fs2 and Lettuce (formerly Fs2 Redis) -> https://redis4cats.profunktor.dev/
Dispatcher depends on in the inner Supervisor
I just tried to wrap AsyncConnectionPoolSupport in F[_] to get a Resource[F, () => Resource[F, RedisCommand[F, K, V]]] but I couldn't since some constructor in redis4cats is private. So I probably should make a PR.
@gvolpe:matrix.org have you considered providing a functional API for pooling? Are there any nuances I should know before starting doing it?
def saveCreatedEvent(c: Node.Created)(implicit C:DefaultConfig) = client.use{ cmd=>
val tx = RedisTransaction(cmd)
val payload = c.payload
val tagCmd = generateSetCommand(cmd,c.nodeId,"tag")(payload.tag)
val commands= HList.fromList(tagCmd::Nil)
tx.filterExec(commands)
}Hlist.fromList never worked. Can you please raise an issue?
@nachocodexx: why are you using HList.fromList though? Isn't that tagCmd a single command? You can basically do
val commands = tagCmd :: HNilOr if you really need a dynamic list, you can use this hack but it requires knowing the types to help the compiler
val commands = HList.fromList(List(IO.unit, IO.pure("hi"))).asInstanceOf[IO[Unit] :: IO[String] :: HNil]if I follow the documentation example and create the commands list using (::) operator and HNil, the result is the same:
val commands= tagCmd::ipAddressCmd::HNil\ No implicit arguments of type: WitnessFilter[HCons[IO[Unit], HCons[IO[Unit], hlist.HNil.type]]]
1 reply
0.13.1 . Am i missing anything?
redis4cats 0.14.0 and 1.0.0
Yeah transactions are quite tricky to get working in an asynchronous fashion. I recommend staying away from them, limit yourself to write-only commands where order does not matter, or use the Sync API from Lettuce directly for now.
The reason is that every REDIS command has to be scheduled to run in the same thread but the scheduler does not guarantee order.
Hi I just tried this, from the official website doc:
import cats.effect._
import cats.implicits._
import dev.profunktor.redis4cats.Redis
import dev.profunktor.redis4cats.effect.Log.Stdout._
object QuickStart extends IOApp.Simple {
def run: IO[Unit] =
Redis[IO].utf8("redis://localhost").use { redis =>
for {
_ <- redis.set("foo", "123")
x <- redis.get("foo")
_ <- redis.setNx("foo", "should not happen")
y <- redis.get("foo")
_ <- IO(println(x === y)) // true
} yield ()
}
}this didn't work for me with 1.0.0. but it worked for me with 0.13.1 apparently I am missing some MkRedis[IO] implicit. where do I get that from?
4 replies
RedisConnection or RedisCommands (of lettuce)?
RedisCommand with small hack. I've create a file with package package dev.profunktor.redis4cats then I've implemented there new trait with commands I need that was an extension of RedisCommands then I've created a client itself by extending BaseRedis and my commands. Also I've made a custom generator of Redis resourcepackage dev.profunktor.redis4cats
import cats.effect.{Concurrent, ContextShift, Resource}
import cats.implicits._
import dev.profunktor.redis4cats.connection.{RedisClient, RedisConnection, RedisStatefulConnection}
import dev.profunktor.redis4cats.data.RedisCodec
import dev.profunktor.redis4cats.effect.JRFuture.FutureLiftOps
import dev.profunktor.redis4cats.effect.{JRFuture, Log, RedisExecutor}
trait ExtRedisCommands[F[_], K, V] extends RedisCommands[F, K, V] {
def renamenx(key: K, newKey: K): F[Boolean]
}
class ExtRedis[F[_]: Concurrent: ContextShift: RedisExecutor: Log, K, V](
conn: RedisConnection[F, K, V],
cluster: Boolean
) extends BaseRedis[F, K, V](conn, cluster)
with ExtRedisCommands[F, K, V] {
def renamenx(key: K, newKey: K): F[Boolean] = {
async
.flatMap(c => RedisExecutor[F].delay(c.renamenx(key, newKey)))
.futureLift
.map(x => Boolean.box(x))
}
}
object ExtRedis {
/**
* Modified version of dev.profunktor.redis4cats.Redis.simple
*/
def simple[F[_]: Concurrent: ContextShift: Log, K, V](uri: String, codec: RedisCodec[K, V]): Resource[F, ExtRedisCommands[F, K, V]] = {
RedisClient[F].from(uri).flatMap(fromClient(_, codec))
}
/**
* Modified version of dev.profunktor.redis4cats.Redis.fromClient
*/
def fromClient[F[_]: Concurrent: ContextShift: Log, K, V](
client: RedisClient,
codec: RedisCodec[K, V]
): Resource[F, ExtRedisCommands[F, K, V]] =
RedisExecutor.make[F].flatMap { implicit redisExecutor =>
val (acquire, release) = {
val acquire = JRFuture
.fromConnectionFuture(
RedisExecutor[F].delay(client.underlying.connectAsync(codec.underlying, client.uri.underlying))
)
.map(c => new ExtRedis(new RedisStatefulConnection(c), false))
val release: ExtRedis[F, K, V] => F[Unit] = c => Log[F].info(s"Releasing Commands connection: ${client.uri.underlying}") *> c.conn.close
(acquire, release)
}
Resource.make(acquire)(release).widen
}
}@quanganhtran: it seems possible to add support for it in the library. IIUC we need a RedisTracingStatefulConnection as another implementation of https://github.com/profunktor/redis4cats/blob/series/1.x/modules/core/src/main/scala/dev/profunktor/redis4cats/connection/RedisConnection.scala#L36 but it'll have to be done in a separate module to avoid an extra dependency in core.
Then we can create special constructors for tracing, also in a redis4cats-tracing module. E.g.
object TracingRedis {
def utf8(uri: String, config: TracingConfiguration): Resource[F, RedisCommands[F, String, String]] = ???
}Feel free to submit a feature request or even better a PR :)
UnderlyingConnection => RedisConnection or something like that but seems doable.
Hello @gvolpe:matrix.org !
I'm new to using this lib, and am trying to fetch data from my db by using the eval method :
def eval(script: String, output: ScriptOutputType[V], keys: List[K], values: List[V]): F[output.R]My problem is : the output and the input value both must have the same type V, why is that ? My input values are strings, but for the output values I would like to fetch something else.
Is there a way to bypass this constraint ? I think that it should be possible, given the underlying lettuce function
<T> Command<K, V, T> eval(byte[] script, ScriptOutputType type, K[] keys, V... values) {
LettuceAssert.notNull(script, "Script " + MUST_NOT_BE_NULL);
LettuceAssert.notNull(type, "ScriptOutputType " + MUST_NOT_BE_NULL);
LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
LettuceAssert.notNull(values, "Values " + MUST_NOT_BE_NULL);
CommandArgs<K, V> args = new CommandArgs<>(codec);
args.add(script).add(keys.length).addKeys(keys).addValues(values);
CommandOutput<K, V, T> output = newScriptOutput(codec, type);
return createCommand(EVAL, output, args);
}Thanks in advance for any answer :)
1 reply
Hello, I have a newbie question. How can I retry getting a Redis connection? (I think the question is more general and applies to every Resource but since I'm trying redis4cats I though about asking here).
def redisConnection: Resource[IO, RedisCommands[IO, String, Long]] = Redis[IO].simple("redis://redis-1:6379", Codecs.derive(RedisCodec.Ascii,stringLongEpi))
.handleErrorWith {
_: Throwable => Resource.liftK(IO.println("attempting to connect to redis") *> IO.sleep(5.seconds)).flatMap(_ => redisConnection)
}This does the trick in the sense that will keep retrying getting the connection, but when the program stops I see a cascade of calls to the release function (i.e. a bunch of Releasing Redis connection: RedisURI(redis://redis-1) are logged). I even got this warn from netty
io.netty.util.HashedWheelTimer - You are creating too many HashedWheelTimer instances. HashedWheelTimer is a shared resource that must be reused across the JVM, so that only a few instances are created.So I guess with my attempt the HashedWheelTimer#finalize is not being called after each attempt.
1 reply
