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.ManagedObjectAlreadyExistsException;
048 import org.opends.server.admin.ManagedObjectDefinition;
049 import org.opends.server.admin.PropertyOption;
050 import org.opends.server.admin.PropertyProvider;
051 import org.opends.server.admin.server.ConfigurationChangeListener;
052 import org.opends.server.admin.server.ServerManagedObject;
053 import org.opends.server.admin.std.client.RegularExpressionIdentityMapperCfgClient;
054 import org.opends.server.admin.std.server.IdentityMapperCfg;
055 import org.opends.server.admin.std.server.RegularExpressionIdentityMapperCfg;
056 import org.opends.server.admin.StringPropertyDefinition;
057 import org.opends.server.admin.Tag;
058 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
059 import org.opends.server.types.AttributeType;
060 import org.opends.server.types.DN;
061
062
063
064 /**
065 * An interface for querying the Regular Expression Identity Mapper
066 * managed object definition meta information.
067 * <p>
068 * The Regular Expression Identity Mapper provides a way to use a
069 * regular expression to translate the provided identifier when
070 * searching for the appropriate user entry.
071 */
072 public final class RegularExpressionIdentityMapperCfgDefn extends ManagedObjectDefinition<RegularExpressionIdentityMapperCfgClient, RegularExpressionIdentityMapperCfg> {
073
074 // The singleton configuration definition instance.
075 private static final RegularExpressionIdentityMapperCfgDefn INSTANCE = new RegularExpressionIdentityMapperCfgDefn();
076
077
078
079 // The "java-class" property definition.
080 private static final ClassPropertyDefinition PD_JAVA_CLASS;
081
082
083
084 // The "match-attribute" property definition.
085 private static final AttributeTypePropertyDefinition PD_MATCH_ATTRIBUTE;
086
087
088
089 // The "match-base-dn" property definition.
090 private static final DNPropertyDefinition PD_MATCH_BASE_DN;
091
092
093
094 // The "match-pattern" property definition.
095 private static final StringPropertyDefinition PD_MATCH_PATTERN;
096
097
098
099 // The "replace-pattern" property definition.
100 private static final StringPropertyDefinition PD_REPLACE_PATTERN;
101
102
103
104 // Build the "java-class" property definition.
105 static {
106 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
107 builder.setOption(PropertyOption.MANDATORY);
108 builder.setOption(PropertyOption.ADVANCED);
109 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
110 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.RegularExpressionIdentityMapper");
111 builder.setDefaultBehaviorProvider(provider);
112 builder.addInstanceOf("org.opends.server.api.IdentityMapper");
113 PD_JAVA_CLASS = builder.getInstance();
114 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
115 }
116
117
118
119 // Build the "match-attribute" property definition.
120 static {
121 AttributeTypePropertyDefinition.Builder builder = AttributeTypePropertyDefinition.createBuilder(INSTANCE, "match-attribute");
122 builder.setOption(PropertyOption.MULTI_VALUED);
123 builder.setOption(PropertyOption.MANDATORY);
124 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "match-attribute"));
125 DefaultBehaviorProvider<AttributeType> provider = new DefinedDefaultBehaviorProvider<AttributeType>("uid");
126 builder.setDefaultBehaviorProvider(provider);
127 PD_MATCH_ATTRIBUTE = builder.getInstance();
128 INSTANCE.registerPropertyDefinition(PD_MATCH_ATTRIBUTE);
129 }
130
131
132
133 // Build the "match-base-dn" property definition.
134 static {
135 DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "match-base-dn");
136 builder.setOption(PropertyOption.MULTI_VALUED);
137 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "match-base-dn"));
138 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DN>(INSTANCE, "match-base-dn"));
139 PD_MATCH_BASE_DN = builder.getInstance();
140 INSTANCE.registerPropertyDefinition(PD_MATCH_BASE_DN);
141 }
142
143
144
145 // Build the "match-pattern" property definition.
146 static {
147 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "match-pattern");
148 builder.setOption(PropertyOption.MANDATORY);
149 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "match-pattern"));
150 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
151 builder.setPattern(".*", "REGEXP");
152 PD_MATCH_PATTERN = builder.getInstance();
153 INSTANCE.registerPropertyDefinition(PD_MATCH_PATTERN);
154 }
155
156
157
158 // Build the "replace-pattern" property definition.
159 static {
160 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "replace-pattern");
161 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "replace-pattern"));
162 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "replace-pattern"));
163 builder.setPattern(".*", "REGEXP");
164 PD_REPLACE_PATTERN = builder.getInstance();
165 INSTANCE.registerPropertyDefinition(PD_REPLACE_PATTERN);
166 }
167
168
169
170 // Register the tags associated with this managed object definition.
171 static {
172 INSTANCE.registerTag(Tag.valueOf("security"));
173 INSTANCE.registerTag(Tag.valueOf("user-management"));
174 }
175
176
177
178 /**
179 * Get the Regular Expression Identity Mapper configuration
180 * definition singleton.
181 *
182 * @return Returns the Regular Expression Identity Mapper
183 * configuration definition singleton.
184 */
185 public static RegularExpressionIdentityMapperCfgDefn getInstance() {
186 return INSTANCE;
187 }
188
189
190
191 /**
192 * Private constructor.
193 */
194 private RegularExpressionIdentityMapperCfgDefn() {
195 super("regular-expression-identity-mapper", IdentityMapperCfgDefn.getInstance());
196 }
197
198
199
200 /**
201 * {@inheritDoc}
202 */
203 public RegularExpressionIdentityMapperCfgClient createClientConfiguration(
204 ManagedObject<? extends RegularExpressionIdentityMapperCfgClient> impl) {
205 return new RegularExpressionIdentityMapperCfgClientImpl(impl);
206 }
207
208
209
210 /**
211 * {@inheritDoc}
212 */
213 public RegularExpressionIdentityMapperCfg createServerConfiguration(
214 ServerManagedObject<? extends RegularExpressionIdentityMapperCfg> impl) {
215 return new RegularExpressionIdentityMapperCfgServerImpl(impl);
216 }
217
218
219
220 /**
221 * {@inheritDoc}
222 */
223 public Class<RegularExpressionIdentityMapperCfg> getServerConfigurationClass() {
224 return RegularExpressionIdentityMapperCfg.class;
225 }
226
227
228
229 /**
230 * Get the "enabled" property definition.
231 * <p>
232 * Indicates whether the Regular Expression Identity Mapper is
233 * enabled for use.
234 *
235 * @return Returns the "enabled" property definition.
236 */
237 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
238 return IdentityMapperCfgDefn.getInstance().getEnabledPropertyDefinition();
239 }
240
241
242
243 /**
244 * Get the "java-class" property definition.
245 * <p>
246 * Specifies the fully-qualified name of the Java class that
247 * provides the Regular Expression Identity Mapper implementation.
248 *
249 * @return Returns the "java-class" property definition.
250 */
251 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
252 return PD_JAVA_CLASS;
253 }
254
255
256
257 /**
258 * Get the "match-attribute" property definition.
259 * <p>
260 * Specifies the name or OID of the attribute whose value should
261 * match the provided identifier string after it has been processed
262 * by the associated regular expression.
263 * <p>
264 * All values must refer to the name or OID of an attribute type
265 * defined in the Directory Server schema. If multiple attributes or
266 * OIDs are provided, at least one of those attributes must contain
267 * the provided ID string value in exactly one entry.
268 *
269 * @return Returns the "match-attribute" property definition.
270 */
271 public AttributeTypePropertyDefinition getMatchAttributePropertyDefinition() {
272 return PD_MATCH_ATTRIBUTE;
273 }
274
275
276
277 /**
278 * Get the "match-base-dn" property definition.
279 * <p>
280 * Specifies the base DN(s) that should be used when performing
281 * searches to map the provided ID string to a user entry. If
282 * multiple values are given, searches are performed below all the
283 * specified base DNs.
284 *
285 * @return Returns the "match-base-dn" property definition.
286 */
287 public DNPropertyDefinition getMatchBaseDNPropertyDefinition() {
288 return PD_MATCH_BASE_DN;
289 }
290
291
292
293 /**
294 * Get the "match-pattern" property definition.
295 * <p>
296 * Specifies the regular expression pattern that is used to identify
297 * portions of the ID string that will be replaced.
298 * <p>
299 * Any portion of the ID string that matches this pattern is
300 * replaced in accordance with the provided replace pattern (or is
301 * removed if no replace pattern is specified). If multiple
302 * substrings within the given ID string match this pattern, all
303 * occurrences are replaced. If no part of the given ID string
304 * matches this pattern, the ID string is not altered. Exactly one
305 * match pattern value must be provided, and it must be a valid
306 * regular expression as described in the API documentation for the
307 * java.util.regex.Pattern class, including support for capturing
308 * groups.
309 *
310 * @return Returns the "match-pattern" property definition.
311 */
312 public StringPropertyDefinition getMatchPatternPropertyDefinition() {
313 return PD_MATCH_PATTERN;
314 }
315
316
317
318 /**
319 * Get the "replace-pattern" property definition.
320 * <p>
321 * Specifies the replacement pattern that should be used for
322 * substrings in the ID string that match the provided regular
323 * expression pattern.
324 * <p>
325 * If no replacement pattern is provided, then any matching portions
326 * of the ID string will be removed (i.e., replaced with an empty
327 * string). The replacement pattern may include a string from a
328 * capturing group by using a dollar sign ($) followed by an integer
329 * value that indicates which capturing group should be used.
330 *
331 * @return Returns the "replace-pattern" property definition.
332 */
333 public StringPropertyDefinition getReplacePatternPropertyDefinition() {
334 return PD_REPLACE_PATTERN;
335 }
336
337
338
339 /**
340 * Managed object client implementation.
341 */
342 private static class RegularExpressionIdentityMapperCfgClientImpl implements
343 RegularExpressionIdentityMapperCfgClient {
344
345 // Private implementation.
346 private ManagedObject<? extends RegularExpressionIdentityMapperCfgClient> impl;
347
348
349
350 // Private constructor.
351 private RegularExpressionIdentityMapperCfgClientImpl(
352 ManagedObject<? extends RegularExpressionIdentityMapperCfgClient> impl) {
353 this.impl = impl;
354 }
355
356
357
358 /**
359 * {@inheritDoc}
360 */
361 public Boolean isEnabled() {
362 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
363 }
364
365
366
367 /**
368 * {@inheritDoc}
369 */
370 public void setEnabled(boolean value) {
371 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
372 }
373
374
375
376 /**
377 * {@inheritDoc}
378 */
379 public String getJavaClass() {
380 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
381 }
382
383
384
385 /**
386 * {@inheritDoc}
387 */
388 public void setJavaClass(String value) {
389 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
390 }
391
392
393
394 /**
395 * {@inheritDoc}
396 */
397 public SortedSet<AttributeType> getMatchAttribute() {
398 return impl.getPropertyValues(INSTANCE.getMatchAttributePropertyDefinition());
399 }
400
401
402
403 /**
404 * {@inheritDoc}
405 */
406 public void setMatchAttribute(Collection<AttributeType> values) {
407 impl.setPropertyValues(INSTANCE.getMatchAttributePropertyDefinition(), values);
408 }
409
410
411
412 /**
413 * {@inheritDoc}
414 */
415 public SortedSet<DN> getMatchBaseDN() {
416 return impl.getPropertyValues(INSTANCE.getMatchBaseDNPropertyDefinition());
417 }
418
419
420
421 /**
422 * {@inheritDoc}
423 */
424 public void setMatchBaseDN(Collection<DN> values) {
425 impl.setPropertyValues(INSTANCE.getMatchBaseDNPropertyDefinition(), values);
426 }
427
428
429
430 /**
431 * {@inheritDoc}
432 */
433 public String getMatchPattern() {
434 return impl.getPropertyValue(INSTANCE.getMatchPatternPropertyDefinition());
435 }
436
437
438
439 /**
440 * {@inheritDoc}
441 */
442 public void setMatchPattern(String value) {
443 impl.setPropertyValue(INSTANCE.getMatchPatternPropertyDefinition(), value);
444 }
445
446
447
448 /**
449 * {@inheritDoc}
450 */
451 public String getReplacePattern() {
452 return impl.getPropertyValue(INSTANCE.getReplacePatternPropertyDefinition());
453 }
454
455
456
457 /**
458 * {@inheritDoc}
459 */
460 public void setReplacePattern(String value) {
461 impl.setPropertyValue(INSTANCE.getReplacePatternPropertyDefinition(), value);
462 }
463
464
465
466 /**
467 * {@inheritDoc}
468 */
469 public ManagedObjectDefinition<? extends RegularExpressionIdentityMapperCfgClient, ? extends RegularExpressionIdentityMapperCfg> definition() {
470 return INSTANCE;
471 }
472
473
474
475 /**
476 * {@inheritDoc}
477 */
478 public PropertyProvider properties() {
479 return impl;
480 }
481
482
483
484 /**
485 * {@inheritDoc}
486 */
487 public void commit() throws ManagedObjectAlreadyExistsException,
488 MissingMandatoryPropertiesException, ConcurrentModificationException,
489 OperationRejectedException, AuthorizationException,
490 CommunicationException {
491 impl.commit();
492 }
493
494 }
495
496
497
498 /**
499 * Managed object server implementation.
500 */
501 private static class RegularExpressionIdentityMapperCfgServerImpl implements
502 RegularExpressionIdentityMapperCfg {
503
504 // Private implementation.
505 private ServerManagedObject<? extends RegularExpressionIdentityMapperCfg> impl;
506
507 // The value of the "enabled" property.
508 private final boolean pEnabled;
509
510 // The value of the "java-class" property.
511 private final String pJavaClass;
512
513 // The value of the "match-attribute" property.
514 private final SortedSet<AttributeType> pMatchAttribute;
515
516 // The value of the "match-base-dn" property.
517 private final SortedSet<DN> pMatchBaseDN;
518
519 // The value of the "match-pattern" property.
520 private final String pMatchPattern;
521
522 // The value of the "replace-pattern" property.
523 private final String pReplacePattern;
524
525
526
527 // Private constructor.
528 private RegularExpressionIdentityMapperCfgServerImpl(ServerManagedObject<? extends RegularExpressionIdentityMapperCfg> impl) {
529 this.impl = impl;
530 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
531 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
532 this.pMatchAttribute = impl.getPropertyValues(INSTANCE.getMatchAttributePropertyDefinition());
533 this.pMatchBaseDN = impl.getPropertyValues(INSTANCE.getMatchBaseDNPropertyDefinition());
534 this.pMatchPattern = impl.getPropertyValue(INSTANCE.getMatchPatternPropertyDefinition());
535 this.pReplacePattern = impl.getPropertyValue(INSTANCE.getReplacePatternPropertyDefinition());
536 }
537
538
539
540 /**
541 * {@inheritDoc}
542 */
543 public void addRegularExpressionChangeListener(
544 ConfigurationChangeListener<RegularExpressionIdentityMapperCfg> listener) {
545 impl.registerChangeListener(listener);
546 }
547
548
549
550 /**
551 * {@inheritDoc}
552 */
553 public void removeRegularExpressionChangeListener(
554 ConfigurationChangeListener<RegularExpressionIdentityMapperCfg> listener) {
555 impl.deregisterChangeListener(listener);
556 }
557 /**
558 * {@inheritDoc}
559 */
560 public void addChangeListener(
561 ConfigurationChangeListener<IdentityMapperCfg> listener) {
562 impl.registerChangeListener(listener);
563 }
564
565
566
567 /**
568 * {@inheritDoc}
569 */
570 public void removeChangeListener(
571 ConfigurationChangeListener<IdentityMapperCfg> listener) {
572 impl.deregisterChangeListener(listener);
573 }
574
575
576
577 /**
578 * {@inheritDoc}
579 */
580 public boolean isEnabled() {
581 return pEnabled;
582 }
583
584
585
586 /**
587 * {@inheritDoc}
588 */
589 public String getJavaClass() {
590 return pJavaClass;
591 }
592
593
594
595 /**
596 * {@inheritDoc}
597 */
598 public SortedSet<AttributeType> getMatchAttribute() {
599 return pMatchAttribute;
600 }
601
602
603
604 /**
605 * {@inheritDoc}
606 */
607 public SortedSet<DN> getMatchBaseDN() {
608 return pMatchBaseDN;
609 }
610
611
612
613 /**
614 * {@inheritDoc}
615 */
616 public String getMatchPattern() {
617 return pMatchPattern;
618 }
619
620
621
622 /**
623 * {@inheritDoc}
624 */
625 public String getReplacePattern() {
626 return pReplacePattern;
627 }
628
629
630
631 /**
632 * {@inheritDoc}
633 */
634 public Class<? extends RegularExpressionIdentityMapperCfg> configurationClass() {
635 return RegularExpressionIdentityMapperCfg.class;
636 }
637
638
639
640 /**
641 * {@inheritDoc}
642 */
643 public DN dn() {
644 return impl.getDN();
645 }
646
647 }
648 }