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 org.opends.server.admin.AdministratorAction;
032 import org.opends.server.admin.BooleanPropertyDefinition;
033 import org.opends.server.admin.ClassPropertyDefinition;
034 import org.opends.server.admin.client.AuthorizationException;
035 import org.opends.server.admin.client.CommunicationException;
036 import org.opends.server.admin.client.ConcurrentModificationException;
037 import org.opends.server.admin.client.ManagedObject;
038 import org.opends.server.admin.client.MissingMandatoryPropertiesException;
039 import org.opends.server.admin.client.OperationRejectedException;
040 import org.opends.server.admin.IntegerPropertyDefinition;
041 import org.opends.server.admin.ManagedObjectAlreadyExistsException;
042 import org.opends.server.admin.ManagedObjectDefinition;
043 import org.opends.server.admin.PropertyOption;
044 import org.opends.server.admin.PropertyProvider;
045 import org.opends.server.admin.server.ConfigurationChangeListener;
046 import org.opends.server.admin.server.ServerManagedObject;
047 import org.opends.server.admin.std.client.EntryCacheCfgClient;
048 import org.opends.server.admin.std.server.EntryCacheCfg;
049 import org.opends.server.admin.Tag;
050 import org.opends.server.admin.TopCfgDefn;
051 import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
052 import org.opends.server.types.DN;
053
054
055
056 /**
057 * An interface for querying the Entry Cache managed object definition
058 * meta information.
059 * <p>
060 * Entry Caches are responsible for caching entries which are likely
061 * to be accessed by client applications in order to improve Directory
062 * Server performance.
063 */
064 public final class EntryCacheCfgDefn extends ManagedObjectDefinition<EntryCacheCfgClient, EntryCacheCfg> {
065
066 // The singleton configuration definition instance.
067 private static final EntryCacheCfgDefn INSTANCE = new EntryCacheCfgDefn();
068
069
070
071 // The "cache-level" property definition.
072 private static final IntegerPropertyDefinition PD_CACHE_LEVEL;
073
074
075
076 // The "enabled" property definition.
077 private static final BooleanPropertyDefinition PD_ENABLED;
078
079
080
081 // The "java-class" property definition.
082 private static final ClassPropertyDefinition PD_JAVA_CLASS;
083
084
085
086 // Build the "cache-level" property definition.
087 static {
088 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "cache-level");
089 builder.setOption(PropertyOption.MANDATORY);
090 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "cache-level"));
091 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>());
092 builder.setLowerLimit(1);
093 PD_CACHE_LEVEL = builder.getInstance();
094 INSTANCE.registerPropertyDefinition(PD_CACHE_LEVEL);
095 }
096
097
098
099 // Build the "enabled" property definition.
100 static {
101 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "enabled");
102 builder.setOption(PropertyOption.MANDATORY);
103 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "enabled"));
104 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Boolean>());
105 PD_ENABLED = builder.getInstance();
106 INSTANCE.registerPropertyDefinition(PD_ENABLED);
107 }
108
109
110
111 // Build the "java-class" property definition.
112 static {
113 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
114 builder.setOption(PropertyOption.MANDATORY);
115 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
116 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
117 builder.addInstanceOf("org.opends.server.api.EntryCache");
118 PD_JAVA_CLASS = builder.getInstance();
119 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
120 }
121
122
123
124 // Register the tags associated with this managed object definition.
125 static {
126 INSTANCE.registerTag(Tag.valueOf("database"));
127 }
128
129
130
131 /**
132 * Get the Entry Cache configuration definition singleton.
133 *
134 * @return Returns the Entry Cache configuration definition
135 * singleton.
136 */
137 public static EntryCacheCfgDefn getInstance() {
138 return INSTANCE;
139 }
140
141
142
143 /**
144 * Private constructor.
145 */
146 private EntryCacheCfgDefn() {
147 super("entry-cache", TopCfgDefn.getInstance());
148 }
149
150
151
152 /**
153 * {@inheritDoc}
154 */
155 public EntryCacheCfgClient createClientConfiguration(
156 ManagedObject<? extends EntryCacheCfgClient> impl) {
157 return new EntryCacheCfgClientImpl(impl);
158 }
159
160
161
162 /**
163 * {@inheritDoc}
164 */
165 public EntryCacheCfg createServerConfiguration(
166 ServerManagedObject<? extends EntryCacheCfg> impl) {
167 return new EntryCacheCfgServerImpl(impl);
168 }
169
170
171
172 /**
173 * {@inheritDoc}
174 */
175 public Class<EntryCacheCfg> getServerConfigurationClass() {
176 return EntryCacheCfg.class;
177 }
178
179
180
181 /**
182 * Get the "cache-level" property definition.
183 * <p>
184 * Specifies the cache level in the cache order if more than one
185 * instance of the cache is configured.
186 *
187 * @return Returns the "cache-level" property definition.
188 */
189 public IntegerPropertyDefinition getCacheLevelPropertyDefinition() {
190 return PD_CACHE_LEVEL;
191 }
192
193
194
195 /**
196 * Get the "enabled" property definition.
197 * <p>
198 * Indicates whether the Entry Cache is enabled.
199 *
200 * @return Returns the "enabled" property definition.
201 */
202 public BooleanPropertyDefinition getEnabledPropertyDefinition() {
203 return PD_ENABLED;
204 }
205
206
207
208 /**
209 * Get the "java-class" property definition.
210 * <p>
211 * Specifies the fully-qualified name of the Java class that
212 * provides the Entry Cache implementation.
213 *
214 * @return Returns the "java-class" property definition.
215 */
216 public ClassPropertyDefinition getJavaClassPropertyDefinition() {
217 return PD_JAVA_CLASS;
218 }
219
220
221
222 /**
223 * Managed object client implementation.
224 */
225 private static class EntryCacheCfgClientImpl implements
226 EntryCacheCfgClient {
227
228 // Private implementation.
229 private ManagedObject<? extends EntryCacheCfgClient> impl;
230
231
232
233 // Private constructor.
234 private EntryCacheCfgClientImpl(
235 ManagedObject<? extends EntryCacheCfgClient> impl) {
236 this.impl = impl;
237 }
238
239
240
241 /**
242 * {@inheritDoc}
243 */
244 public Integer getCacheLevel() {
245 return impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
246 }
247
248
249
250 /**
251 * {@inheritDoc}
252 */
253 public void setCacheLevel(int value) {
254 impl.setPropertyValue(INSTANCE.getCacheLevelPropertyDefinition(), value);
255 }
256
257
258
259 /**
260 * {@inheritDoc}
261 */
262 public Boolean isEnabled() {
263 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
264 }
265
266
267
268 /**
269 * {@inheritDoc}
270 */
271 public void setEnabled(boolean value) {
272 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
273 }
274
275
276
277 /**
278 * {@inheritDoc}
279 */
280 public String getJavaClass() {
281 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
282 }
283
284
285
286 /**
287 * {@inheritDoc}
288 */
289 public void setJavaClass(String value) {
290 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
291 }
292
293
294
295 /**
296 * {@inheritDoc}
297 */
298 public ManagedObjectDefinition<? extends EntryCacheCfgClient, ? extends EntryCacheCfg> definition() {
299 return INSTANCE;
300 }
301
302
303
304 /**
305 * {@inheritDoc}
306 */
307 public PropertyProvider properties() {
308 return impl;
309 }
310
311
312
313 /**
314 * {@inheritDoc}
315 */
316 public void commit() throws ManagedObjectAlreadyExistsException,
317 MissingMandatoryPropertiesException, ConcurrentModificationException,
318 OperationRejectedException, AuthorizationException,
319 CommunicationException {
320 impl.commit();
321 }
322
323 }
324
325
326
327 /**
328 * Managed object server implementation.
329 */
330 private static class EntryCacheCfgServerImpl implements
331 EntryCacheCfg {
332
333 // Private implementation.
334 private ServerManagedObject<? extends EntryCacheCfg> impl;
335
336 // The value of the "cache-level" property.
337 private final int pCacheLevel;
338
339 // The value of the "enabled" property.
340 private final boolean pEnabled;
341
342 // The value of the "java-class" property.
343 private final String pJavaClass;
344
345
346
347 // Private constructor.
348 private EntryCacheCfgServerImpl(ServerManagedObject<? extends EntryCacheCfg> impl) {
349 this.impl = impl;
350 this.pCacheLevel = impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
351 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
352 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
353 }
354
355
356
357 /**
358 * {@inheritDoc}
359 */
360 public void addChangeListener(
361 ConfigurationChangeListener<EntryCacheCfg> listener) {
362 impl.registerChangeListener(listener);
363 }
364
365
366
367 /**
368 * {@inheritDoc}
369 */
370 public void removeChangeListener(
371 ConfigurationChangeListener<EntryCacheCfg> listener) {
372 impl.deregisterChangeListener(listener);
373 }
374
375
376
377 /**
378 * {@inheritDoc}
379 */
380 public int getCacheLevel() {
381 return pCacheLevel;
382 }
383
384
385
386 /**
387 * {@inheritDoc}
388 */
389 public boolean isEnabled() {
390 return pEnabled;
391 }
392
393
394
395 /**
396 * {@inheritDoc}
397 */
398 public String getJavaClass() {
399 return pJavaClass;
400 }
401
402
403
404 /**
405 * {@inheritDoc}
406 */
407 public Class<? extends EntryCacheCfg> configurationClass() {
408 return EntryCacheCfg.class;
409 }
410
411
412
413 /**
414 * {@inheritDoc}
415 */
416 public DN dn() {
417 return impl.getDN();
418 }
419
420 }
421 }