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.FIFOEntryCacheCfgClient;
053    import org.opends.server.admin.std.server.EntryCacheCfg;
054    import org.opends.server.admin.std.server.FIFOEntryCacheCfg;
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 FIFO Entry Cache managed object
064     * definition meta information.
065     * <p>
066     * FIFO Entry Caches use a FIFO queue to keep track of the cached
067     * entries.
068     */
069    public final class FIFOEntryCacheCfgDefn extends ManagedObjectDefinition<FIFOEntryCacheCfgClient, FIFOEntryCacheCfg> {
070    
071      // The singleton configuration definition instance.
072      private static final FIFOEntryCacheCfgDefn INSTANCE = new FIFOEntryCacheCfgDefn();
073    
074    
075    
076      // The "exclude-filter" property definition.
077      private static final StringPropertyDefinition PD_EXCLUDE_FILTER;
078    
079    
080    
081      // The "include-filter" property definition.
082      private static final StringPropertyDefinition PD_INCLUDE_FILTER;
083    
084    
085    
086      // The "java-class" property definition.
087      private static final ClassPropertyDefinition PD_JAVA_CLASS;
088    
089    
090    
091      // The "lock-timeout" property definition.
092      private static final DurationPropertyDefinition PD_LOCK_TIMEOUT;
093    
094    
095    
096      // The "max-entries" property definition.
097      private static final IntegerPropertyDefinition PD_MAX_ENTRIES;
098    
099    
100    
101      // The "max-memory-percent" property definition.
102      private static final IntegerPropertyDefinition PD_MAX_MEMORY_PERCENT;
103    
104    
105    
106      // Build the "exclude-filter" property definition.
107      static {
108          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "exclude-filter");
109          builder.setOption(PropertyOption.MULTI_VALUED);
110          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "exclude-filter"));
111          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
112          PD_EXCLUDE_FILTER = builder.getInstance();
113          INSTANCE.registerPropertyDefinition(PD_EXCLUDE_FILTER);
114      }
115    
116    
117    
118      // Build the "include-filter" property definition.
119      static {
120          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "include-filter");
121          builder.setOption(PropertyOption.MULTI_VALUED);
122          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "include-filter"));
123          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
124          PD_INCLUDE_FILTER = builder.getInstance();
125          INSTANCE.registerPropertyDefinition(PD_INCLUDE_FILTER);
126      }
127    
128    
129    
130      // Build the "java-class" property definition.
131      static {
132          ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
133          builder.setOption(PropertyOption.MANDATORY);
134          builder.setOption(PropertyOption.ADVANCED);
135          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
136          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.FIFOEntryCache");
137          builder.setDefaultBehaviorProvider(provider);
138          builder.addInstanceOf("org.opends.server.api.EntryCache");
139          PD_JAVA_CLASS = builder.getInstance();
140          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
141      }
142    
143    
144    
145      // Build the "lock-timeout" property definition.
146      static {
147          DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "lock-timeout");
148          builder.setOption(PropertyOption.ADVANCED);
149          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "lock-timeout"));
150          DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("2000.0ms");
151          builder.setDefaultBehaviorProvider(provider);
152          builder.setAllowUnlimited(true);
153          builder.setBaseUnit("ms");
154          builder.setLowerLimit("0");
155          PD_LOCK_TIMEOUT = builder.getInstance();
156          INSTANCE.registerPropertyDefinition(PD_LOCK_TIMEOUT);
157      }
158    
159    
160    
161      // Build the "max-entries" property definition.
162      static {
163          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-entries");
164          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-entries"));
165          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("2147483647");
166          builder.setDefaultBehaviorProvider(provider);
167          builder.setLowerLimit(0);
168          PD_MAX_ENTRIES = builder.getInstance();
169          INSTANCE.registerPropertyDefinition(PD_MAX_ENTRIES);
170      }
171    
172    
173    
174      // Build the "max-memory-percent" property definition.
175      static {
176          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-memory-percent");
177          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-memory-percent"));
178          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("90");
179          builder.setDefaultBehaviorProvider(provider);
180          builder.setUpperLimit(100);
181          builder.setLowerLimit(1);
182          PD_MAX_MEMORY_PERCENT = builder.getInstance();
183          INSTANCE.registerPropertyDefinition(PD_MAX_MEMORY_PERCENT);
184      }
185    
186    
187    
188      // Register the tags associated with this managed object definition.
189      static {
190        INSTANCE.registerTag(Tag.valueOf("database"));
191      }
192    
193    
194    
195      /**
196       * Get the FIFO Entry Cache configuration definition singleton.
197       *
198       * @return Returns the FIFO Entry Cache configuration definition
199       *         singleton.
200       */
201      public static FIFOEntryCacheCfgDefn getInstance() {
202        return INSTANCE;
203      }
204    
205    
206    
207      /**
208       * Private constructor.
209       */
210      private FIFOEntryCacheCfgDefn() {
211        super("fifo-entry-cache", EntryCacheCfgDefn.getInstance());
212      }
213    
214    
215    
216      /**
217       * {@inheritDoc}
218       */
219      public FIFOEntryCacheCfgClient createClientConfiguration(
220          ManagedObject<? extends FIFOEntryCacheCfgClient> impl) {
221        return new FIFOEntryCacheCfgClientImpl(impl);
222      }
223    
224    
225    
226      /**
227       * {@inheritDoc}
228       */
229      public FIFOEntryCacheCfg createServerConfiguration(
230          ServerManagedObject<? extends FIFOEntryCacheCfg> impl) {
231        return new FIFOEntryCacheCfgServerImpl(impl);
232      }
233    
234    
235    
236      /**
237       * {@inheritDoc}
238       */
239      public Class<FIFOEntryCacheCfg> getServerConfigurationClass() {
240        return FIFOEntryCacheCfg.class;
241      }
242    
243    
244    
245      /**
246       * Get the "cache-level" property definition.
247       * <p>
248       * Specifies the cache level in the cache order if more than one
249       * instance of the cache is configured.
250       *
251       * @return Returns the "cache-level" property definition.
252       */
253      public IntegerPropertyDefinition getCacheLevelPropertyDefinition() {
254        return EntryCacheCfgDefn.getInstance().getCacheLevelPropertyDefinition();
255      }
256    
257    
258    
259      /**
260       * Get the "enabled" property definition.
261       * <p>
262       * Indicates whether the FIFO Entry Cache is enabled.
263       *
264       * @return Returns the "enabled" property definition.
265       */
266      public BooleanPropertyDefinition getEnabledPropertyDefinition() {
267        return EntryCacheCfgDefn.getInstance().getEnabledPropertyDefinition();
268      }
269    
270    
271    
272      /**
273       * Get the "exclude-filter" property definition.
274       * <p>
275       * The set of filters that define the entries that should be
276       * excluded from the cache.
277       *
278       * @return Returns the "exclude-filter" property definition.
279       */
280      public StringPropertyDefinition getExcludeFilterPropertyDefinition() {
281        return PD_EXCLUDE_FILTER;
282      }
283    
284    
285    
286      /**
287       * Get the "include-filter" property definition.
288       * <p>
289       * The set of filters that define the entries that should be
290       * included in the cache.
291       *
292       * @return Returns the "include-filter" property definition.
293       */
294      public StringPropertyDefinition getIncludeFilterPropertyDefinition() {
295        return PD_INCLUDE_FILTER;
296      }
297    
298    
299    
300      /**
301       * Get the "java-class" property definition.
302       * <p>
303       * Specifies the fully-qualified name of the Java class that
304       * provides the FIFO Entry Cache implementation.
305       *
306       * @return Returns the "java-class" property definition.
307       */
308      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
309        return PD_JAVA_CLASS;
310      }
311    
312    
313    
314      /**
315       * Get the "lock-timeout" property definition.
316       * <p>
317       * Specifies the length of time to wait while attempting to acquire
318       * a read or write lock.
319       *
320       * @return Returns the "lock-timeout" property definition.
321       */
322      public DurationPropertyDefinition getLockTimeoutPropertyDefinition() {
323        return PD_LOCK_TIMEOUT;
324      }
325    
326    
327    
328      /**
329       * Get the "max-entries" property definition.
330       * <p>
331       * Specifies the maximum number of entries that we will allow in the
332       * cache.
333       *
334       * @return Returns the "max-entries" property definition.
335       */
336      public IntegerPropertyDefinition getMaxEntriesPropertyDefinition() {
337        return PD_MAX_ENTRIES;
338      }
339    
340    
341    
342      /**
343       * Get the "max-memory-percent" property definition.
344       * <p>
345       * Specifies the maximum memory usage for the entry cache as a
346       * percentage of the total JVM memory.
347       *
348       * @return Returns the "max-memory-percent" property definition.
349       */
350      public IntegerPropertyDefinition getMaxMemoryPercentPropertyDefinition() {
351        return PD_MAX_MEMORY_PERCENT;
352      }
353    
354    
355    
356      /**
357       * Managed object client implementation.
358       */
359      private static class FIFOEntryCacheCfgClientImpl implements
360        FIFOEntryCacheCfgClient {
361    
362        // Private implementation.
363        private ManagedObject<? extends FIFOEntryCacheCfgClient> impl;
364    
365    
366    
367        // Private constructor.
368        private FIFOEntryCacheCfgClientImpl(
369            ManagedObject<? extends FIFOEntryCacheCfgClient> impl) {
370          this.impl = impl;
371        }
372    
373    
374    
375        /**
376         * {@inheritDoc}
377         */
378        public Integer getCacheLevel() {
379          return impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
380        }
381    
382    
383    
384        /**
385         * {@inheritDoc}
386         */
387        public void setCacheLevel(int value) {
388          impl.setPropertyValue(INSTANCE.getCacheLevelPropertyDefinition(), value);
389        }
390    
391    
392    
393        /**
394         * {@inheritDoc}
395         */
396        public Boolean isEnabled() {
397          return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
398        }
399    
400    
401    
402        /**
403         * {@inheritDoc}
404         */
405        public void setEnabled(boolean value) {
406          impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
407        }
408    
409    
410    
411        /**
412         * {@inheritDoc}
413         */
414        public SortedSet<String> getExcludeFilter() {
415          return impl.getPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition());
416        }
417    
418    
419    
420        /**
421         * {@inheritDoc}
422         */
423        public void setExcludeFilter(Collection<String> values) {
424          impl.setPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition(), values);
425        }
426    
427    
428    
429        /**
430         * {@inheritDoc}
431         */
432        public SortedSet<String> getIncludeFilter() {
433          return impl.getPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition());
434        }
435    
436    
437    
438        /**
439         * {@inheritDoc}
440         */
441        public void setIncludeFilter(Collection<String> values) {
442          impl.setPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition(), values);
443        }
444    
445    
446    
447        /**
448         * {@inheritDoc}
449         */
450        public String getJavaClass() {
451          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
452        }
453    
454    
455    
456        /**
457         * {@inheritDoc}
458         */
459        public void setJavaClass(String value) {
460          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
461        }
462    
463    
464    
465        /**
466         * {@inheritDoc}
467         */
468        public long getLockTimeout() {
469          return impl.getPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition());
470        }
471    
472    
473    
474        /**
475         * {@inheritDoc}
476         */
477        public void setLockTimeout(Long value) {
478          impl.setPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition(), value);
479        }
480    
481    
482    
483        /**
484         * {@inheritDoc}
485         */
486        public int getMaxEntries() {
487          return impl.getPropertyValue(INSTANCE.getMaxEntriesPropertyDefinition());
488        }
489    
490    
491    
492        /**
493         * {@inheritDoc}
494         */
495        public void setMaxEntries(Integer value) {
496          impl.setPropertyValue(INSTANCE.getMaxEntriesPropertyDefinition(), value);
497        }
498    
499    
500    
501        /**
502         * {@inheritDoc}
503         */
504        public int getMaxMemoryPercent() {
505          return impl.getPropertyValue(INSTANCE.getMaxMemoryPercentPropertyDefinition());
506        }
507    
508    
509    
510        /**
511         * {@inheritDoc}
512         */
513        public void setMaxMemoryPercent(Integer value) {
514          impl.setPropertyValue(INSTANCE.getMaxMemoryPercentPropertyDefinition(), value);
515        }
516    
517    
518    
519        /**
520         * {@inheritDoc}
521         */
522        public ManagedObjectDefinition<? extends FIFOEntryCacheCfgClient, ? extends FIFOEntryCacheCfg> definition() {
523          return INSTANCE;
524        }
525    
526    
527    
528        /**
529         * {@inheritDoc}
530         */
531        public PropertyProvider properties() {
532          return impl;
533        }
534    
535    
536    
537        /**
538         * {@inheritDoc}
539         */
540        public void commit() throws ManagedObjectAlreadyExistsException,
541            MissingMandatoryPropertiesException, ConcurrentModificationException,
542            OperationRejectedException, AuthorizationException,
543            CommunicationException {
544          impl.commit();
545        }
546    
547      }
548    
549    
550    
551      /**
552       * Managed object server implementation.
553       */
554      private static class FIFOEntryCacheCfgServerImpl implements
555        FIFOEntryCacheCfg {
556    
557        // Private implementation.
558        private ServerManagedObject<? extends FIFOEntryCacheCfg> impl;
559    
560        // The value of the "cache-level" property.
561        private final int pCacheLevel;
562    
563        // The value of the "enabled" property.
564        private final boolean pEnabled;
565    
566        // The value of the "exclude-filter" property.
567        private final SortedSet<String> pExcludeFilter;
568    
569        // The value of the "include-filter" property.
570        private final SortedSet<String> pIncludeFilter;
571    
572        // The value of the "java-class" property.
573        private final String pJavaClass;
574    
575        // The value of the "lock-timeout" property.
576        private final long pLockTimeout;
577    
578        // The value of the "max-entries" property.
579        private final int pMaxEntries;
580    
581        // The value of the "max-memory-percent" property.
582        private final int pMaxMemoryPercent;
583    
584    
585    
586        // Private constructor.
587        private FIFOEntryCacheCfgServerImpl(ServerManagedObject<? extends FIFOEntryCacheCfg> impl) {
588          this.impl = impl;
589          this.pCacheLevel = impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
590          this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
591          this.pExcludeFilter = impl.getPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition());
592          this.pIncludeFilter = impl.getPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition());
593          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
594          this.pLockTimeout = impl.getPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition());
595          this.pMaxEntries = impl.getPropertyValue(INSTANCE.getMaxEntriesPropertyDefinition());
596          this.pMaxMemoryPercent = impl.getPropertyValue(INSTANCE.getMaxMemoryPercentPropertyDefinition());
597        }
598    
599    
600    
601        /**
602         * {@inheritDoc}
603         */
604        public void addFIFOChangeListener(
605            ConfigurationChangeListener<FIFOEntryCacheCfg> listener) {
606          impl.registerChangeListener(listener);
607        }
608    
609    
610    
611        /**
612         * {@inheritDoc}
613         */
614        public void removeFIFOChangeListener(
615            ConfigurationChangeListener<FIFOEntryCacheCfg> listener) {
616          impl.deregisterChangeListener(listener);
617        }
618        /**
619         * {@inheritDoc}
620         */
621        public void addChangeListener(
622            ConfigurationChangeListener<EntryCacheCfg> listener) {
623          impl.registerChangeListener(listener);
624        }
625    
626    
627    
628        /**
629         * {@inheritDoc}
630         */
631        public void removeChangeListener(
632            ConfigurationChangeListener<EntryCacheCfg> listener) {
633          impl.deregisterChangeListener(listener);
634        }
635    
636    
637    
638        /**
639         * {@inheritDoc}
640         */
641        public int getCacheLevel() {
642          return pCacheLevel;
643        }
644    
645    
646    
647        /**
648         * {@inheritDoc}
649         */
650        public boolean isEnabled() {
651          return pEnabled;
652        }
653    
654    
655    
656        /**
657         * {@inheritDoc}
658         */
659        public SortedSet<String> getExcludeFilter() {
660          return pExcludeFilter;
661        }
662    
663    
664    
665        /**
666         * {@inheritDoc}
667         */
668        public SortedSet<String> getIncludeFilter() {
669          return pIncludeFilter;
670        }
671    
672    
673    
674        /**
675         * {@inheritDoc}
676         */
677        public String getJavaClass() {
678          return pJavaClass;
679        }
680    
681    
682    
683        /**
684         * {@inheritDoc}
685         */
686        public long getLockTimeout() {
687          return pLockTimeout;
688        }
689    
690    
691    
692        /**
693         * {@inheritDoc}
694         */
695        public int getMaxEntries() {
696          return pMaxEntries;
697        }
698    
699    
700    
701        /**
702         * {@inheritDoc}
703         */
704        public int getMaxMemoryPercent() {
705          return pMaxMemoryPercent;
706        }
707    
708    
709    
710        /**
711         * {@inheritDoc}
712         */
713        public Class<? extends FIFOEntryCacheCfg> configurationClass() {
714          return FIFOEntryCacheCfg.class;
715        }
716    
717    
718    
719        /**
720         * {@inheritDoc}
721         */
722        public DN dn() {
723          return impl.getDN();
724        }
725    
726      }
727    }