io.agroal.api.AgroalDataSource Java Examples

@GET
@Path("/{dataSourceName}/{jdbcUrl}/{username}/{minSize}/{maxSize}")
public String test(@PathParam("dataSourceName") String dataSourceName, @PathParam("jdbcUrl") String jdbcUrl,
        @PathParam("username") String username,
        @PathParam("minSize") int minSize, @PathParam("maxSize") int maxSize) throws Exception {
    AgroalDataSource ds;
    if (dataSourceName.equals("default")) {
        ds = CDI.current().select(AgroalDataSource.class)
                .get();
    } else {
        ds = CDI.current().select(AgroalDataSource.class, new DataSource.DataSourceLiteral(dataSourceName))
                .get();
    }
    testDataSource(dataSourceName, ds, URLDecoder.decode(jdbcUrl, StandardCharsets.UTF_8.name()), username, minSize,
            maxSize);
    return "ok";
}
 

private static void dataSourceAssert(String dataSourceName, AgroalDataSource dataSource, String jdbcUrl, String username,
        int minSize, int maxSize)
        throws SQLException {
    AgroalConnectionPoolConfiguration configuration = null;

    try {
        configuration = dataSource.getConfiguration().connectionPoolConfiguration();
    } catch (NullPointerException e) {
        // we catch the NPE here as we have a proxy and we can't test dataSource directly
        fail("Datasource " + dataSourceName + " should not be null");
    }
    assertEquals(jdbcUrl, configuration.connectionFactoryConfiguration().jdbcUrl());
    assertEquals(username, configuration.connectionFactoryConfiguration().principal().getName());
    assertEquals(minSize, configuration.minSize());
    assertEquals(maxSize, configuration.maxSize());
    assertFalse(dataSource.getConfiguration().metricsEnabled()); // metrics not enabled by default

    try (Connection connection = dataSource.getConnection()) {
    }
}
 

private static void testDataSource(AgroalDataSource dataSource, String username, int minSize, int maxSize,
        int initialSize, Duration backgroundValidationInterval, Duration acquisitionTimeout, Duration leakDetectionInterval,
        Duration idleRemovalInterval, Duration maxLifetime, String newConnectionSql) throws SQLException {
    AgroalConnectionPoolConfiguration configuration = dataSource.getConfiguration().connectionPoolConfiguration();
    AgroalConnectionFactoryConfiguration agroalConnectionFactoryConfiguration = configuration
            .connectionFactoryConfiguration();

    assertEquals("jdbc:h2:tcp://localhost/mem:default", agroalConnectionFactoryConfiguration.jdbcUrl());
    assertEquals(username, agroalConnectionFactoryConfiguration.principal().getName());
    assertEquals(minSize, configuration.minSize());
    assertEquals(maxSize, configuration.maxSize());
    assertEquals(initialSize, configuration.initialSize());
    assertEquals(backgroundValidationInterval, configuration.validationTimeout());
    assertEquals(acquisitionTimeout, configuration.acquisitionTimeout());
    assertEquals(leakDetectionInterval, configuration.leakTimeout());
    assertEquals(idleRemovalInterval, configuration.reapTimeout());
    assertEquals(maxLifetime, configuration.maxLifetime());
    assertTrue(configuration.transactionIntegration() instanceof NarayanaTransactionIntegration);
    assertEquals(AgroalConnectionFactoryConfiguration.TransactionIsolation.SERIALIZABLE,
            agroalConnectionFactoryConfiguration.jdbcTransactionIsolation());
    assertTrue(agroalConnectionFactoryConfiguration.trackJdbcResources());
    assertTrue(dataSource.getConfiguration().metricsEnabled());
    assertEquals(newConnectionSql, agroalConnectionFactoryConfiguration.initialSql());
    try (Connection connection = dataSource.getConnection()) {
    }
}
 

static void testDataSource(String dataSourceName, AgroalDataSource dataSource, String jdbcUrl, String username,
        int minSize, int maxSize)
        throws SQLException {
    AgroalConnectionPoolConfiguration configuration = null;

    try {
        configuration = dataSource.getConfiguration().connectionPoolConfiguration();
    } catch (NullPointerException e) {
        // we catch the NPE here as we have a proxy and we can't test dataSource directly
        fail("Datasource " + dataSourceName + " should not be null");
    }
    assertEquals(jdbcUrl, configuration.connectionFactoryConfiguration().jdbcUrl());
    assertEquals(username, configuration.connectionFactoryConfiguration().principal().getName());
    assertEquals(minSize, configuration.minSize());
    assertEquals(maxSize, configuration.maxSize());

    try (Connection connection = dataSource.getConnection()) {
    }
}
 

private static void testDataSource(String dataSourceName, AgroalDataSource dataSource, String jdbcUrl, String username,
        int minSize, int maxSize)
        throws SQLException {
    AgroalConnectionPoolConfiguration configuration = null;

    try {
        configuration = dataSource.getConfiguration().connectionPoolConfiguration();
    } catch (NullPointerException e) {
        // we catch the NPE here as we have a proxy and we can't test dataSource directly
        fail("Datasource " + dataSourceName + " should not be null");
    }
    assertEquals(jdbcUrl, configuration.connectionFactoryConfiguration().jdbcUrl());
    assertEquals(username, configuration.connectionFactoryConfiguration().principal().getName());
    assertEquals(minSize, configuration.minSize());
    assertEquals(maxSize, configuration.maxSize());

    try (Connection connection = dataSource.getConnection()) {
    }
}
 

private static void testDataSource(AgroalDataSource dataSource, String username, int minSize, int maxSize,
        int initialSize, Duration backgroundValidationInterval, Duration acquisitionTimeout, Duration leakDetectionInterval,
        Duration idleRemovalInterval, Duration maxLifetime, String newConnectionSql) throws SQLException {
    AgroalConnectionPoolConfiguration configuration = dataSource.getConfiguration().connectionPoolConfiguration();
    AgroalConnectionFactoryConfiguration agroalConnectionFactoryConfiguration = configuration
            .connectionFactoryConfiguration();

    assertEquals("jdbc:h2:tcp://localhost/mem:default", agroalConnectionFactoryConfiguration.jdbcUrl());
    assertEquals(username, agroalConnectionFactoryConfiguration.principal().getName());
    assertEquals(minSize, configuration.minSize());
    assertEquals(maxSize, configuration.maxSize());
    assertEquals(initialSize, configuration.initialSize());
    assertEquals(backgroundValidationInterval, configuration.validationTimeout());
    assertEquals(acquisitionTimeout, configuration.acquisitionTimeout());
    assertEquals(leakDetectionInterval, configuration.leakTimeout());
    assertEquals(idleRemovalInterval, configuration.reapTimeout());
    assertEquals(maxLifetime, configuration.maxLifetime());
    assertTrue(configuration.transactionIntegration() instanceof NarayanaTransactionIntegration);
    assertEquals(AgroalConnectionFactoryConfiguration.TransactionIsolation.SERIALIZABLE,
            agroalConnectionFactoryConfiguration.jdbcTransactionIsolation());
    assertTrue(agroalConnectionFactoryConfiguration.trackJdbcResources());
    assertTrue(dataSource.getConfiguration().metricsEnabled());
    assertEquals(newConnectionSql, agroalConnectionFactoryConfiguration.initialSql());
    try (Connection connection = dataSource.getConnection()) {
    }
}
 

private static void testDataSource(AgroalDataSource dataSource, String username, int minSize, int maxSize,
        int initialSize, Duration backgroundValidationInterval, Duration acquisitionTimeout, Duration leakDetectionInterval,
        Duration idleRemovalInterval, Duration maxLifetime, String newConnectionSql) throws SQLException {
    AgroalConnectionPoolConfiguration configuration = dataSource.getConfiguration().connectionPoolConfiguration();
    AgroalConnectionFactoryConfiguration agroalConnectionFactoryConfiguration = configuration
            .connectionFactoryConfiguration();

    assertEquals("jdbc:h2:tcp://localhost/mem:default", agroalConnectionFactoryConfiguration.jdbcUrl());
    assertEquals(username, agroalConnectionFactoryConfiguration.principal().getName());
    assertEquals(minSize, configuration.minSize());
    assertEquals(maxSize, configuration.maxSize());
    assertEquals(initialSize, configuration.initialSize());
    assertEquals(backgroundValidationInterval, configuration.validationTimeout());
    assertEquals(acquisitionTimeout, configuration.acquisitionTimeout());
    assertEquals(leakDetectionInterval, configuration.leakTimeout());
    assertEquals(idleRemovalInterval, configuration.reapTimeout());
    assertEquals(maxLifetime, configuration.maxLifetime());
    assertTrue(configuration.transactionIntegration() instanceof NarayanaTransactionIntegration);
    assertEquals(AgroalConnectionFactoryConfiguration.TransactionIsolation.SERIALIZABLE,
            agroalConnectionFactoryConfiguration.jdbcTransactionIsolation());
    assertTrue(agroalConnectionFactoryConfiguration.trackJdbcResources());
    assertTrue(dataSource.getConfiguration().metricsEnabled());
    assertEquals(newConnectionSql, agroalConnectionFactoryConfiguration.initialSql());
    try (Connection connection = dataSource.getConnection()) {
    }
}
 

private AgroalDataSource getDataSource() {
    AgroalDataSource dsLocal = dataSource;
    if (dsLocal == null) {
        synchronized (this) {
            dsLocal = dataSource;
            if (dsLocal == null) {
                if (dataSourceName == null || DataSourceUtil.isDefault(dataSourceName)) {
                    dataSource = dsLocal = Arc.container().instance(AgroalDataSource.class).get();
                } else {
                    dataSource = dsLocal = Arc.container()
                            .instance(AgroalDataSource.class, new DataSourceLiteral(dataSourceName))
                            .get();
                }
            }
        }
    }
    return dsLocal;
}
 

private AgroalDataSource getDataSource() {
    AgroalDataSource dsLocal = dataSource;
    if (dsLocal == null) {
        synchronized (this) {
            dsLocal = dataSource;
            if (dsLocal == null) {
                if (dataSourceName == null || DataSourceUtil.isDefault(dataSourceName)) {
                    dataSource = dsLocal = Arc.container().instance(AgroalDataSource.class).get();
                } else {
                    dataSource = dsLocal = Arc.container()
                            .instance(AgroalDataSource.class, new DataSourceLiteral(dataSourceName))
                            .get();
                }
            }
        }
    }
    return dsLocal;
}
 

@Override
public ConnectionProvider resolve(String tenantId) {

    LOG.debugv("resolve({0})", tenantId);

    final MultiTenancyStrategy strategy = jpaConfig.getMultiTenancyStrategy();
    LOG.debugv("multitenancy strategy: {0}", strategy);
    AgroalDataSource dataSource = tenantDataSource(jpaConfig, tenantId, strategy);
    if (dataSource == null) {
        throw new IllegalStateException("No instance of datasource found for tenant: " + tenantId);
    }
    if (strategy == MultiTenancyStrategy.SCHEMA) {
        return new TenantConnectionProvider(tenantId, dataSource);
    }
    return new QuarkusConnectionProvider(dataSource);
}
 

public QuarkusQuartzConnectionPoolProvider() {
    final ArcContainer container = Arc.container();
    final InstanceHandle<AgroalDataSource> instanceHandle;
    final boolean useDefaultDataSource = "QUARKUS_QUARTZ_DEFAULT_DATASOURCE".equals(dataSourceName);
    if (useDefaultDataSource) {
        instanceHandle = container.instance(AgroalDataSource.class);
    } else {
        instanceHandle = container.instance(AgroalDataSource.class, new DataSourceLiteral(dataSourceName));
    }
    if (instanceHandle.isAvailable()) {
        this.dataSource = instanceHandle.get();
    } else {
        String message = String.format(
                "JDBC Store configured but '%s' datasource is missing. You can configure your datasource by following the guide available at: https://quarkus.io/guides/datasource",
                useDefaultDataSource ? "default" : dataSourceName);
        throw new IllegalStateException(message);
    }
}
 

/**
 * Returns either the default data source or the tenant specific one.
 * 
 * @param tenantId Tenant identifier. The value is required (non-{@literal null}) in case of
 *        {@link MultiTenancyStrategy#DATABASE}.
 * @param strategy Current multitenancy strategy Required value that cannot be {@literal null}.
 * 
 * @return Data source.
 */
private static AgroalDataSource tenantDataSource(JPAConfig jpaConfig, String tenantId, MultiTenancyStrategy strategy) {
    if (strategy != MultiTenancyStrategy.SCHEMA) {
        return Arc.container().instance(AgroalDataSource.class, new DataSource.DataSourceLiteral(tenantId)).get();
    }
    String dataSourceName = jpaConfig.getMultiTenancySchemaDataSource();
    if (dataSourceName == null) {
        AgroalDataSource dataSource = Arc.container().instance(AgroalDataSource.class).get();
        return createFrom(dataSource.getConfiguration());
    }
    return Arc.container().instance(AgroalDataSource.class, new DataSource.DataSourceLiteral(dataSourceName)).get();
}
 

@PreDestroy
public void stop() {
    for (AgroalDataSource dataSource : dataSources.values()) {
        if (dataSource != null) {
            dataSource.close();
        }
    }
}
 

@Override
public boolean isUnwrappableAs(final Class unwrapType) {
    return ConnectionProvider.class.equals(unwrapType) ||
            QuarkusConnectionProvider.class.isAssignableFrom(unwrapType) ||
            DataSource.class.isAssignableFrom(unwrapType) ||
            AgroalDataSource.class.isAssignableFrom(unwrapType);
}
 

@Override
public <T> T unwrap(final Class<T> unwrapType) {
    if (ConnectionProvider.class.equals(unwrapType) ||
            QuarkusConnectionProvider.class.isAssignableFrom(unwrapType)) {
        return (T) this;
    } else if (DataSource.class.isAssignableFrom(unwrapType) || AgroalDataSource.class.isAssignableFrom(unwrapType)) {
        return (T) dataSource;
    } else {
        throw new UnknownUnwrapTypeException(unwrapType);
    }
}
 

public static AgroalDataSource createDataSource(DataSourceConfig dsc, boolean jtaPresent) {
    AgroalDataSourceConfigurationSupplier dataSourceConfig = new AgroalDataSourceConfigurationSupplier();

    AgroalConnectionPoolConfigurationSupplier poolConfig = dataSourceConfig.connectionPoolConfiguration();

    AgroalConnectionFactoryConfigurationSupplier connectionFactoryConfig = poolConfig.connectionFactoryConfiguration();

    if (!jtaPresent) {
        dataSourceConfig.dataSourceImplementation(DataSourceImplementation.HIKARI);
    } else {
        poolConfig.transactionIntegration( JtaProvider.getInstance().getTransactionIntegration() );
    }

    if (!StringUtils.isNullOrEmpty( dsc.getDriverClass() )) {
        connectionFactoryConfig.connectionProviderClassName(dsc.getDriverClass());
    } else if (!StringUtils.isNullOrEmpty( dsc.getDataSourceClass( ))) {
        connectionFactoryConfig.connectionProviderClassName(dsc.getDataSourceClass());
    }

    if (!StringUtils.isNullOrEmpty( dsc.getConnectionUrl() )) {
        connectionFactoryConfig.jdbcUrl(dsc.getConnectionUrl());
    }

    setDatabaseCredentials(connectionFactoryConfig, dsc.getUsername(), dsc.getPassword());

    setConnectionPoolConfiguration(poolConfig, connectionFactoryConfig, dsc.getPool(), !jtaPresent);

    dsc.getProps().forEach(connectionFactoryConfig::jdbcProperty);

    try {
        return AgroalDataSource.from( dataSourceConfig );
    } catch (SQLException e) {
        throw new KumuluzServerException("Failed to create DataSource", e);
    }
}
 

public static AgroalDataSource createXaDataSource(XaDataSourceConfig xdsc, boolean jtaPresent) {
    AgroalDataSourceConfigurationSupplier xaDataSourceConfig = new AgroalDataSourceConfigurationSupplier();

    AgroalConnectionPoolConfigurationSupplier poolConfig = xaDataSourceConfig.connectionPoolConfiguration();

    AgroalConnectionFactoryConfigurationSupplier connectionFactoryConfig = poolConfig.connectionFactoryConfiguration();

    if (jtaPresent) {
        poolConfig.transactionIntegration( JtaProvider.getInstance().getTransactionIntegration() );
    }

    if (!StringUtils.isNullOrEmpty( xdsc.getXaDatasourceClass() )) {
        connectionFactoryConfig.connectionProviderClassName( xdsc.getXaDatasourceClass() );
    }

    setDatabaseCredentials(connectionFactoryConfig, xdsc.getUsername(), xdsc.getPassword());

    setConnectionPoolConfiguration(poolConfig, connectionFactoryConfig, xdsc.getPool(), false);

    xdsc.getProps().forEach(connectionFactoryConfig::jdbcProperty);

    try {
        return AgroalDataSource.from( xaDataSourceConfig );
    } catch (SQLException e) {
        throw new KumuluzServerException("Failed to create XaDataSource", e);
    }
}
 

@Override
public int maximumPoolSize(DataSource dataSource, JsonObject config) throws SQLException {
  if (dataSource instanceof AgroalDataSource) {
    return ((AgroalDataSource) dataSource).getConfiguration().connectionPoolConfiguration().maxSize();
  }
  return -1;
}
 

/**
 * Create a new data source from the given configuration.
 * 
 * @param config Configuration to use.
 * 
 * @return New data source instance.
 */
private static AgroalDataSource createFrom(AgroalDataSourceConfiguration config) {
    try {
        return AgroalDataSource.from(config);
    } catch (SQLException ex) {
        throw new IllegalStateException("Failed to create a new data source based on the default config", ex);
    }
}
 

public AgroalDataSource getDataSource(String dataSourceName) {
    return dataSources.computeIfAbsent(dataSourceName, new Function<String, AgroalDataSource>() {
        @Override
        public AgroalDataSource apply(String s) {
            return doCreateDataSource(s);
        }
    });
}
 

public Supplier<AgroalDataSource> agroalDataSourceSupplier(String dataSourceName,
        @SuppressWarnings("unused") DataSourcesRuntimeConfig dataSourcesRuntimeConfig) {
    final AgroalDataSource agroalDataSource = DataSources.fromName(dataSourceName);
    return new Supplier<AgroalDataSource>() {
        @Override
        public AgroalDataSource get() {
            return agroalDataSource;
        }
    };
}
 

public TenantConnectionProvider(String tenantId, AgroalDataSource dataSource) {
    super(dataSource);
    this.tenantId = tenantId;
}
 

public QuarkusConnectionProvider(final AgroalDataSource dataSource) {
    this.dataSource = dataSource;
}
 

@Substitute
static AgroalDataSource from(AgroalDataSourceConfiguration configuration, AgroalDataSourceListener... listeners)
        throws SQLException {
    return new DataSource(configuration, listeners);
}
 

@Record(ExecutionTime.RUNTIME_INIT)
@BuildStep
void generateDataSourceBeans(AgroalRecorder recorder,
        DataSourcesRuntimeConfig dataSourcesRuntimeConfig,
        List<AggregatedDataSourceBuildTimeConfigBuildItem> aggregatedBuildTimeConfigBuildItems,
        SslNativeConfigBuildItem sslNativeConfig,
        Capabilities capabilities,
        BuildProducer<SyntheticBeanBuildItem> syntheticBeanBuildItemBuildProducer,
        BuildProducer<JdbcDataSourceBuildItem> jdbcDataSource) {
    if (aggregatedBuildTimeConfigBuildItems.isEmpty()) {
        // No datasource has been configured so bail out
        return;
    }

    for (Map.Entry<String, DataSourceSupport.Entry> entry : getDataSourceSupport(aggregatedBuildTimeConfigBuildItems,
            sslNativeConfig,
            capabilities).entries.entrySet()) {

        String dataSourceName = entry.getKey();

        SyntheticBeanBuildItem.ExtendedBeanConfigurator configurator = SyntheticBeanBuildItem
                .configure(AgroalDataSource.class)
                .addType(DATA_SOURCE)
                .scope(Singleton.class)
                .setRuntimeInit()
                .unremovable()
                // pass the runtime config into the recorder to ensure that the DataSource related beans
                // are created after runtime configuration has been setup
                .supplier(recorder.agroalDataSourceSupplier(dataSourceName, dataSourcesRuntimeConfig));

        if (entry.getValue().isDefault) {
            configurator.addQualifier(Default.class);
        } else {
            // this definitely not ideal, but 'elytron-jdbc-security' uses it (although it could be easily changed)
            // which means that perhaps other extensions might depend on this as well...
            configurator.name(dataSourceName);

            configurator.addQualifier().annotation(DotNames.NAMED).addValue("value", dataSourceName).done();
            configurator.addQualifier().annotation(DataSource.class).addValue("value", dataSourceName).done();
        }

        syntheticBeanBuildItemBuildProducer.produce(configurator.done());

        jdbcDataSource.produce(new JdbcDataSourceBuildItem(dataSourceName,
                entry.getValue().resolvedDbKind,
                entry.getValue().isDefault));
    }
}
 

public void setDataSource(AgroalDataSource dataSource) {
    this.dataSource = dataSource;
}
 

@Override
public void close(DataSource dataSource) throws SQLException {
  if (dataSource instanceof AgroalDataSource) {
    ((AgroalDataSource) dataSource).close();
  }
}
 

/**
 * Meant to be used from recorders that create synthetic beans that need access to {@code Datasource}.
 * In such using {@code Arc.container.instance(DataSource.class)} is not possible because
 * {@code Datasource} is itself a synthetic bean.
 * <p>
 * This method relies on the fact that {@code DataSources} should - given the same input -
 * always return the same {@code AgroalDataSource} no matter how many times it is invoked
 * (which makes sense because {@code DataSource} is a {@code Singleton} bean).
 * <p>
 * This method is thread-safe
 */
public static AgroalDataSource fromName(String dataSourceName) {
    return Arc.container().instance(DataSources.class).get()
            .getDataSource(dataSourceName);
}