private boolean isConnectToProxy(final DataSource[] dataSources) { for (DataSource each : dataSources) { try (Connection connection = each.getConnection()) { DatabaseMetaData databaseMetaData = connection.getMetaData(); if (databaseMetaData.getDatabaseProductVersion().contains(PROXY_TAG)) { return true; } } catch (SQLException ex) { throw new ShardingException("Get databaseMetaData failed: ", ex); } } return false; }
private void init() { try { underlyingTransactionManager.init(); } catch (SystemException ex) { throw new ShardingException(ex); } }
private static Object convertDateValue(final Object value, final Class<?> convertType) { Date date = (Date) value; switch (convertType.getName()) { case "java.sql.Date": return new java.sql.Date(date.getTime()); case "java.sql.Time": return new Time(date.getTime()); case "java.sql.Timestamp": return new Timestamp(date.getTime()); default: throw new ShardingException("Unsupported Date type:%s", convertType); } } }
@Override public void begin(final XATransactionContext transactionContext) throws ShardingException { try { underlyingTransactionManager.begin(); } catch (final SystemException | NotSupportedException ex) { throw new ShardingException(ex); } }
@Override public void commit(final XATransactionContext transactionContext) throws ShardingException { try { underlyingTransactionManager.commit(); } catch (final RollbackException | HeuristicMixedException | HeuristicRollbackException | SystemException ex) { throw new ShardingException(ex); } }
/** * Initialize sharding tracer. */ public static void init() { String tracerClassName = System.getProperty(OPENTRACING_TRACER_CLASS_NAME); Preconditions.checkNotNull(tracerClassName, "Can not find opentracing tracer implementation class via system property `%s`", OPENTRACING_TRACER_CLASS_NAME); try { init((Tracer) Class.forName(tracerClassName).newInstance()); } catch (final ReflectiveOperationException ex) { throw new ShardingException("Initialize opentracing tracer class failure.", ex); } }
@Override public int getStatus() throws ShardingException { try { return underlyingTransactionManager.getStatus(); } catch (final SystemException ex) { throw new ShardingException(ex); } }
private XATransactionManager load() { try { if (xaTransactionManagers.size() > 1) { log.warn("There are more than one transaction mangers existing, chosen first one by default."); } if (xaTransactionManagers.isEmpty()) { return new AtomikosTransactionManager(); } return xaTransactionManagers.iterator().next(); } catch (final Exception ex) { throw new ShardingException("Can not initialize the xaTransaction manager failed with " + ex); } }
/** * Create XA DataSource instance. * * @param databaseType database type * @return XA DataSource instance */ public static XADataSource build(final DatabaseType databaseType) { String xaDataSourceClassName = XA_DRIVER_CLASS_NAMES.get(databaseType); Class xaDataSourceClass; try { xaDataSourceClass = Thread.currentThread().getContextClassLoader().loadClass(xaDataSourceClassName); } catch (final ClassNotFoundException ignored) { try { xaDataSourceClass = Class.forName(xaDataSourceClassName); } catch (final ClassNotFoundException ex) { throw new ShardingException("Failed to load [%s]", xaDataSourceClassName); } } try { return (XADataSource) xaDataSourceClass.newInstance(); } catch (final InstantiationException | IllegalAccessException ex) { throw new ShardingException("Failed to instance [%s]", xaDataSourceClassName); } } }
private void setTransactionManagerHandler(final PlatformTransactionManager transactionManager) { switch (TransactionManagerType.getTransactionManagerTypeByClassName(transactionManager.getClass().getName())) { case DATASOURCE: transactionManagerHandler = new DataSourceTransactionManagerHandler(transactionManager); break; case JPA: transactionManagerHandler = new JpaTransactionManagerHandler(transactionManager); break; case UNSUPPORTED: default: throw new ShardingException(String.format("Switching transaction Type is unsupported for transaction manager %s", transactionManager.getClass().getName())); } }
@Override public final void switchTransactionType(final TransactionType transactionType) { Connection connection = getConnectionFromTransactionManager(); try (Statement statement = connection.createStatement()) { statement.execute(String.format(SET_TRANSACTION_TYPE_SQL, transactionType.name())); } catch (final SQLException ex) { throw new ShardingException("Switch transaction type for sharding-proxy failed: ", ex); } }
private static Object convertNumberValue(final Object value, final Class<?> convertType) { Number number = (Number) value; switch (convertType.getName()) { case "byte": return number.byteValue(); case "short": return number.shortValue(); case "int": return number.intValue(); case "long": return number.longValue(); case "double": return number.doubleValue(); case "float": return number.floatValue(); case "java.math.BigDecimal": return new BigDecimal(number.toString()); case "java.lang.Object": return value; case "java.lang.String": return value.toString(); default: throw new ShardingException("Unsupported data type:%s", convertType); } }
@Override public void rollback(final XATransactionContext transactionContext) throws ShardingException { try { if (Status.STATUS_NO_TRANSACTION != getStatus()) { underlyingTransactionManager.rollback(); } } catch (final SystemException ex) { throw new ShardingException(ex); } }
@Override public DataSource wrapDataSource(final DatabaseType databaseType, final XADataSource xaDataSource, final String dataSourceName, final DataSourceParameter dataSourceParameter) { try { return new AtomikosDataSourceBeanWrapper().wrap(databaseType, xaDataSource, dataSourceName, dataSourceParameter); } catch (final Exception ex) { throw new ShardingException("Failed to wrap XADataSource to transactional datasource pool", ex); } }
@Override protected Connection getConnectionFromTransactionManager() { try { Connection result = transactionManager.getDataSource().getConnection(); TransactionSynchronizationManager.bindResource(transactionManager.getDataSource(), new ConnectionHolder(result)); return result; } catch (final SQLException ex) { throw new ShardingException("Could not open JDBC Connection before transaction", ex); } } }
static AbstractBeanDefinition getBeanDefinitionByElement(final Element element) { String type = element.getLocalName(); switch (type) { case ShardingStrategyBeanDefinitionParserTag.STANDARD_STRATEGY_ROOT_TAG: return getStandardShardingStrategyConfigBeanDefinition(element); case ShardingStrategyBeanDefinitionParserTag.COMPLEX_STRATEGY_ROOT_TAG: return getComplexShardingStrategyConfigBeanDefinition(element); case ShardingStrategyBeanDefinitionParserTag.INLINE_STRATEGY_ROOT_TAG: return getInlineShardingStrategyConfigBeanDefinition(element); case ShardingStrategyBeanDefinitionParserTag.HINT_STRATEGY_ROOT_TAG: return getHintShardingStrategyConfigBeanDefinition(element); case ShardingStrategyBeanDefinitionParserTag.NONE_STRATEGY_ROOT_TAG: return getNoneShardingStrategyConfigBeanDefinition(); default: throw new ShardingException("Cannot support type: %s", type); } }