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