Healthcheck now checks if registration db can be reached.

Co-authored-by: Akash <akash1810@users.noreply.github.com>

Author: JuliaBrigitte

common/src/main/scala/db/RegistrationRepository.scala

@@ -11,5 +11,6 @@ trait RegistrationRepository[F[_], S[_[_], _]] {
   def delete(sub: Registration): ConnectionIO[Int]
   def deleteByToken(token: String): ConnectionIO[Int]
   def deleteByDate(olderThanDays: Int): ConnectionIO[Int]
+  def simpleSelectForHealthCheck():  S[F, TopicCount]
   def topicCounts(countsThreshold: Int): S[F, TopicCount]
 }

common/src/main/scala/db/RegistrationService.scala

@@ -44,6 +44,8 @@ class RegistrationService[F[_]: Async, S[_[_], _]](repository: RegistrationRepos
   }
 
   def topicCounts(countThreshold: Int): S[F, TopicCount] = repository.topicCounts(countThreshold)
+
+  def simpleSelectForHealthCheck(): S[F, TopicCount] = repository.simpleSelectForHealthCheck()
 }
 
 

common/src/main/scala/db/SqlRegistrationRepository.scala

@@ -77,6 +77,15 @@ class SqlRegistrationRepository[F[_]: Async](xa: Transactor[F])
         .transact(xa)
   }
 
+  override def simpleSelectForHealthCheck(): Stream[F, TopicCount] = {
+    sql"""
+         SELECT topic from registrations limit 1
+      """
+      .query[TopicCount]
+      .stream
+      .transact(xa)
+  }
+
   override def findTokens(topics: NonEmptyList[String], shardRange: Option[Range]): Stream[F, HarvestedToken] = {
     val queryStatement = (sql"""
         SELECT token, platform, buildTier

registration/app/registration/controllers/Main.scala

@@ -13,11 +13,12 @@ import registration.models.{LegacyNewsstandRegistration, LegacyRegistration}
 import registration.services._
 import registration.services.topic.TopicValidator
 
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.{Await, ExecutionContext, Future}
 import org.slf4j.{Logger, LoggerFactory}
 import play.api.http.HttpEntity
 import providers.ProviderError
 
+import scala.concurrent.duration.Duration
 import scala.util.{Success, Try}
 
 final class Main(
@@ -33,16 +34,18 @@ final class Main(
 
   private val logger: Logger = LoggerFactory.getLogger(this.getClass)
 
-  def healthCheck: Action[AnyContent] = Action {
-    // This forces Play to close the connection rather than allowing
-    // keep-alive (because the content length is unknown)
-    Ok.sendEntity(
-      HttpEntity.Streamed(
-        data =  Source(Array(ByteString("Good")).toVector),
-        contentLength = None,
-        contentType = Some("text/plain")
-      )
-    )
+
+  def healthCheck: Action[AnyContent] = Action.async {
+    //Check if we can talk to the registration database
+    registrar.dbHealthCheck()
+      .map(_ =>     Ok.sendEntity(
+        HttpEntity.Streamed(
+          data =  Source(Array(ByteString("Good")).toVector),
+          contentLength = None,
+          contentType = Some("text/plain")
+        )
+      ))
+      .recover { _ => InternalServerError }
   }
 
   def newsstandRegister: Action[LegacyNewsstandRegistration] =

registration/app/registration/services/DatabaseRegistrar.scala

@@ -8,14 +8,20 @@ import fs2.Stream
 import com.amazonaws.services.cloudwatch.model.StandardUnit
 import metrics.{MetricDataPoint, Metrics}
 
-
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, ExecutionContext, Future}
 import scala.util.{Failure, Success}
 
 class DatabaseRegistrar(
   registrationService: RegistrationService[IO, Stream],
   metrics: Metrics
 )(implicit ec: ExecutionContext) extends NotificationRegistrar {
+  def dbHealthCheck(): Future[List[TopicCount]] = {
+    val simpleSelect = registrationService.simpleSelectForHealthCheck()
+    simpleSelect.compile.toList.unsafeToFuture()
+  }
+
+
   override val providerIdentifier: String = "DatabaseRegistrar"
 
   override def register(deviceToken: DeviceToken, registration: Registration): RegistrarResponse[RegistrationResponse] = {

registration/app/registration/services/NotificationRegistrar.scala

@@ -22,6 +22,7 @@ trait NotificationRegistrar {
   import NotificationRegistrar.RegistrarResponse
   val providerIdentifier: String
   def register(deviceToken: DeviceToken, registration: Registration): RegistrarResponse[RegistrationResponse]
+  def dbHealthCheck(): Future[List[TopicCount]]
 }
 
 object NotificationRegistrar {