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.EnumPropertyDefinition;
046    import org.opends.server.admin.IntegerPropertyDefinition;
047    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
048    import org.opends.server.admin.ManagedObjectDefinition;
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.SizePropertyDefinition;
054    import org.opends.server.admin.std.client.FileSystemEntryCacheCfgClient;
055    import org.opends.server.admin.std.server.EntryCacheCfg;
056    import org.opends.server.admin.std.server.FileSystemEntryCacheCfg;
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 File System Entry Cache managed
066     * object definition meta information.
067     * <p>
068     * The File System Entry Cache is an entry cache implementation which
069     * uses a JE database to keep track of the entries.
070     */
071    public final class FileSystemEntryCacheCfgDefn extends ManagedObjectDefinition<FileSystemEntryCacheCfgClient, FileSystemEntryCacheCfg> {
072    
073      // The singleton configuration definition instance.
074      private static final FileSystemEntryCacheCfgDefn INSTANCE = new FileSystemEntryCacheCfgDefn();
075    
076    
077    
078      /**
079       * Defines the set of permissable values for the "cache-type" property.
080       * <p>
081       * Specifies the policy which should be used for purging entries
082       * from the cache.
083       */
084      public static enum CacheType {
085    
086        /**
087         * FIFO based entry cache.
088         */
089        FIFO("fifo"),
090    
091    
092    
093        /**
094         * LRU based entry cache.
095         */
096        LRU("lru");
097    
098    
099    
100        // String representation of the value.
101        private final String name;
102    
103    
104    
105        // Private constructor.
106        private CacheType(String name) { this.name = name; }
107    
108    
109    
110        /**
111         * {@inheritDoc}
112         */
113        public String toString() { return name; }
114    
115      }
116    
117    
118    
119      // The "cache-directory" property definition.
120      private static final StringPropertyDefinition PD_CACHE_DIRECTORY;
121    
122    
123    
124      // The "cache-type" property definition.
125      private static final EnumPropertyDefinition<CacheType> PD_CACHE_TYPE;
126    
127    
128    
129      // The "compact-encoding" property definition.
130      private static final BooleanPropertyDefinition PD_COMPACT_ENCODING;
131    
132    
133    
134      // The "db-cache-percent" property definition.
135      private static final IntegerPropertyDefinition PD_DB_CACHE_PERCENT;
136    
137    
138    
139      // The "db-cache-size" property definition.
140      private static final SizePropertyDefinition PD_DB_CACHE_SIZE;
141    
142    
143    
144      // The "exclude-filter" property definition.
145      private static final StringPropertyDefinition PD_EXCLUDE_FILTER;
146    
147    
148    
149      // The "include-filter" property definition.
150      private static final StringPropertyDefinition PD_INCLUDE_FILTER;
151    
152    
153    
154      // The "java-class" property definition.
155      private static final ClassPropertyDefinition PD_JAVA_CLASS;
156    
157    
158    
159      // The "je-property" property definition.
160      private static final StringPropertyDefinition PD_JE_PROPERTY;
161    
162    
163    
164      // The "lock-timeout" property definition.
165      private static final DurationPropertyDefinition PD_LOCK_TIMEOUT;
166    
167    
168    
169      // The "max-entries" property definition.
170      private static final IntegerPropertyDefinition PD_MAX_ENTRIES;
171    
172    
173    
174      // The "max-memory-size" property definition.
175      private static final SizePropertyDefinition PD_MAX_MEMORY_SIZE;
176    
177    
178    
179      // The "persistent-cache" property definition.
180      private static final BooleanPropertyDefinition PD_PERSISTENT_CACHE;
181    
182    
183    
184      // Build the "cache-directory" property definition.
185      static {
186          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "cache-directory");
187          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "cache-directory"));
188          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("/tmp/OpenDS.FSCache");
189          builder.setDefaultBehaviorProvider(provider);
190          PD_CACHE_DIRECTORY = builder.getInstance();
191          INSTANCE.registerPropertyDefinition(PD_CACHE_DIRECTORY);
192      }
193    
194    
195    
196      // Build the "cache-type" property definition.
197      static {
198          EnumPropertyDefinition.Builder<CacheType> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "cache-type");
199          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "cache-type"));
200          DefaultBehaviorProvider<CacheType> provider = new DefinedDefaultBehaviorProvider<CacheType>("fifo");
201          builder.setDefaultBehaviorProvider(provider);
202          builder.setEnumClass(CacheType.class);
203          PD_CACHE_TYPE = builder.getInstance();
204          INSTANCE.registerPropertyDefinition(PD_CACHE_TYPE);
205      }
206    
207    
208    
209      // Build the "compact-encoding" property definition.
210      static {
211          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "compact-encoding");
212          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "compact-encoding"));
213          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
214          builder.setDefaultBehaviorProvider(provider);
215          PD_COMPACT_ENCODING = builder.getInstance();
216          INSTANCE.registerPropertyDefinition(PD_COMPACT_ENCODING);
217      }
218    
219    
220    
221      // Build the "db-cache-percent" property definition.
222      static {
223          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "db-cache-percent");
224          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-percent"));
225          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("1");
226          builder.setDefaultBehaviorProvider(provider);
227          builder.setUpperLimit(90);
228          builder.setLowerLimit(0);
229          PD_DB_CACHE_PERCENT = builder.getInstance();
230          INSTANCE.registerPropertyDefinition(PD_DB_CACHE_PERCENT);
231      }
232    
233    
234    
235      // Build the "db-cache-size" property definition.
236      static {
237          SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "db-cache-size");
238          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "db-cache-size"));
239          DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0b");
240          builder.setDefaultBehaviorProvider(provider);
241          PD_DB_CACHE_SIZE = builder.getInstance();
242          INSTANCE.registerPropertyDefinition(PD_DB_CACHE_SIZE);
243      }
244    
245    
246    
247      // Build the "exclude-filter" property definition.
248      static {
249          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "exclude-filter");
250          builder.setOption(PropertyOption.MULTI_VALUED);
251          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "exclude-filter"));
252          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
253          PD_EXCLUDE_FILTER = builder.getInstance();
254          INSTANCE.registerPropertyDefinition(PD_EXCLUDE_FILTER);
255      }
256    
257    
258    
259      // Build the "include-filter" property definition.
260      static {
261          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "include-filter");
262          builder.setOption(PropertyOption.MULTI_VALUED);
263          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "include-filter"));
264          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
265          PD_INCLUDE_FILTER = builder.getInstance();
266          INSTANCE.registerPropertyDefinition(PD_INCLUDE_FILTER);
267      }
268    
269    
270    
271      // Build the "java-class" property definition.
272      static {
273          ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
274          builder.setOption(PropertyOption.MANDATORY);
275          builder.setOption(PropertyOption.ADVANCED);
276          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
277          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.FileSystemEntryCache");
278          builder.setDefaultBehaviorProvider(provider);
279          builder.addInstanceOf("org.opends.server.api.EntryCache");
280          PD_JAVA_CLASS = builder.getInstance();
281          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
282      }
283    
284    
285    
286      // Build the "je-property" property definition.
287      static {
288          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "je-property");
289          builder.setOption(PropertyOption.MULTI_VALUED);
290          builder.setOption(PropertyOption.ADVANCED);
291          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "je-property"));
292          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("je.env.isLocking=false");
293          builder.setDefaultBehaviorProvider(provider);
294          PD_JE_PROPERTY = builder.getInstance();
295          INSTANCE.registerPropertyDefinition(PD_JE_PROPERTY);
296      }
297    
298    
299    
300      // Build the "lock-timeout" property definition.
301      static {
302          DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "lock-timeout");
303          builder.setOption(PropertyOption.ADVANCED);
304          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "lock-timeout"));
305          DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("2000.0ms");
306          builder.setDefaultBehaviorProvider(provider);
307          builder.setAllowUnlimited(true);
308          builder.setBaseUnit("ms");
309          PD_LOCK_TIMEOUT = builder.getInstance();
310          INSTANCE.registerPropertyDefinition(PD_LOCK_TIMEOUT);
311      }
312    
313    
314    
315      // Build the "max-entries" property definition.
316      static {
317          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-entries");
318          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-entries"));
319          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("2147483647");
320          builder.setDefaultBehaviorProvider(provider);
321          builder.setLowerLimit(0);
322          PD_MAX_ENTRIES = builder.getInstance();
323          INSTANCE.registerPropertyDefinition(PD_MAX_ENTRIES);
324      }
325    
326    
327    
328      // Build the "max-memory-size" property definition.
329      static {
330          SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "max-memory-size");
331          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-memory-size"));
332          DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0b");
333          builder.setDefaultBehaviorProvider(provider);
334          PD_MAX_MEMORY_SIZE = builder.getInstance();
335          INSTANCE.registerPropertyDefinition(PD_MAX_MEMORY_SIZE);
336      }
337    
338    
339    
340      // Build the "persistent-cache" property definition.
341      static {
342          BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "persistent-cache");
343          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "persistent-cache"));
344          DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
345          builder.setDefaultBehaviorProvider(provider);
346          PD_PERSISTENT_CACHE = builder.getInstance();
347          INSTANCE.registerPropertyDefinition(PD_PERSISTENT_CACHE);
348      }
349    
350    
351    
352      // Register the tags associated with this managed object definition.
353      static {
354        INSTANCE.registerTag(Tag.valueOf("database"));
355      }
356    
357    
358    
359      /**
360       * Get the File System Entry Cache configuration definition
361       * singleton.
362       *
363       * @return Returns the File System Entry Cache configuration
364       *         definition singleton.
365       */
366      public static FileSystemEntryCacheCfgDefn getInstance() {
367        return INSTANCE;
368      }
369    
370    
371    
372      /**
373       * Private constructor.
374       */
375      private FileSystemEntryCacheCfgDefn() {
376        super("file-system-entry-cache", EntryCacheCfgDefn.getInstance());
377      }
378    
379    
380    
381      /**
382       * {@inheritDoc}
383       */
384      public FileSystemEntryCacheCfgClient createClientConfiguration(
385          ManagedObject<? extends FileSystemEntryCacheCfgClient> impl) {
386        return new FileSystemEntryCacheCfgClientImpl(impl);
387      }
388    
389    
390    
391      /**
392       * {@inheritDoc}
393       */
394      public FileSystemEntryCacheCfg createServerConfiguration(
395          ServerManagedObject<? extends FileSystemEntryCacheCfg> impl) {
396        return new FileSystemEntryCacheCfgServerImpl(impl);
397      }
398    
399    
400    
401      /**
402       * {@inheritDoc}
403       */
404      public Class<FileSystemEntryCacheCfg> getServerConfigurationClass() {
405        return FileSystemEntryCacheCfg.class;
406      }
407    
408    
409    
410      /**
411       * Get the "cache-directory" property definition.
412       * <p>
413       * Specifies the directory in which the JE environment should store
414       * the cache.
415       *
416       * @return Returns the "cache-directory" property definition.
417       */
418      public StringPropertyDefinition getCacheDirectoryPropertyDefinition() {
419        return PD_CACHE_DIRECTORY;
420      }
421    
422    
423    
424      /**
425       * Get the "cache-level" property definition.
426       * <p>
427       * Specifies the cache level in the cache order if more than one
428       * instance of the cache is configured.
429       *
430       * @return Returns the "cache-level" property definition.
431       */
432      public IntegerPropertyDefinition getCacheLevelPropertyDefinition() {
433        return EntryCacheCfgDefn.getInstance().getCacheLevelPropertyDefinition();
434      }
435    
436    
437    
438      /**
439       * Get the "cache-type" property definition.
440       * <p>
441       * Specifies the policy which should be used for purging entries
442       * from the cache.
443       *
444       * @return Returns the "cache-type" property definition.
445       */
446      public EnumPropertyDefinition<CacheType> getCacheTypePropertyDefinition() {
447        return PD_CACHE_TYPE;
448      }
449    
450    
451    
452      /**
453       * Get the "compact-encoding" property definition.
454       * <p>
455       * Indicates whether the cache should use a compact form when
456       * encoding cache entries by compressing the attribute descriptions
457       * and object class sets.
458       * <p>
459       * Note that compression does not preserve user-supplied
460       * capitalization in the object class and attribute type names.
461       *
462       * @return Returns the "compact-encoding" property definition.
463       */
464      public BooleanPropertyDefinition getCompactEncodingPropertyDefinition() {
465        return PD_COMPACT_ENCODING;
466      }
467    
468    
469    
470      /**
471       * Get the "db-cache-percent" property definition.
472       * <p>
473       * Specifies the maximum memory usage for the internal JE cache as a
474       * percentage of the total JVM memory.
475       *
476       * @return Returns the "db-cache-percent" property definition.
477       */
478      public IntegerPropertyDefinition getDBCachePercentPropertyDefinition() {
479        return PD_DB_CACHE_PERCENT;
480      }
481    
482    
483    
484      /**
485       * Get the "db-cache-size" property definition.
486       * <p>
487       * Specifies the maximum JVM memory usage in bytes for the internal
488       * JE cache.
489       *
490       * @return Returns the "db-cache-size" property definition.
491       */
492      public SizePropertyDefinition getDBCacheSizePropertyDefinition() {
493        return PD_DB_CACHE_SIZE;
494      }
495    
496    
497    
498      /**
499       * Get the "enabled" property definition.
500       * <p>
501       * Indicates whether the File System Entry Cache is enabled.
502       *
503       * @return Returns the "enabled" property definition.
504       */
505      public BooleanPropertyDefinition getEnabledPropertyDefinition() {
506        return EntryCacheCfgDefn.getInstance().getEnabledPropertyDefinition();
507      }
508    
509    
510    
511      /**
512       * Get the "exclude-filter" property definition.
513       * <p>
514       * The set of filters that define the entries that should be
515       * excluded from the cache.
516       *
517       * @return Returns the "exclude-filter" property definition.
518       */
519      public StringPropertyDefinition getExcludeFilterPropertyDefinition() {
520        return PD_EXCLUDE_FILTER;
521      }
522    
523    
524    
525      /**
526       * Get the "include-filter" property definition.
527       * <p>
528       * The set of filters that define the entries that should be
529       * included in the cache.
530       *
531       * @return Returns the "include-filter" property definition.
532       */
533      public StringPropertyDefinition getIncludeFilterPropertyDefinition() {
534        return PD_INCLUDE_FILTER;
535      }
536    
537    
538    
539      /**
540       * Get the "java-class" property definition.
541       * <p>
542       * Specifies the fully-qualified name of the Java class that
543       * provides the File System Entry Cache implementation.
544       *
545       * @return Returns the "java-class" property definition.
546       */
547      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
548        return PD_JAVA_CLASS;
549      }
550    
551    
552    
553      /**
554       * Get the "je-property" property definition.
555       * <p>
556       * Specifies the environment properties for the Berkeley DB Java
557       * Edition database providing the backend for this entry cache.
558       * <p>
559       * Any Berkeley DB Java Edition property can be specified using the
560       * following form: property-name=property-value. Refer to the OpenDS
561       * documentation for further information on related properties, their
562       * implications and range values. The definitive identification of
563       * all the property parameters available in the example.properties
564       * file in the Berkeley DB Java Edition distribution.
565       *
566       * @return Returns the "je-property" property definition.
567       */
568      public StringPropertyDefinition getJEPropertyPropertyDefinition() {
569        return PD_JE_PROPERTY;
570      }
571    
572    
573    
574      /**
575       * Get the "lock-timeout" property definition.
576       * <p>
577       * The length of time to wait while attempting to acquire a read or
578       * write lock.
579       *
580       * @return Returns the "lock-timeout" property definition.
581       */
582      public DurationPropertyDefinition getLockTimeoutPropertyDefinition() {
583        return PD_LOCK_TIMEOUT;
584      }
585    
586    
587    
588      /**
589       * Get the "max-entries" property definition.
590       * <p>
591       * The maximum number of entries allowed in the cache.
592       *
593       * @return Returns the "max-entries" property definition.
594       */
595      public IntegerPropertyDefinition getMaxEntriesPropertyDefinition() {
596        return PD_MAX_ENTRIES;
597      }
598    
599    
600    
601      /**
602       * Get the "max-memory-size" property definition.
603       * <p>
604       * The maximum size of the entry cache in bytes.
605       *
606       * @return Returns the "max-memory-size" property definition.
607       */
608      public SizePropertyDefinition getMaxMemorySizePropertyDefinition() {
609        return PD_MAX_MEMORY_SIZE;
610      }
611    
612    
613    
614      /**
615       * Get the "persistent-cache" property definition.
616       * <p>
617       * Specifies whether the cache should persist across restarts.
618       *
619       * @return Returns the "persistent-cache" property definition.
620       */
621      public BooleanPropertyDefinition getPersistentCachePropertyDefinition() {
622        return PD_PERSISTENT_CACHE;
623      }
624    
625    
626    
627      /**
628       * Managed object client implementation.
629       */
630      private static class FileSystemEntryCacheCfgClientImpl implements
631        FileSystemEntryCacheCfgClient {
632    
633        // Private implementation.
634        private ManagedObject<? extends FileSystemEntryCacheCfgClient> impl;
635    
636    
637    
638        // Private constructor.
639        private FileSystemEntryCacheCfgClientImpl(
640            ManagedObject<? extends FileSystemEntryCacheCfgClient> impl) {
641          this.impl = impl;
642        }
643    
644    
645    
646        /**
647         * {@inheritDoc}
648         */
649        public String getCacheDirectory() {
650          return impl.getPropertyValue(INSTANCE.getCacheDirectoryPropertyDefinition());
651        }
652    
653    
654    
655        /**
656         * {@inheritDoc}
657         */
658        public void setCacheDirectory(String value) {
659          impl.setPropertyValue(INSTANCE.getCacheDirectoryPropertyDefinition(), value);
660        }
661    
662    
663    
664        /**
665         * {@inheritDoc}
666         */
667        public Integer getCacheLevel() {
668          return impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
669        }
670    
671    
672    
673        /**
674         * {@inheritDoc}
675         */
676        public void setCacheLevel(int value) {
677          impl.setPropertyValue(INSTANCE.getCacheLevelPropertyDefinition(), value);
678        }
679    
680    
681    
682        /**
683         * {@inheritDoc}
684         */
685        public CacheType getCacheType() {
686          return impl.getPropertyValue(INSTANCE.getCacheTypePropertyDefinition());
687        }
688    
689    
690    
691        /**
692         * {@inheritDoc}
693         */
694        public void setCacheType(CacheType value) {
695          impl.setPropertyValue(INSTANCE.getCacheTypePropertyDefinition(), value);
696        }
697    
698    
699    
700        /**
701         * {@inheritDoc}
702         */
703        public boolean isCompactEncoding() {
704          return impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition());
705        }
706    
707    
708    
709        /**
710         * {@inheritDoc}
711         */
712        public void setCompactEncoding(Boolean value) {
713          impl.setPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition(), value);
714        }
715    
716    
717    
718        /**
719         * {@inheritDoc}
720         */
721        public int getDBCachePercent() {
722          return impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition());
723        }
724    
725    
726    
727        /**
728         * {@inheritDoc}
729         */
730        public void setDBCachePercent(Integer value) {
731          impl.setPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition(), value);
732        }
733    
734    
735    
736        /**
737         * {@inheritDoc}
738         */
739        public long getDBCacheSize() {
740          return impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition());
741        }
742    
743    
744    
745        /**
746         * {@inheritDoc}
747         */
748        public void setDBCacheSize(Long value) {
749          impl.setPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition(), value);
750        }
751    
752    
753    
754        /**
755         * {@inheritDoc}
756         */
757        public Boolean isEnabled() {
758          return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
759        }
760    
761    
762    
763        /**
764         * {@inheritDoc}
765         */
766        public void setEnabled(boolean value) {
767          impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
768        }
769    
770    
771    
772        /**
773         * {@inheritDoc}
774         */
775        public SortedSet<String> getExcludeFilter() {
776          return impl.getPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition());
777        }
778    
779    
780    
781        /**
782         * {@inheritDoc}
783         */
784        public void setExcludeFilter(Collection<String> values) {
785          impl.setPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition(), values);
786        }
787    
788    
789    
790        /**
791         * {@inheritDoc}
792         */
793        public SortedSet<String> getIncludeFilter() {
794          return impl.getPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition());
795        }
796    
797    
798    
799        /**
800         * {@inheritDoc}
801         */
802        public void setIncludeFilter(Collection<String> values) {
803          impl.setPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition(), values);
804        }
805    
806    
807    
808        /**
809         * {@inheritDoc}
810         */
811        public String getJavaClass() {
812          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
813        }
814    
815    
816    
817        /**
818         * {@inheritDoc}
819         */
820        public void setJavaClass(String value) {
821          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
822        }
823    
824    
825    
826        /**
827         * {@inheritDoc}
828         */
829        public SortedSet<String> getJEProperty() {
830          return impl.getPropertyValues(INSTANCE.getJEPropertyPropertyDefinition());
831        }
832    
833    
834    
835        /**
836         * {@inheritDoc}
837         */
838        public void setJEProperty(Collection<String> values) {
839          impl.setPropertyValues(INSTANCE.getJEPropertyPropertyDefinition(), values);
840        }
841    
842    
843    
844        /**
845         * {@inheritDoc}
846         */
847        public long getLockTimeout() {
848          return impl.getPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition());
849        }
850    
851    
852    
853        /**
854         * {@inheritDoc}
855         */
856        public void setLockTimeout(Long value) {
857          impl.setPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition(), value);
858        }
859    
860    
861    
862        /**
863         * {@inheritDoc}
864         */
865        public int getMaxEntries() {
866          return impl.getPropertyValue(INSTANCE.getMaxEntriesPropertyDefinition());
867        }
868    
869    
870    
871        /**
872         * {@inheritDoc}
873         */
874        public void setMaxEntries(Integer value) {
875          impl.setPropertyValue(INSTANCE.getMaxEntriesPropertyDefinition(), value);
876        }
877    
878    
879    
880        /**
881         * {@inheritDoc}
882         */
883        public long getMaxMemorySize() {
884          return impl.getPropertyValue(INSTANCE.getMaxMemorySizePropertyDefinition());
885        }
886    
887    
888    
889        /**
890         * {@inheritDoc}
891         */
892        public void setMaxMemorySize(Long value) {
893          impl.setPropertyValue(INSTANCE.getMaxMemorySizePropertyDefinition(), value);
894        }
895    
896    
897    
898        /**
899         * {@inheritDoc}
900         */
901        public boolean isPersistentCache() {
902          return impl.getPropertyValue(INSTANCE.getPersistentCachePropertyDefinition());
903        }
904    
905    
906    
907        /**
908         * {@inheritDoc}
909         */
910        public void setPersistentCache(Boolean value) {
911          impl.setPropertyValue(INSTANCE.getPersistentCachePropertyDefinition(), value);
912        }
913    
914    
915    
916        /**
917         * {@inheritDoc}
918         */
919        public ManagedObjectDefinition<? extends FileSystemEntryCacheCfgClient, ? extends FileSystemEntryCacheCfg> definition() {
920          return INSTANCE;
921        }
922    
923    
924    
925        /**
926         * {@inheritDoc}
927         */
928        public PropertyProvider properties() {
929          return impl;
930        }
931    
932    
933    
934        /**
935         * {@inheritDoc}
936         */
937        public void commit() throws ManagedObjectAlreadyExistsException,
938            MissingMandatoryPropertiesException, ConcurrentModificationException,
939            OperationRejectedException, AuthorizationException,
940            CommunicationException {
941          impl.commit();
942        }
943    
944      }
945    
946    
947    
948      /**
949       * Managed object server implementation.
950       */
951      private static class FileSystemEntryCacheCfgServerImpl implements
952        FileSystemEntryCacheCfg {
953    
954        // Private implementation.
955        private ServerManagedObject<? extends FileSystemEntryCacheCfg> impl;
956    
957        // The value of the "cache-directory" property.
958        private final String pCacheDirectory;
959    
960        // The value of the "cache-level" property.
961        private final int pCacheLevel;
962    
963        // The value of the "cache-type" property.
964        private final CacheType pCacheType;
965    
966        // The value of the "compact-encoding" property.
967        private final boolean pCompactEncoding;
968    
969        // The value of the "db-cache-percent" property.
970        private final int pDBCachePercent;
971    
972        // The value of the "db-cache-size" property.
973        private final long pDBCacheSize;
974    
975        // The value of the "enabled" property.
976        private final boolean pEnabled;
977    
978        // The value of the "exclude-filter" property.
979        private final SortedSet<String> pExcludeFilter;
980    
981        // The value of the "include-filter" property.
982        private final SortedSet<String> pIncludeFilter;
983    
984        // The value of the "java-class" property.
985        private final String pJavaClass;
986    
987        // The value of the "je-property" property.
988        private final SortedSet<String> pJEProperty;
989    
990        // The value of the "lock-timeout" property.
991        private final long pLockTimeout;
992    
993        // The value of the "max-entries" property.
994        private final int pMaxEntries;
995    
996        // The value of the "max-memory-size" property.
997        private final long pMaxMemorySize;
998    
999        // The value of the "persistent-cache" property.
1000        private final boolean pPersistentCache;
1001    
1002    
1003    
1004        // Private constructor.
1005        private FileSystemEntryCacheCfgServerImpl(ServerManagedObject<? extends FileSystemEntryCacheCfg> impl) {
1006          this.impl = impl;
1007          this.pCacheDirectory = impl.getPropertyValue(INSTANCE.getCacheDirectoryPropertyDefinition());
1008          this.pCacheLevel = impl.getPropertyValue(INSTANCE.getCacheLevelPropertyDefinition());
1009          this.pCacheType = impl.getPropertyValue(INSTANCE.getCacheTypePropertyDefinition());
1010          this.pCompactEncoding = impl.getPropertyValue(INSTANCE.getCompactEncodingPropertyDefinition());
1011          this.pDBCachePercent = impl.getPropertyValue(INSTANCE.getDBCachePercentPropertyDefinition());
1012          this.pDBCacheSize = impl.getPropertyValue(INSTANCE.getDBCacheSizePropertyDefinition());
1013          this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
1014          this.pExcludeFilter = impl.getPropertyValues(INSTANCE.getExcludeFilterPropertyDefinition());
1015          this.pIncludeFilter = impl.getPropertyValues(INSTANCE.getIncludeFilterPropertyDefinition());
1016          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
1017          this.pJEProperty = impl.getPropertyValues(INSTANCE.getJEPropertyPropertyDefinition());
1018          this.pLockTimeout = impl.getPropertyValue(INSTANCE.getLockTimeoutPropertyDefinition());
1019          this.pMaxEntries = impl.getPropertyValue(INSTANCE.getMaxEntriesPropertyDefinition());
1020          this.pMaxMemorySize = impl.getPropertyValue(INSTANCE.getMaxMemorySizePropertyDefinition());
1021          this.pPersistentCache = impl.getPropertyValue(INSTANCE.getPersistentCachePropertyDefinition());
1022        }
1023    
1024    
1025    
1026        /**
1027         * {@inheritDoc}
1028         */
1029        public void addFileSystemChangeListener(
1030            ConfigurationChangeListener<FileSystemEntryCacheCfg> listener) {
1031          impl.registerChangeListener(listener);
1032        }
1033    
1034    
1035    
1036        /**
1037         * {@inheritDoc}
1038         */
1039        public void removeFileSystemChangeListener(
1040            ConfigurationChangeListener<FileSystemEntryCacheCfg> listener) {
1041          impl.deregisterChangeListener(listener);
1042        }
1043        /**
1044         * {@inheritDoc}
1045         */
1046        public void addChangeListener(
1047            ConfigurationChangeListener<EntryCacheCfg> listener) {
1048          impl.registerChangeListener(listener);
1049        }
1050    
1051    
1052    
1053        /**
1054         * {@inheritDoc}
1055         */
1056        public void removeChangeListener(
1057            ConfigurationChangeListener<EntryCacheCfg> listener) {
1058          impl.deregisterChangeListener(listener);
1059        }
1060    
1061    
1062    
1063        /**
1064         * {@inheritDoc}
1065         */
1066        public String getCacheDirectory() {
1067          return pCacheDirectory;
1068        }
1069    
1070    
1071    
1072        /**
1073         * {@inheritDoc}
1074         */
1075        public int getCacheLevel() {
1076          return pCacheLevel;
1077        }
1078    
1079    
1080    
1081        /**
1082         * {@inheritDoc}
1083         */
1084        public CacheType getCacheType() {
1085          return pCacheType;
1086        }
1087    
1088    
1089    
1090        /**
1091         * {@inheritDoc}
1092         */
1093        public boolean isCompactEncoding() {
1094          return pCompactEncoding;
1095        }
1096    
1097    
1098    
1099        /**
1100         * {@inheritDoc}
1101         */
1102        public int getDBCachePercent() {
1103          return pDBCachePercent;
1104        }
1105    
1106    
1107    
1108        /**
1109         * {@inheritDoc}
1110         */
1111        public long getDBCacheSize() {
1112          return pDBCacheSize;
1113        }
1114    
1115    
1116    
1117        /**
1118         * {@inheritDoc}
1119         */
1120        public boolean isEnabled() {
1121          return pEnabled;
1122        }
1123    
1124    
1125    
1126        /**
1127         * {@inheritDoc}
1128         */
1129        public SortedSet<String> getExcludeFilter() {
1130          return pExcludeFilter;
1131        }
1132    
1133    
1134    
1135        /**
1136         * {@inheritDoc}
1137         */
1138        public SortedSet<String> getIncludeFilter() {
1139          return pIncludeFilter;
1140        }
1141    
1142    
1143    
1144        /**
1145         * {@inheritDoc}
1146         */
1147        public String getJavaClass() {
1148          return pJavaClass;
1149        }
1150    
1151    
1152    
1153        /**
1154         * {@inheritDoc}
1155         */
1156        public SortedSet<String> getJEProperty() {
1157          return pJEProperty;
1158        }
1159    
1160    
1161    
1162        /**
1163         * {@inheritDoc}
1164         */
1165        public long getLockTimeout() {
1166          return pLockTimeout;
1167        }
1168    
1169    
1170    
1171        /**
1172         * {@inheritDoc}
1173         */
1174        public int getMaxEntries() {
1175          return pMaxEntries;
1176        }
1177    
1178    
1179    
1180        /**
1181         * {@inheritDoc}
1182         */
1183        public long getMaxMemorySize() {
1184          return pMaxMemorySize;
1185        }
1186    
1187    
1188    
1189        /**
1190         * {@inheritDoc}
1191         */
1192        public boolean isPersistentCache() {
1193          return pPersistentCache;
1194        }
1195    
1196    
1197    
1198        /**
1199         * {@inheritDoc}
1200         */
1201        public Class<? extends FileSystemEntryCacheCfg> configurationClass() {
1202          return FileSystemEntryCacheCfg.class;
1203        }
1204    
1205    
1206    
1207        /**
1208         * {@inheritDoc}
1209         */
1210        public DN dn() {
1211          return impl.getDN();
1212        }
1213    
1214      }
1215    }