1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.extensions
21 
22 import com.github.t3hnar.bcrypt._
23 import com.typesafe.config.Config
24 import grizzled.slf4j.Logging
25 import org.apache.commons.dbcp2.BasicDataSource
26 import org.flywaydb.core.Flyway
27 import org.flywaydb.core.api.MigrationVersion
28 import org.flywaydb.core.api.configuration.FluentConfiguration
29 import org.make.api.extensions.MakeSettings.DefaultAdmin
30 import org.make.api.technical.ExecutorServiceHelper._
31 import org.make.api.technical.MonitorableExecutionContext
32 import scalikejdbc.{ConnectionPool, DataSourceConnectionPool, GlobalSettings, LoggingSQLAndTimeSettings}
33 
34 import java.sql.Connection
35 import java.util.concurrent.{Executors, ThreadPoolExecutor}
36 import scala.concurrent.ExecutionContext
37 import scala.jdk.CollectionConverters._
38 import scala.util.{Failure, Success, Try}
39 
40 class DatabaseConfiguration(override protected val configuration: Config, defaultAdmin: DefaultAdmin)
41     extends ConfigurationSupport
42     with Logging {
43 
44   private val user: String = configuration.getString("database.user")
45   private val password: String = configuration.getString("database.password")
46 
47   private val jdbcUrl: String = configuration.getString("database.jdbc-url")
48 
49   private val readDatasource = new BasicDataSource()
50   readDatasource.setDriverClassName("org.postgresql.Driver")
51   readDatasource.setUrl(jdbcUrl)
52   readDatasource.setUsername(user)
53   readDatasource.setPassword(password)
54   readDatasource.setInitialSize(configuration.getInt("database.pools.read.initial-size"))
55   readDatasource.setMaxTotal(configuration.getInt("database.pools.read.max-total"))
56   readDatasource.setMaxIdle(configuration.getInt("database.pools.read.max-idle"))
57 
58   val (readExecutor: MonitorableExecutionContext, readThreadPool: ExecutionContext) = {
59     @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
60     val executor = Executors
61       .newFixedThreadPool(configuration.getInt("database.pools.read.max-total"))
62       .asInstanceOf[ThreadPoolExecutor]
63     (new MonitorableExecutionContext(executor), executor.instrument("db-read-executor").toExecutionContext)
64   }
65 
66   private val writeDatasource = new BasicDataSource()
67   writeDatasource.setDriverClassName("org.postgresql.Driver")
68   writeDatasource.setUrl(jdbcUrl)
69   writeDatasource.setUsername(user)
70   writeDatasource.setPassword(password)
71   writeDatasource.setInitialSize(configuration.getInt("database.pools.write.initial-size"))
72   writeDatasource.setMaxTotal(configuration.getInt("database.pools.write.max-total"))
73   writeDatasource.setMaxIdle(configuration.getInt("database.pools.write.max-idle"))
74 
75   val (writeExecutor: MonitorableExecutionContext, writeThreadPool: ExecutionContext) = {
76     @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
77     val executor = Executors
78       .newFixedThreadPool(configuration.getInt("database.pools.write.max-total"))
79       .asInstanceOf[ThreadPoolExecutor]
80     (new MonitorableExecutionContext(executor), executor.instrument("db-write-executor").toExecutionContext)
81   }
82 
83   ConnectionPool.add("READ", new DataSourceConnectionPool(dataSource = readDatasource))
84   ConnectionPool.add("WRITE", new DataSourceConnectionPool(dataSource = writeDatasource))
85 
86   GlobalSettings.loggingSQLErrors = true
87   GlobalSettings.loggingSQLAndTime = LoggingSQLAndTimeSettings(
88     enabled = true,
89     warningEnabled = true,
90     warningThresholdMillis = 500,
91     warningLogLevel = "warn",
92     printUnprocessedStackTrace = false,
93     logLevel = "debug"
94   )
95 
96   private val databaseName = writeDatasource.getConnection.getCatalog
97   private val defaultClientId: String = configuration.getString("authentication.default-client-id")
98   private val defaultClientSecret: String = configuration.getString("authentication.default-client-secret")
99   private val defaultBackofficeClientId: String = configuration.getString("authentication.backoffice.client-id")
100   private val defaultBackofficeClientSecret: String = configuration.getString("authentication.backoffice.client-secret")
101 
102   def migrateDatabase(): Unit = {
103     logger.debug(s"Creating database with name: $databaseName")
104     Try {
105       val connection: Connection = writeDatasource.getConnection
106       connection.prepareStatement(s"CREATE DATABASE IF NOT EXISTS $databaseName").execute()
107       connection.close()
108     } match {
109       case Success(_) =>
110       case Failure(e) => logger.debug(s"Error when creating database: ${e.getMessage}")
111     }
112 
113     val setBaselineVersion: Boolean = configuration.getBoolean("database.migration.init-schema")
114 
115     val baselineVersion: MigrationVersion =
116       MigrationVersion.fromVersion(configuration.getString("database.migration.baseline-version"))
117 
118     val repair: Boolean = configuration.getBoolean("database.migration.repair")
119 
120     var flywayBuilder: FluentConfiguration = Flyway
121       .configure()
122       .dataSource(writeDatasource)
123       .initSql("SET autocommit_before_ddl = off")
124       .baselineOnMigrate(true)
125       .locations("classpath:db/migration", "classpath:org/make/api/migrations/db")
126       .placeholders(
127         Map(
128           "dbname" -> databaseName,
129           "clientId" -> defaultClientId,
130           "clientSecret" -> defaultClientSecret,
131           "backofficeClientId" -> defaultBackofficeClientId,
132           "backofficeClientSecret" -> defaultBackofficeClientSecret,
133           "adminEmail" -> defaultAdmin.email,
134           "adminFirstName" -> defaultAdmin.firstName,
135           "adminEncryptedPassword" -> defaultAdmin.password.boundedBcrypt
136         ).asJava
137       )
138 
139     if (!setBaselineVersion && flywayBuilder.getBaselineVersion.compareTo(baselineVersion) < 0) {
140       flywayBuilder = flywayBuilder.baselineVersion(baselineVersion)
141     }
142 
143     val flyway: Flyway = flywayBuilder.load()
144     if (repair) {
145       Try(flyway.repair()) match {
146         case Success(_) => logger.info("Repairing SQL migrations history: success")
147         case Failure(e) => logger.warn("Cannot repair SQL migrations history:", e)
148       }
149     }
150     flyway.migrate()
151     Try(flyway.validate()) match {
152       case Success(_) => logger.info("SQL migrations: success")
153       case Failure(e) => logger.warn("Cannot migrate database:", e)
154     }
155   }
156 }