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 legal-notices/CDDLv1_0.txt
010 * or http://forgerock.org/license/CDDLv1.0.html.
011 * See the License for the specific language governing permissions
012 * and limitations under the License.
013 *
014 * When distributing Covered Code, include this CDDL HEADER in each
015 * file and include the License file at legal-notices/CDDLv1_0.txt.
016 * If applicable, add the following below this CDDL HEADER, with the
017 * fields enclosed by brackets "[]" replaced with your own identifying
018 * information:
019 *      Portions Copyright [yyyy] [name of copyright owner]
020 *
021 * CDDL HEADER END
022 *
023 *
024 *      Copyright 2008 Sun Microsystems, Inc.
025 */
026package org.forgerock.opendj.server.config.meta;
027
028
029
030import org.forgerock.opendj.config.AdministratorAction;
031import org.forgerock.opendj.config.AggregationPropertyDefinition;
032import org.forgerock.opendj.config.BooleanPropertyDefinition;
033import org.forgerock.opendj.config.ClassPropertyDefinition;
034import org.forgerock.opendj.config.client.ConcurrentModificationException;
035import org.forgerock.opendj.config.client.ManagedObject;
036import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
037import org.forgerock.opendj.config.client.OperationRejectedException;
038import org.forgerock.opendj.config.conditions.Conditions;
039import org.forgerock.opendj.config.DefaultBehaviorProvider;
040import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
041import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
042import org.forgerock.opendj.config.ManagedObjectDefinition;
043import org.forgerock.opendj.config.PropertyOption;
044import org.forgerock.opendj.config.PropertyProvider;
045import org.forgerock.opendj.config.server.ConfigurationChangeListener;
046import org.forgerock.opendj.config.server.ServerManagedObject;
047import org.forgerock.opendj.config.Tag;
048import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider;
049import org.forgerock.opendj.ldap.DN;
050import org.forgerock.opendj.ldap.LdapException;
051import org.forgerock.opendj.server.config.client.IdentityMapperCfgClient;
052import org.forgerock.opendj.server.config.client.PlainSASLMechanismHandlerCfgClient;
053import org.forgerock.opendj.server.config.server.IdentityMapperCfg;
054import org.forgerock.opendj.server.config.server.PlainSASLMechanismHandlerCfg;
055import org.forgerock.opendj.server.config.server.SASLMechanismHandlerCfg;
056
057
058
059/**
060 * An interface for querying the Plain SASL Mechanism Handler managed
061 * object definition meta information.
062 * <p>
063 * The Plain SASL Mechanism Handler performs all processing related to
064 * SASL PLAIN authentication.
065 */
066public final class PlainSASLMechanismHandlerCfgDefn extends ManagedObjectDefinition<PlainSASLMechanismHandlerCfgClient, PlainSASLMechanismHandlerCfg> {
067
068  /** The singleton configuration definition instance. */
069  private static final PlainSASLMechanismHandlerCfgDefn INSTANCE = new PlainSASLMechanismHandlerCfgDefn();
070
071
072
073  /** The "identity-mapper" property definition. */
074  private static final AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> PD_IDENTITY_MAPPER;
075
076
077
078  /** The "java-class" property definition. */
079  private static final ClassPropertyDefinition PD_JAVA_CLASS;
080
081
082
083  /** Build the "identity-mapper" property definition. */
084  static {
085      AggregationPropertyDefinition.Builder<IdentityMapperCfgClient, IdentityMapperCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "identity-mapper");
086      builder.setOption(PropertyOption.MANDATORY);
087      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "identity-mapper"));
088      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
089      builder.setParentPath("/");
090      builder.setRelationDefinition("identity-mapper");
091      builder.setTargetNeedsEnablingCondition(Conditions.contains("enabled", "true"));
092      builder.setTargetIsEnabledCondition(Conditions.contains("enabled", "true"));
093      PD_IDENTITY_MAPPER = builder.getInstance();
094      INSTANCE.registerPropertyDefinition(PD_IDENTITY_MAPPER);
095      INSTANCE.registerConstraint(PD_IDENTITY_MAPPER.getSourceConstraint());
096  }
097
098
099
100  /** Build the "java-class" property definition. */
101  static {
102      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
103      builder.setOption(PropertyOption.MANDATORY);
104      builder.setOption(PropertyOption.ADVANCED);
105      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
106      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.PlainSASLMechanismHandler");
107      builder.setDefaultBehaviorProvider(provider);
108      builder.addInstanceOf("org.opends.server.api.SASLMechanismHandler");
109      PD_JAVA_CLASS = builder.getInstance();
110      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
111  }
112
113
114
115  // Register the tags associated with this managed object definition.
116  static {
117    INSTANCE.registerTag(Tag.valueOf("security"));
118  }
119
120
121
122  /**
123   * Get the Plain SASL Mechanism Handler configuration definition
124   * singleton.
125   *
126   * @return Returns the Plain SASL Mechanism Handler configuration
127   *         definition singleton.
128   */
129  public static PlainSASLMechanismHandlerCfgDefn getInstance() {
130    return INSTANCE;
131  }
132
133
134
135  /**
136   * Private constructor.
137   */
138  private PlainSASLMechanismHandlerCfgDefn() {
139    super("plain-sasl-mechanism-handler", SASLMechanismHandlerCfgDefn.getInstance());
140  }
141
142
143
144  /** {@inheritDoc} */
145  public PlainSASLMechanismHandlerCfgClient createClientConfiguration(
146      ManagedObject<? extends PlainSASLMechanismHandlerCfgClient> impl) {
147    return new PlainSASLMechanismHandlerCfgClientImpl(impl);
148  }
149
150
151
152  /** {@inheritDoc} */
153  public PlainSASLMechanismHandlerCfg createServerConfiguration(
154      ServerManagedObject<? extends PlainSASLMechanismHandlerCfg> impl) {
155    return new PlainSASLMechanismHandlerCfgServerImpl(impl);
156  }
157
158
159
160  /** {@inheritDoc} */
161  public Class<PlainSASLMechanismHandlerCfg> getServerConfigurationClass() {
162    return PlainSASLMechanismHandlerCfg.class;
163  }
164
165
166
167  /**
168   * Get the "enabled" property definition.
169   * <p>
170   * Indicates whether the SASL mechanism handler is enabled for use.
171   *
172   * @return Returns the "enabled" property definition.
173   */
174  public BooleanPropertyDefinition getEnabledPropertyDefinition() {
175    return SASLMechanismHandlerCfgDefn.getInstance().getEnabledPropertyDefinition();
176  }
177
178
179
180  /**
181   * Get the "identity-mapper" property definition.
182   * <p>
183   * Specifies the name of the identity mapper that is to be used with
184   * this SASL mechanism handler to match the authentication or
185   * authorization ID included in the SASL bind request to the
186   * corresponding user in the directory.
187   *
188   * @return Returns the "identity-mapper" property definition.
189   */
190  public AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> getIdentityMapperPropertyDefinition() {
191    return PD_IDENTITY_MAPPER;
192  }
193
194
195
196  /**
197   * Get the "java-class" property definition.
198   * <p>
199   * Specifies the fully-qualified name of the Java class that
200   * provides the SASL mechanism handler implementation.
201   *
202   * @return Returns the "java-class" property definition.
203   */
204  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
205    return PD_JAVA_CLASS;
206  }
207
208
209
210  /**
211   * Managed object client implementation.
212   */
213  private static class PlainSASLMechanismHandlerCfgClientImpl implements
214    PlainSASLMechanismHandlerCfgClient {
215
216    /** Private implementation. */
217    private ManagedObject<? extends PlainSASLMechanismHandlerCfgClient> impl;
218
219
220
221    /** Private constructor. */
222    private PlainSASLMechanismHandlerCfgClientImpl(
223        ManagedObject<? extends PlainSASLMechanismHandlerCfgClient> impl) {
224      this.impl = impl;
225    }
226
227
228
229    /** {@inheritDoc} */
230    public Boolean isEnabled() {
231      return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
232    }
233
234
235
236    /** {@inheritDoc} */
237    public void setEnabled(boolean value) {
238      impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
239    }
240
241
242
243    /** {@inheritDoc} */
244    public String getIdentityMapper() {
245      return impl.getPropertyValue(INSTANCE.getIdentityMapperPropertyDefinition());
246    }
247
248
249
250    /** {@inheritDoc} */
251    public void setIdentityMapper(String value) {
252      impl.setPropertyValue(INSTANCE.getIdentityMapperPropertyDefinition(), value);
253    }
254
255
256
257    /** {@inheritDoc} */
258    public String getJavaClass() {
259      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
260    }
261
262
263
264    /** {@inheritDoc} */
265    public void setJavaClass(String value) {
266      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
267    }
268
269
270
271    /** {@inheritDoc} */
272    public ManagedObjectDefinition<? extends PlainSASLMechanismHandlerCfgClient, ? extends PlainSASLMechanismHandlerCfg> definition() {
273      return INSTANCE;
274    }
275
276
277
278    /** {@inheritDoc} */
279    public PropertyProvider properties() {
280      return impl;
281    }
282
283
284
285    /** {@inheritDoc} */
286    public void commit() throws ManagedObjectAlreadyExistsException,
287        MissingMandatoryPropertiesException, ConcurrentModificationException,
288        OperationRejectedException, LdapException {
289      impl.commit();
290    }
291
292
293
294    /** {@inheritDoc} */
295    public String toString() {
296      return impl.toString();
297    }
298  }
299
300
301
302  /**
303   * Managed object server implementation.
304   */
305  private static class PlainSASLMechanismHandlerCfgServerImpl implements
306    PlainSASLMechanismHandlerCfg {
307
308    /** Private implementation. */
309    private ServerManagedObject<? extends PlainSASLMechanismHandlerCfg> impl;
310
311    /** The value of the "enabled" property. */
312    private final boolean pEnabled;
313
314    /** The value of the "identity-mapper" property. */
315    private final String pIdentityMapper;
316
317    /** The value of the "java-class" property. */
318    private final String pJavaClass;
319
320
321
322    /** Private constructor. */
323    private PlainSASLMechanismHandlerCfgServerImpl(ServerManagedObject<? extends PlainSASLMechanismHandlerCfg> impl) {
324      this.impl = impl;
325      this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
326      this.pIdentityMapper = impl.getPropertyValue(INSTANCE.getIdentityMapperPropertyDefinition());
327      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
328    }
329
330
331
332    /** {@inheritDoc} */
333    public void addPlainChangeListener(
334        ConfigurationChangeListener<PlainSASLMechanismHandlerCfg> listener) {
335      impl.registerChangeListener(listener);
336    }
337
338
339
340    /** {@inheritDoc} */
341    public void removePlainChangeListener(
342        ConfigurationChangeListener<PlainSASLMechanismHandlerCfg> listener) {
343      impl.deregisterChangeListener(listener);
344    }
345    /** {@inheritDoc} */
346    public void addChangeListener(
347        ConfigurationChangeListener<SASLMechanismHandlerCfg> listener) {
348      impl.registerChangeListener(listener);
349    }
350
351
352
353    /** {@inheritDoc} */
354    public void removeChangeListener(
355        ConfigurationChangeListener<SASLMechanismHandlerCfg> listener) {
356      impl.deregisterChangeListener(listener);
357    }
358
359
360
361    /** {@inheritDoc} */
362    public boolean isEnabled() {
363      return pEnabled;
364    }
365
366
367
368    /** {@inheritDoc} */
369    public String getIdentityMapper() {
370      return pIdentityMapper;
371    }
372
373
374
375    /**
376     * {@inheritDoc}
377     */
378    public DN getIdentityMapperDN() {
379      String value = getIdentityMapper();
380      if (value == null) return null;
381      return INSTANCE.getIdentityMapperPropertyDefinition().getChildDN(value);
382    }
383
384
385
386    /** {@inheritDoc} */
387    public String getJavaClass() {
388      return pJavaClass;
389    }
390
391
392
393    /** {@inheritDoc} */
394    public Class<? extends PlainSASLMechanismHandlerCfg> configurationClass() {
395      return PlainSASLMechanismHandlerCfg.class;
396    }
397
398
399
400    /** {@inheritDoc} */
401    public DN dn() {
402      return impl.getDN();
403    }
404
405
406
407    /** {@inheritDoc} */
408    public String toString() {
409      return impl.toString();
410    }
411  }
412}