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