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}