public JdbcStoreReader(StoreProperties props) { this.props = props; this.marshaller = SerializationConfigUtil.getMarshaller(props); this.config = JdbcConfigurationUtil.getStoreConfig(props); this.connectionFactory = new PooledConnectionFactory(); String segmentCount = props.get(Element.SEGMENT_COUNT); this.metaData = new DbMetaData(config.dialect(), config.dbMajorVersion(), config.dbMinorVersion(), false, false, // If we don't have segments then disable it segmentCount == null || Integer.parseInt(segmentCount) <= 0); this.stringConfig = config.table(); this.binaryConfig = createBinaryTableConfig(); connectionFactory.start(config.connectionFactory(), JdbcStoreReader.class.getClassLoader()); }
@Override public void start() { if (configuration.manageConnectionFactory()) { ConnectionFactory factory = ConnectionFactory.getConnectionFactory(configuration.connectionFactory().connectionFactoryClass()); factory.start(configuration.connectionFactory(), factory.getClass().getClassLoader()); initializeConnectionFactory(factory); } try { Object mapper = Util.loadClassStrict(configuration.key2StringMapper(), globalConfiguration.classLoader()).newInstance(); if (mapper instanceof Key2StringMapper) key2StringMapper = (Key2StringMapper) mapper; } catch (Exception e) { log.errorf("Trying to instantiate %s, however it failed due to %s", configuration.key2StringMapper(), e.getClass().getName()); throw new IllegalStateException("This should not happen.", e); } if (trace) { log.tracef("Using key2StringMapper: %s", key2StringMapper.getClass().getName()); } if (configuration.preload()) { enforceTwoWayMapper("preload"); } if (isDistributedCache) { enforceTwoWayMapper("distribution/rehashing"); } }
@Override public String toString() { return "JdbcStringBasedStoreConfiguration [table=" + table + ", attributes=" + attributes + ", connectionFactory=" + connectionFactory() + ", async=" + async() + ", singletonStore()=" + singletonStore() + "]"; }
public static TableManager getManager(ConnectionFactory connectionFactory, JdbcStringBasedStoreConfiguration config) { DbMetaData metaData = getDbMetaData(connectionFactory, config.dialect(), config.dbMajorVersion(), config.dbMinorVersion(), isPropertyDisabled(config, UPSERT_DISABLED), isPropertyDisabled(config, INDEXING_DISABLED), !config.segmented()); return getManager(metaData, connectionFactory, config.table()); }
JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) cacheManager.getDefaultCacheConfiguration().persistence().stores().get(0); assertEquals(128, store.table().batchSize()); assertEquals(34, store.table().fetchSize()); assertEquals("BINARY", store.table().dataColumnType()); assertEquals("version", store.table().timestampColumnName()); assertTrue(store.async().enabled()); assertEquals("DummyKey2StringMapper", store.key2StringMapper()); assertTrue(store.shared()); assertTrue(store.preload()); assertEquals(DatabaseType.H2, store.dialect()); PooledConnectionFactoryConfiguration connectionFactory = (PooledConnectionFactoryConfiguration) store.connectionFactory(); assertEquals("jdbc:h2:mem:infinispan;DB_CLOSE_DELAY=-1", connectionFactory.connectionUrl()); assertEquals("org.h2.Driver", connectionFactory.driverClass()); assertEquals("dbuser", connectionFactory.username()); assertEquals("dbpass", connectionFactory.password()); assertTrue(store.ignoreModifications()); assertTrue(store.fetchPersistentState()); assertTrue(store.purgeOnStartup()); assertFalse(store.singletonStore().enabled());
Configuration configuration = b.build(); JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0); assert store.connectionFactory() instanceof PooledConnectionFactoryConfiguration; assert ((PooledConnectionFactoryConfiguration)store.connectionFactory()).connectionUrl().equals(JDBC_URL); assert store.table().tableNamePrefix().equals("STRINGS_"); assert store.table().idColumnName().equals("id"); assert store.table().idColumnType().equals("VARCHAR"); assert store.table().dataColumnName().equals("datum"); assert store.table().dataColumnType().equals("BINARY"); assert store.table().timestampColumnName().equals("version"); assert store.table().timestampColumnType().equals("BIGINT"); assert store.fetchPersistentState(); assert store.async().enabled(); Configuration configuration2 = b.build(); JdbcStringBasedStoreConfiguration store2 = (JdbcStringBasedStoreConfiguration) configuration2.persistence().stores().get(0); assert store2.connectionFactory() instanceof PooledConnectionFactoryConfiguration; assert ((PooledConnectionFactoryConfiguration)store2.connectionFactory()).connectionUrl().equals(JDBC_URL); assert store2.table().tableNamePrefix().equals("STRINGS_"); assert store2.table().idColumnName().equals("id"); assert store2.table().idColumnType().equals("VARCHAR"); assert store2.table().dataColumnName().equals("datum"); assert store2.table().dataColumnType().equals("BINARY"); assert store2.table().timestampColumnName().equals("version"); assert store2.table().timestampColumnType().equals("BIGINT"); assert store2.fetchPersistentState(); assert store2.async().enabled();
@Override public Builder<?> read(JdbcStringBasedStoreConfiguration template) { super.read(template); this.table.read(template.table()); return this; }
@Override public void stop() { Throwable cause = null; try { tableManager.stop(); tableManager = null; } catch (Throwable t) { cause = t.getCause(); if (cause == null) cause = t; log.debug("Exception while stopping", t); } try { if (configuration.connectionFactory() instanceof ManagedConnectionFactory) { log.tracef("Stopping managed connection factory: %s", connectionFactory); connectionFactory.stop(); } } catch (Throwable t) { if (cause == null) { cause = t; } else { t.addSuppressed(cause); } log.debug("Exception while stopping", t); } if (cause != null) { throw new PersistenceException("Exceptions occurred while stopping store", cause); } }
private TwoWayKey2StringMapper getTwoWayMapper() { String mapperClass = config.key2StringMapper(); if (mapperClass != null) { ClassLoader classLoader = JdbcConfigurationUtil.class.getClassLoader(); try { return (TwoWayKey2StringMapper) Util.loadClass(mapperClass, classLoader).newInstance(); } catch (IllegalAccessException | InstantiationException e) { throw new CacheConfigurationException(String.format("Unabled to load TwoWayKey2StringMapper '%s' for %s store", mapperClass, SOURCE), e); } } return new DefaultTwoWayKey2StringMapper(); } }
@Override public void serialize(XMLExtendedStreamWriter writer, JdbcStringBasedStoreConfiguration configuration) throws XMLStreamException { writer.writeStartElement(Element.STRING_KEYED_JDBC_STORE); writeJdbcStoreAttributes(writer, configuration); writeCommonStoreSubAttributes(writer, configuration); writeJDBCStoreTable(writer, Element.STRING_KEYED_TABLE, configuration.table()); writeJDBCStoreConnection(writer, configuration); writeCommonStoreElements(writer, configuration); writer.writeEndElement(); }
public void testImplicitPooledConnectionFactory() { ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .connectionPool().connectionUrl(JDBC_URL); Configuration configuration = b.build(); JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0); assert store.connectionFactory() instanceof PooledConnectionFactoryConfiguration; }
@Override protected void compareStoreConfiguration(String name, StoreConfiguration beforeStore, StoreConfiguration afterStore) { if (beforeStore instanceof AbstractJdbcStoreConfiguration) { AbstractJdbcStoreConfiguration before = (AbstractJdbcStoreConfiguration) beforeStore; AbstractJdbcStoreConfiguration after = (AbstractJdbcStoreConfiguration) afterStore; assertEquals("Configuration " + name + " JDBC connection factory", before.connectionFactory(), after.connectionFactory()); } if (beforeStore instanceof JdbcStringBasedStoreConfiguration) { JdbcStringBasedStoreConfiguration before = (JdbcStringBasedStoreConfiguration) beforeStore; JdbcStringBasedStoreConfiguration after = (JdbcStringBasedStoreConfiguration) afterStore; compareAttributeSets("Configuration " + name + " table", before.table().attributes(), after.table().attributes()); } super.compareStoreConfiguration(name, beforeStore, afterStore); } }
public void testImplicitManagedConnectionFactory() { ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .dataSource().jndiUrl("java:jboss/datasources/ExampleDS"); Configuration configuration = b.build(); JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0); assert store.connectionFactory() instanceof ManagedConnectionFactoryConfiguration; }
public void testTableProperties() { Properties props = new Properties(); props.put("createOnStart", "false"); props.put("dropOnExit", "true"); ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .connectionPool().connectionUrl(JDBC_URL) .withProperties(props); Configuration stringConfiguration = b.build(); JdbcStringBasedStoreConfiguration stringStoreConfiguration = (JdbcStringBasedStoreConfiguration) stringConfiguration.persistence().stores().get(0); assertFalse(stringStoreConfiguration.table().createOnStart()); assertTrue(stringStoreConfiguration.table().dropOnExit()); } }