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.ManagedObject;
043 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
044 import org.opends.server.admin.client.OperationRejectedException;
045 import org.opends.server.admin.DefaultBehaviorProvider;
046 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
047 import org.opends.server.admin.DurationPropertyDefinition;
048 import org.opends.server.admin.IntegerPropertyDefinition;
049 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
050 import org.opends.server.admin.ManagedObjectDefinition;
051 import org.opends.server.admin.PropertyOption;
052 import org.opends.server.admin.PropertyProvider;
053 import org.opends.server.admin.server.ConfigurationChangeListener;
054 import org.opends.server.admin.server.ServerManagedObject;
055 import org.opends.server.admin.SizePropertyDefinition;
056 import org.opends.server.admin.std.client.FileBasedAccessLogPublisherCfgClient;
057 import org.opends.server.admin.std.client.LogRetentionPolicyCfgClient;
058 import org.opends.server.admin.std.client.LogRotationPolicyCfgClient;
059 import org.opends.server.admin.std.server.AccessLogPublisherCfg;
060 import org.opends.server.admin.std.server.FileBasedAccessLogPublisherCfg;
061 import org.opends.server.admin.std.server.LogPublisherCfg;
062 import org.opends.server.admin.std.server.LogRetentionPolicyCfg;
063 import org.opends.server.admin.std.server.LogRotationPolicyCfg;
064 import org.opends.server.admin.StringPropertyDefinition;
065 import org.opends.server.admin.Tag;
066 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
067 import org.opends.server.types.DN;
068
069
070
071 /**
072 * An interface for querying the File Based Access Log Publisher
073 * managed object definition meta information.
074 * <p>
075 * File Based Access Log Publishers publish access messages to the
076 * file system.
077 */
078 public final class FileBasedAccessLogPublisherCfgDefn extends ManagedObjectDefinition<FileBasedAccessLogPublisherCfgClient, FileBasedAccessLogPublisherCfg> {
079
080 // The singleton configuration definition instance.
081 private static final FileBasedAccessLogPublisherCfgDefn INSTANCE = new FileBasedAccessLogPublisherCfgDefn();
082
083
084
085 // The "append" property definition.
086 private static final BooleanPropertyDefinition PD_APPEND;
087
088
089
090 // The "asynchronous" property definition.
091 private static final BooleanPropertyDefinition PD_ASYNCHRONOUS;
092
093
094
095 // The "auto-flush" property definition.
096 private static final BooleanPropertyDefinition PD_AUTO_FLUSH;
097
098
099
100 // The "buffer-size" property definition.
101 private static final SizePropertyDefinition PD_BUFFER_SIZE;
102
103
104
105 // The "java-class" property definition.
106 private static final ClassPropertyDefinition PD_JAVA_CLASS;
107
108
109
110 // The "log-file" property definition.
111 private static final StringPropertyDefinition PD_LOG_FILE;
112
113
114
115 // The "log-file-permissions" property definition.
116 private static final StringPropertyDefinition PD_LOG_FILE_PERMISSIONS;
117
118
119
120 // The "queue-size" property definition.
121 private static final IntegerPropertyDefinition PD_QUEUE_SIZE;
122
123
124
125 // The "retention-policy" property definition.
126 private static final AggregationPropertyDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> PD_RETENTION_POLICY;
127
128
129
130 // The "rotation-policy" property definition.
131 private static final AggregationPropertyDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> PD_ROTATION_POLICY;
132
133
134
135 // The "time-interval" property definition.
136 private static final DurationPropertyDefinition PD_TIME_INTERVAL;
137
138
139
140 // Build the "append" property definition.
141 static {
142 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "append");
143 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "append"));
144 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
145 builder.setDefaultBehaviorProvider(provider);
146 PD_APPEND = builder.getInstance();
147 INSTANCE.registerPropertyDefinition(PD_APPEND);
148 }
149
150
151
152 // Build the "asynchronous" property definition.
153 static {
154 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "asynchronous");
155 builder.setOption(PropertyOption.MANDATORY);
156 builder.setOption(PropertyOption.ADVANCED);
157 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "asynchronous"));
158 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
159 builder.setDefaultBehaviorProvider(provider);
160 PD_ASYNCHRONOUS = builder.getInstance();
161 INSTANCE.registerPropertyDefinition(PD_ASYNCHRONOUS);
162 }
163
164
165
166 // Build the "auto-flush" property definition.
167 static {
168 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "auto-flush");
169 builder.setOption(PropertyOption.ADVANCED);
170 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "auto-flush"));
171 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
172 builder.setDefaultBehaviorProvider(provider);
173 PD_AUTO_FLUSH = builder.getInstance();
174 INSTANCE.registerPropertyDefinition(PD_AUTO_FLUSH);
175 }
176
177
178
179 // Build the "buffer-size" property definition.
180 static {
181 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "buffer-size");
182 builder.setOption(PropertyOption.ADVANCED);
183 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "buffer-size"));
184 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("64kb");
185 builder.setDefaultBehaviorProvider(provider);
186 builder.setLowerLimit("1");
187 PD_BUFFER_SIZE = builder.getInstance();
188 INSTANCE.registerPropertyDefinition(PD_BUFFER_SIZE);
189 }
190
191
192
193 // Build the "java-class" property definition.
194 static {
195 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
196 builder.setOption(PropertyOption.MANDATORY);
197 builder.setOption(PropertyOption.ADVANCED);
198 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
199 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.loggers.TextAccessLogPublisher");
200 builder.setDefaultBehaviorProvider(provider);
201 builder.addInstanceOf("org.opends.server.api.AccessLogPublisher");
202 PD_JAVA_CLASS = builder.getInstance();
203 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
204 }
205
206
207
208 // Build the "log-file" property definition.
209 static {
210 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-file");
211 builder.setOption(PropertyOption.MANDATORY);
212 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "log-file"));
213 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
214 builder.setPattern(".*", "FILE");
215 PD_LOG_FILE = builder.getInstance();
216 INSTANCE.registerPropertyDefinition(PD_LOG_FILE);
217 }
218
219
220
221 // Build the "log-file-permissions" property definition.
222 static {
223 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "log-file-permissions");
224 builder.setOption(PropertyOption.MANDATORY);
225 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "log-file-permissions"));
226 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("640");
227 builder.setDefaultBehaviorProvider(provider);
228 builder.setPattern("^([0-7][0-7][0-7])$", "MODE");
229 PD_LOG_FILE_PERMISSIONS = builder.getInstance();
230 INSTANCE.registerPropertyDefinition(PD_LOG_FILE_PERMISSIONS);
231 }
232
233
234
235 // Build the "queue-size" property definition.
236 static {
237 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "queue-size");
238 builder.setOption(PropertyOption.ADVANCED);
239 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "queue-size"));
240 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("5000");
241 builder.setDefaultBehaviorProvider(provider);
242 builder.setLowerLimit(1);
243 PD_QUEUE_SIZE = builder.getInstance();
244 INSTANCE.registerPropertyDefinition(PD_QUEUE_SIZE);
245 }
246
247
248
249 // Build the "retention-policy" property definition.
250 static {
251 AggregationPropertyDefinition.Builder<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "retention-policy");
252 builder.setOption(PropertyOption.MULTI_VALUED);
253 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "retention-policy"));
254 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "retention-policy"));
255 builder.setParentPath("/");
256 builder.setRelationDefinition("log-retention-policy");
257 PD_RETENTION_POLICY = builder.getInstance();
258 INSTANCE.registerPropertyDefinition(PD_RETENTION_POLICY);
259 INSTANCE.registerConstraint(PD_RETENTION_POLICY.getSourceConstraint());
260 }
261
262
263
264 // Build the "rotation-policy" property definition.
265 static {
266 AggregationPropertyDefinition.Builder<LogRotationPolicyCfgClient, LogRotationPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "rotation-policy");
267 builder.setOption(PropertyOption.MULTI_VALUED);
268 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "rotation-policy"));
269 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "rotation-policy"));
270 builder.setParentPath("/");
271 builder.setRelationDefinition("log-rotation-policy");
272 PD_ROTATION_POLICY = builder.getInstance();
273 INSTANCE.registerPropertyDefinition(PD_ROTATION_POLICY);
274 INSTANCE.registerConstraint(PD_ROTATION_POLICY.getSourceConstraint());
275 }
276
277
278
279 // Build the "time-interval" property definition.
280 static {
281 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "time-interval");
282 builder.setOption(PropertyOption.ADVANCED);
283 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "time-interval"));
284 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("5s");
285 builder.setDefaultBehaviorProvider(provider);
286 builder.setBaseUnit("ms");
287 builder.setLowerLimit("1");
288 PD_TIME_INTERVAL = builder.getInstance();
289 INSTANCE.registerPropertyDefinition(PD_TIME_INTERVAL);
290 }
291
292
293
294 // Register the tags associated with this managed object definition.
295 static {
296 INSTANCE.registerTag(Tag.valueOf("logging"));
297 }
298
299
300
301 /**
302 * Get the File Based Access Log Publisher configuration definition
303 * singleton.
304 *
305 * @return Returns the File Based Access Log Publisher configuration
306 * definition singleton.
307 */
308 public static FileBasedAccessLogPublisherCfgDefn getInstance() {
309 return INSTANCE;
310 }
311
312
313
314 /**
315 * Private constructor.
316 */
317 private FileBasedAccessLogPublisherCfgDefn() {
318 super("file-based-access-log-publisher", AccessLogPublisherCfgDefn.getInstance());
319 }
320
321
322
323 /**
324 * {@inheritDoc}
325 */
326 public FileBasedAccessLogPublisherCfgClient createClientConfiguration(
327 ManagedObject<? extends FileBasedAccessLogPublisherCfgClient> impl) {
328 return new FileBasedAccessLogPublisherCfgClientImpl(impl);
329 }
330
331
332
333 /**
334 * {@inheritDoc}
335 */
336 public FileBasedAccessLogPublisherCfg createServerConfiguration(
337 ServerManagedObject<? extends FileBasedAccessLogPublisherCfg> impl) {
338 return new FileBasedAccessLogPublisherCfgServerImpl(impl);
339 }
340
341
342
343 /**
344 * {@inheritDoc}
345 */
346 public Class<FileBasedAccessLogPublisherCfg> getServerConfigurationClass() {
347 return FileBasedAccessLogPublisherCfg.class;
348 }
349
350
351
352 /**
353 * Get the "append" property definition.
354 * <p>
355 * Specifies whether to append to existing log files.
356 *
357 * @return Returns the "append" property definition.
358 */
359 public BooleanPropertyDefinition getAppendPropertyDefinition() {
360 return PD_APPEND;
361 }
362
363
364
365 /**
366 * Get the "asynchronous" property definition.
367 * <p>
368 * Indicates whether the File Based Access Log Publisher will
369 * publish records asynchronously.
370 *
371 * @return Returns the "asynchronous" property definition.
372 */
373 public BooleanPropertyDefinition getAsynchronousPropertyDefinition() {
374 return PD_ASYNCHRONOUS;
375 }
376
377
378
379 /**
380 * Get the "auto-flush" property definition.
381 * <p>
382 * Specifies whether to flush the writer after every log record.
383 * <p>
384 * If the asynchronous writes option is used, the writer is flushed
385 * after all the log records in the queue are written.
386 *
387 * @return Returns the "auto-flush" property definition.
388 */
389 public BooleanPropertyDefinition getAutoFlushPropertyDefinition() {
390 return PD_AUTO_FLUSH;
391 }
392
393
394
395 /**
396 * Get the "buffer-size" property definition.
397 * <p>
398 * Specifies the log file buffer size.
399 *
400 * @return Returns the "buffer-size" property definition.
401 */
402 public SizePropertyDefinition getBufferSizePropertyDefinition() {
403 return PD_BUFFER_SIZE;
404 }
405
406
407
408 /**
409 * Get the "enabled" property definition.
410 * <p>
411 * Indicates whether the File Based Access Log Publisher is enabled
412 * for use.
413 *
414 * @return Returns the "enabled" property definition.
415 */
416 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
417 return AccessLogPublisherCfgDefn.getInstance().getEnabledPropertyDefinition();
418 }
419
420
421
422 /**
423 * Get the "java-class" property definition.
424 * <p>
425 * The fully-qualified name of the Java class that provides the File
426 * Based Access Log Publisher implementation.
427 *
428 * @return Returns the "java-class" property definition.
429 */
430 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
431 return PD_JAVA_CLASS;
432 }
433
434
435
436 /**
437 * Get the "log-file" property definition.
438 * <p>
439 * The file name to use for the log files generated by the File
440 * Based Access Log Publisher. The path to the file is relative to
441 * the server root.
442 *
443 * @return Returns the "log-file" property definition.
444 */
445 public StringPropertyDefinition getLogFilePropertyDefinition() {
446 return PD_LOG_FILE;
447 }
448
449
450
451 /**
452 * Get the "log-file-permissions" property definition.
453 * <p>
454 * The UNIX permissions of the log files created by this File Based
455 * Access Log Publisher.
456 *
457 * @return Returns the "log-file-permissions" property definition.
458 */
459 public StringPropertyDefinition getLogFilePermissionsPropertyDefinition() {
460 return PD_LOG_FILE_PERMISSIONS;
461 }
462
463
464
465 /**
466 * Get the "queue-size" property definition.
467 * <p>
468 * The maximum number of log records that can be stored in the
469 * asynchronous queue.
470 *
471 * @return Returns the "queue-size" property definition.
472 */
473 public IntegerPropertyDefinition getQueueSizePropertyDefinition() {
474 return PD_QUEUE_SIZE;
475 }
476
477
478
479 /**
480 * Get the "retention-policy" property definition.
481 * <p>
482 * The retention policy to use for the File Based Access Log
483 * Publisher .
484 * <p>
485 * When multiple policies are used, log files are cleaned when any
486 * of the policy's conditions are met.
487 *
488 * @return Returns the "retention-policy" property definition.
489 */
490 public AggregationPropertyDefinition<LogRetentionPolicyCfgClient, LogRetentionPolicyCfg> getRetentionPolicyPropertyDefinition() {
491 return PD_RETENTION_POLICY;
492 }
493
494
495
496 /**
497 * Get the "rotation-policy" property definition.
498 * <p>
499 * The rotation policy to use for the File Based Access Log
500 * Publisher .
501 * <p>
502 * When multiple policies are used, rotation will occur if any
503 * policy's conditions are met.
504 *
505 * @return Returns the "rotation-policy" property definition.
506 */
507 public AggregationPropertyDefinition<LogRotationPolicyCfgClient, LogRotationPolicyCfg> getRotationPolicyPropertyDefinition() {
508 return PD_ROTATION_POLICY;
509 }
510
511
512
513 /**
514 * Get the "suppress-internal-operations" property definition.
515 * <p>
516 * Indicates whether internal operations (for example, operations
517 * that are initiated by plugins) should be logged along with the
518 * operations that are requested by users.
519 *
520 * @return Returns the "suppress-internal-operations" property definition.
521 */
522 public BooleanPropertyDefinition getSuppressInternalOperationsPropertyDefinition() {
523 return AccessLogPublisherCfgDefn.getInstance().getSuppressInternalOperationsPropertyDefinition();
524 }
525
526
527
528 /**
529 * Get the "suppress-synchronization-operations" property definition.
530 * <p>
531 * Indicates whether access messages that are generated by
532 * synchronization operations should be suppressed.
533 *
534 * @return Returns the "suppress-synchronization-operations" property definition.
535 */
536 public BooleanPropertyDefinition getSuppressSynchronizationOperationsPropertyDefinition() {
537 return AccessLogPublisherCfgDefn.getInstance().getSuppressSynchronizationOperationsPropertyDefinition();
538 }
539
540
541
542 /**
543 * Get the "time-interval" property definition.
544 * <p>
545 * Specifies the interval at which to check whether the log files
546 * need to be rotated.
547 *
548 * @return Returns the "time-interval" property definition.
549 */
550 public DurationPropertyDefinition getTimeIntervalPropertyDefinition() {
551 return PD_TIME_INTERVAL;
552 }
553
554
555
556 /**
557 * Managed object client implementation.
558 */
559 private static class FileBasedAccessLogPublisherCfgClientImpl implements
560 FileBasedAccessLogPublisherCfgClient {
561
562 // Private implementation.
563 private ManagedObject<? extends FileBasedAccessLogPublisherCfgClient> impl;
564
565
566
567 // Private constructor.
568 private FileBasedAccessLogPublisherCfgClientImpl(
569 ManagedObject<? extends FileBasedAccessLogPublisherCfgClient> impl) {
570 this.impl = impl;
571 }
572
573
574
575 /**
576 * {@inheritDoc}
577 */
578 public boolean isAppend() {
579 return impl.getPropertyValue(INSTANCE.getAppendPropertyDefinition());
580 }
581
582
583
584 /**
585 * {@inheritDoc}
586 */
587 public void setAppend(Boolean value) {
588 impl.setPropertyValue(INSTANCE.getAppendPropertyDefinition(), value);
589 }
590
591
592
593 /**
594 * {@inheritDoc}
595 */
596 public boolean isAsynchronous() {
597 return impl.getPropertyValue(INSTANCE.getAsynchronousPropertyDefinition());
598 }
599
600
601
602 /**
603 * {@inheritDoc}
604 */
605 public void setAsynchronous(boolean value) {
606 impl.setPropertyValue(INSTANCE.getAsynchronousPropertyDefinition(), value);
607 }
608
609
610
611 /**
612 * {@inheritDoc}
613 */
614 public boolean isAutoFlush() {
615 return impl.getPropertyValue(INSTANCE.getAutoFlushPropertyDefinition());
616 }
617
618
619
620 /**
621 * {@inheritDoc}
622 */
623 public void setAutoFlush(Boolean value) {
624 impl.setPropertyValue(INSTANCE.getAutoFlushPropertyDefinition(), value);
625 }
626
627
628
629 /**
630 * {@inheritDoc}
631 */
632 public long getBufferSize() {
633 return impl.getPropertyValue(INSTANCE.getBufferSizePropertyDefinition());
634 }
635
636
637
638 /**
639 * {@inheritDoc}
640 */
641 public void setBufferSize(Long value) {
642 impl.setPropertyValue(INSTANCE.getBufferSizePropertyDefinition(), value);
643 }
644
645
646
647 /**
648 * {@inheritDoc}
649 */
650 public Boolean isEnabled() {
651 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
652 }
653
654
655
656 /**
657 * {@inheritDoc}
658 */
659 public void setEnabled(boolean value) {
660 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
661 }
662
663
664
665 /**
666 * {@inheritDoc}
667 */
668 public String getJavaClass() {
669 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
670 }
671
672
673
674 /**
675 * {@inheritDoc}
676 */
677 public void setJavaClass(String value) {
678 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
679 }
680
681
682
683 /**
684 * {@inheritDoc}
685 */
686 public String getLogFile() {
687 return impl.getPropertyValue(INSTANCE.getLogFilePropertyDefinition());
688 }
689
690
691
692 /**
693 * {@inheritDoc}
694 */
695 public void setLogFile(String value) {
696 impl.setPropertyValue(INSTANCE.getLogFilePropertyDefinition(), value);
697 }
698
699
700
701 /**
702 * {@inheritDoc}
703 */
704 public String getLogFilePermissions() {
705 return impl.getPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition());
706 }
707
708
709
710 /**
711 * {@inheritDoc}
712 */
713 public void setLogFilePermissions(String value) {
714 impl.setPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition(), value);
715 }
716
717
718
719 /**
720 * {@inheritDoc}
721 */
722 public int getQueueSize() {
723 return impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition());
724 }
725
726
727
728 /**
729 * {@inheritDoc}
730 */
731 public void setQueueSize(Integer value) {
732 impl.setPropertyValue(INSTANCE.getQueueSizePropertyDefinition(), value);
733 }
734
735
736
737 /**
738 * {@inheritDoc}
739 */
740 public SortedSet<String> getRetentionPolicy() {
741 return impl.getPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition());
742 }
743
744
745
746 /**
747 * {@inheritDoc}
748 */
749 public void setRetentionPolicy(Collection<String> values) {
750 impl.setPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition(), values);
751 }
752
753
754
755 /**
756 * {@inheritDoc}
757 */
758 public SortedSet<String> getRotationPolicy() {
759 return impl.getPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition());
760 }
761
762
763
764 /**
765 * {@inheritDoc}
766 */
767 public void setRotationPolicy(Collection<String> values) {
768 impl.setPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition(), values);
769 }
770
771
772
773 /**
774 * {@inheritDoc}
775 */
776 public boolean isSuppressInternalOperations() {
777 return impl.getPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition());
778 }
779
780
781
782 /**
783 * {@inheritDoc}
784 */
785 public void setSuppressInternalOperations(Boolean value) {
786 impl.setPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition(), value);
787 }
788
789
790
791 /**
792 * {@inheritDoc}
793 */
794 public boolean isSuppressSynchronizationOperations() {
795 return impl.getPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition());
796 }
797
798
799
800 /**
801 * {@inheritDoc}
802 */
803 public void setSuppressSynchronizationOperations(Boolean value) {
804 impl.setPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition(), value);
805 }
806
807
808
809 /**
810 * {@inheritDoc}
811 */
812 public long getTimeInterval() {
813 return impl.getPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition());
814 }
815
816
817
818 /**
819 * {@inheritDoc}
820 */
821 public void setTimeInterval(Long value) {
822 impl.setPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition(), value);
823 }
824
825
826
827 /**
828 * {@inheritDoc}
829 */
830 public ManagedObjectDefinition<? extends FileBasedAccessLogPublisherCfgClient, ? extends FileBasedAccessLogPublisherCfg> definition() {
831 return INSTANCE;
832 }
833
834
835
836 /**
837 * {@inheritDoc}
838 */
839 public PropertyProvider properties() {
840 return impl;
841 }
842
843
844
845 /**
846 * {@inheritDoc}
847 */
848 public void commit() throws ManagedObjectAlreadyExistsException,
849 MissingMandatoryPropertiesException, ConcurrentModificationException,
850 OperationRejectedException, AuthorizationException,
851 CommunicationException {
852 impl.commit();
853 }
854
855 }
856
857
858
859 /**
860 * Managed object server implementation.
861 */
862 private static class FileBasedAccessLogPublisherCfgServerImpl implements
863 FileBasedAccessLogPublisherCfg {
864
865 // Private implementation.
866 private ServerManagedObject<? extends FileBasedAccessLogPublisherCfg> impl;
867
868 // The value of the "append" property.
869 private final boolean pAppend;
870
871 // The value of the "asynchronous" property.
872 private final boolean pAsynchronous;
873
874 // The value of the "auto-flush" property.
875 private final boolean pAutoFlush;
876
877 // The value of the "buffer-size" property.
878 private final long pBufferSize;
879
880 // The value of the "enabled" property.
881 private final boolean pEnabled;
882
883 // The value of the "java-class" property.
884 private final String pJavaClass;
885
886 // The value of the "log-file" property.
887 private final String pLogFile;
888
889 // The value of the "log-file-permissions" property.
890 private final String pLogFilePermissions;
891
892 // The value of the "queue-size" property.
893 private final int pQueueSize;
894
895 // The value of the "retention-policy" property.
896 private final SortedSet<String> pRetentionPolicy;
897
898 // The value of the "rotation-policy" property.
899 private final SortedSet<String> pRotationPolicy;
900
901 // The value of the "suppress-internal-operations" property.
902 private final boolean pSuppressInternalOperations;
903
904 // The value of the "suppress-synchronization-operations" property.
905 private final boolean pSuppressSynchronizationOperations;
906
907 // The value of the "time-interval" property.
908 private final long pTimeInterval;
909
910
911
912 // Private constructor.
913 private FileBasedAccessLogPublisherCfgServerImpl(ServerManagedObject<? extends FileBasedAccessLogPublisherCfg> impl) {
914 this.impl = impl;
915 this.pAppend = impl.getPropertyValue(INSTANCE.getAppendPropertyDefinition());
916 this.pAsynchronous = impl.getPropertyValue(INSTANCE.getAsynchronousPropertyDefinition());
917 this.pAutoFlush = impl.getPropertyValue(INSTANCE.getAutoFlushPropertyDefinition());
918 this.pBufferSize = impl.getPropertyValue(INSTANCE.getBufferSizePropertyDefinition());
919 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
920 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
921 this.pLogFile = impl.getPropertyValue(INSTANCE.getLogFilePropertyDefinition());
922 this.pLogFilePermissions = impl.getPropertyValue(INSTANCE.getLogFilePermissionsPropertyDefinition());
923 this.pQueueSize = impl.getPropertyValue(INSTANCE.getQueueSizePropertyDefinition());
924 this.pRetentionPolicy = impl.getPropertyValues(INSTANCE.getRetentionPolicyPropertyDefinition());
925 this.pRotationPolicy = impl.getPropertyValues(INSTANCE.getRotationPolicyPropertyDefinition());
926 this.pSuppressInternalOperations = impl.getPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition());
927 this.pSuppressSynchronizationOperations = impl.getPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition());
928 this.pTimeInterval = impl.getPropertyValue(INSTANCE.getTimeIntervalPropertyDefinition());
929 }
930
931
932
933 /**
934 * {@inheritDoc}
935 */
936 public void addFileBasedAccessChangeListener(
937 ConfigurationChangeListener<FileBasedAccessLogPublisherCfg> listener) {
938 impl.registerChangeListener(listener);
939 }
940
941
942
943 /**
944 * {@inheritDoc}
945 */
946 public void removeFileBasedAccessChangeListener(
947 ConfigurationChangeListener<FileBasedAccessLogPublisherCfg> listener) {
948 impl.deregisterChangeListener(listener);
949 }
950 /**
951 * {@inheritDoc}
952 */
953 public void addAccessChangeListener(
954 ConfigurationChangeListener<AccessLogPublisherCfg> listener) {
955 impl.registerChangeListener(listener);
956 }
957
958
959
960 /**
961 * {@inheritDoc}
962 */
963 public void removeAccessChangeListener(
964 ConfigurationChangeListener<AccessLogPublisherCfg> listener) {
965 impl.deregisterChangeListener(listener);
966 }
967 /**
968 * {@inheritDoc}
969 */
970 public void addChangeListener(
971 ConfigurationChangeListener<LogPublisherCfg> listener) {
972 impl.registerChangeListener(listener);
973 }
974
975
976
977 /**
978 * {@inheritDoc}
979 */
980 public void removeChangeListener(
981 ConfigurationChangeListener<LogPublisherCfg> listener) {
982 impl.deregisterChangeListener(listener);
983 }
984
985
986
987 /**
988 * {@inheritDoc}
989 */
990 public boolean isAppend() {
991 return pAppend;
992 }
993
994
995
996 /**
997 * {@inheritDoc}
998 */
999 public boolean isAsynchronous() {
1000 return pAsynchronous;
1001 }
1002
1003
1004
1005 /**
1006 * {@inheritDoc}
1007 */
1008 public boolean isAutoFlush() {
1009 return pAutoFlush;
1010 }
1011
1012
1013
1014 /**
1015 * {@inheritDoc}
1016 */
1017 public long getBufferSize() {
1018 return pBufferSize;
1019 }
1020
1021
1022
1023 /**
1024 * {@inheritDoc}
1025 */
1026 public boolean isEnabled() {
1027 return pEnabled;
1028 }
1029
1030
1031
1032 /**
1033 * {@inheritDoc}
1034 */
1035 public String getJavaClass() {
1036 return pJavaClass;
1037 }
1038
1039
1040
1041 /**
1042 * {@inheritDoc}
1043 */
1044 public String getLogFile() {
1045 return pLogFile;
1046 }
1047
1048
1049
1050 /**
1051 * {@inheritDoc}
1052 */
1053 public String getLogFilePermissions() {
1054 return pLogFilePermissions;
1055 }
1056
1057
1058
1059 /**
1060 * {@inheritDoc}
1061 */
1062 public int getQueueSize() {
1063 return pQueueSize;
1064 }
1065
1066
1067
1068 /**
1069 * {@inheritDoc}
1070 */
1071 public SortedSet<String> getRetentionPolicy() {
1072 return pRetentionPolicy;
1073 }
1074
1075
1076
1077 /**
1078 * {@inheritDoc}
1079 */
1080 public SortedSet<DN> getRetentionPolicyDNs() {
1081 SortedSet<String> values = getRetentionPolicy();
1082 SortedSet<DN> dnValues = new TreeSet<DN>();
1083 for (String value : values) {
1084 DN dn = INSTANCE.getRetentionPolicyPropertyDefinition().getChildDN(value);
1085 dnValues.add(dn);
1086 }
1087 return dnValues;
1088 }
1089
1090
1091
1092 /**
1093 * {@inheritDoc}
1094 */
1095 public SortedSet<String> getRotationPolicy() {
1096 return pRotationPolicy;
1097 }
1098
1099
1100
1101 /**
1102 * {@inheritDoc}
1103 */
1104 public SortedSet<DN> getRotationPolicyDNs() {
1105 SortedSet<String> values = getRotationPolicy();
1106 SortedSet<DN> dnValues = new TreeSet<DN>();
1107 for (String value : values) {
1108 DN dn = INSTANCE.getRotationPolicyPropertyDefinition().getChildDN(value);
1109 dnValues.add(dn);
1110 }
1111 return dnValues;
1112 }
1113
1114
1115
1116 /**
1117 * {@inheritDoc}
1118 */
1119 public boolean isSuppressInternalOperations() {
1120 return pSuppressInternalOperations;
1121 }
1122
1123
1124
1125 /**
1126 * {@inheritDoc}
1127 */
1128 public boolean isSuppressSynchronizationOperations() {
1129 return pSuppressSynchronizationOperations;
1130 }
1131
1132
1133
1134 /**
1135 * {@inheritDoc}
1136 */
1137 public long getTimeInterval() {
1138 return pTimeInterval;
1139 }
1140
1141
1142
1143 /**
1144 * {@inheritDoc}
1145 */
1146 public Class<? extends FileBasedAccessLogPublisherCfg> configurationClass() {
1147 return FileBasedAccessLogPublisherCfg.class;
1148 }
1149
1150
1151
1152 /**
1153 * {@inheritDoc}
1154 */
1155 public DN dn() {
1156 return impl.getDN();
1157 }
1158
1159 }
1160 }