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