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 java.util.TreeSet;
034 import org.opends.server.admin.AdministratorAction;
035 import org.opends.server.admin.AggregationPropertyDefinition;
036 import org.opends.server.admin.AliasDefaultBehaviorProvider;
037 import org.opends.server.admin.BooleanPropertyDefinition;
038 import org.opends.server.admin.ClassPropertyDefinition;
039 import org.opends.server.admin.client.AuthorizationException;
040 import org.opends.server.admin.client.CommunicationException;
041 import org.opends.server.admin.client.ConcurrentModificationException;
042 import org.opends.server.admin.client.IllegalManagedObjectNameException;
043 import org.opends.server.admin.client.ManagedObject;
044 import org.opends.server.admin.client.ManagedObjectDecodingException;
045 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
046 import org.opends.server.admin.client.OperationRejectedException;
047 import org.opends.server.admin.DefaultBehaviorException;
048 import org.opends.server.admin.DefaultBehaviorProvider;
049 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
050 import org.opends.server.admin.DefinitionDecodingException;
051 import org.opends.server.admin.DurationPropertyDefinition;
052 import org.opends.server.admin.EnumPropertyDefinition;
053 import org.opends.server.admin.InstantiableRelationDefinition;
054 import org.opends.server.admin.IntegerPropertyDefinition;
055 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
056 import org.opends.server.admin.ManagedObjectDefinition;
057 import org.opends.server.admin.ManagedObjectNotFoundException;
058 import org.opends.server.admin.PropertyOption;
059 import org.opends.server.admin.PropertyProvider;
060 import org.opends.server.admin.server.ConfigurationAddListener;
061 import org.opends.server.admin.server.ConfigurationChangeListener;
062 import org.opends.server.admin.server.ConfigurationDeleteListener;
063 import org.opends.server.admin.server.ServerManagedObject;
064 import org.opends.server.admin.SizePropertyDefinition;
065 import org.opends.server.admin.std.client.DebugTargetCfgClient;
066 import org.opends.server.admin.std.client.FileBasedDebugLogPublisherCfgClient;
067 import org.opends.server.admin.std.client.LogRetentionPolicyCfgClient;
068 import org.opends.server.admin.std.client.LogRotationPolicyCfgClient;
069 import org.opends.server.admin.std.meta.DebugLogPublisherCfgDefn.DefaultDebugCategory;
070 import org.opends.server.admin.std.meta.DebugLogPublisherCfgDefn.DefaultDebugLevel;
071 import org.opends.server.admin.std.server.DebugLogPublisherCfg;
072 import org.opends.server.admin.std.server.DebugTargetCfg;
073 import org.opends.server.admin.std.server.FileBasedDebugLogPublisherCfg;
074 import org.opends.server.admin.std.server.LogPublisherCfg;
075 import org.opends.server.admin.std.server.LogRetentionPolicyCfg;
076 import org.opends.server.admin.std.server.LogRotationPolicyCfg;
077 import org.opends.server.admin.StringPropertyDefinition;
078 import org.opends.server.admin.Tag;
079 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
080 import org.opends.server.config.ConfigException;
081 import org.opends.server.types.DN;
082
083
084
085 /**
086 * An interface for querying the File Based Debug Log Publisher
087 * managed object definition meta information.
088 * <p>
089 * File Based Debug Log Publishers publish debug messages to the file
090 * system.
091 */
092 public final class FileBasedDebugLogPublisherCfgDefn extends ManagedObjectDefinition<FileBasedDebugLogPublisherCfgClient, FileBasedDebugLogPublisherCfg> {
093
094 // The singleton configuration definition instance.
095 private static final FileBasedDebugLogPublisherCfgDefn INSTANCE = new FileBasedDebugLogPublisherCfgDefn();
096
097
098
099 // The "append" property definition.
100 private static final BooleanPropertyDefinition PD_APPEND;
101
102
103
104 // The "asynchronous" property definition.
105 private static final BooleanPropertyDefinition PD_ASYNCHRONOUS;
106
107
108
109 // The "auto-flush" property definition.
110 private static final BooleanPropertyDefinition PD_AUTO_FLUSH;
111
112
113
114 // The "buffer-size" property definition.
115 private static final SizePropertyDefinition PD_BUFFER_SIZE;
116
117
118
119 // The "java-class" property definition.
120 private static final ClassPropertyDefinition PD_JAVA_CLASS;
121
122
123
124 // The "log-file" property definition.
125 private static final StringPropertyDefinition PD_LOG_FILE;
126
127
128
129 // The "log-file-permissions" property definition.
130 private static final StringPropertyDefinition PD_LOG_FILE_PERMISSIONS;
131
132
133
134 // The "queue-size" property definition.
135 private static final IntegerPropertyDefinition PD_QUEUE_SIZE;
136
137
138
139 // The "retention-policy" property definition.
140 private static final AggregationPropertyDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> PD_RETENTION_POLICY;
141
142
143
144 // The "rotation-policy" property definition.
145 private static final AggregationPropertyDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> PD_ROTATION_POLICY;
146
147
148
149 // The "time-interval" property definition.
150 private static final DurationPropertyDefinition PD_TIME_INTERVAL;
151
152
153
154 // Build the "append" property definition.
155 static {
156 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "append");
157 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "append"));
158 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
159 builder.setDefaultBehaviorProvider(provider);
160 PD_APPEND = builder.getInstance();
161 INSTANCE.registerPropertyDefinition(PD_APPEND);
162 }
163
164
165
166 // Build the "asynchronous" property definition.
167 static {
168 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "asynchronous");
169 builder.setOption(PropertyOption.MANDATORY);
170 builder.setOption(PropertyOption.ADVANCED);
171 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "asynchronous"));
172 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
173 builder.setDefaultBehaviorProvider(provider);
174 PD_ASYNCHRONOUS = builder.getInstance();
175 INSTANCE.registerPropertyDefinition(PD_ASYNCHRONOUS);
176 }
177
178
179
180 // Build the "auto-flush" property definition.
181 static {
182 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "auto-flush");
183 builder.setOption(PropertyOption.ADVANCED);
184 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "auto-flush"));
185 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
186 builder.setDefaultBehaviorProvider(provider);
187 PD_AUTO_FLUSH = builder.getInstance();
188 INSTANCE.registerPropertyDefinition(PD_AUTO_FLUSH);
189 }
190
191
192
193 // Build the "buffer-size" property definition.
194 static {
195 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "buffer-size");
196 builder.setOption(PropertyOption.ADVANCED);
197 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "buffer-size"));
198 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("64kb");
199 builder.setDefaultBehaviorProvider(provider);
200 builder.setLowerLimit("1");
201 PD_BUFFER_SIZE = builder.getInstance();
202 INSTANCE.registerPropertyDefinition(PD_BUFFER_SIZE);
203 }
204
205
206
207 // Build the "java-class" property definition.
208 static {
209 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
210 builder.setOption(PropertyOption.MANDATORY);
211 builder.setOption(PropertyOption.ADVANCED);
212 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
213 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.loggers.debug.TextDebugLogPublisher");
214 builder.setDefaultBehaviorProvider(provider);
215 builder.addInstanceOf("org.opends.server.api.DebugLogPublisher");
216 PD_JAVA_CLASS = builder.getInstance();
217 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
218 }
219
220
221
222 // Build the "log-file" property definition.
223 static {
224 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-file");
225 builder.setOption(PropertyOption.MANDATORY);
226 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "log-file"));
227 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
228 PD_LOG_FILE = builder.getInstance();
229 INSTANCE.registerPropertyDefinition(PD_LOG_FILE);
230 }
231
232
233
234 // Build the "log-file-permissions" property definition.
235 static {
236 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-file-permissions");
237 builder.setOption(PropertyOption.MANDATORY);
238 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-file-permissions"));
239 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("640");
240 builder.setDefaultBehaviorProvider(provider);
241 builder.setPattern("^([0-7][0-7][0-7])$", "MODE");
242 PD_LOG_FILE_PERMISSIONS = builder.getInstance();
243 INSTANCE.registerPropertyDefinition(PD_LOG_FILE_PERMISSIONS);
244 }
245
246
247
248 // Build the "queue-size" property definition.
249 static {
250 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "queue-size");
251 builder.setOption(PropertyOption.ADVANCED);
252 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "queue-size"));
253 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("5000");
254 builder.setDefaultBehaviorProvider(provider);
255 builder.setLowerLimit(1);
256 PD_QUEUE_SIZE = builder.getInstance();
257 INSTANCE.registerPropertyDefinition(PD_QUEUE_SIZE);
258 }
259
260
261
262 // Build the "retention-policy" property definition.
263 static {
264 AggregationPropertyDefinition.Builder<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "retention-policy");
265 builder.setOption(PropertyOption.MULTI_VALUED);
266 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "retention-policy"));
267 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "retention-policy"));
268 builder.setParentPath("/");
269 builder.setRelationDefinition("log-retention-policy");
270 PD_RETENTION_POLICY = builder.getInstance();
271 INSTANCE.registerPropertyDefinition(PD_RETENTION_POLICY);
272 INSTANCE.registerConstraint(PD_RETENTION_POLICY.getSourceConstraint());
273 }
274
275
276
277 // Build the "rotation-policy" property definition.
278 static {
279 AggregationPropertyDefinition.Builder<LogRotationPolicyCfgClient, LogRotationPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "rotation-policy");
280 builder.setOption(PropertyOption.MULTI_VALUED);
281 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "rotation-policy"));
282 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "rotation-policy"));
283 builder.setParentPath("/");
284 builder.setRelationDefinition("log-rotation-policy");
285 PD_ROTATION_POLICY = builder.getInstance();
286 INSTANCE.registerPropertyDefinition(PD_ROTATION_POLICY);
287 INSTANCE.registerConstraint(PD_ROTATION_POLICY.getSourceConstraint());
288 }
289
290
291
292 // Build the "time-interval" property definition.
293 static {
294 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "time-interval");
295 builder.setOption(PropertyOption.ADVANCED);
296 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "time-interval"));
297 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("5s");
298 builder.setDefaultBehaviorProvider(provider);
299 builder.setBaseUnit("ms");
300 builder.setLowerLimit("1");
301 PD_TIME_INTERVAL = builder.getInstance();
302 INSTANCE.registerPropertyDefinition(PD_TIME_INTERVAL);
303 }
304
305
306
307 // Register the tags associated with this managed object definition.
308 static {
309 INSTANCE.registerTag(Tag.valueOf("logging"));
310 }
311
312
313
314 /**
315 * Get the File Based Debug Log Publisher configuration definition
316 * singleton.
317 *
318 * @return Returns the File Based Debug Log Publisher configuration
319 * definition singleton.
320 */
321 public static FileBasedDebugLogPublisherCfgDefn getInstance() {
322 return INSTANCE;
323 }
324
325
326
327 /**
328 * Private constructor.
329 */
330 private FileBasedDebugLogPublisherCfgDefn() {
331 super("file-based-debug-log-publisher", DebugLogPublisherCfgDefn.getInstance());
332 }
333
334
335
336 /**
337 * {@inheritDoc}
338 */
339 public FileBasedDebugLogPublisherCfgClient createClientConfiguration(
340 ManagedObject<? extends FileBasedDebugLogPublisherCfgClient> impl) {
341 return new FileBasedDebugLogPublisherCfgClientImpl(impl);
342 }
343
344
345
346 /**
347 * {@inheritDoc}
348 */
349 public FileBasedDebugLogPublisherCfg createServerConfiguration(
350 ServerManagedObject<? extends FileBasedDebugLogPublisherCfg> impl) {
351 return new FileBasedDebugLogPublisherCfgServerImpl(impl);
352 }
353
354
355
356 /**
357 * {@inheritDoc}
358 */
359 public Class<FileBasedDebugLogPublisherCfg> getServerConfigurationClass() {
360 return FileBasedDebugLogPublisherCfg.class;
361 }
362
363
364
365 /**
366 * Get the "append" property definition.
367 * <p>
368 * Specifies whether to append to existing log files.
369 *
370 * @return Returns the "append" property definition.
371 */
372 public BooleanPropertyDefinition getAppendPropertyDefinition() {
373 return PD_APPEND;
374 }
375
376
377
378 /**
379 * Get the "asynchronous" property definition.
380 * <p>
381 * Indicates whether the File Based Debug Log Publisher will publish
382 * records asynchronously.
383 *
384 * @return Returns the "asynchronous" property definition.
385 */
386 public BooleanPropertyDefinition getAsynchronousPropertyDefinition() {
387 return PD_ASYNCHRONOUS;
388 }
389
390
391
392 /**
393 * Get the "auto-flush" property definition.
394 * <p>
395 * Specifies whether to flush the writer after every log record.
396 * <p>
397 * If the asynchronous writes option is used, the writer is flushed
398 * after all the log records in the queue are written.
399 *
400 * @return Returns the "auto-flush" property definition.
401 */
402 public BooleanPropertyDefinition getAutoFlushPropertyDefinition() {
403 return PD_AUTO_FLUSH;
404 }
405
406
407
408 /**
409 * Get the "buffer-size" property definition.
410 * <p>
411 * Specifies the log file buffer size.
412 *
413 * @return Returns the "buffer-size" property definition.
414 */
415 public SizePropertyDefinition getBufferSizePropertyDefinition() {
416 return PD_BUFFER_SIZE;
417 }
418
419
420
421 /**
422 * Get the "default-debug-category" property definition.
423 * <p>
424 * The debug message categories to be logged when none of the
425 * defined targets match the message.
426 *
427 * @return Returns the "default-debug-category" property definition.
428 */
429 public EnumPropertyDefinition<DefaultDebugCategory> getDefaultDebugCategoryPropertyDefinition() {
430 return DebugLogPublisherCfgDefn.getInstance().getDefaultDebugCategoryPropertyDefinition();
431 }
432
433
434
435 /**
436 * Get the "default-debug-level" property definition.
437 * <p>
438 * The lowest severity level of debug messages to log when none of
439 * the defined targets match the message.
440 *
441 * @return Returns the "default-debug-level" property definition.
442 */
443 public EnumPropertyDefinition<DefaultDebugLevel> getDefaultDebugLevelPropertyDefinition() {
444 return DebugLogPublisherCfgDefn.getInstance().getDefaultDebugLevelPropertyDefinition();
445 }
446
447
448
449 /**
450 * Get the "default-include-throwable-cause" property definition.
451 * <p>
452 * Indicates whether to include the cause of exceptions in exception
453 * thrown and caught messages logged by default.
454 *
455 * @return Returns the "default-include-throwable-cause" property definition.
456 */
457 public BooleanPropertyDefinition getDefaultIncludeThrowableCausePropertyDefinition() {
458 return DebugLogPublisherCfgDefn.getInstance().getDefaultIncludeThrowableCausePropertyDefinition();
459 }
460
461
462
463 /**
464 * Get the "default-omit-method-entry-arguments" property definition.
465 * <p>
466 * Indicates whether to include method arguments in debug messages
467 * logged by default.
468 *
469 * @return Returns the "default-omit-method-entry-arguments" property definition.
470 */
471 public BooleanPropertyDefinition getDefaultOmitMethodEntryArgumentsPropertyDefinition() {
472 return DebugLogPublisherCfgDefn.getInstance().getDefaultOmitMethodEntryArgumentsPropertyDefinition();
473 }
474
475
476
477 /**
478 * Get the "default-omit-method-return-value" property definition.
479 * <p>
480 * Indicates whether to include the return value in debug messages
481 * logged by default.
482 *
483 * @return Returns the "default-omit-method-return-value" property definition.
484 */
485 public BooleanPropertyDefinition getDefaultOmitMethodReturnValuePropertyDefinition() {
486 return DebugLogPublisherCfgDefn.getInstance().getDefaultOmitMethodReturnValuePropertyDefinition();
487 }
488
489
490
491 /**
492 * Get the "default-throwable-stack-frames" property definition.
493 * <p>
494 * Indicates the number of stack frames to include in the stack
495 * trace for method entry and exception thrown messages.
496 *
497 * @return Returns the "default-throwable-stack-frames" property definition.
498 */
499 public IntegerPropertyDefinition getDefaultThrowableStackFramesPropertyDefinition() {
500 return DebugLogPublisherCfgDefn.getInstance().getDefaultThrowableStackFramesPropertyDefinition();
501 }
502
503
504
505 /**
506 * Get the "enabled" property definition.
507 * <p>
508 * Indicates whether the File Based Debug Log Publisher is enabled
509 * for use.
510 *
511 * @return Returns the "enabled" property definition.
512 */
513 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
514 return DebugLogPublisherCfgDefn.getInstance().getEnabledPropertyDefinition();
515 }
516
517
518
519 /**
520 * Get the "java-class" property definition.
521 * <p>
522 * The fully-qualified name of the Java class that provides the File
523 * Based Debug Log Publisher implementation.
524 *
525 * @return Returns the "java-class" property definition.
526 */
527 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
528 return PD_JAVA_CLASS;
529 }
530
531
532
533 /**
534 * Get the "log-file" property definition.
535 * <p>
536 * The file name to use for the log files generated by the File
537 * Based Debug Log Publisher .
538 * <p>
539 * The path to the file is relative to the server root.
540 *
541 * @return Returns the "log-file" property definition.
542 */
543 public StringPropertyDefinition getLogFilePropertyDefinition() {
544 return PD_LOG_FILE;
545 }
546
547
548
549 /**
550 * Get the "log-file-permissions" property definition.
551 * <p>
552 * The UNIX permissions of the log files created by this File Based
553 * Debug Log Publisher .
554 *
555 * @return Returns the "log-file-permissions" property definition.
556 */
557 public StringPropertyDefinition getLogFilePermissionsPropertyDefinition() {
558 return PD_LOG_FILE_PERMISSIONS;
559 }
560
561
562
563 /**
564 * Get the "queue-size" property definition.
565 * <p>
566 * The maximum number of log records that can be stored in the
567 * asynchronous queue.
568 *
569 * @return Returns the "queue-size" property definition.
570 */
571 public IntegerPropertyDefinition getQueueSizePropertyDefinition() {
572 return PD_QUEUE_SIZE;
573 }
574
575
576
577 /**
578 * Get the "retention-policy" property definition.
579 * <p>
580 * The retention policy to use for the File Based Debug Log
581 * Publisher .
582 * <p>
583 * When multiple policies are used, log files are cleaned when any
584 * of the policy's conditions are met.
585 *
586 * @return Returns the "retention-policy" property definition.
587 */
588 public AggregationPropertyDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> getRetentionPolicyPropertyDefinition() {
589 return PD_RETENTION_POLICY;
590 }
591
592
593
594 /**
595 * Get the "rotation-policy" property definition.
596 * <p>
597 * The rotation policy to use for the File Based Debug Log Publisher
598 * .
599 * <p>
600 * When multiple policies are used, rotation will occur if any
601 * policy's conditions are met.
602 *
603 * @return Returns the "rotation-policy" property definition.
604 */
605 public AggregationPropertyDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> getRotationPolicyPropertyDefinition() {
606 return PD_ROTATION_POLICY;
607 }
608
609
610
611 /**
612 * Get the "time-interval" property definition.
613 * <p>
614 * Specifies the interval at which to check whether the log files
615 * need to be rotated.
616 *
617 * @return Returns the "time-interval" property definition.
618 */
619 public DurationPropertyDefinition getTimeIntervalPropertyDefinition() {
620 return PD_TIME_INTERVAL;
621 }
622
623
624
625 /**
626 * Get the "debug-targets" relation definition.
627 *
628 * @return Returns the "debug-targets" relation definition.
629 */
630 public InstantiableRelationDefinition<DebugTargetCfgClient,DebugTargetCfg> getDebugTargetsRelationDefinition() {
631 return DebugLogPublisherCfgDefn.getInstance().getDebugTargetsRelationDefinition();
632 }
633
634
635
636 /**
637 * Managed object client implementation.
638 */
639 private static class FileBasedDebugLogPublisherCfgClientImpl implements
640 FileBasedDebugLogPublisherCfgClient {
641
642 // Private implementation.
643 private ManagedObject<? extends FileBasedDebugLogPublisherCfgClient> impl;
644
645
646
647 // Private constructor.
648 private FileBasedDebugLogPublisherCfgClientImpl(
649 ManagedObject<? extends FileBasedDebugLogPublisherCfgClient> impl) {
650 this.impl = impl;
651 }
652
653
654
655 /**
656 * {@inheritDoc}
657 */
658 public boolean isAppend() {
659 return impl.getPropertyValue(INSTANCE.getAppendPropertyDefinition());
660 }
661
662
663
664 /**
665 * {@inheritDoc}
666 */
667 public void setAppend(Boolean value) {
668 impl.setPropertyValue(INSTANCE.getAppendPropertyDefinition(), value);
669 }
670
671
672
673 /**
674 * {@inheritDoc}
675 */
676 public boolean isAsynchronous() {
677 return impl.getPropertyValue(INSTANCE.getAsynchronousPropertyDefinition());
678 }
679
680
681
682 /**
683 * {@inheritDoc}
684 */
685 public void setAsynchronous(boolean value) {
686 impl.setPropertyValue(INSTANCE.getAsynchronousPropertyDefinition(), value);
687 }
688
689
690
691 /**
692 * {@inheritDoc}
693 */
694 public boolean isAutoFlush() {
695 return impl.getPropertyValue(INSTANCE.getAutoFlushPropertyDefinition());
696 }
697
698
699
700 /**
701 * {@inheritDoc}
702 */
703 public void setAutoFlush(Boolean value) {
704 impl.setPropertyValue(INSTANCE.getAutoFlushPropertyDefinition(), value);
705 }
706
707
708
709 /**
710 * {@inheritDoc}
711 */
712 public long getBufferSize() {
713 return impl.getPropertyValue(INSTANCE.getBufferSizePropertyDefinition());
714 }
715
716
717
718 /**
719 * {@inheritDoc}
720 */
721 public void setBufferSize(Long value) {
722 impl.setPropertyValue(INSTANCE.getBufferSizePropertyDefinition(), value);
723 }
724
725
726
727 /**
728 * {@inheritDoc}
729 */
730 public SortedSet<DefaultDebugCategory> getDefaultDebugCategory() {
731 return impl.getPropertyValues(INSTANCE.getDefaultDebugCategoryPropertyDefinition());
732 }
733
734
735
736 /**
737 * {@inheritDoc}
738 */
739 public void setDefaultDebugCategory(Collection<DefaultDebugCategory> values) {
740 impl.setPropertyValues(INSTANCE.getDefaultDebugCategoryPropertyDefinition(), values);
741 }
742
743
744
745 /**
746 * {@inheritDoc}
747 */
748 public DefaultDebugLevel getDefaultDebugLevel() {
749 return impl.getPropertyValue(INSTANCE.getDefaultDebugLevelPropertyDefinition());
750 }
751
752
753
754 /**
755 * {@inheritDoc}
756 */
757 public void setDefaultDebugLevel(DefaultDebugLevel value) {
758 impl.setPropertyValue(INSTANCE.getDefaultDebugLevelPropertyDefinition(), value);
759 }
760
761
762
763 /**
764 * {@inheritDoc}
765 */
766 public boolean isDefaultIncludeThrowableCause() {
767 return impl.getPropertyValue(INSTANCE.getDefaultIncludeThrowableCausePropertyDefinition());
768 }
769
770
771
772 /**
773 * {@inheritDoc}
774 */
775 public void setDefaultIncludeThrowableCause(Boolean value) {
776 impl.setPropertyValue(INSTANCE.getDefaultIncludeThrowableCausePropertyDefinition(), value);
777 }
778
779
780
781 /**
782 * {@inheritDoc}
783 */
784 public boolean isDefaultOmitMethodEntryArguments() {
785 return impl.getPropertyValue(INSTANCE.getDefaultOmitMethodEntryArgumentsPropertyDefinition());
786 }
787
788
789
790 /**
791 * {@inheritDoc}
792 */
793 public void setDefaultOmitMethodEntryArguments(Boolean value) {
794 impl.setPropertyValue(INSTANCE.getDefaultOmitMethodEntryArgumentsPropertyDefinition(), value);
795 }
796
797
798
799 /**
800 * {@inheritDoc}
801 */
802 public boolean isDefaultOmitMethodReturnValue() {
803 return impl.getPropertyValue(INSTANCE.getDefaultOmitMethodReturnValuePropertyDefinition());
804 }
805
806
807
808 /**
809 * {@inheritDoc}
810 */
811 public void setDefaultOmitMethodReturnValue(Boolean value) {
812 impl.setPropertyValue(INSTANCE.getDefaultOmitMethodReturnValuePropertyDefinition(), value);
813 }
814
815
816
817 /**
818 * {@inheritDoc}
819 */
820 public int getDefaultThrowableStackFrames() {
821 return impl.getPropertyValue(INSTANCE.getDefaultThrowableStackFramesPropertyDefinition());
822 }
823
824
825
826 /**
827 * {@inheritDoc}
828 */
829 public void setDefaultThrowableStackFrames(Integer value) {
830 impl.setPropertyValue(INSTANCE.getDefaultThrowableStackFramesPropertyDefinition(), value);
831 }
832
833
834
835 /**
836 * {@inheritDoc}
837 */
838 public Boolean isEnabled() {
839 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
840 }
841
842
843
844 /**
845 * {@inheritDoc}
846 */
847 public void setEnabled(boolean value) {
848 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
849 }
850
851
852
853 /**
854 * {@inheritDoc}
855 */
856 public String getJavaClass() {
857 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
858 }
859
860
861
862 /**
863 * {@inheritDoc}
864 */
865 public void setJavaClass(String value) {
866 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
867 }
868
869
870
871 /**
872 * {@inheritDoc}
873 */
874 public String getLogFile() {
875 return impl.getPropertyValue(INSTANCE.getLogFilePropertyDefinition());
876 }
877
878
879
880 /**
881 * {@inheritDoc}
882 */
883 public void setLogFile(String value) {
884 impl.setPropertyValue(INSTANCE.getLogFilePropertyDefinition(), value);
885 }
886
887
888
889 /**
890 * {@inheritDoc}
891 */
892 public String getLogFilePermissions() {
893 return impl.getPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition());
894 }
895
896
897
898 /**
899 * {@inheritDoc}
900 */
901 public void setLogFilePermissions(String value) {
902 impl.setPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition(), value);
903 }
904
905
906
907 /**
908 * {@inheritDoc}
909 */
910 public int getQueueSize() {
911 return impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition());
912 }
913
914
915
916 /**
917 * {@inheritDoc}
918 */
919 public void setQueueSize(Integer value) {
920 impl.setPropertyValue(INSTANCE.getQueueSizePropertyDefinition(), value);
921 }
922
923
924
925 /**
926 * {@inheritDoc}
927 */
928 public SortedSet<String> getRetentionPolicy() {
929 return impl.getPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition());
930 }
931
932
933
934 /**
935 * {@inheritDoc}
936 */
937 public void setRetentionPolicy(Collection<String> values) {
938 impl.setPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition(), values);
939 }
940
941
942
943 /**
944 * {@inheritDoc}
945 */
946 public SortedSet<String> getRotationPolicy() {
947 return impl.getPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition());
948 }
949
950
951
952 /**
953 * {@inheritDoc}
954 */
955 public void setRotationPolicy(Collection<String> values) {
956 impl.setPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition(), values);
957 }
958
959
960
961 /**
962 * {@inheritDoc}
963 */
964 public long getTimeInterval() {
965 return impl.getPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition());
966 }
967
968
969
970 /**
971 * {@inheritDoc}
972 */
973 public void setTimeInterval(Long value) {
974 impl.setPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition(), value);
975 }
976
977
978
979 /**
980 * {@inheritDoc}
981 */
982 public String[] listDebugTargets() throws ConcurrentModificationException,
983 AuthorizationException, CommunicationException {
984 return impl.listChildren(INSTANCE.getDebugTargetsRelationDefinition());
985 }
986
987
988
989 /**
990 * {@inheritDoc}
991 */
992 public DebugTargetCfgClient getDebugTarget(String name)
993 throws DefinitionDecodingException, ManagedObjectDecodingException,
994 ManagedObjectNotFoundException, ConcurrentModificationException,
995 AuthorizationException, CommunicationException {
996 return impl.getChild(INSTANCE.getDebugTargetsRelationDefinition(), name).getConfiguration();
997 }
998
999
1000
1001 /**
1002 * {@inheritDoc}
1003 */
1004 public <M extends DebugTargetCfgClient> M createDebugTarget(
1005 ManagedObjectDefinition<M, ? extends DebugTargetCfg> d, String name, Collection<DefaultBehaviorException> exceptions) throws IllegalManagedObjectNameException {
1006 return impl.createChild(INSTANCE.getDebugTargetsRelationDefinition(), d, name, exceptions).getConfiguration();
1007 }
1008
1009
1010
1011 /**
1012 * {@inheritDoc}
1013 */
1014 public void removeDebugTarget(String name)
1015 throws ManagedObjectNotFoundException, ConcurrentModificationException,
1016 OperationRejectedException, AuthorizationException, CommunicationException {
1017 impl.removeChild(INSTANCE.getDebugTargetsRelationDefinition(), name);
1018 }
1019
1020
1021
1022 /**
1023 * {@inheritDoc}
1024 */
1025 public ManagedObjectDefinition<? extends FileBasedDebugLogPublisherCfgClient, ? extends FileBasedDebugLogPublisherCfg> definition() {
1026 return INSTANCE;
1027 }
1028
1029
1030
1031 /**
1032 * {@inheritDoc}
1033 */
1034 public PropertyProvider properties() {
1035 return impl;
1036 }
1037
1038
1039
1040 /**
1041 * {@inheritDoc}
1042 */
1043 public void commit() throws ManagedObjectAlreadyExistsException,
1044 MissingMandatoryPropertiesException, ConcurrentModificationException,
1045 OperationRejectedException, AuthorizationException,
1046 CommunicationException {
1047 impl.commit();
1048 }
1049
1050 }
1051
1052
1053
1054 /**
1055 * Managed object server implementation.
1056 */
1057 private static class FileBasedDebugLogPublisherCfgServerImpl implements
1058 FileBasedDebugLogPublisherCfg {
1059
1060 // Private implementation.
1061 private ServerManagedObject<? extends FileBasedDebugLogPublisherCfg> impl;
1062
1063 // The value of the "append" property.
1064 private final boolean pAppend;
1065
1066 // The value of the "asynchronous" property.
1067 private final boolean pAsynchronous;
1068
1069 // The value of the "auto-flush" property.
1070 private final boolean pAutoFlush;
1071
1072 // The value of the "buffer-size" property.
1073 private final long pBufferSize;
1074
1075 // The value of the "default-debug-category" property.
1076 private final SortedSet<DefaultDebugCategory> pDefaultDebugCategory;
1077
1078 // The value of the "default-debug-level" property.
1079 private final DefaultDebugLevel pDefaultDebugLevel;
1080
1081 // The value of the "default-include-throwable-cause" property.
1082 private final boolean pDefaultIncludeThrowableCause;
1083
1084 // The value of the "default-omit-method-entry-arguments" property.
1085 private final boolean pDefaultOmitMethodEntryArguments;
1086
1087 // The value of the "default-omit-method-return-value" property.
1088 private final boolean pDefaultOmitMethodReturnValue;
1089
1090 // The value of the "default-throwable-stack-frames" property.
1091 private final int pDefaultThrowableStackFrames;
1092
1093 // The value of the "enabled" property.
1094 private final boolean pEnabled;
1095
1096 // The value of the "java-class" property.
1097 private final String pJavaClass;
1098
1099 // The value of the "log-file" property.
1100 private final String pLogFile;
1101
1102 // The value of the "log-file-permissions" property.
1103 private final String pLogFilePermissions;
1104
1105 // The value of the "queue-size" property.
1106 private final int pQueueSize;
1107
1108 // The value of the "retention-policy" property.
1109 private final SortedSet<String> pRetentionPolicy;
1110
1111 // The value of the "rotation-policy" property.
1112 private final SortedSet<String> pRotationPolicy;
1113
1114 // The value of the "time-interval" property.
1115 private final long pTimeInterval;
1116
1117
1118
1119 // Private constructor.
1120 private FileBasedDebugLogPublisherCfgServerImpl(ServerManagedObject<? extends FileBasedDebugLogPublisherCfg> impl) {
1121 this.impl = impl;
1122 this.pAppend = impl.getPropertyValue(INSTANCE.getAppendPropertyDefinition());
1123 this.pAsynchronous = impl.getPropertyValue(INSTANCE.getAsynchronousPropertyDefinition());
1124 this.pAutoFlush = impl.getPropertyValue(INSTANCE.getAutoFlushPropertyDefinition());
1125 this.pBufferSize = impl.getPropertyValue(INSTANCE.getBufferSizePropertyDefinition());
1126 this.pDefaultDebugCategory = impl.getPropertyValues(INSTANCE.getDefaultDebugCategoryPropertyDefinition());
1127 this.pDefaultDebugLevel = impl.getPropertyValue(INSTANCE.getDefaultDebugLevelPropertyDefinition());
1128 this.pDefaultIncludeThrowableCause = impl.getPropertyValue(INSTANCE.getDefaultIncludeThrowableCausePropertyDefinition());
1129 this.pDefaultOmitMethodEntryArguments = impl.getPropertyValue(INSTANCE.getDefaultOmitMethodEntryArgumentsPropertyDefinition());
1130 this.pDefaultOmitMethodReturnValue = impl.getPropertyValue(INSTANCE.getDefaultOmitMethodReturnValuePropertyDefinition());
1131 this.pDefaultThrowableStackFrames = impl.getPropertyValue(INSTANCE.getDefaultThrowableStackFramesPropertyDefinition());
1132 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
1133 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
1134 this.pLogFile = impl.getPropertyValue(INSTANCE.getLogFilePropertyDefinition());
1135 this.pLogFilePermissions = impl.getPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition());
1136 this.pQueueSize = impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition());
1137 this.pRetentionPolicy = impl.getPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition());
1138 this.pRotationPolicy = impl.getPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition());
1139 this.pTimeInterval = impl.getPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition());
1140 }
1141
1142
1143
1144 /**
1145 * {@inheritDoc}
1146 */
1147 public void addFileBasedDebugChangeListener(
1148 ConfigurationChangeListener<FileBasedDebugLogPublisherCfg> listener) {
1149 impl.registerChangeListener(listener);
1150 }
1151
1152
1153
1154 /**
1155 * {@inheritDoc}
1156 */
1157 public void removeFileBasedDebugChangeListener(
1158 ConfigurationChangeListener<FileBasedDebugLogPublisherCfg> listener) {
1159 impl.deregisterChangeListener(listener);
1160 }
1161 /**
1162 * {@inheritDoc}
1163 */
1164 public void addDebugChangeListener(
1165 ConfigurationChangeListener<DebugLogPublisherCfg> listener) {
1166 impl.registerChangeListener(listener);
1167 }
1168
1169
1170
1171 /**
1172 * {@inheritDoc}
1173 */
1174 public void removeDebugChangeListener(
1175 ConfigurationChangeListener<DebugLogPublisherCfg> listener) {
1176 impl.deregisterChangeListener(listener);
1177 }
1178 /**
1179 * {@inheritDoc}
1180 */
1181 public void addChangeListener(
1182 ConfigurationChangeListener<LogPublisherCfg> listener) {
1183 impl.registerChangeListener(listener);
1184 }
1185
1186
1187
1188 /**
1189 * {@inheritDoc}
1190 */
1191 public void removeChangeListener(
1192 ConfigurationChangeListener<LogPublisherCfg> listener) {
1193 impl.deregisterChangeListener(listener);
1194 }
1195
1196
1197
1198 /**
1199 * {@inheritDoc}
1200 */
1201 public boolean isAppend() {
1202 return pAppend;
1203 }
1204
1205
1206
1207 /**
1208 * {@inheritDoc}
1209 */
1210 public boolean isAsynchronous() {
1211 return pAsynchronous;
1212 }
1213
1214
1215
1216 /**
1217 * {@inheritDoc}
1218 */
1219 public boolean isAutoFlush() {
1220 return pAutoFlush;
1221 }
1222
1223
1224
1225 /**
1226 * {@inheritDoc}
1227 */
1228 public long getBufferSize() {
1229 return pBufferSize;
1230 }
1231
1232
1233
1234 /**
1235 * {@inheritDoc}
1236 */
1237 public SortedSet<DefaultDebugCategory> getDefaultDebugCategory() {
1238 return pDefaultDebugCategory;
1239 }
1240
1241
1242
1243 /**
1244 * {@inheritDoc}
1245 */
1246 public DefaultDebugLevel getDefaultDebugLevel() {
1247 return pDefaultDebugLevel;
1248 }
1249
1250
1251
1252 /**
1253 * {@inheritDoc}
1254 */
1255 public boolean isDefaultIncludeThrowableCause() {
1256 return pDefaultIncludeThrowableCause;
1257 }
1258
1259
1260
1261 /**
1262 * {@inheritDoc}
1263 */
1264 public boolean isDefaultOmitMethodEntryArguments() {
1265 return pDefaultOmitMethodEntryArguments;
1266 }
1267
1268
1269
1270 /**
1271 * {@inheritDoc}
1272 */
1273 public boolean isDefaultOmitMethodReturnValue() {
1274 return pDefaultOmitMethodReturnValue;
1275 }
1276
1277
1278
1279 /**
1280 * {@inheritDoc}
1281 */
1282 public int getDefaultThrowableStackFrames() {
1283 return pDefaultThrowableStackFrames;
1284 }
1285
1286
1287
1288 /**
1289 * {@inheritDoc}
1290 */
1291 public boolean isEnabled() {
1292 return pEnabled;
1293 }
1294
1295
1296
1297 /**
1298 * {@inheritDoc}
1299 */
1300 public String getJavaClass() {
1301 return pJavaClass;
1302 }
1303
1304
1305
1306 /**
1307 * {@inheritDoc}
1308 */
1309 public String getLogFile() {
1310 return pLogFile;
1311 }
1312
1313
1314
1315 /**
1316 * {@inheritDoc}
1317 */
1318 public String getLogFilePermissions() {
1319 return pLogFilePermissions;
1320 }
1321
1322
1323
1324 /**
1325 * {@inheritDoc}
1326 */
1327 public int getQueueSize() {
1328 return pQueueSize;
1329 }
1330
1331
1332
1333 /**
1334 * {@inheritDoc}
1335 */
1336 public SortedSet<String> getRetentionPolicy() {
1337 return pRetentionPolicy;
1338 }
1339
1340
1341
1342 /**
1343 * {@inheritDoc}
1344 */
1345 public SortedSet<DN> getRetentionPolicyDNs() {
1346 SortedSet<String> values = getRetentionPolicy();
1347 SortedSet<DN> dnValues = new TreeSet<DN>();
1348 for (String value : values) {
1349 DN dn = INSTANCE.getRetentionPolicyPropertyDefinition().getChildDN(value);
1350 dnValues.add(dn);
1351 }
1352 return dnValues;
1353 }
1354
1355
1356
1357 /**
1358 * {@inheritDoc}
1359 */
1360 public SortedSet<String> getRotationPolicy() {
1361 return pRotationPolicy;
1362 }
1363
1364
1365
1366 /**
1367 * {@inheritDoc}
1368 */
1369 public SortedSet<DN> getRotationPolicyDNs() {
1370 SortedSet<String> values = getRotationPolicy();
1371 SortedSet<DN> dnValues = new TreeSet<DN>();
1372 for (String value : values) {
1373 DN dn = INSTANCE.getRotationPolicyPropertyDefinition().getChildDN(value);
1374 dnValues.add(dn);
1375 }
1376 return dnValues;
1377 }
1378
1379
1380
1381 /**
1382 * {@inheritDoc}
1383 */
1384 public long getTimeInterval() {
1385 return pTimeInterval;
1386 }
1387
1388
1389
1390 /**
1391 * {@inheritDoc}
1392 */
1393 public String[] listDebugTargets() {
1394 return impl.listChildren(INSTANCE.getDebugTargetsRelationDefinition());
1395 }
1396
1397
1398
1399 /**
1400 * {@inheritDoc}
1401 */
1402 public DebugTargetCfg getDebugTarget(String name) throws ConfigException {
1403 return impl.getChild(INSTANCE.getDebugTargetsRelationDefinition(), name).getConfiguration();
1404 }
1405
1406
1407
1408 /**
1409 * {@inheritDoc}
1410 */
1411 public void addDebugTargetAddListener(
1412 ConfigurationAddListener<DebugTargetCfg> listener) throws ConfigException {
1413 impl.registerAddListener(INSTANCE.getDebugTargetsRelationDefinition(), listener);
1414 }
1415
1416
1417
1418 /**
1419 * {@inheritDoc}
1420 */
1421 public void removeDebugTargetAddListener(
1422 ConfigurationAddListener<DebugTargetCfg> listener) {
1423 impl.deregisterAddListener(INSTANCE.getDebugTargetsRelationDefinition(), listener);
1424 }
1425
1426
1427
1428 /**
1429 * {@inheritDoc}
1430 */
1431 public void addDebugTargetDeleteListener(
1432 ConfigurationDeleteListener<DebugTargetCfg> listener) throws ConfigException {
1433 impl.registerDeleteListener(INSTANCE.getDebugTargetsRelationDefinition(), listener);
1434 }
1435
1436
1437
1438 /**
1439 * {@inheritDoc}
1440 */
1441 public void removeDebugTargetDeleteListener(
1442 ConfigurationDeleteListener<DebugTargetCfg> listener) {
1443 impl.deregisterDeleteListener(INSTANCE.getDebugTargetsRelationDefinition(), listener);
1444 }
1445
1446
1447
1448 /**
1449 * {@inheritDoc}
1450 */
1451 public Class<? extends FileBasedDebugLogPublisherCfg> configurationClass() {
1452 return FileBasedDebugLogPublisherCfg.class;
1453 }
1454
1455
1456
1457 /**
1458 * {@inheritDoc}
1459 */
1460 public DN dn() {
1461 return impl.getDN();
1462 }
1463
1464 }
1465 }