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.DurationPropertyDefinition;
045    import org.opends.server.admin.IntegerPropertyDefinition;
046    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047    import org.opends.server.admin.ManagedObjectDefinition;
048    import org.opends.server.admin.PropertyOption;
049    import org.opends.server.admin.PropertyProvider;
050    import org.opends.server.admin.server.ConfigurationChangeListener;
051    import org.opends.server.admin.server.ServerManagedObject;
052    import org.opends.server.admin.std.client.SoftReferenceEntryCacheCfgClient;
053    import org.opends.server.admin.std.server.EntryCacheCfg;
054    import org.opends.server.admin.std.server.SoftReferenceEntryCacheCfg;
055    import org.opends.server.admin.StringPropertyDefinition;
056    import org.opends.server.admin.Tag;
057    import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
058    import org.opends.server.types.DN;
059    
060    
061    
062    /**
063     * An interface for querying the Soft Reference Entry Cache managed
064     * object definition meta information.
065     * <p>
066     * The Soft Reference Entry Cache is a Directory Server entry cache
067     * implementation that uses soft references to manage objects to allow
068     * them to be freed if the JVM is running low on memory.
069     */
070    public final class SoftReferenceEntryCacheCfgDefn extends ManagedObjectDefinition<SoftReferenceEntryCacheCfgClient, SoftReferenceEntryCacheCfg> {
071    
072      // The singleton configuration definition instance.
073      private static final SoftReferenceEntryCacheCfgDefn INSTANCE = new SoftReferenceEntryCacheCfgDefn();
074    
075    
076    
077      // The "exclude-filter" property definition.
078      private static final StringPropertyDefinition PD_EXCLUDE_FILTER;
079    
080    
081    
082      // The "include-filter" property definition.
083      private static final StringPropertyDefinition PD_INCLUDE_FILTER;
084    
085    
086    
087      // The "java-class" property definition.
088      private static final ClassPropertyDefinition PD_JAVA_CLASS;
089    
090    
091    
092      // The "lock-timeout" property definition.
093      private static final DurationPropertyDefinition PD_LOCK_TIMEOUT;
094    
095    
096    
097      // Build the "exclude-filter" property definition.
098      static {
099          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "exclude-filter");
100          builder.setOption(PropertyOption.MULTI_VALUED);
101          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "exclude-filter"));
102          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
103          PD_EXCLUDE_FILTER = builder.getInstance();
104          INSTANCE.registerPropertyDefinition(PD_EXCLUDE_FILTER);
105      }
106    
107    
108    
109      // Build the "include-filter" property definition.
110      static {
111          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "include-filter");
112          builder.setOption(PropertyOption.MULTI_VALUED);
113          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "include-filter"));
114          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
115          PD_INCLUDE_FILTER = builder.getInstance();
116          INSTANCE.registerPropertyDefinition(PD_INCLUDE_FILTER);
117      }
118    
119    
120    
121      // Build the "java-class" property definition.
122      static {
123          ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
124          builder.setOption(PropertyOption.MANDATORY);
125          builder.setOption(PropertyOption.ADVANCED);
126          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
127          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.SoftReferenceEntryCache");
128          builder.setDefaultBehaviorProvider(provider);
129          builder.addInstanceOf("org.opends.server.api.EntryCache");
130          PD_JAVA_CLASS = builder.getInstance();
131          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
132      }
133    
134    
135    
136      // Build the "lock-timeout" property definition.
137      static {
138          DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "lock-timeout");
139          builder.setOption(PropertyOption.ADVANCED);
140          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "lock-timeout"));
141          DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("3000ms");
142          builder.setDefaultBehaviorProvider(provider);
143          builder.setAllowUnlimited(true);
144          builder.setBaseUnit("ms");
145          builder.setLowerLimit("0");
146          PD_LOCK_TIMEOUT = builder.getInstance();
147          INSTANCE.registerPropertyDefinition(PD_LOCK_TIMEOUT);
148      }
149    
150    
151    
152      // Register the tags associated with this managed object definition.
153      static {
154        INSTANCE.registerTag(Tag.valueOf("database"));
155      }
156    
157    
158    
159      /**
160       * Get the Soft Reference Entry Cache configuration definition
161       * singleton.
162       *
163       * @return Returns the Soft Reference Entry Cache configuration
164       *         definition singleton.
165       */
166      public static SoftReferenceEntryCacheCfgDefn getInstance() {
167        return INSTANCE;
168      }
169    
170    
171    
172      /**
173       * Private constructor.
174       */
175      private SoftReferenceEntryCacheCfgDefn() {
176        super("soft-reference-entry-cache", EntryCacheCfgDefn.getInstance());
177      }
178    
179    
180    
181      /**
182       * {@inheritDoc}
183       */
184      public SoftReferenceEntryCacheCfgClient createClientConfiguration(
185          ManagedObject<? extends SoftReferenceEntryCacheCfgClient> impl) {
186        return new SoftReferenceEntryCacheCfgClientImpl(impl);
187      }
188    
189    
190    
191      /**
192       * {@inheritDoc}
193       */
194      public SoftReferenceEntryCacheCfg createServerConfiguration(
195          ServerManagedObject<? extends SoftReferenceEntryCacheCfg> impl) {
196        return new SoftReferenceEntryCacheCfgServerImpl(impl);
197      }
198    
199    
200    
201      /**
202       * {@inheritDoc}
203       */
204      public Class<SoftReferenceEntryCacheCfg> getServerConfigurationClass() {
205        return SoftReferenceEntryCacheCfg.class;
206      }
207    
208    
209    
210      /**
211       * Get the "cache-level" property definition.
212       * <p>
213       * Specifies the cache level in the cache order if more than one
214       * instance of the cache is configured.
215       *
216       * @return Returns the "cache-level" property definition.
217       */
218      public IntegerPropertyDefinition getCacheLevelPropertyDefinition() {
219        return EntryCacheCfgDefn.getInstance().getCacheLevelPropertyDefinition();
220      }
221    
222    
223    
224      /**
225       * Get the "enabled" property definition.
226       * <p>
227       * Indicates whether the Soft Reference Entry Cache is enabled.
228       *
229       * @return Returns the "enabled" property definition.
230       */
231      public BooleanPropertyDefinition getEnabledPropertyDefinition() {
232        return EntryCacheCfgDefn.getInstance().getEnabledPropertyDefinition();
233      }
234    
235    
236    
237      /**
238       * Get the "exclude-filter" property definition.
239       * <p>
240       * The set of filters that define the entries that should be
241       * excluded from the cache.
242       *
243       * @return Returns the "exclude-filter" property definition.
244       */
245      public StringPropertyDefinition getExcludeFilterPropertyDefinition() {
246        return PD_EXCLUDE_FILTER;
247      }
248    
249    
250    
251      /**
252       * Get the "include-filter" property definition.
253       * <p>
254       * The set of filters that define the entries that should be
255       * included in the cache.
256       *
257       * @return Returns the "include-filter" property definition.
258       */
259      public StringPropertyDefinition getIncludeFilterPropertyDefinition() {
260        return PD_INCLUDE_FILTER;
261      }
262    
263    
264    
265      /**
266       * Get the "java-class" property definition.
267       * <p>
268       * Specifies the fully-qualified name of the Java class that
269       * provides the Soft Reference Entry Cache implementation.
270       *
271       * @return Returns the "java-class" property definition.
272       */
273      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
274        return PD_JAVA_CLASS;
275      }
276    
277    
278    
279      /**
280       * Get the "lock-timeout" property definition.
281       * <p>
282       * Specifies the length of time in milliseconds to wait while
283       * attempting to acquire a read or write lock.
284       *
285       * @return Returns the "lock-timeout" property definition.
286       */
287      public DurationPropertyDefinition getLockTimeoutPropertyDefinition() {
288        return PD_LOCK_TIMEOUT;
289      }
290    
291    
292    
293      /**
294       * Managed object client implementation.
295       */
296      private static class SoftReferenceEntryCacheCfgClientImpl implements
297        SoftReferenceEntryCacheCfgClient {
298    
299        // Private implementation.
300        private ManagedObject<? extends SoftReferenceEntryCacheCfgClient> impl;
301    
302    
303    
304        // Private constructor.
305        private SoftReferenceEntryCacheCfgClientImpl(
306            ManagedObject<? extends SoftReferenceEntryCacheCfgClient> impl) {
307          this.impl = impl;
308        }
309    
310    
311    
312        /**
313         * {@inheritDoc}
314         */
315        public Integer getCacheLevel() {
316          return impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
317        }
318    
319    
320    
321        /**
322         * {@inheritDoc}
323         */
324        public void setCacheLevel(int value) {
325          impl.setPropertyValue(INSTANCE.getCacheLevelPropertyDefinition(), value);
326        }
327    
328    
329    
330        /**
331         * {@inheritDoc}
332         */
333        public Boolean isEnabled() {
334          return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
335        }
336    
337    
338    
339        /**
340         * {@inheritDoc}
341         */
342        public void setEnabled(boolean value) {
343          impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
344        }
345    
346    
347    
348        /**
349         * {@inheritDoc}
350         */
351        public SortedSet<String> getExcludeFilter() {
352          return impl.getPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition());
353        }
354    
355    
356    
357        /**
358         * {@inheritDoc}
359         */
360        public void setExcludeFilter(Collection<String> values) {
361          impl.setPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition(), values);
362        }
363    
364    
365    
366        /**
367         * {@inheritDoc}
368         */
369        public SortedSet<String> getIncludeFilter() {
370          return impl.getPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition());
371        }
372    
373    
374    
375        /**
376         * {@inheritDoc}
377         */
378        public void setIncludeFilter(Collection<String> values) {
379          impl.setPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition(), values);
380        }
381    
382    
383    
384        /**
385         * {@inheritDoc}
386         */
387        public String getJavaClass() {
388          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
389        }
390    
391    
392    
393        /**
394         * {@inheritDoc}
395         */
396        public void setJavaClass(String value) {
397          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
398        }
399    
400    
401    
402        /**
403         * {@inheritDoc}
404         */
405        public long getLockTimeout() {
406          return impl.getPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition());
407        }
408    
409    
410    
411        /**
412         * {@inheritDoc}
413         */
414        public void setLockTimeout(Long value) {
415          impl.setPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition(), value);
416        }
417    
418    
419    
420        /**
421         * {@inheritDoc}
422         */
423        public ManagedObjectDefinition<? extends SoftReferenceEntryCacheCfgClient, ? extends SoftReferenceEntryCacheCfg> definition() {
424          return INSTANCE;
425        }
426    
427    
428    
429        /**
430         * {@inheritDoc}
431         */
432        public PropertyProvider properties() {
433          return impl;
434        }
435    
436    
437    
438        /**
439         * {@inheritDoc}
440         */
441        public void commit() throws ManagedObjectAlreadyExistsException,
442            MissingMandatoryPropertiesException, ConcurrentModificationException,
443            OperationRejectedException, AuthorizationException,
444            CommunicationException {
445          impl.commit();
446        }
447    
448      }
449    
450    
451    
452      /**
453       * Managed object server implementation.
454       */
455      private static class SoftReferenceEntryCacheCfgServerImpl implements
456        SoftReferenceEntryCacheCfg {
457    
458        // Private implementation.
459        private ServerManagedObject<? extends SoftReferenceEntryCacheCfg> impl;
460    
461        // The value of the "cache-level" property.
462        private final int pCacheLevel;
463    
464        // The value of the "enabled" property.
465        private final boolean pEnabled;
466    
467        // The value of the "exclude-filter" property.
468        private final SortedSet<String> pExcludeFilter;
469    
470        // The value of the "include-filter" property.
471        private final SortedSet<String> pIncludeFilter;
472    
473        // The value of the "java-class" property.
474        private final String pJavaClass;
475    
476        // The value of the "lock-timeout" property.
477        private final long pLockTimeout;
478    
479    
480    
481        // Private constructor.
482        private SoftReferenceEntryCacheCfgServerImpl(ServerManagedObject<? extends SoftReferenceEntryCacheCfg> impl) {
483          this.impl = impl;
484          this.pCacheLevel = impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
485          this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
486          this.pExcludeFilter = impl.getPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition());
487          this.pIncludeFilter = impl.getPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition());
488          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
489          this.pLockTimeout = impl.getPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition());
490        }
491    
492    
493    
494        /**
495         * {@inheritDoc}
496         */
497        public void addSoftReferenceChangeListener(
498            ConfigurationChangeListener<SoftReferenceEntryCacheCfg> listener) {
499          impl.registerChangeListener(listener);
500        }
501    
502    
503    
504        /**
505         * {@inheritDoc}
506         */
507        public void removeSoftReferenceChangeListener(
508            ConfigurationChangeListener<SoftReferenceEntryCacheCfg> listener) {
509          impl.deregisterChangeListener(listener);
510        }
511        /**
512         * {@inheritDoc}
513         */
514        public void addChangeListener(
515            ConfigurationChangeListener<EntryCacheCfg> listener) {
516          impl.registerChangeListener(listener);
517        }
518    
519    
520    
521        /**
522         * {@inheritDoc}
523         */
524        public void removeChangeListener(
525            ConfigurationChangeListener<EntryCacheCfg> listener) {
526          impl.deregisterChangeListener(listener);
527        }
528    
529    
530    
531        /**
532         * {@inheritDoc}
533         */
534        public int getCacheLevel() {
535          return pCacheLevel;
536        }
537    
538    
539    
540        /**
541         * {@inheritDoc}
542         */
543        public boolean isEnabled() {
544          return pEnabled;
545        }
546    
547    
548    
549        /**
550         * {@inheritDoc}
551         */
552        public SortedSet<String> getExcludeFilter() {
553          return pExcludeFilter;
554        }
555    
556    
557    
558        /**
559         * {@inheritDoc}
560         */
561        public SortedSet<String> getIncludeFilter() {
562          return pIncludeFilter;
563        }
564    
565    
566    
567        /**
568         * {@inheritDoc}
569         */
570        public String getJavaClass() {
571          return pJavaClass;
572        }
573    
574    
575    
576        /**
577         * {@inheritDoc}
578         */
579        public long getLockTimeout() {
580          return pLockTimeout;
581        }
582    
583    
584    
585        /**
586         * {@inheritDoc}
587         */
588        public Class<? extends SoftReferenceEntryCacheCfg> configurationClass() {
589          return SoftReferenceEntryCacheCfg.class;
590        }
591    
592    
593    
594        /**
595         * {@inheritDoc}
596         */
597        public DN dn() {
598          return impl.getDN();
599        }
600    
601      }
602    }