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.AliasDefaultBehaviorProvider; 035 import org.opends.server.admin.BooleanPropertyDefinition; 036 import org.opends.server.admin.ClassPropertyDefinition; 037 import org.opends.server.admin.client.AuthorizationException; 038 import org.opends.server.admin.client.CommunicationException; 039 import org.opends.server.admin.client.ConcurrentModificationException; 040 import org.opends.server.admin.client.IllegalManagedObjectNameException; 041 import org.opends.server.admin.client.ManagedObject; 042 import org.opends.server.admin.client.ManagedObjectDecodingException; 043 import org.opends.server.admin.client.MissingMandatoryPropertiesException; 044 import org.opends.server.admin.client.OperationRejectedException; 045 import org.opends.server.admin.DefaultBehaviorException; 046 import org.opends.server.admin.DefaultBehaviorProvider; 047 import org.opends.server.admin.DefinedDefaultBehaviorProvider; 048 import org.opends.server.admin.DefinitionDecodingException; 049 import org.opends.server.admin.EnumPropertyDefinition; 050 import org.opends.server.admin.InstantiableRelationDefinition; 051 import org.opends.server.admin.IntegerPropertyDefinition; 052 import org.opends.server.admin.ManagedObjectAlreadyExistsException; 053 import org.opends.server.admin.ManagedObjectDefinition; 054 import org.opends.server.admin.ManagedObjectNotFoundException; 055 import org.opends.server.admin.PropertyOption; 056 import org.opends.server.admin.PropertyProvider; 057 import org.opends.server.admin.server.ConfigurationAddListener; 058 import org.opends.server.admin.server.ConfigurationChangeListener; 059 import org.opends.server.admin.server.ConfigurationDeleteListener; 060 import org.opends.server.admin.server.ServerManagedObject; 061 import org.opends.server.admin.std.client.DebugLogPublisherCfgClient; 062 import org.opends.server.admin.std.client.DebugTargetCfgClient; 063 import org.opends.server.admin.std.server.DebugLogPublisherCfg; 064 import org.opends.server.admin.std.server.DebugTargetCfg; 065 import org.opends.server.admin.std.server.LogPublisherCfg; 066 import org.opends.server.admin.Tag; 067 import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 068 import org.opends.server.config.ConfigException; 069 import org.opends.server.types.DN; 070 071 072 073 /** 074 * An interface for querying the Debug Log Publisher managed object 075 * definition meta information. 076 * <p> 077 * Debug Log Publishers are responsible for distributing debug log 078 * messages from the debug logger to a destination. 079 */ 080 public final class DebugLogPublisherCfgDefn extends ManagedObjectDefinition<DebugLogPublisherCfgClient, DebugLogPublisherCfg> { 081 082 // The singleton configuration definition instance. 083 private static final DebugLogPublisherCfgDefn INSTANCE = new DebugLogPublisherCfgDefn(); 084 085 086 087 /** 088 * Defines the set of permissable values for the "default-debug-category" property. 089 * <p> 090 * The debug message categories to be logged when none of the 091 * defined targets match the message. 092 */ 093 public static enum DefaultDebugCategory { 094 095 /** 096 * Exception caught. 097 */ 098 CAUGHT("caught"), 099 100 101 102 /** 103 * Constructor entry. 104 */ 105 CONSTRUCTOR("constructor"), 106 107 108 109 /** 110 * Raw data dump. 111 */ 112 DATA("data"), 113 114 115 116 /** 117 * Access to a backend database. 118 */ 119 DATABASE_ACCESS("database-access"), 120 121 122 123 /** 124 * Method entry. 125 */ 126 ENTER("enter"), 127 128 129 130 /** 131 * Method exit. 132 */ 133 EXIT("exit"), 134 135 136 137 /** 138 * Arbitrary debug message. 139 */ 140 MESSAGE("message"), 141 142 143 144 /** 145 * Protocol element dump. 146 */ 147 PROTOCOL("protocol"), 148 149 150 151 /** 152 * Exception throw from method. 153 */ 154 THROWN("thrown"); 155 156 157 158 // String representation of the value. 159 private final String name; 160 161 162 163 // Private constructor. 164 private DefaultDebugCategory(String name) { this.name = name; } 165 166 167 168 /** 169 * {@inheritDoc} 170 */ 171 public String toString() { return name; } 172 173 } 174 175 176 177 /** 178 * Defines the set of permissable values for the "default-debug-level" property. 179 * <p> 180 * The lowest severity level of debug messages to log when none of 181 * the defined targets match the message. 182 */ 183 public static enum DefaultDebugLevel { 184 185 /** 186 * Messages with any severity level will be logged. 187 */ 188 ALL("all"), 189 190 191 192 /** 193 * No messages will be logged. 194 */ 195 DISABLED("disabled"), 196 197 198 199 /** 200 * Messages with severity level of ERROR or higher will be logged. 201 */ 202 ERROR("error"), 203 204 205 206 /** 207 * Messages with severity level of INFO or higher will be logged. 208 */ 209 INFO("info"), 210 211 212 213 /** 214 * Messages with severity level of VERBOSE or higher will be 215 * logged. 216 */ 217 VERBOSE("verbose"), 218 219 220 221 /** 222 * Messages with severity level of WARNING or higher will be 223 * logged. 224 */ 225 WARNING("warning"); 226 227 228 229 // String representation of the value. 230 private final String name; 231 232 233 234 // Private constructor. 235 private DefaultDebugLevel(String name) { this.name = name; } 236 237 238 239 /** 240 * {@inheritDoc} 241 */ 242 public String toString() { return name; } 243 244 } 245 246 247 248 // The "default-debug-category" property definition. 249 private static final EnumPropertyDefinition<DefaultDebugCategory> PD_DEFAULT_DEBUG_CATEGORY; 250 251 252 253 // The "default-debug-level" property definition. 254 private static final EnumPropertyDefinition<DefaultDebugLevel> PD_DEFAULT_DEBUG_LEVEL; 255 256 257 258 // The "default-include-throwable-cause" property definition. 259 private static final BooleanPropertyDefinition PD_DEFAULT_INCLUDE_THROWABLE_CAUSE; 260 261 262 263 // The "default-omit-method-entry-arguments" property definition. 264 private static final BooleanPropertyDefinition PD_DEFAULT_OMIT_METHOD_ENTRY_ARGUMENTS; 265 266 267 268 // The "default-omit-method-return-value" property definition. 269 private static final BooleanPropertyDefinition PD_DEFAULT_OMIT_METHOD_RETURN_VALUE; 270 271 272 273 // The "default-throwable-stack-frames" property definition. 274 private static final IntegerPropertyDefinition PD_DEFAULT_THROWABLE_STACK_FRAMES; 275 276 277 278 // The "java-class" property definition. 279 private static final ClassPropertyDefinition PD_JAVA_CLASS; 280 281 282 283 // The "debug-targets" relation definition. 284 private static final InstantiableRelationDefinition<DebugTargetCfgClient, DebugTargetCfg> RD_DEBUG_TARGETS; 285 286 287 288 // Build the "default-debug-category" property definition. 289 static { 290 EnumPropertyDefinition.Builder<DefaultDebugCategory> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "default-debug-category"); 291 builder.setOption(PropertyOption.MULTI_VALUED); 292 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-debug-category")); 293 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DefaultDebugCategory>(INSTANCE, "default-debug-category")); 294 builder.setEnumClass(DefaultDebugCategory.class); 295 PD_DEFAULT_DEBUG_CATEGORY = builder.getInstance(); 296 INSTANCE.registerPropertyDefinition(PD_DEFAULT_DEBUG_CATEGORY); 297 } 298 299 300 301 // Build the "default-debug-level" property definition. 302 static { 303 EnumPropertyDefinition.Builder<DefaultDebugLevel> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "default-debug-level"); 304 builder.setOption(PropertyOption.MANDATORY); 305 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-debug-level")); 306 DefaultBehaviorProvider<DefaultDebugLevel> provider = new DefinedDefaultBehaviorProvider<DefaultDebugLevel>("error"); 307 builder.setDefaultBehaviorProvider(provider); 308 builder.setEnumClass(DefaultDebugLevel.class); 309 PD_DEFAULT_DEBUG_LEVEL = builder.getInstance(); 310 INSTANCE.registerPropertyDefinition(PD_DEFAULT_DEBUG_LEVEL); 311 } 312 313 314 315 // Build the "default-include-throwable-cause" property definition. 316 static { 317 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "default-include-throwable-cause"); 318 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-include-throwable-cause")); 319 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 320 builder.setDefaultBehaviorProvider(provider); 321 PD_DEFAULT_INCLUDE_THROWABLE_CAUSE = builder.getInstance(); 322 INSTANCE.registerPropertyDefinition(PD_DEFAULT_INCLUDE_THROWABLE_CAUSE); 323 } 324 325 326 327 // Build the "default-omit-method-entry-arguments" property definition. 328 static { 329 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "default-omit-method-entry-arguments"); 330 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-omit-method-entry-arguments")); 331 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 332 builder.setDefaultBehaviorProvider(provider); 333 PD_DEFAULT_OMIT_METHOD_ENTRY_ARGUMENTS = builder.getInstance(); 334 INSTANCE.registerPropertyDefinition(PD_DEFAULT_OMIT_METHOD_ENTRY_ARGUMENTS); 335 } 336 337 338 339 // Build the "default-omit-method-return-value" property definition. 340 static { 341 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "default-omit-method-return-value"); 342 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-omit-method-return-value")); 343 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 344 builder.setDefaultBehaviorProvider(provider); 345 PD_DEFAULT_OMIT_METHOD_RETURN_VALUE = builder.getInstance(); 346 INSTANCE.registerPropertyDefinition(PD_DEFAULT_OMIT_METHOD_RETURN_VALUE); 347 } 348 349 350 351 // Build the "default-throwable-stack-frames" property definition. 352 static { 353 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "default-throwable-stack-frames"); 354 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-throwable-stack-frames")); 355 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("0"); 356 builder.setDefaultBehaviorProvider(provider); 357 builder.setLowerLimit(0); 358 PD_DEFAULT_THROWABLE_STACK_FRAMES = builder.getInstance(); 359 INSTANCE.registerPropertyDefinition(PD_DEFAULT_THROWABLE_STACK_FRAMES); 360 } 361 362 363 364 // Build the "java-class" property definition. 365 static { 366 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class"); 367 builder.setOption(PropertyOption.MANDATORY); 368 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class")); 369 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 370 builder.addInstanceOf("org.opends.server.api.DebugLogPublisher"); 371 PD_JAVA_CLASS = builder.getInstance(); 372 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 373 } 374 375 376 377 // Build the "debug-targets" relation definition. 378 static { 379 InstantiableRelationDefinition.Builder<DebugTargetCfgClient, DebugTargetCfg> builder = 380 new InstantiableRelationDefinition.Builder<DebugTargetCfgClient, DebugTargetCfg>(INSTANCE, "debug-target", "debug-targets", DebugTargetCfgDefn.getInstance()); 381 builder.setNamingProperty(DebugTargetCfgDefn.getInstance().getDebugScopePropertyDefinition()); 382 RD_DEBUG_TARGETS = builder.getInstance(); 383 INSTANCE.registerRelationDefinition(RD_DEBUG_TARGETS); 384 } 385 386 387 388 // Register the tags associated with this managed object definition. 389 static { 390 INSTANCE.registerTag(Tag.valueOf("logging")); 391 } 392 393 394 395 /** 396 * Get the Debug Log Publisher configuration definition singleton. 397 * 398 * @return Returns the Debug Log Publisher configuration definition 399 * singleton. 400 */ 401 public static DebugLogPublisherCfgDefn getInstance() { 402 return INSTANCE; 403 } 404 405 406 407 /** 408 * Private constructor. 409 */ 410 private DebugLogPublisherCfgDefn() { 411 super("debug-log-publisher", LogPublisherCfgDefn.getInstance()); 412 } 413 414 415 416 /** 417 * {@inheritDoc} 418 */ 419 public DebugLogPublisherCfgClient createClientConfiguration( 420 ManagedObject<? extends DebugLogPublisherCfgClient> impl) { 421 return new DebugLogPublisherCfgClientImpl(impl); 422 } 423 424 425 426 /** 427 * {@inheritDoc} 428 */ 429 public DebugLogPublisherCfg createServerConfiguration( 430 ServerManagedObject<? extends DebugLogPublisherCfg> impl) { 431 return new DebugLogPublisherCfgServerImpl(impl); 432 } 433 434 435 436 /** 437 * {@inheritDoc} 438 */ 439 public Class<DebugLogPublisherCfg> getServerConfigurationClass() { 440 return DebugLogPublisherCfg.class; 441 } 442 443 444 445 /** 446 * Get the "default-debug-category" property definition. 447 * <p> 448 * The debug message categories to be logged when none of the 449 * defined targets match the message. 450 * 451 * @return Returns the "default-debug-category" property definition. 452 */ 453 public EnumPropertyDefinition<DefaultDebugCategory> getDefaultDebugCategoryPropertyDefinition() { 454 return PD_DEFAULT_DEBUG_CATEGORY; 455 } 456 457 458 459 /** 460 * Get the "default-debug-level" property definition. 461 * <p> 462 * The lowest severity level of debug messages to log when none of 463 * the defined targets match the message. 464 * 465 * @return Returns the "default-debug-level" property definition. 466 */ 467 public EnumPropertyDefinition<DefaultDebugLevel> getDefaultDebugLevelPropertyDefinition() { 468 return PD_DEFAULT_DEBUG_LEVEL; 469 } 470 471 472 473 /** 474 * Get the "default-include-throwable-cause" property definition. 475 * <p> 476 * Indicates whether to include the cause of exceptions in exception 477 * thrown and caught messages logged by default. 478 * 479 * @return Returns the "default-include-throwable-cause" property definition. 480 */ 481 public BooleanPropertyDefinition getDefaultIncludeThrowableCausePropertyDefinition() { 482 return PD_DEFAULT_INCLUDE_THROWABLE_CAUSE; 483 } 484 485 486 487 /** 488 * Get the "default-omit-method-entry-arguments" property definition. 489 * <p> 490 * Indicates whether to include method arguments in debug messages 491 * logged by default. 492 * 493 * @return Returns the "default-omit-method-entry-arguments" property definition. 494 */ 495 public BooleanPropertyDefinition getDefaultOmitMethodEntryArgumentsPropertyDefinition() { 496 return PD_DEFAULT_OMIT_METHOD_ENTRY_ARGUMENTS; 497 } 498 499 500 501 /** 502 * Get the "default-omit-method-return-value" property definition. 503 * <p> 504 * Indicates whether to include the return value in debug messages 505 * logged by default. 506 * 507 * @return Returns the "default-omit-method-return-value" property definition. 508 */ 509 public BooleanPropertyDefinition getDefaultOmitMethodReturnValuePropertyDefinition() { 510 return PD_DEFAULT_OMIT_METHOD_RETURN_VALUE; 511 } 512 513 514 515 /** 516 * Get the "default-throwable-stack-frames" property definition. 517 * <p> 518 * Indicates the number of stack frames to include in the stack 519 * trace for method entry and exception thrown messages. 520 * 521 * @return Returns the "default-throwable-stack-frames" property definition. 522 */ 523 public IntegerPropertyDefinition getDefaultThrowableStackFramesPropertyDefinition() { 524 return PD_DEFAULT_THROWABLE_STACK_FRAMES; 525 } 526 527 528 529 /** 530 * Get the "enabled" property definition. 531 * <p> 532 * Indicates whether the Debug Log Publisher is enabled for use. 533 * 534 * @return Returns the "enabled" property definition. 535 */ 536 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 537 return LogPublisherCfgDefn.getInstance().getEnabledPropertyDefinition(); 538 } 539 540 541 542 /** 543 * Get the "java-class" property definition. 544 * <p> 545 * The fully-qualified name of the Java class that provides the 546 * Debug Log Publisher implementation. 547 * 548 * @return Returns the "java-class" property definition. 549 */ 550 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 551 return PD_JAVA_CLASS; 552 } 553 554 555 556 /** 557 * Get the "debug-targets" relation definition. 558 * 559 * @return Returns the "debug-targets" relation definition. 560 */ 561 public InstantiableRelationDefinition<DebugTargetCfgClient,DebugTargetCfg> getDebugTargetsRelationDefinition() { 562 return RD_DEBUG_TARGETS; 563 } 564 565 566 567 /** 568 * Managed object client implementation. 569 */ 570 private static class DebugLogPublisherCfgClientImpl implements 571 DebugLogPublisherCfgClient { 572 573 // Private implementation. 574 private ManagedObject<? extends DebugLogPublisherCfgClient> impl; 575 576 577 578 // Private constructor. 579 private DebugLogPublisherCfgClientImpl( 580 ManagedObject<? extends DebugLogPublisherCfgClient> impl) { 581 this.impl = impl; 582 } 583 584 585 586 /** 587 * {@inheritDoc} 588 */ 589 public SortedSet<DefaultDebugCategory> getDefaultDebugCategory() { 590 return impl.getPropertyValues(INSTANCE.getDefaultDebugCategoryPropertyDefinition()); 591 } 592 593 594 595 /** 596 * {@inheritDoc} 597 */ 598 public void setDefaultDebugCategory(Collection<DefaultDebugCategory> values) { 599 impl.setPropertyValues(INSTANCE.getDefaultDebugCategoryPropertyDefinition(), values); 600 } 601 602 603 604 /** 605 * {@inheritDoc} 606 */ 607 public DefaultDebugLevel getDefaultDebugLevel() { 608 return impl.getPropertyValue(INSTANCE.getDefaultDebugLevelPropertyDefinition()); 609 } 610 611 612 613 /** 614 * {@inheritDoc} 615 */ 616 public void setDefaultDebugLevel(DefaultDebugLevel value) { 617 impl.setPropertyValue(INSTANCE.getDefaultDebugLevelPropertyDefinition(), value); 618 } 619 620 621 622 /** 623 * {@inheritDoc} 624 */ 625 public boolean isDefaultIncludeThrowableCause() { 626 return impl.getPropertyValue(INSTANCE.getDefaultIncludeThrowableCausePropertyDefinition()); 627 } 628 629 630 631 /** 632 * {@inheritDoc} 633 */ 634 public void setDefaultIncludeThrowableCause(Boolean value) { 635 impl.setPropertyValue(INSTANCE.getDefaultIncludeThrowableCausePropertyDefinition(), value); 636 } 637 638 639 640 /** 641 * {@inheritDoc} 642 */ 643 public boolean isDefaultOmitMethodEntryArguments() { 644 return impl.getPropertyValue(INSTANCE.getDefaultOmitMethodEntryArgumentsPropertyDefinition()); 645 } 646 647 648 649 /** 650 * {@inheritDoc} 651 */ 652 public void setDefaultOmitMethodEntryArguments(Boolean value) { 653 impl.setPropertyValue(INSTANCE.getDefaultOmitMethodEntryArgumentsPropertyDefinition(), value); 654 } 655 656 657 658 /** 659 * {@inheritDoc} 660 */ 661 public boolean isDefaultOmitMethodReturnValue() { 662 return impl.getPropertyValue(INSTANCE.getDefaultOmitMethodReturnValuePropertyDefinition()); 663 } 664 665 666 667 /** 668 * {@inheritDoc} 669 */ 670 public void setDefaultOmitMethodReturnValue(Boolean value) { 671 impl.setPropertyValue(INSTANCE.getDefaultOmitMethodReturnValuePropertyDefinition(), value); 672 } 673 674 675 676 /** 677 * {@inheritDoc} 678 */ 679 public int getDefaultThrowableStackFrames() { 680 return impl.getPropertyValue(INSTANCE.getDefaultThrowableStackFramesPropertyDefinition()); 681 } 682 683 684 685 /** 686 * {@inheritDoc} 687 */ 688 public void setDefaultThrowableStackFrames(Integer value) { 689 impl.setPropertyValue(INSTANCE.getDefaultThrowableStackFramesPropertyDefinition(), value); 690 } 691 692 693 694 /** 695 * {@inheritDoc} 696 */ 697 public Boolean isEnabled() { 698 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 699 } 700 701 702 703 /** 704 * {@inheritDoc} 705 */ 706 public void setEnabled(boolean value) { 707 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 708 } 709 710 711 712 /** 713 * {@inheritDoc} 714 */ 715 public String getJavaClass() { 716 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 717 } 718 719 720 721 /** 722 * {@inheritDoc} 723 */ 724 public void setJavaClass(String value) { 725 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 726 } 727 728 729 730 /** 731 * {@inheritDoc} 732 */ 733 public String[] listDebugTargets() throws ConcurrentModificationException, 734 AuthorizationException, CommunicationException { 735 return impl.listChildren(INSTANCE.getDebugTargetsRelationDefinition()); 736 } 737 738 739 740 /** 741 * {@inheritDoc} 742 */ 743 public DebugTargetCfgClient getDebugTarget(String name) 744 throws DefinitionDecodingException, ManagedObjectDecodingException, 745 ManagedObjectNotFoundException, ConcurrentModificationException, 746 AuthorizationException, CommunicationException { 747 return impl.getChild(INSTANCE.getDebugTargetsRelationDefinition(), name).getConfiguration(); 748 } 749 750 751 752 /** 753 * {@inheritDoc} 754 */ 755 public <M extends DebugTargetCfgClient> M createDebugTarget( 756 ManagedObjectDefinition<M, ? extends DebugTargetCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException { 757 return impl.createChild(INSTANCE.getDebugTargetsRelationDefinition(), d, name, exceptions).getConfiguration(); 758 } 759 760 761 762 /** 763 * {@inheritDoc} 764 */ 765 public void removeDebugTarget(String name) 766 throws ManagedObjectNotFoundException, ConcurrentModificationException, 767 OperationRejectedException, AuthorizationException, CommunicationException { 768 impl.removeChild(INSTANCE.getDebugTargetsRelationDefinition(), name); 769 } 770 771 772 773 /** 774 * {@inheritDoc} 775 */ 776 public ManagedObjectDefinition<? extends DebugLogPublisherCfgClient, ? extends DebugLogPublisherCfg> definition() { 777 return INSTANCE; 778 } 779 780 781 782 /** 783 * {@inheritDoc} 784 */ 785 public PropertyProvider properties() { 786 return impl; 787 } 788 789 790 791 /** 792 * {@inheritDoc} 793 */ 794 public void commit() throws ManagedObjectAlreadyExistsException, 795 MissingMandatoryPropertiesException, ConcurrentModificationException, 796 OperationRejectedException, AuthorizationException, 797 CommunicationException { 798 impl.commit(); 799 } 800 801 } 802 803 804 805 /** 806 * Managed object server implementation. 807 */ 808 private static class DebugLogPublisherCfgServerImpl implements 809 DebugLogPublisherCfg { 810 811 // Private implementation. 812 private ServerManagedObject<? extends DebugLogPublisherCfg> impl; 813 814 // The value of the "default-debug-category" property. 815 private final SortedSet<DefaultDebugCategory> pDefaultDebugCategory; 816 817 // The value of the "default-debug-level" property. 818 private final DefaultDebugLevel pDefaultDebugLevel; 819 820 // The value of the "default-include-throwable-cause" property. 821 private final boolean pDefaultIncludeThrowableCause; 822 823 // The value of the "default-omit-method-entry-arguments" property. 824 private final boolean pDefaultOmitMethodEntryArguments; 825 826 // The value of the "default-omit-method-return-value" property. 827 private final boolean pDefaultOmitMethodReturnValue; 828 829 // The value of the "default-throwable-stack-frames" property. 830 private final int pDefaultThrowableStackFrames; 831 832 // The value of the "enabled" property. 833 private final boolean pEnabled; 834 835 // The value of the "java-class" property. 836 private final String pJavaClass; 837 838 839 840 // Private constructor. 841 private DebugLogPublisherCfgServerImpl(ServerManagedObject<? extends DebugLogPublisherCfg> impl) { 842 this.impl = impl; 843 this.pDefaultDebugCategory = impl.getPropertyValues(INSTANCE.getDefaultDebugCategoryPropertyDefinition()); 844 this.pDefaultDebugLevel = impl.getPropertyValue(INSTANCE.getDefaultDebugLevelPropertyDefinition()); 845 this.pDefaultIncludeThrowableCause = impl.getPropertyValue(INSTANCE.getDefaultIncludeThrowableCausePropertyDefinition()); 846 this.pDefaultOmitMethodEntryArguments = impl.getPropertyValue(INSTANCE.getDefaultOmitMethodEntryArgumentsPropertyDefinition()); 847 this.pDefaultOmitMethodReturnValue = impl.getPropertyValue(INSTANCE.getDefaultOmitMethodReturnValuePropertyDefinition()); 848 this.pDefaultThrowableStackFrames = impl.getPropertyValue(INSTANCE.getDefaultThrowableStackFramesPropertyDefinition()); 849 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 850 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 851 } 852 853 854 855 /** 856 * {@inheritDoc} 857 */ 858 public void addDebugChangeListener( 859 ConfigurationChangeListener<DebugLogPublisherCfg> listener) { 860 impl.registerChangeListener(listener); 861 } 862 863 864 865 /** 866 * {@inheritDoc} 867 */ 868 public void removeDebugChangeListener( 869 ConfigurationChangeListener<DebugLogPublisherCfg> listener) { 870 impl.deregisterChangeListener(listener); 871 } 872 /** 873 * {@inheritDoc} 874 */ 875 public void addChangeListener( 876 ConfigurationChangeListener<LogPublisherCfg> listener) { 877 impl.registerChangeListener(listener); 878 } 879 880 881 882 /** 883 * {@inheritDoc} 884 */ 885 public void removeChangeListener( 886 ConfigurationChangeListener<LogPublisherCfg> listener) { 887 impl.deregisterChangeListener(listener); 888 } 889 890 891 892 /** 893 * {@inheritDoc} 894 */ 895 public SortedSet<DefaultDebugCategory> getDefaultDebugCategory() { 896 return pDefaultDebugCategory; 897 } 898 899 900 901 /** 902 * {@inheritDoc} 903 */ 904 public DefaultDebugLevel getDefaultDebugLevel() { 905 return pDefaultDebugLevel; 906 } 907 908 909 910 /** 911 * {@inheritDoc} 912 */ 913 public boolean isDefaultIncludeThrowableCause() { 914 return pDefaultIncludeThrowableCause; 915 } 916 917 918 919 /** 920 * {@inheritDoc} 921 */ 922 public boolean isDefaultOmitMethodEntryArguments() { 923 return pDefaultOmitMethodEntryArguments; 924 } 925 926 927 928 /** 929 * {@inheritDoc} 930 */ 931 public boolean isDefaultOmitMethodReturnValue() { 932 return pDefaultOmitMethodReturnValue; 933 } 934 935 936 937 /** 938 * {@inheritDoc} 939 */ 940 public int getDefaultThrowableStackFrames() { 941 return pDefaultThrowableStackFrames; 942 } 943 944 945 946 /** 947 * {@inheritDoc} 948 */ 949 public boolean isEnabled() { 950 return pEnabled; 951 } 952 953 954 955 /** 956 * {@inheritDoc} 957 */ 958 public String getJavaClass() { 959 return pJavaClass; 960 } 961 962 963 964 /** 965 * {@inheritDoc} 966 */ 967 public String[] listDebugTargets() { 968 return impl.listChildren(INSTANCE.getDebugTargetsRelationDefinition()); 969 } 970 971 972 973 /** 974 * {@inheritDoc} 975 */ 976 public DebugTargetCfg getDebugTarget(String name) throws ConfigException { 977 return impl.getChild(INSTANCE.getDebugTargetsRelationDefinition(), name).getConfiguration(); 978 } 979 980 981 982 /** 983 * {@inheritDoc} 984 */ 985 public void addDebugTargetAddListener( 986 ConfigurationAddListener<DebugTargetCfg> listener) throws ConfigException { 987 impl.registerAddListener(INSTANCE.getDebugTargetsRelationDefinition(), listener); 988 } 989 990 991 992 /** 993 * {@inheritDoc} 994 */ 995 public void removeDebugTargetAddListener( 996 ConfigurationAddListener<DebugTargetCfg> listener) { 997 impl.deregisterAddListener(INSTANCE.getDebugTargetsRelationDefinition(), listener); 998 } 999 1000 1001 1002 /** 1003 * {@inheritDoc} 1004 */ 1005 public void addDebugTargetDeleteListener( 1006 ConfigurationDeleteListener<DebugTargetCfg> listener) throws ConfigException { 1007 impl.registerDeleteListener(INSTANCE.getDebugTargetsRelationDefinition(), listener); 1008 } 1009 1010 1011 1012 /** 1013 * {@inheritDoc} 1014 */ 1015 public void removeDebugTargetDeleteListener( 1016 ConfigurationDeleteListener<DebugTargetCfg> listener) { 1017 impl.deregisterDeleteListener(INSTANCE.getDebugTargetsRelationDefinition(), listener); 1018 } 1019 1020 1021 1022 /** 1023 * {@inheritDoc} 1024 */ 1025 public Class<? extends DebugLogPublisherCfg> configurationClass() { 1026 return DebugLogPublisherCfg.class; 1027 } 1028 1029 1030 1031 /** 1032 * {@inheritDoc} 1033 */ 1034 public DN dn() { 1035 return impl.getDN(); 1036 } 1037 1038 } 1039 }