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.opends.server.admin.std.meta; 027 028 029 030import java.util.Collection; 031import java.util.SortedSet; 032import org.opends.server.admin.AdministratorAction; 033import org.opends.server.admin.BooleanPropertyDefinition; 034import org.opends.server.admin.ClassPropertyDefinition; 035import org.opends.server.admin.client.AuthorizationException; 036import org.opends.server.admin.client.CommunicationException; 037import org.opends.server.admin.client.ConcurrentModificationException; 038import org.opends.server.admin.client.ManagedObject; 039import org.opends.server.admin.client.MissingMandatoryPropertiesException; 040import org.opends.server.admin.client.OperationRejectedException; 041import org.opends.server.admin.DNPropertyDefinition; 042import org.opends.server.admin.EnumPropertyDefinition; 043import org.opends.server.admin.ManagedObjectAlreadyExistsException; 044import org.opends.server.admin.ManagedObjectDefinition; 045import org.opends.server.admin.PropertyException; 046import org.opends.server.admin.PropertyOption; 047import org.opends.server.admin.PropertyProvider; 048import org.opends.server.admin.server.ConfigurationChangeListener; 049import org.opends.server.admin.server.ServerManagedObject; 050import org.opends.server.admin.std.client.BackendCfgClient; 051import org.opends.server.admin.std.server.BackendCfg; 052import org.opends.server.admin.StringPropertyDefinition; 053import org.opends.server.admin.Tag; 054import org.opends.server.admin.TopCfgDefn; 055import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 056import org.opends.server.types.DN; 057 058 059 060/** 061 * An interface for querying the Backend managed object definition 062 * meta information. 063 * <p> 064 * Backends are responsible for providing access to the underlying 065 * data presented by the server. 066 */ 067public final class BackendCfgDefn extends ManagedObjectDefinition<BackendCfgClient, BackendCfg> { 068 069 // The singleton configuration definition instance. 070 private static final BackendCfgDefn INSTANCE = new BackendCfgDefn(); 071 072 073 074 /** 075 * Defines the set of permissable values for the "writability-mode" property. 076 * <p> 077 * Specifies the behavior that the backend should use when 078 * processing write operations. 079 */ 080 public static enum WritabilityMode { 081 082 /** 083 * Causes all write attempts to fail. 084 */ 085 DISABLED("disabled"), 086 087 088 089 /** 090 * Allows write operations to be performed in that backend (if the 091 * requested operation is valid, the user has permission to perform 092 * the operation, the backend supports that type of write 093 * operation, and the global writability-mode property is also 094 * enabled). 095 */ 096 ENABLED("enabled"), 097 098 099 100 /** 101 * Causes external write attempts to fail but allows writes by 102 * replication and internal operations. 103 */ 104 INTERNAL_ONLY("internal-only"); 105 106 107 108 // String representation of the value. 109 private final String name; 110 111 112 113 // Private constructor. 114 private WritabilityMode(String name) { this.name = name; } 115 116 117 118 /** 119 * {@inheritDoc} 120 */ 121 public String toString() { return name; } 122 123 } 124 125 126 127 // The "backend-id" property definition. 128 private static final StringPropertyDefinition PD_BACKEND_ID; 129 130 131 132 // The "base-dn" property definition. 133 private static final DNPropertyDefinition PD_BASE_DN; 134 135 136 137 // The "enabled" property definition. 138 private static final BooleanPropertyDefinition PD_ENABLED; 139 140 141 142 // The "java-class" property definition. 143 private static final ClassPropertyDefinition PD_JAVA_CLASS; 144 145 146 147 // The "writability-mode" property definition. 148 private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE; 149 150 151 152 // Build the "backend-id" property definition. 153 static { 154 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "backend-id"); 155 builder.setOption(PropertyOption.READ_ONLY); 156 builder.setOption(PropertyOption.MANDATORY); 157 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "backend-id")); 158 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 159 PD_BACKEND_ID = builder.getInstance(); 160 INSTANCE.registerPropertyDefinition(PD_BACKEND_ID); 161 } 162 163 164 165 // Build the "base-dn" property definition. 166 static { 167 DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "base-dn"); 168 builder.setOption(PropertyOption.MULTI_VALUED); 169 builder.setOption(PropertyOption.MANDATORY); 170 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "base-dn")); 171 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<DN>()); 172 PD_BASE_DN = builder.getInstance(); 173 INSTANCE.registerPropertyDefinition(PD_BASE_DN); 174 } 175 176 177 178 // Build the "enabled" property definition. 179 static { 180 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled"); 181 builder.setOption(PropertyOption.MANDATORY); 182 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled")); 183 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>()); 184 PD_ENABLED = builder.getInstance(); 185 INSTANCE.registerPropertyDefinition(PD_ENABLED); 186 } 187 188 189 190 // Build the "java-class" property definition. 191 static { 192 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class"); 193 builder.setOption(PropertyOption.MANDATORY); 194 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class")); 195 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 196 builder.addInstanceOf("org.opends.server.api.Backend"); 197 PD_JAVA_CLASS = builder.getInstance(); 198 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 199 } 200 201 202 203 // Build the "writability-mode" property definition. 204 static { 205 EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode"); 206 builder.setOption(PropertyOption.MANDATORY); 207 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode")); 208 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<WritabilityMode>()); 209 builder.setEnumClass(WritabilityMode.class); 210 PD_WRITABILITY_MODE = builder.getInstance(); 211 INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE); 212 } 213 214 215 216 // Register the tags associated with this managed object definition. 217 static { 218 INSTANCE.registerTag(Tag.valueOf("database")); 219 } 220 221 222 223 /** 224 * Get the Backend configuration definition singleton. 225 * 226 * @return Returns the Backend configuration definition singleton. 227 */ 228 public static BackendCfgDefn getInstance() { 229 return INSTANCE; 230 } 231 232 233 234 /** 235 * Private constructor. 236 */ 237 private BackendCfgDefn() { 238 super("backend", TopCfgDefn.getInstance()); 239 } 240 241 242 243 /** 244 * {@inheritDoc} 245 */ 246 public BackendCfgClient createClientConfiguration( 247 ManagedObject<? extends BackendCfgClient> impl) { 248 return new BackendCfgClientImpl(impl); 249 } 250 251 252 253 /** 254 * {@inheritDoc} 255 */ 256 public BackendCfg createServerConfiguration( 257 ServerManagedObject<? extends BackendCfg> impl) { 258 return new BackendCfgServerImpl(impl); 259 } 260 261 262 263 /** 264 * {@inheritDoc} 265 */ 266 public Class<BackendCfg> getServerConfigurationClass() { 267 return BackendCfg.class; 268 } 269 270 271 272 /** 273 * Get the "backend-id" property definition. 274 * <p> 275 * Specifies a name to identify the associated backend. 276 * <p> 277 * The name must be unique among all backends in the server. The 278 * backend ID may not be altered after the backend is created in the 279 * server. 280 * 281 * @return Returns the "backend-id" property definition. 282 */ 283 public StringPropertyDefinition getBackendIdPropertyDefinition() { 284 return PD_BACKEND_ID; 285 } 286 287 288 289 /** 290 * Get the "base-dn" property definition. 291 * <p> 292 * Specifies the base DN(s) for the data that the backend handles. 293 * <p> 294 * A single backend may be responsible for one or more base DNs. 295 * Note that no two backends may have the same base DN although one 296 * backend may have a base DN that is below a base DN provided by 297 * another backend (similar to the use of sub-suffixes in the Sun 298 * Java System Directory Server). If any of the base DNs is 299 * subordinate to a base DN for another backend, then all base DNs 300 * for that backend must be subordinate to that same base DN. 301 * 302 * @return Returns the "base-dn" property definition. 303 */ 304 public DNPropertyDefinition getBaseDNPropertyDefinition() { 305 return PD_BASE_DN; 306 } 307 308 309 310 /** 311 * Get the "enabled" property definition. 312 * <p> 313 * Indicates whether the backend is enabled in the server. 314 * <p> 315 * If a backend is not enabled, then its contents are not accessible 316 * when processing operations. 317 * 318 * @return Returns the "enabled" property definition. 319 */ 320 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 321 return PD_ENABLED; 322 } 323 324 325 326 /** 327 * Get the "java-class" property definition. 328 * <p> 329 * Specifies the fully-qualified name of the Java class that 330 * provides the backend implementation. 331 * 332 * @return Returns the "java-class" property definition. 333 */ 334 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 335 return PD_JAVA_CLASS; 336 } 337 338 339 340 /** 341 * Get the "writability-mode" property definition. 342 * <p> 343 * Specifies the behavior that the backend should use when 344 * processing write operations. 345 * 346 * @return Returns the "writability-mode" property definition. 347 */ 348 public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() { 349 return PD_WRITABILITY_MODE; 350 } 351 352 353 354 /** 355 * Managed object client implementation. 356 */ 357 private static class BackendCfgClientImpl implements 358 BackendCfgClient { 359 360 // Private implementation. 361 private ManagedObject<? extends BackendCfgClient> impl; 362 363 364 365 // Private constructor. 366 private BackendCfgClientImpl( 367 ManagedObject<? extends BackendCfgClient> impl) { 368 this.impl = impl; 369 } 370 371 372 373 /** 374 * {@inheritDoc} 375 */ 376 public String getBackendId() { 377 return impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition()); 378 } 379 380 381 382 /** 383 * {@inheritDoc} 384 */ 385 public void setBackendId(String value) throws PropertyException { 386 impl.setPropertyValue(INSTANCE.getBackendIdPropertyDefinition(), value); 387 } 388 389 390 391 /** 392 * {@inheritDoc} 393 */ 394 public SortedSet<DN> getBaseDN() { 395 return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition()); 396 } 397 398 399 400 /** 401 * {@inheritDoc} 402 */ 403 public void setBaseDN(Collection<DN> values) { 404 impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values); 405 } 406 407 408 409 /** 410 * {@inheritDoc} 411 */ 412 public Boolean isEnabled() { 413 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 414 } 415 416 417 418 /** 419 * {@inheritDoc} 420 */ 421 public void setEnabled(boolean value) { 422 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 423 } 424 425 426 427 /** 428 * {@inheritDoc} 429 */ 430 public String getJavaClass() { 431 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 432 } 433 434 435 436 /** 437 * {@inheritDoc} 438 */ 439 public void setJavaClass(String value) { 440 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 441 } 442 443 444 445 /** 446 * {@inheritDoc} 447 */ 448 public WritabilityMode getWritabilityMode() { 449 return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition()); 450 } 451 452 453 454 /** 455 * {@inheritDoc} 456 */ 457 public void setWritabilityMode(WritabilityMode value) { 458 impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value); 459 } 460 461 462 463 /** 464 * {@inheritDoc} 465 */ 466 public ManagedObjectDefinition<? extends BackendCfgClient, ? extends BackendCfg> definition() { 467 return INSTANCE; 468 } 469 470 471 472 /** 473 * {@inheritDoc} 474 */ 475 public PropertyProvider properties() { 476 return impl; 477 } 478 479 480 481 /** 482 * {@inheritDoc} 483 */ 484 public void commit() throws ManagedObjectAlreadyExistsException, 485 MissingMandatoryPropertiesException, ConcurrentModificationException, 486 OperationRejectedException, AuthorizationException, 487 CommunicationException { 488 impl.commit(); 489 } 490 491 } 492 493 494 495 /** 496 * Managed object server implementation. 497 */ 498 private static class BackendCfgServerImpl implements 499 BackendCfg { 500 501 // Private implementation. 502 private ServerManagedObject<? extends BackendCfg> impl; 503 504 // The value of the "backend-id" property. 505 private final String pBackendId; 506 507 // The value of the "base-dn" property. 508 private final SortedSet<DN> pBaseDN; 509 510 // The value of the "enabled" property. 511 private final boolean pEnabled; 512 513 // The value of the "java-class" property. 514 private final String pJavaClass; 515 516 // The value of the "writability-mode" property. 517 private final WritabilityMode pWritabilityMode; 518 519 520 521 // Private constructor. 522 private BackendCfgServerImpl(ServerManagedObject<? extends BackendCfg> impl) { 523 this.impl = impl; 524 this.pBackendId = impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition()); 525 this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition()); 526 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 527 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 528 this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition()); 529 } 530 531 532 533 /** 534 * {@inheritDoc} 535 */ 536 public void addChangeListener( 537 ConfigurationChangeListener<BackendCfg> listener) { 538 impl.registerChangeListener(listener); 539 } 540 541 542 543 /** 544 * {@inheritDoc} 545 */ 546 public void removeChangeListener( 547 ConfigurationChangeListener<BackendCfg> listener) { 548 impl.deregisterChangeListener(listener); 549 } 550 551 552 553 /** 554 * {@inheritDoc} 555 */ 556 public String getBackendId() { 557 return pBackendId; 558 } 559 560 561 562 /** 563 * {@inheritDoc} 564 */ 565 public SortedSet<DN> getBaseDN() { 566 return pBaseDN; 567 } 568 569 570 571 /** 572 * {@inheritDoc} 573 */ 574 public boolean isEnabled() { 575 return pEnabled; 576 } 577 578 579 580 /** 581 * {@inheritDoc} 582 */ 583 public String getJavaClass() { 584 return pJavaClass; 585 } 586 587 588 589 /** 590 * {@inheritDoc} 591 */ 592 public WritabilityMode getWritabilityMode() { 593 return pWritabilityMode; 594 } 595 596 597 598 /** 599 * {@inheritDoc} 600 */ 601 public Class<? extends BackendCfg> configurationClass() { 602 return BackendCfg.class; 603 } 604 605 606 607 /** 608 * {@inheritDoc} 609 */ 610 public DN dn() { 611 return impl.getDN(); 612 } 613 614 } 615}