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 2008 Sun Microsystems, Inc.
026     */
027    package org.opends.server.admin.std.meta;
028    
029    
030    
031    import java.util.Collection;
032    import java.util.SortedSet;
033    import org.opends.server.admin.AdministratorAction;
034    import org.opends.server.admin.BooleanPropertyDefinition;
035    import org.opends.server.admin.ClassPropertyDefinition;
036    import org.opends.server.admin.client.AuthorizationException;
037    import org.opends.server.admin.client.CommunicationException;
038    import org.opends.server.admin.client.ConcurrentModificationException;
039    import org.opends.server.admin.client.ManagedObject;
040    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
041    import org.opends.server.admin.client.OperationRejectedException;
042    import org.opends.server.admin.DefaultBehaviorProvider;
043    import org.opends.server.admin.DefinedDefaultBehaviorProvider;
044    import org.opends.server.admin.DurationPropertyDefinition;
045    import org.opends.server.admin.EnumPropertyDefinition;
046    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047    import org.opends.server.admin.ManagedObjectDefinition;
048    import org.opends.server.admin.PropertyOption;
049    import org.opends.server.admin.PropertyProvider;
050    import org.opends.server.admin.server.ConfigurationChangeListener;
051    import org.opends.server.admin.server.ServerManagedObject;
052    import org.opends.server.admin.std.client.ProfilerPluginCfgClient;
053    import org.opends.server.admin.std.meta.PluginCfgDefn.PluginType;
054    import org.opends.server.admin.std.server.PluginCfg;
055    import org.opends.server.admin.std.server.ProfilerPluginCfg;
056    import org.opends.server.admin.StringPropertyDefinition;
057    import org.opends.server.admin.Tag;
058    import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
059    import org.opends.server.types.DN;
060    
061    
062    
063    /**
064     * An interface for querying the Profiler Plugin managed object
065     * definition meta information.
066     * <p>
067     * The Profiler plug-in captures profiling information about
068     * operations performed inside the JVM while the Directory Server is
069     * running.
070     */
071    public final class ProfilerPluginCfgDefn extends ManagedObjectDefinition<ProfilerPluginCfgClient, ProfilerPluginCfg> {
072    
073      // The singleton configuration definition instance.
074      private static final ProfilerPluginCfgDefn INSTANCE = new ProfilerPluginCfgDefn();
075    
076    
077    
078      /**
079       * Defines the set of permissable values for the "profile-action" property.
080       * <p>
081       * Specifies the action that should be taken by the profiler.
082       * <p>
083       * A value of "start" causes the profiler thread to start collecting
084       * data if it is not already active. A value of "stop" causes the
085       * profiler thread to stop collecting data and write it to disk, and
086       * a value of "cancel" causes the profiler thread to stop collecting
087       * data and discard anything that has been captured. These operations
088       * occur immediately.
089       */
090      public static enum ProfileAction {
091    
092        /**
093         * Stop collecting profile data and discard what has been
094         * captured.
095         */
096        CANCEL("cancel"),
097    
098    
099    
100        /**
101         * Do not take any action.
102         */
103        NONE("none"),
104    
105    
106    
107        /**
108         * Start collecting profile data.
109         */
110        START("start"),
111    
112    
113    
114        /**
115         * Stop collecting profile data and write what has been captured
116         * to a file in the profile directory.
117         */
118        STOP("stop");
119    
120    
121    
122        // String representation of the value.
123        private final String name;
124    
125    
126    
127        // Private constructor.
128        private ProfileAction(String name) { this.name = name; }
129    
130    
131    
132        /**
133         * {@inheritDoc}
134         */
135        public String toString() { return name; }
136    
137      }
138    
139    
140    
141      // The "enable-profiling-on-startup" property definition.
142      private static final BooleanPropertyDefinition PD_ENABLE_PROFILING_ON_STARTUP;
143    
144    
145    
146      // The "invoke-for-internal-operations" property definition.
147      private static final BooleanPropertyDefinition PD_INVOKE_FOR_INTERNAL_OPERATIONS;
148    
149    
150    
151      // The "java-class" property definition.
152      private static final ClassPropertyDefinition PD_JAVA_CLASS;
153    
154    
155    
156      // The "plugin-type" property definition.
157      private static final EnumPropertyDefinition<PluginType> PD_PLUGIN_TYPE;
158    
159    
160    
161      // The "profile-action" property definition.
162      private static final EnumPropertyDefinition<ProfileAction> PD_PROFILE_ACTION;
163    
164    
165    
166      // The "profile-directory" property definition.
167      private static final StringPropertyDefinition PD_PROFILE_DIRECTORY;
168    
169    
170    
171      // The "profile-sample-interval" property definition.
172      private static final DurationPropertyDefinition PD_PROFILE_SAMPLE_INTERVAL;
173    
174    
175    
176      // Build the "enable-profiling-on-startup" property definition.
177      static {
178          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enable-profiling-on-startup");
179          builder.setOption(PropertyOption.MANDATORY);
180          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enable-profiling-on-startup"));
181          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>());
182          PD_ENABLE_PROFILING_ON_STARTUP = builder.getInstance();
183          INSTANCE.registerPropertyDefinition(PD_ENABLE_PROFILING_ON_STARTUP);
184      }
185    
186    
187    
188      // Build the "invoke-for-internal-operations" property definition.
189      static {
190          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "invoke-for-internal-operations");
191          builder.setOption(PropertyOption.ADVANCED);
192          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "invoke-for-internal-operations"));
193          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
194          builder.setDefaultBehaviorProvider(provider);
195          PD_INVOKE_FOR_INTERNAL_OPERATIONS = builder.getInstance();
196          INSTANCE.registerPropertyDefinition(PD_INVOKE_FOR_INTERNAL_OPERATIONS);
197      }
198    
199    
200    
201      // Build the "java-class" property definition.
202      static {
203          ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
204          builder.setOption(PropertyOption.MANDATORY);
205          builder.setOption(PropertyOption.ADVANCED);
206          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
207          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.plugins.profiler.ProfilerPlugin");
208          builder.setDefaultBehaviorProvider(provider);
209          builder.addInstanceOf("org.opends.server.api.plugin.DirectoryServerPlugin");
210          PD_JAVA_CLASS = builder.getInstance();
211          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
212      }
213    
214    
215    
216      // Build the "plugin-type" property definition.
217      static {
218          EnumPropertyDefinition.Builder<PluginType> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "plugin-type");
219          builder.setOption(PropertyOption.MULTI_VALUED);
220          builder.setOption(PropertyOption.MANDATORY);
221          builder.setOption(PropertyOption.ADVANCED);
222          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "plugin-type"));
223          DefaultBehaviorProvider<PluginType> provider = new DefinedDefaultBehaviorProvider<PluginType>("startup");
224          builder.setDefaultBehaviorProvider(provider);
225          builder.setEnumClass(PluginType.class);
226          PD_PLUGIN_TYPE = builder.getInstance();
227          INSTANCE.registerPropertyDefinition(PD_PLUGIN_TYPE);
228      }
229    
230    
231    
232      // Build the "profile-action" property definition.
233      static {
234          EnumPropertyDefinition.Builder<ProfileAction> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "profile-action");
235          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "profile-action"));
236          DefaultBehaviorProvider<ProfileAction> provider = new DefinedDefaultBehaviorProvider<ProfileAction>("none");
237          builder.setDefaultBehaviorProvider(provider);
238          builder.setEnumClass(ProfileAction.class);
239          PD_PROFILE_ACTION = builder.getInstance();
240          INSTANCE.registerPropertyDefinition(PD_PROFILE_ACTION);
241      }
242    
243    
244    
245      // Build the "profile-directory" property definition.
246      static {
247          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "profile-directory");
248          builder.setOption(PropertyOption.MANDATORY);
249          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "profile-directory"));
250          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
251          builder.setPattern(".*", "DIR");
252          PD_PROFILE_DIRECTORY = builder.getInstance();
253          INSTANCE.registerPropertyDefinition(PD_PROFILE_DIRECTORY);
254      }
255    
256    
257    
258      // Build the "profile-sample-interval" property definition.
259      static {
260          DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "profile-sample-interval");
261          builder.setOption(PropertyOption.MANDATORY);
262          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "profile-sample-interval"));
263          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Long>());
264          builder.setBaseUnit("ms");
265          builder.setUpperLimit("2147483647");
266          builder.setLowerLimit("1");
267          PD_PROFILE_SAMPLE_INTERVAL = builder.getInstance();
268          INSTANCE.registerPropertyDefinition(PD_PROFILE_SAMPLE_INTERVAL);
269      }
270    
271    
272    
273      // Register the tags associated with this managed object definition.
274      static {
275        INSTANCE.registerTag(Tag.valueOf("core-server"));
276      }
277    
278    
279    
280      /**
281       * Get the Profiler Plugin configuration definition singleton.
282       *
283       * @return Returns the Profiler Plugin configuration definition
284       *         singleton.
285       */
286      public static ProfilerPluginCfgDefn getInstance() {
287        return INSTANCE;
288      }
289    
290    
291    
292      /**
293       * Private constructor.
294       */
295      private ProfilerPluginCfgDefn() {
296        super("profiler-plugin", PluginCfgDefn.getInstance());
297      }
298    
299    
300    
301      /**
302       * {@inheritDoc}
303       */
304      public ProfilerPluginCfgClient createClientConfiguration(
305          ManagedObject<? extends ProfilerPluginCfgClient> impl) {
306        return new ProfilerPluginCfgClientImpl(impl);
307      }
308    
309    
310    
311      /**
312       * {@inheritDoc}
313       */
314      public ProfilerPluginCfg createServerConfiguration(
315          ServerManagedObject<? extends ProfilerPluginCfg> impl) {
316        return new ProfilerPluginCfgServerImpl(impl);
317      }
318    
319    
320    
321      /**
322       * {@inheritDoc}
323       */
324      public Class<ProfilerPluginCfg> getServerConfigurationClass() {
325        return ProfilerPluginCfg.class;
326      }
327    
328    
329    
330      /**
331       * Get the "enabled" property definition.
332       * <p>
333       * Indicates whether the plug-in is enabled for use.
334       *
335       * @return Returns the "enabled" property definition.
336       */
337      public BooleanPropertyDefinition getEnabledPropertyDefinition() {
338        return PluginCfgDefn.getInstance().getEnabledPropertyDefinition();
339      }
340    
341    
342    
343      /**
344       * Get the "enable-profiling-on-startup" property definition.
345       * <p>
346       * Indicates whether the profiler plug-in is to start collecting
347       * data automatically when the Directory Server is started.
348       * <p>
349       * This property is read only when the server is started, and any
350       * changes take effect on the next restart. This property is
351       * typically set to "false" unless startup profiling is required,
352       * because otherwise the volume of data that can be collected can
353       * cause the server to run out of memory if it is not turned off in a
354       * timely manner.
355       *
356       * @return Returns the "enable-profiling-on-startup" property definition.
357       */
358      public BooleanPropertyDefinition getEnableProfilingOnStartupPropertyDefinition() {
359        return PD_ENABLE_PROFILING_ON_STARTUP;
360      }
361    
362    
363    
364      /**
365       * Get the "invoke-for-internal-operations" property definition.
366       * <p>
367       * Indicates whether the plug-in should be invoked for internal
368       * operations.
369       * <p>
370       * Any plug-in that can be invoked for internal operations must
371       * ensure that it does not create any new internal operatons that can
372       * cause the same plug-in to be re-invoked.
373       *
374       * @return Returns the "invoke-for-internal-operations" property definition.
375       */
376      public BooleanPropertyDefinition getInvokeForInternalOperationsPropertyDefinition() {
377        return PD_INVOKE_FOR_INTERNAL_OPERATIONS;
378      }
379    
380    
381    
382      /**
383       * Get the "java-class" property definition.
384       * <p>
385       * Specifies the fully-qualified name of the Java class that
386       * provides the plug-in implementation.
387       *
388       * @return Returns the "java-class" property definition.
389       */
390      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
391        return PD_JAVA_CLASS;
392      }
393    
394    
395    
396      /**
397       * Get the "plugin-type" property definition.
398       * <p>
399       * Specifies the set of plug-in types for the plug-in, which
400       * specifies the times at which the plug-in is invoked.
401       *
402       * @return Returns the "plugin-type" property definition.
403       */
404      public EnumPropertyDefinition<PluginType> getPluginTypePropertyDefinition() {
405        return PD_PLUGIN_TYPE;
406      }
407    
408    
409    
410      /**
411       * Get the "profile-action" property definition.
412       * <p>
413       * Specifies the action that should be taken by the profiler.
414       * <p>
415       * A value of "start" causes the profiler thread to start collecting
416       * data if it is not already active. A value of "stop" causes the
417       * profiler thread to stop collecting data and write it to disk, and
418       * a value of "cancel" causes the profiler thread to stop collecting
419       * data and discard anything that has been captured. These operations
420       * occur immediately.
421       *
422       * @return Returns the "profile-action" property definition.
423       */
424      public EnumPropertyDefinition<ProfileAction> getProfileActionPropertyDefinition() {
425        return PD_PROFILE_ACTION;
426      }
427    
428    
429    
430      /**
431       * Get the "profile-directory" property definition.
432       * <p>
433       * Specifies the path to the directory where profile information is
434       * to be written. This path may be either an absolute path or a path
435       * that is relative to the root of the OpenDS Directory Server
436       * instance.
437       * <p>
438       * The directory must exist and the Directory Server must have
439       * permission to create new files in it.
440       *
441       * @return Returns the "profile-directory" property definition.
442       */
443      public StringPropertyDefinition getProfileDirectoryPropertyDefinition() {
444        return PD_PROFILE_DIRECTORY;
445      }
446    
447    
448    
449      /**
450       * Get the "profile-sample-interval" property definition.
451       * <p>
452       * Specifies the sample interval in milliseconds to be used when
453       * capturing profiling information in the server.
454       * <p>
455       * When capturing data, the profiler thread sleeps for this length
456       * of time between calls to obtain traces for all threads running in
457       * the JVM.
458       *
459       * @return Returns the "profile-sample-interval" property definition.
460       */
461      public DurationPropertyDefinition getProfileSampleIntervalPropertyDefinition() {
462        return PD_PROFILE_SAMPLE_INTERVAL;
463      }
464    
465    
466    
467      /**
468       * Managed object client implementation.
469       */
470      private static class ProfilerPluginCfgClientImpl implements
471        ProfilerPluginCfgClient {
472    
473        // Private implementation.
474        private ManagedObject<? extends ProfilerPluginCfgClient> impl;
475    
476    
477    
478        // Private constructor.
479        private ProfilerPluginCfgClientImpl(
480            ManagedObject<? extends ProfilerPluginCfgClient> impl) {
481          this.impl = impl;
482        }
483    
484    
485    
486        /**
487         * {@inheritDoc}
488         */
489        public Boolean isEnabled() {
490          return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
491        }
492    
493    
494    
495        /**
496         * {@inheritDoc}
497         */
498        public void setEnabled(boolean value) {
499          impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
500        }
501    
502    
503    
504        /**
505         * {@inheritDoc}
506         */
507        public Boolean isEnableProfilingOnStartup() {
508          return impl.getPropertyValue(INSTANCE.getEnableProfilingOnStartupPropertyDefinition());
509        }
510    
511    
512    
513        /**
514         * {@inheritDoc}
515         */
516        public void setEnableProfilingOnStartup(boolean value) {
517          impl.setPropertyValue(INSTANCE.getEnableProfilingOnStartupPropertyDefinition(), value);
518        }
519    
520    
521    
522        /**
523         * {@inheritDoc}
524         */
525        public boolean isInvokeForInternalOperations() {
526          return impl.getPropertyValue(INSTANCE.getInvokeForInternalOperationsPropertyDefinition());
527        }
528    
529    
530    
531        /**
532         * {@inheritDoc}
533         */
534        public void setInvokeForInternalOperations(Boolean value) {
535          impl.setPropertyValue(INSTANCE.getInvokeForInternalOperationsPropertyDefinition(), value);
536        }
537    
538    
539    
540        /**
541         * {@inheritDoc}
542         */
543        public String getJavaClass() {
544          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
545        }
546    
547    
548    
549        /**
550         * {@inheritDoc}
551         */
552        public void setJavaClass(String value) {
553          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
554        }
555    
556    
557    
558        /**
559         * {@inheritDoc}
560         */
561        public SortedSet<PluginType> getPluginType() {
562          return impl.getPropertyValues(INSTANCE.getPluginTypePropertyDefinition());
563        }
564    
565    
566    
567        /**
568         * {@inheritDoc}
569         */
570        public void setPluginType(Collection<PluginType> values) {
571          impl.setPropertyValues(INSTANCE.getPluginTypePropertyDefinition(), values);
572        }
573    
574    
575    
576        /**
577         * {@inheritDoc}
578         */
579        public ProfileAction getProfileAction() {
580          return impl.getPropertyValue(INSTANCE.getProfileActionPropertyDefinition());
581        }
582    
583    
584    
585        /**
586         * {@inheritDoc}
587         */
588        public void setProfileAction(ProfileAction value) {
589          impl.setPropertyValue(INSTANCE.getProfileActionPropertyDefinition(), value);
590        }
591    
592    
593    
594        /**
595         * {@inheritDoc}
596         */
597        public String getProfileDirectory() {
598          return impl.getPropertyValue(INSTANCE.getProfileDirectoryPropertyDefinition());
599        }
600    
601    
602    
603        /**
604         * {@inheritDoc}
605         */
606        public void setProfileDirectory(String value) {
607          impl.setPropertyValue(INSTANCE.getProfileDirectoryPropertyDefinition(), value);
608        }
609    
610    
611    
612        /**
613         * {@inheritDoc}
614         */
615        public Long getProfileSampleInterval() {
616          return impl.getPropertyValue(INSTANCE.getProfileSampleIntervalPropertyDefinition());
617        }
618    
619    
620    
621        /**
622         * {@inheritDoc}
623         */
624        public void setProfileSampleInterval(long value) {
625          impl.setPropertyValue(INSTANCE.getProfileSampleIntervalPropertyDefinition(), value);
626        }
627    
628    
629    
630        /**
631         * {@inheritDoc}
632         */
633        public ManagedObjectDefinition<? extends ProfilerPluginCfgClient, ? extends ProfilerPluginCfg> definition() {
634          return INSTANCE;
635        }
636    
637    
638    
639        /**
640         * {@inheritDoc}
641         */
642        public PropertyProvider properties() {
643          return impl;
644        }
645    
646    
647    
648        /**
649         * {@inheritDoc}
650         */
651        public void commit() throws ManagedObjectAlreadyExistsException,
652            MissingMandatoryPropertiesException, ConcurrentModificationException,
653            OperationRejectedException, AuthorizationException,
654            CommunicationException {
655          impl.commit();
656        }
657    
658      }
659    
660    
661    
662      /**
663       * Managed object server implementation.
664       */
665      private static class ProfilerPluginCfgServerImpl implements
666        ProfilerPluginCfg {
667    
668        // Private implementation.
669        private ServerManagedObject<? extends ProfilerPluginCfg> impl;
670    
671        // The value of the "enabled" property.
672        private final boolean pEnabled;
673    
674        // The value of the "enable-profiling-on-startup" property.
675        private final boolean pEnableProfilingOnStartup;
676    
677        // The value of the "invoke-for-internal-operations" property.
678        private final boolean pInvokeForInternalOperations;
679    
680        // The value of the "java-class" property.
681        private final String pJavaClass;
682    
683        // The value of the "plugin-type" property.
684        private final SortedSet<PluginType> pPluginType;
685    
686        // The value of the "profile-action" property.
687        private final ProfileAction pProfileAction;
688    
689        // The value of the "profile-directory" property.
690        private final String pProfileDirectory;
691    
692        // The value of the "profile-sample-interval" property.
693        private final long pProfileSampleInterval;
694    
695    
696    
697        // Private constructor.
698        private ProfilerPluginCfgServerImpl(ServerManagedObject<? extends ProfilerPluginCfg> impl) {
699          this.impl = impl;
700          this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
701          this.pEnableProfilingOnStartup = impl.getPropertyValue(INSTANCE.getEnableProfilingOnStartupPropertyDefinition());
702          this.pInvokeForInternalOperations = impl.getPropertyValue(INSTANCE.getInvokeForInternalOperationsPropertyDefinition());
703          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
704          this.pPluginType = impl.getPropertyValues(INSTANCE.getPluginTypePropertyDefinition());
705          this.pProfileAction = impl.getPropertyValue(INSTANCE.getProfileActionPropertyDefinition());
706          this.pProfileDirectory = impl.getPropertyValue(INSTANCE.getProfileDirectoryPropertyDefinition());
707          this.pProfileSampleInterval = impl.getPropertyValue(INSTANCE.getProfileSampleIntervalPropertyDefinition());
708        }
709    
710    
711    
712        /**
713         * {@inheritDoc}
714         */
715        public void addProfilerChangeListener(
716            ConfigurationChangeListener<ProfilerPluginCfg> listener) {
717          impl.registerChangeListener(listener);
718        }
719    
720    
721    
722        /**
723         * {@inheritDoc}
724         */
725        public void removeProfilerChangeListener(
726            ConfigurationChangeListener<ProfilerPluginCfg> listener) {
727          impl.deregisterChangeListener(listener);
728        }
729        /**
730         * {@inheritDoc}
731         */
732        public void addChangeListener(
733            ConfigurationChangeListener<PluginCfg> listener) {
734          impl.registerChangeListener(listener);
735        }
736    
737    
738    
739        /**
740         * {@inheritDoc}
741         */
742        public void removeChangeListener(
743            ConfigurationChangeListener<PluginCfg> listener) {
744          impl.deregisterChangeListener(listener);
745        }
746    
747    
748    
749        /**
750         * {@inheritDoc}
751         */
752        public boolean isEnabled() {
753          return pEnabled;
754        }
755    
756    
757    
758        /**
759         * {@inheritDoc}
760         */
761        public boolean isEnableProfilingOnStartup() {
762          return pEnableProfilingOnStartup;
763        }
764    
765    
766    
767        /**
768         * {@inheritDoc}
769         */
770        public boolean isInvokeForInternalOperations() {
771          return pInvokeForInternalOperations;
772        }
773    
774    
775    
776        /**
777         * {@inheritDoc}
778         */
779        public String getJavaClass() {
780          return pJavaClass;
781        }
782    
783    
784    
785        /**
786         * {@inheritDoc}
787         */
788        public SortedSet<PluginType> getPluginType() {
789          return pPluginType;
790        }
791    
792    
793    
794        /**
795         * {@inheritDoc}
796         */
797        public ProfileAction getProfileAction() {
798          return pProfileAction;
799        }
800    
801    
802    
803        /**
804         * {@inheritDoc}
805         */
806        public String getProfileDirectory() {
807          return pProfileDirectory;
808        }
809    
810    
811    
812        /**
813         * {@inheritDoc}
814         */
815        public long getProfileSampleInterval() {
816          return pProfileSampleInterval;
817        }
818    
819    
820    
821        /**
822         * {@inheritDoc}
823         */
824        public Class<? extends ProfilerPluginCfg> configurationClass() {
825          return ProfilerPluginCfg.class;
826        }
827    
828    
829    
830        /**
831         * {@inheritDoc}
832         */
833        public DN dn() {
834          return impl.getDN();
835        }
836    
837      }
838    }