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 org.opends.server.admin.AdministratorAction;
032 import org.opends.server.admin.BooleanPropertyDefinition;
033 import org.opends.server.admin.ClassPropertyDefinition;
034 import org.opends.server.admin.client.AuthorizationException;
035 import org.opends.server.admin.client.CommunicationException;
036 import org.opends.server.admin.client.ConcurrentModificationException;
037 import org.opends.server.admin.client.ManagedObject;
038 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
039 import org.opends.server.admin.client.OperationRejectedException;
040 import org.opends.server.admin.DefaultBehaviorProvider;
041 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
042 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
043 import org.opends.server.admin.ManagedObjectDefinition;
044 import org.opends.server.admin.PropertyOption;
045 import org.opends.server.admin.PropertyProvider;
046 import org.opends.server.admin.server.ConfigurationChangeListener;
047 import org.opends.server.admin.server.ServerManagedObject;
048 import org.opends.server.admin.std.client.AccessLogPublisherCfgClient;
049 import org.opends.server.admin.std.server.AccessLogPublisherCfg;
050 import org.opends.server.admin.std.server.LogPublisherCfg;
051 import org.opends.server.admin.Tag;
052 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
053 import org.opends.server.types.DN;
054
055
056
057 /**
058 * An interface for querying the Access Log Publisher managed object
059 * definition meta information.
060 * <p>
061 * Access Log Publishers are responsible for distributing access log
062 * messages from the access logger to a destination.
063 */
064 public final class AccessLogPublisherCfgDefn extends ManagedObjectDefinition<AccessLogPublisherCfgClient, AccessLogPublisherCfg> {
065
066 // The singleton configuration definition instance.
067 private static final AccessLogPublisherCfgDefn INSTANCE = new AccessLogPublisherCfgDefn();
068
069
070
071 // The "java-class" property definition.
072 private static final ClassPropertyDefinition PD_JAVA_CLASS;
073
074
075
076 // The "suppress-internal-operations" property definition.
077 private static final BooleanPropertyDefinition PD_SUPPRESS_INTERNAL_OPERATIONS;
078
079
080
081 // The "suppress-synchronization-operations" property definition.
082 private static final BooleanPropertyDefinition PD_SUPPRESS_SYNCHRONIZATION_OPERATIONS;
083
084
085
086 // Build the "java-class" property definition.
087 static {
088 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
089 builder.setOption(PropertyOption.MANDATORY);
090 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
091 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
092 builder.addInstanceOf("org.opends.server.api.AccessLogPublisher");
093 PD_JAVA_CLASS = builder.getInstance();
094 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
095 }
096
097
098
099 // Build the "suppress-internal-operations" property definition.
100 static {
101 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "suppress-internal-operations");
102 builder.setOption(PropertyOption.ADVANCED);
103 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "suppress-internal-operations"));
104 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
105 builder.setDefaultBehaviorProvider(provider);
106 PD_SUPPRESS_INTERNAL_OPERATIONS = builder.getInstance();
107 INSTANCE.registerPropertyDefinition(PD_SUPPRESS_INTERNAL_OPERATIONS);
108 }
109
110
111
112 // Build the "suppress-synchronization-operations" property definition.
113 static {
114 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "suppress-synchronization-operations");
115 builder.setOption(PropertyOption.ADVANCED);
116 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "suppress-synchronization-operations"));
117 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
118 builder.setDefaultBehaviorProvider(provider);
119 PD_SUPPRESS_SYNCHRONIZATION_OPERATIONS = builder.getInstance();
120 INSTANCE.registerPropertyDefinition(PD_SUPPRESS_SYNCHRONIZATION_OPERATIONS);
121 }
122
123
124
125 // Register the tags associated with this managed object definition.
126 static {
127 INSTANCE.registerTag(Tag.valueOf("logging"));
128 }
129
130
131
132 /**
133 * Get the Access Log Publisher configuration definition singleton.
134 *
135 * @return Returns the Access Log Publisher configuration definition
136 * singleton.
137 */
138 public static AccessLogPublisherCfgDefn getInstance() {
139 return INSTANCE;
140 }
141
142
143
144 /**
145 * Private constructor.
146 */
147 private AccessLogPublisherCfgDefn() {
148 super("access-log-publisher", LogPublisherCfgDefn.getInstance());
149 }
150
151
152
153 /**
154 * {@inheritDoc}
155 */
156 public AccessLogPublisherCfgClient createClientConfiguration(
157 ManagedObject<? extends AccessLogPublisherCfgClient> impl) {
158 return new AccessLogPublisherCfgClientImpl(impl);
159 }
160
161
162
163 /**
164 * {@inheritDoc}
165 */
166 public AccessLogPublisherCfg createServerConfiguration(
167 ServerManagedObject<? extends AccessLogPublisherCfg> impl) {
168 return new AccessLogPublisherCfgServerImpl(impl);
169 }
170
171
172
173 /**
174 * {@inheritDoc}
175 */
176 public Class<AccessLogPublisherCfg> getServerConfigurationClass() {
177 return AccessLogPublisherCfg.class;
178 }
179
180
181
182 /**
183 * Get the "enabled" property definition.
184 * <p>
185 * Indicates whether the Access Log Publisher is enabled for use.
186 *
187 * @return Returns the "enabled" property definition.
188 */
189 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
190 return LogPublisherCfgDefn.getInstance().getEnabledPropertyDefinition();
191 }
192
193
194
195 /**
196 * Get the "java-class" property definition.
197 * <p>
198 * The fully-qualified name of the Java class that provides the
199 * Access Log Publisher implementation.
200 *
201 * @return Returns the "java-class" property definition.
202 */
203 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
204 return PD_JAVA_CLASS;
205 }
206
207
208
209 /**
210 * Get the "suppress-internal-operations" property definition.
211 * <p>
212 * Indicates whether internal operations (for example, operations
213 * that are initiated by plugins) should be logged along with the
214 * operations that are requested by users.
215 *
216 * @return Returns the "suppress-internal-operations" property definition.
217 */
218 public BooleanPropertyDefinition getSuppressInternalOperationsPropertyDefinition() {
219 return PD_SUPPRESS_INTERNAL_OPERATIONS;
220 }
221
222
223
224 /**
225 * Get the "suppress-synchronization-operations" property definition.
226 * <p>
227 * Indicates whether access messages that are generated by
228 * synchronization operations should be suppressed.
229 *
230 * @return Returns the "suppress-synchronization-operations" property definition.
231 */
232 public BooleanPropertyDefinition getSuppressSynchronizationOperationsPropertyDefinition() {
233 return PD_SUPPRESS_SYNCHRONIZATION_OPERATIONS;
234 }
235
236
237
238 /**
239 * Managed object client implementation.
240 */
241 private static class AccessLogPublisherCfgClientImpl implements
242 AccessLogPublisherCfgClient {
243
244 // Private implementation.
245 private ManagedObject<? extends AccessLogPublisherCfgClient> impl;
246
247
248
249 // Private constructor.
250 private AccessLogPublisherCfgClientImpl(
251 ManagedObject<? extends AccessLogPublisherCfgClient> impl) {
252 this.impl = impl;
253 }
254
255
256
257 /**
258 * {@inheritDoc}
259 */
260 public Boolean isEnabled() {
261 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
262 }
263
264
265
266 /**
267 * {@inheritDoc}
268 */
269 public void setEnabled(boolean value) {
270 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
271 }
272
273
274
275 /**
276 * {@inheritDoc}
277 */
278 public String getJavaClass() {
279 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
280 }
281
282
283
284 /**
285 * {@inheritDoc}
286 */
287 public void setJavaClass(String value) {
288 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
289 }
290
291
292
293 /**
294 * {@inheritDoc}
295 */
296 public boolean isSuppressInternalOperations() {
297 return impl.getPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition());
298 }
299
300
301
302 /**
303 * {@inheritDoc}
304 */
305 public void setSuppressInternalOperations(Boolean value) {
306 impl.setPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition(), value);
307 }
308
309
310
311 /**
312 * {@inheritDoc}
313 */
314 public boolean isSuppressSynchronizationOperations() {
315 return impl.getPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition());
316 }
317
318
319
320 /**
321 * {@inheritDoc}
322 */
323 public void setSuppressSynchronizationOperations(Boolean value) {
324 impl.setPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition(), value);
325 }
326
327
328
329 /**
330 * {@inheritDoc}
331 */
332 public ManagedObjectDefinition<? extends AccessLogPublisherCfgClient, ? extends AccessLogPublisherCfg> definition() {
333 return INSTANCE;
334 }
335
336
337
338 /**
339 * {@inheritDoc}
340 */
341 public PropertyProvider properties() {
342 return impl;
343 }
344
345
346
347 /**
348 * {@inheritDoc}
349 */
350 public void commit() throws ManagedObjectAlreadyExistsException,
351 MissingMandatoryPropertiesException, ConcurrentModificationException,
352 OperationRejectedException, AuthorizationException,
353 CommunicationException {
354 impl.commit();
355 }
356
357 }
358
359
360
361 /**
362 * Managed object server implementation.
363 */
364 private static class AccessLogPublisherCfgServerImpl implements
365 AccessLogPublisherCfg {
366
367 // Private implementation.
368 private ServerManagedObject<? extends AccessLogPublisherCfg> impl;
369
370 // The value of the "enabled" property.
371 private final boolean pEnabled;
372
373 // The value of the "java-class" property.
374 private final String pJavaClass;
375
376 // The value of the "suppress-internal-operations" property.
377 private final boolean pSuppressInternalOperations;
378
379 // The value of the "suppress-synchronization-operations" property.
380 private final boolean pSuppressSynchronizationOperations;
381
382
383
384 // Private constructor.
385 private AccessLogPublisherCfgServerImpl(ServerManagedObject<? extends AccessLogPublisherCfg> impl) {
386 this.impl = impl;
387 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
388 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
389 this.pSuppressInternalOperations = impl.getPropertyValue(INSTANCE.getSuppressInternalOperationsPropertyDefinition());
390 this.pSuppressSynchronizationOperations = impl.getPropertyValue(INSTANCE.getSuppressSynchronizationOperationsPropertyDefinition());
391 }
392
393
394
395 /**
396 * {@inheritDoc}
397 */
398 public void addAccessChangeListener(
399 ConfigurationChangeListener<AccessLogPublisherCfg> listener) {
400 impl.registerChangeListener(listener);
401 }
402
403
404
405 /**
406 * {@inheritDoc}
407 */
408 public void removeAccessChangeListener(
409 ConfigurationChangeListener<AccessLogPublisherCfg> listener) {
410 impl.deregisterChangeListener(listener);
411 }
412 /**
413 * {@inheritDoc}
414 */
415 public void addChangeListener(
416 ConfigurationChangeListener<LogPublisherCfg> listener) {
417 impl.registerChangeListener(listener);
418 }
419
420
421
422 /**
423 * {@inheritDoc}
424 */
425 public void removeChangeListener(
426 ConfigurationChangeListener<LogPublisherCfg> listener) {
427 impl.deregisterChangeListener(listener);
428 }
429
430
431
432 /**
433 * {@inheritDoc}
434 */
435 public boolean isEnabled() {
436 return pEnabled;
437 }
438
439
440
441 /**
442 * {@inheritDoc}
443 */
444 public String getJavaClass() {
445 return pJavaClass;
446 }
447
448
449
450 /**
451 * {@inheritDoc}
452 */
453 public boolean isSuppressInternalOperations() {
454 return pSuppressInternalOperations;
455 }
456
457
458
459 /**
460 * {@inheritDoc}
461 */
462 public boolean isSuppressSynchronizationOperations() {
463 return pSuppressSynchronizationOperations;
464 }
465
466
467
468 /**
469 * {@inheritDoc}
470 */
471 public Class<? extends AccessLogPublisherCfg> configurationClass() {
472 return AccessLogPublisherCfg.class;
473 }
474
475
476
477 /**
478 * {@inheritDoc}
479 */
480 public DN dn() {
481 return impl.getDN();
482 }
483
484 }
485 }