RedisCache.scala

package util

import com.redis._
import java.util.concurrent.Executors
import scala.concurrent.{Future, ExecutionContext}

trait Cache {
  def get(key: String): Future[Option[String]]
  def set(key: String, value: String, seconds: Long): Future[Boolean]
  def ping(): Future[Boolean]
  def pushToQueue(queueName: String, data: String): Future[Option[Long]]
}

class RedisCache extends Cache {
  private val Ex = Executors.newFixedThreadPool(5)
  private implicit val Ec = ExecutionContext.fromExecutor(Ex)

  lazy val clients = new RedisClientPool(Configuration.CacheHost, Configuration.CachePort)

  def get(key: String): Future[Option[String]] = {
    val result = Future { clients.withClient(_.get(key)) }
    result
  }

  def set(key: String, value: String, seconds: Long = 0): Future[Boolean] = {
    val result = if (seconds <= 0) {
      Future { clients.withClient(_.set(key, value)) }
    } else {
      Future { clients.withClient(_.setex(key, seconds, value)) }
    }
    result
  }

  def ping(): Future[Boolean] = Future {
    clients.withClient { client =>
      client.ping.exists(_ == "PONG")
    }
  } recover {
    case _ => false
  }

  def pushToQueue(queueName: String, data: String): Future[Option[Long]] = {
    Future { clients.withClient(_.rpush(queueName, data)) }
  }
}