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