/*
* HA-JDBC: High-Availability JDBC
* Copyright (C) 2012 Paul Ferraro
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package net.sf.hajdbc.sql;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.beans.PropertyEditor;
import java.beans.PropertyEditorManager;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlID;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.XmlValue;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import net.sf.hajdbc.Database;
import net.sf.hajdbc.DatabaseClusterConfiguration;
import net.sf.hajdbc.DatabaseFactory;
import net.sf.hajdbc.ExecutorServiceProvider;
import net.sf.hajdbc.Identifiable;
import net.sf.hajdbc.IdentifiableMatcher;
import net.sf.hajdbc.Messages;
import net.sf.hajdbc.SynchronizationStrategy;
import net.sf.hajdbc.TransactionMode;
import net.sf.hajdbc.balancer.BalancerFactory;
import net.sf.hajdbc.cache.DatabaseMetaDataCacheFactory;
import net.sf.hajdbc.codec.DecoderFactory;
import net.sf.hajdbc.codec.MultiplexingDecoderFactory;
import net.sf.hajdbc.dialect.DialectFactory;
import net.sf.hajdbc.distributed.CommandDispatcherFactory;
import net.sf.hajdbc.durability.DurabilityFactory;
import net.sf.hajdbc.io.InputSinkProvider;
import net.sf.hajdbc.lock.LockManagerFactory;
import net.sf.hajdbc.management.DefaultMBeanRegistrar;
import net.sf.hajdbc.management.MBeanRegistrar;
import net.sf.hajdbc.state.StateManagerFactory;
import net.sf.hajdbc.tx.SimpleTransactionIdentifierFactory;
import net.sf.hajdbc.tx.TransactionIdentifierFactory;
import net.sf.hajdbc.tx.UUIDTransactionIdentifierFactory;
import net.sf.hajdbc.util.ServiceLoaders;
import net.sf.hajdbc.util.concurrent.cron.CronExpression;
/**
* @author Paul Ferraro
*/
@XmlType(propOrder = { "commandDispatcherFactoryDescriptor", "synchronizationStrategyDescriptors", "stateManagerFactoryDescriptor", "lockManagerFactoryDescriptor" })
public abstract class AbstractDatabaseClusterConfiguration<Z, D extends Database<Z>> implements DatabaseClusterConfiguration<Z, D>
{
private static final long serialVersionUID = -2808296483725374829L;
private CommandDispatcherFactory dispatcherFactory;
private Map<String, SynchronizationStrategy> synchronizationStrategies = new HashMap<String, SynchronizationStrategy>();
private StateManagerFactory stateManagerFactory = ServiceLoaders.findRequiredService(StateManagerFactory.class);
private LockManagerFactory lockManagerFactory = ServiceLoaders.findRequiredService(LockManagerFactory.class);
protected abstract NestedConfiguration<Z, D> getNestedConfiguration();
@Override
public DatabaseFactory<Z, D> getDatabaseFactory()
{
return this.getNestedConfiguration().getDatabaseFactory();
}
@XmlElement(name = "distributable")
private CommandDispatcherFactoryDescriptor getCommandDispatcherFactoryDescriptor() throws Exception
{
return (this.dispatcherFactory != null) ? new CommandDispatcherFactoryDescriptorAdapter().marshal(this.dispatcherFactory) : null;
}
@SuppressWarnings("unused")
private void setCommandDispatcherFactoryDescriptor(CommandDispatcherFactoryDescriptor descriptor) throws Exception
{
this.dispatcherFactory = (descriptor != null) ? new CommandDispatcherFactoryDescriptorAdapter().unmarshal(descriptor) : null;
}
@XmlElement(name = "sync")
private SynchronizationStrategyDescriptor[] getSynchronizationStrategyDescriptors() throws Exception
{
List<SynchronizationStrategyDescriptor> results = new ArrayList<SynchronizationStrategyDescriptor>(this.synchronizationStrategies.size());
SynchronizationStrategyDescriptorAdapter adapter = new SynchronizationStrategyDescriptorAdapter();
for (Map.Entry<String, SynchronizationStrategy> entry: this.synchronizationStrategies.entrySet())
{
SynchronizationStrategyDescriptor result = adapter.marshal(entry.getValue());
result.setId(entry.getKey());
results.add(result);
}
return results.toArray(new SynchronizationStrategyDescriptor[results.size()]);
}
@SuppressWarnings("unused")
private void setSynchronizationStrategyDescriptors(SynchronizationStrategyDescriptor[] entries) throws Exception
{
SynchronizationStrategyDescriptorAdapter adapter = new SynchronizationStrategyDescriptorAdapter();
for (SynchronizationStrategyDescriptor entry: entries)
{
SynchronizationStrategy strategy = adapter.unmarshal(entry);
this.synchronizationStrategies.put(entry.getId(), strategy);
}
}
@XmlElement(name = "state")
private StateManagerFactoryDescriptor getStateManagerFactoryDescriptor() throws Exception
{
return new StateManagerFactoryDescriptorAdapter().marshal(this.stateManagerFactory);
}
@SuppressWarnings("unused")
private void setStateManagerFactoryDescriptor(StateManagerFactoryDescriptor descriptor) throws Exception
{
this.stateManagerFactory = new StateManagerFactoryDescriptorAdapter().unmarshal(descriptor);
}
@XmlElement(name = "lock")
private LockManagerFactoryDescriptor getLockManagerFactoryDescriptor() throws Exception
{
return new LockManagerFactoryDescriptorAdapter().marshal(this.lockManagerFactory);
}
@SuppressWarnings("unused")
private void setLockManagerFactoryDescriptor(LockManagerFactoryDescriptor descriptor) throws Exception
{
this.lockManagerFactory = new LockManagerFactoryDescriptorAdapter().unmarshal(descriptor);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getAutoActivationExpression()
*/
@Override
public CronExpression getAutoActivationExpression()
{
return this.getNestedConfiguration().getAutoActivationExpression();
}
public void setAutoActivationExpression(CronExpression expression)
{
this.getNestedConfiguration().setAutoActivationExpression(expression);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getBalancerFactory()
*/
@Override
public BalancerFactory getBalancerFactory()
{
return this.getNestedConfiguration().getBalancerFactory();
}
public void setBalancerFactory(BalancerFactory factory)
{
this.getNestedConfiguration().setBalancerFactory(factory);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDispatcherFactory()
*/
@Override
public CommandDispatcherFactory getDispatcherFactory()
{
return this.dispatcherFactory;
}
public void setDispatcherFactory(CommandDispatcherFactory factory)
{
this.dispatcherFactory = factory;
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDatabaseMap()
*/
@Override
public ConcurrentMap<String, D> getDatabaseMap()
{
return this.getNestedConfiguration().getDatabaseMap();
}
public void setDatabases(Collection<D> databases)
{
Map<String, D> map = this.getDatabaseMap();
for (D database: databases)
{
map.put(database.getId(), database);
}
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDatabaseMetaDataCacheFactory()
*/
@Override
public DatabaseMetaDataCacheFactory getDatabaseMetaDataCacheFactory()
{
return this.getNestedConfiguration().getDatabaseMetaDataCacheFactory();
}
public void setDatabaseMetaDataCacheFactory(DatabaseMetaDataCacheFactory factory)
{
this.getNestedConfiguration().setDatabaseMetaDataCacheFactory(factory);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDefaultSynchronizationStrategy()
*/
@Override
public String getDefaultSynchronizationStrategy()
{
return this.getNestedConfiguration().getDefaultSynchronizationStrategy();
}
public void setDefaultSynchronizationStrategy(String strategy)
{
this.getNestedConfiguration().setDefaultSynchronizationStrategy(strategy);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDialectFactory()
*/
@Override
public DialectFactory getDialectFactory()
{
return this.getNestedConfiguration().getDialectFactory();
}
public void setDialectFactory(DialectFactory factory)
{
this.getNestedConfiguration().setDialectFactory(factory);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDurabilityFactory()
*/
@Override
public DurabilityFactory getDurabilityFactory()
{
return this.getNestedConfiguration().getDurabilityFactory();
}
public void setDurabilityFactory(DurabilityFactory factory)
{
this.getNestedConfiguration().setDurabilityFactory(factory);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getExecutorProvider()
*/
@Override
public ExecutorServiceProvider getExecutorProvider()
{
return this.getNestedConfiguration().getExecutorProvider();
}
public void setExecutorProvider(ExecutorServiceProvider provider)
{
this.getNestedConfiguration().setExecutorProvider(provider);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getThreadFactory()
*/
@Override
public ThreadFactory getThreadFactory()
{
return this.getNestedConfiguration().getThreadFactory();
}
public void setThreadFactory(ThreadFactory factory)
{
this.getNestedConfiguration().setThreadFactory(factory);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getDecoderFactory()
*/
@Override
public DecoderFactory getDecoderFactory()
{
return this.getNestedConfiguration().getDecoderFactory();
}
public void setCodecFactory(DecoderFactory factory)
{
this.getNestedConfiguration().setDecoderFactory(factory);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getFailureDetectionExpression()
*/
@Override
public CronExpression getFailureDetectionExpression()
{
return this.getNestedConfiguration().getFailureDetectionExpression();
}
public void setFailureDetectionExpression(CronExpression expression)
{
this.getNestedConfiguration().setFailureDetectionExpression(expression);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getStateManagerFactory()
*/
@Override
public StateManagerFactory getStateManagerFactory()
{
return this.stateManagerFactory;
}
public void setStateManagerFactory(StateManagerFactory factory)
{
this.stateManagerFactory = factory;
}
@Override
public LockManagerFactory getLockManagerFactory()
{
return this.lockManagerFactory;
}
public void setLockManagerFactory(LockManagerFactory factory)
{
this.lockManagerFactory = factory;
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getSynchronizationStrategyMap()
*/
@Override
public Map<String, SynchronizationStrategy> getSynchronizationStrategyMap()
{
return this.synchronizationStrategies;
}
public void setSynchronizationStrategyMap(Map<String, SynchronizationStrategy> strategies)
{
this.synchronizationStrategies = strategies;
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getTransactionMode()
*/
@Override
public TransactionMode getTransactionMode()
{
return this.getNestedConfiguration().getTransactionMode();
}
public void setTransactionMode(TransactionMode mode)
{
this.getNestedConfiguration().setTransactionMode(mode);
}
@Override
public InputSinkProvider getInputSinkProvider()
{
return this.getNestedConfiguration().getInputSinkProvider();
}
public void setInputSinkFactoryProvider(InputSinkProvider provider)
{
this.getNestedConfiguration().setSinkSourceProvider(provider);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isCurrentDateEvaluationEnabled()
*/
@Override
public boolean isCurrentDateEvaluationEnabled()
{
return this.getNestedConfiguration().isCurrentDateEvaluationEnabled();
}
public void setCurrentDateEvaluationEnabled(boolean enabled)
{
this.getNestedConfiguration().setCurrentDateEvaluationEnabled(enabled);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isCurrentTimeEvaluationEnabled()
*/
@Override
public boolean isCurrentTimeEvaluationEnabled()
{
return this.getNestedConfiguration().isCurrentTimeEvaluationEnabled();
}
public void setCurrentTimeEvaluationEnabled(boolean enabled)
{
this.getNestedConfiguration().setCurrentTimeEvaluationEnabled(enabled);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isCurrentTimestampEvaluationEnabled()
*/
@Override
public boolean isCurrentTimestampEvaluationEnabled()
{
return this.getNestedConfiguration().isCurrentTimestampEvaluationEnabled();
}
public void setCurrentTimestampEvaluationEnabled(boolean enabled)
{
this.getNestedConfiguration().setCurrentTimestampEvaluationEnabled(enabled);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isIdentityColumnDetectionEnabled()
*/
@Override
public boolean isIdentityColumnDetectionEnabled()
{
return this.getNestedConfiguration().isIdentityColumnDetectionEnabled();
}
public void setIdentityColumnDetectionEnabled(boolean enabled)
{
this.getNestedConfiguration().setIdentityColumnDetectionEnabled(enabled);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isRandEvaluationEnabled()
*/
@Override
public boolean isRandEvaluationEnabled()
{
return this.getNestedConfiguration().isRandEvaluationEnabled();
}
public void setRandEvaluationEnabled(boolean enabled)
{
this.getNestedConfiguration().setRandEvaluationEnabled(enabled);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isSequenceDetectionEnabled()
*/
@Override
public boolean isSequenceDetectionEnabled()
{
return this.getNestedConfiguration().isSequenceDetectionEnabled();
}
public void setSequenceDetectionEnabled(boolean enabled)
{
this.getNestedConfiguration().setSequenceDetectionEnabled(enabled);
}
static Map<String, Map.Entry<PropertyDescriptor, PropertyEditor>> findDescriptors(Class<?> targetClass) throws Exception
{
Map<String, Map.Entry<PropertyDescriptor, PropertyEditor>> map = new HashMap<String, Map.Entry<PropertyDescriptor, PropertyEditor>>();
for (PropertyDescriptor descriptor: Introspector.getBeanInfo(targetClass).getPropertyDescriptors())
{
if ((descriptor.getReadMethod() != null) && (descriptor.getWriteMethod() != null))
{
PropertyEditor editor = PropertyEditorManager.findEditor(descriptor.getPropertyType());
if (editor != null)
{
map.put(descriptor.getName(), new AbstractMap.SimpleImmutableEntry<PropertyDescriptor, PropertyEditor>(descriptor, editor));
}
}
}
return map;
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getMBeanRegistrar()
*/
@Override
public MBeanRegistrar<Z, D> getMBeanRegistrar()
{
return this.getNestedConfiguration().getMBeanRegistrar();
}
public void setMBeanRegistrar(MBeanRegistrar<Z, D> registrar)
{
this.getNestedConfiguration().setMBeanRegistrar(registrar);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isEmptyClusterAllowed()
*/
@Override
public boolean isEmptyClusterAllowed()
{
return this.getNestedConfiguration().isEmptyClusterAllowed();
}
public void setEmptyClusterAllowed(boolean emptyClusterAllowed)
{
this.getNestedConfiguration().setEmptyClusterAllowed(emptyClusterAllowed);
}
/**
* {@inheritDoc}
* @see net.sf.hajdbc.DatabaseClusterConfiguration#getTransactionIdentifierFactory()
*/
@Override
public TransactionIdentifierFactory<? extends Object> getTransactionIdentifierFactory()
{
return (this.dispatcherFactory != null) ? new UUIDTransactionIdentifierFactory() : new SimpleTransactionIdentifierFactory();
}
@XmlType(name = "abstractNestedConfiguration")
protected static abstract class NestedConfiguration<Z, D extends Database<Z>> implements DatabaseClusterConfiguration<Z, D>, DatabaseFactory<Z, D>
{
private static final long serialVersionUID = -5674156614205147546L;
@XmlJavaTypeAdapter(BalancerFactoryAdapter.class)
@XmlAttribute(name = "balancer")
private BalancerFactory balancerFactory = ServiceLoaders.findService(BalancerFactory.class);
@XmlJavaTypeAdapter(DatabaseMetaDataCacheFactoryAdapter.class)
@XmlAttribute(name = "meta-data-cache")
private DatabaseMetaDataCacheFactory databaseMetaDataCacheFactory = ServiceLoaders.findService(DatabaseMetaDataCacheFactory.class);
@XmlJavaTypeAdapter(DialectFactoryAdapter.class)
@XmlAttribute(name = "dialect")
private DialectFactory dialectFactory = ServiceLoaders.findService(DialectFactory.class);
@XmlJavaTypeAdapter(DurabilityFactoryAdapter.class)
@XmlAttribute(name = "durability")
private DurabilityFactory durabilityFactory = ServiceLoaders.findService(DurabilityFactory.class);
@XmlJavaTypeAdapter(SinkSourceProviderAdapter.class)
@XmlAttribute(name = "input-sink")
private InputSinkProvider sinkSourceProvider = ServiceLoaders.findService(InputSinkProvider.class);
private ExecutorServiceProvider executorProvider = new DefaultExecutorServiceProvider();
private ThreadFactory threadFactory = Executors.defaultThreadFactory();
private DecoderFactory decoderFactory = new MultiplexingDecoderFactory();
private MBeanRegistrar<Z, D> registrar = new DefaultMBeanRegistrar<Z, D>();
@XmlJavaTypeAdapter(TransactionModeAdapter.class)
@XmlAttribute(name = "transaction-mode")
private TransactionMode transactionMode = TransactionModeEnum.SERIAL;
@XmlJavaTypeAdapter(CronExpressionAdapter.class)
@XmlAttribute(name = "auto-activate-schedule")
private CronExpression autoActivationExpression;
@XmlJavaTypeAdapter(CronExpressionAdapter.class)
@XmlAttribute(name = "failure-detect-schedule")
private CronExpression failureDetectionExpression;
@XmlAttribute(name = "eval-current-date")
private Boolean currentDateEvaluationEnabled = false;
@XmlAttribute(name = "eval-current-time")
private Boolean currentTimeEvaluationEnabled = false;
@XmlAttribute(name = "eval-current-timestamp")
private Boolean currentTimestampEvaluationEnabled = false;
@XmlAttribute(name = "eval-rand")
private Boolean randEvaluationEnabled = false;
@XmlAttribute(name = "detect-identity-columns")
private Boolean identityColumnDetectionEnabled = false;
@XmlAttribute(name = "detect-sequences")
private Boolean sequenceDetectionEnabled = false;
@XmlAttribute(name = "allow-empty-cluster")
private Boolean emptyClusterAllowed = false;
private String defaultSynchronizationStrategy;
private ConcurrentMap<String, D> databases = new ConcurrentHashMap<String, D>();
@Override
public DatabaseFactory<Z, D> getDatabaseFactory()
{
return this;
}
@XmlIDREF
@XmlAttribute(name = "default-sync", required = true)
private SynchronizationStrategyDescriptor getDefaultSynchronizationStrategyDescriptor()
{
SynchronizationStrategyDescriptor descriptor = new SynchronizationStrategyDescriptor();
descriptor.setId(this.defaultSynchronizationStrategy);
return descriptor;
}
@SuppressWarnings("unused")
private void setDefaultSynchronizationStrategyDescriptor(SynchronizationStrategyDescriptor descriptor)
{
this.defaultSynchronizationStrategy = descriptor.getId();
}
@Override
public ConcurrentMap<String, D> getDatabaseMap()
{
return this.databases;
}
@Override
public CronExpression getAutoActivationExpression()
{
return this.autoActivationExpression;
}
void setAutoActivationExpression(CronExpression expression)
{
this.autoActivationExpression = expression;
}
@Override
public BalancerFactory getBalancerFactory()
{
return this.balancerFactory;
}
void setBalancerFactory(BalancerFactory factory)
{
this.balancerFactory = factory;
}
@Override
public CommandDispatcherFactory getDispatcherFactory()
{
throw new IllegalStateException();
}
@Override
public DatabaseMetaDataCacheFactory getDatabaseMetaDataCacheFactory()
{
return this.databaseMetaDataCacheFactory;
}
void setDatabaseMetaDataCacheFactory(DatabaseMetaDataCacheFactory factory)
{
this.databaseMetaDataCacheFactory = factory;
}
@Override
public String getDefaultSynchronizationStrategy()
{
return this.defaultSynchronizationStrategy;
}
void setDefaultSynchronizationStrategy(String strategy)
{
this.defaultSynchronizationStrategy = strategy;
}
@Override
public DialectFactory getDialectFactory()
{
return this.dialectFactory;
}
void setDialectFactory(DialectFactory factory)
{
this.dialectFactory = factory;
}
@Override
public DurabilityFactory getDurabilityFactory()
{
return this.durabilityFactory;
}
void setDurabilityFactory(DurabilityFactory factory)
{
this.durabilityFactory = factory;
}
@Override
public ExecutorServiceProvider getExecutorProvider()
{
return this.executorProvider;
}
void setExecutorProvider(ExecutorServiceProvider provider)
{
this.executorProvider = provider;
}
@Override
public ThreadFactory getThreadFactory()
{
return this.threadFactory;
}
void setThreadFactory(ThreadFactory factory)
{
this.threadFactory = factory;
}
@Override
public DecoderFactory getDecoderFactory()
{
return this.decoderFactory;
}
void setDecoderFactory(DecoderFactory factory)
{
this.decoderFactory = factory;
}
@Override
public MBeanRegistrar<Z, D> getMBeanRegistrar()
{
return this.registrar;
}
void setMBeanRegistrar(MBeanRegistrar<Z, D> registrar)
{
this.registrar = registrar;
}
@Override
public CronExpression getFailureDetectionExpression()
{
return this.failureDetectionExpression;
}
void setFailureDetectionExpression(CronExpression expression)
{
this.failureDetectionExpression = expression;
}
@Override
public StateManagerFactory getStateManagerFactory()
{
throw new IllegalStateException();
}
@Override
public LockManagerFactory getLockManagerFactory()
{
throw new IllegalStateException();
}
@Override
public Map<String, SynchronizationStrategy> getSynchronizationStrategyMap()
{
throw new IllegalStateException();
}
@Override
public TransactionMode getTransactionMode()
{
return this.transactionMode;
}
void setTransactionMode(TransactionMode mode)
{
this.transactionMode = mode;
}
@Override
public InputSinkProvider getInputSinkProvider()
{
return this.sinkSourceProvider;
}
void setSinkSourceProvider(InputSinkProvider provider)
{
this.sinkSourceProvider = provider;
}
@Override
public boolean isCurrentDateEvaluationEnabled()
{
return this.currentDateEvaluationEnabled;
}
void setCurrentDateEvaluationEnabled(boolean enabled)
{
this.currentDateEvaluationEnabled = enabled;
}
@Override
public boolean isCurrentTimeEvaluationEnabled()
{
return this.currentTimeEvaluationEnabled;
}
void setCurrentTimeEvaluationEnabled(boolean enabled)
{
this.currentTimeEvaluationEnabled = enabled;
}
@Override
public boolean isCurrentTimestampEvaluationEnabled()
{
return this.currentTimestampEvaluationEnabled;
}
void setCurrentTimestampEvaluationEnabled(boolean enabled)
{
this.currentTimestampEvaluationEnabled = enabled;
}
@Override
public boolean isIdentityColumnDetectionEnabled()
{
return this.identityColumnDetectionEnabled;
}
void setIdentityColumnDetectionEnabled(boolean enabled)
{
this.identityColumnDetectionEnabled = enabled;
}
@Override
public boolean isRandEvaluationEnabled()
{
return this.randEvaluationEnabled;
}
void setRandEvaluationEnabled(boolean enabled)
{
this.randEvaluationEnabled = enabled;
}
@Override
public boolean isSequenceDetectionEnabled()
{
return this.sequenceDetectionEnabled;
}
void setSequenceDetectionEnabled(boolean enabled)
{
this.sequenceDetectionEnabled = enabled;
}
@Override
public TransactionIdentifierFactory<? extends Object> getTransactionIdentifierFactory()
{
throw new IllegalStateException();
}
/* (non-Javadoc)
* @see net.sf.hajdbc.DatabaseClusterConfiguration#isEmptyClusterAllowed()
*/
@Override
public boolean isEmptyClusterAllowed()
{
return this.emptyClusterAllowed;
}
void setEmptyClusterAllowed(boolean emptyClusterAllowed)
{
this.emptyClusterAllowed = emptyClusterAllowed;
}
}
static class IdentifiableServiceAdapter<T extends Identifiable> extends XmlAdapter<String, T>
{
private final Class<T> serviceClass;
IdentifiableServiceAdapter(Class<T> serviceClass)
{
this.serviceClass = serviceClass;
}
@Override
public T unmarshal(final String value)
{
return ServiceLoaders.findRequiredService(new IdentifiableMatcher<T>(value), this.serviceClass);
}
@Override
public String marshal(T service)
{
return service.getId();
}
}
static class BalancerFactoryAdapter extends IdentifiableServiceAdapter<BalancerFactory>
{
BalancerFactoryAdapter()
{
super(BalancerFactory.class);
}
}
static class DatabaseMetaDataCacheFactoryAdapter extends IdentifiableServiceAdapter<DatabaseMetaDataCacheFactory>
{
DatabaseMetaDataCacheFactoryAdapter()
{
super(DatabaseMetaDataCacheFactory.class);
}
}
static class DurabilityFactoryAdapter extends IdentifiableServiceAdapter<DurabilityFactory>
{
DurabilityFactoryAdapter()
{
super(DurabilityFactory.class);
}
}
static class TransactionModeAdapter extends EnumAdapter<TransactionMode, TransactionModeEnum>
{
@Override
protected Class<TransactionModeEnum> getTargetClass()
{
return TransactionModeEnum.class;
}
}
static abstract class EnumAdapter<I, E extends I> extends XmlAdapter<E, I>
{
@Override
public I unmarshal(E enumerated)
{
return enumerated;
}
@Override
public E marshal(I object)
{
return this.getTargetClass().cast(object);
}
protected abstract Class<E> getTargetClass();
}
static class DialectFactoryAdapter extends IdentifiableServiceAdapter<DialectFactory>
{
DialectFactoryAdapter()
{
super(DialectFactory.class);
}
}
static class SinkSourceProviderAdapter extends IdentifiableServiceAdapter<InputSinkProvider>
{
SinkSourceProviderAdapter()
{
super(InputSinkProvider.class);
}
}
static class CronExpressionAdapter extends XmlAdapter<String, CronExpression>
{
@Override
public String marshal(CronExpression expression)
{
return (expression != null) ? expression.getCronExpression() : null;
}
@Override
public CronExpression unmarshal(String value) throws Exception
{
return (value != null) ? new CronExpression(value) : null;
}
}
@XmlType
static class CommandDispatcherFactoryDescriptor extends IdentifiableServiceDescriptor
{
@XmlAttribute(name = "id", required = false)
private String id = "jgroups";
@Override
public String getId()
{
return this.id;
}
@Override
public void setId(String id)
{
this.id = id;
}
}
static class CommandDispatcherFactoryDescriptorAdapter extends IdentifiableServiceDescriptorAdapter<CommandDispatcherFactory, CommandDispatcherFactoryDescriptor>
{
CommandDispatcherFactoryDescriptorAdapter()
{
super(CommandDispatcherFactory.class, CommandDispatcherFactoryDescriptor.class);
}
}
@XmlType
static class SynchronizationStrategyDescriptor extends IdentifiableServiceDescriptor
{
@XmlID
@XmlAttribute(name = "id", required = true)
private String id;
@Override
public String getId()
{
return this.id;
}
@Override
public void setId(String id)
{
this.id = id;
}
}
static class SynchronizationStrategyDescriptorAdapter extends IdentifiableServiceDescriptorAdapter<SynchronizationStrategy, SynchronizationStrategyDescriptor>
{
SynchronizationStrategyDescriptorAdapter()
{
super(SynchronizationStrategy.class, SynchronizationStrategyDescriptor.class);
}
}
@XmlType
static class StateManagerFactoryDescriptor extends IdentifiableServiceDescriptor
{
@XmlAttribute(name = "id", required = true)
private String id;
@Override
public String getId()
{
return this.id;
}
@Override
public void setId(String id)
{
this.id = id;
}
}
static class StateManagerFactoryDescriptorAdapter extends IdentifiableServiceDescriptorAdapter<StateManagerFactory, StateManagerFactoryDescriptor>
{
StateManagerFactoryDescriptorAdapter()
{
super(StateManagerFactory.class, StateManagerFactoryDescriptor.class);
}
}
@XmlType
static class LockManagerFactoryDescriptor extends IdentifiableServiceDescriptor
{
@XmlAttribute(name = "id", required = true)
private String id;
@Override
public String getId()
{
return this.id;
}
@Override
public void setId(String id)
{
this.id = id;
}
}
static class LockManagerFactoryDescriptorAdapter extends IdentifiableServiceDescriptorAdapter<LockManagerFactory, LockManagerFactoryDescriptor>
{
LockManagerFactoryDescriptorAdapter()
{
super(LockManagerFactory.class, LockManagerFactoryDescriptor.class);
}
}
static abstract class IdentifiableServiceDescriptor implements Identifiable
{
@XmlElement(name = "property")
private List<Property> properties;
public List<Property> getProperties()
{
return this.properties;
}
public void setProperties(List<Property> properties)
{
this.properties = properties;
}
public abstract void setId(String id);
}
static class IdentifiableServiceDescriptorAdapter<T extends Identifiable, D extends IdentifiableServiceDescriptor> extends XmlAdapter<D, T>
{
private final Class<T> serviceClass;
private final Class<D> descriptorClass;
IdentifiableServiceDescriptorAdapter(Class<T> serviceClass, Class<D> descriptorClass)
{
this.serviceClass = serviceClass;
this.descriptorClass = descriptorClass;
}
@Override
public D marshal(T object) throws Exception
{
D result = this.descriptorClass.newInstance();
List<Property> properties = new LinkedList<Property>();
result.setId(object.getId());
result.setProperties(properties);
for (Map.Entry<PropertyDescriptor, PropertyEditor> entry: findDescriptors(object.getClass()).values())
{
PropertyDescriptor descriptor = entry.getKey();
PropertyEditor editor = entry.getValue();
Object value = descriptor.getReadMethod().invoke(object);
if (value != null)
{
editor.setValue(value);
Property property = new Property();
property.setName(descriptor.getName());
property.setValue(editor.getAsText());
properties.add(property);
}
}
return result;
}
@Override
public T unmarshal(D target) throws Exception
{
T result = ServiceLoaders.findRequiredService(new IdentifiableMatcher<T>(target.getId()), this.serviceClass);
List<Property> properties = target.getProperties();
if (properties != null)
{
Map<String, Map.Entry<PropertyDescriptor, PropertyEditor>> descriptors = findDescriptors(result.getClass());
for (Property property: properties)
{
String name = property.getName();
Map.Entry<PropertyDescriptor, PropertyEditor> entry = descriptors.get(name);
if (entry == null)
{
throw new IllegalArgumentException(Messages.INVALID_PROPERTY.getMessage(name, result.getClass().getName()));
}
PropertyDescriptor descriptor = entry.getKey();
PropertyEditor editor = entry.getValue();
String textValue = property.getValue();
try
{
editor.setAsText(textValue);
}
catch (Exception e)
{
throw new IllegalArgumentException(Messages.INVALID_PROPERTY_VALUE.getMessage(textValue, name, result.getClass().getName()));
}
descriptor.getWriteMethod().invoke(result, editor.getValue());
}
}
return result;
}
}
@XmlType
protected static class Property
{
@XmlAttribute(required = true)
private String name;
@XmlValue
private String value;
public String getName()
{
return this.name;
}
public void setName(String name)
{
this.name = name;
}
public String getValue()
{
return this.value;
}
public void setValue(String value)
{
this.value = value;
}
}
}