001    /*
002     * Copyright 2008-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2015 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.ldap.sdk.unboundidds.monitors;
022    
023    
024    
025    import java.util.Collections;
026    import java.util.LinkedHashMap;
027    import java.util.Map;
028    
029    import com.unboundid.ldap.sdk.Entry;
030    import com.unboundid.util.NotMutable;
031    import com.unboundid.util.ThreadSafety;
032    import com.unboundid.util.ThreadSafetyLevel;
033    
034    import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*;
035    
036    
037    
038    /**
039     * <BLOCKQUOTE>
040     *   <B>NOTE:</B>  This class is part of the Commercial Edition of the UnboundID
041     *   LDAP SDK for Java.  It is not available for use in applications that
042     *   include only the Standard Edition of the LDAP SDK, and is not supported for
043     *   use in conjunction with non-UnboundID products.
044     * </BLOCKQUOTE>
045     * This class defines a monitor entry that provides information about the state
046     * of the traditional work queue.  For all practical purposes, the traditional
047     * work queue has been replaced by the UnboundID Work Queue, which is the new
048     * default work queue implementation (which exposes its own monitor information
049     * that can be accessed using the {@link UnboundIDWorkQueueMonitorEntry}).
050     * However, in the event that the traditional work queue is configured for use
051     * instead of the UnboundID work queue, then this monitor entry may be used to
052     * access the information that it provides, which may include:
053     * <UL>
054     *   <LI>The total number of requests submitted to the work queue.</LI>
055     *   <LI>The number of requests that were rejected because the work queue was
056     *       already at its maximum capacity.</LI>
057     *   <LI>The number of operations currently held in the work queue waiting to be
058     *       picked for processing by a worker thread.</LI>
059     *   <LI>The average number of operations held in the work queue since startup
060     *       as observed from periodic polling.</LI>
061     *   <LI>The maximum number of operations held in the work queue at any time
062     *       since startup as observed from periodic polling.</LI>
063     * </UL>
064     * The server should present at most one traditional work queue monitor entry.
065     * It can be retrieved using the
066     * {@link MonitorManager#getTraditionalWorkQueueMonitorEntry} method.  This
067     * entry provides specific methods for accessing information about the state of
068     * the work queue (e.g., the
069     * {@link TraditionalWorkQueueMonitorEntry#getCurrentBacklog} method may be used
070     * to retrieve the number of operations currently held in the work queue).
071     * Alternately, this information may be accessed using the generic API.  See the
072     * {@link MonitorManager} class documentation for an example that demonstrates
073     * the use of the generic API for accessing monitor data.
074     */
075    @NotMutable()
076    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
077    public final class TraditionalWorkQueueMonitorEntry
078           extends MonitorEntry
079    {
080      /**
081       * The structural object class used in LDAP statistics monitor entries.
082       */
083      static final String TRADITIONAL_WORK_QUEUE_MONITOR_OC =
084           "ds-traditional-work-queue-monitor-entry";
085    
086    
087    
088      /**
089       * The name of the attribute that contains the average observed work queue
090       * request backlog.
091       */
092      private static final String ATTR_AVERAGE_BACKLOG = "averageRequestBacklog";
093    
094    
095    
096      /**
097       * The name of the attribute that contains the current work queue request
098       * backlog.
099       */
100      private static final String ATTR_CURRENT_BACKLOG = "currentRequestBacklog";
101    
102    
103    
104      /**
105       * The name of the attribute that contains the maximum observed work queue
106       * request backlog.
107       */
108      private static final String ATTR_MAX_BACKLOG = "maxRequestBacklog";
109    
110    
111    
112      /**
113       * The name of the attribute that contains the total number of requests that
114       * have been rejected because the work queue was full.
115       */
116      private static final String ATTR_REQUESTS_REJECTED =
117           "requestsRejectedDueToQueueFull";
118    
119    
120    
121      /**
122       * The name of the attribute that contains the total number of requests
123       * submitted.
124       */
125      private static final String ATTR_REQUESTS_SUBMITTED = "requestsSubmitted";
126    
127    
128    
129      /**
130       * The serial version UID for this serializable class.
131       */
132      private static final long serialVersionUID = 5254676890679281070L;
133    
134    
135    
136      // The average work queue backlog.
137      private final Long averageBacklog;
138    
139      // The current work queue backlog.
140      private final Long currentBacklog;
141    
142      // The maximum work queue backlog.
143      private final Long maxBacklog;
144    
145      // The total number of requests rejected due to a full work queue.
146      private final Long requestsRejected;
147    
148      // The total number of requests submitted.
149      private final Long requestsSubmitted;
150    
151    
152    
153      /**
154       * Creates a new traditional work queue monitor entry from the provided entry.
155       *
156       * @param  entry  The entry to be parsed as a traditional work queue monitor
157       *                entry.  It must not be {@code null}.
158       */
159      public TraditionalWorkQueueMonitorEntry(final Entry entry)
160      {
161        super(entry);
162    
163        averageBacklog    = getLong(ATTR_AVERAGE_BACKLOG);
164        currentBacklog    = getLong(ATTR_CURRENT_BACKLOG);
165        maxBacklog        = getLong(ATTR_MAX_BACKLOG);
166        requestsRejected  = getLong(ATTR_REQUESTS_REJECTED);
167        requestsSubmitted = getLong(ATTR_REQUESTS_SUBMITTED);
168      }
169    
170    
171    
172      /**
173       * Retrieves the average number of operations observed in the work queue.
174       *
175       * @return  The average number of operations observed in the work queue, or
176       *          {@code null} if that information was not included in the monitor
177       *          entry.
178       */
179      public Long getAverageBacklog()
180      {
181        return averageBacklog;
182      }
183    
184    
185    
186      /**
187       * Retrieves the number of operations that are currently in the work queue
188       * waiting to be processed.
189       *
190       * @return  The number of operations that are currently in the work queue
191       *          waiting to be processed, or {@code null} if that information was
192       *          not included in the monitor entry.
193       */
194      public Long getCurrentBacklog()
195      {
196        return currentBacklog;
197      }
198    
199    
200    
201      /**
202       * Retrieves the maximum number of operations observed in the work queue at
203       * any given time.
204       *
205       * @return  The total number of operations observed in the work queue at any
206       *          given time, or {@code null} if that information was not included
207       *          in the monitor entry.
208       */
209      public Long getMaxBacklog()
210      {
211        return maxBacklog;
212      }
213    
214    
215    
216      /**
217       * Retrieves the total number of operation requests that were rejected because
218       * the work queue was at its maximum capacity.
219       *
220       * @return  The total number of operation requests rejected because the work
221       *          queue was at its maximum capacity, or {@code null} if that
222       *          information was not included in the monitor entry.
223       */
224      public Long getRequestsRejectedDueToQueueFull()
225      {
226        return requestsRejected;
227      }
228    
229    
230    
231      /**
232       * Retrieves the total number of operation requests submitted to the work
233       * queue.
234       *
235       * @return  The total number of operation requests submitted to the work
236       *          queue, or {@code null} if that information was not included in the
237       *          monitor entry.
238       */
239      public Long getRequestsSubmitted()
240      {
241        return requestsSubmitted;
242      }
243    
244    
245    
246      /**
247       * {@inheritDoc}
248       */
249      @Override()
250      public String getMonitorDisplayName()
251      {
252        return INFO_TRADITIONAL_WORK_QUEUE_MONITOR_DISPNAME.get();
253      }
254    
255    
256    
257      /**
258       * {@inheritDoc}
259       */
260      @Override()
261      public String getMonitorDescription()
262      {
263        return INFO_TRADITIONAL_WORK_QUEUE_MONITOR_DESC.get();
264      }
265    
266    
267    
268      /**
269       * {@inheritDoc}
270       */
271      @Override()
272      public Map<String,MonitorAttribute> getMonitorAttributes()
273      {
274        final LinkedHashMap<String,MonitorAttribute> attrs =
275             new LinkedHashMap<String,MonitorAttribute>();
276    
277        if (requestsSubmitted != null)
278        {
279          addMonitorAttribute(attrs,
280               ATTR_REQUESTS_SUBMITTED,
281               INFO_TRADITIONAL_WORK_QUEUE_DISPNAME_REQUESTS_SUBMITTED.get(),
282               INFO_TRADITIONAL_WORK_QUEUE_DESC_REQUESTS_SUBMITTED.get(),
283               requestsSubmitted);
284        }
285    
286        if (requestsRejected != null)
287        {
288          addMonitorAttribute(attrs,
289               ATTR_REQUESTS_REJECTED,
290               INFO_TRADITIONAL_WORK_QUEUE_DISPNAME_REQUESTS_REJECTED.get(),
291               INFO_TRADITIONAL_WORK_QUEUE_DESC_REQUESTS_REJECTED.get(),
292               requestsRejected);
293        }
294    
295        if (currentBacklog != null)
296        {
297          addMonitorAttribute(attrs,
298               ATTR_CURRENT_BACKLOG,
299               INFO_TRADITIONAL_WORK_QUEUE_DISPNAME_CURRENT_BACKLOG.get(),
300               INFO_TRADITIONAL_WORK_QUEUE_DESC_CURRENT_BACKLOG.get(),
301               currentBacklog);
302        }
303    
304        if (averageBacklog != null)
305        {
306          addMonitorAttribute(attrs,
307               ATTR_AVERAGE_BACKLOG,
308               INFO_TRADITIONAL_WORK_QUEUE_DISPNAME_AVERAGE_BACKLOG.get(),
309               INFO_TRADITIONAL_WORK_QUEUE_DESC_AVERAGE_BACKLOG.get(),
310               averageBacklog);
311        }
312    
313        if (maxBacklog != null)
314        {
315          addMonitorAttribute(attrs,
316               ATTR_MAX_BACKLOG,
317               INFO_TRADITIONAL_WORK_QUEUE_DISPNAME_MAX_BACKLOG.get(),
318               INFO_TRADITIONAL_WORK_QUEUE_DESC_MAX_BACKLOG.get(),
319               maxBacklog);
320        }
321    
322        return Collections.unmodifiableMap(attrs);
323      }
324    }