001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.admin.std.meta;
028
029
030
031 import java.util.Collection;
032 import java.util.SortedSet;
033 import org.opends.server.admin.AdministratorAction;
034 import org.opends.server.admin.AliasDefaultBehaviorProvider;
035 import org.opends.server.admin.BooleanPropertyDefinition;
036 import org.opends.server.admin.ClassPropertyDefinition;
037 import org.opends.server.admin.client.AuthorizationException;
038 import org.opends.server.admin.client.CommunicationException;
039 import org.opends.server.admin.client.ConcurrentModificationException;
040 import org.opends.server.admin.client.ManagedObject;
041 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
042 import org.opends.server.admin.client.OperationRejectedException;
043 import org.opends.server.admin.DefaultBehaviorProvider;
044 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
045 import org.opends.server.admin.EnumPropertyDefinition;
046 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047 import org.opends.server.admin.ManagedObjectDefinition;
048 import org.opends.server.admin.PropertyOption;
049 import org.opends.server.admin.PropertyProvider;
050 import org.opends.server.admin.server.ConfigurationChangeListener;
051 import org.opends.server.admin.server.ServerManagedObject;
052 import org.opends.server.admin.std.client.ErrorLogPublisherCfgClient;
053 import org.opends.server.admin.std.server.ErrorLogPublisherCfg;
054 import org.opends.server.admin.std.server.LogPublisherCfg;
055 import org.opends.server.admin.StringPropertyDefinition;
056 import org.opends.server.admin.Tag;
057 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
058 import org.opends.server.types.DN;
059
060
061
062 /**
063 * An interface for querying the Error Log Publisher managed object
064 * definition meta information.
065 * <p>
066 * Error Log Publishers are responsible for distributing error log
067 * messages from the error logger to a destination.
068 */
069 public final class ErrorLogPublisherCfgDefn extends ManagedObjectDefinition<ErrorLogPublisherCfgClient, ErrorLogPublisherCfg> {
070
071 // The singleton configuration definition instance.
072 private static final ErrorLogPublisherCfgDefn INSTANCE = new ErrorLogPublisherCfgDefn();
073
074
075
076 /**
077 * Defines the set of permissable values for the "default-severity" property.
078 * <p>
079 * Specifies the default severity levels for the logger.
080 */
081 public static enum DefaultSeverity {
082
083 /**
084 * Messages of all severity levels are logged.
085 */
086 ALL("all"),
087
088
089
090 /**
091 * The error log severity that is used for messages that provide
092 * debugging information triggered during processing.
093 */
094 DEBUG("debug"),
095
096
097
098 /**
099 * The error log severity that is used for messages that provide
100 * information about fatal errors which may force the server to
101 * shut down or operate in a significantly degraded state.
102 */
103 FATAL_ERROR("fatal-error"),
104
105
106
107 /**
108 * The error log severity that is used for messages that provide
109 * information about significant events within the server that are
110 * not warnings or errors.
111 */
112 INFO("info"),
113
114
115
116 /**
117 * The error log severity that is used for messages that provide
118 * information about mild (recoverable) errors encountered during
119 * processing.
120 */
121 MILD_ERROR("mild-error"),
122
123
124
125 /**
126 * The error log severity that is used for messages that provide
127 * information about mild warnings triggered during processing.
128 */
129 MILD_WARNING("mild-warning"),
130
131
132
133 /**
134 * No messages of any severity are logged by default. This value
135 * is intended to be used in conjunction with the override-severity
136 * property to define an error logger that will publish no error
137 * message beside the errors of a given category.
138 */
139 NONE("none"),
140
141
142
143 /**
144 * The error log severity that is used for the most important
145 * informational messages (i.e., information that should almost
146 * always be logged but is not associated with a warning or error
147 * condition).
148 */
149 NOTICE("notice"),
150
151
152
153 /**
154 * The error log severity that is used for messages that provide
155 * information about severe errors encountered during processing.
156 */
157 SEVERE_ERROR("severe-error"),
158
159
160
161 /**
162 * The error log severity that is used for messages that provide
163 * information about severe warnings triggered during processing.
164 */
165 SEVERE_WARNING("severe-warning");
166
167
168
169 // String representation of the value.
170 private final String name;
171
172
173
174 // Private constructor.
175 private DefaultSeverity(String name) { this.name = name; }
176
177
178
179 /**
180 * {@inheritDoc}
181 */
182 public String toString() { return name; }
183
184 }
185
186
187
188 // The "default-severity" property definition.
189 private static final EnumPropertyDefinition<DefaultSeverity> PD_DEFAULT_SEVERITY;
190
191
192
193 // The "java-class" property definition.
194 private static final ClassPropertyDefinition PD_JAVA_CLASS;
195
196
197
198 // The "override-severity" property definition.
199 private static final StringPropertyDefinition PD_OVERRIDE_SEVERITY;
200
201
202
203 // Build the "default-severity" property definition.
204 static {
205 EnumPropertyDefinition.Builder<DefaultSeverity> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "default-severity");
206 builder.setOption(PropertyOption.MULTI_VALUED);
207 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-severity"));
208 DefaultBehaviorProvider<DefaultSeverity> provider = new DefinedDefaultBehaviorProvider<DefaultSeverity>("fatal-error", "severe-warning", "severe-error");
209 builder.setDefaultBehaviorProvider(provider);
210 builder.setEnumClass(DefaultSeverity.class);
211 PD_DEFAULT_SEVERITY = builder.getInstance();
212 INSTANCE.registerPropertyDefinition(PD_DEFAULT_SEVERITY);
213 }
214
215
216
217 // Build the "java-class" property definition.
218 static {
219 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
220 builder.setOption(PropertyOption.MANDATORY);
221 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
222 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
223 builder.addInstanceOf("org.opends.server.api.ErrorLogPublisher");
224 PD_JAVA_CLASS = builder.getInstance();
225 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
226 }
227
228
229
230 // Build the "override-severity" property definition.
231 static {
232 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "override-severity");
233 builder.setOption(PropertyOption.MULTI_VALUED);
234 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "override-severity"));
235 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "override-severity"));
236 builder.setPattern(".*", "STRING");
237 PD_OVERRIDE_SEVERITY = builder.getInstance();
238 INSTANCE.registerPropertyDefinition(PD_OVERRIDE_SEVERITY);
239 }
240
241
242
243 // Register the tags associated with this managed object definition.
244 static {
245 INSTANCE.registerTag(Tag.valueOf("logging"));
246 }
247
248
249
250 /**
251 * Get the Error Log Publisher configuration definition singleton.
252 *
253 * @return Returns the Error Log Publisher configuration definition
254 * singleton.
255 */
256 public static ErrorLogPublisherCfgDefn getInstance() {
257 return INSTANCE;
258 }
259
260
261
262 /**
263 * Private constructor.
264 */
265 private ErrorLogPublisherCfgDefn() {
266 super("error-log-publisher", LogPublisherCfgDefn.getInstance());
267 }
268
269
270
271 /**
272 * {@inheritDoc}
273 */
274 public ErrorLogPublisherCfgClient createClientConfiguration(
275 ManagedObject<? extends ErrorLogPublisherCfgClient> impl) {
276 return new ErrorLogPublisherCfgClientImpl(impl);
277 }
278
279
280
281 /**
282 * {@inheritDoc}
283 */
284 public ErrorLogPublisherCfg createServerConfiguration(
285 ServerManagedObject<? extends ErrorLogPublisherCfg> impl) {
286 return new ErrorLogPublisherCfgServerImpl(impl);
287 }
288
289
290
291 /**
292 * {@inheritDoc}
293 */
294 public Class<ErrorLogPublisherCfg> getServerConfigurationClass() {
295 return ErrorLogPublisherCfg.class;
296 }
297
298
299
300 /**
301 * Get the "default-severity" property definition.
302 * <p>
303 * Specifies the default severity levels for the logger.
304 *
305 * @return Returns the "default-severity" property definition.
306 */
307 public EnumPropertyDefinition<DefaultSeverity> getDefaultSeverityPropertyDefinition() {
308 return PD_DEFAULT_SEVERITY;
309 }
310
311
312
313 /**
314 * Get the "enabled" property definition.
315 * <p>
316 * Indicates whether the Error Log Publisher is enabled for use.
317 *
318 * @return Returns the "enabled" property definition.
319 */
320 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
321 return LogPublisherCfgDefn.getInstance().getEnabledPropertyDefinition();
322 }
323
324
325
326 /**
327 * Get the "java-class" property definition.
328 * <p>
329 * The fully-qualified name of the Java class that provides the
330 * Error Log Publisher implementation.
331 *
332 * @return Returns the "java-class" property definition.
333 */
334 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
335 return PD_JAVA_CLASS;
336 }
337
338
339
340 /**
341 * Get the "override-severity" property definition.
342 * <p>
343 * Specifies the override severity levels for the logger based on
344 * the category of the messages.
345 * <p>
346 * Each override severity level should include the category and the
347 * severity levels to log for that category, for example,
348 * core=mild-error,info,mild-warning. Valid categories are: core,
349 * extensions, protocol, config, log, util, schema, plugin, jeb,
350 * backend, tools, task, access-control, admin, sync, version,
351 * quicksetup, admin-tool, dsconfig, user-defined. Valid severities
352 * are: all, fatal-error, info, mild-error, mild-warning, notice,
353 * severe-error, severe-warning, debug.
354 *
355 * @return Returns the "override-severity" property definition.
356 */
357 public StringPropertyDefinition getOverrideSeverityPropertyDefinition() {
358 return PD_OVERRIDE_SEVERITY;
359 }
360
361
362
363 /**
364 * Managed object client implementation.
365 */
366 private static class ErrorLogPublisherCfgClientImpl implements
367 ErrorLogPublisherCfgClient {
368
369 // Private implementation.
370 private ManagedObject<? extends ErrorLogPublisherCfgClient> impl;
371
372
373
374 // Private constructor.
375 private ErrorLogPublisherCfgClientImpl(
376 ManagedObject<? extends ErrorLogPublisherCfgClient> impl) {
377 this.impl = impl;
378 }
379
380
381
382 /**
383 * {@inheritDoc}
384 */
385 public SortedSet<DefaultSeverity> getDefaultSeverity() {
386 return impl.getPropertyValues(INSTANCE.getDefaultSeverityPropertyDefinition());
387 }
388
389
390
391 /**
392 * {@inheritDoc}
393 */
394 public void setDefaultSeverity(Collection<DefaultSeverity> values) {
395 impl.setPropertyValues(INSTANCE.getDefaultSeverityPropertyDefinition(), values);
396 }
397
398
399
400 /**
401 * {@inheritDoc}
402 */
403 public Boolean isEnabled() {
404 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
405 }
406
407
408
409 /**
410 * {@inheritDoc}
411 */
412 public void setEnabled(boolean value) {
413 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
414 }
415
416
417
418 /**
419 * {@inheritDoc}
420 */
421 public String getJavaClass() {
422 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
423 }
424
425
426
427 /**
428 * {@inheritDoc}
429 */
430 public void setJavaClass(String value) {
431 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
432 }
433
434
435
436 /**
437 * {@inheritDoc}
438 */
439 public SortedSet<String> getOverrideSeverity() {
440 return impl.getPropertyValues(INSTANCE.getOverrideSeverityPropertyDefinition());
441 }
442
443
444
445 /**
446 * {@inheritDoc}
447 */
448 public void setOverrideSeverity(Collection<String> values) {
449 impl.setPropertyValues(INSTANCE.getOverrideSeverityPropertyDefinition(), values);
450 }
451
452
453
454 /**
455 * {@inheritDoc}
456 */
457 public ManagedObjectDefinition<? extends ErrorLogPublisherCfgClient, ? extends ErrorLogPublisherCfg> definition() {
458 return INSTANCE;
459 }
460
461
462
463 /**
464 * {@inheritDoc}
465 */
466 public PropertyProvider properties() {
467 return impl;
468 }
469
470
471
472 /**
473 * {@inheritDoc}
474 */
475 public void commit() throws ManagedObjectAlreadyExistsException,
476 MissingMandatoryPropertiesException, ConcurrentModificationException,
477 OperationRejectedException, AuthorizationException,
478 CommunicationException {
479 impl.commit();
480 }
481
482 }
483
484
485
486 /**
487 * Managed object server implementation.
488 */
489 private static class ErrorLogPublisherCfgServerImpl implements
490 ErrorLogPublisherCfg {
491
492 // Private implementation.
493 private ServerManagedObject<? extends ErrorLogPublisherCfg> impl;
494
495 // The value of the "default-severity" property.
496 private final SortedSet<DefaultSeverity> pDefaultSeverity;
497
498 // The value of the "enabled" property.
499 private final boolean pEnabled;
500
501 // The value of the "java-class" property.
502 private final String pJavaClass;
503
504 // The value of the "override-severity" property.
505 private final SortedSet<String> pOverrideSeverity;
506
507
508
509 // Private constructor.
510 private ErrorLogPublisherCfgServerImpl(ServerManagedObject<? extends ErrorLogPublisherCfg> impl) {
511 this.impl = impl;
512 this.pDefaultSeverity = impl.getPropertyValues(INSTANCE.getDefaultSeverityPropertyDefinition());
513 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
514 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
515 this.pOverrideSeverity = impl.getPropertyValues(INSTANCE.getOverrideSeverityPropertyDefinition());
516 }
517
518
519
520 /**
521 * {@inheritDoc}
522 */
523 public void addErrorChangeListener(
524 ConfigurationChangeListener<ErrorLogPublisherCfg> listener) {
525 impl.registerChangeListener(listener);
526 }
527
528
529
530 /**
531 * {@inheritDoc}
532 */
533 public void removeErrorChangeListener(
534 ConfigurationChangeListener<ErrorLogPublisherCfg> listener) {
535 impl.deregisterChangeListener(listener);
536 }
537 /**
538 * {@inheritDoc}
539 */
540 public void addChangeListener(
541 ConfigurationChangeListener<LogPublisherCfg> listener) {
542 impl.registerChangeListener(listener);
543 }
544
545
546
547 /**
548 * {@inheritDoc}
549 */
550 public void removeChangeListener(
551 ConfigurationChangeListener<LogPublisherCfg> listener) {
552 impl.deregisterChangeListener(listener);
553 }
554
555
556
557 /**
558 * {@inheritDoc}
559 */
560 public SortedSet<DefaultSeverity> getDefaultSeverity() {
561 return pDefaultSeverity;
562 }
563
564
565
566 /**
567 * {@inheritDoc}
568 */
569 public boolean isEnabled() {
570 return pEnabled;
571 }
572
573
574
575 /**
576 * {@inheritDoc}
577 */
578 public String getJavaClass() {
579 return pJavaClass;
580 }
581
582
583
584 /**
585 * {@inheritDoc}
586 */
587 public SortedSet<String> getOverrideSeverity() {
588 return pOverrideSeverity;
589 }
590
591
592
593 /**
594 * {@inheritDoc}
595 */
596 public Class<? extends ErrorLogPublisherCfg> configurationClass() {
597 return ErrorLogPublisherCfg.class;
598 }
599
600
601
602 /**
603 * {@inheritDoc}
604 */
605 public DN dn() {
606 return impl.getDN();
607 }
608
609 }
610 }