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.AttributeTypePropertyDefinition; 035 import org.opends.server.admin.client.AuthorizationException; 036 import org.opends.server.admin.client.CommunicationException; 037 import org.opends.server.admin.client.ConcurrentModificationException; 038 import org.opends.server.admin.client.ManagedObject; 039 import org.opends.server.admin.client.MissingMandatoryPropertiesException; 040 import org.opends.server.admin.client.OperationRejectedException; 041 import org.opends.server.admin.DefaultBehaviorProvider; 042 import org.opends.server.admin.DefinedDefaultBehaviorProvider; 043 import org.opends.server.admin.EnumPropertyDefinition; 044 import org.opends.server.admin.IntegerPropertyDefinition; 045 import org.opends.server.admin.ManagedObjectAlreadyExistsException; 046 import org.opends.server.admin.ManagedObjectDefinition; 047 import org.opends.server.admin.PropertyIsReadOnlyException; 048 import org.opends.server.admin.PropertyOption; 049 import org.opends.server.admin.PropertyProvider; 050 import org.opends.server.admin.RelativeInheritedDefaultBehaviorProvider; 051 import org.opends.server.admin.server.ConfigurationChangeListener; 052 import org.opends.server.admin.server.ServerManagedObject; 053 import org.opends.server.admin.std.client.LocalDBIndexCfgClient; 054 import org.opends.server.admin.std.server.LocalDBIndexCfg; 055 import org.opends.server.admin.Tag; 056 import org.opends.server.admin.TopCfgDefn; 057 import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 058 import org.opends.server.types.AttributeType; 059 import org.opends.server.types.DN; 060 061 062 063 /** 064 * An interface for querying the Local DB Index managed object 065 * definition meta information. 066 * <p> 067 * Local DB Indexes are used to store information that makes it 068 * possible to locate entries very quickly when processing search 069 * operations. 070 */ 071 public final class LocalDBIndexCfgDefn extends ManagedObjectDefinition<LocalDBIndexCfgClient, LocalDBIndexCfg> { 072 073 // The singleton configuration definition instance. 074 private static final LocalDBIndexCfgDefn INSTANCE = new LocalDBIndexCfgDefn(); 075 076 077 078 /** 079 * Defines the set of permissable values for the "index-type" property. 080 * <p> 081 * Specifies the type(s) of indexing that should be performed for 082 * the associated attribute. 083 * <p> 084 * For equality, presence, and substring index types, the associated 085 * attribute type must have a corresponding matching rule. 086 */ 087 public static enum IndexType { 088 089 /** 090 * This index type is used to improve the efficiency of searches 091 * using approximate matching search filters. 092 */ 093 APPROXIMATE("approximate"), 094 095 096 097 /** 098 * This index type is used to improve the efficiency of searches 099 * using equality search filters. 100 */ 101 EQUALITY("equality"), 102 103 104 105 /** 106 * This index type is used to improve the efficiency of searches 107 * using "greater than or equal to" or "less then or equal to" 108 * search filters. 109 */ 110 ORDERING("ordering"), 111 112 113 114 /** 115 * This index type is used to improve the efficiency of searches 116 * using the presence search filters. 117 */ 118 PRESENCE("presence"), 119 120 121 122 /** 123 * This index type is used to improve the efficiency of searches 124 * using substring search filters. 125 */ 126 SUBSTRING("substring"); 127 128 129 130 // String representation of the value. 131 private final String name; 132 133 134 135 // Private constructor. 136 private IndexType(String name) { this.name = name; } 137 138 139 140 /** 141 * {@inheritDoc} 142 */ 143 public String toString() { return name; } 144 145 } 146 147 148 149 // The "attribute" property definition. 150 private static final AttributeTypePropertyDefinition PD_ATTRIBUTE; 151 152 153 154 // The "index-entry-limit" property definition. 155 private static final IntegerPropertyDefinition PD_INDEX_ENTRY_LIMIT; 156 157 158 159 // The "index-type" property definition. 160 private static final EnumPropertyDefinition<IndexType> PD_INDEX_TYPE; 161 162 163 164 // The "substring-length" property definition. 165 private static final IntegerPropertyDefinition PD_SUBSTRING_LENGTH; 166 167 168 169 // Build the "attribute" property definition. 170 static { 171 AttributeTypePropertyDefinition.Builder builder = AttributeTypePropertyDefinition.createBuilder(INSTANCE, "attribute"); 172 builder.setOption(PropertyOption.READ_ONLY); 173 builder.setOption(PropertyOption.MANDATORY); 174 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "attribute")); 175 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<AttributeType>()); 176 PD_ATTRIBUTE = builder.getInstance(); 177 INSTANCE.registerPropertyDefinition(PD_ATTRIBUTE); 178 } 179 180 181 182 // Build the "index-entry-limit" property definition. 183 static { 184 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "index-entry-limit"); 185 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "index-entry-limit")); 186 DefaultBehaviorProvider<Integer> provider = new RelativeInheritedDefaultBehaviorProvider<Integer>(LocalDBBackendCfgDefn.getInstance(), "index-entry-limit", 1); 187 builder.setDefaultBehaviorProvider(provider); 188 builder.setUpperLimit(2147483647); 189 builder.setLowerLimit(0); 190 PD_INDEX_ENTRY_LIMIT = builder.getInstance(); 191 INSTANCE.registerPropertyDefinition(PD_INDEX_ENTRY_LIMIT); 192 } 193 194 195 196 // Build the "index-type" property definition. 197 static { 198 EnumPropertyDefinition.Builder<IndexType> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "index-type"); 199 builder.setOption(PropertyOption.MULTI_VALUED); 200 builder.setOption(PropertyOption.MANDATORY); 201 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "index-type")); 202 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<IndexType>()); 203 builder.setEnumClass(IndexType.class); 204 PD_INDEX_TYPE = builder.getInstance(); 205 INSTANCE.registerPropertyDefinition(PD_INDEX_TYPE); 206 } 207 208 209 210 // Build the "substring-length" property definition. 211 static { 212 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "substring-length"); 213 builder.setOption(PropertyOption.ADVANCED); 214 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "substring-length")); 215 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("6"); 216 builder.setDefaultBehaviorProvider(provider); 217 builder.setLowerLimit(3); 218 PD_SUBSTRING_LENGTH = builder.getInstance(); 219 INSTANCE.registerPropertyDefinition(PD_SUBSTRING_LENGTH); 220 } 221 222 223 224 // Register the tags associated with this managed object definition. 225 static { 226 INSTANCE.registerTag(Tag.valueOf("database")); 227 } 228 229 230 231 /** 232 * Get the Local DB Index configuration definition singleton. 233 * 234 * @return Returns the Local DB Index configuration definition 235 * singleton. 236 */ 237 public static LocalDBIndexCfgDefn getInstance() { 238 return INSTANCE; 239 } 240 241 242 243 /** 244 * Private constructor. 245 */ 246 private LocalDBIndexCfgDefn() { 247 super("local-db-index", TopCfgDefn.getInstance()); 248 } 249 250 251 252 /** 253 * {@inheritDoc} 254 */ 255 public LocalDBIndexCfgClient createClientConfiguration( 256 ManagedObject<? extends LocalDBIndexCfgClient> impl) { 257 return new LocalDBIndexCfgClientImpl(impl); 258 } 259 260 261 262 /** 263 * {@inheritDoc} 264 */ 265 public LocalDBIndexCfg createServerConfiguration( 266 ServerManagedObject<? extends LocalDBIndexCfg> impl) { 267 return new LocalDBIndexCfgServerImpl(impl); 268 } 269 270 271 272 /** 273 * {@inheritDoc} 274 */ 275 public Class<LocalDBIndexCfg> getServerConfigurationClass() { 276 return LocalDBIndexCfg.class; 277 } 278 279 280 281 /** 282 * Get the "attribute" property definition. 283 * <p> 284 * Specifies the name of the attribute for which the index is to be 285 * maintained. 286 * 287 * @return Returns the "attribute" property definition. 288 */ 289 public AttributeTypePropertyDefinition getAttributePropertyDefinition() { 290 return PD_ATTRIBUTE; 291 } 292 293 294 295 /** 296 * Get the "index-entry-limit" property definition. 297 * <p> 298 * Specifies the maximum number of entries that are allowed to match 299 * a given index key before that particular index key is no longer 300 * maintained. 301 * <p> 302 * This is analogous to the ALL IDs threshold in the Sun Java System 303 * Directory Server. If this is specified, its value overrides the JE 304 * backend-wide configuration. For no limit, use 0 for the value. 305 * 306 * @return Returns the "index-entry-limit" property definition. 307 */ 308 public IntegerPropertyDefinition getIndexEntryLimitPropertyDefinition() { 309 return PD_INDEX_ENTRY_LIMIT; 310 } 311 312 313 314 /** 315 * Get the "index-type" property definition. 316 * <p> 317 * Specifies the type(s) of indexing that should be performed for 318 * the associated attribute. 319 * <p> 320 * For equality, presence, and substring index types, the associated 321 * attribute type must have a corresponding matching rule. 322 * 323 * @return Returns the "index-type" property definition. 324 */ 325 public EnumPropertyDefinition<IndexType> getIndexTypePropertyDefinition() { 326 return PD_INDEX_TYPE; 327 } 328 329 330 331 /** 332 * Get the "substring-length" property definition. 333 * <p> 334 * The length of substrings in a substring index. 335 * 336 * @return Returns the "substring-length" property definition. 337 */ 338 public IntegerPropertyDefinition getSubstringLengthPropertyDefinition() { 339 return PD_SUBSTRING_LENGTH; 340 } 341 342 343 344 /** 345 * Managed object client implementation. 346 */ 347 private static class LocalDBIndexCfgClientImpl implements 348 LocalDBIndexCfgClient { 349 350 // Private implementation. 351 private ManagedObject<? extends LocalDBIndexCfgClient> impl; 352 353 354 355 // Private constructor. 356 private LocalDBIndexCfgClientImpl( 357 ManagedObject<? extends LocalDBIndexCfgClient> impl) { 358 this.impl = impl; 359 } 360 361 362 363 /** 364 * {@inheritDoc} 365 */ 366 public AttributeType getAttribute() { 367 return impl.getPropertyValue(INSTANCE.getAttributePropertyDefinition()); 368 } 369 370 371 372 /** 373 * {@inheritDoc} 374 */ 375 public void setAttribute(AttributeType value) throws PropertyIsReadOnlyException { 376 impl.setPropertyValue(INSTANCE.getAttributePropertyDefinition(), value); 377 } 378 379 380 381 /** 382 * {@inheritDoc} 383 */ 384 public Integer getIndexEntryLimit() { 385 return impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition()); 386 } 387 388 389 390 /** 391 * {@inheritDoc} 392 */ 393 public void setIndexEntryLimit(Integer value) { 394 impl.setPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition(), value); 395 } 396 397 398 399 /** 400 * {@inheritDoc} 401 */ 402 public SortedSet<IndexType> getIndexType() { 403 return impl.getPropertyValues(INSTANCE.getIndexTypePropertyDefinition()); 404 } 405 406 407 408 /** 409 * {@inheritDoc} 410 */ 411 public void setIndexType(Collection<IndexType> values) { 412 impl.setPropertyValues(INSTANCE.getIndexTypePropertyDefinition(), values); 413 } 414 415 416 417 /** 418 * {@inheritDoc} 419 */ 420 public int getSubstringLength() { 421 return impl.getPropertyValue(INSTANCE.getSubstringLengthPropertyDefinition()); 422 } 423 424 425 426 /** 427 * {@inheritDoc} 428 */ 429 public void setSubstringLength(Integer value) { 430 impl.setPropertyValue(INSTANCE.getSubstringLengthPropertyDefinition(), value); 431 } 432 433 434 435 /** 436 * {@inheritDoc} 437 */ 438 public ManagedObjectDefinition<? extends LocalDBIndexCfgClient, ? extends LocalDBIndexCfg> definition() { 439 return INSTANCE; 440 } 441 442 443 444 /** 445 * {@inheritDoc} 446 */ 447 public PropertyProvider properties() { 448 return impl; 449 } 450 451 452 453 /** 454 * {@inheritDoc} 455 */ 456 public void commit() throws ManagedObjectAlreadyExistsException, 457 MissingMandatoryPropertiesException, ConcurrentModificationException, 458 OperationRejectedException, AuthorizationException, 459 CommunicationException { 460 impl.commit(); 461 } 462 463 } 464 465 466 467 /** 468 * Managed object server implementation. 469 */ 470 private static class LocalDBIndexCfgServerImpl implements 471 LocalDBIndexCfg { 472 473 // Private implementation. 474 private ServerManagedObject<? extends LocalDBIndexCfg> impl; 475 476 // The value of the "attribute" property. 477 private final AttributeType pAttribute; 478 479 // The value of the "index-entry-limit" property. 480 private final Integer pIndexEntryLimit; 481 482 // The value of the "index-type" property. 483 private final SortedSet<IndexType> pIndexType; 484 485 // The value of the "substring-length" property. 486 private final int pSubstringLength; 487 488 489 490 // Private constructor. 491 private LocalDBIndexCfgServerImpl(ServerManagedObject<? extends LocalDBIndexCfg> impl) { 492 this.impl = impl; 493 this.pAttribute = impl.getPropertyValue(INSTANCE.getAttributePropertyDefinition()); 494 this.pIndexEntryLimit = impl.getPropertyValue(INSTANCE.getIndexEntryLimitPropertyDefinition()); 495 this.pIndexType = impl.getPropertyValues(INSTANCE.getIndexTypePropertyDefinition()); 496 this.pSubstringLength = impl.getPropertyValue(INSTANCE.getSubstringLengthPropertyDefinition()); 497 } 498 499 500 501 /** 502 * {@inheritDoc} 503 */ 504 public void addChangeListener( 505 ConfigurationChangeListener<LocalDBIndexCfg> listener) { 506 impl.registerChangeListener(listener); 507 } 508 509 510 511 /** 512 * {@inheritDoc} 513 */ 514 public void removeChangeListener( 515 ConfigurationChangeListener<LocalDBIndexCfg> listener) { 516 impl.deregisterChangeListener(listener); 517 } 518 519 520 521 /** 522 * {@inheritDoc} 523 */ 524 public AttributeType getAttribute() { 525 return pAttribute; 526 } 527 528 529 530 /** 531 * {@inheritDoc} 532 */ 533 public Integer getIndexEntryLimit() { 534 return pIndexEntryLimit; 535 } 536 537 538 539 /** 540 * {@inheritDoc} 541 */ 542 public SortedSet<IndexType> getIndexType() { 543 return pIndexType; 544 } 545 546 547 548 /** 549 * {@inheritDoc} 550 */ 551 public int getSubstringLength() { 552 return pSubstringLength; 553 } 554 555 556 557 /** 558 * {@inheritDoc} 559 */ 560 public Class<? extends LocalDBIndexCfg> configurationClass() { 561 return LocalDBIndexCfg.class; 562 } 563 564 565 566 /** 567 * {@inheritDoc} 568 */ 569 public DN dn() { 570 return impl.getDN(); 571 } 572 573 } 574 }