4783218024

Committed 24 Apr 2023 06:36AM UTC coverage: 23.857% (-0.4%) from 24.304%

Build Type

Committed by Pat Losoponkul

Commit Message

feat(prism-agent): customize service tapir schema

Pull Request Pull Request #511: feat(prism-agent): migrate DID endpoint to tapir [WIP]

Run Details

200 of 200 new or added lines in 16 files covered. (100.0%)

2045 of 8572 relevant lines covered (23.86%)

0.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.87

/connect/lib/sql-doobie/src/main/scala/io/iohk/atala/connect/sql/repository/TransactorLayer.scala

package io.iohk.atala.connect.sql.repository

import cats.effect.{Async, Resource}
import doobie.util.transactor.Transactor
import com.zaxxer.hikari.HikariConfig
import doobie.util.ExecutionContexts
import doobie.hikari.HikariTransactor
import zio.interop.catz.*
import zio.*
import cats.effect.std.Dispatcher

case class DbConfig(
    username: String,
    password: String,
    jdbcUrl: String,
    awaitConnectionThreads: Int = 8
)

object TransactorLayer {

  def hikari[A[_]: Async: Dispatcher](config: DbConfig)(using tag: Tag[Transactor[A]]): TaskLayer[Transactor[A]] = {
    val transactorLayerZio = ZIO
      .attempt {
        // https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing
        val poolSize = (config.awaitConnectionThreads * 2) + 1
        val hikariConfig = makeHikariConfig(config)
        hikariConfig.setPoolName("DBPool")
        hikariConfig.setLeakDetectionThreshold(300000) // 5 mins
        hikariConfig.setMinimumIdle(poolSize)
        hikariConfig.setMaximumPoolSize(poolSize) // Both Pool size amd Minimum Idle should same and is recommended
        hikariConfig
      }
      .map { hikariConfig =>
        val pool: Resource[A, Transactor[A]] = for {
          // Resource yielding a transactor configured with a bounded connect EC and an unbounded
          // transaction EC. Everything will be closed and shut down cleanly after use.
          ec <- ExecutionContexts.fixedThreadPool[A](config.awaitConnectionThreads) // our connect EC
          xa <- HikariTransactor.fromHikariConfig[A](hikariConfig, ec)
        } yield xa

        pool.toManaged.toLayer[Transactor[A]]
      }

    ZLayer.fromZIO(transactorLayerZio).flatten
  }

  private def makeHikariConfig(config: DbConfig): HikariConfig = {
    val hikariConfig = HikariConfig()

    hikariConfig.setJdbcUrl(config.jdbcUrl)
    hikariConfig.setUsername(config.username)
    hikariConfig.setPassword(config.password)
    hikariConfig.setAutoCommit(false)

    hikariConfig.setDriverClassName("org.postgresql.Driver")
    hikariConfig.addDataSourceProperty("cachePrepStmts", "true")
    hikariConfig.addDataSourceProperty("prepStmtCacheSize", "250")
    hikariConfig.addDataSourceProperty("prepStmtCacheSqlLimit", "2048")

    hikariConfig
  }

}

1	package io.iohk.atala.connect.sql.repository
2
3	import cats.effect.{Async, Resource}
4	import doobie.util.transactor.Transactor
5	import com.zaxxer.hikari.HikariConfig
6	import doobie.util.ExecutionContexts
7	import doobie.hikari.HikariTransactor
8	import zio.interop.catz.*
9	import zio.*
10	import cats.effect.std.Dispatcher
11
12	case class DbConfig(
13	username: String,
14	password: String,
15	jdbcUrl: String,	1✔
16	awaitConnectionThreads: Int = 8
17	)
18
19	object TransactorLayer {
20		1✔
21	def hikari[A[_]: Async: Dispatcher](config: DbConfig)(using tag: Tag[Transactor[A]]): TaskLayer[Transactor[A]] = {	1✔
22	val transactorLayerZio = ZIO
23	.attempt {
24	// https://github.com/brettwooldridge/HikariCP/wiki/About-Pool-Sizing
25	val poolSize = (config.awaitConnectionThreads * 2) + 1	×
26	val hikariConfig = makeHikariConfig(config)	×
27	hikariConfig.setPoolName("DBPool")	×
28	hikariConfig.setLeakDetectionThreshold(300000) // 5 mins	×
29	hikariConfig.setMinimumIdle(poolSize)	×
30	hikariConfig.setMaximumPoolSize(poolSize) // Both Pool size amd Minimum Idle should same and is recommended
31	hikariConfig
32	}
33	.map { hikariConfig =>	1✔
34	val pool: Resource[A, Transactor[A]] = for {
35	// Resource yielding a transactor configured with a bounded connect EC and an unbounded
36	// transaction EC. Everything will be closed and shut down cleanly after use.	×
37	ec <- ExecutionContexts.fixedThreadPool[A](config.awaitConnectionThreads) // our connect EC	×
38	xa <- HikariTransactor.fromHikariConfig[A](hikariConfig, ec)
39	} yield xa
40		×
41	pool.toManaged.toLayer[Transactor[A]]
42	}
43		×
44	ZLayer.fromZIO(transactorLayerZio).flatten
45	}
46		1✔
47	private def makeHikariConfig(config: DbConfig): HikariConfig = {	1✔
48	val hikariConfig = HikariConfig()
49		1✔
50	hikariConfig.setJdbcUrl(config.jdbcUrl)	1✔
51	hikariConfig.setUsername(config.username)	1✔
52	hikariConfig.setPassword(config.password)	1✔
53	hikariConfig.setAutoCommit(false)
54		1✔
55	hikariConfig.setDriverClassName("org.postgresql.Driver")	1✔
56	hikariConfig.addDataSourceProperty("cachePrepStmts", "true")	1✔
57	hikariConfig.addDataSourceProperty("prepStmtCacheSize", "250")	1✔
58	hikariConfig.addDataSourceProperty("prepStmtCacheSqlLimit", "2048")
59
60	hikariConfig
61	}
62
63	}

input-output-hk / atala-prism-building-blocks / 4783218024

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous