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.client.AuthorizationException;
033    import org.opends.server.admin.client.CommunicationException;
034    import org.opends.server.admin.client.ConcurrentModificationException;
035    import org.opends.server.admin.client.ManagedObject;
036    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
037    import org.opends.server.admin.client.OperationRejectedException;
038    import org.opends.server.admin.DefaultBehaviorProvider;
039    import org.opends.server.admin.DefinedDefaultBehaviorProvider;
040    import org.opends.server.admin.DNPropertyDefinition;
041    import org.opends.server.admin.EnumPropertyDefinition;
042    import org.opends.server.admin.IntegerPropertyDefinition;
043    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
044    import org.opends.server.admin.ManagedObjectDefinition;
045    import org.opends.server.admin.PropertyIsReadOnlyException;
046    import org.opends.server.admin.PropertyOption;
047    import org.opends.server.admin.PropertyProvider;
048    import org.opends.server.admin.server.ConfigurationChangeListener;
049    import org.opends.server.admin.server.ServerManagedObject;
050    import org.opends.server.admin.std.client.LocalDBVLVIndexCfgClient;
051    import org.opends.server.admin.std.server.LocalDBVLVIndexCfg;
052    import org.opends.server.admin.StringPropertyDefinition;
053    import org.opends.server.admin.Tag;
054    import org.opends.server.admin.TopCfgDefn;
055    import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
056    import org.opends.server.types.DN;
057    
058    
059    
060    /**
061     * An interface for querying the Local DB VLV Index managed object
062     * definition meta information.
063     * <p>
064     * Local DB VLV Indexes are used to store information about a specific
065     * search request that makes it possible to efficiently process them
066     * using the VLV control.
067     */
068    public final class LocalDBVLVIndexCfgDefn extends ManagedObjectDefinition<LocalDBVLVIndexCfgClient, LocalDBVLVIndexCfg> {
069    
070      // The singleton configuration definition instance.
071      private static final LocalDBVLVIndexCfgDefn INSTANCE = new LocalDBVLVIndexCfgDefn();
072    
073    
074    
075      /**
076       * Defines the set of permissable values for the "scope" property.
077       * <p>
078       * Specifies the LDAP scope of the query that is being indexed.
079       */
080      public static enum Scope {
081    
082        /**
083         * Search the base object only.
084         */
085        BASE_OBJECT("base-object"),
086    
087    
088    
089        /**
090         * Search the immediate children of the base object but do not
091         * include any of their descendants or the base object itself.
092         */
093        SINGLE_LEVEL("single-level"),
094    
095    
096    
097        /**
098         * Search the entire subtree below the base object but do not
099         * include the base object itself.
100         */
101        SUBORDINATE_SUBTREE("subordinate-subtree"),
102    
103    
104    
105        /**
106         * Search the base object and the entire subtree below the base
107         * object.
108         */
109        WHOLE_SUBTREE("whole-subtree");
110    
111    
112    
113        // String representation of the value.
114        private final String name;
115    
116    
117    
118        // Private constructor.
119        private Scope(String name) { this.name = name; }
120    
121    
122    
123        /**
124         * {@inheritDoc}
125         */
126        public String toString() { return name; }
127    
128      }
129    
130    
131    
132      // The "base-dn" property definition.
133      private static final DNPropertyDefinition PD_BASE_DN;
134    
135    
136    
137      // The "filter" property definition.
138      private static final StringPropertyDefinition PD_FILTER;
139    
140    
141    
142      // The "max-block-size" property definition.
143      private static final IntegerPropertyDefinition PD_MAX_BLOCK_SIZE;
144    
145    
146    
147      // The "name" property definition.
148      private static final StringPropertyDefinition PD_NAME;
149    
150    
151    
152      // The "scope" property definition.
153      private static final EnumPropertyDefinition<Scope> PD_SCOPE;
154    
155    
156    
157      // The "sort-order" property definition.
158      private static final StringPropertyDefinition PD_SORT_ORDER;
159    
160    
161    
162      // Build the "base-dn" property definition.
163      static {
164          DNPropertyDefinition.Builder builder = DNPropertyDefinition.createBuilder(INSTANCE, "base-dn");
165          builder.setOption(PropertyOption.MANDATORY);
166          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "base-dn"));
167          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<DN>());
168          PD_BASE_DN = builder.getInstance();
169          INSTANCE.registerPropertyDefinition(PD_BASE_DN);
170      }
171    
172    
173    
174      // Build the "filter" property definition.
175      static {
176          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "filter");
177          builder.setOption(PropertyOption.MANDATORY);
178          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "filter"));
179          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
180          builder.setPattern(".*", "STRING");
181          PD_FILTER = builder.getInstance();
182          INSTANCE.registerPropertyDefinition(PD_FILTER);
183      }
184    
185    
186    
187      // Build the "max-block-size" property definition.
188      static {
189          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-block-size");
190          builder.setOption(PropertyOption.READ_ONLY);
191          builder.setOption(PropertyOption.ADVANCED);
192          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-block-size"));
193          DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("4000");
194          builder.setDefaultBehaviorProvider(provider);
195          PD_MAX_BLOCK_SIZE = builder.getInstance();
196          INSTANCE.registerPropertyDefinition(PD_MAX_BLOCK_SIZE);
197      }
198    
199    
200    
201      // Build the "name" property definition.
202      static {
203          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "name");
204          builder.setOption(PropertyOption.READ_ONLY);
205          builder.setOption(PropertyOption.MANDATORY);
206          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "name"));
207          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
208          PD_NAME = builder.getInstance();
209          INSTANCE.registerPropertyDefinition(PD_NAME);
210      }
211    
212    
213    
214      // Build the "scope" property definition.
215      static {
216          EnumPropertyDefinition.Builder<Scope> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "scope");
217          builder.setOption(PropertyOption.MANDATORY);
218          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "scope"));
219          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Scope>());
220          builder.setEnumClass(Scope.class);
221          PD_SCOPE = builder.getInstance();
222          INSTANCE.registerPropertyDefinition(PD_SCOPE);
223      }
224    
225    
226    
227      // Build the "sort-order" property definition.
228      static {
229          StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "sort-order");
230          builder.setOption(PropertyOption.MANDATORY);
231          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.OTHER, INSTANCE, "sort-order"));
232          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
233          builder.setPattern(".*", "STRING");
234          PD_SORT_ORDER = builder.getInstance();
235          INSTANCE.registerPropertyDefinition(PD_SORT_ORDER);
236      }
237    
238    
239    
240      // Register the tags associated with this managed object definition.
241      static {
242        INSTANCE.registerTag(Tag.valueOf("database"));
243      }
244    
245    
246    
247      /**
248       * Get the Local DB VLV Index configuration definition singleton.
249       *
250       * @return Returns the Local DB VLV Index configuration definition
251       *         singleton.
252       */
253      public static LocalDBVLVIndexCfgDefn getInstance() {
254        return INSTANCE;
255      }
256    
257    
258    
259      /**
260       * Private constructor.
261       */
262      private LocalDBVLVIndexCfgDefn() {
263        super("local-db-vlv-index", TopCfgDefn.getInstance());
264      }
265    
266    
267    
268      /**
269       * {@inheritDoc}
270       */
271      public LocalDBVLVIndexCfgClient createClientConfiguration(
272          ManagedObject<? extends LocalDBVLVIndexCfgClient> impl) {
273        return new LocalDBVLVIndexCfgClientImpl(impl);
274      }
275    
276    
277    
278      /**
279       * {@inheritDoc}
280       */
281      public LocalDBVLVIndexCfg createServerConfiguration(
282          ServerManagedObject<? extends LocalDBVLVIndexCfg> impl) {
283        return new LocalDBVLVIndexCfgServerImpl(impl);
284      }
285    
286    
287    
288      /**
289       * {@inheritDoc}
290       */
291      public Class<LocalDBVLVIndexCfg> getServerConfigurationClass() {
292        return LocalDBVLVIndexCfg.class;
293      }
294    
295    
296    
297      /**
298       * Get the "base-dn" property definition.
299       * <p>
300       * Specifies the base DN used in the search query that is being
301       * indexed.
302       *
303       * @return Returns the "base-dn" property definition.
304       */
305      public DNPropertyDefinition getBaseDNPropertyDefinition() {
306        return PD_BASE_DN;
307      }
308    
309    
310    
311      /**
312       * Get the "filter" property definition.
313       * <p>
314       * Specifies the LDAP filter used in the query that is being
315       * indexed.
316       *
317       * @return Returns the "filter" property definition.
318       */
319      public StringPropertyDefinition getFilterPropertyDefinition() {
320        return PD_FILTER;
321      }
322    
323    
324    
325      /**
326       * Get the "max-block-size" property definition.
327       * <p>
328       * Specifies the number of entry IDs to store in a single sorted set
329       * before it must be split.
330       *
331       * @return Returns the "max-block-size" property definition.
332       */
333      public IntegerPropertyDefinition getMaxBlockSizePropertyDefinition() {
334        return PD_MAX_BLOCK_SIZE;
335      }
336    
337    
338    
339      /**
340       * Get the "name" property definition.
341       * <p>
342       * Specifies a unique name for this VLV index.
343       *
344       * @return Returns the "name" property definition.
345       */
346      public StringPropertyDefinition getNamePropertyDefinition() {
347        return PD_NAME;
348      }
349    
350    
351    
352      /**
353       * Get the "scope" property definition.
354       * <p>
355       * Specifies the LDAP scope of the query that is being indexed.
356       *
357       * @return Returns the "scope" property definition.
358       */
359      public EnumPropertyDefinition<Scope> getScopePropertyDefinition() {
360        return PD_SCOPE;
361      }
362    
363    
364    
365      /**
366       * Get the "sort-order" property definition.
367       * <p>
368       * Specifies the names of the attributes that are used to sort the
369       * entries for the query being indexed.
370       * <p>
371       * Multiple attributes can be used to determine the sort order by
372       * listing the attribute names from highest to lowest precedence.
373       * Optionally, + or - can be prefixed to the attribute name to sort
374       * the attribute in ascending order or descending order respectively.
375       *
376       * @return Returns the "sort-order" property definition.
377       */
378      public StringPropertyDefinition getSortOrderPropertyDefinition() {
379        return PD_SORT_ORDER;
380      }
381    
382    
383    
384      /**
385       * Managed object client implementation.
386       */
387      private static class LocalDBVLVIndexCfgClientImpl implements
388        LocalDBVLVIndexCfgClient {
389    
390        // Private implementation.
391        private ManagedObject<? extends LocalDBVLVIndexCfgClient> impl;
392    
393    
394    
395        // Private constructor.
396        private LocalDBVLVIndexCfgClientImpl(
397            ManagedObject<? extends LocalDBVLVIndexCfgClient> impl) {
398          this.impl = impl;
399        }
400    
401    
402    
403        /**
404         * {@inheritDoc}
405         */
406        public DN getBaseDN() {
407          return impl.getPropertyValue(INSTANCE.getBaseDNPropertyDefinition());
408        }
409    
410    
411    
412        /**
413         * {@inheritDoc}
414         */
415        public void setBaseDN(DN value) {
416          impl.setPropertyValue(INSTANCE.getBaseDNPropertyDefinition(), value);
417        }
418    
419    
420    
421        /**
422         * {@inheritDoc}
423         */
424        public String getFilter() {
425          return impl.getPropertyValue(INSTANCE.getFilterPropertyDefinition());
426        }
427    
428    
429    
430        /**
431         * {@inheritDoc}
432         */
433        public void setFilter(String value) {
434          impl.setPropertyValue(INSTANCE.getFilterPropertyDefinition(), value);
435        }
436    
437    
438    
439        /**
440         * {@inheritDoc}
441         */
442        public int getMaxBlockSize() {
443          return impl.getPropertyValue(INSTANCE.getMaxBlockSizePropertyDefinition());
444        }
445    
446    
447    
448        /**
449         * {@inheritDoc}
450         */
451        public void setMaxBlockSize(Integer value) throws PropertyIsReadOnlyException {
452          impl.setPropertyValue(INSTANCE.getMaxBlockSizePropertyDefinition(), value);
453        }
454    
455    
456    
457        /**
458         * {@inheritDoc}
459         */
460        public String getName() {
461          return impl.getPropertyValue(INSTANCE.getNamePropertyDefinition());
462        }
463    
464    
465    
466        /**
467         * {@inheritDoc}
468         */
469        public void setName(String value) throws PropertyIsReadOnlyException {
470          impl.setPropertyValue(INSTANCE.getNamePropertyDefinition(), value);
471        }
472    
473    
474    
475        /**
476         * {@inheritDoc}
477         */
478        public Scope getScope() {
479          return impl.getPropertyValue(INSTANCE.getScopePropertyDefinition());
480        }
481    
482    
483    
484        /**
485         * {@inheritDoc}
486         */
487        public void setScope(Scope value) {
488          impl.setPropertyValue(INSTANCE.getScopePropertyDefinition(), value);
489        }
490    
491    
492    
493        /**
494         * {@inheritDoc}
495         */
496        public String getSortOrder() {
497          return impl.getPropertyValue(INSTANCE.getSortOrderPropertyDefinition());
498        }
499    
500    
501    
502        /**
503         * {@inheritDoc}
504         */
505        public void setSortOrder(String value) {
506          impl.setPropertyValue(INSTANCE.getSortOrderPropertyDefinition(), value);
507        }
508    
509    
510    
511        /**
512         * {@inheritDoc}
513         */
514        public ManagedObjectDefinition<? extends LocalDBVLVIndexCfgClient, ? extends LocalDBVLVIndexCfg> definition() {
515          return INSTANCE;
516        }
517    
518    
519    
520        /**
521         * {@inheritDoc}
522         */
523        public PropertyProvider properties() {
524          return impl;
525        }
526    
527    
528    
529        /**
530         * {@inheritDoc}
531         */
532        public void commit() throws ManagedObjectAlreadyExistsException,
533            MissingMandatoryPropertiesException, ConcurrentModificationException,
534            OperationRejectedException, AuthorizationException,
535            CommunicationException {
536          impl.commit();
537        }
538    
539      }
540    
541    
542    
543      /**
544       * Managed object server implementation.
545       */
546      private static class LocalDBVLVIndexCfgServerImpl implements
547        LocalDBVLVIndexCfg {
548    
549        // Private implementation.
550        private ServerManagedObject<? extends LocalDBVLVIndexCfg> impl;
551    
552        // The value of the "base-dn" property.
553        private final DN pBaseDN;
554    
555        // The value of the "filter" property.
556        private final String pFilter;
557    
558        // The value of the "max-block-size" property.
559        private final int pMaxBlockSize;
560    
561        // The value of the "name" property.
562        private final String pName;
563    
564        // The value of the "scope" property.
565        private final Scope pScope;
566    
567        // The value of the "sort-order" property.
568        private final String pSortOrder;
569    
570    
571    
572        // Private constructor.
573        private LocalDBVLVIndexCfgServerImpl(ServerManagedObject<? extends LocalDBVLVIndexCfg> impl) {
574          this.impl = impl;
575          this.pBaseDN = impl.getPropertyValue(INSTANCE.getBaseDNPropertyDefinition());
576          this.pFilter = impl.getPropertyValue(INSTANCE.getFilterPropertyDefinition());
577          this.pMaxBlockSize = impl.getPropertyValue(INSTANCE.getMaxBlockSizePropertyDefinition());
578          this.pName = impl.getPropertyValue(INSTANCE.getNamePropertyDefinition());
579          this.pScope = impl.getPropertyValue(INSTANCE.getScopePropertyDefinition());
580          this.pSortOrder = impl.getPropertyValue(INSTANCE.getSortOrderPropertyDefinition());
581        }
582    
583    
584    
585        /**
586         * {@inheritDoc}
587         */
588        public void addChangeListener(
589            ConfigurationChangeListener<LocalDBVLVIndexCfg> listener) {
590          impl.registerChangeListener(listener);
591        }
592    
593    
594    
595        /**
596         * {@inheritDoc}
597         */
598        public void removeChangeListener(
599            ConfigurationChangeListener<LocalDBVLVIndexCfg> listener) {
600          impl.deregisterChangeListener(listener);
601        }
602    
603    
604    
605        /**
606         * {@inheritDoc}
607         */
608        public DN getBaseDN() {
609          return pBaseDN;
610        }
611    
612    
613    
614        /**
615         * {@inheritDoc}
616         */
617        public String getFilter() {
618          return pFilter;
619        }
620    
621    
622    
623        /**
624         * {@inheritDoc}
625         */
626        public int getMaxBlockSize() {
627          return pMaxBlockSize;
628        }
629    
630    
631    
632        /**
633         * {@inheritDoc}
634         */
635        public String getName() {
636          return pName;
637        }
638    
639    
640    
641        /**
642         * {@inheritDoc}
643         */
644        public Scope getScope() {
645          return pScope;
646        }
647    
648    
649    
650        /**
651         * {@inheritDoc}
652         */
653        public String getSortOrder() {
654          return pSortOrder;
655        }
656    
657    
658    
659        /**
660         * {@inheritDoc}
661         */
662        public Class<? extends LocalDBVLVIndexCfg> configurationClass() {
663          return LocalDBVLVIndexCfg.class;
664        }
665    
666    
667    
668        /**
669         * {@inheritDoc}
670         */
671        public DN dn() {
672          return impl.getDN();
673        }
674    
675      }
676    }