001/* 002 * The contents of this file are subject to the terms of the Common Development and 003 * Distribution License (the License). You may not use this file except in compliance with the 004 * License. 005 * 006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the 007 * specific language governing permission and limitations under the License. 008 * 009 * When distributing Covered Software, include this CDDL Header Notice in each file and include 010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL 011 * Header, with the fields enclosed by brackets [] replaced by your own identifying 012 * information: "Portions Copyright [year] [name of copyright owner]". 013 * 014 * Copyright 2008 Sun Microsystems, Inc. 015 */ 016package org.forgerock.opendj.server.config.meta; 017 018 019 020import java.net.InetAddress; 021import java.util.Collection; 022import java.util.SortedSet; 023import org.forgerock.opendj.config.AdministratorAction; 024import org.forgerock.opendj.config.AliasDefaultBehaviorProvider; 025import org.forgerock.opendj.config.BooleanPropertyDefinition; 026import org.forgerock.opendj.config.client.ConcurrentModificationException; 027import org.forgerock.opendj.config.client.ManagedObject; 028import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException; 029import org.forgerock.opendj.config.client.OperationRejectedException; 030import org.forgerock.opendj.config.DefaultBehaviorProvider; 031import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider; 032import org.forgerock.opendj.config.DurationPropertyDefinition; 033import org.forgerock.opendj.config.IntegerPropertyDefinition; 034import org.forgerock.opendj.config.IPAddressPropertyDefinition; 035import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException; 036import org.forgerock.opendj.config.ManagedObjectDefinition; 037import org.forgerock.opendj.config.PropertyException; 038import org.forgerock.opendj.config.PropertyOption; 039import org.forgerock.opendj.config.PropertyProvider; 040import org.forgerock.opendj.config.server.ConfigurationChangeListener; 041import org.forgerock.opendj.config.server.ServerManagedObject; 042import org.forgerock.opendj.config.SizePropertyDefinition; 043import org.forgerock.opendj.config.StringPropertyDefinition; 044import org.forgerock.opendj.config.Tag; 045import org.forgerock.opendj.config.TopCfgDefn; 046import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider; 047import org.forgerock.opendj.ldap.DN; 048import org.forgerock.opendj.ldap.LdapException; 049import org.forgerock.opendj.server.config.client.ReplicationServerCfgClient; 050import org.forgerock.opendj.server.config.server.ReplicationServerCfg; 051 052 053 054/** 055 * An interface for querying the Replication Server managed object 056 * definition meta information. 057 * <p> 058 * Replication Servers publish updates to Directory Servers within a 059 * Replication Domain. 060 */ 061public final class ReplicationServerCfgDefn extends ManagedObjectDefinition<ReplicationServerCfgClient, ReplicationServerCfg> { 062 063 /** The singleton configuration definition instance. */ 064 private static final ReplicationServerCfgDefn INSTANCE = new ReplicationServerCfgDefn(); 065 066 067 068 /** The "assured-timeout" property definition. */ 069 private static final DurationPropertyDefinition PD_ASSURED_TIMEOUT; 070 071 072 073 /** The "cipher-key-length" property definition. */ 074 private static final IntegerPropertyDefinition PD_CIPHER_KEY_LENGTH; 075 076 077 078 /** The "cipher-transformation" property definition. */ 079 private static final StringPropertyDefinition PD_CIPHER_TRANSFORMATION; 080 081 082 083 /** The "compute-change-number" property definition. */ 084 private static final BooleanPropertyDefinition PD_COMPUTE_CHANGE_NUMBER; 085 086 087 088 /** The "confidentiality-enabled" property definition. */ 089 private static final BooleanPropertyDefinition PD_CONFIDENTIALITY_ENABLED; 090 091 092 093 /** The "degraded-status-threshold" property definition. */ 094 private static final IntegerPropertyDefinition PD_DEGRADED_STATUS_THRESHOLD; 095 096 097 098 /** The "disk-full-threshold" property definition. */ 099 private static final SizePropertyDefinition PD_DISK_FULL_THRESHOLD; 100 101 102 103 /** The "disk-low-threshold" property definition. */ 104 private static final SizePropertyDefinition PD_DISK_LOW_THRESHOLD; 105 106 107 108 /** The "group-id" property definition. */ 109 private static final IntegerPropertyDefinition PD_GROUP_ID; 110 111 112 113 /** The "monitoring-period" property definition. */ 114 private static final DurationPropertyDefinition PD_MONITORING_PERIOD; 115 116 117 118 /** The "queue-size" property definition. */ 119 private static final IntegerPropertyDefinition PD_QUEUE_SIZE; 120 121 122 123 /** The "replication-db-directory" property definition. */ 124 private static final StringPropertyDefinition PD_REPLICATION_DB_DIRECTORY; 125 126 127 128 /** The "replication-port" property definition. */ 129 private static final IntegerPropertyDefinition PD_REPLICATION_PORT; 130 131 132 133 /** The "replication-purge-delay" property definition. */ 134 private static final DurationPropertyDefinition PD_REPLICATION_PURGE_DELAY; 135 136 137 138 /** The "replication-server" property definition. */ 139 private static final StringPropertyDefinition PD_REPLICATION_SERVER; 140 141 142 143 /** The "replication-server-id" property definition. */ 144 private static final IntegerPropertyDefinition PD_REPLICATION_SERVER_ID; 145 146 147 148 /** The "source-address" property definition. */ 149 private static final IPAddressPropertyDefinition PD_SOURCE_ADDRESS; 150 151 152 153 /** The "weight" property definition. */ 154 private static final IntegerPropertyDefinition PD_WEIGHT; 155 156 157 158 /** The "window-size" property definition. */ 159 private static final IntegerPropertyDefinition PD_WINDOW_SIZE; 160 161 162 163 /** Build the "assured-timeout" property definition. */ 164 static { 165 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "assured-timeout"); 166 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "assured-timeout")); 167 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("1000ms"); 168 builder.setDefaultBehaviorProvider(provider); 169 builder.setBaseUnit("ms"); 170 builder.setLowerLimit("1"); 171 PD_ASSURED_TIMEOUT = builder.getInstance(); 172 INSTANCE.registerPropertyDefinition(PD_ASSURED_TIMEOUT); 173 } 174 175 176 177 /** Build the "cipher-key-length" property definition. */ 178 static { 179 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "cipher-key-length"); 180 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cipher-key-length")); 181 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("128"); 182 builder.setDefaultBehaviorProvider(provider); 183 PD_CIPHER_KEY_LENGTH = builder.getInstance(); 184 INSTANCE.registerPropertyDefinition(PD_CIPHER_KEY_LENGTH); 185 } 186 187 188 189 /** Build the "cipher-transformation" property definition. */ 190 static { 191 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "cipher-transformation"); 192 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cipher-transformation")); 193 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("AES/CBC/PKCS5Padding"); 194 builder.setDefaultBehaviorProvider(provider); 195 PD_CIPHER_TRANSFORMATION = builder.getInstance(); 196 INSTANCE.registerPropertyDefinition(PD_CIPHER_TRANSFORMATION); 197 } 198 199 200 201 /** Build the "compute-change-number" property definition. */ 202 static { 203 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "compute-change-number"); 204 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "compute-change-number")); 205 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 206 builder.setDefaultBehaviorProvider(provider); 207 PD_COMPUTE_CHANGE_NUMBER = builder.getInstance(); 208 INSTANCE.registerPropertyDefinition(PD_COMPUTE_CHANGE_NUMBER); 209 } 210 211 212 213 /** Build the "confidentiality-enabled" property definition. */ 214 static { 215 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "confidentiality-enabled"); 216 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "confidentiality-enabled")); 217 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 218 builder.setDefaultBehaviorProvider(provider); 219 PD_CONFIDENTIALITY_ENABLED = builder.getInstance(); 220 INSTANCE.registerPropertyDefinition(PD_CONFIDENTIALITY_ENABLED); 221 } 222 223 224 225 /** Build the "degraded-status-threshold" property definition. */ 226 static { 227 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "degraded-status-threshold"); 228 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "degraded-status-threshold")); 229 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("5000"); 230 builder.setDefaultBehaviorProvider(provider); 231 builder.setLowerLimit(0); 232 PD_DEGRADED_STATUS_THRESHOLD = builder.getInstance(); 233 INSTANCE.registerPropertyDefinition(PD_DEGRADED_STATUS_THRESHOLD); 234 } 235 236 237 238 /** Build the "disk-full-threshold" property definition. */ 239 static { 240 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-full-threshold"); 241 builder.setOption(PropertyOption.ADVANCED); 242 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-full-threshold")); 243 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("100 megabytes"); 244 builder.setDefaultBehaviorProvider(provider); 245 builder.setLowerLimit("0"); 246 PD_DISK_FULL_THRESHOLD = builder.getInstance(); 247 INSTANCE.registerPropertyDefinition(PD_DISK_FULL_THRESHOLD); 248 } 249 250 251 252 /** Build the "disk-low-threshold" property definition. */ 253 static { 254 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-low-threshold"); 255 builder.setOption(PropertyOption.ADVANCED); 256 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-low-threshold")); 257 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("200 megabytes"); 258 builder.setDefaultBehaviorProvider(provider); 259 builder.setLowerLimit("0"); 260 PD_DISK_LOW_THRESHOLD = builder.getInstance(); 261 INSTANCE.registerPropertyDefinition(PD_DISK_LOW_THRESHOLD); 262 } 263 264 265 266 /** Build the "group-id" property definition. */ 267 static { 268 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "group-id"); 269 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "group-id")); 270 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("1"); 271 builder.setDefaultBehaviorProvider(provider); 272 builder.setUpperLimit(127); 273 builder.setLowerLimit(1); 274 PD_GROUP_ID = builder.getInstance(); 275 INSTANCE.registerPropertyDefinition(PD_GROUP_ID); 276 } 277 278 279 280 /** Build the "monitoring-period" property definition. */ 281 static { 282 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "monitoring-period"); 283 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "monitoring-period")); 284 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("60s"); 285 builder.setDefaultBehaviorProvider(provider); 286 builder.setBaseUnit("ms"); 287 builder.setLowerLimit("0"); 288 PD_MONITORING_PERIOD = builder.getInstance(); 289 INSTANCE.registerPropertyDefinition(PD_MONITORING_PERIOD); 290 } 291 292 293 294 /** Build the "queue-size" property definition. */ 295 static { 296 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "queue-size"); 297 builder.setOption(PropertyOption.ADVANCED); 298 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "queue-size")); 299 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("10000"); 300 builder.setDefaultBehaviorProvider(provider); 301 PD_QUEUE_SIZE = builder.getInstance(); 302 INSTANCE.registerPropertyDefinition(PD_QUEUE_SIZE); 303 } 304 305 306 307 /** Build the "replication-db-directory" property definition. */ 308 static { 309 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "replication-db-directory"); 310 builder.setOption(PropertyOption.READ_ONLY); 311 builder.setOption(PropertyOption.MANDATORY); 312 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-db-directory")); 313 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("changelogDb"); 314 builder.setDefaultBehaviorProvider(provider); 315 PD_REPLICATION_DB_DIRECTORY = builder.getInstance(); 316 INSTANCE.registerPropertyDefinition(PD_REPLICATION_DB_DIRECTORY); 317 } 318 319 320 321 /** Build the "replication-port" property definition. */ 322 static { 323 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "replication-port"); 324 builder.setOption(PropertyOption.MANDATORY); 325 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-port")); 326 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 327 builder.setUpperLimit(65535); 328 builder.setLowerLimit(1); 329 PD_REPLICATION_PORT = builder.getInstance(); 330 INSTANCE.registerPropertyDefinition(PD_REPLICATION_PORT); 331 } 332 333 334 335 /** Build the "replication-purge-delay" property definition. */ 336 static { 337 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "replication-purge-delay"); 338 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-purge-delay")); 339 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("3 days"); 340 builder.setDefaultBehaviorProvider(provider); 341 builder.setAllowUnlimited(false); 342 builder.setBaseUnit("s"); 343 PD_REPLICATION_PURGE_DELAY = builder.getInstance(); 344 INSTANCE.registerPropertyDefinition(PD_REPLICATION_PURGE_DELAY); 345 } 346 347 348 349 /** Build the "replication-server" property definition. */ 350 static { 351 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "replication-server"); 352 builder.setOption(PropertyOption.MULTI_VALUED); 353 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-server")); 354 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 355 builder.setPattern("^.+:[0-9]+$", "HOST:PORT"); 356 PD_REPLICATION_SERVER = builder.getInstance(); 357 INSTANCE.registerPropertyDefinition(PD_REPLICATION_SERVER); 358 } 359 360 361 362 /** Build the "replication-server-id" property definition. */ 363 static { 364 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "replication-server-id"); 365 builder.setOption(PropertyOption.READ_ONLY); 366 builder.setOption(PropertyOption.MANDATORY); 367 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replication-server-id")); 368 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 369 builder.setUpperLimit(65535); 370 builder.setLowerLimit(1); 371 PD_REPLICATION_SERVER_ID = builder.getInstance(); 372 INSTANCE.registerPropertyDefinition(PD_REPLICATION_SERVER_ID); 373 } 374 375 376 377 /** Build the "source-address" property definition. */ 378 static { 379 IPAddressPropertyDefinition.Builder builder = IPAddressPropertyDefinition.createBuilder(INSTANCE, "source-address"); 380 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "source-address")); 381 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<InetAddress>(INSTANCE, "source-address")); 382 PD_SOURCE_ADDRESS = builder.getInstance(); 383 INSTANCE.registerPropertyDefinition(PD_SOURCE_ADDRESS); 384 } 385 386 387 388 /** Build the "weight" property definition. */ 389 static { 390 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "weight"); 391 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "weight")); 392 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("1"); 393 builder.setDefaultBehaviorProvider(provider); 394 builder.setLowerLimit(1); 395 PD_WEIGHT = builder.getInstance(); 396 INSTANCE.registerPropertyDefinition(PD_WEIGHT); 397 } 398 399 400 401 /** Build the "window-size" property definition. */ 402 static { 403 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "window-size"); 404 builder.setOption(PropertyOption.ADVANCED); 405 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "window-size")); 406 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("100000"); 407 builder.setDefaultBehaviorProvider(provider); 408 PD_WINDOW_SIZE = builder.getInstance(); 409 INSTANCE.registerPropertyDefinition(PD_WINDOW_SIZE); 410 } 411 412 413 414 // Register the tags associated with this managed object definition. 415 static { 416 INSTANCE.registerTag(Tag.valueOf("replication")); 417 } 418 419 420 421 /** 422 * Get the Replication Server configuration definition singleton. 423 * 424 * @return Returns the Replication Server configuration definition 425 * singleton. 426 */ 427 public static ReplicationServerCfgDefn getInstance() { 428 return INSTANCE; 429 } 430 431 432 433 /** 434 * Private constructor. 435 */ 436 private ReplicationServerCfgDefn() { 437 super("replication-server", TopCfgDefn.getInstance()); 438 } 439 440 441 442 /** {@inheritDoc} */ 443 public ReplicationServerCfgClient createClientConfiguration( 444 ManagedObject<? extends ReplicationServerCfgClient> impl) { 445 return new ReplicationServerCfgClientImpl(impl); 446 } 447 448 449 450 /** {@inheritDoc} */ 451 public ReplicationServerCfg createServerConfiguration( 452 ServerManagedObject<? extends ReplicationServerCfg> impl) { 453 return new ReplicationServerCfgServerImpl(impl); 454 } 455 456 457 458 /** {@inheritDoc} */ 459 public Class<ReplicationServerCfg> getServerConfigurationClass() { 460 return ReplicationServerCfg.class; 461 } 462 463 464 465 /** 466 * Get the "assured-timeout" property definition. 467 * <p> 468 * The timeout value when waiting for assured mode acknowledgments. 469 * <p> 470 * Defines the number of milliseconds that the replication server 471 * will wait for assured acknowledgments (in either Safe Data or Safe 472 * Read assured sub modes) before forgetting them and answer to the 473 * entity that sent an update and is waiting for acknowledgment. 474 * 475 * @return Returns the "assured-timeout" property definition. 476 */ 477 public DurationPropertyDefinition getAssuredTimeoutPropertyDefinition() { 478 return PD_ASSURED_TIMEOUT; 479 } 480 481 482 483 /** 484 * Get the "cipher-key-length" property definition. 485 * <p> 486 * Specifies the key length in bits for the preferred cipher. 487 * 488 * @return Returns the "cipher-key-length" property definition. 489 */ 490 public IntegerPropertyDefinition getCipherKeyLengthPropertyDefinition() { 491 return PD_CIPHER_KEY_LENGTH; 492 } 493 494 495 496 /** 497 * Get the "cipher-transformation" property definition. 498 * <p> 499 * Specifies the cipher for the directory server. The syntax is 500 * "algorithm/mode/padding". 501 * <p> 502 * The full transformation is required: specifying only an algorithm 503 * and allowing the cipher provider to supply the default mode and 504 * padding is not supported, because there is no guarantee these 505 * default values are the same among different implementations. Some 506 * cipher algorithms, including RC4 and ARCFOUR, do not have a mode 507 * or padding, and hence must be specified using NONE for the mode 508 * field and NoPadding for the padding field. For example, 509 * RC4/NONE/NoPadding. 510 * 511 * @return Returns the "cipher-transformation" property definition. 512 */ 513 public StringPropertyDefinition getCipherTransformationPropertyDefinition() { 514 return PD_CIPHER_TRANSFORMATION; 515 } 516 517 518 519 /** 520 * Get the "compute-change-number" property definition. 521 * <p> 522 * Whether the replication server will compute change numbers. 523 * <p> 524 * This boolean tells the replication server to compute change 525 * numbers for each replicated change by maintaining a change number 526 * index database. Changenumbers are computed according to 527 * http://tools.ietf.org/html/draft-good-ldap-changelog-04. Note this 528 * functionality has an impact on CPU, disk accesses and storage. If 529 * changenumbers are not required, it is advisable to set this value 530 * to false. 531 * 532 * @return Returns the "compute-change-number" property definition. 533 */ 534 public BooleanPropertyDefinition getComputeChangeNumberPropertyDefinition() { 535 return PD_COMPUTE_CHANGE_NUMBER; 536 } 537 538 539 540 /** 541 * Get the "confidentiality-enabled" property definition. 542 * <p> 543 * Indicates whether the replication change-log should make records 544 * readable only by Directory Server. Throughput and disk space are 545 * affected by the more expensive operations taking place. 546 * <p> 547 * Confidentiality is achieved by encrypting records on all domains 548 * managed by this replication server. Encrypting the records 549 * prevents unauthorized parties from accessing contents of LDAP 550 * operations. For complete protection, consider enabling secure 551 * communications between servers. Change number indexing is not 552 * affected by the setting. 553 * 554 * @return Returns the "confidentiality-enabled" property definition. 555 */ 556 public BooleanPropertyDefinition getConfidentialityEnabledPropertyDefinition() { 557 return PD_CONFIDENTIALITY_ENABLED; 558 } 559 560 561 562 /** 563 * Get the "degraded-status-threshold" property definition. 564 * <p> 565 * The number of pending changes as threshold value for putting a 566 * directory server in degraded status. 567 * <p> 568 * This value represents a number of pending changes a replication 569 * server has in queue for sending to a directory server. Once this 570 * value is crossed, the matching directory server goes in degraded 571 * status. When number of pending changes goes back under this value, 572 * the directory server is put back in normal status. 0 means status 573 * analyzer is disabled and directory servers are never put in 574 * degraded status. 575 * 576 * @return Returns the "degraded-status-threshold" property definition. 577 */ 578 public IntegerPropertyDefinition getDegradedStatusThresholdPropertyDefinition() { 579 return PD_DEGRADED_STATUS_THRESHOLD; 580 } 581 582 583 584 /** 585 * Get the "disk-full-threshold" property definition. 586 * <p> 587 * The free disk space threshold at which point a warning alert 588 * notification will be triggered and the replication server will 589 * disconnect from the rest of the replication topology. 590 * <p> 591 * When the available free space on the disk used by the replication 592 * changelog falls below the value specified, this replication server 593 * will stop. Connected Directory Servers will fail over to another 594 * RS. The replication server will restart again as soon as free 595 * space rises above the low threshold. 596 * 597 * @return Returns the "disk-full-threshold" property definition. 598 */ 599 public SizePropertyDefinition getDiskFullThresholdPropertyDefinition() { 600 return PD_DISK_FULL_THRESHOLD; 601 } 602 603 604 605 /** 606 * Get the "disk-low-threshold" property definition. 607 * <p> 608 * The free disk space threshold at which point a warning alert 609 * notification will be triggered. 610 * <p> 611 * When the available free space on the disk used by the replication 612 * changelog falls below the value specified, a warning is sent and 613 * logged. Normal operation will continue but administrators are 614 * advised to take action to free some disk space. 615 * 616 * @return Returns the "disk-low-threshold" property definition. 617 */ 618 public SizePropertyDefinition getDiskLowThresholdPropertyDefinition() { 619 return PD_DISK_LOW_THRESHOLD; 620 } 621 622 623 624 /** 625 * Get the "group-id" property definition. 626 * <p> 627 * The group id for the replication server. 628 * <p> 629 * This value defines the group id of the replication server. The 630 * replication system of a LDAP server uses the group id of the 631 * replicated domain and tries to connect, if possible, to a 632 * replication with the same group id. 633 * 634 * @return Returns the "group-id" property definition. 635 */ 636 public IntegerPropertyDefinition getGroupIdPropertyDefinition() { 637 return PD_GROUP_ID; 638 } 639 640 641 642 /** 643 * Get the "monitoring-period" property definition. 644 * <p> 645 * The period between sending of monitoring messages. 646 * <p> 647 * Defines the duration that the replication server will wait before 648 * sending new monitoring messages to its peers (replication servers 649 * and directory servers). Larger values increase the length of time 650 * it takes for a directory server to detect and switch to a more 651 * suitable replication server, whereas smaller values increase the 652 * amount of background network traffic. 653 * 654 * @return Returns the "monitoring-period" property definition. 655 */ 656 public DurationPropertyDefinition getMonitoringPeriodPropertyDefinition() { 657 return PD_MONITORING_PERIOD; 658 } 659 660 661 662 /** 663 * Get the "queue-size" property definition. 664 * <p> 665 * Specifies the number of changes that are kept in memory for each 666 * directory server in the Replication Domain. 667 * 668 * @return Returns the "queue-size" property definition. 669 */ 670 public IntegerPropertyDefinition getQueueSizePropertyDefinition() { 671 return PD_QUEUE_SIZE; 672 } 673 674 675 676 /** 677 * Get the "replication-db-directory" property definition. 678 * <p> 679 * The path where the Replication Server stores all persistent 680 * information. 681 * 682 * @return Returns the "replication-db-directory" property definition. 683 */ 684 public StringPropertyDefinition getReplicationDBDirectoryPropertyDefinition() { 685 return PD_REPLICATION_DB_DIRECTORY; 686 } 687 688 689 690 /** 691 * Get the "replication-port" property definition. 692 * <p> 693 * The port on which this Replication Server waits for connections 694 * from other Replication Servers or Directory Servers. 695 * 696 * @return Returns the "replication-port" property definition. 697 */ 698 public IntegerPropertyDefinition getReplicationPortPropertyDefinition() { 699 return PD_REPLICATION_PORT; 700 } 701 702 703 704 /** 705 * Get the "replication-purge-delay" property definition. 706 * <p> 707 * The time (in seconds) after which the Replication Server erases 708 * all persistent information. 709 * 710 * @return Returns the "replication-purge-delay" property definition. 711 */ 712 public DurationPropertyDefinition getReplicationPurgeDelayPropertyDefinition() { 713 return PD_REPLICATION_PURGE_DELAY; 714 } 715 716 717 718 /** 719 * Get the "replication-server" property definition. 720 * <p> 721 * Specifies the addresses of other Replication Servers to which 722 * this Replication Server tries to connect at startup time. 723 * <p> 724 * Addresses must be specified using the syntax: "hostname:port". If 725 * IPv6 addresses are used as the hostname, they must be specified 726 * using the syntax "[IPv6Address]:port". 727 * 728 * @return Returns the "replication-server" property definition. 729 */ 730 public StringPropertyDefinition getReplicationServerPropertyDefinition() { 731 return PD_REPLICATION_SERVER; 732 } 733 734 735 736 /** 737 * Get the "replication-server-id" property definition. 738 * <p> 739 * Specifies a unique identifier for the Replication Server. 740 * <p> 741 * Each Replication Server must have a different server ID. 742 * 743 * @return Returns the "replication-server-id" property definition. 744 */ 745 public IntegerPropertyDefinition getReplicationServerIdPropertyDefinition() { 746 return PD_REPLICATION_SERVER_ID; 747 } 748 749 750 751 /** 752 * Get the "source-address" property definition. 753 * <p> 754 * If specified, the server will bind to the address before 755 * connecting to the remote server. 756 * <p> 757 * The address must be one assigned to an existing network 758 * interface. 759 * 760 * @return Returns the "source-address" property definition. 761 */ 762 public IPAddressPropertyDefinition getSourceAddressPropertyDefinition() { 763 return PD_SOURCE_ADDRESS; 764 } 765 766 767 768 /** 769 * Get the "weight" property definition. 770 * <p> 771 * The weight of the replication server. 772 * <p> 773 * The weight affected to the replication server. Each replication 774 * server of the topology has a weight. When combined together, the 775 * weights of the replication servers of a same group can be 776 * translated to a percentage that determines the quantity of 777 * directory servers of the topology that should be connected to a 778 * replication server. For instance imagine a topology with 3 779 * replication servers (with the same group id) with the following 780 * weights: RS1=1, RS2=1, RS3=2. This means that RS1 should have 25% 781 * of the directory servers connected in the topology, RS2 25%, and 782 * RS3 50%. This may be useful if the replication servers of the 783 * topology have a different power and one wants to spread the load 784 * between the replication servers according to their power. 785 * 786 * @return Returns the "weight" property definition. 787 */ 788 public IntegerPropertyDefinition getWeightPropertyDefinition() { 789 return PD_WEIGHT; 790 } 791 792 793 794 /** 795 * Get the "window-size" property definition. 796 * <p> 797 * Specifies the window size that the Replication Server uses when 798 * communicating with other Replication Servers. 799 * <p> 800 * This option may be deprecated and removed in future releases. 801 * 802 * @return Returns the "window-size" property definition. 803 */ 804 public IntegerPropertyDefinition getWindowSizePropertyDefinition() { 805 return PD_WINDOW_SIZE; 806 } 807 808 809 810 /** 811 * Managed object client implementation. 812 */ 813 private static class ReplicationServerCfgClientImpl implements 814 ReplicationServerCfgClient { 815 816 /** Private implementation. */ 817 private ManagedObject<? extends ReplicationServerCfgClient> impl; 818 819 820 821 /** Private constructor. */ 822 private ReplicationServerCfgClientImpl( 823 ManagedObject<? extends ReplicationServerCfgClient> impl) { 824 this.impl = impl; 825 } 826 827 828 829 /** {@inheritDoc} */ 830 public long getAssuredTimeout() { 831 return impl.getPropertyValue(INSTANCE.getAssuredTimeoutPropertyDefinition()); 832 } 833 834 835 836 /** {@inheritDoc} */ 837 public void setAssuredTimeout(Long value) { 838 impl.setPropertyValue(INSTANCE.getAssuredTimeoutPropertyDefinition(), value); 839 } 840 841 842 843 /** {@inheritDoc} */ 844 public int getCipherKeyLength() { 845 return impl.getPropertyValue(INSTANCE.getCipherKeyLengthPropertyDefinition()); 846 } 847 848 849 850 /** {@inheritDoc} */ 851 public void setCipherKeyLength(Integer value) { 852 impl.setPropertyValue(INSTANCE.getCipherKeyLengthPropertyDefinition(), value); 853 } 854 855 856 857 /** {@inheritDoc} */ 858 public String getCipherTransformation() { 859 return impl.getPropertyValue(INSTANCE.getCipherTransformationPropertyDefinition()); 860 } 861 862 863 864 /** {@inheritDoc} */ 865 public void setCipherTransformation(String value) { 866 impl.setPropertyValue(INSTANCE.getCipherTransformationPropertyDefinition(), value); 867 } 868 869 870 871 /** {@inheritDoc} */ 872 public boolean isComputeChangeNumber() { 873 return impl.getPropertyValue(INSTANCE.getComputeChangeNumberPropertyDefinition()); 874 } 875 876 877 878 /** {@inheritDoc} */ 879 public void setComputeChangeNumber(Boolean value) { 880 impl.setPropertyValue(INSTANCE.getComputeChangeNumberPropertyDefinition(), value); 881 } 882 883 884 885 /** {@inheritDoc} */ 886 public boolean isConfidentialityEnabled() { 887 return impl.getPropertyValue(INSTANCE.getConfidentialityEnabledPropertyDefinition()); 888 } 889 890 891 892 /** {@inheritDoc} */ 893 public void setConfidentialityEnabled(Boolean value) { 894 impl.setPropertyValue(INSTANCE.getConfidentialityEnabledPropertyDefinition(), value); 895 } 896 897 898 899 /** {@inheritDoc} */ 900 public int getDegradedStatusThreshold() { 901 return impl.getPropertyValue(INSTANCE.getDegradedStatusThresholdPropertyDefinition()); 902 } 903 904 905 906 /** {@inheritDoc} */ 907 public void setDegradedStatusThreshold(Integer value) { 908 impl.setPropertyValue(INSTANCE.getDegradedStatusThresholdPropertyDefinition(), value); 909 } 910 911 912 913 /** {@inheritDoc} */ 914 public long getDiskFullThreshold() { 915 return impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition()); 916 } 917 918 919 920 /** {@inheritDoc} */ 921 public void setDiskFullThreshold(Long value) { 922 impl.setPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition(), value); 923 } 924 925 926 927 /** {@inheritDoc} */ 928 public long getDiskLowThreshold() { 929 return impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition()); 930 } 931 932 933 934 /** {@inheritDoc} */ 935 public void setDiskLowThreshold(Long value) { 936 impl.setPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition(), value); 937 } 938 939 940 941 /** {@inheritDoc} */ 942 public int getGroupId() { 943 return impl.getPropertyValue(INSTANCE.getGroupIdPropertyDefinition()); 944 } 945 946 947 948 /** {@inheritDoc} */ 949 public void setGroupId(Integer value) { 950 impl.setPropertyValue(INSTANCE.getGroupIdPropertyDefinition(), value); 951 } 952 953 954 955 /** {@inheritDoc} */ 956 public long getMonitoringPeriod() { 957 return impl.getPropertyValue(INSTANCE.getMonitoringPeriodPropertyDefinition()); 958 } 959 960 961 962 /** {@inheritDoc} */ 963 public void setMonitoringPeriod(Long value) { 964 impl.setPropertyValue(INSTANCE.getMonitoringPeriodPropertyDefinition(), value); 965 } 966 967 968 969 /** {@inheritDoc} */ 970 public int getQueueSize() { 971 return impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition()); 972 } 973 974 975 976 /** {@inheritDoc} */ 977 public void setQueueSize(Integer value) { 978 impl.setPropertyValue(INSTANCE.getQueueSizePropertyDefinition(), value); 979 } 980 981 982 983 /** {@inheritDoc} */ 984 public String getReplicationDBDirectory() { 985 return impl.getPropertyValue(INSTANCE.getReplicationDBDirectoryPropertyDefinition()); 986 } 987 988 989 990 /** {@inheritDoc} */ 991 public void setReplicationDBDirectory(String value) throws PropertyException { 992 impl.setPropertyValue(INSTANCE.getReplicationDBDirectoryPropertyDefinition(), value); 993 } 994 995 996 997 /** {@inheritDoc} */ 998 public Integer getReplicationPort() { 999 return impl.getPropertyValue(INSTANCE.getReplicationPortPropertyDefinition()); 1000 } 1001 1002 1003 1004 /** {@inheritDoc} */ 1005 public void setReplicationPort(int value) { 1006 impl.setPropertyValue(INSTANCE.getReplicationPortPropertyDefinition(), value); 1007 } 1008 1009 1010 1011 /** {@inheritDoc} */ 1012 public long getReplicationPurgeDelay() { 1013 return impl.getPropertyValue(INSTANCE.getReplicationPurgeDelayPropertyDefinition()); 1014 } 1015 1016 1017 1018 /** {@inheritDoc} */ 1019 public void setReplicationPurgeDelay(Long value) { 1020 impl.setPropertyValue(INSTANCE.getReplicationPurgeDelayPropertyDefinition(), value); 1021 } 1022 1023 1024 1025 /** {@inheritDoc} */ 1026 public SortedSet<String> getReplicationServer() { 1027 return impl.getPropertyValues(INSTANCE.getReplicationServerPropertyDefinition()); 1028 } 1029 1030 1031 1032 /** {@inheritDoc} */ 1033 public void setReplicationServer(Collection<String> values) { 1034 impl.setPropertyValues(INSTANCE.getReplicationServerPropertyDefinition(), values); 1035 } 1036 1037 1038 1039 /** {@inheritDoc} */ 1040 public Integer getReplicationServerId() { 1041 return impl.getPropertyValue(INSTANCE.getReplicationServerIdPropertyDefinition()); 1042 } 1043 1044 1045 1046 /** {@inheritDoc} */ 1047 public void setReplicationServerId(int value) throws PropertyException { 1048 impl.setPropertyValue(INSTANCE.getReplicationServerIdPropertyDefinition(), value); 1049 } 1050 1051 1052 1053 /** {@inheritDoc} */ 1054 public InetAddress getSourceAddress() { 1055 return impl.getPropertyValue(INSTANCE.getSourceAddressPropertyDefinition()); 1056 } 1057 1058 1059 1060 /** {@inheritDoc} */ 1061 public void setSourceAddress(InetAddress value) { 1062 impl.setPropertyValue(INSTANCE.getSourceAddressPropertyDefinition(), value); 1063 } 1064 1065 1066 1067 /** {@inheritDoc} */ 1068 public int getWeight() { 1069 return impl.getPropertyValue(INSTANCE.getWeightPropertyDefinition()); 1070 } 1071 1072 1073 1074 /** {@inheritDoc} */ 1075 public void setWeight(Integer value) { 1076 impl.setPropertyValue(INSTANCE.getWeightPropertyDefinition(), value); 1077 } 1078 1079 1080 1081 /** {@inheritDoc} */ 1082 public int getWindowSize() { 1083 return impl.getPropertyValue(INSTANCE.getWindowSizePropertyDefinition()); 1084 } 1085 1086 1087 1088 /** {@inheritDoc} */ 1089 public void setWindowSize(Integer value) { 1090 impl.setPropertyValue(INSTANCE.getWindowSizePropertyDefinition(), value); 1091 } 1092 1093 1094 1095 /** {@inheritDoc} */ 1096 public ManagedObjectDefinition<? extends ReplicationServerCfgClient, ? extends ReplicationServerCfg> definition() { 1097 return INSTANCE; 1098 } 1099 1100 1101 1102 /** {@inheritDoc} */ 1103 public PropertyProvider properties() { 1104 return impl; 1105 } 1106 1107 1108 1109 /** {@inheritDoc} */ 1110 public void commit() throws ManagedObjectAlreadyExistsException, 1111 MissingMandatoryPropertiesException, ConcurrentModificationException, 1112 OperationRejectedException, LdapException { 1113 impl.commit(); 1114 } 1115 1116 1117 1118 /** {@inheritDoc} */ 1119 public String toString() { 1120 return impl.toString(); 1121 } 1122 } 1123 1124 1125 1126 /** 1127 * Managed object server implementation. 1128 */ 1129 private static class ReplicationServerCfgServerImpl implements 1130 ReplicationServerCfg { 1131 1132 /** Private implementation. */ 1133 private ServerManagedObject<? extends ReplicationServerCfg> impl; 1134 1135 /** The value of the "assured-timeout" property. */ 1136 private final long pAssuredTimeout; 1137 1138 /** The value of the "cipher-key-length" property. */ 1139 private final int pCipherKeyLength; 1140 1141 /** The value of the "cipher-transformation" property. */ 1142 private final String pCipherTransformation; 1143 1144 /** The value of the "compute-change-number" property. */ 1145 private final boolean pComputeChangeNumber; 1146 1147 /** The value of the "confidentiality-enabled" property. */ 1148 private final boolean pConfidentialityEnabled; 1149 1150 /** The value of the "degraded-status-threshold" property. */ 1151 private final int pDegradedStatusThreshold; 1152 1153 /** The value of the "disk-full-threshold" property. */ 1154 private final long pDiskFullThreshold; 1155 1156 /** The value of the "disk-low-threshold" property. */ 1157 private final long pDiskLowThreshold; 1158 1159 /** The value of the "group-id" property. */ 1160 private final int pGroupId; 1161 1162 /** The value of the "monitoring-period" property. */ 1163 private final long pMonitoringPeriod; 1164 1165 /** The value of the "queue-size" property. */ 1166 private final int pQueueSize; 1167 1168 /** The value of the "replication-db-directory" property. */ 1169 private final String pReplicationDBDirectory; 1170 1171 /** The value of the "replication-port" property. */ 1172 private final int pReplicationPort; 1173 1174 /** The value of the "replication-purge-delay" property. */ 1175 private final long pReplicationPurgeDelay; 1176 1177 /** The value of the "replication-server" property. */ 1178 private final SortedSet<String> pReplicationServer; 1179 1180 /** The value of the "replication-server-id" property. */ 1181 private final int pReplicationServerId; 1182 1183 /** The value of the "source-address" property. */ 1184 private final InetAddress pSourceAddress; 1185 1186 /** The value of the "weight" property. */ 1187 private final int pWeight; 1188 1189 /** The value of the "window-size" property. */ 1190 private final int pWindowSize; 1191 1192 1193 1194 /** Private constructor. */ 1195 private ReplicationServerCfgServerImpl(ServerManagedObject<? extends ReplicationServerCfg> impl) { 1196 this.impl = impl; 1197 this.pAssuredTimeout = impl.getPropertyValue(INSTANCE.getAssuredTimeoutPropertyDefinition()); 1198 this.pCipherKeyLength = impl.getPropertyValue(INSTANCE.getCipherKeyLengthPropertyDefinition()); 1199 this.pCipherTransformation = impl.getPropertyValue(INSTANCE.getCipherTransformationPropertyDefinition()); 1200 this.pComputeChangeNumber = impl.getPropertyValue(INSTANCE.getComputeChangeNumberPropertyDefinition()); 1201 this.pConfidentialityEnabled = impl.getPropertyValue(INSTANCE.getConfidentialityEnabledPropertyDefinition()); 1202 this.pDegradedStatusThreshold = impl.getPropertyValue(INSTANCE.getDegradedStatusThresholdPropertyDefinition()); 1203 this.pDiskFullThreshold = impl.getPropertyValue(INSTANCE.getDiskFullThresholdPropertyDefinition()); 1204 this.pDiskLowThreshold = impl.getPropertyValue(INSTANCE.getDiskLowThresholdPropertyDefinition()); 1205 this.pGroupId = impl.getPropertyValue(INSTANCE.getGroupIdPropertyDefinition()); 1206 this.pMonitoringPeriod = impl.getPropertyValue(INSTANCE.getMonitoringPeriodPropertyDefinition()); 1207 this.pQueueSize = impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition()); 1208 this.pReplicationDBDirectory = impl.getPropertyValue(INSTANCE.getReplicationDBDirectoryPropertyDefinition()); 1209 this.pReplicationPort = impl.getPropertyValue(INSTANCE.getReplicationPortPropertyDefinition()); 1210 this.pReplicationPurgeDelay = impl.getPropertyValue(INSTANCE.getReplicationPurgeDelayPropertyDefinition()); 1211 this.pReplicationServer = impl.getPropertyValues(INSTANCE.getReplicationServerPropertyDefinition()); 1212 this.pReplicationServerId = impl.getPropertyValue(INSTANCE.getReplicationServerIdPropertyDefinition()); 1213 this.pSourceAddress = impl.getPropertyValue(INSTANCE.getSourceAddressPropertyDefinition()); 1214 this.pWeight = impl.getPropertyValue(INSTANCE.getWeightPropertyDefinition()); 1215 this.pWindowSize = impl.getPropertyValue(INSTANCE.getWindowSizePropertyDefinition()); 1216 } 1217 1218 1219 1220 /** {@inheritDoc} */ 1221 public void addChangeListener( 1222 ConfigurationChangeListener<ReplicationServerCfg> listener) { 1223 impl.registerChangeListener(listener); 1224 } 1225 1226 1227 1228 /** {@inheritDoc} */ 1229 public void removeChangeListener( 1230 ConfigurationChangeListener<ReplicationServerCfg> listener) { 1231 impl.deregisterChangeListener(listener); 1232 } 1233 1234 1235 1236 /** {@inheritDoc} */ 1237 public long getAssuredTimeout() { 1238 return pAssuredTimeout; 1239 } 1240 1241 1242 1243 /** {@inheritDoc} */ 1244 public int getCipherKeyLength() { 1245 return pCipherKeyLength; 1246 } 1247 1248 1249 1250 /** {@inheritDoc} */ 1251 public String getCipherTransformation() { 1252 return pCipherTransformation; 1253 } 1254 1255 1256 1257 /** {@inheritDoc} */ 1258 public boolean isComputeChangeNumber() { 1259 return pComputeChangeNumber; 1260 } 1261 1262 1263 1264 /** {@inheritDoc} */ 1265 public boolean isConfidentialityEnabled() { 1266 return pConfidentialityEnabled; 1267 } 1268 1269 1270 1271 /** {@inheritDoc} */ 1272 public int getDegradedStatusThreshold() { 1273 return pDegradedStatusThreshold; 1274 } 1275 1276 1277 1278 /** {@inheritDoc} */ 1279 public long getDiskFullThreshold() { 1280 return pDiskFullThreshold; 1281 } 1282 1283 1284 1285 /** {@inheritDoc} */ 1286 public long getDiskLowThreshold() { 1287 return pDiskLowThreshold; 1288 } 1289 1290 1291 1292 /** {@inheritDoc} */ 1293 public int getGroupId() { 1294 return pGroupId; 1295 } 1296 1297 1298 1299 /** {@inheritDoc} */ 1300 public long getMonitoringPeriod() { 1301 return pMonitoringPeriod; 1302 } 1303 1304 1305 1306 /** {@inheritDoc} */ 1307 public int getQueueSize() { 1308 return pQueueSize; 1309 } 1310 1311 1312 1313 /** {@inheritDoc} */ 1314 public String getReplicationDBDirectory() { 1315 return pReplicationDBDirectory; 1316 } 1317 1318 1319 1320 /** {@inheritDoc} */ 1321 public int getReplicationPort() { 1322 return pReplicationPort; 1323 } 1324 1325 1326 1327 /** {@inheritDoc} */ 1328 public long getReplicationPurgeDelay() { 1329 return pReplicationPurgeDelay; 1330 } 1331 1332 1333 1334 /** {@inheritDoc} */ 1335 public SortedSet<String> getReplicationServer() { 1336 return pReplicationServer; 1337 } 1338 1339 1340 1341 /** {@inheritDoc} */ 1342 public int getReplicationServerId() { 1343 return pReplicationServerId; 1344 } 1345 1346 1347 1348 /** {@inheritDoc} */ 1349 public InetAddress getSourceAddress() { 1350 return pSourceAddress; 1351 } 1352 1353 1354 1355 /** {@inheritDoc} */ 1356 public int getWeight() { 1357 return pWeight; 1358 } 1359 1360 1361 1362 /** {@inheritDoc} */ 1363 public int getWindowSize() { 1364 return pWindowSize; 1365 } 1366 1367 1368 1369 /** {@inheritDoc} */ 1370 public Class<? extends ReplicationServerCfg> configurationClass() { 1371 return ReplicationServerCfg.class; 1372 } 1373 1374 1375 1376 /** {@inheritDoc} */ 1377 public DN dn() { 1378 return impl.getDN(); 1379 } 1380 1381 1382 1383 /** {@inheritDoc} */ 1384 public String toString() { 1385 return impl.toString(); 1386 } 1387 } 1388}