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