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.ArrayList;
026    import java.util.Collections;
027    import java.util.List;
028    import java.util.logging.Level;
029    
030    import com.unboundid.ldap.sdk.Entry;
031    import com.unboundid.ldap.sdk.Filter;
032    import com.unboundid.ldap.sdk.LDAPConnection;
033    import com.unboundid.ldap.sdk.LDAPInterface;
034    import com.unboundid.ldap.sdk.LDAPSearchException;
035    import com.unboundid.ldap.sdk.SearchResult;
036    import com.unboundid.ldap.sdk.SearchResultEntry;
037    import com.unboundid.ldap.sdk.SearchScope;
038    import com.unboundid.util.DebugType;
039    import com.unboundid.util.ThreadSafety;
040    import com.unboundid.util.ThreadSafetyLevel;
041    
042    import static com.unboundid.util.Debug.*;
043    
044    
045    
046    /**
047     * <BLOCKQUOTE>
048     *   <B>NOTE:</B>  This class is part of the Commercial Edition of the UnboundID
049     *   LDAP SDK for Java.  It is not available for use in applications that
050     *   include only the Standard Edition of the LDAP SDK, and is not supported for
051     *   use in conjunction with non-UnboundID products.
052     * </BLOCKQUOTE>
053     * This class provides a set of methods for retrieving Directory Server monitor
054     * entries.  In particular, it provides methods for retrieving all monitor
055     * entries from the server, as well as retrieving monitor entries of specific
056     * types.
057     * <BR><BR>
058     * <H2>Example</H2>
059     * The following example demonstrates the process for retrieving all monitor
060     * entries published by the directory server and printing the information
061     * contained in each using the generic API for accessing monitor entry data:
062     * <PRE>
063     * List&lt;MonitorEntry&gt; allMonitorEntries =
064     *      MonitorManager.getMonitorEntries(connection);
065     * for (MonitorEntry e : allMonitorEntries)
066     * {
067     *   String monitorName = e.getMonitorName();
068     *   String displayName = e.getMonitorDisplayName();
069     *   Map&lt;String,MonitorAttribute&gt; monitorAttributes =
070     *        e.getMonitorAttributes();
071     * }
072     * </PRE>
073     */
074    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
075    public final class MonitorManager
076    {
077      /**
078       * Prevent this class from being instantiated.
079       */
080      private MonitorManager()
081      {
082        // No implementation is required.
083      }
084    
085    
086    
087      /**
088       * Retrieves a list of all monitor entries available in the Directory Server.
089       *
090       * @param  connection  The connection to use to communicate with the Directory
091       *                     Server.
092       *
093       * @return  A list of all monitor entries available in the Directory Server.
094       *
095       * @throws  LDAPSearchException  If a problem occurs while communicating with
096       *                               the Directory Server.
097       */
098      public static List<MonitorEntry> getMonitorEntries(
099                                            final LDAPConnection connection)
100             throws LDAPSearchException
101      {
102        return getMonitorEntries((LDAPInterface) connection);
103      }
104    
105    
106    
107      /**
108       * Retrieves a list of all monitor entries available in the Directory Server.
109       *
110       * @param  connection  The connection to use to communicate with the Directory
111       *                     Server.
112       *
113       * @return  A list of all monitor entries available in the Directory Server.
114       *
115       * @throws  LDAPSearchException  If a problem occurs while communicating with
116       *                               the Directory Server.
117       */
118      public static List<MonitorEntry> getMonitorEntries(
119                                            final LDAPInterface connection)
120             throws LDAPSearchException
121      {
122        final Filter filter = Filter.createEqualityFilter("objectClass",
123                             MonitorEntry.GENERIC_MONITOR_OC);
124    
125        final SearchResult searchResult =
126             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
127                               filter);
128    
129        final ArrayList<MonitorEntry> monitorEntries =
130             new ArrayList<MonitorEntry>(searchResult.getEntryCount());
131        for (final SearchResultEntry e : searchResult.getSearchEntries())
132        {
133          monitorEntries.add(MonitorEntry.decode(e));
134        }
135    
136        return Collections.unmodifiableList(monitorEntries);
137      }
138    
139    
140    
141      /**
142       * Retrieves the general monitor entry from the Directory Server.
143       *
144       * @param  connection  The connection to use to communicate with the Directory
145       *                     Server.
146       *
147       * @return  The general monitor entry from the Directory Server, or
148       *          {@code null} if it is not available.
149       *
150       * @throws  LDAPSearchException  If a problem occurs while communicating with
151       *                               the Directory Server.
152       */
153      public static GeneralMonitorEntry getGeneralMonitorEntry(
154                                             final LDAPConnection connection)
155             throws LDAPSearchException
156      {
157        return getGeneralMonitorEntry((LDAPInterface) connection);
158      }
159    
160    
161    
162      /**
163       * Retrieves the general monitor entry from the Directory Server.
164       *
165       * @param  connection  The connection to use to communicate with the Directory
166       *                     Server.
167       *
168       * @return  The general monitor entry from the Directory Server, or
169       *          {@code null} if it is not available.
170       *
171       * @throws  LDAPSearchException  If a problem occurs while communicating with
172       *                               the Directory Server.
173       */
174      public static GeneralMonitorEntry getGeneralMonitorEntry(
175                                             final LDAPInterface connection)
176             throws LDAPSearchException
177      {
178        final Filter filter = Filter.createPresenceFilter("objectClass");
179    
180        final SearchResult searchResult =
181             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.BASE,
182                               filter);
183    
184        final int numEntries = searchResult.getEntryCount();
185        if (numEntries == 0)
186        {
187          debug(Level.FINE, DebugType.MONITOR,
188                "No entries returned in getGeneralMonitorEntry");
189    
190          return null;
191        }
192    
193        return new GeneralMonitorEntry(searchResult.getSearchEntries().get(0));
194      }
195    
196    
197    
198      /**
199       * Retrieves the active operations monitor entry from the Directory Server.
200       *
201       * @param  connection  The connection to use to communicate with the Directory
202       *                     Server.
203       *
204       * @return  The active operations monitor entry from the Directory Server, or
205       *          {@code null} if it is not available.
206       *
207       * @throws  LDAPSearchException  If a problem occurs while communicating with
208       *                               the Directory Server.
209       */
210      public static ActiveOperationsMonitorEntry
211                         getActiveOperationsMonitorEntry(
212                              final LDAPConnection connection)
213             throws LDAPSearchException
214      {
215        return getActiveOperationsMonitorEntry((LDAPInterface) connection);
216      }
217    
218    
219    
220      /**
221       * Retrieves the active operations monitor entry from the Directory Server.
222       *
223       * @param  connection  The connection to use to communicate with the Directory
224       *                     Server.
225       *
226       * @return  The active operations monitor entry from the Directory Server, or
227       *          {@code null} if it is not available.
228       *
229       * @throws  LDAPSearchException  If a problem occurs while communicating with
230       *                               the Directory Server.
231       */
232      public static ActiveOperationsMonitorEntry
233                         getActiveOperationsMonitorEntry(
234                              final LDAPInterface connection)
235             throws LDAPSearchException
236      {
237        final Filter filter = Filter.createEqualityFilter("objectClass",
238             ActiveOperationsMonitorEntry.ACTIVE_OPERATIONS_MONITOR_OC);
239    
240        final SearchResult searchResult =
241             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
242                               filter);
243    
244        final int numEntries = searchResult.getEntryCount();
245        if (numEntries == 0)
246        {
247          debug(Level.FINE, DebugType.MONITOR,
248                "No entries returned in getActiveOperationsMonitorEntry");
249    
250          return null;
251        }
252        else if (numEntries != 1)
253        {
254          debug(Level.FINE, DebugType.MONITOR,
255                "Multiple entries returned in getActiveOperationsMonitorEntry");
256        }
257    
258        return new ActiveOperationsMonitorEntry(
259                        searchResult.getSearchEntries().get(0));
260      }
261    
262    
263    
264      /**
265       * Retrieves a list of all backend monitor entries available in the Directory
266       * Server.
267       *
268       * @param  connection  The connection to use to communicate with the Directory
269       *                     Server.
270       *
271       * @return  A list of all backend monitor entries available in the Directory
272       *          Server.
273       *
274       * @throws  LDAPSearchException  If a problem occurs while communicating with
275       *                               the Directory Server.
276       */
277      public static List<BackendMonitorEntry> getBackendMonitorEntries(
278                                                   final LDAPConnection connection)
279             throws LDAPSearchException
280      {
281        return getBackendMonitorEntries((LDAPInterface) connection);
282      }
283    
284    
285    
286      /**
287       * Retrieves a list of all backend monitor entries available in the Directory
288       * Server.
289       *
290       * @param  connection  The connection to use to communicate with the Directory
291       *                     Server.
292       *
293       * @return  A list of all backend monitor entries available in the Directory
294       *          Server.
295       *
296       * @throws  LDAPSearchException  If a problem occurs while communicating with
297       *                               the Directory Server.
298       */
299      public static List<BackendMonitorEntry> getBackendMonitorEntries(
300                                                   final LDAPInterface connection)
301             throws LDAPSearchException
302      {
303        final Filter filter = Filter.createEqualityFilter("objectClass",
304                             BackendMonitorEntry.BACKEND_MONITOR_OC);
305    
306        final SearchResult searchResult =
307             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
308                               filter);
309    
310        final ArrayList<BackendMonitorEntry> monitorEntries =
311             new ArrayList<BackendMonitorEntry>(searchResult.getEntryCount());
312        for (final SearchResultEntry e : searchResult.getSearchEntries())
313        {
314          monitorEntries.add(new BackendMonitorEntry(e));
315        }
316    
317        return Collections.unmodifiableList(monitorEntries);
318      }
319    
320    
321    
322      /**
323       * Retrieves the client connection monitor entry from the Directory Server.
324       *
325       * @param  connection  The connection to use to communicate with the Directory
326       *                     Server.
327       *
328       * @return  The client connection monitor entry from the Directory Server, or
329       *          {@code null} if it is not available.
330       *
331       * @throws  LDAPSearchException  If a problem occurs while communicating with
332       *                               the Directory Server.
333       */
334      public static ClientConnectionMonitorEntry
335                         getClientConnectionMonitorEntry(
336                              final LDAPConnection connection)
337             throws LDAPSearchException
338      {
339        return getClientConnectionMonitorEntry((LDAPInterface) connection);
340      }
341    
342    
343    
344      /**
345       * Retrieves the client connection monitor entry from the Directory Server.
346       *
347       * @param  connection  The connection to use to communicate with the Directory
348       *                     Server.
349       *
350       * @return  The client connection monitor entry from the Directory Server, or
351       *          {@code null} if it is not available.
352       *
353       * @throws  LDAPSearchException  If a problem occurs while communicating with
354       *                               the Directory Server.
355       */
356      public static ClientConnectionMonitorEntry
357                         getClientConnectionMonitorEntry(
358                              final LDAPInterface connection)
359             throws LDAPSearchException
360      {
361        final Filter filter = Filter.createEqualityFilter("objectClass",
362             ClientConnectionMonitorEntry.CLIENT_CONNECTION_MONITOR_OC);
363    
364        final SearchResult searchResult =
365             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
366                               filter);
367    
368        final int numEntries = searchResult.getEntryCount();
369        if (numEntries == 0)
370        {
371          debug(Level.FINE, DebugType.MONITOR,
372                "No entries returned in getClientConnectionMonitorEntry");
373    
374          return null;
375        }
376        else if (numEntries != 1)
377        {
378          debug(Level.FINE, DebugType.MONITOR,
379                "Multiple entries returned in getClientConnectionMonitorEntry");
380        }
381    
382        return new ClientConnectionMonitorEntry(
383                        searchResult.getSearchEntries().get(0));
384      }
385    
386    
387    
388      /**
389       * Retrieves a list of all connection handler monitor entries available in the
390       * Directory Server.
391       *
392       * @param  connection  The connection to use to communicate with the Directory
393       *                     Server.
394       *
395       * @return  A list of all connection handler monitor entries available in the
396       *          Directory Server.
397       *
398       * @throws  LDAPSearchException  If a problem occurs while communicating with
399       *                               the Directory Server.
400       */
401      public static List<ConnectionHandlerMonitorEntry>
402                         getConnectionHandlerMonitorEntries(
403                              final LDAPConnection connection)
404             throws LDAPSearchException
405      {
406        return getConnectionHandlerMonitorEntries((LDAPInterface) connection);
407      }
408    
409    
410    
411      /**
412       * Retrieves a list of all connection handler monitor entries available in the
413       * Directory Server.
414       *
415       * @param  connection  The connection to use to communicate with the Directory
416       *                     Server.
417       *
418       * @return  A list of all connection handler monitor entries available in the
419       *          Directory Server.
420       *
421       * @throws  LDAPSearchException  If a problem occurs while communicating with
422       *                               the Directory Server.
423       */
424      public static List<ConnectionHandlerMonitorEntry>
425                         getConnectionHandlerMonitorEntries(
426                              final LDAPInterface connection)
427             throws LDAPSearchException
428      {
429        final Filter filter = Filter.createEqualityFilter("objectClass",
430             ConnectionHandlerMonitorEntry.CONNECTION_HANDLER_MONITOR_OC);
431    
432        final SearchResult searchResult =
433             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
434                               filter);
435    
436        final ArrayList<ConnectionHandlerMonitorEntry> monitorEntries =
437             new ArrayList<ConnectionHandlerMonitorEntry>(
438                      searchResult.getEntryCount());
439        for (final SearchResultEntry e : searchResult.getSearchEntries())
440        {
441          monitorEntries.add(new ConnectionHandlerMonitorEntry(e));
442        }
443    
444        return Collections.unmodifiableList(monitorEntries);
445      }
446    
447    
448    
449      /**
450       * Retrieves the disk space usage monitor entry from the Directory Server.
451       *
452       * @param  connection  The connection to use to communicate with the Directory
453       *                     Server.
454       *
455       * @return  The disk space usage monitor entry from the Directory Server, or
456       *          {@code null} if it is not available.
457       *
458       * @throws  LDAPSearchException  If a problem occurs while communicating with
459       *                               the Directory Server.
460       */
461      public static DiskSpaceUsageMonitorEntry getDiskSpaceUsageMonitorEntry(
462                                                    final LDAPConnection connection)
463             throws LDAPSearchException
464      {
465        return getDiskSpaceUsageMonitorEntry((LDAPInterface) connection);
466      }
467    
468    
469    
470      /**
471       * Retrieves the disk space usage monitor entry from the Directory Server.
472       *
473       * @param  connection  The connection to use to communicate with the Directory
474       *                     Server.
475       *
476       * @return  The disk space usage monitor entry from the Directory Server, or
477       *          {@code null} if it is not available.
478       *
479       * @throws  LDAPSearchException  If a problem occurs while communicating with
480       *                               the Directory Server.
481       */
482      public static DiskSpaceUsageMonitorEntry getDiskSpaceUsageMonitorEntry(
483                                                    final LDAPInterface connection)
484             throws LDAPSearchException
485      {
486        final Filter filter = Filter.createEqualityFilter("objectClass",
487             DiskSpaceUsageMonitorEntry.DISK_SPACE_USAGE_MONITOR_OC);
488    
489        final SearchResult searchResult =
490             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
491                               filter);
492    
493        final int numEntries = searchResult.getEntryCount();
494        if (numEntries == 0)
495        {
496          debug(Level.FINE, DebugType.MONITOR,
497                "No entries returned in getDiskSpaceUsageMonitorEntry");
498    
499          return null;
500        }
501        else if (numEntries != 1)
502        {
503          debug(Level.FINE, DebugType.MONITOR,
504                "Multiple entries returned in getDiskSpaceUsageMonitorEntry");
505        }
506    
507        return new DiskSpaceUsageMonitorEntry(
508                        searchResult.getSearchEntries().get(0));
509      }
510    
511    
512    
513      /**
514       * Retrieves the entry cache monitor entry from the Directory Server.
515       *
516       * @param  connection  The connection to use to communicate with the Directory
517       *                     Server.
518       *
519       * @return  The entry cache monitor entry from the Directory Server, or
520       *          {@code null} if it is not available.
521       *
522       * @throws  LDAPSearchException  If a problem occurs while communicating with
523       *                               the Directory Server.
524       */
525      public static EntryCacheMonitorEntry getEntryCacheMonitorEntry(
526                                                final LDAPConnection connection)
527             throws LDAPSearchException
528      {
529        return getEntryCacheMonitorEntry((LDAPInterface) connection);
530      }
531    
532    
533    
534      /**
535       * Retrieves the entry cache monitor entry from the Directory Server.
536       *
537       * @param  connection  The connection to use to communicate with the Directory
538       *                     Server.
539       *
540       * @return  The entry cache monitor entry from the Directory Server, or
541       *          {@code null} if it is not available.
542       *
543       * @throws  LDAPSearchException  If a problem occurs while communicating with
544       *                               the Directory Server.
545       */
546      public static EntryCacheMonitorEntry getEntryCacheMonitorEntry(
547                                                final LDAPInterface connection)
548             throws LDAPSearchException
549      {
550        final Filter filter = Filter.createEqualityFilter("objectClass",
551                             EntryCacheMonitorEntry.ENTRY_CACHE_MONITOR_OC);
552    
553        final SearchResult searchResult =
554             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
555                               filter);
556    
557        final int numEntries = searchResult.getEntryCount();
558        if (numEntries == 0)
559        {
560          debug(Level.FINE, DebugType.MONITOR,
561                "No entries returned in getEntryCacheMonitorEntry");
562    
563          return null;
564        }
565        else if (numEntries != 1)
566        {
567          debug(Level.FINE, DebugType.MONITOR,
568                "Multiple entries returned in getEntryCacheMonitorEntry");
569        }
570    
571        return new EntryCacheMonitorEntry(searchResult.getSearchEntries().get(0));
572      }
573    
574    
575    
576      /**
577       * Retrieves the FIFO entry cache monitor entries from the Directory Server.
578       *
579       * @param  connection  The connection to use to communicate with the Directory
580       *                     Server.
581       *
582       * @return  The entry cache monitor entry from the Directory Server, or
583       *          {@code null} if it is not available.
584       *
585       * @throws  LDAPSearchException  If a problem occurs while communicating with
586       *                               the Directory Server.
587       */
588      public static List<FIFOEntryCacheMonitorEntry>
589                  getFIFOEntryCacheMonitorEntries(final LDAPConnection connection)
590             throws LDAPSearchException
591      {
592        return getFIFOEntryCacheMonitorEntries((LDAPInterface) connection);
593      }
594    
595    
596    
597      /**
598       * Retrieves the FIFO entry cache monitor entries from the Directory Server.
599       *
600       * @param  connection  The connection to use to communicate with the Directory
601       *                     Server.
602       *
603       * @return  The entry cache monitor entry from the Directory Server, or
604       *          {@code null} if it is not available.
605       *
606       * @throws  LDAPSearchException  If a problem occurs while communicating with
607       *                               the Directory Server.
608       */
609      public static List<FIFOEntryCacheMonitorEntry>
610                  getFIFOEntryCacheMonitorEntries(final LDAPInterface connection)
611             throws LDAPSearchException
612      {
613        final Filter filter = Filter.createEqualityFilter("objectClass",
614             FIFOEntryCacheMonitorEntry.FIFO_ENTRY_CACHE_MONITOR_OC);
615    
616        final SearchResult searchResult =
617             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
618                               filter);
619    
620        final ArrayList<FIFOEntryCacheMonitorEntry> monitorEntries =
621             new ArrayList<FIFOEntryCacheMonitorEntry>(
622                  searchResult.getEntryCount());
623        for (final SearchResultEntry e : searchResult.getSearchEntries())
624        {
625          monitorEntries.add(new FIFOEntryCacheMonitorEntry(e));
626        }
627    
628        return Collections.unmodifiableList(monitorEntries);
629      }
630    
631    
632    
633      /**
634       * Retrieves a list of all gauge monitor entries available in the Directory
635       * Server.  This may include monitor entries for gauges of different types
636       * (e.g., numeric gauges and indicator gauges).
637       *
638       * @param  connection  The connection to use to communicate with the Directory
639       *                     Server.
640       *
641       * @return  A list of all gauge monitor entries available in the Directory
642       *          Server.
643       *
644       * @throws  LDAPSearchException  If a problem occurs while communicating with
645       *                               the Directory Server.
646       */
647      public static List<GaugeMonitorEntry> getGaugeMonitorEntries(
648                                                 final LDAPInterface connection)
649             throws LDAPSearchException
650      {
651        final Filter filter = Filter.createEqualityFilter("objectClass",
652             GaugeMonitorEntry.GAUGE_MONITOR_OC);
653    
654        final SearchResult searchResult =
655             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
656                               filter);
657    
658        final ArrayList<GaugeMonitorEntry> monitorEntries =
659             new ArrayList<GaugeMonitorEntry>(searchResult.getEntryCount());
660        for (final SearchResultEntry e : searchResult.getSearchEntries())
661        {
662          try
663          {
664            monitorEntries.add((GaugeMonitorEntry) MonitorEntry.decode(e));
665          }
666          catch (final Exception ex)
667          {
668            debugException(ex);
669          }
670        }
671    
672        return Collections.unmodifiableList(monitorEntries);
673      }
674    
675    
676    
677      /**
678       * Retrieves the group cache monitor entry from the Directory Server.
679       *
680       * @param  connection  The connection to use to communicate with the Directory
681       *                     Server.
682       *
683       * @return  The group cache monitor entry from the Directory Server, or
684       *          {@code null} if it is not available.
685       *
686       * @throws  LDAPSearchException  If a problem occurs while communicating with
687       *                               the Directory Server.
688       */
689      public static GroupCacheMonitorEntry getGroupCacheMonitorEntry(
690                                                final LDAPInterface connection)
691             throws LDAPSearchException
692      {
693        final Filter filter = Filter.createEqualityFilter("objectClass",
694                             GroupCacheMonitorEntry.GROUP_CACHE_MONITOR_OC);
695    
696        final SearchResult searchResult =
697             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
698                               filter);
699    
700        final int numEntries = searchResult.getEntryCount();
701        if (numEntries == 0)
702        {
703          debug(Level.FINE, DebugType.MONITOR,
704                "No entries returned in getGroupCacheMonitorEntry");
705    
706          return null;
707        }
708        else if (numEntries != 1)
709        {
710          debug(Level.FINE, DebugType.MONITOR,
711                "Multiple entries returned in getGroupCacheMonitorEntry");
712        }
713    
714        return new GroupCacheMonitorEntry(searchResult.getSearchEntries().get(0));
715      }
716    
717    
718    
719      /**
720       * Retrieves the host system recent CPU and memory monitor entry from the
721       * Directory Server.
722       *
723       * @param  connection  The connection to use to communicate with the Directory
724       *                     Server.
725       *
726       * @return  The host system recent CPU and memory monitor entry from the
727       *          Directory Server, or {@code null} if it is not available.
728       *
729       * @throws  LDAPSearchException  If a problem occurs while communicating with
730       *                               the Directory Server.
731       */
732      public static HostSystemRecentCPUAndMemoryMonitorEntry
733                         getHostSystemRecentCPUAndMemoryMonitorEntry(
734                              final LDAPInterface connection)
735             throws LDAPSearchException
736      {
737        final Filter filter = Filter.createEqualityFilter("objectClass",
738             HostSystemRecentCPUAndMemoryMonitorEntry.
739                  HOST_SYSTEM_RECENT_CPU_AND_MEMORY_MONITOR_OC);
740    
741        final SearchResult searchResult =
742             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
743                               filter);
744    
745        final int numEntries = searchResult.getEntryCount();
746        if (numEntries == 0)
747        {
748          debug(Level.FINE, DebugType.MONITOR,
749                "No entries returned in " +
750                     "getHostSystemRecentCPUAndMemoryMonitorEntry");
751    
752          return null;
753        }
754        else if (numEntries != 1)
755        {
756          debug(Level.FINE, DebugType.MONITOR,
757                "Multiple entries returned in " +
758                     "getHostSystemRecentCPUAndMemoryMonitorEntry");
759        }
760    
761        return new HostSystemRecentCPUAndMemoryMonitorEntry(
762             searchResult.getSearchEntries().get(0));
763      }
764    
765    
766    
767      /**
768       * Retrieves a list of all index monitor entries available in the Directory
769       * Server.
770       *
771       * @param  connection  The connection to use to communicate with the Directory
772       *                     Server.
773       *
774       * @return  A list of all index monitor entries available in the Directory
775       *          Server.
776       *
777       * @throws  LDAPSearchException  If a problem occurs while communicating with
778       *                               the Directory Server.
779       */
780      public static List<IndexMonitorEntry> getIndexMonitorEntries(
781                                                 final LDAPConnection connection)
782             throws LDAPSearchException
783      {
784        return getIndexMonitorEntries((LDAPInterface) connection);
785      }
786    
787    
788    
789      /**
790       * Retrieves a list of all index monitor entries available in the Directory
791       * Server.
792       *
793       * @param  connection  The connection to use to communicate with the Directory
794       *                     Server.
795       *
796       * @return  A list of all index monitor entries available in the Directory
797       *          Server.
798       *
799       * @throws  LDAPSearchException  If a problem occurs while communicating with
800       *                               the Directory Server.
801       */
802      public static List<IndexMonitorEntry> getIndexMonitorEntries(
803                                                 final LDAPInterface connection)
804             throws LDAPSearchException
805      {
806        final Filter filter = Filter.createEqualityFilter("objectClass",
807                             IndexMonitorEntry.INDEX_MONITOR_OC);
808    
809        final SearchResult searchResult =
810             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
811                               filter);
812    
813        final ArrayList<IndexMonitorEntry> monitorEntries =
814             new ArrayList<IndexMonitorEntry>(searchResult.getEntryCount());
815        for (final SearchResultEntry e : searchResult.getSearchEntries())
816        {
817          monitorEntries.add(new IndexMonitorEntry(e));
818        }
819    
820        return Collections.unmodifiableList(monitorEntries);
821      }
822    
823    
824    
825      /**
826       * Retrieves a list of all indicator gauge monitor entries available in the
827       * Directory Server.
828       *
829       * @param  connection  The connection to use to communicate with the Directory
830       *                     Server.
831       *
832       * @return  A list of all indicator gauge monitor entries available in the
833       *          Directory Server.
834       *
835       * @throws  LDAPSearchException  If a problem occurs while communicating with
836       *                               the Directory Server.
837       */
838      public static List<IndicatorGaugeMonitorEntry>
839                  getIndicatorGaugeMonitorEntries(final LDAPInterface connection)
840             throws LDAPSearchException
841      {
842        final Filter filter = Filter.createEqualityFilter("objectClass",
843             GaugeMonitorEntry.GAUGE_MONITOR_OC);
844    
845        final SearchResult searchResult =
846             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
847                               filter);
848    
849        final ArrayList<IndicatorGaugeMonitorEntry> monitorEntries =
850             new ArrayList<IndicatorGaugeMonitorEntry>(
851                  searchResult.getEntryCount());
852        for (final SearchResultEntry e : searchResult.getSearchEntries())
853        {
854          monitorEntries.add(new IndicatorGaugeMonitorEntry(e));
855        }
856    
857        return Collections.unmodifiableList(monitorEntries);
858      }
859    
860    
861    
862      /**
863       * Retrieves a list of all JE environment monitor entries available in the
864       * Directory Server.
865       *
866       * @param  connection  The connection to use to communicate with the Directory
867       *                     Server.
868       *
869       * @return  A list of all JE environment monitor entries available in the
870       *          Directory Server.
871       *
872       * @throws  LDAPSearchException  If a problem occurs while communicating with
873       *                               the Directory Server.
874       */
875      public static List<JEEnvironmentMonitorEntry>
876                         getJEEnvironmentMonitorEntries(
877                              final LDAPConnection connection)
878             throws LDAPSearchException
879      {
880        return getJEEnvironmentMonitorEntries((LDAPInterface) connection);
881      }
882    
883    
884    
885      /**
886       * Retrieves a list of all JE environment monitor entries available in the
887       * Directory Server.
888       *
889       * @param  connection  The connection to use to communicate with the Directory
890       *                     Server.
891       *
892       * @return  A list of all JE environment monitor entries available in the
893       *          Directory Server.
894       *
895       * @throws  LDAPSearchException  If a problem occurs while communicating with
896       *                               the Directory Server.
897       */
898      public static List<JEEnvironmentMonitorEntry>
899                         getJEEnvironmentMonitorEntries(
900                              final LDAPInterface connection)
901             throws LDAPSearchException
902      {
903        final Filter filter = Filter.createEqualityFilter("objectClass",
904                             JEEnvironmentMonitorEntry.JE_ENVIRONMENT_MONITOR_OC);
905    
906        final SearchResult searchResult =
907             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
908                               filter);
909    
910        final ArrayList<JEEnvironmentMonitorEntry> monitorEntries =
911             new ArrayList<JEEnvironmentMonitorEntry>(searchResult.getEntryCount());
912        for (final SearchResultEntry e : searchResult.getSearchEntries())
913        {
914          monitorEntries.add(new JEEnvironmentMonitorEntry(e));
915        }
916    
917        return Collections.unmodifiableList(monitorEntries);
918      }
919    
920    
921    
922      /**
923       * Retrieves a list of all LDAP external server monitor entries available in
924       * the Directory Server.
925       *
926       * @param  connection  The connection to use to communicate with the Directory
927       *                     Server.
928       *
929       * @return  A list of all LDAP external server monitor entries available in
930       *          the Directory Server.
931       *
932       * @throws  LDAPSearchException  If a problem occurs while communicating with
933       *                               the Directory Server.
934       */
935      public static List<LDAPExternalServerMonitorEntry>
936                         getLDAPExternalServerMonitorEntries(
937                              final LDAPConnection connection)
938             throws LDAPSearchException
939      {
940        return getLDAPExternalServerMonitorEntries((LDAPInterface) connection);
941      }
942    
943    
944    
945      /**
946       * Retrieves a list of all LDAP external server monitor entries available in
947       * the Directory Server.
948       *
949       * @param  connection  The connection to use to communicate with the Directory
950       *                     Server.
951       *
952       * @return  A list of all LDAP external server monitor entries available in
953       *          the Directory Server.
954       *
955       * @throws  LDAPSearchException  If a problem occurs while communicating with
956       *                               the Directory Server.
957       */
958      public static List<LDAPExternalServerMonitorEntry>
959                         getLDAPExternalServerMonitorEntries(
960                              final LDAPInterface connection)
961             throws LDAPSearchException
962      {
963        final Filter filter = Filter.createEqualityFilter("objectClass",
964             LDAPExternalServerMonitorEntry.LDAP_EXTERNAL_SERVER_MONITOR_OC);
965    
966        final SearchResult searchResult =
967             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
968                               filter);
969    
970        final ArrayList<LDAPExternalServerMonitorEntry> monitorEntries =
971             new ArrayList<LDAPExternalServerMonitorEntry>(
972                      searchResult.getEntryCount());
973        for (final SearchResultEntry e : searchResult.getSearchEntries())
974        {
975          monitorEntries.add(new LDAPExternalServerMonitorEntry(e));
976        }
977    
978        return Collections.unmodifiableList(monitorEntries);
979      }
980    
981    
982    
983      /**
984       * Retrieves a list of all LDAP statistics monitor entries available in the
985       * Directory Server.
986       *
987       * @param  connection  The connection to use to communicate with the Directory
988       *                     Server.
989       *
990       * @return  A list of all LDAP statistics monitor entries available in the
991       *          Directory Server.
992       *
993       * @throws  LDAPSearchException  If a problem occurs while communicating with
994       *                               the Directory Server.
995       */
996      public static List<LDAPStatisticsMonitorEntry>
997                         getLDAPStatisticsMonitorEntries(
998                              final LDAPConnection connection)
999             throws LDAPSearchException
1000      {
1001        return getLDAPStatisticsMonitorEntries((LDAPInterface) connection);
1002      }
1003    
1004    
1005    
1006      /**
1007       * Retrieves a list of all LDAP statistics monitor entries available in the
1008       * Directory Server.
1009       *
1010       * @param  connection  The connection to use to communicate with the Directory
1011       *                     Server.
1012       *
1013       * @return  A list of all LDAP statistics monitor entries available in the
1014       *          Directory Server.
1015       *
1016       * @throws  LDAPSearchException  If a problem occurs while communicating with
1017       *                               the Directory Server.
1018       */
1019      public static List<LDAPStatisticsMonitorEntry>
1020                         getLDAPStatisticsMonitorEntries(
1021                              final LDAPInterface connection)
1022             throws LDAPSearchException
1023      {
1024        final Filter filter = Filter.createEqualityFilter("objectClass",
1025                             LDAPStatisticsMonitorEntry.LDAP_STATISTICS_MONITOR_OC);
1026    
1027        final SearchResult searchResult =
1028             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1029                               filter);
1030    
1031        final ArrayList<LDAPStatisticsMonitorEntry> monitorEntries =
1032             new ArrayList<LDAPStatisticsMonitorEntry>(
1033                      searchResult.getEntryCount());
1034        for (final SearchResultEntry e : searchResult.getSearchEntries())
1035        {
1036          monitorEntries.add(new LDAPStatisticsMonitorEntry(e));
1037        }
1038    
1039        return Collections.unmodifiableList(monitorEntries);
1040      }
1041    
1042    
1043    
1044      /**
1045       * Retrieves a list of all load-balancing algorithm monitor entries available
1046       * in the Directory Proxy Server.
1047       *
1048       * @param  connection  The connection to use to communicate with the Directory
1049       *                     Proxy Server.
1050       *
1051       * @return  A list of all load-balancing algorithm monitor entries available
1052       *          in the Directory Proxy Server.
1053       *
1054       * @throws  LDAPSearchException  If a problem occurs while communicating with
1055       *                               the Directory Proxy Server.
1056       */
1057      public static List<LoadBalancingAlgorithmMonitorEntry>
1058                         getLoadBalancingAlgorithmMonitorEntries(
1059                              final LDAPConnection connection)
1060             throws LDAPSearchException
1061      {
1062        return getLoadBalancingAlgorithmMonitorEntries((LDAPInterface) connection);
1063      }
1064    
1065    
1066    
1067      /**
1068       * Retrieves a list of all load-balancing algorithm monitor entries available
1069       * in the Directory Proxy Server.
1070       *
1071       * @param  connection  The connection to use to communicate with the Directory
1072       *                     Proxy Server.
1073       *
1074       * @return  A list of all load-balancing algorithm monitor entries available
1075       *          in the Directory Proxy Server.
1076       *
1077       * @throws  LDAPSearchException  If a problem occurs while communicating with
1078       *                               the Directory Proxy Server.
1079       */
1080      public static List<LoadBalancingAlgorithmMonitorEntry>
1081                         getLoadBalancingAlgorithmMonitorEntries(
1082                              final LDAPInterface connection)
1083             throws LDAPSearchException
1084      {
1085        final Filter filter = Filter.createEqualityFilter("objectClass",
1086             LoadBalancingAlgorithmMonitorEntry.
1087                  LOAD_BALANCING_ALGORITHM_MONITOR_OC);
1088    
1089        final SearchResult searchResult =
1090             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1091                               filter);
1092    
1093        final ArrayList<LoadBalancingAlgorithmMonitorEntry> monitorEntries =
1094             new ArrayList<LoadBalancingAlgorithmMonitorEntry>(
1095                      searchResult.getEntryCount());
1096        for (final SearchResultEntry e : searchResult.getSearchEntries())
1097        {
1098          monitorEntries.add(new LoadBalancingAlgorithmMonitorEntry(e));
1099        }
1100    
1101        return Collections.unmodifiableList(monitorEntries);
1102      }
1103    
1104    
1105    
1106      /**
1107       * Retrieves the memory usage monitor entry from the Directory Server.
1108       *
1109       * @param  connection  The connection to use to communicate with the Directory
1110       *                     Server.
1111       *
1112       * @return  The memory usage monitor entry from the Directory Server, or
1113       *          {@code null} if it is not available.
1114       *
1115       * @throws  LDAPSearchException  If a problem occurs while communicating with
1116       *                               the Directory Server.
1117       */
1118      public static MemoryUsageMonitorEntry getMemoryUsageMonitorEntry(
1119                                                 final LDAPConnection connection)
1120             throws LDAPSearchException
1121      {
1122        return getMemoryUsageMonitorEntry((LDAPInterface) connection);
1123      }
1124    
1125    
1126    
1127      /**
1128       * Retrieves the memory usage monitor entry from the Directory Server.
1129       *
1130       * @param  connection  The connection to use to communicate with the Directory
1131       *                     Server.
1132       *
1133       * @return  The memory usage monitor entry from the Directory Server, or
1134       *          {@code null} if it is not available.
1135       *
1136       * @throws  LDAPSearchException  If a problem occurs while communicating with
1137       *                               the Directory Server.
1138       */
1139      public static MemoryUsageMonitorEntry getMemoryUsageMonitorEntry(
1140                                                 final LDAPInterface connection)
1141             throws LDAPSearchException
1142      {
1143        final Filter filter = Filter.createEqualityFilter("objectClass",
1144                             MemoryUsageMonitorEntry.MEMORY_USAGE_MONITOR_OC);
1145    
1146        final SearchResult searchResult =
1147             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1148                               filter);
1149    
1150        final int numEntries = searchResult.getEntryCount();
1151        if (numEntries == 0)
1152        {
1153          debug(Level.FINE, DebugType.MONITOR,
1154                "No entries returned in getMemoryUsageMonitorEntry");
1155    
1156          return null;
1157        }
1158        else if (numEntries != 1)
1159        {
1160          debug(Level.FINE, DebugType.MONITOR,
1161                "Multiple entries returned in getMemoryUsageMonitorEntry");
1162        }
1163    
1164        return new MemoryUsageMonitorEntry(searchResult.getSearchEntries().get(0));
1165      }
1166    
1167    
1168    
1169      /**
1170       * Retrieves a list of all numeric gauge monitor entries available in the
1171       * Directory Server.
1172       *
1173       * @param  connection  The connection to use to communicate with the Directory
1174       *                     Server.
1175       *
1176       * @return  A list of all numeric gauge monitor entries available in the
1177       *          Directory Server.
1178       *
1179       * @throws  LDAPSearchException  If a problem occurs while communicating with
1180       *                               the Directory Server.
1181       */
1182      public static List<NumericGaugeMonitorEntry>
1183                  getNumericGaugeMonitorEntries(final LDAPInterface connection)
1184             throws LDAPSearchException
1185      {
1186        final Filter filter = Filter.createEqualityFilter("objectClass",
1187             GaugeMonitorEntry.GAUGE_MONITOR_OC);
1188    
1189        final SearchResult searchResult =
1190             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1191                               filter);
1192    
1193        final ArrayList<NumericGaugeMonitorEntry> monitorEntries =
1194             new ArrayList<NumericGaugeMonitorEntry>(
1195                  searchResult.getEntryCount());
1196        for (final SearchResultEntry e : searchResult.getSearchEntries())
1197        {
1198          monitorEntries.add(new NumericGaugeMonitorEntry(e));
1199        }
1200    
1201        return Collections.unmodifiableList(monitorEntries);
1202      }
1203    
1204    
1205    
1206      /**
1207       * Retrieves the per application processing time histogram monitor entries
1208       * from the Directory Server.
1209       *
1210       * @param  connection  The connection to use to communicate with the Directory
1211       *                     Server.
1212       *
1213       * @return  The per application processing time histogram monitor entries from
1214       *          the Directory Server.  If none are available, an empty list is
1215       *          returned.
1216       *
1217       * @throws  LDAPSearchException  If a problem occurs while communicating with
1218       *                               the Directory Server.
1219       */
1220      public static List<PerApplicationProcessingTimeHistogramMonitorEntry>
1221                         getPerApplicationProcessingTimeHistogramMonitorEntries(
1222                              final LDAPConnection connection)
1223             throws LDAPSearchException
1224      {
1225        return getPerApplicationProcessingTimeHistogramMonitorEntries(
1226             (LDAPInterface) connection);
1227      }
1228    
1229    
1230    
1231      /**
1232       * Retrieves the per application processing time histogram monitor entries
1233       * from the Directory Server.
1234       *
1235       * @param  connection  The connection to use to communicate with the Directory
1236       *                     Server.
1237       *
1238       * @return  The per application processing time histogram monitor entries from
1239       *          the Directory Server.  If none are available, an empty list is
1240       *          returned.
1241       *
1242       * @throws  LDAPSearchException  If a problem occurs while communicating with
1243       *                               the Directory Server.
1244       */
1245      public static List<PerApplicationProcessingTimeHistogramMonitorEntry>
1246                         getPerApplicationProcessingTimeHistogramMonitorEntries(
1247                              final LDAPInterface connection)
1248             throws LDAPSearchException
1249      {
1250        final Filter filter = Filter.createEqualityFilter("objectClass",
1251             PerApplicationProcessingTimeHistogramMonitorEntry.
1252                  PER_APPLICATION_PROCESSING_TIME_HISTOGRAM_MONITOR_OC);
1253    
1254        final SearchResult searchResult =
1255             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1256                               filter);
1257    
1258        final int numEntries = searchResult.getEntryCount();
1259        if (numEntries == 0)
1260        {
1261          debug(Level.FINE, DebugType.MONITOR,
1262                "No entries returned in " +
1263                     "getPerApplicationProcessingTimeHistogramMonitorEntries");
1264    
1265          return Collections.emptyList();
1266        }
1267    
1268        List<PerApplicationProcessingTimeHistogramMonitorEntry> monitorEntries =
1269             new ArrayList<PerApplicationProcessingTimeHistogramMonitorEntry>();
1270    
1271        for (Entry entry: searchResult.getSearchEntries())
1272        {
1273          monitorEntries.add(
1274               new PerApplicationProcessingTimeHistogramMonitorEntry(entry));
1275        }
1276    
1277    
1278        return monitorEntries;
1279      }
1280    
1281    
1282    
1283      /**
1284       * Retrieves the processing time histogram monitor entry from the Directory
1285       * Server.
1286       *
1287       * @param  connection  The connection to use to communicate with the Directory
1288       *                     Server.
1289       *
1290       * @return  The processing time histogram monitor entry from the Directory
1291       *          Server, or {@code null} if it is not available.
1292       *
1293       * @throws  LDAPSearchException  If a problem occurs while communicating with
1294       *                               the Directory Server.
1295       */
1296      public static ProcessingTimeHistogramMonitorEntry
1297                         getProcessingTimeHistogramMonitorEntry(
1298                              final LDAPConnection connection)
1299             throws LDAPSearchException
1300      {
1301        return getProcessingTimeHistogramMonitorEntry((LDAPInterface) connection);
1302      }
1303    
1304    
1305    
1306      /**
1307       * Retrieves the processing time histogram monitor entry from the Directory
1308       * Server.
1309       *
1310       * @param  connection  The connection to use to communicate with the Directory
1311       *                     Server.
1312       *
1313       * @return  The processing time histogram monitor entry from the Directory
1314       *          Server, or {@code null} if it is not available.
1315       *
1316       * @throws  LDAPSearchException  If a problem occurs while communicating with
1317       *                               the Directory Server.
1318       */
1319      public static ProcessingTimeHistogramMonitorEntry
1320                         getProcessingTimeHistogramMonitorEntry(
1321                              final LDAPInterface connection)
1322             throws LDAPSearchException
1323      {
1324        final Filter filter = Filter.createEqualityFilter("objectClass",
1325                             ProcessingTimeHistogramMonitorEntry.
1326                                  PROCESSING_TIME_HISTOGRAM_MONITOR_OC);
1327    
1328        final SearchResult searchResult =
1329             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1330                               filter);
1331    
1332        final int numEntries = searchResult.getEntryCount();
1333        if (numEntries == 0)
1334        {
1335          debug(Level.FINE, DebugType.MONITOR,
1336                "No entries returned in getProcessingTimeHistogramMonitorEntry");
1337    
1338          return null;
1339        }
1340        else if (numEntries != 1)
1341        {
1342          debug(Level.FINE, DebugType.MONITOR,
1343                "Multiple entries returned in " +
1344                "getProcessingTimeHistogramMonitorEntry");
1345        }
1346    
1347        return new ProcessingTimeHistogramMonitorEntry(
1348                        searchResult.getSearchEntries().get(0));
1349      }
1350    
1351    
1352    
1353      /**
1354       * Retrieves a list of all replica monitor entries available in the Directory
1355       * Server.
1356       *
1357       * @param  connection  The connection to use to communicate with the Directory
1358       *                     Server.
1359       *
1360       * @return  A list of all replica monitor entries available in the Directory
1361       *          Server.
1362       *
1363       * @throws  LDAPSearchException  If a problem occurs while communicating with
1364       *                               the Directory Server.
1365       */
1366      public static List<ReplicaMonitorEntry> getReplicaMonitorEntries(
1367                                                   final LDAPConnection connection)
1368             throws LDAPSearchException
1369      {
1370        return getReplicaMonitorEntries((LDAPInterface) connection);
1371      }
1372    
1373    
1374    
1375      /**
1376       * Retrieves a list of all replica monitor entries available in the Directory
1377       * Server.
1378       *
1379       * @param  connection  The connection to use to communicate with the Directory
1380       *                     Server.
1381       *
1382       * @return  A list of all replica monitor entries available in the Directory
1383       *          Server.
1384       *
1385       * @throws  LDAPSearchException  If a problem occurs while communicating with
1386       *                               the Directory Server.
1387       */
1388      public static List<ReplicaMonitorEntry> getReplicaMonitorEntries(
1389                                                   final LDAPInterface connection)
1390             throws LDAPSearchException
1391      {
1392        final Filter filter = Filter.createEqualityFilter("objectClass",
1393             ReplicaMonitorEntry.REPLICA_MONITOR_OC);
1394    
1395        final SearchResult searchResult =
1396             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1397                               filter);
1398    
1399        final ArrayList<ReplicaMonitorEntry> monitorEntries =
1400             new ArrayList<ReplicaMonitorEntry>(
1401                      searchResult.getEntryCount());
1402        for (final SearchResultEntry e : searchResult.getSearchEntries())
1403        {
1404          monitorEntries.add(new ReplicaMonitorEntry(e));
1405        }
1406    
1407        return Collections.unmodifiableList(monitorEntries);
1408      }
1409    
1410    
1411    
1412      /**
1413       * Retrieves the replication server monitor entry from the Directory Server.
1414       *
1415       * @param  connection  The connection to use to communicate with the Directory
1416       *                     Server.
1417       *
1418       * @return  The replication server monitor entry from the Directory Server, or
1419       *          {@code null} if it is not available.
1420       *
1421       * @throws  LDAPSearchException  If a problem occurs while communicating with
1422       *                               the Directory Server.
1423       */
1424      public static ReplicationServerMonitorEntry getReplicationServerMonitorEntry(
1425                         final LDAPConnection connection)
1426             throws LDAPSearchException
1427      {
1428        return getReplicationServerMonitorEntry((LDAPInterface) connection);
1429      }
1430    
1431    
1432    
1433      /**
1434       * Retrieves the replication server monitor entry from the Directory Server.
1435       *
1436       * @param  connection  The connection to use to communicate with the Directory
1437       *                     Server.
1438       *
1439       * @return  The replication server monitor entry from the Directory Server, or
1440       *          {@code null} if it is not available.
1441       *
1442       * @throws  LDAPSearchException  If a problem occurs while communicating with
1443       *                               the Directory Server.
1444       */
1445      public static ReplicationServerMonitorEntry getReplicationServerMonitorEntry(
1446                         final LDAPInterface connection)
1447             throws LDAPSearchException
1448      {
1449        final Filter filter = Filter.createEqualityFilter("objectClass",
1450             ReplicationServerMonitorEntry.REPLICATION_SERVER_MONITOR_OC);
1451    
1452        final SearchResult searchResult =
1453             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1454                               filter);
1455    
1456        final int numEntries = searchResult.getEntryCount();
1457        if (numEntries == 0)
1458        {
1459          debug(Level.FINE, DebugType.MONITOR,
1460                "No entries returned in getReplicationServerMonitorEntry");
1461    
1462          return null;
1463        }
1464        else if (numEntries != 1)
1465        {
1466          debug(Level.FINE, DebugType.MONITOR,
1467                "Multiple entries returned in " +
1468                "getReplicationServerMonitorEntry");
1469        }
1470    
1471        return new ReplicationServerMonitorEntry(
1472                        searchResult.getSearchEntries().get(0));
1473      }
1474    
1475    
1476    
1477      /**
1478       * Retrieves a list of all replication summary monitor entries available in
1479       * the Directory Server.
1480       *
1481       * @param  connection  The connection to use to communicate with the Directory
1482       *                     Server.
1483       *
1484       * @return  A list of all replication summary monitor entries available in the
1485       *          Directory Server.
1486       *
1487       * @throws  LDAPSearchException  If a problem occurs while communicating with
1488       *                               the Directory Server.
1489       */
1490      public static List<ReplicationSummaryMonitorEntry>
1491                         getReplicationSummaryMonitorEntries(
1492                              final LDAPConnection connection)
1493             throws LDAPSearchException
1494      {
1495        return getReplicationSummaryMonitorEntries((LDAPInterface) connection);
1496      }
1497    
1498    
1499    
1500      /**
1501       * Retrieves a list of all replication summary monitor entries available in
1502       * the Directory Server.
1503       *
1504       * @param  connection  The connection to use to communicate with the Directory
1505       *                     Server.
1506       *
1507       * @return  A list of all replication summary monitor entries available in the
1508       *          Directory Server.
1509       *
1510       * @throws  LDAPSearchException  If a problem occurs while communicating with
1511       *                               the Directory Server.
1512       */
1513      public static List<ReplicationSummaryMonitorEntry>
1514                         getReplicationSummaryMonitorEntries(
1515                              final LDAPInterface connection)
1516             throws LDAPSearchException
1517      {
1518        final Filter filter = Filter.createEqualityFilter("objectClass",
1519             ReplicationSummaryMonitorEntry.REPLICATION_SUMMARY_MONITOR_OC);
1520    
1521        final SearchResult searchResult =
1522             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1523                               filter);
1524    
1525        final ArrayList<ReplicationSummaryMonitorEntry> monitorEntries =
1526             new ArrayList<ReplicationSummaryMonitorEntry>(
1527                      searchResult.getEntryCount());
1528        for (final SearchResultEntry e : searchResult.getSearchEntries())
1529        {
1530          monitorEntries.add(new ReplicationSummaryMonitorEntry(e));
1531        }
1532    
1533        return Collections.unmodifiableList(monitorEntries);
1534      }
1535    
1536    
1537    
1538      /**
1539       * Retrieves the result code monitor entry from the Directory Server.
1540       *
1541       * @param  connection  The connection to use to communicate with the Directory
1542       *                     Server.
1543       *
1544       * @return  The result code monitor entry from the Directory Server, or
1545       *          {@code null} if it is not available.
1546       *
1547       * @throws  LDAPSearchException  If a problem occurs while communicating with
1548       *                               the Directory Server.
1549       */
1550      public static ResultCodeMonitorEntry getResultCodeMonitorEntry(
1551                                                final LDAPInterface connection)
1552             throws LDAPSearchException
1553      {
1554        final Filter filter = Filter.createEqualityFilter("objectClass",
1555             ResultCodeMonitorEntry.RESULT_CODE_MONITOR_OC);
1556    
1557        final SearchResult searchResult = connection.search(
1558             MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB, filter);
1559    
1560        final int numEntries = searchResult.getEntryCount();
1561        if (numEntries == 0)
1562        {
1563          debug(Level.FINE, DebugType.MONITOR,
1564                "No entries returned in getResultCodeMonitorEntry");
1565    
1566          return null;
1567        }
1568        else if (numEntries != 1)
1569        {
1570          debug(Level.FINE, DebugType.MONITOR,
1571                "Multiple entries returned in getResultCodeMonitorEntry");
1572        }
1573    
1574        return new ResultCodeMonitorEntry(searchResult.getSearchEntries().get(0));
1575      }
1576    
1577    
1578    
1579      /**
1580       * Retrieves the system info monitor entry from the Directory Server.
1581       *
1582       * @param  connection  The connection to use to communicate with the Directory
1583       *                     Server.
1584       *
1585       * @return  The system info monitor entry from the Directory Server, or
1586       *          {@code null} if it is not available.
1587       *
1588       * @throws  LDAPSearchException  If a problem occurs while communicating with
1589       *                               the Directory Server.
1590       */
1591      public static SystemInfoMonitorEntry getSystemInfoMonitorEntry(
1592                                                final LDAPConnection connection)
1593             throws LDAPSearchException
1594      {
1595        return getSystemInfoMonitorEntry((LDAPInterface) connection);
1596      }
1597    
1598    
1599    
1600      /**
1601       * Retrieves the system info monitor entry from the Directory Server.
1602       *
1603       * @param  connection  The connection to use to communicate with the Directory
1604       *                     Server.
1605       *
1606       * @return  The system info monitor entry from the Directory Server, or
1607       *          {@code null} if it is not available.
1608       *
1609       * @throws  LDAPSearchException  If a problem occurs while communicating with
1610       *                               the Directory Server.
1611       */
1612      public static SystemInfoMonitorEntry getSystemInfoMonitorEntry(
1613                                                final LDAPInterface connection)
1614             throws LDAPSearchException
1615      {
1616        final Filter filter = Filter.createEqualityFilter("objectClass",
1617                             SystemInfoMonitorEntry.SYSTEM_INFO_MONITOR_OC);
1618    
1619        final SearchResult searchResult =
1620             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1621                               filter);
1622    
1623        final int numEntries = searchResult.getEntryCount();
1624        if (numEntries == 0)
1625        {
1626          debug(Level.FINE, DebugType.MONITOR,
1627                "No entries returned in getSystemInfoMonitorEntry");
1628    
1629          return null;
1630        }
1631        else if (numEntries != 1)
1632        {
1633          debug(Level.FINE, DebugType.MONITOR,
1634                "Multiple entries returned in getSystemInfoMonitorEntry");
1635        }
1636    
1637        return new SystemInfoMonitorEntry(searchResult.getSearchEntries().get(0));
1638      }
1639    
1640    
1641    
1642      /**
1643       * Retrieves the stack trace monitor entry from the Directory Server.
1644       *
1645       * @param  connection  The connection to use to communicate with the Directory
1646       *                     Server.
1647       *
1648       * @return  The stack trace monitor entry from the Directory Server, or
1649       *          {@code null} if it is not available.
1650       *
1651       * @throws  LDAPSearchException  If a problem occurs while communicating with
1652       *                               the Directory Server.
1653       */
1654      public static StackTraceMonitorEntry getStackTraceMonitorEntry(
1655                                                final LDAPConnection connection)
1656             throws LDAPSearchException
1657      {
1658        return getStackTraceMonitorEntry((LDAPInterface) connection);
1659      }
1660    
1661    
1662    
1663      /**
1664       * Retrieves the stack trace monitor entry from the Directory Server.
1665       *
1666       * @param  connection  The connection to use to communicate with the Directory
1667       *                     Server.
1668       *
1669       * @return  The stack trace monitor entry from the Directory Server, or
1670       *          {@code null} if it is not available.
1671       *
1672       * @throws  LDAPSearchException  If a problem occurs while communicating with
1673       *                               the Directory Server.
1674       */
1675      public static StackTraceMonitorEntry getStackTraceMonitorEntry(
1676                                                final LDAPInterface connection)
1677             throws LDAPSearchException
1678      {
1679        final Filter filter = Filter.createEqualityFilter("objectClass",
1680                             StackTraceMonitorEntry.STACK_TRACE_MONITOR_OC);
1681    
1682        final SearchResult searchResult =
1683             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1684                               filter);
1685    
1686        final int numEntries = searchResult.getEntryCount();
1687        if (numEntries == 0)
1688        {
1689          debug(Level.FINE, DebugType.MONITOR,
1690                "No entries returned in getStackTraceMonitorEntry");
1691    
1692          return null;
1693        }
1694        else if (numEntries != 1)
1695        {
1696          debug(Level.FINE, DebugType.MONITOR,
1697                "Multiple entries returned in getStackTraceMonitorEntry");
1698        }
1699    
1700        return new StackTraceMonitorEntry(searchResult.getSearchEntries().get(0));
1701      }
1702    
1703    
1704    
1705      /**
1706       * Retrieves the traditional work queue monitor entry from the Directory
1707       * Server.
1708       *
1709       * @param  connection  The connection to use to communicate with the Directory
1710       *                     Server.
1711       *
1712       * @return  The traditional work queue monitor entry from the Directory
1713       *          Server, or {@code null} if it is not available.
1714       *
1715       * @throws  LDAPSearchException  If a problem occurs while communicating with
1716       *                               the Directory Server.
1717       */
1718      public static TraditionalWorkQueueMonitorEntry
1719             getTraditionalWorkQueueMonitorEntry(final LDAPConnection connection)
1720             throws LDAPSearchException
1721      {
1722        return getTraditionalWorkQueueMonitorEntry((LDAPInterface) connection);
1723      }
1724    
1725    
1726    
1727      /**
1728       * Retrieves the traditional work queue monitor entry from the Directory
1729       * Server.
1730       *
1731       * @param  connection  The connection to use to communicate with the Directory
1732       *                     Server.
1733       *
1734       * @return  The traditional work queue monitor entry from the Directory
1735       *          Server, or {@code null} if it is not available.
1736       *
1737       * @throws  LDAPSearchException  If a problem occurs while communicating with
1738       *                               the Directory Server.
1739       */
1740      public static TraditionalWorkQueueMonitorEntry
1741             getTraditionalWorkQueueMonitorEntry(final LDAPInterface connection)
1742             throws LDAPSearchException
1743      {
1744        final Filter filter = Filter.createEqualityFilter("objectClass",
1745             TraditionalWorkQueueMonitorEntry.TRADITIONAL_WORK_QUEUE_MONITOR_OC);
1746    
1747        final SearchResult searchResult =
1748             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1749                               filter);
1750    
1751        final int numEntries = searchResult.getEntryCount();
1752        if (numEntries == 0)
1753        {
1754          debug(Level.FINE, DebugType.MONITOR,
1755                "No entries returned in getTraditionalWorkQueueMonitorEntry");
1756    
1757          return null;
1758        }
1759        else if (numEntries != 1)
1760        {
1761          debug(Level.FINE, DebugType.MONITOR,
1762                "Multiple entries returned in getTraditionalWorkQueueMonitorEntry");
1763        }
1764    
1765        return new TraditionalWorkQueueMonitorEntry(
1766                        searchResult.getSearchEntries().get(0));
1767      }
1768    
1769    
1770    
1771      /**
1772       * Retrieves the UnboundID work queue monitor entry from the Directory Server.
1773       *
1774       * @param  connection  The connection to use to communicate with the Directory
1775       *                     Server.
1776       *
1777       * @return  The UnboundID work queue monitor entry from the Directory Server,
1778       *          or {@code null} if it is not available.
1779       *
1780       * @throws  LDAPSearchException  If a problem occurs while communicating with
1781       *                               the Directory Server.
1782       */
1783      public static UnboundIDWorkQueueMonitorEntry
1784             getUnboundIDWorkQueueMonitorEntry(final LDAPConnection connection)
1785             throws LDAPSearchException
1786      {
1787        return getUnboundIDWorkQueueMonitorEntry((LDAPInterface) connection);
1788      }
1789    
1790    
1791    
1792      /**
1793       * Retrieves the UnboundID work queue monitor entry from the Directory Server.
1794       *
1795       * @param  connection  The connection to use to communicate with the Directory
1796       *                     Server.
1797       *
1798       * @return  The UnboundID work queue monitor entry from the Directory Server,
1799       *          or {@code null} if it is not available.
1800       *
1801       * @throws  LDAPSearchException  If a problem occurs while communicating with
1802       *                               the Directory Server.
1803       */
1804      public static UnboundIDWorkQueueMonitorEntry
1805             getUnboundIDWorkQueueMonitorEntry(final LDAPInterface connection)
1806             throws LDAPSearchException
1807      {
1808        final Filter filter = Filter.createEqualityFilter("objectClass",
1809             UnboundIDWorkQueueMonitorEntry.UNBOUNDID_WORK_QUEUE_MONITOR_OC);
1810    
1811        final SearchResult searchResult =
1812             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1813                               filter);
1814    
1815        final int numEntries = searchResult.getEntryCount();
1816        if (numEntries == 0)
1817        {
1818          debug(Level.FINE, DebugType.MONITOR,
1819                "No entries returned in getUnboundIDWorkQueueMonitorEntry");
1820    
1821          return null;
1822        }
1823        else if (numEntries != 1)
1824        {
1825          debug(Level.FINE, DebugType.MONITOR,
1826                "Multiple entries returned in getUnboundIDWorkQueueMonitorEntry");
1827        }
1828    
1829        return new UnboundIDWorkQueueMonitorEntry(
1830                        searchResult.getSearchEntries().get(0));
1831      }
1832    
1833    
1834    
1835      /**
1836       * Retrieves the version monitor entry from the Directory Server.
1837       *
1838       * @param  connection  The connection to use to communicate with the Directory
1839       *                     Server.
1840       *
1841       * @return  The version monitor entry from the Directory Server, or
1842       *          {@code null} if it is not available.
1843       *
1844       * @throws  LDAPSearchException  If a problem occurs while communicating with
1845       *                               the Directory Server.
1846       */
1847      public static VersionMonitorEntry getVersionMonitorEntry(
1848                                             final LDAPConnection connection)
1849             throws LDAPSearchException
1850      {
1851        return getVersionMonitorEntry((LDAPInterface) connection);
1852      }
1853    
1854    
1855    
1856      /**
1857       * Retrieves the version monitor entry from the Directory Server.
1858       *
1859       * @param  connection  The connection to use to communicate with the Directory
1860       *                     Server.
1861       *
1862       * @return  The version monitor entry from the Directory Server, or
1863       *          {@code null} if it is not available.
1864       *
1865       * @throws  LDAPSearchException  If a problem occurs while communicating with
1866       *                               the Directory Server.
1867       */
1868      public static VersionMonitorEntry getVersionMonitorEntry(
1869                                             final LDAPInterface connection)
1870             throws LDAPSearchException
1871      {
1872        final Filter filter = Filter.createEqualityFilter("objectClass",
1873             VersionMonitorEntry.VERSION_MONITOR_OC);
1874    
1875        final SearchResult searchResult =
1876             connection.search(MonitorEntry.MONITOR_BASE_DN, SearchScope.SUB,
1877                               filter);
1878    
1879        final int numEntries = searchResult.getEntryCount();
1880        if (numEntries == 0)
1881        {
1882          debug(Level.FINE, DebugType.MONITOR,
1883                "No entries returned in getVersionMonitorEntry");
1884    
1885          return null;
1886        }
1887        else if (numEntries != 1)
1888        {
1889          debug(Level.FINE, DebugType.MONITOR,
1890                "Multiple entries returned in getVersionMonitorEntry");
1891        }
1892    
1893        return new VersionMonitorEntry(searchResult.getSearchEntries().get(0));
1894      }
1895    }