| File was renamed from opendj-sdk/opends/src/server/org/opends/server/replication/plugin/MultimasterSynchronization.java |
| | |
| | | import org.opends.server.types.ResultCode; |
| | | import org.opends.server.types.SynchronizationProviderResult; |
| | | |
| | | import static org.opends.server.messages.SynchronizationMessages.*; |
| | | import static org.opends.server.messages.ReplicationMessages.*; |
| | | |
| | | /** |
| | | * This class is used to load the Synchronization code inside the JVM |
| | | * and to trigger initialization of the synchronization. |
| | | * This class is used to load the Replication code inside the JVM |
| | | * and to trigger initialization of the replication. |
| | | * |
| | | * It also extends the SynchronizationProvider class in order to have some |
| | | * synchronization code running during the operation process |
| | | * replication code running during the operation process |
| | | * as pre-op, conflictRsolution, and post-op. |
| | | */ |
| | | public class MultimasterSynchronization |
| | | public class MultimasterReplication |
| | | extends SynchronizationProvider<MultimasterSynchronizationProviderCfg> |
| | | implements ConfigurationAddListener<MultimasterDomainCfg>, |
| | | ConfigurationDeleteListener<MultimasterDomainCfg>, |
| | |
| | | "ds-cfg-synchronization-provider-config"; |
| | | |
| | | private ChangelogListener changelog = null; |
| | | private static Map<DN, SynchronizationDomain> domains = |
| | | new HashMap<DN, SynchronizationDomain>() ; |
| | | private static Map<DN, ReplicationDomain> domains = |
| | | new HashMap<DN, ReplicationDomain>() ; |
| | | |
| | | |
| | | /** |
| | |
| | | for (String name : configuration.listMultimasterDomains()) |
| | | { |
| | | MultimasterDomainCfg domain = configuration.getMultimasterDomain(name); |
| | | createNewSynchronizationDomain(domain); |
| | | createNewDomain(domain); |
| | | } |
| | | |
| | | /* |
| | |
| | | public boolean isConfigurationAddAcceptable( |
| | | MultimasterDomainCfg configuration, List<String> unacceptableReasons) |
| | | { |
| | | return SynchronizationDomain.isConfigurationAcceptable( |
| | | return ReplicationDomain.isConfigurationAcceptable( |
| | | configuration, unacceptableReasons); |
| | | } |
| | | |
| | |
| | | { |
| | | try |
| | | { |
| | | createNewSynchronizationDomain(configuration); |
| | | createNewDomain(configuration); |
| | | return new ConfigChangeResult(ResultCode.SUCCESS, false); |
| | | } catch (ConfigException e) |
| | | { |
| | |
| | | } |
| | | |
| | | /** |
| | | * Creates a New Synchronization domain from its configEntry, do the |
| | | * Creates a new domain from its configEntry, do the |
| | | * necessary initialization and starts it so that it is |
| | | * fully operational when this method returns. |
| | | * @param configuration The entry whith the configuration of this domain. |
| | | * @throws ConfigException When the configuration is not valid. |
| | | */ |
| | | private void createNewSynchronizationDomain( |
| | | private void createNewDomain( |
| | | MultimasterDomainCfg configuration) |
| | | throws ConfigException |
| | | { |
| | | SynchronizationDomain domain; |
| | | domain = new SynchronizationDomain(configuration); |
| | | ReplicationDomain domain; |
| | | domain = new ReplicationDomain(configuration); |
| | | domains.put(domain.getBaseDN(), domain); |
| | | domain.start(); |
| | | } |
| | |
| | | public SynchronizationProviderResult handleConflictResolution( |
| | | ModifyOperation modifyOperation) |
| | | { |
| | | SynchronizationDomain domain = |
| | | ReplicationDomain domain = |
| | | findDomain(modifyOperation.getEntryDN(), modifyOperation); |
| | | if (domain == null) |
| | | return new SynchronizationProviderResult(true); |
| | |
| | | public SynchronizationProviderResult handleConflictResolution( |
| | | AddOperation addOperation) throws DirectoryException |
| | | { |
| | | SynchronizationDomain domain = |
| | | ReplicationDomain domain = |
| | | findDomain(addOperation.getEntryDN(), addOperation); |
| | | if (domain == null) |
| | | return new SynchronizationProviderResult(true); |
| | |
| | | public SynchronizationProviderResult handleConflictResolution( |
| | | DeleteOperation deleteOperation) throws DirectoryException |
| | | { |
| | | SynchronizationDomain domain = |
| | | ReplicationDomain domain = |
| | | findDomain(deleteOperation.getEntryDN(), deleteOperation); |
| | | if (domain == null) |
| | | return new SynchronizationProviderResult(true); |
| | |
| | | public SynchronizationProviderResult handleConflictResolution( |
| | | ModifyDNOperation modifyDNOperation) throws DirectoryException |
| | | { |
| | | SynchronizationDomain domain = |
| | | ReplicationDomain domain = |
| | | findDomain(modifyDNOperation.getEntryDN(), modifyDNOperation); |
| | | if (domain == null) |
| | | return new SynchronizationProviderResult(true); |
| | |
| | | doPreOperation(ModifyOperation modifyOperation) |
| | | { |
| | | DN operationDN = modifyOperation.getEntryDN(); |
| | | SynchronizationDomain domain = findDomain(operationDN, modifyOperation); |
| | | ReplicationDomain domain = findDomain(operationDN, modifyOperation); |
| | | |
| | | if ((domain == null) || (!domain.solveConflict())) |
| | | return new SynchronizationProviderResult(true); |
| | |
| | | @Override |
| | | public SynchronizationProviderResult doPreOperation(AddOperation addOperation) |
| | | { |
| | | SynchronizationDomain domain = |
| | | ReplicationDomain domain = |
| | | findDomain(addOperation.getEntryDN(), addOperation); |
| | | if (domain == null) |
| | | return new SynchronizationProviderResult(true); |
| | |
| | | @Override |
| | | public void finalizeSynchronizationProvider() |
| | | { |
| | | // shutdown all the Synchronization domains |
| | | for (SynchronizationDomain domain : domains.values()) |
| | | // shutdown all the domains |
| | | for (ReplicationDomain domain : domains.values()) |
| | | { |
| | | domain.shutdown(); |
| | | } |
| | |
| | | } |
| | | |
| | | /** |
| | | * Finds the Synchronization domain for a given DN. |
| | | * Finds the domain for a given DN. |
| | | * |
| | | * @param dn The DN for which the domain must be returned. |
| | | * @param op An optional operation for which the check is done. |
| | | * Can be null is the request has no associated operation. |
| | | * @return The Synchronization domain for this DN. |
| | | * @return The domain for this DN. |
| | | */ |
| | | public static SynchronizationDomain findDomain(DN dn, Operation op) |
| | | public static ReplicationDomain findDomain(DN dn, Operation op) |
| | | { |
| | | /* |
| | | * Don't run the special synchronization code on Operation that are |
| | | * Don't run the special replication code on Operation that are |
| | | * specifically marked as don't synchronize. |
| | | */ |
| | | if ((op != null) && op.dontSynchronize()) |
| | | return null; |
| | | |
| | | SynchronizationDomain domain = null; |
| | | ReplicationDomain domain = null; |
| | | DN temp = dn; |
| | | do |
| | | { |
| | |
| | | */ |
| | | private void genericPostOperation(Operation operation, DN dn) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, operation); |
| | | ReplicationDomain domain = findDomain(dn, operation); |
| | | if (domain == null) |
| | | return; |
| | | |
| | |
| | | * This method is called whenever the server detects a modification |
| | | * of the schema done by directly modifying the backing files |
| | | * of the schema backend. |
| | | * Call the schema Synchronization Domain if it exists. |
| | | * Call the schema Domain if it exists. |
| | | * |
| | | * @param modifications The list of modifications that was |
| | | * applied to the schema. |
| | |
| | | @Override |
| | | public void processSchemaChange(List<Modification> modifications) |
| | | { |
| | | SynchronizationDomain domain = |
| | | ReplicationDomain domain = |
| | | findDomain(DirectoryServer.getSchemaDN(), null); |
| | | if (domain != null) |
| | | domain.synchronizeModifications(modifications); |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.backupStart(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.backupEnd(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.disable(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.enable(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.disable(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.enable(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.backupStart(); |
| | | } |
| | |
| | | { |
| | | for (DN dn : backend.getBaseDNs()) |
| | | { |
| | | SynchronizationDomain domain = findDomain(dn, null); |
| | | ReplicationDomain domain = findDomain(dn, null); |
| | | if (domain != null) |
| | | domain.backupEnd(); |
| | | } |
| | |
| | | MultimasterDomainCfg configuration) |
| | | { |
| | | DN dn = configuration.getSynchronizationDN(); |
| | | SynchronizationDomain domain = domains.remove(dn); |
| | | ReplicationDomain domain = domains.remove(dn); |
| | | if (domain != null) |
| | | domain.shutdown(); |
| | | |