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 }