Rename dedicated datasource to events datasource

application/src/main/resources/thingsboard.yml

@@ -775,26 +775,26 @@ spring:
       maximumPoolSize: "${SPRING_DATASOURCE_MAXIMUM_POOL_SIZE:16}"
       # Enable MBean to diagnose pools state via JMX
       registerMbeans: "${SPRING_DATASOURCE_HIKARI_REGISTER_MBEANS:false}"
-    dedicated:
+    events:
       # Enable dedicated datasource (a separate database) for events and audit logs.
       # Before enabling this, make sure you have set up the following tables in the new DB:
       # error_event, lc_event, rule_chain_debug_event, rule_node_debug_event, stats_event, audit_log
-      enabled: "${SPRING_DEDICATED_DATASOURCE_ENABLED:false}"
+      enabled: "${SPRING_DEDICATED_EVENTS_DATASOURCE_ENABLED:false}"
-      # Database driver for Spring JPA for dedicated datasource
+      # Database driver for Spring JPA for events datasource
-      driverClassName: "${SPRING_DEDICATED_DATASOURCE_DRIVER_CLASS_NAME:org.postgresql.Driver}"
+      driverClassName: "${SPRING_EVENTS_DATASOURCE_DRIVER_CLASS_NAME:org.postgresql.Driver}"
-      # Database connection URL for dedicated datasource
+      # Database connection URL for events datasource
-      url: "${SPRING_DEDICATED_DATASOURCE_URL:jdbc:postgresql://localhost:5432/thingsboard_dedicated}"
+      url: "${SPRING_EVENTS_DATASOURCE_URL:jdbc:postgresql://localhost:5432/thingsboard_events}"
-      # Database user name for dedicated datasource
+      # Database username for events datasource
-      username: "${SPRING_DEDICATED_DATASOURCE_USERNAME:postgres}"
+      username: "${SPRING_EVENTS_DATASOURCE_USERNAME:postgres}"
-      # Database user password for dedicated datasource
+      # Database user password for events datasource
-      password: "${SPRING_DEDICATED_DATASOURCE_PASSWORD:postgres}"
+      password: "${SPRING_EVENTS_DATASOURCE_PASSWORD:postgres}"
       hikari:
-        # This property controls the amount of time that a connection can be out of the pool before a message is logged indicating a possible connection leak for dedicated datasource. A value of 0 means leak detection is disabled
+        # This property controls the amount of time that a connection can be out of the pool before a message is logged indicating a possible connection leak for events datasource. A value of 0 means leak detection is disabled
-        leakDetectionThreshold: "${SPRING_DEDICATED_DATASOURCE_HIKARI_LEAK_DETECTION_THRESHOLD:0}"
+        leakDetectionThreshold: "${SPRING_EVENTS_DATASOURCE_HIKARI_LEAK_DETECTION_THRESHOLD:0}"
-        # This property increases the number of connections in the pool as demand increases for dedicated datasource. At the same time, the property ensures that the pool doesn't grow to the point of exhausting a system's resources, which ultimately affects an application's performance and availability
+        # This property increases the number of connections in the pool as demand increases for events datasource. At the same time, the property ensures that the pool doesn't grow to the point of exhausting a system's resources, which ultimately affects an application's performance and availability
-        maximumPoolSize: "${SPRING_DEDICATED_DATASOURCE_MAXIMUM_POOL_SIZE:16}"
+        maximumPoolSize: "${SPRING_EVENTS_DATASOURCE_MAXIMUM_POOL_SIZE:16}"
-        # Enable MBean to diagnose pools state via JMX for dedicated datasource
+        # Enable MBean to diagnose pools state via JMX for events datasource
-        registerMbeans: "${SPRING_DEDICATED_DATASOURCE_HIKARI_REGISTER_MBEANS:false}"
+        registerMbeans: "${SPRING_EVENTS_DATASOURCE_HIKARI_REGISTER_MBEANS:false}"
 
 # Audit log parameters
 audit-log:

application/src/test/java/org/thingsboard/server/controller/AuditLogControllerTest_DedicatedDataSource.java → application/src/test/java/org/thingsboard/server/controller/AuditLogControllerTest_DedicatedEventsDataSource.java

@@ -19,18 +19,18 @@ import lombok.Getter;
 import org.springframework.boot.test.mock.mockito.SpyBean;
 import org.springframework.test.context.TestPropertySource;
 import org.thingsboard.server.dao.service.DaoSqlTest;
-import org.thingsboard.server.dao.sqlts.insert.sql.DedicatedSqlPartitioningRepository;
+import org.thingsboard.server.dao.sqlts.insert.sql.DedicatedEventsSqlPartitioningRepository;
 
 @DaoSqlTest
 @TestPropertySource(properties = {
-        "spring.datasource.dedicated.enabled=true",
+        "spring.datasource.events.enabled=true",
-        "spring.datasource.dedicated.url=${spring.datasource.url}",
+        "spring.datasource.events.url=${spring.datasource.url}",
-        "spring.datasource.dedicated.driverClassName=${spring.datasource.driverClassName}",
+        "spring.datasource.events.driverClassName=${spring.datasource.driverClassName}",
 })
-public class AuditLogControllerTest_DedicatedDataSource extends AuditLogControllerTest {
+public class AuditLogControllerTest_DedicatedEventsDataSource extends AuditLogControllerTest {
 
     @Getter
     @SpyBean
-    private DedicatedSqlPartitioningRepository partitioningRepository;
+    private DedicatedEventsSqlPartitioningRepository partitioningRepository;
 
 }

dao/src/main/java/org/thingsboard/server/dao/config/DedicatedDataSource.java → dao/src/main/java/org/thingsboard/server/dao/config/DedicatedEventsDataSource.java

@@ -21,6 +21,6 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
 @Retention(RetentionPolicy.RUNTIME)
-@ConditionalOnProperty(value = "spring.datasource.dedicated.enabled", havingValue = "true")
+@ConditionalOnProperty(value = "spring.datasource.events.enabled", havingValue = "true")
-public @interface DedicatedDataSource {
+public @interface DedicatedEventsDataSource {
 }

dao/src/main/java/org/thingsboard/server/dao/config/DedicatedJpaDaoConfig.java → dao/src/main/java/org/thingsboard/server/dao/config/DedicatedEventsJpaDaoConfig.java

@@ -38,60 +38,53 @@ import org.thingsboard.server.dao.model.sql.StatisticsEventEntity;
 import javax.sql.DataSource;
 import java.util.Objects;
 
-/*
+@DedicatedEventsDataSource
- * To make entity use a dedicated datasource:
- * - add its JpaRepository to exclusions list in @EnableJpaRepositories in JpaDaoConfig
- * - add the package of this JpaRepository to @EnableJpaRepositories in DefaultDedicatedJpaDaoConfig
- * - add the package of this JpaRepository to @EnableJpaRepositories in DedicatedJpaDaoConfig
- * - add the entity class to packages list in dedicatedEntityManagerFactory in DedicatedJpaDaoConfig
- * */
-@DedicatedDataSource
 @Configuration
 @EnableJpaRepositories(value = {"org.thingsboard.server.dao.sql.event", "org.thingsboard.server.dao.sql.audit"},
         bootstrapMode = BootstrapMode.LAZY,
-        entityManagerFactoryRef = "dedicatedEntityManagerFactory", transactionManagerRef = "dedicatedTransactionManager")
+        entityManagerFactoryRef = "eventsEntityManagerFactory", transactionManagerRef = "eventsTransactionManager")
-public class DedicatedJpaDaoConfig {
+public class DedicatedEventsJpaDaoConfig {
 
-    public static final String DEDICATED_PERSISTENCE_UNIT = "dedicated";
+    public static final String EVENTS_PERSISTENCE_UNIT = "events";
-    public static final String DEDICATED_TRANSACTION_MANAGER = DEDICATED_PERSISTENCE_UNIT + "TransactionManager";
+    public static final String EVENTS_TRANSACTION_MANAGER = EVENTS_PERSISTENCE_UNIT + "TransactionManager";
-    public static final String DEDICATED_TRANSACTION_TEMPLATE = DEDICATED_PERSISTENCE_UNIT + "TransactionTemplate";
+    public static final String EVENTS_TRANSACTION_TEMPLATE = EVENTS_PERSISTENCE_UNIT + "TransactionTemplate";
-    public static final String DEDICATED_JDBC_TEMPLATE = DEDICATED_PERSISTENCE_UNIT + "JdbcTemplate";
+    public static final String EVENTS_JDBC_TEMPLATE = EVENTS_PERSISTENCE_UNIT + "JdbcTemplate";
 
     @Bean
-    @ConfigurationProperties("spring.datasource.dedicated")
+    @ConfigurationProperties("spring.datasource.events")
-    public DataSourceProperties dedicatedDataSourceProperties() {
+    public DataSourceProperties eventsDataSourceProperties() {
         return new DataSourceProperties();
     }
 
-    @ConfigurationProperties(prefix = "spring.datasource.dedicated.hikari")
+    @ConfigurationProperties(prefix = "spring.datasource.events.hikari")
     @Bean
-    public DataSource dedicatedDataSource(@Qualifier("dedicatedDataSourceProperties") DataSourceProperties dedicatedDataSourceProperties) {
+    public DataSource eventsDataSource(@Qualifier("eventsDataSourceProperties") DataSourceProperties eventsDataSourceProperties) {
-        return dedicatedDataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
+        return eventsDataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource.class).build();
     }
 
     @Bean
-    public LocalContainerEntityManagerFactoryBean dedicatedEntityManagerFactory(@Qualifier("dedicatedDataSource") DataSource dedicatedDataSource,
+    public LocalContainerEntityManagerFactoryBean eventsEntityManagerFactory(@Qualifier("eventsDataSource") DataSource eventsDataSource,
                                                                                 EntityManagerFactoryBuilder builder) {
         return builder
-                .dataSource(dedicatedDataSource)
+                .dataSource(eventsDataSource)
                 .packages(LifecycleEventEntity.class, StatisticsEventEntity.class, ErrorEventEntity.class, RuleNodeDebugEventEntity.class, RuleChainDebugEventEntity.class, AuditLogEntity.class)
-                .persistenceUnit(DEDICATED_PERSISTENCE_UNIT)
+                .persistenceUnit(EVENTS_PERSISTENCE_UNIT)
                 .build();
     }
 
-    @Bean(DEDICATED_TRANSACTION_MANAGER)
+    @Bean(EVENTS_TRANSACTION_MANAGER)
-    public JpaTransactionManager dedicatedTransactionManager(@Qualifier("dedicatedEntityManagerFactory") LocalContainerEntityManagerFactoryBean dedicatedEntityManagerFactory) {
+    public JpaTransactionManager eventsTransactionManager(@Qualifier("eventsEntityManagerFactory") LocalContainerEntityManagerFactoryBean eventsEntityManagerFactory) {
-        return new JpaTransactionManager(Objects.requireNonNull(dedicatedEntityManagerFactory.getObject()));
+        return new JpaTransactionManager(Objects.requireNonNull(eventsEntityManagerFactory.getObject()));
     }
 
-    @Bean(DEDICATED_TRANSACTION_TEMPLATE)
+    @Bean(EVENTS_TRANSACTION_TEMPLATE)
-    public TransactionTemplate dedicatedTransactionTemplate(@Qualifier(DEDICATED_TRANSACTION_MANAGER) JpaTransactionManager dedicatedTransactionManager) {
+    public TransactionTemplate eventsTransactionTemplate(@Qualifier(EVENTS_TRANSACTION_MANAGER) JpaTransactionManager eventsTransactionManager) {
-        return new TransactionTemplate(dedicatedTransactionManager);
+        return new TransactionTemplate(eventsTransactionManager);
     }
 
-    @Bean(DEDICATED_JDBC_TEMPLATE)
+    @Bean(EVENTS_JDBC_TEMPLATE)
-    public JdbcTemplate dedicatedJdbcTemplate(@Qualifier("dedicatedDataSource") DataSource dedicatedDataSource) {
+    public JdbcTemplate eventsJdbcTemplate(@Qualifier("eventsDataSource") DataSource eventsDataSource) {
-        return new JdbcTemplate(dedicatedDataSource);
+        return new JdbcTemplate(eventsDataSource);
     }
 
 }

dao/src/main/java/org/thingsboard/server/dao/config/DefaultDataSource.java

@@ -21,6 +21,6 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
 @Retention(RetentionPolicy.RUNTIME)
-@ConditionalOnProperty(value = "spring.datasource.dedicated.enabled", havingValue = "false", matchIfMissing = true)
+@ConditionalOnProperty(value = "spring.datasource.events.enabled", havingValue = "false", matchIfMissing = true)
 public @interface DefaultDataSource {
 }

dao/src/main/java/org/thingsboard/server/dao/sql/audit/DedicatedJpaAuditLogDao.java

@@ -24,51 +24,51 @@ import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.common.data.audit.AuditLog;
 import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.dao.config.DedicatedDataSource;
+import org.thingsboard.server.dao.config.DedicatedEventsDataSource;
-import org.thingsboard.server.dao.sqlts.insert.sql.DedicatedSqlPartitioningRepository;
+import org.thingsboard.server.dao.sqlts.insert.sql.DedicatedEventsSqlPartitioningRepository;
 import org.thingsboard.server.dao.util.SqlDao;
 
 import java.util.Collection;
 import java.util.UUID;
 
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_JDBC_TEMPLATE;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_JDBC_TEMPLATE;
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_PERSISTENCE_UNIT;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_PERSISTENCE_UNIT;
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_TRANSACTION_MANAGER;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_TRANSACTION_MANAGER;
 
-@DedicatedDataSource
+@DedicatedEventsDataSource
 @Component
 @SqlDao
 public class DedicatedJpaAuditLogDao extends JpaAuditLogDao {
 
     @Autowired
-    @Qualifier(DEDICATED_JDBC_TEMPLATE)
+    @Qualifier(EVENTS_JDBC_TEMPLATE)
     private JdbcTemplate jdbcTemplate;
-    @PersistenceContext(unitName = DEDICATED_PERSISTENCE_UNIT)
+    @PersistenceContext(unitName = EVENTS_PERSISTENCE_UNIT)
     private EntityManager entityManager;
 
-    public DedicatedJpaAuditLogDao(AuditLogRepository auditLogRepository, DedicatedSqlPartitioningRepository partitioningRepository) {
+    public DedicatedJpaAuditLogDao(AuditLogRepository auditLogRepository, DedicatedEventsSqlPartitioningRepository partitioningRepository) {
         super(auditLogRepository, partitioningRepository);
     }
 
-    @Transactional(transactionManager = DEDICATED_TRANSACTION_MANAGER)
+    @Transactional(transactionManager = EVENTS_TRANSACTION_MANAGER)
     @Override
     public AuditLog save(TenantId tenantId, AuditLog domain) {
         return super.save(tenantId, domain);
     }
 
-    @Transactional(transactionManager = DEDICATED_TRANSACTION_MANAGER)
+    @Transactional(transactionManager = EVENTS_TRANSACTION_MANAGER)
     @Override
     public AuditLog saveAndFlush(TenantId tenantId, AuditLog domain) {
         return super.saveAndFlush(tenantId, domain);
     }
 
-    @Transactional(transactionManager = DEDICATED_TRANSACTION_MANAGER)
+    @Transactional(transactionManager = EVENTS_TRANSACTION_MANAGER)
     @Override
     public boolean removeById(TenantId tenantId, UUID id) {
         return super.removeById(tenantId, id);
     }
 
-    @Transactional(transactionManager = DEDICATED_TRANSACTION_MANAGER)
+    @Transactional(transactionManager = EVENTS_TRANSACTION_MANAGER)
     @Override
     public void removeAllByIds(Collection<UUID> ids) {
         super.removeAllByIds(ids);

dao/src/main/java/org/thingsboard/server/dao/sql/event/DedicatedEventInsertRepository.java

@@ -19,17 +19,17 @@ import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.support.TransactionTemplate;
-import org.thingsboard.server.dao.config.DedicatedDataSource;
+import org.thingsboard.server.dao.config.DedicatedEventsDataSource;
 
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_JDBC_TEMPLATE;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_JDBC_TEMPLATE;
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_TRANSACTION_TEMPLATE;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_TRANSACTION_TEMPLATE;
 
-@DedicatedDataSource
+@DedicatedEventsDataSource
 @Repository
 public class DedicatedEventInsertRepository extends EventInsertRepository {
 
-    public DedicatedEventInsertRepository(@Qualifier(DEDICATED_JDBC_TEMPLATE) JdbcTemplate jdbcTemplate,
+    public DedicatedEventInsertRepository(@Qualifier(EVENTS_JDBC_TEMPLATE) JdbcTemplate jdbcTemplate,
-                                          @Qualifier(DEDICATED_TRANSACTION_TEMPLATE) TransactionTemplate transactionTemplate) {
+                                          @Qualifier(EVENTS_TRANSACTION_TEMPLATE) TransactionTemplate transactionTemplate) {
         super(jdbcTemplate, transactionTemplate);
     }
 

dao/src/main/java/org/thingsboard/server/dao/sql/event/DedicatedJpaEventDao.java

@@ -17,18 +17,18 @@ package org.thingsboard.server.dao.sql.event;
 
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.stats.StatsFactory;
-import org.thingsboard.server.dao.config.DedicatedDataSource;
+import org.thingsboard.server.dao.config.DedicatedEventsDataSource;
 import org.thingsboard.server.dao.sql.ScheduledLogExecutorComponent;
-import org.thingsboard.server.dao.sqlts.insert.sql.DedicatedSqlPartitioningRepository;
+import org.thingsboard.server.dao.sqlts.insert.sql.DedicatedEventsSqlPartitioningRepository;
 import org.thingsboard.server.dao.util.SqlDao;
 
-@DedicatedDataSource
+@DedicatedEventsDataSource
 @Component
 @SqlDao
 public class DedicatedJpaEventDao extends JpaBaseEventDao {
 
     public DedicatedJpaEventDao(EventPartitionConfiguration partitionConfiguration,
-                                DedicatedSqlPartitioningRepository partitioningRepository,
+                                DedicatedEventsSqlPartitioningRepository partitioningRepository,
                                 LifecycleEventRepository lcEventRepository,
                                 StatisticsEventRepository statsEventRepository,
                                 ErrorEventRepository errorEventRepository,

dao/src/main/java/org/thingsboard/server/dao/sqlts/insert/sql/DedicatedSqlPartitioningRepository.java → dao/src/main/java/org/thingsboard/server/dao/sqlts/insert/sql/DedicatedEventsSqlPartitioningRepository.java

@@ -21,27 +21,27 @@ import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
-import org.thingsboard.server.dao.config.DedicatedDataSource;
+import org.thingsboard.server.dao.config.DedicatedEventsDataSource;
 import org.thingsboard.server.dao.timeseries.SqlPartition;
 
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_JDBC_TEMPLATE;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_JDBC_TEMPLATE;
-import static org.thingsboard.server.dao.config.DedicatedJpaDaoConfig.DEDICATED_TRANSACTION_MANAGER;
+import static org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig.EVENTS_TRANSACTION_MANAGER;
 
-@DedicatedDataSource
+@DedicatedEventsDataSource
 @Repository
-public class DedicatedSqlPartitioningRepository extends SqlPartitioningRepository {
+public class DedicatedEventsSqlPartitioningRepository extends SqlPartitioningRepository {
 
     @Autowired
-    @Qualifier(DEDICATED_JDBC_TEMPLATE)
+    @Qualifier(EVENTS_JDBC_TEMPLATE)
     private JdbcTemplate jdbcTemplate;
 
-    @Transactional(propagation = Propagation.NOT_SUPPORTED, transactionManager = DEDICATED_TRANSACTION_MANAGER)
+    @Transactional(propagation = Propagation.NOT_SUPPORTED, transactionManager = EVENTS_TRANSACTION_MANAGER)
     @Override
     public void save(SqlPartition partition) {
         super.save(partition);
     }
 
-    @Transactional(propagation = Propagation.NOT_SUPPORTED, transactionManager = DEDICATED_TRANSACTION_MANAGER)
+    @Transactional(propagation = Propagation.NOT_SUPPORTED, transactionManager = EVENTS_TRANSACTION_MANAGER)
     @Override
     public void createPartitionIfNotExists(String table, long entityTs, long partitionDurationMs) {
         super.createPartitionIfNotExists(table, entityTs, partitionDurationMs);

dao/src/test/java/org/thingsboard/server/dao/AbstractDaoServiceTest.java

@@ -25,14 +25,14 @@ import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
 import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
 import org.thingsboard.server.common.stats.StatsFactory;
-import org.thingsboard.server.dao.config.DedicatedJpaDaoConfig;
+import org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig;
 import org.thingsboard.server.dao.config.JpaDaoConfig;
 import org.thingsboard.server.dao.config.SqlTsDaoConfig;
 import org.thingsboard.server.dao.config.SqlTsLatestDaoConfig;
 import org.thingsboard.server.dao.service.DaoSqlTest;
 
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = {JpaDaoConfig.class, SqlTsDaoConfig.class, SqlTsLatestDaoConfig.class, DedicatedJpaDaoConfig.class})
+@ContextConfiguration(classes = {JpaDaoConfig.class, SqlTsDaoConfig.class, SqlTsLatestDaoConfig.class, DedicatedEventsJpaDaoConfig.class})
 @DaoSqlTest
 @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
 @TestExecutionListeners({

dao/src/test/java/org/thingsboard/server/dao/AbstractJpaDaoTest.java

@@ -24,7 +24,7 @@ import org.springframework.test.context.junit4.SpringRunner;
 import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
 import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
 import org.thingsboard.server.common.stats.StatsFactory;
-import org.thingsboard.server.dao.config.DedicatedJpaDaoConfig;
+import org.thingsboard.server.dao.config.DedicatedEventsJpaDaoConfig;
 import org.thingsboard.server.dao.config.DefaultDedicatedJpaDaoConfig;
 import org.thingsboard.server.dao.config.JpaDaoConfig;
 import org.thingsboard.server.dao.config.SqlTsDaoConfig;
@@ -35,7 +35,7 @@ import org.thingsboard.server.dao.service.DaoSqlTest;
  * Created by Valerii Sosliuk on 4/22/2017.
  */
 @RunWith(SpringRunner.class)
-@ContextConfiguration(classes = {JpaDaoConfig.class, SqlTsDaoConfig.class, SqlTsLatestDaoConfig.class, DedicatedJpaDaoConfig.class, DefaultDedicatedJpaDaoConfig.class})
+@ContextConfiguration(classes = {JpaDaoConfig.class, SqlTsDaoConfig.class, SqlTsLatestDaoConfig.class, DedicatedEventsJpaDaoConfig.class, DefaultDedicatedJpaDaoConfig.class})
 @DaoSqlTest
 @TestExecutionListeners({
         DependencyInjectionTestExecutionListener.class,

dao/src/test/java/org/thingsboard/server/dao/PostgreSqlInitializer.java

@@ -52,17 +52,6 @@ public class PostgreSqlInitializer {
         }
         log.info("Postgres DB is initialized!");
     }
-    public static void initDedicatedDb(Connection conn) {
-        log.info("initialize Postgres DB...");
-        try {
-                URL sqlFileUrl = Resources.getResource("sql/dedicated.sql");
-                String sql = Resources.toString(sqlFileUrl, Charsets.UTF_8);
-                conn.createStatement().execute(sql);
-        } catch (IOException | SQLException e) {
-            throw new RuntimeException("Unable to init the Postgres database. Reason: " + e.getMessage(), e);
-        }
-        log.info("Postgres DB is initialized!");
-    }
 
     private static void cleanUpDb(Connection conn) {
         log.info("clean up Postgres DB...");
@@ -74,4 +63,5 @@ public class PostgreSqlInitializer {
             throw new RuntimeException("Unable to clean up the Postgres database. Reason: " + e.getMessage(), e);
         }
     }
+
 }

dao/src/test/java/org/thingsboard/server/dao/service/event/sql/EventServiceSqlTest_DedicatedDataSource.java → dao/src/test/java/org/thingsboard/server/dao/service/event/sql/EventServiceSqlTest_DedicatedEventsDataSource.java

@@ -20,9 +20,9 @@ import org.thingsboard.server.dao.service.DaoSqlTest;
 
 @DaoSqlTest
 @TestPropertySource(properties = {
-        "spring.datasource.dedicated.enabled=true",
+        "spring.datasource.events.enabled=true",
-        "spring.datasource.dedicated.url=${spring.datasource.url}",
+        "spring.datasource.events.url=${spring.datasource.url}",
-        "spring.datasource.dedicated.driverClassName=${spring.datasource.driverClassName}"
+        "spring.datasource.events.driverClassName=${spring.datasource.driverClassName}"
 })
-public class EventServiceSqlTest_DedicatedDataSource extends EventServiceSqlTest {
+public class EventServiceSqlTest_DedicatedEventsDataSource extends EventServiceSqlTest {
 }