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.DefaultBehaviorProvider;
043 import org.opends.server.admin.DefinedDefaultBehaviorProvider;
044 import org.opends.server.admin.DNPropertyDefinition;
045 import org.opends.server.admin.EnumPropertyDefinition;
046 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047 import org.opends.server.admin.ManagedObjectDefinition;
048 import org.opends.server.admin.PropertyIsReadOnlyException;
049 import org.opends.server.admin.PropertyOption;
050 import org.opends.server.admin.PropertyProvider;
051 import org.opends.server.admin.server.ConfigurationChangeListener;
052 import org.opends.server.admin.server.ServerManagedObject;
053 import org.opends.server.admin.std.client.LDIFBackendCfgClient;
054 import org.opends.server.admin.std.meta.BackendCfgDefn.WritabilityMode;
055 import org.opends.server.admin.std.server.BackendCfg;
056 import org.opends.server.admin.std.server.LDIFBackendCfg;
057 import org.opends.server.admin.StringPropertyDefinition;
058 import org.opends.server.admin.Tag;
059 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
060 import org.opends.server.types.DN;
061
062
063
064 /**
065 * An interface for querying the LDIF Backend managed object
066 * definition meta information.
067 * <p>
068 * The LDIF Backend provides a mechanism for interacting with data
069 * stored in an LDIF file.
070 */
071 public final class LDIFBackendCfgDefn extends ManagedObjectDefinition<LDIFBackendCfgClient, LDIFBackendCfg> {
072
073 // The singleton configuration definition instance.
074 private static final LDIFBackendCfgDefn INSTANCE = new LDIFBackendCfgDefn();
075
076
077
078 // The "is-private-backend" property definition.
079 private static final BooleanPropertyDefinition PD_IS_PRIVATE_BACKEND;
080
081
082
083 // The "java-class" property definition.
084 private static final ClassPropertyDefinition PD_JAVA_CLASS;
085
086
087
088 // The "ldif-file" property definition.
089 private static final StringPropertyDefinition PD_LDIF_FILE;
090
091
092
093 // The "writability-mode" property definition.
094 private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE;
095
096
097
098 // Build the "is-private-backend" property definition.
099 static {
100 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "is-private-backend");
101 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "is-private-backend"));
102 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
103 builder.setDefaultBehaviorProvider(provider);
104 PD_IS_PRIVATE_BACKEND = builder.getInstance();
105 INSTANCE.registerPropertyDefinition(PD_IS_PRIVATE_BACKEND);
106 }
107
108
109
110 // Build the "java-class" property definition.
111 static {
112 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
113 builder.setOption(PropertyOption.MANDATORY);
114 builder.setOption(PropertyOption.ADVANCED);
115 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
116 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.backends.LDIFBackend");
117 builder.setDefaultBehaviorProvider(provider);
118 builder.addInstanceOf("org.opends.server.api.Backend");
119 PD_JAVA_CLASS = builder.getInstance();
120 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
121 }
122
123
124
125 // Build the "ldif-file" property definition.
126 static {
127 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ldif-file");
128 builder.setOption(PropertyOption.MANDATORY);
129 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "ldif-file"));
130 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
131 PD_LDIF_FILE = builder.getInstance();
132 INSTANCE.registerPropertyDefinition(PD_LDIF_FILE);
133 }
134
135
136
137 // Build the "writability-mode" property definition.
138 static {
139 EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode");
140 builder.setOption(PropertyOption.MANDATORY);
141 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode"));
142 DefaultBehaviorProvider<WritabilityMode> provider = new DefinedDefaultBehaviorProvider<WritabilityMode>("enabled");
143 builder.setDefaultBehaviorProvider(provider);
144 builder.setEnumClass(WritabilityMode.class);
145 PD_WRITABILITY_MODE = builder.getInstance();
146 INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE);
147 }
148
149
150
151 // Register the tags associated with this managed object definition.
152 static {
153 INSTANCE.registerTag(Tag.valueOf("database"));
154 }
155
156
157
158 /**
159 * Get the LDIF Backend configuration definition singleton.
160 *
161 * @return Returns the LDIF Backend configuration definition
162 * singleton.
163 */
164 public static LDIFBackendCfgDefn getInstance() {
165 return INSTANCE;
166 }
167
168
169
170 /**
171 * Private constructor.
172 */
173 private LDIFBackendCfgDefn() {
174 super("ldif-backend", BackendCfgDefn.getInstance());
175 }
176
177
178
179 /**
180 * {@inheritDoc}
181 */
182 public LDIFBackendCfgClient createClientConfiguration(
183 ManagedObject<? extends LDIFBackendCfgClient> impl) {
184 return new LDIFBackendCfgClientImpl(impl);
185 }
186
187
188
189 /**
190 * {@inheritDoc}
191 */
192 public LDIFBackendCfg createServerConfiguration(
193 ServerManagedObject<? extends LDIFBackendCfg> impl) {
194 return new LDIFBackendCfgServerImpl(impl);
195 }
196
197
198
199 /**
200 * {@inheritDoc}
201 */
202 public Class<LDIFBackendCfg> getServerConfigurationClass() {
203 return LDIFBackendCfg.class;
204 }
205
206
207
208 /**
209 * Get the "backend-id" property definition.
210 * <p>
211 * Specifies a name to identify the associated backend.
212 * <p>
213 * The name must be unique among all backends in the server. The
214 * backend ID may not be altered after the backend is created in the
215 * server.
216 *
217 * @return Returns the "backend-id" property definition.
218 */
219 public StringPropertyDefinition getBackendIdPropertyDefinition() {
220 return BackendCfgDefn.getInstance().getBackendIdPropertyDefinition();
221 }
222
223
224
225 /**
226 * Get the "base-dn" property definition.
227 * <p>
228 * Specifies the base DN(s) for the data that the backend handles.
229 * <p>
230 * A single backend may be responsible for one or more base DNs.
231 * Note that no two backends may have the same base DN although one
232 * backend may have a base DN that is below a base DN provided by
233 * another backend (similar to the use of sub-suffixes in the Sun
234 * Java System Directory Server). If any of the base DNs is
235 * subordinate to a base DN for another backend, then all base DNs
236 * for that backend must be subordinate to that same base DN.
237 *
238 * @return Returns the "base-dn" property definition.
239 */
240 public DNPropertyDefinition getBaseDNPropertyDefinition() {
241 return BackendCfgDefn.getInstance().getBaseDNPropertyDefinition();
242 }
243
244
245
246 /**
247 * Get the "enabled" property definition.
248 * <p>
249 * Indicates whether the backend is enabled in the server.
250 * <p>
251 * If a backend is not enabled, then its contents are not accessible
252 * when processing operations.
253 *
254 * @return Returns the "enabled" property definition.
255 */
256 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
257 return BackendCfgDefn.getInstance().getEnabledPropertyDefinition();
258 }
259
260
261
262 /**
263 * Get the "is-private-backend" property definition.
264 * <p>
265 * Indicates whether the backend should be considered a private
266 * backend, which indicates that it is used for storing operational
267 * data rather than user-defined information.
268 *
269 * @return Returns the "is-private-backend" property definition.
270 */
271 public BooleanPropertyDefinition getIsPrivateBackendPropertyDefinition() {
272 return PD_IS_PRIVATE_BACKEND;
273 }
274
275
276
277 /**
278 * Get the "java-class" property definition.
279 * <p>
280 * Specifies the fully-qualified name of the Java class that
281 * provides the backend implementation.
282 *
283 * @return Returns the "java-class" property definition.
284 */
285 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
286 return PD_JAVA_CLASS;
287 }
288
289
290
291 /**
292 * Get the "ldif-file" property definition.
293 * <p>
294 * Specifies the path to the LDIF file containing the data for this
295 * backend.
296 *
297 * @return Returns the "ldif-file" property definition.
298 */
299 public StringPropertyDefinition getLDIFFilePropertyDefinition() {
300 return PD_LDIF_FILE;
301 }
302
303
304
305 /**
306 * Get the "writability-mode" property definition.
307 * <p>
308 * Specifies the behavior that the backend should use when
309 * processing write operations.
310 *
311 * @return Returns the "writability-mode" property definition.
312 */
313 public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() {
314 return PD_WRITABILITY_MODE;
315 }
316
317
318
319 /**
320 * Managed object client implementation.
321 */
322 private static class LDIFBackendCfgClientImpl implements
323 LDIFBackendCfgClient {
324
325 // Private implementation.
326 private ManagedObject<? extends LDIFBackendCfgClient> impl;
327
328
329
330 // Private constructor.
331 private LDIFBackendCfgClientImpl(
332 ManagedObject<? extends LDIFBackendCfgClient> impl) {
333 this.impl = impl;
334 }
335
336
337
338 /**
339 * {@inheritDoc}
340 */
341 public String getBackendId() {
342 return impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
343 }
344
345
346
347 /**
348 * {@inheritDoc}
349 */
350 public void setBackendId(String value) throws PropertyIsReadOnlyException {
351 impl.setPropertyValue(INSTANCE.getBackendIdPropertyDefinition(), value);
352 }
353
354
355
356 /**
357 * {@inheritDoc}
358 */
359 public SortedSet<DN> getBaseDN() {
360 return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
361 }
362
363
364
365 /**
366 * {@inheritDoc}
367 */
368 public void setBaseDN(Collection<DN> values) {
369 impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values);
370 }
371
372
373
374 /**
375 * {@inheritDoc}
376 */
377 public Boolean isEnabled() {
378 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
379 }
380
381
382
383 /**
384 * {@inheritDoc}
385 */
386 public void setEnabled(boolean value) {
387 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
388 }
389
390
391
392 /**
393 * {@inheritDoc}
394 */
395 public boolean isIsPrivateBackend() {
396 return impl.getPropertyValue(INSTANCE.getIsPrivateBackendPropertyDefinition());
397 }
398
399
400
401 /**
402 * {@inheritDoc}
403 */
404 public void setIsPrivateBackend(Boolean value) {
405 impl.setPropertyValue(INSTANCE.getIsPrivateBackendPropertyDefinition(), value);
406 }
407
408
409
410 /**
411 * {@inheritDoc}
412 */
413 public String getJavaClass() {
414 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
415 }
416
417
418
419 /**
420 * {@inheritDoc}
421 */
422 public void setJavaClass(String value) {
423 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
424 }
425
426
427
428 /**
429 * {@inheritDoc}
430 */
431 public String getLDIFFile() {
432 return impl.getPropertyValue(INSTANCE.getLDIFFilePropertyDefinition());
433 }
434
435
436
437 /**
438 * {@inheritDoc}
439 */
440 public void setLDIFFile(String value) {
441 impl.setPropertyValue(INSTANCE.getLDIFFilePropertyDefinition(), 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 LDIFBackendCfgClient, ? extends LDIFBackendCfg> 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 LDIFBackendCfgServerImpl implements
500 LDIFBackendCfg {
501
502 // Private implementation.
503 private ServerManagedObject<? extends LDIFBackendCfg> 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 "is-private-backend" property.
515 private final boolean pIsPrivateBackend;
516
517 // The value of the "java-class" property.
518 private final String pJavaClass;
519
520 // The value of the "ldif-file" property.
521 private final String pLDIFFile;
522
523 // The value of the "writability-mode" property.
524 private final WritabilityMode pWritabilityMode;
525
526
527
528 // Private constructor.
529 private LDIFBackendCfgServerImpl(ServerManagedObject<? extends LDIFBackendCfg> impl) {
530 this.impl = impl;
531 this.pBackendId = impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
532 this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
533 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
534 this.pIsPrivateBackend = impl.getPropertyValue(INSTANCE.getIsPrivateBackendPropertyDefinition());
535 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
536 this.pLDIFFile = impl.getPropertyValue(INSTANCE.getLDIFFilePropertyDefinition());
537 this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
538 }
539
540
541
542 /**
543 * {@inheritDoc}
544 */
545 public void addLDIFChangeListener(
546 ConfigurationChangeListener<LDIFBackendCfg> listener) {
547 impl.registerChangeListener(listener);
548 }
549
550
551
552 /**
553 * {@inheritDoc}
554 */
555 public void removeLDIFChangeListener(
556 ConfigurationChangeListener<LDIFBackendCfg> listener) {
557 impl.deregisterChangeListener(listener);
558 }
559 /**
560 * {@inheritDoc}
561 */
562 public void addChangeListener(
563 ConfigurationChangeListener<BackendCfg> listener) {
564 impl.registerChangeListener(listener);
565 }
566
567
568
569 /**
570 * {@inheritDoc}
571 */
572 public void removeChangeListener(
573 ConfigurationChangeListener<BackendCfg> listener) {
574 impl.deregisterChangeListener(listener);
575 }
576
577
578
579 /**
580 * {@inheritDoc}
581 */
582 public String getBackendId() {
583 return pBackendId;
584 }
585
586
587
588 /**
589 * {@inheritDoc}
590 */
591 public SortedSet<DN> getBaseDN() {
592 return pBaseDN;
593 }
594
595
596
597 /**
598 * {@inheritDoc}
599 */
600 public boolean isEnabled() {
601 return pEnabled;
602 }
603
604
605
606 /**
607 * {@inheritDoc}
608 */
609 public boolean isIsPrivateBackend() {
610 return pIsPrivateBackend;
611 }
612
613
614
615 /**
616 * {@inheritDoc}
617 */
618 public String getJavaClass() {
619 return pJavaClass;
620 }
621
622
623
624 /**
625 * {@inheritDoc}
626 */
627 public String getLDIFFile() {
628 return pLDIFFile;
629 }
630
631
632
633 /**
634 * {@inheritDoc}
635 */
636 public WritabilityMode getWritabilityMode() {
637 return pWritabilityMode;
638 }
639
640
641
642 /**
643 * {@inheritDoc}
644 */
645 public Class<? extends LDIFBackendCfg> configurationClass() {
646 return LDIFBackendCfg.class;
647 }
648
649
650
651 /**
652 * {@inheritDoc}
653 */
654 public DN dn() {
655 return impl.getDN();
656 }
657
658 }
659 }