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