RedisDbT.scala

trait RedisDbT {
  val host: String
  val port: Int
  val timeout: FiniteDuration

  implicit val _system : ActorSystem
  def getRedisInstance = _system.actorOf(Props(new RedisDbService(host,port,timeout)))

}

object RedisDbT {
  //Other Messages for the Redis Actor 
  case class EnqueueElementRequest(queueName : String, value : String , duration : Option[FiniteDuration] = None )
  case class EnqueueElementResponse(status : Boolean)

  case class DequeueElementRequest(queueName : String)
  case class DequeueElementResult(result : Option[String])

}

private[DB] class RedisDbService(
 val host: String,
 val port: Int,
 val timeout: FiniteDuration
) extends Actor
  with ActorLogging {
  implicit val actorSystem = context.system
  lazy val client  = RedisClient(host,port)
  implicit val _timeout = timeout

  import RedisDbT._
  import scala.concurrent.ExecutionContext.Implicits.global
  override def receive: Receive = {
    //Other Actor Messages 
    case req : EnqueueElementRequest =>
      val currentSender = sender()

      val enqueueFut = client.rpush(req.queueName,req.value)
      enqueueFut.onComplete{
        case Success(res) =>
          res match {
            case x if x < 1 => currentSender ! EnqueueElementResponse(false)
            case _          => currentSender ! EnqueueElementResponse(true)
          }
        case Failure(ex)  =>
          log.error("Error Enqueuing in Redis : {}",ex.getMessage)
          currentSender ! EnqueueElementResponse(false)
      }
    case req : DequeueElementRequest =>
      val currentSender = sender()
      val dequeueFut = client.lpop(req.queueName)
      dequeueFut.onComplete{
        case Success(res) =>
          currentSender ! DequeueElementResult(res.map(_.utf8String))
        case Failure(ex)  =>
          log.error("Error Dequeuing in Redis : {}",ex.getMessage)
          currentSender ! DequeueElementResult(None)
      }
  }