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}