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
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2006-2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.types;
028 import org.opends.messages.Message;
029
030
031
032 import java.util.Map;
033 import java.util.Set;
034
035 import org.opends.server.api.AlertGenerator;
036 import org.opends.server.api.ApproximateMatchingRule;
037 import org.opends.server.api.AttributeSyntax;
038 import org.opends.server.api.ChangeNotificationListener;
039 import org.opends.server.api.ConfigHandler;
040 import org.opends.server.api.EqualityMatchingRule;
041 import org.opends.server.api.ExtendedOperationHandler;
042 import org.opends.server.api.InvokableComponent;
043 import org.opends.server.api.OrderingMatchingRule;
044 import org.opends.server.api.SASLMechanismHandler;
045 import org.opends.server.api.ServerShutdownListener;
046 import org.opends.server.api.SubstringMatchingRule;
047 import org.opends.server.api.MatchingRule;
048 import org.opends.server.config.ConfigEntry;
049 import org.opends.server.config.ConfigException;
050 import org.opends.server.core.DirectoryServer;
051
052
053 /**
054 * This interface defines a set of methods that may be used by
055 * third-party code to obtatin information about the core Directory
056 * Server configuration and the instances of various kinds of
057 * components that have registered themselves with the server.
058 * <BR><BR>
059 * Note that this interface is not intended to be implemented by any
060 * third-party code. It is merely used to control which elements are
061 * intended for use by external classes.
062 */
063 @org.opends.server.types.PublicAPI(
064 stability=org.opends.server.types.StabilityLevel.VOLATILE,
065 mayInstantiate=false,
066 mayExtend=false,
067 mayInvoke=true)
068 public final class DirectoryConfig
069 {
070 /**
071 * Retrieves a reference to the Directory Server crypto manager.
072 *
073 * @return A reference to the Directory Server crypto manager.
074 */
075 public static CryptoManager getCryptoManager()
076 {
077 return DirectoryServer.getCryptoManager();
078 }
079
080
081
082 /**
083 * Retrieves the operating system on which the Directory Server is
084 * running.
085 *
086 * @return The operating system on which the Directory Server is
087 * running.
088 */
089 public static OperatingSystem getOperatingSystem()
090 {
091 return DirectoryServer.getOperatingSystem();
092 }
093
094
095
096 /**
097 * Retrieves a reference to the Directory Server configuration
098 * handler.
099 *
100 * @return A reference to the Directory Server configuration
101 * handler.
102 */
103 public static ConfigHandler getConfigHandler()
104 {
105 return DirectoryServer.getConfigHandler();
106 }
107
108
109
110 /**
111 * Retrieves the requested entry from the Directory Server
112 * configuration.
113 *
114 * @param entryDN The DN of the configuration entry to retrieve.
115 *
116 * @return The requested entry from the Directory Server
117 * configuration.
118 *
119 * @throws ConfigException If a problem occurs while trying to
120 * retrieve the requested entry.
121 */
122 public static ConfigEntry getConfigEntry(DN entryDN)
123 throws ConfigException
124 {
125 return DirectoryServer.getConfigEntry(entryDN);
126 }
127
128
129
130 /**
131 * Retrieves the path to the root directory for this instance of the
132 * Directory Server.
133 *
134 * @return The path to the root directory for this instance of the
135 * Directory Server.
136 */
137 public static String getServerRoot()
138 {
139 return DirectoryServer.getServerRoot();
140 }
141
142
143
144 /**
145 * Retrieves the time that the Directory Server was started, in
146 * milliseconds since the epoch.
147 *
148 * @return The time that the Directory Server was started, in
149 * milliseconds since the epoch.
150 */
151 public static long getStartTime()
152 {
153 return DirectoryServer.getStartTime();
154 }
155
156
157
158 /**
159 * Retrieves the time that the Directory Server was started,
160 * formatted in UTC.
161 *
162 * @return The time that the Directory Server was started,
163 * formatted in UTC.
164 */
165 public static String getStartTimeUTC()
166 {
167 return DirectoryServer.getStartTimeUTC();
168 }
169
170
171
172 /**
173 * Retrieves a reference to the Directory Server schema.
174 *
175 * @return A reference to the Directory Server schema.
176 */
177 public static Schema getSchema()
178 {
179 return DirectoryServer.getSchema();
180 }
181
182
183
184 /**
185 * Retrieves the set of matching rules registered with the Directory
186 * Server. The mapping will be between the lowercase name or OID
187 * for each matching rule and the matching rule implementation. The
188 * same matching rule instance may be included multiple times with
189 * different keys. The returned map must not be altered by the
190 * caller.
191 *
192 * @return The set of matching rules registered with the Directory
193 * Server.
194 */
195 public static Map<String,MatchingRule> getMatchingRules()
196 {
197 return DirectoryServer.getMatchingRules();
198 }
199
200
201
202 /**
203 * Retrieves the matching rule with the specified name or OID.
204 *
205 * @param lowerName The lowercase name or OID for the matching
206 * rule to retrieve.
207 *
208 * @return The requested matching rule, or <CODE>null</CODE> if no
209 * such matching rule has been defined in the server.
210 */
211 public static MatchingRule getMatchingRule(String lowerName)
212 {
213 return DirectoryServer.getMatchingRule(lowerName);
214 }
215
216
217
218 /**
219 * Retrieves the approximate matching rule with the specified name
220 * or OID.
221 *
222 * @param lowerName The lowercase name or OID for the approximate
223 * matching rule to retrieve.
224 *
225 * @return The requested approximate matching rule, or
226 * <CODE>null</CODE> if no such matching rule has been
227 * defined in the server.
228 */
229 public static ApproximateMatchingRule
230 getApproximateMatchingRule(String lowerName)
231 {
232 return DirectoryServer.getApproximateMatchingRule(lowerName);
233 }
234
235
236
237 /**
238 * Retrieves the equality matching rule with the specified name or
239 * OID.
240 *
241 * @param lowerName The lowercase name or OID for the equality
242 * matching rule to retrieve.
243 *
244 * @return The requested equality matching rule, or
245 * <CODE>null</CODE> if no such matching rule has been
246 * defined in the server.
247 */
248 public static EqualityMatchingRule
249 getEqualityMatchingRule(String lowerName)
250 {
251 return DirectoryServer.getEqualityMatchingRule(lowerName);
252 }
253
254
255
256 /**
257 * Retrieves the ordering matching rule with the specified name or
258 * OID.
259 *
260 * @param lowerName The lowercase name or OID for the ordering
261 * matching rule to retrieve.
262 *
263 * @return The requested ordering matching rule, or
264 * <CODE>null</CODE> if no such matching rule has been
265 * defined in the server.
266 */
267 public static OrderingMatchingRule
268 getOrderingMatchingRule(String lowerName)
269 {
270 return DirectoryServer.getOrderingMatchingRule(lowerName);
271 }
272
273
274
275 /**
276 * Retrieves the substring matching rule with the specified name or
277 * OID.
278 *
279 * @param lowerName The lowercase name or OID for the substring
280 * matching rule to retrieve.
281 *
282 * @return The requested substring matching rule, or
283 * <CODE>null</CODE> if no such matching rule has been
284 * defined in the server.
285 */
286 public static SubstringMatchingRule
287 getSubstringMatchingRule(String lowerName)
288 {
289 return DirectoryServer.getSubstringMatchingRule(lowerName);
290 }
291
292
293
294 /**
295 * Retrieves the set of objectclasses registered with the Directory
296 * Server. The mapping will be between the lowercase name or OID
297 * for each objectclass and the objectclass implementation. The
298 * same objectclass instance may be included multiple times with
299 * different keys. The returned map must not be altered by the
300 * caller.
301 *
302 * @return The set of objectclasses defined in the Directory
303 * Server.
304 */
305 public static Map<String,ObjectClass> getObjectClasses()
306 {
307 return DirectoryServer.getObjectClasses();
308 }
309
310
311
312 /**
313 * Retrieves the objectclass for the provided lowercase name or OID.
314 * It can optionally return a generated "default" version if the
315 * requested objectclass is not defined in the schema.
316 *
317 * @param lowerName The lowercase name or OID for the
318 * objectclass to retrieve.
319 * @param returnDefault Indicates whether to generate a default
320 * version if the requested objectclass is
321 * not defined in the server schema.
322 *
323 * @return The objectclass type, or <CODE>null</CODE> if there is
324 * no objectclass with the specified name or OID defined in
325 * the server schema and a default class should not be
326 * returned.
327 */
328 public static ObjectClass
329 getObjectClass(String lowerName, boolean returnDefault)
330 {
331 return DirectoryServer.getObjectClass(lowerName, returnDefault);
332 }
333
334
335
336 /**
337 * Retrieves the "top" objectClass, which should be the topmost
338 * objectclass in the inheritance chain for most other
339 * objectclasses.
340 *
341 * @return The "top" objectClass.
342 */
343 public static ObjectClass getTopObjectClass()
344 {
345 return DirectoryServer.getTopObjectClass();
346 }
347
348
349
350 /**
351 * Retrieves the set of attribute type definitions that have been
352 * defined in the Directory Server. The mapping will be between the
353 * lowercase name or OID for each attribute type and the attribute
354 * type implementation. The same attribute type may be included
355 * multiple times with different keys. The returned map must not be
356 * altered by the caller.
357 *
358 * @return The set of attribute type definitions that have been
359 * defined in the Directory Server.
360 */
361 public static Map<String,AttributeType> getAttributeTypes()
362 {
363 return DirectoryServer.getAttributeTypes();
364 }
365
366
367
368 /**
369 * Retrieves the attribute type for the provided lowercase name or
370 * OID. It can optionally return a generated "default" version if
371 * the requested attribute type is not defined in the schema.
372 *
373 * @param lowerName The lowercase name or OID for the
374 * attribute type to retrieve.
375 * @param returnDefault Indicates whether to generate a default
376 * version if the requested attribute type is
377 * not defined in the server schema.
378 *
379 * @return The requested attribute type, or <CODE>null</CODE> if
380 * there is no attribute with the specified type defined in
381 * the server schema and a default type should not be
382 * returned.
383 */
384 public static AttributeType
385 getAttributeType(String lowerName, boolean returnDefault)
386 {
387 return DirectoryServer.getAttributeType(lowerName, returnDefault);
388 }
389
390
391
392 /**
393 * Retrieves the attribute type for the "objectClass" attribute.
394 *
395 * @return The attribute type for the "objectClass" attribute.
396 */
397 public static AttributeType getObjectClassAttributeType()
398 {
399 return DirectoryServer.getObjectClassAttributeType();
400 }
401
402
403
404 /**
405 * Retrieves the set of attribute syntaxes defined in the Directory
406 * Server. The mapping will be between the OID and the
407 * corresponding syntax implementation. The returned map must not
408 * be altered by the caller.
409 *
410 * @return The set of attribute syntaxes defined in the Directory
411 * Server.
412 */
413 public static Map<String,AttributeSyntax>
414 getAttributeSyntaxes()
415 {
416 return DirectoryServer.getAttributeSyntaxes();
417 }
418
419
420
421 /**
422 * Retrieves the requested attribute syntax.
423 *
424 * @param oid The OID of the syntax to retrieve.
425 * @param allowDefault Indicates whether to return the default
426 * attribute syntax if the requested syntax is
427 * unknown.
428 *
429 * @return The requested attribute syntax, the default syntax if
430 * the requested syntax is unknown and the caller has
431 * indicated that the default is acceptable, or
432 * <CODE>null</CODE> otherwise.
433 */
434 public static AttributeSyntax
435 getAttributeSyntax(String oid, boolean allowDefault)
436 {
437 return DirectoryServer.getAttributeSyntax(oid, allowDefault);
438 }
439
440
441
442 /**
443 * Retrieves the default attribute syntax that should be used for
444 * attributes that are not defined in the server schema.
445 *
446 * @return The default attribute syntax that should be used for
447 * attributes that are not defined in the server schema.
448 */
449 public static AttributeSyntax getDefaultAttributeSyntax()
450 {
451 return DirectoryServer.getDefaultAttributeSyntax();
452 }
453
454
455
456 /**
457 * Retrieves the default attribute syntax that should be used for
458 * attributes that are not defined in the server schema and are
459 * meant to store binary values.
460 *
461 * @return The default attribute syntax that should be used for
462 * attributes that are not defined in the server schema and
463 * are meant to store binary values.
464 */
465 public static AttributeSyntax getDefaultBinarySyntax()
466 {
467 return DirectoryServer.getDefaultBinarySyntax();
468 }
469
470
471
472 /**
473 * Retrieves the default attribute syntax that should be used for
474 * attributes that are not defined in the server schema and are
475 * meant to store Boolean values.
476 *
477 * @return The default attribute syntax that should be used for
478 * attributes that are not defined in the server schema and
479 * are meant to store Boolean values.
480 */
481 public static AttributeSyntax getDefaultBooleanSyntax()
482 {
483 return DirectoryServer.getDefaultBooleanSyntax();
484 }
485
486
487
488 /**
489 * Retrieves the default attribute syntax that should be used for
490 * attributes that are not defined in the server schema and are
491 * meant to store DN values.
492 *
493 * @return The default attribute syntax that should be used for
494 * attributes that are not defined in the server schema and
495 * are meant to store DN values.
496 */
497 public static AttributeSyntax getDefaultDNSyntax()
498 {
499 return DirectoryServer.getDefaultDNSyntax();
500 }
501
502
503
504 /**
505 * Retrieves the default attribute syntax that should be used for
506 * attributes that are not defined in the server schema and are
507 * meant to store integer values.
508 *
509 * @return The default attribute syntax that should be used for
510 * attributes that are not defined in the server schema and
511 * are meant to store integer values.
512 */
513 public static AttributeSyntax getDefaultIntegerSyntax()
514 {
515 return DirectoryServer.getDefaultIntegerSyntax();
516 }
517
518
519
520 /**
521 * Retrieves the default attribute syntax that should be used for
522 * attributes that are not defined in the server schema and are
523 * meant to store string values.
524 *
525 * @return The default attribute syntax that should be used for
526 * attributes that are not defined in the server schema and
527 * are meant to store string values.
528 */
529 public static AttributeSyntax getDefaultStringSyntax()
530 {
531 return DirectoryServer.getDefaultStringSyntax();
532 }
533
534
535
536 /**
537 * Retrieves the set of matching rule uses defined in the Directory
538 * Server. The mapping will be between the matching rule and its
539 * corresponding matching rule use. The returned map must not be
540 * altered by the caller.
541 *
542 * @return The set of matching rule uses defined in the Directory
543 * Server.
544 */
545 public static Map<MatchingRule,MatchingRuleUse>
546 getMatchingRuleUses()
547 {
548 return DirectoryServer.getMatchingRuleUses();
549 }
550
551
552
553 /**
554 * Retrieves the matching rule use associated with the provided
555 * matching rule.
556 *
557 * @param matchingRule The matching rule for which to retrieve the
558 * matching rule use.
559 *
560 * @return The matching rule use for the provided matching rule, or
561 * <CODE>null</CODE> if none is defined.
562 */
563 public static MatchingRuleUse
564 getMatchingRuleUse(MatchingRule matchingRule)
565 {
566 return DirectoryServer.getMatchingRuleUse(matchingRule);
567 }
568
569
570
571 /**
572 * Retrieves the set of DIT content rules defined in the Directory
573 * Server. The mapping will be between the structural objectclass
574 * and its corresponding DIT content rule. The returned map must
575 * not be altered by the caller.
576 *
577 * @return The set of DIT content rules defined in the Directory
578 * Server.
579 */
580 public static Map<ObjectClass,DITContentRule>
581 getDITContentRules()
582 {
583 return DirectoryServer.getDITContentRules();
584 }
585
586
587
588 /**
589 * Retrieves the DIT content rule associated with the specified
590 * objectclass.
591 *
592 * @param objectClass The objectclass for which to retrieve the
593 * associated DIT content rule.
594 *
595 * @return The requested DIT content rule, or <CODE>null</CODE> if
596 * no such rule is defined in the schema.
597 */
598 public static DITContentRule
599 getDITContentRule(ObjectClass objectClass)
600 {
601 return DirectoryServer.getDITContentRule(objectClass);
602 }
603
604
605
606 /**
607 * Retrieves the set of DIT structure rules defined in the Directory
608 * Server. The mapping will be between the name form and its
609 * corresponding DIT structure rule. The returned map must not be
610 * altered by the caller.
611 *
612 * @return The set of DIT structure rules defined in the Directory
613 * Server.
614 */
615 public static Map<NameForm,DITStructureRule>
616 getDITStructureRules()
617 {
618 return DirectoryServer.getDITStructureRules();
619 }
620
621
622
623 /**
624 * Retrieves the DIT structure rule associated with the provided
625 * rule ID.
626 *
627 * @param ruleID The rule ID for which to retrieve the associated
628 * DIT structure rule.
629 *
630 * @return The requested DIT structure rule, or <CODE>null</CODE>
631 * if no such rule is defined.
632 */
633 public static DITStructureRule getDITStructureRule(int ruleID)
634 {
635 return DirectoryServer.getDITStructureRule(ruleID);
636 }
637
638
639
640 /**
641 * Retrieves the DIT structure rule associated with the provided
642 * name form.
643 *
644 * @param nameForm The name form for which to retrieve the
645 * associated DIT structure rule.
646 *
647 * @return The requested DIT structure rule, or <CODE>null</CODE>
648 * if no such rule is defined.
649 */
650 public static DITStructureRule
651 getDITStructureRule(NameForm nameForm)
652 {
653 return DirectoryServer.getDITStructureRule(nameForm);
654 }
655
656
657
658 /**
659 * Retrieves the set of name forms defined in the Directory Server.
660 * The mapping will be between the structural objectclass and its
661 * corresponding name form. The returned map must not be altered by
662 * the caller.
663 *
664 * @return The set of name forms defined in the Directory Server.
665 */
666 public static Map<ObjectClass,NameForm> getNameForms()
667 {
668 return DirectoryServer.getNameForms();
669 }
670
671
672
673 /**
674 * Retrieves the name form associated with the specified structural
675 * objectclass.
676 *
677 * @param objectClass The structural objectclass for which to
678 * retrieve the associated name form.
679 *
680 * @return The requested name form, or <CODE>null</CODE> if no such
681 * name form is defined in the schema.
682 */
683 public static NameForm getNameForm(ObjectClass objectClass)
684 {
685 return DirectoryServer.getNameForm(objectClass);
686 }
687
688
689
690 /**
691 * Retrieves the name form associated with the specified name or
692 * OID.
693 *
694 * @param lowerName The name or OID of the name form to retrieve,
695 * formatted in all lowercase characters.
696 *
697 * @return The requested name form, or <CODE>null</CODE> if no such
698 * name form is defined in the schema.
699 */
700 public static NameForm getNameForm(String lowerName)
701 {
702 return DirectoryServer.getNameForm(lowerName);
703 }
704
705
706
707 /**
708 * Registers the provided invokable component with the Directory
709 * Server.
710 *
711 * @param component The invokable component to register.
712 */
713 public static void registerInvokableComponent(
714 InvokableComponent component)
715 {
716 DirectoryServer.registerInvokableComponent(component);
717 }
718
719
720
721 /**
722 * Deregisters the provided invokable component with the Directory
723 * Server.
724 *
725 * @param component The invokable component to deregister.
726 */
727 public static void deregisterInvokableComponent(
728 InvokableComponent component)
729 {
730 DirectoryServer.deregisterInvokableComponent(component);
731 }
732
733
734
735 /**
736 * Registers the provided alert generator with the Directory Server.
737 *
738 * @param alertGenerator The alert generator to register.
739 */
740 public static void registerAlertGenerator(
741 AlertGenerator alertGenerator)
742 {
743 DirectoryServer.registerAlertGenerator(alertGenerator);
744 }
745
746
747
748 /**
749 * Deregisters the provided alert generator with the Directory
750 * Server.
751 *
752 * @param alertGenerator The alert generator to deregister.
753 */
754 public static void deregisterAlertGenerator(
755 AlertGenerator alertGenerator)
756 {
757 DirectoryServer.deregisterAlertGenerator(alertGenerator);
758 }
759
760
761
762 /**
763 * Sends an alert notification with the provided information.
764 *
765 * @param generator The alert generator that created the alert.
766 * @param alertType The alert type name for this alert.
767 * @param alertMessage A message (possibly <CODE>null</CODE>) that
768 * can provide more information about this
769 * alert.
770 */
771 public static void
772 sendAlertNotification(AlertGenerator generator,
773 String alertType,
774 Message alertMessage)
775 {
776 DirectoryServer.sendAlertNotification(generator, alertType,
777 alertMessage);
778 }
779
780
781
782 /**
783 * Retrieves the result code that should be used when the Directory
784 * Server encounters an internal server error.
785 *
786 * @return The result code that should be used when the Directory
787 * Server encounters an internal server error.
788 */
789 public static ResultCode getServerErrorResultCode()
790 {
791 return DirectoryServer.getServerErrorResultCode();
792 }
793
794
795
796 /**
797 * Retrieves the entry with the requested DN. It will first
798 * determine which backend should be used for this DN and will then
799 * use that backend to retrieve the entry. The caller must already
800 * hold the appropriate lock on the specified entry.
801 *
802 * @param entryDN The DN of the entry to retrieve.
803 *
804 * @return The requested entry, or <CODE>null</CODE> if it does not
805 * exist.
806 *
807 * @throws DirectoryException If a problem occurs while attempting
808 * to retrieve the entry.
809 */
810 public static Entry getEntry(DN entryDN)
811 throws DirectoryException
812 {
813 return DirectoryServer.getEntry(entryDN);
814 }
815
816
817
818 /**
819 * Indicates whether the specified entry exists in the Directory
820 * Server. The caller is not required to hold any locks when
821 * invoking this method.
822 *
823 * @param entryDN The DN of the entry for which to make the
824 * determination.
825 *
826 * @return <CODE>true</CODE> if the specified entry exists in one
827 * of the backends, or <CODE>false</CODE> if it does not.
828 *
829 * @throws DirectoryException If a problem occurs while attempting
830 * to make the determination.
831 */
832 public static boolean entryExists(DN entryDN)
833 throws DirectoryException
834 {
835 return DirectoryServer.entryExists(entryDN);
836 }
837
838
839
840 /**
841 * Retrieves the set of OIDs for the supported controls registered
842 * with the Directory Server.
843 *
844 * @return The set of OIDS for the supported controls registered
845 * with the Directory Server.
846 */
847 public static Set<String> getSupportedControls()
848 {
849 return DirectoryServer.getSupportedControls();
850 }
851
852
853
854 /**
855 * Indicates whether the specified OID is registered with the
856 * Directory Server as a supported control.
857 *
858 * @param controlOID The OID of the control for which to make the
859 * determination.
860 *
861 * @return <CODE>true</CODE> if the specified OID is registered
862 * with the server as a supported control, or
863 * <CODE>false</CODE> if not.
864 */
865 public static boolean isSupportedControl(String controlOID)
866 {
867 return DirectoryServer.isSupportedControl(controlOID);
868 }
869
870
871
872 /**
873 * Registers the provided OID as a supported control for the
874 * Directory Server. This will have no effect if the specified
875 * control OID is already present in the list of supported controls.
876 *
877 * @param controlOID The OID of the control to register as a
878 * supported control.
879 */
880 public static void registerSupportedControl(String controlOID)
881 {
882 DirectoryServer.registerSupportedControl(controlOID);
883 }
884
885
886
887 /**
888 * Deregisters the provided OID as a supported control for the
889 * Directory Server. This will have no effect if the specified
890 * control OID is not present in the list of supported controls.
891 *
892 * @param controlOID The OID of the control to deregister as a
893 * supported control.
894 */
895 public static void
896 deregisterSupportedControl(String controlOID)
897 {
898 DirectoryServer.deregisterSupportedControl(controlOID);
899 }
900
901
902
903 /**
904 * Retrieves the set of OIDs for the supported features registered
905 * with the Directory Server.
906 *
907 * @return The set of OIDs for the supported features registered
908 * with the Directory Server.
909 */
910 public static Set<String> getSupportedFeatures()
911 {
912 return DirectoryServer.getSupportedFeatures();
913 }
914
915
916
917 /**
918 * Indicates whether the specified OID is registered with the
919 * Directory Server as a supported feature.
920 *
921 * @param featureOID The OID of the feature for which to make the
922 * determination.
923 *
924 * @return <CODE>true</CODE> if the specified OID is registered
925 * with the server as a supported feature, or
926 * <CODE>false</CODE> if not.
927 */
928 public static boolean isSupportedFeature(String featureOID)
929 {
930 return DirectoryServer.isSupportedFeature(featureOID);
931 }
932
933
934
935 /**
936 * Registers the provided OID as a supported feature for the
937 * Directory Server. This will have no effect if the specified
938 * feature OID is already present in the list of supported features.
939 *
940 * @param featureOID The OID of the feature to register as a
941 * supported feature.
942 */
943 public static void registerSupportedFeature(String featureOID)
944 {
945 DirectoryServer.registerSupportedFeature(featureOID);
946 }
947
948
949
950 /**
951 * Deregisters the provided OID as a supported feature for the
952 * Directory Server. This will have no effect if the specified
953 * feature OID is not present in the list of supported features.
954 *
955 * @param featureOID The OID of the feature to deregister as a
956 * supported feature.
957 */
958 public static void
959 deregisterSupportedFeature(String featureOID)
960 {
961 DirectoryServer.deregisterSupportedFeature(featureOID);
962 }
963
964
965
966 /**
967 * Retrieves the set of extended operations that may be processed by
968 * the Directory Server. The mapping will be between the OID and
969 * the extended operation handler providing the logic for the
970 * extended operation with that OID. The returned map must not be
971 * altered by the caller.
972 *
973 * @return The set of extended operations that may be processed by
974 * the Directory Server.
975 */
976 public static Map<String,ExtendedOperationHandler>
977 getSupportedExtensions()
978 {
979 return DirectoryServer.getSupportedExtensions();
980 }
981
982
983
984 /**
985 * Retrieves the handler for the extended operation for the provided
986 * extended operation OID.
987 *
988 * @param oid The OID of the extended operation to retrieve.
989 *
990 * @return The handler for the specified extended operation, or
991 * <CODE>null</CODE> if there is none.
992 */
993 public static ExtendedOperationHandler
994 getExtendedOperationHandler(String oid)
995 {
996 return DirectoryServer.getExtendedOperationHandler(oid);
997 }
998
999
1000
1001 /**
1002 * Registers the provided extended operation handler with the
1003 * Directory Server.
1004 *
1005 * @param oid The OID for the extended operation to register.
1006 * @param handler The extended operation handler to register with
1007 * the Directory Server.
1008 */
1009 public static void registerSupportedExtension(String oid,
1010 ExtendedOperationHandler handler)
1011 {
1012 DirectoryServer.registerSupportedExtension(oid, handler);
1013 }
1014
1015
1016
1017 /**
1018 * Deregisters the provided extended operation handler with the
1019 * Directory Server.
1020 *
1021 * @param oid The OID for the extended operation to deregister.
1022 */
1023 public static void deregisterSupportedExtension(String oid)
1024 {
1025 DirectoryServer.deregisterSupportedExtension(oid);
1026 }
1027
1028
1029
1030 /**
1031 * Retrieves the set of SASL mechanisms that are supported by the
1032 * Directory Server. The mapping will be between the mechanism name
1033 * and the SASL mechanism handler that implements support for that
1034 * mechanism. The returned map must not be altered by the caller.
1035 *
1036 * @return The set of SASL mechanisms that are supported by the
1037 * Directory Server.
1038 */
1039 public static Map<String,SASLMechanismHandler>
1040 getSupportedSASLMechanisms()
1041 {
1042 return DirectoryServer.getSupportedSASLMechanisms();
1043 }
1044
1045
1046
1047 /**
1048 * Retrieves the handler for the specified SASL mechanism.
1049 *
1050 * @param name The name of the SASL mechanism to retrieve.
1051 *
1052 * @return The handler for the specified SASL mechanism, or
1053 * <CODE>null</CODE> if there is none.
1054 */
1055 public static SASLMechanismHandler
1056 getSASLMechanismHandler(String name)
1057 {
1058 return DirectoryServer.getSASLMechanismHandler(name);
1059 }
1060
1061
1062
1063 /**
1064 * Registers the provided SASL mechanism handler with the Directory
1065 * Server.
1066 *
1067 * @param name The name of the SASL mechanism to be registered.
1068 * @param handler The SASL mechanism handler to register with the
1069 * Directory Server.
1070 */
1071 public static void
1072 registerSASLMechanismHandler(String name,
1073 SASLMechanismHandler handler)
1074 {
1075 DirectoryServer.registerSASLMechanismHandler(name, handler);
1076 }
1077
1078
1079
1080 /**
1081 * Deregisters the provided SASL mechanism handler with the
1082 * Directory Server.
1083 *
1084 * @param name The name of the SASL mechanism to be deregistered.
1085 */
1086 public static void deregisterSASLMechanismHandler(String name)
1087 {
1088 DirectoryServer.deregisterSASLMechanismHandler(name);
1089 }
1090
1091
1092
1093 /**
1094 * Registers the provided change notification listener with the
1095 * Directory Server so that it will be notified of any add, delete,
1096 * modify, or modify DN operations that are performed.
1097 *
1098 * @param changeListener The change notification listener to
1099 * register with the Directory Server.
1100 */
1101 public static void
1102 registerChangeNotificationListener(
1103 ChangeNotificationListener changeListener)
1104 {
1105 DirectoryServer.registerChangeNotificationListener(
1106 changeListener);
1107 }
1108
1109
1110
1111 /**
1112 * Deregisters the provided change notification listener with the
1113 * Directory Server so that it will no longer be notified of any
1114 * add, delete, modify, or modify DN operations that are performed.
1115 *
1116 * @param changeListener The change notification listener to
1117 * deregister with the Directory Server.
1118 */
1119 public static void deregisterChangeNotificationListener(
1120 ChangeNotificationListener changeListener)
1121 {
1122 DirectoryServer.deregisterChangeNotificationListener(
1123 changeListener);
1124 }
1125
1126
1127
1128 /**
1129 * Registers the provided shutdown listener with the Directory
1130 * Server so that it will be notified when the server shuts down.
1131 *
1132 * @param listener The shutdown listener to register with the
1133 * Directory Server.
1134 */
1135 public static void
1136 registerShutdownListener(ServerShutdownListener listener)
1137 {
1138 DirectoryServer.registerShutdownListener(listener);
1139 }
1140
1141
1142
1143 /**
1144 * Deregisters the provided shutdown listener with the Directory
1145 * Server.
1146 *
1147 * @param listener The shutdown listener to deregister with the
1148 * Directory Server.
1149 */
1150 public static void
1151 deregisterShutdownListener(ServerShutdownListener listener)
1152 {
1153 DirectoryServer.deregisterShutdownListener(listener);
1154 }
1155
1156
1157
1158 /**
1159 * Retrieves the full version string for the Directory Server.
1160 *
1161 * @return The full version string for the Directory Server.
1162 */
1163 public static String getVersionString()
1164 {
1165 return DirectoryServer.getVersionString();
1166 }
1167 }
1168