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.IntegerPropertyDefinition; 043 import org.opends.server.admin.ManagedObjectAlreadyExistsException; 044 import org.opends.server.admin.ManagedObjectDefinition; 045 import org.opends.server.admin.PropertyOption; 046 import org.opends.server.admin.PropertyProvider; 047 import org.opends.server.admin.server.ConfigurationChangeListener; 048 import org.opends.server.admin.server.ServerManagedObject; 049 import org.opends.server.admin.std.client.UniqueCharactersPasswordValidatorCfgClient; 050 import org.opends.server.admin.std.server.PasswordValidatorCfg; 051 import org.opends.server.admin.std.server.UniqueCharactersPasswordValidatorCfg; 052 import org.opends.server.admin.Tag; 053 import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 054 import org.opends.server.types.DN; 055 056 057 058 /** 059 * An interface for querying the Unique Characters Password Validator 060 * managed object definition meta information. 061 * <p> 062 * The Unique Characters Password Validator is used to determine 063 * whether a proposed password is acceptable based on the number of 064 * unique characters that it contains. 065 */ 066 public final class UniqueCharactersPasswordValidatorCfgDefn extends ManagedObjectDefinition<UniqueCharactersPasswordValidatorCfgClient, UniqueCharactersPasswordValidatorCfg> { 067 068 // The singleton configuration definition instance. 069 private static final UniqueCharactersPasswordValidatorCfgDefn INSTANCE = new UniqueCharactersPasswordValidatorCfgDefn(); 070 071 072 073 // The "case-sensitive-validation" property definition. 074 private static final BooleanPropertyDefinition PD_CASE_SENSITIVE_VALIDATION; 075 076 077 078 // The "java-class" property definition. 079 private static final ClassPropertyDefinition PD_JAVA_CLASS; 080 081 082 083 // The "min-unique-characters" property definition. 084 private static final IntegerPropertyDefinition PD_MIN_UNIQUE_CHARACTERS; 085 086 087 088 // Build the "case-sensitive-validation" property definition. 089 static { 090 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "case-sensitive-validation"); 091 builder.setOption(PropertyOption.MANDATORY); 092 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "case-sensitive-validation")); 093 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>()); 094 PD_CASE_SENSITIVE_VALIDATION = builder.getInstance(); 095 INSTANCE.registerPropertyDefinition(PD_CASE_SENSITIVE_VALIDATION); 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.UniqueCharactersPasswordValidator"); 107 builder.setDefaultBehaviorProvider(provider); 108 builder.addInstanceOf("org.opends.server.api.PasswordValidator"); 109 PD_JAVA_CLASS = builder.getInstance(); 110 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 111 } 112 113 114 115 // Build the "min-unique-characters" property definition. 116 static { 117 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "min-unique-characters"); 118 builder.setOption(PropertyOption.MANDATORY); 119 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "min-unique-characters")); 120 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 121 builder.setLowerLimit(0); 122 PD_MIN_UNIQUE_CHARACTERS = builder.getInstance(); 123 INSTANCE.registerPropertyDefinition(PD_MIN_UNIQUE_CHARACTERS); 124 } 125 126 127 128 // Register the tags associated with this managed object definition. 129 static { 130 INSTANCE.registerTag(Tag.valueOf("user-management")); 131 } 132 133 134 135 /** 136 * Get the Unique Characters Password Validator configuration 137 * definition singleton. 138 * 139 * @return Returns the Unique Characters Password Validator 140 * configuration definition singleton. 141 */ 142 public static UniqueCharactersPasswordValidatorCfgDefn getInstance() { 143 return INSTANCE; 144 } 145 146 147 148 /** 149 * Private constructor. 150 */ 151 private UniqueCharactersPasswordValidatorCfgDefn() { 152 super("unique-characters-password-validator", PasswordValidatorCfgDefn.getInstance()); 153 } 154 155 156 157 /** 158 * {@inheritDoc} 159 */ 160 public UniqueCharactersPasswordValidatorCfgClient createClientConfiguration( 161 ManagedObject<? extends UniqueCharactersPasswordValidatorCfgClient> impl) { 162 return new UniqueCharactersPasswordValidatorCfgClientImpl(impl); 163 } 164 165 166 167 /** 168 * {@inheritDoc} 169 */ 170 public UniqueCharactersPasswordValidatorCfg createServerConfiguration( 171 ServerManagedObject<? extends UniqueCharactersPasswordValidatorCfg> impl) { 172 return new UniqueCharactersPasswordValidatorCfgServerImpl(impl); 173 } 174 175 176 177 /** 178 * {@inheritDoc} 179 */ 180 public Class<UniqueCharactersPasswordValidatorCfg> getServerConfigurationClass() { 181 return UniqueCharactersPasswordValidatorCfg.class; 182 } 183 184 185 186 /** 187 * Get the "case-sensitive-validation" property definition. 188 * <p> 189 * Indicates whether this password validator should treat password 190 * characters in a case-sensitive manner. 191 * <p> 192 * A value of true indicates that the validator does not consider a 193 * capital letter to be the same as its lower-case counterpart. A 194 * value of false indicates that the validator ignores differences in 195 * capitalization when looking at the number of unique characters in 196 * the password. 197 * 198 * @return Returns the "case-sensitive-validation" property definition. 199 */ 200 public BooleanPropertyDefinition getCaseSensitiveValidationPropertyDefinition() { 201 return PD_CASE_SENSITIVE_VALIDATION; 202 } 203 204 205 206 /** 207 * Get the "enabled" property definition. 208 * <p> 209 * Indicates whether the password validator is enabled for use. 210 * 211 * @return Returns the "enabled" property definition. 212 */ 213 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 214 return PasswordValidatorCfgDefn.getInstance().getEnabledPropertyDefinition(); 215 } 216 217 218 219 /** 220 * Get the "java-class" property definition. 221 * <p> 222 * Specifies the fully-qualified name of the Java class that 223 * provides the password validator implementation. 224 * 225 * @return Returns the "java-class" property definition. 226 */ 227 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 228 return PD_JAVA_CLASS; 229 } 230 231 232 233 /** 234 * Get the "min-unique-characters" property definition. 235 * <p> 236 * Specifies the minimum number of unique characters that a password 237 * will be allowed to contain. 238 * <p> 239 * A value of zero indicates that no minimum value is enforced. 240 * 241 * @return Returns the "min-unique-characters" property definition. 242 */ 243 public IntegerPropertyDefinition getMinUniqueCharactersPropertyDefinition() { 244 return PD_MIN_UNIQUE_CHARACTERS; 245 } 246 247 248 249 /** 250 * Managed object client implementation. 251 */ 252 private static class UniqueCharactersPasswordValidatorCfgClientImpl implements 253 UniqueCharactersPasswordValidatorCfgClient { 254 255 // Private implementation. 256 private ManagedObject<? extends UniqueCharactersPasswordValidatorCfgClient> impl; 257 258 259 260 // Private constructor. 261 private UniqueCharactersPasswordValidatorCfgClientImpl( 262 ManagedObject<? extends UniqueCharactersPasswordValidatorCfgClient> impl) { 263 this.impl = impl; 264 } 265 266 267 268 /** 269 * {@inheritDoc} 270 */ 271 public Boolean isCaseSensitiveValidation() { 272 return impl.getPropertyValue(INSTANCE.getCaseSensitiveValidationPropertyDefinition()); 273 } 274 275 276 277 /** 278 * {@inheritDoc} 279 */ 280 public void setCaseSensitiveValidation(boolean value) { 281 impl.setPropertyValue(INSTANCE.getCaseSensitiveValidationPropertyDefinition(), value); 282 } 283 284 285 286 /** 287 * {@inheritDoc} 288 */ 289 public Boolean isEnabled() { 290 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 291 } 292 293 294 295 /** 296 * {@inheritDoc} 297 */ 298 public void setEnabled(boolean value) { 299 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 300 } 301 302 303 304 /** 305 * {@inheritDoc} 306 */ 307 public String getJavaClass() { 308 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 309 } 310 311 312 313 /** 314 * {@inheritDoc} 315 */ 316 public void setJavaClass(String value) { 317 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 318 } 319 320 321 322 /** 323 * {@inheritDoc} 324 */ 325 public Integer getMinUniqueCharacters() { 326 return impl.getPropertyValue(INSTANCE.getMinUniqueCharactersPropertyDefinition()); 327 } 328 329 330 331 /** 332 * {@inheritDoc} 333 */ 334 public void setMinUniqueCharacters(int value) { 335 impl.setPropertyValue(INSTANCE.getMinUniqueCharactersPropertyDefinition(), value); 336 } 337 338 339 340 /** 341 * {@inheritDoc} 342 */ 343 public ManagedObjectDefinition<? extends UniqueCharactersPasswordValidatorCfgClient, ? extends UniqueCharactersPasswordValidatorCfg> definition() { 344 return INSTANCE; 345 } 346 347 348 349 /** 350 * {@inheritDoc} 351 */ 352 public PropertyProvider properties() { 353 return impl; 354 } 355 356 357 358 /** 359 * {@inheritDoc} 360 */ 361 public void commit() throws ManagedObjectAlreadyExistsException, 362 MissingMandatoryPropertiesException, ConcurrentModificationException, 363 OperationRejectedException, AuthorizationException, 364 CommunicationException { 365 impl.commit(); 366 } 367 368 } 369 370 371 372 /** 373 * Managed object server implementation. 374 */ 375 private static class UniqueCharactersPasswordValidatorCfgServerImpl implements 376 UniqueCharactersPasswordValidatorCfg { 377 378 // Private implementation. 379 private ServerManagedObject<? extends UniqueCharactersPasswordValidatorCfg> impl; 380 381 // The value of the "case-sensitive-validation" property. 382 private final boolean pCaseSensitiveValidation; 383 384 // The value of the "enabled" property. 385 private final boolean pEnabled; 386 387 // The value of the "java-class" property. 388 private final String pJavaClass; 389 390 // The value of the "min-unique-characters" property. 391 private final int pMinUniqueCharacters; 392 393 394 395 // Private constructor. 396 private UniqueCharactersPasswordValidatorCfgServerImpl(ServerManagedObject<? extends UniqueCharactersPasswordValidatorCfg> impl) { 397 this.impl = impl; 398 this.pCaseSensitiveValidation = impl.getPropertyValue(INSTANCE.getCaseSensitiveValidationPropertyDefinition()); 399 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 400 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 401 this.pMinUniqueCharacters = impl.getPropertyValue(INSTANCE.getMinUniqueCharactersPropertyDefinition()); 402 } 403 404 405 406 /** 407 * {@inheritDoc} 408 */ 409 public void addUniqueCharactersChangeListener( 410 ConfigurationChangeListener<UniqueCharactersPasswordValidatorCfg> listener) { 411 impl.registerChangeListener(listener); 412 } 413 414 415 416 /** 417 * {@inheritDoc} 418 */ 419 public void removeUniqueCharactersChangeListener( 420 ConfigurationChangeListener<UniqueCharactersPasswordValidatorCfg> listener) { 421 impl.deregisterChangeListener(listener); 422 } 423 /** 424 * {@inheritDoc} 425 */ 426 public void addChangeListener( 427 ConfigurationChangeListener<PasswordValidatorCfg> listener) { 428 impl.registerChangeListener(listener); 429 } 430 431 432 433 /** 434 * {@inheritDoc} 435 */ 436 public void removeChangeListener( 437 ConfigurationChangeListener<PasswordValidatorCfg> listener) { 438 impl.deregisterChangeListener(listener); 439 } 440 441 442 443 /** 444 * {@inheritDoc} 445 */ 446 public boolean isCaseSensitiveValidation() { 447 return pCaseSensitiveValidation; 448 } 449 450 451 452 /** 453 * {@inheritDoc} 454 */ 455 public boolean isEnabled() { 456 return pEnabled; 457 } 458 459 460 461 /** 462 * {@inheritDoc} 463 */ 464 public String getJavaClass() { 465 return pJavaClass; 466 } 467 468 469 470 /** 471 * {@inheritDoc} 472 */ 473 public int getMinUniqueCharacters() { 474 return pMinUniqueCharacters; 475 } 476 477 478 479 /** 480 * {@inheritDoc} 481 */ 482 public Class<? extends UniqueCharactersPasswordValidatorCfg> configurationClass() { 483 return UniqueCharactersPasswordValidatorCfg.class; 484 } 485 486 487 488 /** 489 * {@inheritDoc} 490 */ 491 public DN dn() { 492 return impl.getDN(); 493 } 494 495 } 496 }