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.DNPropertyDefinition;
045    import org.opends.server.admin.EnumPropertyDefinition;
046    import org.opends.server.admin.ManagedObjectAlreadyExistsException;
047    import org.opends.server.admin.ManagedObjectDefinition;
048    import org.opends.server.admin.ManagedObjectOption;
049    import org.opends.server.admin.PropertyIsReadOnlyException;
050    import org.opends.server.admin.PropertyOption;
051    import org.opends.server.admin.PropertyProvider;
052    import org.opends.server.admin.server.ConfigurationChangeListener;
053    import org.opends.server.admin.server.ServerManagedObject;
054    import org.opends.server.admin.std.client.MonitorBackendCfgClient;
055    import org.opends.server.admin.std.meta.BackendCfgDefn.WritabilityMode;
056    import org.opends.server.admin.std.server.BackendCfg;
057    import org.opends.server.admin.std.server.MonitorBackendCfg;
058    import org.opends.server.admin.StringPropertyDefinition;
059    import org.opends.server.admin.Tag;
060    import org.opends.server.types.DN;
061    
062    
063    
064    /**
065     * An interface for querying the Monitor Backend managed object
066     * definition meta information.
067     * <p>
068     * The Monitor Backend allows clients to access the information made
069     * available by Directory Server monitor providers.
070     */
071    public final class MonitorBackendCfgDefn extends ManagedObjectDefinition<MonitorBackendCfgClient, MonitorBackendCfg> {
072    
073      // The singleton configuration definition instance.
074      private static final MonitorBackendCfgDefn INSTANCE = new MonitorBackendCfgDefn();
075    
076    
077    
078      // The "java-class" property definition.
079      private static final ClassPropertyDefinition PD_JAVA_CLASS;
080    
081    
082    
083      // The "writability-mode" property definition.
084      private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE;
085    
086    
087    
088      // Build the "java-class" property definition.
089      static {
090          ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
091          builder.setOption(PropertyOption.MANDATORY);
092          builder.setOption(PropertyOption.ADVANCED);
093          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class"));
094          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.backends.MonitorBackend");
095          builder.setDefaultBehaviorProvider(provider);
096          builder.addInstanceOf("org.opends.server.api.Backend");
097          PD_JAVA_CLASS = builder.getInstance();
098          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
099      }
100    
101    
102    
103      // Build the "writability-mode" property definition.
104      static {
105          EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode");
106          builder.setOption(PropertyOption.MANDATORY);
107          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode"));
108          DefaultBehaviorProvider<WritabilityMode> provider = new DefinedDefaultBehaviorProvider<WritabilityMode>("disabled");
109          builder.setDefaultBehaviorProvider(provider);
110          builder.setEnumClass(WritabilityMode.class);
111          PD_WRITABILITY_MODE = builder.getInstance();
112          INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE);
113      }
114    
115    
116    
117      // Register the options associated with this managed object definition.
118      static {
119        INSTANCE.registerOption(ManagedObjectOption.ADVANCED);
120      }
121    
122    
123    
124      // Register the tags associated with this managed object definition.
125      static {
126        INSTANCE.registerTag(Tag.valueOf("database"));
127      }
128    
129    
130    
131      /**
132       * Get the Monitor Backend configuration definition singleton.
133       *
134       * @return Returns the Monitor Backend configuration definition
135       *         singleton.
136       */
137      public static MonitorBackendCfgDefn getInstance() {
138        return INSTANCE;
139      }
140    
141    
142    
143      /**
144       * Private constructor.
145       */
146      private MonitorBackendCfgDefn() {
147        super("monitor-backend", BackendCfgDefn.getInstance());
148      }
149    
150    
151    
152      /**
153       * {@inheritDoc}
154       */
155      public MonitorBackendCfgClient createClientConfiguration(
156          ManagedObject<? extends MonitorBackendCfgClient> impl) {
157        return new MonitorBackendCfgClientImpl(impl);
158      }
159    
160    
161    
162      /**
163       * {@inheritDoc}
164       */
165      public MonitorBackendCfg createServerConfiguration(
166          ServerManagedObject<? extends MonitorBackendCfg> impl) {
167        return new MonitorBackendCfgServerImpl(impl);
168      }
169    
170    
171    
172      /**
173       * {@inheritDoc}
174       */
175      public Class<MonitorBackendCfg> getServerConfigurationClass() {
176        return MonitorBackendCfg.class;
177      }
178    
179    
180    
181      /**
182       * Get the "backend-id" property definition.
183       * <p>
184       * Specifies a name to identify the associated backend.
185       * <p>
186       * The name must be unique among all backends in the server. The
187       * backend ID may not be altered after the backend is created in the
188       * server.
189       *
190       * @return Returns the "backend-id" property definition.
191       */
192      public StringPropertyDefinition getBackendIdPropertyDefinition() {
193        return BackendCfgDefn.getInstance().getBackendIdPropertyDefinition();
194      }
195    
196    
197    
198      /**
199       * Get the "base-dn" property definition.
200       * <p>
201       * Specifies the base DN(s) for the data that the backend handles.
202       * <p>
203       * A single backend may be responsible for one or more base DNs.
204       * Note that no two backends may have the same base DN although one
205       * backend may have a base DN that is below a base DN provided by
206       * another backend (similar to the use of sub-suffixes in the Sun
207       * Java System Directory Server). If any of the base DNs is
208       * subordinate to a base DN for another backend, then all base DNs
209       * for that backend must be subordinate to that same base DN.
210       *
211       * @return Returns the "base-dn" property definition.
212       */
213      public DNPropertyDefinition getBaseDNPropertyDefinition() {
214        return BackendCfgDefn.getInstance().getBaseDNPropertyDefinition();
215      }
216    
217    
218    
219      /**
220       * Get the "enabled" property definition.
221       * <p>
222       * Indicates whether the backend is enabled in the server.
223       * <p>
224       * If a backend is not enabled, then its contents are not accessible
225       * when processing operations.
226       *
227       * @return Returns the "enabled" property definition.
228       */
229      public BooleanPropertyDefinition getEnabledPropertyDefinition() {
230        return BackendCfgDefn.getInstance().getEnabledPropertyDefinition();
231      }
232    
233    
234    
235      /**
236       * Get the "java-class" property definition.
237       * <p>
238       * Specifies the fully-qualified name of the Java class that
239       * provides the backend implementation.
240       *
241       * @return Returns the "java-class" property definition.
242       */
243      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
244        return PD_JAVA_CLASS;
245      }
246    
247    
248    
249      /**
250       * Get the "writability-mode" property definition.
251       * <p>
252       * Specifies the behavior that the backend should use when
253       * processing write operations.
254       *
255       * @return Returns the "writability-mode" property definition.
256       */
257      public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() {
258        return PD_WRITABILITY_MODE;
259      }
260    
261    
262    
263      /**
264       * Managed object client implementation.
265       */
266      private static class MonitorBackendCfgClientImpl implements
267        MonitorBackendCfgClient {
268    
269        // Private implementation.
270        private ManagedObject<? extends MonitorBackendCfgClient> impl;
271    
272    
273    
274        // Private constructor.
275        private MonitorBackendCfgClientImpl(
276            ManagedObject<? extends MonitorBackendCfgClient> impl) {
277          this.impl = impl;
278        }
279    
280    
281    
282        /**
283         * {@inheritDoc}
284         */
285        public String getBackendId() {
286          return impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
287        }
288    
289    
290    
291        /**
292         * {@inheritDoc}
293         */
294        public void setBackendId(String value) throws PropertyIsReadOnlyException {
295          impl.setPropertyValue(INSTANCE.getBackendIdPropertyDefinition(), value);
296        }
297    
298    
299    
300        /**
301         * {@inheritDoc}
302         */
303        public SortedSet<DN> getBaseDN() {
304          return impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
305        }
306    
307    
308    
309        /**
310         * {@inheritDoc}
311         */
312        public void setBaseDN(Collection<DN> values) {
313          impl.setPropertyValues(INSTANCE.getBaseDNPropertyDefinition(), values);
314        }
315    
316    
317    
318        /**
319         * {@inheritDoc}
320         */
321        public Boolean isEnabled() {
322          return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
323        }
324    
325    
326    
327        /**
328         * {@inheritDoc}
329         */
330        public void setEnabled(boolean value) {
331          impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value);
332        }
333    
334    
335    
336        /**
337         * {@inheritDoc}
338         */
339        public String getJavaClass() {
340          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
341        }
342    
343    
344    
345        /**
346         * {@inheritDoc}
347         */
348        public void setJavaClass(String value) {
349          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
350        }
351    
352    
353    
354        /**
355         * {@inheritDoc}
356         */
357        public WritabilityMode getWritabilityMode() {
358          return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
359        }
360    
361    
362    
363        /**
364         * {@inheritDoc}
365         */
366        public void setWritabilityMode(WritabilityMode value) {
367          impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value);
368        }
369    
370    
371    
372        /**
373         * {@inheritDoc}
374         */
375        public ManagedObjectDefinition<? extends MonitorBackendCfgClient, ? extends MonitorBackendCfg> definition() {
376          return INSTANCE;
377        }
378    
379    
380    
381        /**
382         * {@inheritDoc}
383         */
384        public PropertyProvider properties() {
385          return impl;
386        }
387    
388    
389    
390        /**
391         * {@inheritDoc}
392         */
393        public void commit() throws ManagedObjectAlreadyExistsException,
394            MissingMandatoryPropertiesException, ConcurrentModificationException,
395            OperationRejectedException, AuthorizationException,
396            CommunicationException {
397          impl.commit();
398        }
399    
400      }
401    
402    
403    
404      /**
405       * Managed object server implementation.
406       */
407      private static class MonitorBackendCfgServerImpl implements
408        MonitorBackendCfg {
409    
410        // Private implementation.
411        private ServerManagedObject<? extends MonitorBackendCfg> impl;
412    
413        // The value of the "backend-id" property.
414        private final String pBackendId;
415    
416        // The value of the "base-dn" property.
417        private final SortedSet<DN> pBaseDN;
418    
419        // The value of the "enabled" property.
420        private final boolean pEnabled;
421    
422        // The value of the "java-class" property.
423        private final String pJavaClass;
424    
425        // The value of the "writability-mode" property.
426        private final WritabilityMode pWritabilityMode;
427    
428    
429    
430        // Private constructor.
431        private MonitorBackendCfgServerImpl(ServerManagedObject<? extends MonitorBackendCfg> impl) {
432          this.impl = impl;
433          this.pBackendId = impl.getPropertyValue(INSTANCE.getBackendIdPropertyDefinition());
434          this.pBaseDN = impl.getPropertyValues(INSTANCE.getBaseDNPropertyDefinition());
435          this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition());
436          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
437          this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
438        }
439    
440    
441    
442        /**
443         * {@inheritDoc}
444         */
445        public void addMonitorChangeListener(
446            ConfigurationChangeListener<MonitorBackendCfg> listener) {
447          impl.registerChangeListener(listener);
448        }
449    
450    
451    
452        /**
453         * {@inheritDoc}
454         */
455        public void removeMonitorChangeListener(
456            ConfigurationChangeListener<MonitorBackendCfg> listener) {
457          impl.deregisterChangeListener(listener);
458        }
459        /**
460         * {@inheritDoc}
461         */
462        public void addChangeListener(
463            ConfigurationChangeListener<BackendCfg> listener) {
464          impl.registerChangeListener(listener);
465        }
466    
467    
468    
469        /**
470         * {@inheritDoc}
471         */
472        public void removeChangeListener(
473            ConfigurationChangeListener<BackendCfg> listener) {
474          impl.deregisterChangeListener(listener);
475        }
476    
477    
478    
479        /**
480         * {@inheritDoc}
481         */
482        public String getBackendId() {
483          return pBackendId;
484        }
485    
486    
487    
488        /**
489         * {@inheritDoc}
490         */
491        public SortedSet<DN> getBaseDN() {
492          return pBaseDN;
493        }
494    
495    
496    
497        /**
498         * {@inheritDoc}
499         */
500        public boolean isEnabled() {
501          return pEnabled;
502        }
503    
504    
505    
506        /**
507         * {@inheritDoc}
508         */
509        public String getJavaClass() {
510          return pJavaClass;
511        }
512    
513    
514    
515        /**
516         * {@inheritDoc}
517         */
518        public WritabilityMode getWritabilityMode() {
519          return pWritabilityMode;
520        }
521    
522    
523    
524        /**
525         * {@inheritDoc}
526         */
527        public Class<? extends MonitorBackendCfg> configurationClass() {
528          return MonitorBackendCfg.class;
529        }
530    
531    
532    
533        /**
534         * {@inheritDoc}
535         */
536        public DN dn() {
537          return impl.getDN();
538        }
539    
540      }
541    }