001/*
002 * The contents of this file are subject to the terms of the Common Development and
003 * Distribution License (the License). You may not use this file except in compliance with the
004 * License.
005 *
006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
007 * specific language governing permission and limitations under the License.
008 *
009 * When distributing Covered Software, include this CDDL Header Notice in each file and include
010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
011 * Header, with the fields enclosed by brackets [] replaced by your own identifying
012 * information: "Portions Copyright [year] [name of copyright owner]".
013 *
014 * Copyright 2008-2010 Sun Microsystems, Inc.
015 * Portions Copyright 2014-2016 ForgeRock AS.
016 */
017package org.opends.guitools.controlpanel.datamodel;
018
019import java.io.File;
020import java.io.IOException;
021import java.util.ArrayList;
022import java.util.Collection;
023import java.util.Collections;
024import java.util.Date;
025import java.util.HashSet;
026import java.util.List;
027import java.util.Set;
028
029import org.forgerock.opendj.ldap.DN;
030import org.forgerock.opendj.ldap.schema.AttributeType;
031import org.forgerock.opendj.ldap.schema.ObjectClass;
032import org.opends.guitools.controlpanel.util.ConfigFromDirContext;
033import org.opends.quicksetup.UserData;
034import org.opends.server.tools.tasks.TaskEntry;
035import org.opends.server.types.Schema;
036
037import com.forgerock.opendj.util.OperatingSystem;
038
039import static org.opends.guitools.controlpanel.datamodel.BasicMonitoringAttributes.*;
040import static org.opends.guitools.controlpanel.util.Utilities.*;
041import static org.opends.server.types.CommonSchemaElements.*;
042
043/**
044 * This is just a class used to provide a data model describing what the
045 * StatusPanelDialog will show to the user.
046 */
047public class ServerDescriptor
048{
049  private static String localHostName = UserData.getDefaultHostName();
050
051  private ServerStatus status;
052  private int openConnections;
053  private Set<BackendDescriptor> backends = new HashSet<>();
054  private Set<ConnectionHandlerDescriptor> listeners = new HashSet<>();
055  private ConnectionHandlerDescriptor adminConnector;
056  private Set<DN> administrativeUsers = new HashSet<>();
057  private String installPath;
058  private String instancePath;
059  private String openDSVersion;
060  private String javaVersion;
061  private ArrayList<Exception> exceptions = new ArrayList<>();
062  private boolean isWindowsServiceEnabled;
063  private boolean isSchemaEnabled;
064  private Schema schema;
065
066  private CustomSearchResult rootMonitor;
067  private CustomSearchResult jvmMemoryUsage;
068  private CustomSearchResult systemInformation;
069  private CustomSearchResult entryCaches;
070  private CustomSearchResult workQueue;
071
072  private Set<TaskEntry> taskEntries = new HashSet<>();
073
074  private long runningTime = -1;
075  private boolean isAuthenticated;
076  private String hostName = localHostName;
077  private boolean isLocal = true;
078
079  /** Enumeration indicating the status of the server. */
080  public enum ServerStatus
081  {
082    /** Server Started. */
083    STARTED,
084    /** Server Stopped. */
085    STOPPED,
086    /** Server Starting. */
087    STARTING,
088    /** Server Stopping. */
089    STOPPING,
090    /** Not connected to remote. */
091    NOT_CONNECTED_TO_REMOTE,
092    /** Status Unknown. */
093    UNKNOWN
094  }
095
096  /** Default constructor. */
097  public ServerDescriptor()
098  {
099  }
100
101  /**
102   * Return the administrative users.
103   * @return the administrative users.
104   */
105  public Set<DN> getAdministrativeUsers()
106  {
107    return administrativeUsers;
108  }
109
110  /**
111   * Set the administrative users.
112   * @param administrativeUsers the administrative users to set
113   */
114  public void setAdministrativeUsers(Set<DN> administrativeUsers)
115  {
116    this.administrativeUsers = Collections.unmodifiableSet(administrativeUsers);
117  }
118
119  /**
120   * Returns whether the schema is enabled or not.
121   * @return <CODE>true</CODE> if the schema is enabled and <CODE>false</CODE>
122   * otherwise.
123   */
124  public boolean isSchemaEnabled()
125  {
126    return isSchemaEnabled;
127  }
128
129  /**
130   * Sets whether the schema is enabled or not.
131   * @param isSchemaEnabled <CODE>true</CODE> if the schema is enabled and
132   * <CODE>false</CODE> otherwise.
133   */
134  public void setSchemaEnabled(boolean isSchemaEnabled)
135  {
136    this.isSchemaEnabled = isSchemaEnabled;
137  }
138
139  /**
140   * Return the instance path where the server databases and configuration is
141   * located.
142   * @return the instance path where the server databases and configuration is
143   * located
144   */
145  public String getInstancePath()
146  {
147    return instancePath;
148  }
149
150  /**
151   * Sets the instance path where the server databases and configuration is
152   * located.
153   * @param instancePath the instance path where the server databases and
154   * configuration is located.
155   */
156  public void setInstancePath(String instancePath)
157  {
158    this.instancePath = instancePath;
159  }
160
161  /**
162   * Return the install path where the server is installed.
163   * @return the install path where the server is installed.
164   */
165  public String getInstallPath()
166  {
167    return installPath;
168  }
169
170  /**
171   * Sets the install path where the server is installed.
172   * @param installPath the install path where the server is installed.
173   */
174  public void setInstallPath(String installPath)
175  {
176    this.installPath = installPath;
177  }
178
179  /**
180   * Returns whether the install and the instance are on the same server
181   * or not.
182   * @return whether the install and the instance are on the same server
183   * or not.
184   */
185  public boolean sameInstallAndInstance()
186  {
187    boolean sameInstallAndInstance;
188    String instance = getInstancePath();
189    String install = getInstallPath();
190    try
191    {
192      if (instance != null)
193      {
194        sameInstallAndInstance = instance.equals(install);
195        if (!sameInstallAndInstance &&
196            (isLocal() || OperatingSystem.isWindows()))
197        {
198          File f1 = new File(instance);
199          File f2 = new File(install);
200          sameInstallAndInstance =
201            f1.getCanonicalFile().equals(f2.getCanonicalFile());
202        }
203      }
204      else
205      {
206        sameInstallAndInstance = install == null;
207      }
208    }
209    catch (IOException ioe)
210    {
211      sameInstallAndInstance = false;
212    }
213    return sameInstallAndInstance;
214  }
215
216  /**
217   * Return the java version used to run the server.
218   * @return the java version used to run the server.
219   */
220  public String getJavaVersion()
221  {
222    return javaVersion;
223  }
224
225  /**
226   * Set the java version used to run the server.
227   * @param javaVersion the java version used to run the server.
228   */
229  public void setJavaVersion(String javaVersion)
230  {
231    this.javaVersion = javaVersion;
232  }
233
234  /**
235   * Returns the number of open connection in the server.
236   * @return the number of open connection in the server.
237   */
238  public int getOpenConnections()
239  {
240    return openConnections;
241  }
242
243  /**
244   * Set the number of open connections.
245   * @param openConnections the number of open connections.
246   */
247  public void setOpenConnections(int openConnections)
248  {
249    this.openConnections = openConnections;
250  }
251
252  /**
253   * Returns the version of the server.
254   * @return the version of the server.
255   */
256  public String getOpenDSVersion()
257  {
258    return openDSVersion;
259  }
260
261  /**
262   * Sets the version of the server.
263   * @param openDSVersion the version of the server.
264   */
265  public void setOpenDSVersion(String openDSVersion)
266  {
267    this.openDSVersion = openDSVersion;
268  }
269
270  /**
271   * Returns the status of the server.
272   * @return the status of the server.
273   */
274  public ServerStatus getStatus()
275  {
276    return status;
277  }
278
279  /**
280   * Sets the status of the server.
281   * @param status the status of the server.
282   */
283  public void setStatus(ServerStatus status)
284  {
285    this.status = status;
286  }
287
288  /**
289   * Returns the task entries.
290   * @return the task entries.
291   */
292  public Set<TaskEntry> getTaskEntries()
293  {
294    return taskEntries;
295  }
296
297  /**
298   * Sets the the task entries.
299   * @param taskEntries the task entries.
300   */
301  public void setTaskEntries(Set<TaskEntry> taskEntries)
302  {
303    this.taskEntries = Collections.unmodifiableSet(taskEntries);
304  }
305
306  @Override
307  public boolean equals(Object o)
308  {
309    if (this == o)
310    {
311      return true;
312    }
313    if (!(o instanceof ServerDescriptor))
314    {
315      return false;
316    }
317
318    ServerDescriptor desc = (ServerDescriptor) o;
319    return desc.getStatus() == getStatus()
320        && desc.isLocal() == isLocal()
321        && desc.isAuthenticated() == isAuthenticated()
322        && desc.getOpenConnections() == getOpenConnections()
323        && areEqual(getInstallPath(), desc.getInstallPath())
324        && areEqual(getInstancePath(), desc.getInstancePath())
325        && areEqual(getJavaVersion(), desc.getJavaVersion())
326        && areEqual(getOpenDSVersion(), desc.getOpenDSVersion())
327        && areEqual(desc.getAdministrativeUsers(), getAdministrativeUsers())
328        && areEqual(desc.getConnectionHandlers(), getConnectionHandlers())
329        && areEqual(desc.getBackends(), getBackends())
330        && areEqual(desc.getExceptions(), getExceptions())
331        && desc.isSchemaEnabled() == isSchemaEnabled()
332        && areSchemasEqual(getSchema(), desc.getSchema())
333        && (!OperatingSystem.isWindows() || desc.isWindowsServiceEnabled() == isWindowsServiceEnabled())
334        && desc.getTaskEntries().equals(getTaskEntries());
335  }
336
337  @Override
338  public int hashCode()
339  {
340    String s = installPath + openDSVersion + javaVersion + isAuthenticated;
341    return status.hashCode() + openConnections + s.hashCode();
342  }
343
344  /**
345   * Return whether we were authenticated when retrieving the information of
346   * this ServerStatusDescriptor.
347   * @return <CODE>true</CODE> if we were authenticated when retrieving the
348   * information of this ServerStatusDescriptor and <CODE>false</CODE>
349   * otherwise.
350   */
351  public boolean isAuthenticated()
352  {
353    return isAuthenticated;
354  }
355
356  /**
357   * Sets whether we were authenticated when retrieving the information of
358   * this ServerStatusDescriptor.
359   * @param isAuthenticated whether we were authenticated when retrieving the
360   * information of this ServerStatusDescriptor.
361   */
362  public void setAuthenticated(boolean isAuthenticated)
363  {
364    this.isAuthenticated = isAuthenticated;
365  }
366
367  /**
368   * Returns the backend descriptors of the server.
369   * @return the backend descriptors of the server.
370   */
371  public Set<BackendDescriptor> getBackends()
372  {
373    return backends;
374  }
375
376  /**
377   * Sets the backend descriptors of the server.
378   * @param backends the database descriptors to set.
379   */
380  public void setBackends(Set<BackendDescriptor> backends)
381  {
382    this.backends = Collections.unmodifiableSet(backends);
383  }
384
385  /**
386   * Returns the listener descriptors of the server.
387   * @return the listener descriptors of the server.
388   */
389  public Set<ConnectionHandlerDescriptor> getConnectionHandlers()
390  {
391    return listeners;
392  }
393
394  /**
395   * Sets the listener descriptors of the server.
396   * @param listeners the listener descriptors to set.
397   */
398  public void setConnectionHandlers(Set<ConnectionHandlerDescriptor> listeners)
399  {
400    this.listeners = Collections.unmodifiableSet(listeners);
401  }
402
403  /**
404   * Sets the schema of the server.
405   * @param schema the schema of the server.
406   */
407  public void setSchema(Schema schema)
408  {
409    this.schema = schema;
410  }
411
412  /**
413   * Returns the schema of the server.
414   * @return the schema of the server.
415   */
416  public Schema getSchema()
417  {
418    return schema;
419  }
420
421  /**
422   * Returns the host name of the server.
423   * @return the host name of the server.
424   */
425  public String getHostname()
426  {
427    return hostName;
428  }
429
430  /**
431   * Sets the host name of the server.
432   * @param hostName the host name of the server.
433   */
434  public void setHostname(String hostName)
435  {
436    this.hostName = hostName;
437  }
438
439  /**
440   * Returns <CODE>true</CODE> if we are trying to manage the local host and
441   * <CODE>false</CODE> otherwise.
442   * @return <CODE>true</CODE> if we are trying to manage the local host and
443   * <CODE>false</CODE> otherwise.
444   */
445  public boolean isLocal()
446  {
447    return isLocal;
448  }
449
450  /**
451   * Sets whether this server represents the local instance or a remote server.
452   * @param isLocal whether this server represents the local instance or a
453   * remote server (in another machine or in another installation on the same
454   * machine).
455   */
456  public void setIsLocal(boolean isLocal)
457  {
458    this.isLocal = isLocal;
459  }
460
461  /**
462   * Returns the exceptions that occurred while reading the configuration.
463   * @return the exceptions that occurred while reading the configuration.
464   */
465  public List<Exception> getExceptions()
466  {
467    return Collections.unmodifiableList(exceptions);
468  }
469
470  /**
471   * Sets the exceptions that occurred while reading the configuration.
472   * @param exceptions exceptions that occurred while reading the
473   * configuration.
474   */
475  public void setExceptions(Collection<Exception> exceptions)
476  {
477    this.exceptions.clear();
478    this.exceptions.addAll(exceptions);
479  }
480
481  /**
482   * Tells whether the windows service is enabled or not.
483   * @return <CODE>true</CODE> if the windows service is enabled and
484   * <CODE>false</CODE> otherwise.
485   */
486  public boolean isWindowsServiceEnabled()
487  {
488    return isWindowsServiceEnabled;
489  }
490
491  /**
492   * Sets whether the windows service is enabled or not.
493   * @param isWindowsServiceEnabled <CODE>true</CODE> if the windows service is
494   * enabled and <CODE>false</CODE> otherwise.
495   */
496  public void setWindowsServiceEnabled(boolean isWindowsServiceEnabled)
497  {
498    this.isWindowsServiceEnabled = isWindowsServiceEnabled;
499  }
500
501  /**
502   * Returns whether the server is running under a windows system or not.
503   * @return whether the server is running under a windows system or not.
504   */
505  public boolean isWindows()
506  {
507    if (isLocal())
508    {
509      return OperatingSystem.isWindows();
510    }
511    CustomSearchResult sr = getSystemInformationMonitor();
512    if (sr == null)
513    {
514      return false;
515    }
516    String os = getFirstValueAsString(sr, "operatingSystem");
517    return os != null && OperatingSystem.WINDOWS.equals(OperatingSystem.forName(os));
518  }
519
520  /**
521   * Method used to compare schemas.
522   * Returns <CODE>true</CODE> if the two schemas are equal and
523   * <CODE>false</CODE> otherwise.
524   * @param schema1 the first schema.
525   * @param schema2 the second schema.
526   * @return <CODE>true</CODE> if the two schemas are equal and
527   * <CODE>false</CODE> otherwise.
528   */
529  public static boolean areSchemasEqual(Schema schema1, Schema schema2)
530  {
531    if (schema1 == schema2)
532    {
533      return true;
534    }
535    else if (schema2 == null)
536    {
537      return schema1 != null;
538    }
539    else if (schema1 == null)
540    {
541      return false;
542    }
543
544    return areAttributeTypesEqual(schema1, schema2)
545        && areObjectClassesEqual(schema1, schema2)
546        && areEqual(schema1.getMatchingRules(), schema2.getMatchingRules())
547        && areEqual(schema1.getSyntaxes(), schema2.getSyntaxes());
548  }
549
550  private static boolean areAttributeTypesEqual(Schema schema1, Schema schema2)
551  {
552    final List<AttributeType> attrs1 = new ArrayList<>(schema1.getAttributeTypes());
553    final List<AttributeType> attrs2 = new ArrayList<>(schema2.getAttributeTypes());
554    if (attrs1.size() != attrs2.size())
555    {
556      return false;
557    }
558    Collections.sort(attrs1);
559    Collections.sort(attrs2);
560    for (int i = 0; i < attrs1.size(); i++)
561    {
562      AttributeType attr1 = attrs1.get(i);
563      AttributeType attr2 = attrs2.get(i);
564      if (attr2 == null || !areAttributesEqual(attr1, attr2))
565      {
566        return false;
567      }
568    }
569    return true;
570  }
571
572  private static boolean areObjectClassesEqual(Schema schema1, Schema schema2)
573  {
574    final Collection<ObjectClass> ocs1 = schema1.getObjectClasses();
575    final Collection<ObjectClass> ocs2 = schema2.getObjectClasses();
576    if (ocs1.size() != ocs2.size())
577    {
578      return false;
579    }
580    for (ObjectClass oc1 : ocs1)
581    {
582      ObjectClass oc2 = schema2.getObjectClass(oc1.getNameOrOID());
583      if (oc2.isPlaceHolder() || !areObjectClassesEqual(oc1, oc2))
584      {
585        return false;
586      }
587    }
588    return true;
589  }
590
591  /**
592   * Method used to compare attributes defined in the schema.
593   * Returns <CODE>true</CODE> if the two schema attributes are equal and
594   * <CODE>false</CODE> otherwise.
595   * @param schema1 the first schema attribute.
596   * @param schema2 the second schema attribute.
597   * @return <CODE>true</CODE> if the two schema attributes are equal and
598   * <CODE>false</CODE> otherwise.
599   */
600  private static boolean areAttributesEqual(AttributeType attr1, AttributeType attr2)
601  {
602    return attr1.getOID().equals(attr2.getOID())
603        && attr1.isCollective() == attr2.isCollective()
604        && attr1.isNoUserModification() == attr2.isNoUserModification()
605        && attr1.isObjectClass() == attr2.isObjectClass()
606        && attr1.isObsolete() == attr2.isObsolete()
607        && attr1.isOperational() == attr2.isOperational()
608        && attr1.isSingleValue() == attr2.isSingleValue()
609        && areEqual(attr1.getApproximateMatchingRule(), attr2.getApproximateMatchingRule())
610        && areEqual(new SomeSchemaElement(attr1).getDefinitionWithFileName(),
611            new SomeSchemaElement(attr2).getDefinitionWithFileName())
612        && areEqual(attr1.getDescription(), attr2.getDescription())
613        && areEqual(attr1.getEqualityMatchingRule(), attr2.getEqualityMatchingRule())
614        && areEqual(attr1.getOrderingMatchingRule(), attr2.getOrderingMatchingRule())
615        && areEqual(attr1.getSubstringMatchingRule(), attr2.getSubstringMatchingRule())
616        && areEqual(attr1.getSuperiorType(), attr2.getSuperiorType())
617        && areEqual(attr1.getSyntax(), attr2.getSyntax())
618        && areEqual(attr1.getSyntax().getOID(), attr2.getSyntax().getOID())
619        && areEqual(attr1.getExtraProperties().keySet(), attr2.getExtraProperties().keySet())
620        && areEqual(toSet(attr1.getNames()), toSet(attr2.getNames()));
621  }
622
623  /**
624   * Method used to compare objectclasses defined in the schema.
625   * Returns <CODE>true</CODE> if the two schema objectclasses are equal and
626   * <CODE>false</CODE> otherwise.
627   * @param schema1 the first schema objectclass.
628   * @param schema2 the second schema objectclass.
629   * @return <CODE>true</CODE> if the two schema objectclasses are equal and
630   * <CODE>false</CODE> otherwise.
631   */
632  private static boolean areObjectClassesEqual(ObjectClass oc1, ObjectClass oc2)
633  {
634    return oc1.getOID().equals(oc2.getOID())
635        && areEqual(getDefinitionWithFileName(oc1), getDefinitionWithFileName(oc2))
636        && areEqual(oc1.getDescription(), oc2.getDescription())
637        && areEqual(oc1.getObjectClassType(), oc2.getObjectClassType())
638        && areEqual(oc1.getDeclaredOptionalAttributes(), oc2.getDeclaredOptionalAttributes())
639        && areEqual(oc1.getDeclaredRequiredAttributes(), oc2.getDeclaredRequiredAttributes())
640        && areEqual(oc1.getSuperiorClasses(), oc2.getSuperiorClasses())
641        && areEqual(oc1.getExtraProperties().keySet(), oc2.getExtraProperties().keySet())
642        && areEqual(toSet(oc1.getNames()), toSet(oc2.getNames()));
643  }
644
645  private static Set<Object> toSet(Iterable<?> iterable)
646  {
647    Set<Object> s = new HashSet<>();
648    for (Object o : iterable)
649    {
650      s.add(o);
651    }
652    return s;
653  }
654
655  /**
656   * Commodity method used to compare two objects that might be
657   * <CODE>null</CODE>.
658   * @param o1 the first object.
659   * @param o2 the second object.
660   * @return if both objects are <CODE>null</CODE> returns true.  If not returns
661   * <CODE>true</CODE> if both objects are equal according to the Object.equal
662   * method and <CODE>false</CODE> otherwise.
663   */
664  private static boolean areEqual(Object o1, Object o2)
665  {
666    if (o1 != null)
667    {
668      return o1.equals(o2);
669    }
670    return o2 == null;
671  }
672
673  /**
674   * Returns the admin connector.
675   * @return the admin connector.
676   */
677  public ConnectionHandlerDescriptor getAdminConnector()
678  {
679    return adminConnector;
680  }
681
682  /**
683   * Sets the admin connector.
684   * @param adminConnector the admin connector.
685   */
686  public void setAdminConnector(ConnectionHandlerDescriptor adminConnector)
687  {
688    this.adminConnector = adminConnector;
689  }
690
691  /**
692   * Sets the monitoring entry for the entry caches.
693   * @param entryCaches the monitoring entry for the entry caches.
694   */
695  public void setEntryCachesMonitor(CustomSearchResult entryCaches)
696  {
697    this.entryCaches = entryCaches;
698  }
699
700  /**
701   * Sets the monitoring entry for the JVM memory usage.
702   * @param jvmMemoryUsage the monitoring entry for the JVM memory usage.
703   */
704  public void setJvmMemoryUsageMonitor(CustomSearchResult jvmMemoryUsage)
705  {
706    this.jvmMemoryUsage = jvmMemoryUsage;
707  }
708
709  /**
710   * Sets the root entry of the monitoring tree.
711   * @param rootMonitor the root entry of the monitoring tree.
712   */
713  public void setRootMonitor(CustomSearchResult rootMonitor)
714  {
715    this.rootMonitor = rootMonitor;
716    runningTime = computeRunningTime(rootMonitor);
717  }
718
719  private long computeRunningTime(CustomSearchResult rootMonitor)
720  {
721    if (rootMonitor != null)
722    {
723      try
724      {
725        String start = getFirstValueAsString(rootMonitor, START_DATE.getAttributeName());
726        String current = getFirstValueAsString(rootMonitor, CURRENT_DATE.getAttributeName());
727        Date startTime = ConfigFromDirContext.utcParser.parse(start);
728        Date currentTime = ConfigFromDirContext.utcParser.parse(current);
729        return currentTime.getTime() - startTime.getTime();
730      }
731      catch (Throwable t)
732      {
733        return -1;
734      }
735    }
736    return -1;
737  }
738
739  /**
740   * Returns the running time of the server in milliseconds.  Returns -1 if
741   * no running time could be found.
742   * @return the running time of the server in milliseconds.
743   */
744  public long getRunningTime()
745  {
746    return runningTime;
747  }
748
749  /**
750   * Sets the monitoring entry for the system information.
751   * @param systemInformation entry for the system information.
752   */
753  public void setSystemInformationMonitor(CustomSearchResult systemInformation)
754  {
755    this.systemInformation = systemInformation;
756  }
757
758  /**
759   * Sets the monitoring entry of the work queue.
760   * @param workQueue entry of the work queue.
761   */
762  public void setWorkQueueMonitor(CustomSearchResult workQueue)
763  {
764    this.workQueue = workQueue;
765  }
766
767  /**
768   * Returns the monitoring entry for the entry caches.
769   * @return the monitoring entry for the entry caches.
770   */
771  public CustomSearchResult getEntryCachesMonitor()
772  {
773    return entryCaches;
774  }
775
776  /**
777   * Returns the monitoring entry for the JVM memory usage.
778   * @return the monitoring entry for the JVM memory usage.
779   */
780  public CustomSearchResult getJvmMemoryUsageMonitor()
781  {
782    return jvmMemoryUsage;
783  }
784
785  /**
786   * Returns the root entry of the monitoring tree.
787   * @return the root entry of the monitoring tree.
788   */
789  public CustomSearchResult getRootMonitor()
790  {
791    return rootMonitor;
792  }
793
794  /**
795   * Returns the monitoring entry for the system information.
796   * @return the monitoring entry for the system information.
797   */
798  public CustomSearchResult getSystemInformationMonitor()
799  {
800    return systemInformation;
801  }
802
803  /**
804   * Returns the monitoring entry for the work queue.
805   * @return the monitoring entry for the work queue.
806   */
807  public CustomSearchResult getWorkQueueMonitor()
808  {
809    return workQueue;
810  }
811}