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}