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,22 @@ class SqlRegistrationRepository[F[_]: Async](xa: Transactor[F])
         .transact(xa)
   }
 
+  /**
+   * Used to verify that the DB connection is healthy.
+   * We just select one topic and a constant value as this is sufficient to check connectivity (we don't care about what data is returned).
+   */
+  override def simpleSelectForHealthCheck(): Stream[F, TopicCount] = {
+    sql"""
+         SELECT  topic
+                , 1
+         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,25 @@ 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(_ => {
+        // 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")
+          )
+        )
+      })
+      .recover { _ => {
+        logger.error("Failing to connect to database")
+        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 {

registration/test/registration/controllers/RegistrationsFixtures.scala

@@ -35,6 +35,9 @@ trait DelayedRegistrationsBase extends RegistrationsBase {
         provider = Unknown
       ))
     }
+
+    // Not needed for tests
+    override def dbHealthCheck(): Future[List[TopicCount]] = Future.successful(List.empty)
   }
 }
 
@@ -71,6 +74,8 @@ trait RegistrationsBase extends WithPlayApp with RegistrationsJson {
       ))
     }
 
+    // Not needed for tests
+    override def dbHealthCheck(): Future[List[TopicCount]] = Future.successful(List.empty)
   }