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