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 }