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.AttributeTypePropertyDefinition;
036 import org.opends.server.admin.BooleanPropertyDefinition;
037 import org.opends.server.admin.ClassPropertyDefinition;
038 import org.opends.server.admin.client.AuthorizationException;
039 import org.opends.server.admin.client.CommunicationException;
040 import org.opends.server.admin.client.ConcurrentModificationException;
041 import org.opends.server.admin.client.ManagedObject;
042 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
043 import org.opends.server.admin.client.OperationRejectedException;
044 import org.opends.server.admin.DefaultBehaviorProvider;
045 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
046 import org.opends.server.admin.DNPropertyDefinition;
047 import org.opends.server.admin.EnumPropertyDefinition;
048 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
049 import org.opends.server.admin.ManagedObjectDefinition;
050 import org.opends.server.admin.PropertyOption;
051 import org.opends.server.admin.PropertyProvider;
052 import org.opends.server.admin.server.ConfigurationChangeListener;
053 import org.opends.server.admin.server.ServerManagedObject;
054 import org.opends.server.admin.std.client.VirtualAttributeCfgClient;
055 import org.opends.server.admin.std.server.VirtualAttributeCfg;
056 import org.opends.server.admin.StringPropertyDefinition;
057 import org.opends.server.admin.Tag;
058 import org.opends.server.admin.TopCfgDefn;
059 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
060 import org.opends.server.types.AttributeType;
061 import org.opends.server.types.DN;
062
063
064
065 /**
066 * An interface for querying the Virtual Attribute managed object
067 * definition meta information.
068 * <p>
069 * Virtual Attributes are responsible for dynamically generating
070 * attribute values that appear in entries but are not persistently
071 * stored in the backend.
072 */
073 public final class VirtualAttributeCfgDefn extends ManagedObjectDefinition<VirtualAttributeCfgClient, VirtualAttributeCfg> {
074
075 // The singleton configuration definition instance.
076 private static final VirtualAttributeCfgDefn INSTANCE = new VirtualAttributeCfgDefn();
077
078
079
080 /**
081 * Defines the set of permissable values for the "conflict-behavior" property.
082 * <p>
083 * Specifies the behavior that the server is to exhibit for entries
084 * that already contain one or more real values for the associated
085 * attribute.
086 */
087 public static enum ConflictBehavior {
088
089 /**
090 * Indicates that the virtual attribute provider is to preserve
091 * any real values contained in the entry and merge them with the
092 * set of generated virtual values so that both the real and
093 * virtual values are used.
094 */
095 MERGE_REAL_AND_VIRTUAL("merge-real-and-virtual"),
096
097
098
099 /**
100 * Indicates that any real values contained in the entry are
101 * preserved and used, and virtual values are not generated.
102 */
103 REAL_OVERRIDES_VIRTUAL("real-overrides-virtual"),
104
105
106
107 /**
108 * Indicates that the virtual attribute provider suppresses any
109 * real values contained in the entry and generates virtual values
110 * and uses them.
111 */
112 VIRTUAL_OVERRIDES_REAL("virtual-overrides-real");
113
114
115
116 // String representation of the value.
117 private final String name;
118
119
120
121 // Private constructor.
122 private ConflictBehavior(String name) { this.name = name; }
123
124
125
126 /**
127 * {@inheritDoc}
128 */
129 public String toString() { return name; }
130
131 }
132
133
134
135 // The "attribute-type" property definition.
136 private static final AttributeTypePropertyDefinition PD_ATTRIBUTE_TYPE;
137
138
139
140 // The "base-dn" property definition.
141 private static final DNPropertyDefinition PD_BASE_DN;
142
143
144
145 // The "conflict-behavior" property definition.
146 private static final EnumPropertyDefinition<ConflictBehavior> PD_CONFLICT_BEHAVIOR;
147
148
149
150 // The "enabled" property definition.
151 private static final BooleanPropertyDefinition PD_ENABLED;
152
153
154
155 // The "filter" property definition.
156 private static final StringPropertyDefinition PD_FILTER;
157
158
159
160 // The "group-dn" property definition.
161 private static final DNPropertyDefinition PD_GROUP_DN;
162
163
164
165 // The "java-class" property definition.
166 private static final ClassPropertyDefinition PD_JAVA_CLASS;
167
168
169
170 // Build the "attribute-type" property definition.
171 static {
172 AttributeTypePropertyDefinition.Builder builder = AttributeTypePropertyDefinition.createBuilder(INSTANCE, "attribute-type");
173 builder.setOption(PropertyOption.MANDATORY);
174 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "attribute-type"));
175 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<AttributeType>());
176 PD_ATTRIBUTE_TYPE = builder.getInstance();
177 INSTANCE.registerPropertyDefinition(PD_ATTRIBUTE_TYPE);
178 }
179
180
181
182 // Build the "base-dn" property definition.
183 static {
184 DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "base-dn");
185 builder.setOption(PropertyOption.MULTI_VALUED);
186 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "base-dn"));
187 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DN>(INSTANCE, "base-dn"));
188 PD_BASE_DN = builder.getInstance();
189 INSTANCE.registerPropertyDefinition(PD_BASE_DN);
190 }
191
192
193
194 // Build the "conflict-behavior" property definition.
195 static {
196 EnumPropertyDefinition.Builder<ConflictBehavior> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "conflict-behavior");
197 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "conflict-behavior"));
198 DefaultBehaviorProvider<ConflictBehavior> provider = new DefinedDefaultBehaviorProvider<ConflictBehavior>("real-overrides-virtual");
199 builder.setDefaultBehaviorProvider(provider);
200 builder.setEnumClass(ConflictBehavior.class);
201 PD_CONFLICT_BEHAVIOR = builder.getInstance();
202 INSTANCE.registerPropertyDefinition(PD_CONFLICT_BEHAVIOR);
203 }
204
205
206
207 // Build the "enabled" property definition.
208 static {
209 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled");
210 builder.setOption(PropertyOption.MANDATORY);
211 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled"));
212 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>());
213 PD_ENABLED = builder.getInstance();
214 INSTANCE.registerPropertyDefinition(PD_ENABLED);
215 }
216
217
218
219 // Build the "filter" property definition.
220 static {
221 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "filter");
222 builder.setOption(PropertyOption.MULTI_VALUED);
223 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "filter"));
224 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("(objectClass=*)");
225 builder.setDefaultBehaviorProvider(provider);
226 builder.setPattern(".*", "STRING");
227 PD_FILTER = builder.getInstance();
228 INSTANCE.registerPropertyDefinition(PD_FILTER);
229 }
230
231
232
233 // Build the "group-dn" property definition.
234 static {
235 DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "group-dn");
236 builder.setOption(PropertyOption.MULTI_VALUED);
237 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "group-dn"));
238 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DN>(INSTANCE, "group-dn"));
239 PD_GROUP_DN = builder.getInstance();
240 INSTANCE.registerPropertyDefinition(PD_GROUP_DN);
241 }
242
243
244
245 // Build the "java-class" property definition.
246 static {
247 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
248 builder.setOption(PropertyOption.MANDATORY);
249 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
250 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
251 builder.addInstanceOf("org.opends.server.api.VirtualAttributeProvider");
252 PD_JAVA_CLASS = builder.getInstance();
253 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
254 }
255
256
257
258 // Register the tags associated with this managed object definition.
259 static {
260 INSTANCE.registerTag(Tag.valueOf("core-server"));
261 }
262
263
264
265 /**
266 * Get the Virtual Attribute configuration definition singleton.
267 *
268 * @return Returns the Virtual Attribute configuration definition
269 * singleton.
270 */
271 public static VirtualAttributeCfgDefn getInstance() {
272 return INSTANCE;
273 }
274
275
276
277 /**
278 * Private constructor.
279 */
280 private VirtualAttributeCfgDefn() {
281 super("virtual-attribute", TopCfgDefn.getInstance());
282 }
283
284
285
286 /**
287 * {@inheritDoc}
288 */
289 public VirtualAttributeCfgClient createClientConfiguration(
290 ManagedObject<? extends VirtualAttributeCfgClient> impl) {
291 return new VirtualAttributeCfgClientImpl(impl);
292 }
293
294
295
296 /**
297 * {@inheritDoc}
298 */
299 public VirtualAttributeCfg createServerConfiguration(
300 ServerManagedObject<? extends VirtualAttributeCfg> impl) {
301 return new VirtualAttributeCfgServerImpl(impl);
302 }
303
304
305
306 /**
307 * {@inheritDoc}
308 */
309 public Class<VirtualAttributeCfg> getServerConfigurationClass() {
310 return VirtualAttributeCfg.class;
311 }
312
313
314
315 /**
316 * Get the "attribute-type" property definition.
317 * <p>
318 * Specifies the attribute type for the attribute whose values are
319 * to be dynamically assigned by the virtual attribute.
320 *
321 * @return Returns the "attribute-type" property definition.
322 */
323 public AttributeTypePropertyDefinition getAttributeTypePropertyDefinition() {
324 return PD_ATTRIBUTE_TYPE;
325 }
326
327
328
329 /**
330 * Get the "base-dn" property definition.
331 * <p>
332 * Specifies the base DNs for the branches containing entries that
333 * are eligible to use this virtual attribute.
334 * <p>
335 * If no values are given, then the server generates virtual
336 * attributes anywhere in the server.
337 *
338 * @return Returns the "base-dn" property definition.
339 */
340 public DNPropertyDefinition getBaseDNPropertyDefinition() {
341 return PD_BASE_DN;
342 }
343
344
345
346 /**
347 * Get the "conflict-behavior" property definition.
348 * <p>
349 * Specifies the behavior that the server is to exhibit for entries
350 * that already contain one or more real values for the associated
351 * attribute.
352 *
353 * @return Returns the "conflict-behavior" property definition.
354 */
355 public EnumPropertyDefinition<ConflictBehavior> getConflictBehaviorPropertyDefinition() {
356 return PD_CONFLICT_BEHAVIOR;
357 }
358
359
360
361 /**
362 * Get the "enabled" property definition.
363 * <p>
364 * Indicates whether the Virtual Attribute is enabled for use.
365 *
366 * @return Returns the "enabled" property definition.
367 */
368 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
369 return PD_ENABLED;
370 }
371
372
373
374 /**
375 * Get the "filter" property definition.
376 * <p>
377 * Specifies the search filters to be applied against entries to
378 * determine if the virtual attribute is to be generated for those
379 * entries.
380 * <p>
381 * If no values are given, then any entry is eligible to have the
382 * value generated. If one or more filters are specified, then only
383 * entries that match at least one of those filters are allowed to
384 * have the virtual attribute.
385 *
386 * @return Returns the "filter" property definition.
387 */
388 public StringPropertyDefinition getFilterPropertyDefinition() {
389 return PD_FILTER;
390 }
391
392
393
394 /**
395 * Get the "group-dn" property definition.
396 * <p>
397 * Specifies the DNs of the groups whose members can be eligible to
398 * use this virtual attribute.
399 * <p>
400 * If no values are given, then group membership is not taken into
401 * account when generating the virtual attribute. If one or more
402 * group DNs are specified, then only members of those groups are
403 * allowed to have the virtual attribute.
404 *
405 * @return Returns the "group-dn" property definition.
406 */
407 public DNPropertyDefinition getGroupDNPropertyDefinition() {
408 return PD_GROUP_DN;
409 }
410
411
412
413 /**
414 * Get the "java-class" property definition.
415 * <p>
416 * Specifies the fully-qualified name of the virtual attribute
417 * provider class that generates the attribute values.
418 *
419 * @return Returns the "java-class" property definition.
420 */
421 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
422 return PD_JAVA_CLASS;
423 }
424
425
426
427 /**
428 * Managed object client implementation.
429 */
430 private static class VirtualAttributeCfgClientImpl implements
431 VirtualAttributeCfgClient {
432
433 // Private implementation.
434 private ManagedObject<? extends VirtualAttributeCfgClient> impl;
435
436
437
438 // Private constructor.
439 private VirtualAttributeCfgClientImpl(
440 ManagedObject<? extends VirtualAttributeCfgClient> impl) {
441 this.impl = impl;
442 }
443
444
445
446 /**
447 * {@inheritDoc}
448 */
449 public AttributeType getAttributeType() {
450 return impl.getPropertyValue(INSTANCE.getAttributeTypePropertyDefinition());
451 }
452
453
454
455 /**
456 * {@inheritDoc}
457 */
458 public void setAttributeType(AttributeType value) {
459 impl.setPropertyValue(INSTANCE.getAttributeTypePropertyDefinition(), value);
460 }
461
462
463
464 /**
465 * {@inheritDoc}
466 */
467 public SortedSet<DN> getBaseDN() {
468 return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
469 }
470
471
472
473 /**
474 * {@inheritDoc}
475 */
476 public void setBaseDN(Collection<DN> values) {
477 impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values);
478 }
479
480
481
482 /**
483 * {@inheritDoc}
484 */
485 public ConflictBehavior getConflictBehavior() {
486 return impl.getPropertyValue(INSTANCE.getConflictBehaviorPropertyDefinition());
487 }
488
489
490
491 /**
492 * {@inheritDoc}
493 */
494 public void setConflictBehavior(ConflictBehavior value) {
495 impl.setPropertyValue(INSTANCE.getConflictBehaviorPropertyDefinition(), value);
496 }
497
498
499
500 /**
501 * {@inheritDoc}
502 */
503 public Boolean isEnabled() {
504 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
505 }
506
507
508
509 /**
510 * {@inheritDoc}
511 */
512 public void setEnabled(boolean value) {
513 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
514 }
515
516
517
518 /**
519 * {@inheritDoc}
520 */
521 public SortedSet<String> getFilter() {
522 return impl.getPropertyValues(INSTANCE.getFilterPropertyDefinition());
523 }
524
525
526
527 /**
528 * {@inheritDoc}
529 */
530 public void setFilter(Collection<String> values) {
531 impl.setPropertyValues(INSTANCE.getFilterPropertyDefinition(), values);
532 }
533
534
535
536 /**
537 * {@inheritDoc}
538 */
539 public SortedSet<DN> getGroupDN() {
540 return impl.getPropertyValues(INSTANCE.getGroupDNPropertyDefinition());
541 }
542
543
544
545 /**
546 * {@inheritDoc}
547 */
548 public void setGroupDN(Collection<DN> values) {
549 impl.setPropertyValues(INSTANCE.getGroupDNPropertyDefinition(), values);
550 }
551
552
553
554 /**
555 * {@inheritDoc}
556 */
557 public String getJavaClass() {
558 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
559 }
560
561
562
563 /**
564 * {@inheritDoc}
565 */
566 public void setJavaClass(String value) {
567 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
568 }
569
570
571
572 /**
573 * {@inheritDoc}
574 */
575 public ManagedObjectDefinition<? extends VirtualAttributeCfgClient, ? extends VirtualAttributeCfg> definition() {
576 return INSTANCE;
577 }
578
579
580
581 /**
582 * {@inheritDoc}
583 */
584 public PropertyProvider properties() {
585 return impl;
586 }
587
588
589
590 /**
591 * {@inheritDoc}
592 */
593 public void commit() throws ManagedObjectAlreadyExistsException,
594 MissingMandatoryPropertiesException, ConcurrentModificationException,
595 OperationRejectedException, AuthorizationException,
596 CommunicationException {
597 impl.commit();
598 }
599
600 }
601
602
603
604 /**
605 * Managed object server implementation.
606 */
607 private static class VirtualAttributeCfgServerImpl implements
608 VirtualAttributeCfg {
609
610 // Private implementation.
611 private ServerManagedObject<? extends VirtualAttributeCfg> impl;
612
613 // The value of the "attribute-type" property.
614 private final AttributeType pAttributeType;
615
616 // The value of the "base-dn" property.
617 private final SortedSet<DN> pBaseDN;
618
619 // The value of the "conflict-behavior" property.
620 private final ConflictBehavior pConflictBehavior;
621
622 // The value of the "enabled" property.
623 private final boolean pEnabled;
624
625 // The value of the "filter" property.
626 private final SortedSet<String> pFilter;
627
628 // The value of the "group-dn" property.
629 private final SortedSet<DN> pGroupDN;
630
631 // The value of the "java-class" property.
632 private final String pJavaClass;
633
634
635
636 // Private constructor.
637 private VirtualAttributeCfgServerImpl(ServerManagedObject<? extends VirtualAttributeCfg> impl) {
638 this.impl = impl;
639 this.pAttributeType = impl.getPropertyValue(INSTANCE.getAttributeTypePropertyDefinition());
640 this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
641 this.pConflictBehavior = impl.getPropertyValue(INSTANCE.getConflictBehaviorPropertyDefinition());
642 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
643 this.pFilter = impl.getPropertyValues(INSTANCE.getFilterPropertyDefinition());
644 this.pGroupDN = impl.getPropertyValues(INSTANCE.getGroupDNPropertyDefinition());
645 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
646 }
647
648
649
650 /**
651 * {@inheritDoc}
652 */
653 public void addChangeListener(
654 ConfigurationChangeListener<VirtualAttributeCfg> listener) {
655 impl.registerChangeListener(listener);
656 }
657
658
659
660 /**
661 * {@inheritDoc}
662 */
663 public void removeChangeListener(
664 ConfigurationChangeListener<VirtualAttributeCfg> listener) {
665 impl.deregisterChangeListener(listener);
666 }
667
668
669
670 /**
671 * {@inheritDoc}
672 */
673 public AttributeType getAttributeType() {
674 return pAttributeType;
675 }
676
677
678
679 /**
680 * {@inheritDoc}
681 */
682 public SortedSet<DN> getBaseDN() {
683 return pBaseDN;
684 }
685
686
687
688 /**
689 * {@inheritDoc}
690 */
691 public ConflictBehavior getConflictBehavior() {
692 return pConflictBehavior;
693 }
694
695
696
697 /**
698 * {@inheritDoc}
699 */
700 public boolean isEnabled() {
701 return pEnabled;
702 }
703
704
705
706 /**
707 * {@inheritDoc}
708 */
709 public SortedSet<String> getFilter() {
710 return pFilter;
711 }
712
713
714
715 /**
716 * {@inheritDoc}
717 */
718 public SortedSet<DN> getGroupDN() {
719 return pGroupDN;
720 }
721
722
723
724 /**
725 * {@inheritDoc}
726 */
727 public String getJavaClass() {
728 return pJavaClass;
729 }
730
731
732
733 /**
734 * {@inheritDoc}
735 */
736 public Class<? extends VirtualAttributeCfg> configurationClass() {
737 return VirtualAttributeCfg.class;
738 }
739
740
741
742 /**
743 * {@inheritDoc}
744 */
745 public DN dn() {
746 return impl.getDN();
747 }
748
749 }
750 }