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}