001/*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License").  You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
010 * or http://forgerock.org/license/CDDLv1.0.html.
011 * See the License for the specific language governing permissions
012 * and limitations under the License.
013 *
014 * When distributing Covered Code, include this CDDL HEADER in each
015 * file and include the License file at legal-notices/CDDLv1_0.txt.
016 * If applicable, add the following below this CDDL HEADER, with the
017 * fields enclosed by brackets "[]" replaced with your own identifying
018 * information:
019 *      Portions Copyright [yyyy] [name of copyright owner]
020 *
021 * CDDL HEADER END
022 *
023 *
024 *      Copyright 2008 Sun Microsystems, Inc.
025 */
026package org.forgerock.opendj.server.config.meta;
027
028
029
030import java.util.Collection;
031import org.forgerock.opendj.config.AdministratorAction;
032import org.forgerock.opendj.config.BooleanPropertyDefinition;
033import org.forgerock.opendj.config.ClassPropertyDefinition;
034import org.forgerock.opendj.config.client.ConcurrentModificationException;
035import org.forgerock.opendj.config.client.IllegalManagedObjectNameException;
036import org.forgerock.opendj.config.client.ManagedObject;
037import org.forgerock.opendj.config.client.ManagedObjectDecodingException;
038import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
039import org.forgerock.opendj.config.client.OperationRejectedException;
040import org.forgerock.opendj.config.DefaultBehaviorProvider;
041import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
042import org.forgerock.opendj.config.DefinitionDecodingException;
043import org.forgerock.opendj.config.DurationPropertyDefinition;
044import org.forgerock.opendj.config.InstantiableRelationDefinition;
045import org.forgerock.opendj.config.IntegerPropertyDefinition;
046import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
047import org.forgerock.opendj.config.ManagedObjectDefinition;
048import org.forgerock.opendj.config.ManagedObjectNotFoundException;
049import org.forgerock.opendj.config.OptionalRelationDefinition;
050import org.forgerock.opendj.config.PropertyException;
051import org.forgerock.opendj.config.PropertyOption;
052import org.forgerock.opendj.config.PropertyProvider;
053import org.forgerock.opendj.config.server.ConfigException;
054import org.forgerock.opendj.config.server.ConfigurationAddListener;
055import org.forgerock.opendj.config.server.ConfigurationChangeListener;
056import org.forgerock.opendj.config.server.ConfigurationDeleteListener;
057import org.forgerock.opendj.config.server.ServerManagedObject;
058import org.forgerock.opendj.config.Tag;
059import org.forgerock.opendj.ldap.DN;
060import org.forgerock.opendj.ldap.LdapException;
061import org.forgerock.opendj.server.config.client.ReplicationDomainCfgClient;
062import org.forgerock.opendj.server.config.client.ReplicationServerCfgClient;
063import org.forgerock.opendj.server.config.client.ReplicationSynchronizationProviderCfgClient;
064import org.forgerock.opendj.server.config.server.ReplicationDomainCfg;
065import org.forgerock.opendj.server.config.server.ReplicationServerCfg;
066import org.forgerock.opendj.server.config.server.ReplicationSynchronizationProviderCfg;
067import org.forgerock.opendj.server.config.server.SynchronizationProviderCfg;
068
069
070
071/**
072 * An interface for querying the Replication Synchronization Provider
073 * managed object definition meta information.
074 * <p>
075 * The Replication Synchronization Provider provides multi-master
076 * replication of data across multiple directory server instances.
077 */
078public final class ReplicationSynchronizationProviderCfgDefn extends ManagedObjectDefinition<ReplicationSynchronizationProviderCfgClient, ReplicationSynchronizationProviderCfg> {
079
080  // The singleton configuration definition instance.
081  private static final ReplicationSynchronizationProviderCfgDefn INSTANCE = new ReplicationSynchronizationProviderCfgDefn();
082
083
084
085  // The "connection-timeout" property definition.
086  private static final DurationPropertyDefinition PD_CONNECTION_TIMEOUT;
087
088
089
090  // The "java-class" property definition.
091  private static final ClassPropertyDefinition PD_JAVA_CLASS;
092
093
094
095  // The "num-update-replay-threads" property definition.
096  private static final IntegerPropertyDefinition PD_NUM_UPDATE_REPLAY_THREADS;
097
098
099
100  // The "replication-domains" relation definition.
101  private static final InstantiableRelationDefinition<ReplicationDomainCfgClient, ReplicationDomainCfg> RD_REPLICATION_DOMAINS;
102
103
104
105  // The "replication-server" relation definition.
106  private static final OptionalRelationDefinition<ReplicationServerCfgClient, ReplicationServerCfg> RD_REPLICATION_SERVER;
107
108
109
110  // Build the "connection-timeout" property definition.
111  static {
112      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "connection-timeout");
113      builder.setOption(PropertyOption.ADVANCED);
114      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "connection-timeout"));
115      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("5 seconds");
116      builder.setDefaultBehaviorProvider(provider);
117      builder.setBaseUnit("ms");
118      builder.setLowerLimit("0");
119      PD_CONNECTION_TIMEOUT = builder.getInstance();
120      INSTANCE.registerPropertyDefinition(PD_CONNECTION_TIMEOUT);
121  }
122
123
124
125  // Build the "java-class" property definition.
126  static {
127      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
128      builder.setOption(PropertyOption.MANDATORY);
129      builder.setOption(PropertyOption.ADVANCED);
130      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
131      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.replication.plugin.MultimasterReplication");
132      builder.setDefaultBehaviorProvider(provider);
133      builder.addInstanceOf("org.opends.server.api.SynchronizationProvider");
134      PD_JAVA_CLASS = builder.getInstance();
135      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
136  }
137
138
139
140  // Build the "num-update-replay-threads" property definition.
141  static {
142      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "num-update-replay-threads");
143      builder.setOption(PropertyOption.ADVANCED);
144      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "num-update-replay-threads"));
145      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("10");
146      builder.setDefaultBehaviorProvider(provider);
147      builder.setUpperLimit(65535);
148      builder.setLowerLimit(1);
149      PD_NUM_UPDATE_REPLAY_THREADS = builder.getInstance();
150      INSTANCE.registerPropertyDefinition(PD_NUM_UPDATE_REPLAY_THREADS);
151  }
152
153
154
155  // Build the "replication-domains" relation definition.
156  static {
157    InstantiableRelationDefinition.Builder<ReplicationDomainCfgClient, ReplicationDomainCfg> builder =
158      new InstantiableRelationDefinition.Builder<ReplicationDomainCfgClient, ReplicationDomainCfg>(INSTANCE, "replication-domain", "replication-domains", ReplicationDomainCfgDefn.getInstance());
159    RD_REPLICATION_DOMAINS = builder.getInstance();
160    INSTANCE.registerRelationDefinition(RD_REPLICATION_DOMAINS);
161  }
162
163
164
165  // Build the "replication-server" relation definition.
166  static {
167    OptionalRelationDefinition.Builder<ReplicationServerCfgClient, ReplicationServerCfg> builder =
168      new OptionalRelationDefinition.Builder<ReplicationServerCfgClient, ReplicationServerCfg>(INSTANCE, "replication-server", ReplicationServerCfgDefn.getInstance());
169    RD_REPLICATION_SERVER = builder.getInstance();
170    INSTANCE.registerRelationDefinition(RD_REPLICATION_SERVER);
171  }
172
173
174
175  // Register the tags associated with this managed object definition.
176  static {
177    INSTANCE.registerTag(Tag.valueOf("replication"));
178  }
179
180
181
182  /**
183   * Get the Replication Synchronization Provider configuration
184   * definition singleton.
185   *
186   * @return Returns the Replication Synchronization Provider
187   *         configuration definition singleton.
188   */
189  public static ReplicationSynchronizationProviderCfgDefn getInstance() {
190    return INSTANCE;
191  }
192
193
194
195  /**
196   * Private constructor.
197   */
198  private ReplicationSynchronizationProviderCfgDefn() {
199    super("replication-synchronization-provider", SynchronizationProviderCfgDefn.getInstance());
200  }
201
202
203
204  /**
205   * {@inheritDoc}
206   */
207  public ReplicationSynchronizationProviderCfgClient createClientConfiguration(
208      ManagedObject<? extends ReplicationSynchronizationProviderCfgClient> impl) {
209    return new ReplicationSynchronizationProviderCfgClientImpl(impl);
210  }
211
212
213
214  /**
215   * {@inheritDoc}
216   */
217  public ReplicationSynchronizationProviderCfg createServerConfiguration(
218      ServerManagedObject<? extends ReplicationSynchronizationProviderCfg> impl) {
219    return new ReplicationSynchronizationProviderCfgServerImpl(impl);
220  }
221
222
223
224  /**
225   * {@inheritDoc}
226   */
227  public Class<ReplicationSynchronizationProviderCfg> getServerConfigurationClass() {
228    return ReplicationSynchronizationProviderCfg.class;
229  }
230
231
232
233  /**
234   * Get the "connection-timeout" property definition.
235   * <p>
236   * Specifies the timeout used when connecting to peers and when
237   * performing SSL negotiation.
238   *
239   * @return Returns the "connection-timeout" property definition.
240   */
241  public DurationPropertyDefinition getConnectionTimeoutPropertyDefinition() {
242    return PD_CONNECTION_TIMEOUT;
243  }
244
245
246
247  /**
248   * Get the "enabled" property definition.
249   * <p>
250   * Indicates whether the Replication Synchronization Provider is
251   * enabled for use.
252   *
253   * @return Returns the "enabled" property definition.
254   */
255  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
256    return SynchronizationProviderCfgDefn.getInstance().getEnabledPropertyDefinition();
257  }
258
259
260
261  /**
262   * Get the "java-class" property definition.
263   * <p>
264   * Specifies the fully-qualified name of the Java class that
265   * provides the Replication Synchronization Provider implementation.
266   *
267   * @return Returns the "java-class" property definition.
268   */
269  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
270    return PD_JAVA_CLASS;
271  }
272
273
274
275  /**
276   * Get the "num-update-replay-threads" property definition.
277   * <p>
278   * Specifies the number of update replay threads.
279   * <p>
280   * This value is the number of threads created for replaying every
281   * updates received for all the replication domains.
282   *
283   * @return Returns the "num-update-replay-threads" property definition.
284   */
285  public IntegerPropertyDefinition getNumUpdateReplayThreadsPropertyDefinition() {
286    return PD_NUM_UPDATE_REPLAY_THREADS;
287  }
288
289
290
291  /**
292   * Get the "replication-domains" relation definition.
293   *
294   * @return Returns the "replication-domains" relation definition.
295   */
296  public InstantiableRelationDefinition<ReplicationDomainCfgClient,ReplicationDomainCfg> getReplicationDomainsRelationDefinition() {
297    return RD_REPLICATION_DOMAINS;
298  }
299
300
301
302  /**
303   * Get the "replication-server" relation definition.
304   *
305   * @return Returns the "replication-server" relation definition.
306   */
307  public OptionalRelationDefinition<ReplicationServerCfgClient,ReplicationServerCfg> getReplicationServerRelationDefinition() {
308    return RD_REPLICATION_SERVER;
309  }
310
311
312
313  /**
314   * Managed object client implementation.
315   */
316  private static class ReplicationSynchronizationProviderCfgClientImpl implements
317    ReplicationSynchronizationProviderCfgClient {
318
319    // Private implementation.
320    private ManagedObject<? extends ReplicationSynchronizationProviderCfgClient> impl;
321
322
323
324    // Private constructor.
325    private ReplicationSynchronizationProviderCfgClientImpl(
326        ManagedObject<? extends ReplicationSynchronizationProviderCfgClient> impl) {
327      this.impl = impl;
328    }
329
330
331
332    /**
333     * {@inheritDoc}
334     */
335    public long getConnectionTimeout() {
336      return impl.getPropertyValue(INSTANCE.getConnectionTimeoutPropertyDefinition());
337    }
338
339
340
341    /**
342     * {@inheritDoc}
343     */
344    public void setConnectionTimeout(Long value) {
345      impl.setPropertyValue(INSTANCE.getConnectionTimeoutPropertyDefinition(), value);
346    }
347
348
349
350    /**
351     * {@inheritDoc}
352     */
353    public Boolean isEnabled() {
354      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
355    }
356
357
358
359    /**
360     * {@inheritDoc}
361     */
362    public void setEnabled(boolean value) {
363      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
364    }
365
366
367
368    /**
369     * {@inheritDoc}
370     */
371    public String getJavaClass() {
372      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
373    }
374
375
376
377    /**
378     * {@inheritDoc}
379     */
380    public void setJavaClass(String value) {
381      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
382    }
383
384
385
386    /**
387     * {@inheritDoc}
388     */
389    public int getNumUpdateReplayThreads() {
390      return impl.getPropertyValue(INSTANCE.getNumUpdateReplayThreadsPropertyDefinition());
391    }
392
393
394
395    /**
396     * {@inheritDoc}
397     */
398    public void setNumUpdateReplayThreads(Integer value) {
399      impl.setPropertyValue(INSTANCE.getNumUpdateReplayThreadsPropertyDefinition(), value);
400    }
401
402
403
404    /**
405     * {@inheritDoc}
406     */
407    public String[] listReplicationDomains() throws ConcurrentModificationException,
408        LdapException {
409      return impl.listChildren(INSTANCE.getReplicationDomainsRelationDefinition());
410    }
411
412
413
414    /**
415     * {@inheritDoc}
416     */
417    public ReplicationDomainCfgClient getReplicationDomain(String name)
418        throws DefinitionDecodingException, ManagedObjectDecodingException,
419        ManagedObjectNotFoundException, ConcurrentModificationException,
420        LdapException {
421      return impl.getChild(INSTANCE.getReplicationDomainsRelationDefinition(), name).getConfiguration();
422    }
423
424
425
426    /**
427     * {@inheritDoc}
428     */
429    public <M extends ReplicationDomainCfgClient> M createReplicationDomain(
430        ManagedObjectDefinition<M, ? extends ReplicationDomainCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException {
431      return impl.createChild(INSTANCE.getReplicationDomainsRelationDefinition(), d, name, exceptions).getConfiguration();
432    }
433
434
435
436    /**
437     * {@inheritDoc}
438     */
439    public void removeReplicationDomain(String name)
440        throws ManagedObjectNotFoundException, ConcurrentModificationException,
441        OperationRejectedException, LdapException {
442      impl.removeChild(INSTANCE.getReplicationDomainsRelationDefinition(), name);
443    }
444
445
446
447    /**
448     * {@inheritDoc}
449     */
450    public boolean hasReplicationServer() throws ConcurrentModificationException,
451        LdapException {
452      return impl.hasChild(INSTANCE.getReplicationServerRelationDefinition());
453    }
454
455
456
457    /**
458     * {@inheritDoc}
459     */
460    public ReplicationServerCfgClient getReplicationServer()
461        throws DefinitionDecodingException, ManagedObjectDecodingException,
462        ManagedObjectNotFoundException, ConcurrentModificationException,
463        LdapException {
464      return impl.getChild(INSTANCE.getReplicationServerRelationDefinition()).getConfiguration();
465    }
466
467
468
469    /**
470     * {@inheritDoc}
471     */
472    public <M extends ReplicationServerCfgClient> M createReplicationServer(
473        ManagedObjectDefinition<M, ? extends ReplicationServerCfg> d, Collection<PropertyException> exceptions) {
474      return impl.createChild(INSTANCE.getReplicationServerRelationDefinition(), d, exceptions).getConfiguration();
475    }
476
477
478
479    /**
480     * {@inheritDoc}
481     */
482    public void removeReplicationServer()
483        throws ManagedObjectNotFoundException, ConcurrentModificationException,
484        OperationRejectedException, LdapException {
485      impl.removeChild(INSTANCE.getReplicationServerRelationDefinition());
486    }
487
488
489
490    /**
491     * {@inheritDoc}
492     */
493    public ManagedObjectDefinition<? extends ReplicationSynchronizationProviderCfgClient, ? extends ReplicationSynchronizationProviderCfg> definition() {
494      return INSTANCE;
495    }
496
497
498
499    /**
500     * {@inheritDoc}
501     */
502    public PropertyProvider properties() {
503      return impl;
504    }
505
506
507
508    /**
509     * {@inheritDoc}
510     */
511    public void commit() throws ManagedObjectAlreadyExistsException,
512        MissingMandatoryPropertiesException, ConcurrentModificationException,
513        OperationRejectedException, LdapException {
514      impl.commit();
515    }
516
517  }
518
519
520
521  /**
522   * Managed object server implementation.
523   */
524  private static class ReplicationSynchronizationProviderCfgServerImpl implements
525    ReplicationSynchronizationProviderCfg {
526
527    // Private implementation.
528    private ServerManagedObject<? extends ReplicationSynchronizationProviderCfg> impl;
529
530    // The value of the "connection-timeout" property.
531    private final long pConnectionTimeout;
532
533    // The value of the "enabled" property.
534    private final boolean pEnabled;
535
536    // The value of the "java-class" property.
537    private final String pJavaClass;
538
539    // The value of the "num-update-replay-threads" property.
540    private final int pNumUpdateReplayThreads;
541
542
543
544    // Private constructor.
545    private ReplicationSynchronizationProviderCfgServerImpl(ServerManagedObject<? extends ReplicationSynchronizationProviderCfg> impl) {
546      this.impl = impl;
547      this.pConnectionTimeout = impl.getPropertyValue(INSTANCE.getConnectionTimeoutPropertyDefinition());
548      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
549      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
550      this.pNumUpdateReplayThreads = impl.getPropertyValue(INSTANCE.getNumUpdateReplayThreadsPropertyDefinition());
551    }
552
553
554
555    /**
556     * {@inheritDoc}
557     */
558    public void addReplicationChangeListener(
559        ConfigurationChangeListener<ReplicationSynchronizationProviderCfg> listener) {
560      impl.registerChangeListener(listener);
561    }
562
563
564
565    /**
566     * {@inheritDoc}
567     */
568    public void removeReplicationChangeListener(
569        ConfigurationChangeListener<ReplicationSynchronizationProviderCfg> listener) {
570      impl.deregisterChangeListener(listener);
571    }
572    /**
573     * {@inheritDoc}
574     */
575    public void addChangeListener(
576        ConfigurationChangeListener<SynchronizationProviderCfg> listener) {
577      impl.registerChangeListener(listener);
578    }
579
580
581
582    /**
583     * {@inheritDoc}
584     */
585    public void removeChangeListener(
586        ConfigurationChangeListener<SynchronizationProviderCfg> listener) {
587      impl.deregisterChangeListener(listener);
588    }
589
590
591
592    /**
593     * {@inheritDoc}
594     */
595    public long getConnectionTimeout() {
596      return pConnectionTimeout;
597    }
598
599
600
601    /**
602     * {@inheritDoc}
603     */
604    public boolean isEnabled() {
605      return pEnabled;
606    }
607
608
609
610    /**
611     * {@inheritDoc}
612     */
613    public String getJavaClass() {
614      return pJavaClass;
615    }
616
617
618
619    /**
620     * {@inheritDoc}
621     */
622    public int getNumUpdateReplayThreads() {
623      return pNumUpdateReplayThreads;
624    }
625
626
627
628    /**
629     * {@inheritDoc}
630     */
631    public String[] listReplicationDomains() {
632      return impl.listChildren(INSTANCE.getReplicationDomainsRelationDefinition());
633    }
634
635
636
637    /**
638     * {@inheritDoc}
639     */
640    public ReplicationDomainCfg getReplicationDomain(String name) throws ConfigException {
641      return impl.getChild(INSTANCE.getReplicationDomainsRelationDefinition(), name).getConfiguration();
642    }
643
644
645
646    /**
647     * {@inheritDoc}
648     */
649    public void addReplicationDomainAddListener(
650        ConfigurationAddListener<ReplicationDomainCfg> listener) throws ConfigException {
651      impl.registerAddListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
652    }
653
654
655
656    /**
657     * {@inheritDoc}
658     */
659    public void removeReplicationDomainAddListener(
660        ConfigurationAddListener<ReplicationDomainCfg> listener) {
661      impl.deregisterAddListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
662    }
663
664
665
666    /**
667     * {@inheritDoc}
668     */
669    public void addReplicationDomainDeleteListener(
670        ConfigurationDeleteListener<ReplicationDomainCfg> listener) throws ConfigException {
671      impl.registerDeleteListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
672    }
673
674
675
676    /**
677     * {@inheritDoc}
678     */
679    public void removeReplicationDomainDeleteListener(
680        ConfigurationDeleteListener<ReplicationDomainCfg> listener) {
681      impl.deregisterDeleteListener(INSTANCE.getReplicationDomainsRelationDefinition(), listener);
682    }
683
684
685
686    /**
687     * {@inheritDoc}
688     */
689    public boolean hasReplicationServer() {
690      return impl.hasChild(INSTANCE.getReplicationServerRelationDefinition());
691    }
692
693
694
695    /**
696     * {@inheritDoc}
697     */
698    public ReplicationServerCfg getReplicationServer() throws ConfigException {
699      return impl.getChild(INSTANCE.getReplicationServerRelationDefinition()).getConfiguration();
700    }
701
702
703
704    /**
705     * {@inheritDoc}
706     */
707    public void addReplicationServerAddListener(
708        ConfigurationAddListener<ReplicationServerCfg> listener) throws ConfigException {
709      impl.registerAddListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
710    }
711
712
713
714    /**
715     * {@inheritDoc}
716     */
717    public void removeReplicationServerAddListener(
718        ConfigurationAddListener<ReplicationServerCfg> listener) {
719      impl.deregisterAddListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
720    }
721
722
723
724    /**
725     * {@inheritDoc}
726     */
727    public void addReplicationServerDeleteListener(
728        ConfigurationDeleteListener<ReplicationServerCfg> listener) throws ConfigException {
729      impl.registerDeleteListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
730    }
731
732
733
734    /**
735     * {@inheritDoc}
736     */
737    public void removeReplicationServerDeleteListener(
738        ConfigurationDeleteListener<ReplicationServerCfg> listener) {
739      impl.deregisterDeleteListener(INSTANCE.getReplicationServerRelationDefinition(), listener);
740    }
741
742
743
744    /**
745     * {@inheritDoc}
746     */
747    public Class<? extends ReplicationSynchronizationProviderCfg> configurationClass() {
748      return ReplicationSynchronizationProviderCfg.class;
749    }
750
751
752
753    /**
754     * {@inheritDoc}
755     */
756    public DN dn() {
757      return impl.getDN();
758    }
759
760  }
761}