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.AliasDefaultBehaviorProvider;
033    import org.opends.server.admin.ClassPropertyDefinition;
034    import org.opends.server.admin.client.AuthorizationException;
035    import org.opends.server.admin.client.CommunicationException;
036    import org.opends.server.admin.client.ConcurrentModificationException;
037    import org.opends.server.admin.client.ManagedObject;
038    import org.opends.server.admin.client.MissingMandatoryPropertiesException;
039    import org.opends.server.admin.client.OperationRejectedException;
040    import org.opends.server.admin.DefaultBehaviorProvider;
041    import org.opends.server.admin.DefinedDefaultBehaviorProvider;
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.PropertyOption;
046    import org.opends.server.admin.PropertyProvider;
047    import org.opends.server.admin.server.ConfigurationChangeListener;
048    import org.opends.server.admin.server.ServerManagedObject;
049    import org.opends.server.admin.std.client.TraditionalWorkQueueCfgClient;
050    import org.opends.server.admin.std.server.TraditionalWorkQueueCfg;
051    import org.opends.server.admin.std.server.WorkQueueCfg;
052    import org.opends.server.admin.Tag;
053    import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
054    import org.opends.server.types.DN;
055    
056    
057    
058    /**
059     * An interface for querying the Traditional Work Queue managed object
060     * definition meta information.
061     * <p>
062     * The Traditional Work Queue is a type of work queue that uses a
063     * number of worker threads that watch a queue and pick up an operation
064     * to process whenever one becomes available.
065     */
066    public final class TraditionalWorkQueueCfgDefn extends ManagedObjectDefinition<TraditionalWorkQueueCfgClient, TraditionalWorkQueueCfg> {
067    
068      // The singleton configuration definition instance.
069      private static final TraditionalWorkQueueCfgDefn INSTANCE = new TraditionalWorkQueueCfgDefn();
070    
071    
072    
073      // The "java-class" property definition.
074      private static final ClassPropertyDefinition PD_JAVA_CLASS;
075    
076    
077    
078      // The "max-work-queue-capacity" property definition.
079      private static final IntegerPropertyDefinition PD_MAX_WORK_QUEUE_CAPACITY;
080    
081    
082    
083      // The "num-worker-threads" property definition.
084      private static final IntegerPropertyDefinition PD_NUM_WORKER_THREADS;
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.SERVER_RESTART, INSTANCE, "java-class"));
094          DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.TraditionalWorkQueue");
095          builder.setDefaultBehaviorProvider(provider);
096          builder.addInstanceOf("org.opends.server.api.WorkQueue");
097          PD_JAVA_CLASS = builder.getInstance();
098          INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
099      }
100    
101    
102    
103      // Build the "max-work-queue-capacity" property definition.
104      static {
105          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-work-queue-capacity");
106          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.SERVER_RESTART, INSTANCE, "max-work-queue-capacity"));
107          builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<Integer>(INSTANCE, "max-work-queue-capacity"));
108          builder.setUpperLimit(2147483647);
109          builder.setLowerLimit(0);
110          PD_MAX_WORK_QUEUE_CAPACITY = builder.getInstance();
111          INSTANCE.registerPropertyDefinition(PD_MAX_WORK_QUEUE_CAPACITY);
112      }
113    
114    
115    
116      // Build the "num-worker-threads" property definition.
117      static {
118          IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "num-worker-threads");
119          builder.setOption(PropertyOption.MANDATORY);
120          builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "num-worker-threads"));
121          builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>());
122          builder.setUpperLimit(2147483647);
123          builder.setLowerLimit(1);
124          PD_NUM_WORKER_THREADS = builder.getInstance();
125          INSTANCE.registerPropertyDefinition(PD_NUM_WORKER_THREADS);
126      }
127    
128    
129    
130      // Register the tags associated with this managed object definition.
131      static {
132        INSTANCE.registerTag(Tag.valueOf("core-server"));
133      }
134    
135    
136    
137      /**
138       * Get the Traditional Work Queue configuration definition
139       * singleton.
140       *
141       * @return Returns the Traditional Work Queue configuration
142       *         definition singleton.
143       */
144      public static TraditionalWorkQueueCfgDefn getInstance() {
145        return INSTANCE;
146      }
147    
148    
149    
150      /**
151       * Private constructor.
152       */
153      private TraditionalWorkQueueCfgDefn() {
154        super("traditional-work-queue", WorkQueueCfgDefn.getInstance());
155      }
156    
157    
158    
159      /**
160       * {@inheritDoc}
161       */
162      public TraditionalWorkQueueCfgClient createClientConfiguration(
163          ManagedObject<? extends TraditionalWorkQueueCfgClient> impl) {
164        return new TraditionalWorkQueueCfgClientImpl(impl);
165      }
166    
167    
168    
169      /**
170       * {@inheritDoc}
171       */
172      public TraditionalWorkQueueCfg createServerConfiguration(
173          ServerManagedObject<? extends TraditionalWorkQueueCfg> impl) {
174        return new TraditionalWorkQueueCfgServerImpl(impl);
175      }
176    
177    
178    
179      /**
180       * {@inheritDoc}
181       */
182      public Class<TraditionalWorkQueueCfg> getServerConfigurationClass() {
183        return TraditionalWorkQueueCfg.class;
184      }
185    
186    
187    
188      /**
189       * Get the "java-class" property definition.
190       * <p>
191       * Specifies the fully-qualified name of the Java class that
192       * provides the Traditional Work Queue implementation.
193       *
194       * @return Returns the "java-class" property definition.
195       */
196      public ClassPropertyDefinition getJavaClassPropertyDefinition() {
197        return PD_JAVA_CLASS;
198      }
199    
200    
201    
202      /**
203       * Get the "max-work-queue-capacity" property definition.
204       * <p>
205       * Specifies the maximum number of queued operations that can be in
206       * the work queue at any given time.
207       * <p>
208       * If the work queue is already full and additional requests are
209       * received by the server, the requests are rejected. A value of zero
210       * indicates that there is no limit to the size of the queue.
211       *
212       * @return Returns the "max-work-queue-capacity" property definition.
213       */
214      public IntegerPropertyDefinition getMaxWorkQueueCapacityPropertyDefinition() {
215        return PD_MAX_WORK_QUEUE_CAPACITY;
216      }
217    
218    
219    
220      /**
221       * Get the "num-worker-threads" property definition.
222       * <p>
223       * Specifies the number of worker threads to be used for processing
224       * operations placed in the queue.
225       * <p>
226       * If the value is increased, the additional worker threads are
227       * created immediately. If the value is reduced, the appropriate
228       * number of threads are destroyed as operations complete processing.
229       *
230       * @return Returns the "num-worker-threads" property definition.
231       */
232      public IntegerPropertyDefinition getNumWorkerThreadsPropertyDefinition() {
233        return PD_NUM_WORKER_THREADS;
234      }
235    
236    
237    
238      /**
239       * Managed object client implementation.
240       */
241      private static class TraditionalWorkQueueCfgClientImpl implements
242        TraditionalWorkQueueCfgClient {
243    
244        // Private implementation.
245        private ManagedObject<? extends TraditionalWorkQueueCfgClient> impl;
246    
247    
248    
249        // Private constructor.
250        private TraditionalWorkQueueCfgClientImpl(
251            ManagedObject<? extends TraditionalWorkQueueCfgClient> impl) {
252          this.impl = impl;
253        }
254    
255    
256    
257        /**
258         * {@inheritDoc}
259         */
260        public String getJavaClass() {
261          return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
262        }
263    
264    
265    
266        /**
267         * {@inheritDoc}
268         */
269        public void setJavaClass(String value) {
270          impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
271        }
272    
273    
274    
275        /**
276         * {@inheritDoc}
277         */
278        public Integer getMaxWorkQueueCapacity() {
279          return impl.getPropertyValue(INSTANCE.getMaxWorkQueueCapacityPropertyDefinition());
280        }
281    
282    
283    
284        /**
285         * {@inheritDoc}
286         */
287        public void setMaxWorkQueueCapacity(Integer value) {
288          impl.setPropertyValue(INSTANCE.getMaxWorkQueueCapacityPropertyDefinition(), value);
289        }
290    
291    
292    
293        /**
294         * {@inheritDoc}
295         */
296        public Integer getNumWorkerThreads() {
297          return impl.getPropertyValue(INSTANCE.getNumWorkerThreadsPropertyDefinition());
298        }
299    
300    
301    
302        /**
303         * {@inheritDoc}
304         */
305        public void setNumWorkerThreads(int value) {
306          impl.setPropertyValue(INSTANCE.getNumWorkerThreadsPropertyDefinition(), value);
307        }
308    
309    
310    
311        /**
312         * {@inheritDoc}
313         */
314        public ManagedObjectDefinition<? extends TraditionalWorkQueueCfgClient, ? extends TraditionalWorkQueueCfg> definition() {
315          return INSTANCE;
316        }
317    
318    
319    
320        /**
321         * {@inheritDoc}
322         */
323        public PropertyProvider properties() {
324          return impl;
325        }
326    
327    
328    
329        /**
330         * {@inheritDoc}
331         */
332        public void commit() throws ManagedObjectAlreadyExistsException,
333            MissingMandatoryPropertiesException, ConcurrentModificationException,
334            OperationRejectedException, AuthorizationException,
335            CommunicationException {
336          impl.commit();
337        }
338    
339      }
340    
341    
342    
343      /**
344       * Managed object server implementation.
345       */
346      private static class TraditionalWorkQueueCfgServerImpl implements
347        TraditionalWorkQueueCfg {
348    
349        // Private implementation.
350        private ServerManagedObject<? extends TraditionalWorkQueueCfg> impl;
351    
352        // The value of the "java-class" property.
353        private final String pJavaClass;
354    
355        // The value of the "max-work-queue-capacity" property.
356        private final Integer pMaxWorkQueueCapacity;
357    
358        // The value of the "num-worker-threads" property.
359        private final int pNumWorkerThreads;
360    
361    
362    
363        // Private constructor.
364        private TraditionalWorkQueueCfgServerImpl(ServerManagedObject<? extends TraditionalWorkQueueCfg> impl) {
365          this.impl = impl;
366          this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
367          this.pMaxWorkQueueCapacity = impl.getPropertyValue(INSTANCE.getMaxWorkQueueCapacityPropertyDefinition());
368          this.pNumWorkerThreads = impl.getPropertyValue(INSTANCE.getNumWorkerThreadsPropertyDefinition());
369        }
370    
371    
372    
373        /**
374         * {@inheritDoc}
375         */
376        public void addTraditionalChangeListener(
377            ConfigurationChangeListener<TraditionalWorkQueueCfg> listener) {
378          impl.registerChangeListener(listener);
379        }
380    
381    
382    
383        /**
384         * {@inheritDoc}
385         */
386        public void removeTraditionalChangeListener(
387            ConfigurationChangeListener<TraditionalWorkQueueCfg> listener) {
388          impl.deregisterChangeListener(listener);
389        }
390        /**
391         * {@inheritDoc}
392         */
393        public void addChangeListener(
394            ConfigurationChangeListener<WorkQueueCfg> listener) {
395          impl.registerChangeListener(listener);
396        }
397    
398    
399    
400        /**
401         * {@inheritDoc}
402         */
403        public void removeChangeListener(
404            ConfigurationChangeListener<WorkQueueCfg> listener) {
405          impl.deregisterChangeListener(listener);
406        }
407    
408    
409    
410        /**
411         * {@inheritDoc}
412         */
413        public String getJavaClass() {
414          return pJavaClass;
415        }
416    
417    
418    
419        /**
420         * {@inheritDoc}
421         */
422        public Integer getMaxWorkQueueCapacity() {
423          return pMaxWorkQueueCapacity;
424        }
425    
426    
427    
428        /**
429         * {@inheritDoc}
430         */
431        public int getNumWorkerThreads() {
432          return pNumWorkerThreads;
433        }
434    
435    
436    
437        /**
438         * {@inheritDoc}
439         */
440        public Class<? extends TraditionalWorkQueueCfg> configurationClass() {
441          return TraditionalWorkQueueCfg.class;
442        }
443    
444    
445    
446        /**
447         * {@inheritDoc}
448         */
449        public DN dn() {
450          return impl.getDN();
451        }
452    
453      }
454    }