001/* 002 * Copyright 2008-2025 Ping Identity Corporation 003 * All Rights Reserved. 004 */ 005/* 006 * Copyright 2008-2025 Ping Identity Corporation 007 * 008 * Licensed under the Apache License, Version 2.0 (the "License"); 009 * you may not use this file except in compliance with the License. 010 * You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, software 015 * distributed under the License is distributed on an "AS IS" BASIS, 016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 017 * See the License for the specific language governing permissions and 018 * limitations under the License. 019 */ 020/* 021 * Copyright (C) 2008-2025 Ping Identity Corporation 022 * 023 * This program is free software; you can redistribute it and/or modify 024 * it under the terms of the GNU General Public License (GPLv2 only) 025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 026 * as published by the Free Software Foundation. 027 * 028 * This program is distributed in the hope that it will be useful, 029 * but WITHOUT ANY WARRANTY; without even the implied warranty of 030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 031 * GNU General Public License for more details. 032 * 033 * You should have received a copy of the GNU General Public License 034 * along with this program; if not, see <http://www.gnu.org/licenses>. 035 */ 036package com.unboundid.ldap.sdk.unboundidds.monitors; 037 038 039 040import java.util.Collections; 041import java.util.LinkedHashMap; 042import java.util.Map; 043 044import com.unboundid.ldap.sdk.Entry; 045import com.unboundid.util.NotMutable; 046import com.unboundid.util.NotNull; 047import com.unboundid.util.Nullable; 048import com.unboundid.util.StaticUtils; 049import com.unboundid.util.ThreadSafety; 050import com.unboundid.util.ThreadSafetyLevel; 051 052import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 053 054 055 056/** 057 * This class defines a monitor entry that provides general information about 058 * the Directory Server version. 059 * <BR> 060 * <BLOCKQUOTE> 061 * <B>NOTE:</B> This class, and other classes within the 062 * {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only 063 * supported for use against Ping Identity, UnboundID, and 064 * Nokia/Alcatel-Lucent 8661 server products. These classes provide support 065 * for proprietary functionality or for external specifications that are not 066 * considered stable or mature enough to be guaranteed to work in an 067 * interoperable way with other types of LDAP servers. 068 * </BLOCKQUOTE> 069 * <BR> 070 * Information that it may make available includes: 071 * <UL> 072 * <LI>The full Directory Server version string, which may contain 073 * spaces.</LI> 074 * <LI>The compact Directory Server version string, which will not contain 075 * any spaces and may use a more compact representation than the full 076 * version string.</LI> 077 * <LI>The Directory Server product name.</LI> 078 * <LI>A compact representation of the Directory Server product name.</LI> 079 * <LI>The server major version number.</LI> 080 * <LI>The server minor version number.</LI> 081 * <LI>The server point version number.</LI> 082 * <LI>A version qualifier string which may provide a more descriptive name 083 * for the build of the server.</LI> 084 * <LI>The server build ID string.</LI> 085 * <LI>The server promoted build number.</LI> 086 * <LI>The source control revision number for the source used to build the 087 * server.</LI> 088 * <LI>A list of the bugfix IDs for any special fixes included in the 089 * server.</LI> 090 * </UL> 091 * The server should present at most one version monitor entry. It can be 092 * retrieved using the {@link MonitorManager#getVersionMonitorEntry} method. 093 * This entry provides specific methods for accessing this version information 094 * (e.g., the {@link VersionMonitorEntry#getFullVersion} method can be used to 095 * retrieve the full version string for the server). Alternately, this 096 * information may be accessed using the generic API. See the 097 * {@link MonitorManager} class documentation for an example that demonstrates 098 * the use of the generic API for accessing monitor data. 099 */ 100@NotMutable() 101@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 102public final class VersionMonitorEntry 103 extends MonitorEntry 104{ 105 /** 106 * The structural object class used in version monitor entries. 107 */ 108 @NotNull protected static final String VERSION_MONITOR_OC = 109 "ds-version-monitor-entry"; 110 111 112 113 /** 114 * The name of the attribute used to provide the server build ID. 115 */ 116 @NotNull private static final String ATTR_BUILD_ID = "buildID"; 117 118 119 120 /** 121 * The name of the attribute used to provide the server promoted build number. 122 */ 123 @NotNull private static final String ATTR_BUILD_NUMBER = "buildNumber"; 124 125 126 127 /** 128 * The name of the attribute used to provide a compact server version string. 129 */ 130 @NotNull private static final String ATTR_COMPACT_VERSION = "compactVersion"; 131 132 133 134 /** 135 * The name of the attribute used to indicate whether the server is operating 136 * in FIPS-compliant mode (regardless of whether it's using FIPS 140-2 or 137 * FIPS 140-3). 138 */ 139 @NotNull private static final String ATTR_FIPS_COMPLIANT_MODE = 140 "fips-compliant-mode"; 141 142 143 144 /** 145 * The name of the attribute used to indicate whether the server is operating 146 * in FIPS 140-2-compliant mode. 147 */ 148 @NotNull private static final String ATTR_FIPS_140_2_COMPLIANT_MODE = 149 "fips-140-2-compliant-mode"; 150 151 152 153 /** 154 * The name of the attribute used to indicate whether the server is operating 155 * in FIPS 140-3-compliant mode. 156 */ 157 @NotNull private static final String ATTR_FIPS_140_3_COMPLIANT_MODE = 158 "fips-140-3-compliant-mode"; 159 160 161 162 /** 163 * The name of the attribute used to provide the list of bugfix IDs. 164 */ 165 @NotNull private static final String ATTR_FIX_IDS = "fixIDs"; 166 167 168 169 /** 170 * The name of the attribute used to provide a full server version string. 171 */ 172 @NotNull private static final String ATTR_FULL_VERSION = "fullVersion"; 173 174 175 176 /** 177 * The name of the attribute used to hold the Groovy library version. 178 */ 179 @NotNull private static final String ATTR_GROOVY_VERSION = "groovyVersion"; 180 181 182 183 /** 184 * The name of the attribute used to hold the Berkeley DB JE library version. 185 */ 186 @NotNull private static final String ATTR_JE_VERSION = "jeVersion"; 187 188 189 190 /** 191 * The name of the attribute used to hold the jzlib library version. 192 */ 193 @NotNull private static final String ATTR_JZLIB_VERSION = "jzlibVersion"; 194 195 196 197 /** 198 * The name of the attribute used to hold the LDAP SDK library version. 199 */ 200 @NotNull private static final String ATTR_LDAP_SDK_VERSION = "ldapSDKVersion"; 201 202 203 204 /** 205 * The name of the attribute used to provide the major version number. 206 */ 207 @NotNull private static final String ATTR_MAJOR_VERSION = "majorVersion"; 208 209 210 211 /** 212 * The name of the attribute used to provide the minor version number. 213 */ 214 @NotNull private static final String ATTR_MINOR_VERSION = "minorVersion"; 215 216 217 218 /** 219 * The name of the attribute used to provide the point version number. 220 */ 221 @NotNull private static final String ATTR_POINT_VERSION = "pointVersion"; 222 223 224 225 /** 226 * The name of the attribute used to provide the product name. 227 */ 228 @NotNull private static final String ATTR_PRODUCT_NAME = "productName"; 229 230 231 232 /** 233 * The name of the attribute used to provide the source revision identifier. 234 */ 235 @NotNull private static final String ATTR_REVISION_ID = "revisionID"; 236 237 238 239 /** 240 * The name of the attribute used to provide the source revision number. 241 */ 242 @NotNull private static final String ATTR_REVISION_NUMBER = "revisionNumber"; 243 244 245 246 /** 247 * The name of the attribute used to hold the server SDK library version. 248 */ 249 @NotNull private static final String ATTR_SERVER_SDK_VERSION = 250 "serverSDKVersion"; 251 252 253 254 /** 255 * The name of the attribute used to provide the short product name. 256 */ 257 @NotNull private static final String ATTR_SHORT_NAME = "shortName"; 258 259 260 261 /** 262 * The name of the attribute used to hold the server SNMP4J library version. 263 */ 264 @NotNull private static final String ATTR_SNMP4J_VERSION = "snmp4jVersion"; 265 266 267 268 /** 269 * The name of the attribute used to hold the server SNMP4J agent library 270 * version. 271 */ 272 @NotNull private static final String ATTR_SNMP4J_AGENT_VERSION = 273 "snmp4jAgentVersion"; 274 275 276 277 /** 278 * The name of the attribute used to hold the server SNMP4J AgentX library 279 * version. 280 */ 281 @NotNull private static final String ATTR_SNMP4J_AGENTX_VERSION = 282 "snmp4jAgentXVersion"; 283 284 285 286 /** 287 * The name of the attribute used to provide the server's version qualifier. 288 */ 289 @NotNull private static final String ATTR_VERSION_QUALIFIER = 290 "versionQualifier"; 291 292 293 294 /** 295 * The serial version UID for this serializable class. 296 */ 297 private static final long serialVersionUID = -8501846678698542926L; 298 299 300 301 // Indicates whether the server is running in FIPS-compliant mode. 302 @Nullable private final Boolean fipsCompliantMode; 303 304 // Indicates whether the server is running in FIPS 1402-2-compliant mode. 305 @Nullable private final Boolean fips1402CompliantMode; 306 307 // Indicates whether the server is running in FIPS 1402-3-compliant mode. 308 @Nullable private final Boolean fips1403CompliantMode; 309 310 // The server build number. 311 @Nullable private final Long buildNumber; 312 313 // The server major version number. 314 @Nullable private final Long majorVersion; 315 316 // The server minor version number. 317 @Nullable private final Long minorVersion; 318 319 // The server point version number. 320 @Nullable private final Long pointVersion; 321 322 // The server source revision number. 323 @Nullable private final Long revisionNumber; 324 325 // The server build ID. 326 @Nullable private final String buildID; 327 328 // The compact server version string. 329 @Nullable private final String compactVersion; 330 331 // The list of bugfix IDs. 332 @Nullable private final String fixIDs; 333 334 // The Groovy library version. 335 @Nullable private final String groovyVersion; 336 337 // The full server version string. 338 @Nullable private final String fullVersion; 339 340 // The Berkeley DB JE library version. 341 @Nullable private final String jeVersion; 342 343 // The jzlib library version. 344 @Nullable private final String jzlibVersion; 345 346 // The LDAP SDK library version. 347 @Nullable private final String ldapSDKVersion; 348 349 // The server product name. 350 @Nullable private final String productName; 351 352 // A string that identifies the source revision from which the server was 353 // built. 354 @Nullable private final String revisionID; 355 356 // The server SDK library version. 357 @Nullable private final String serverSDKVersion; 358 359 // The server short product name. 360 @Nullable private final String shortName; 361 362 // The SNMP4J library version. 363 @Nullable private final String snmp4jVersion; 364 365 // The SNMP4J agent library version. 366 @Nullable private final String snmp4jAgentVersion; 367 368 // The SNMP4J AgentX library version. 369 @Nullable private final String snmp4jAgentXVersion; 370 371 // The server version qualifier string. 372 @Nullable private final String versionQualifier; 373 374 375 376 /** 377 * Creates a new version monitor entry from the provided entry. 378 * 379 * @param entry The entry to be parsed as a version monitor entry. It must 380 * not be {@code null}. 381 */ 382 public VersionMonitorEntry(@NotNull final Entry entry) 383 { 384 super(entry); 385 386 fipsCompliantMode = getBoolean(ATTR_FIPS_COMPLIANT_MODE); 387 fips1402CompliantMode = getBoolean(ATTR_FIPS_140_2_COMPLIANT_MODE); 388 fips1403CompliantMode = getBoolean(ATTR_FIPS_140_3_COMPLIANT_MODE); 389 buildNumber = getLong(ATTR_BUILD_NUMBER); 390 majorVersion = getLong(ATTR_MAJOR_VERSION); 391 minorVersion = getLong(ATTR_MINOR_VERSION); 392 pointVersion = getLong(ATTR_POINT_VERSION); 393 revisionNumber = getLong(ATTR_REVISION_NUMBER); 394 buildID = getString(ATTR_BUILD_ID); 395 compactVersion = getString(ATTR_COMPACT_VERSION); 396 fixIDs = getString(ATTR_FIX_IDS); 397 groovyVersion = getString(ATTR_GROOVY_VERSION); 398 fullVersion = getString(ATTR_FULL_VERSION); 399 jeVersion = getString(ATTR_JE_VERSION); 400 jzlibVersion = getString(ATTR_JZLIB_VERSION); 401 ldapSDKVersion = getString(ATTR_LDAP_SDK_VERSION); 402 productName = getString(ATTR_PRODUCT_NAME); 403 revisionID = getString(ATTR_REVISION_ID); 404 serverSDKVersion = getString(ATTR_SERVER_SDK_VERSION); 405 shortName = getString(ATTR_SHORT_NAME); 406 snmp4jVersion = getString(ATTR_SNMP4J_VERSION); 407 snmp4jAgentVersion = getString(ATTR_SNMP4J_AGENT_VERSION); 408 snmp4jAgentXVersion = getString(ATTR_SNMP4J_AGENTX_VERSION); 409 versionQualifier = getString(ATTR_VERSION_QUALIFIER); 410 } 411 412 413 414 /** 415 * Retrieves the Directory Server build ID string. 416 * 417 * @return The Directory Server build ID string, or {@code null} if it was 418 * not included in the monitor entry. 419 */ 420 @Nullable() 421 public String getBuildID() 422 { 423 return buildID; 424 } 425 426 427 428 /** 429 * Retrieves the Directory Server promoted build number. 430 * 431 * @return The Directory Server promoted build number, or {@code null} if it 432 * was not included in the monitor entry. 433 */ 434 @Nullable() 435 public Long getBuildNumber() 436 { 437 return buildNumber; 438 } 439 440 441 442 /** 443 * Retrieves a compact representation of the Directory Server version string. 444 * It will not contain any spaces. 445 * 446 * @return A compact representation of the Directory Server version string, 447 * or {@code null} if it was not included in the monitor entry. 448 */ 449 @Nullable() 450 public String getCompactVersion() 451 { 452 return compactVersion; 453 } 454 455 456 457 /** 458 * Indicates whether the server is running in FIPS-compliant mode. 459 * 460 * @return {@code Boolean.TRUE} if the server is running in FIPS 140-2 or 461 * FIPS 140-3-compliant mode, {@code Boolean.FALSE} if the server is 462 * not running in FIPS-compliant mode, or {@code null} if it was not 463 * included in the monitor entry. 464 */ 465 @Nullable() 466 public Boolean getFIPSCompliantMode() 467 { 468 return fipsCompliantMode; 469 } 470 471 472 473 /** 474 * Indicates whether the server is running in FIPS 140-2-compliant mode. 475 * 476 * @return {@code Boolean.TRUE} if the server is running in FIPS 477 * 140-2-compliant mode, {@code Boolean.FALSE} if the server is not 478 * running in FIPS 140-2-compliant mode, or {@code null} if it was 479 * not included in the monitor entry. 480 */ 481 @Nullable() 482 public Boolean getFIPS1402CompliantMode() 483 { 484 return fips1402CompliantMode; 485 } 486 487 488 489 /** 490 * Indicates whether the server is running in FIPS 140-3-compliant mode. 491 * 492 * @return {@code Boolean.TRUE} if the server is running in FIPS 493 * 140-3-compliant mode, {@code Boolean.FALSE} if the server is not 494 * running in FIPS 140-3-compliant mode, or {@code null} if it was 495 * not included in the monitor entry. 496 */ 497 @Nullable() 498 public Boolean getFIPS1403CompliantMode() 499 { 500 return fips1403CompliantMode; 501 } 502 503 504 505 /** 506 * Retrieves a space-delimited list of the bugfix IDs for special fixes 507 * included in the Directory Server. 508 * 509 * @return A space-delimited list of the bugfix IDs for special fixes 510 * included in the Directory Server, or {@code null} if it was not 511 * included in the monitor entry. 512 */ 513 @Nullable() 514 public String getFixIDs() 515 { 516 return fixIDs; 517 } 518 519 520 521 /** 522 * Retrieves the full Directory Server version string. 523 * 524 * @return The full Directory Server version string, or {@code null} if it 525 * was not included in the monitor entry. 526 */ 527 @Nullable() 528 public String getFullVersion() 529 { 530 return fullVersion; 531 } 532 533 534 535 /** 536 * Retrieves the Groovy library version string. 537 * 538 * @return The Groovy library version string, or {@code null} if it was not 539 * included in the monitor entry. 540 */ 541 @Nullable() 542 public String getGroovyVersion() 543 { 544 return groovyVersion; 545 } 546 547 548 549 /** 550 * Retrieves the Berkeley DB Java Edition library version string. 551 * 552 * @return The Berkeley DB Java Edition library version string, or 553 * {@code null} if it was not included in the monitor entry. 554 */ 555 @Nullable() 556 public String getBerkeleyDBJEVersion() 557 { 558 return jeVersion; 559 } 560 561 562 563 /** 564 * Retrieves the jzlib library version string. 565 * 566 * @return The jzlib library version string, or {@code null} if it was not 567 * included in the monitor entry. 568 */ 569 @Nullable() 570 public String getJZLibVersion() 571 { 572 return jzlibVersion; 573 } 574 575 576 577 /** 578 * Retrieves the UnboundID LDAP SDK for Java library version string. 579 * 580 * @return The UnboundID LDAP SDK for Java library version string, or 581 * {@code null} if it was not included in the monitor entry. 582 */ 583 @Nullable() 584 public String getLDAPSDKVersion() 585 { 586 return ldapSDKVersion; 587 } 588 589 590 591 /** 592 * Retrieves the Directory Server major version number. 593 * 594 * @return The Directory Server major version number, or {@code null} if it 595 * was not included in the monitor entry. 596 */ 597 @Nullable() 598 public Long getMajorVersion() 599 { 600 return majorVersion; 601 } 602 603 604 605 /** 606 * Retrieves the Directory Server minor version number. 607 * 608 * @return The Directory Server minor version number, or {@code null} if it 609 * was not included in the monitor entry. 610 */ 611 @Nullable() 612 public Long getMinorVersion() 613 { 614 return minorVersion; 615 } 616 617 618 619 /** 620 * Retrieves the Directory Server point version number. 621 * 622 * @return The Directory Server point version number, or {@code null} if it 623 * was not included in the monitor entry. 624 */ 625 @Nullable() 626 public Long getPointVersion() 627 { 628 return pointVersion; 629 } 630 631 632 633 /** 634 * Retrieves the Directory Server product name (e.g., "Ping Identity Directory 635 * Server"). 636 * 637 * @return The Directory Server product name, or {@code null} if it was not 638 * included in the monitor entry. 639 */ 640 @Nullable() 641 public String getProductName() 642 { 643 return productName; 644 } 645 646 647 648 /** 649 * Retrieves the source revision number from which the Directory Server was 650 * built. 651 * 652 * @return The source revision number from which the Directory Server was 653 * built, or {@code null} if it was not included in the monitor 654 * entry or if it was not numeric. 655 * 656 * @deprecated Use {@link #getRevisionID} instead, as the version control 657 * system might not use numeric revision identifiers. 658 */ 659 @Deprecated() 660 @Nullable() 661 public Long getRevisionNumber() 662 { 663 return revisionNumber; 664 } 665 666 667 668 /** 669 * Retrieves a string that identifies the source revision from which the 670 * server was built. 671 * 672 * @return A string that identifies the source revision from which the server 673 * was built. 674 */ 675 @Nullable() 676 public String getRevisionID() 677 { 678 return revisionID; 679 } 680 681 682 683 /** 684 * Retrieves the UnboundID Server SDK library version string. 685 * 686 * @return The UnboundID Server SDK library version string, or {@code null} 687 * if it was not included in the monitor entry. 688 */ 689 @Nullable() 690 public String getServerSDKVersion() 691 { 692 return serverSDKVersion; 693 } 694 695 696 697 /** 698 * Retrieves the Directory Server short product name (e.g., 699 * "Ping-Identity-DS"). 700 * 701 * @return The Directory Server short product name, or {@code null} if it was 702 * not included in the monitor entry. 703 */ 704 @Nullable() 705 public String getShortProductName() 706 { 707 return shortName; 708 } 709 710 711 712 /** 713 * Retrieves the SNMP4J library version string. 714 * 715 * @return The SNMP4J library version string, or {@code null} if it was not 716 * included in the monitor entry. 717 */ 718 @Nullable() 719 public String getSNMP4JVersion() 720 { 721 return snmp4jVersion; 722 } 723 724 725 726 /** 727 * Retrieves the SNMP4J agent library version string. 728 * 729 * @return The SNMP4J agent library version string, or {@code null} if it was 730 * not included in the monitor entry. 731 */ 732 @Nullable() 733 public String getSNMP4JAgentVersion() 734 { 735 return snmp4jAgentVersion; 736 } 737 738 739 740 /** 741 * Retrieves the SNMP4J AgentX library version string. 742 * 743 * @return The SNMP4J AgentX library version string, or {@code null} if it 744 * was not included in the monitor entry. 745 */ 746 @Nullable() 747 public String getSNMP4JAgentXVersion() 748 { 749 return snmp4jAgentXVersion; 750 } 751 752 753 754 /** 755 * Retrieves the Directory Server version qualifier string (e.g., "-beta1"). 756 * 757 * @return The Directory Server version qualifier string, or {@code null} if 758 * it was not included in the monitor entry. 759 */ 760 @Nullable() 761 public String getVersionQualifier() 762 { 763 return versionQualifier; 764 } 765 766 767 768 /** 769 * {@inheritDoc} 770 */ 771 @Override() 772 @NotNull() 773 public String getMonitorDisplayName() 774 { 775 return INFO_VERSION_MONITOR_DISPNAME.get(); 776 } 777 778 779 780 /** 781 * {@inheritDoc} 782 */ 783 @Override() 784 @NotNull() 785 public String getMonitorDescription() 786 { 787 return INFO_VERSION_MONITOR_DESC.get(); 788 } 789 790 791 792 /** 793 * {@inheritDoc} 794 */ 795 @Override() 796 @NotNull() 797 public Map<String,MonitorAttribute> getMonitorAttributes() 798 { 799 final LinkedHashMap<String,MonitorAttribute> attrs = 800 new LinkedHashMap<>(StaticUtils.computeMapCapacity(20)); 801 802 if (productName != null) 803 { 804 addMonitorAttribute(attrs, 805 ATTR_PRODUCT_NAME, 806 INFO_VERSION_DISPNAME_PRODUCT_NAME.get(), 807 INFO_VERSION_DESC_PRODUCT_NAME.get(), 808 productName); 809 } 810 811 if (shortName != null) 812 { 813 addMonitorAttribute(attrs, 814 ATTR_SHORT_NAME, 815 INFO_VERSION_DISPNAME_SHORT_NAME.get(), 816 INFO_VERSION_DESC_SHORT_NAME.get(), 817 shortName); 818 } 819 820 if (fullVersion != null) 821 { 822 addMonitorAttribute(attrs, 823 ATTR_FULL_VERSION, 824 INFO_VERSION_DISPNAME_FULL_VERSION.get(), 825 INFO_VERSION_DESC_FULL_VERSION.get(), 826 fullVersion); 827 } 828 829 if (compactVersion != null) 830 { 831 addMonitorAttribute(attrs, 832 ATTR_COMPACT_VERSION, 833 INFO_VERSION_DISPNAME_COMPACT_VERSION.get(), 834 INFO_VERSION_DESC_COMPACT_VERSION.get(), 835 compactVersion); 836 } 837 838 if (buildID != null) 839 { 840 addMonitorAttribute(attrs, 841 ATTR_BUILD_ID, 842 INFO_VERSION_DISPNAME_BUILD_ID.get(), 843 INFO_VERSION_DESC_BUILD_ID.get(), 844 buildID); 845 } 846 847 if (majorVersion != null) 848 { 849 addMonitorAttribute(attrs, 850 ATTR_MAJOR_VERSION, 851 INFO_VERSION_DISPNAME_MAJOR_VERSION.get(), 852 INFO_VERSION_DESC_MAJOR_VERSION.get(), 853 majorVersion); 854 } 855 856 if (minorVersion != null) 857 { 858 addMonitorAttribute(attrs, 859 ATTR_MINOR_VERSION, 860 INFO_VERSION_DISPNAME_MINOR_VERSION.get(), 861 INFO_VERSION_DESC_MINOR_VERSION.get(), 862 minorVersion); 863 } 864 865 if (pointVersion != null) 866 { 867 addMonitorAttribute(attrs, 868 ATTR_POINT_VERSION, 869 INFO_VERSION_DISPNAME_POINT_VERSION.get(), 870 INFO_VERSION_DESC_POINT_VERSION.get(), 871 pointVersion); 872 } 873 874 if (buildNumber != null) 875 { 876 addMonitorAttribute(attrs, 877 ATTR_BUILD_NUMBER, 878 INFO_VERSION_DISPNAME_BUILD_NUMBER.get(), 879 INFO_VERSION_DESC_BUILD_NUMBER.get(), 880 buildNumber); 881 } 882 883 if (versionQualifier != null) 884 { 885 addMonitorAttribute(attrs, 886 ATTR_VERSION_QUALIFIER, 887 INFO_VERSION_DISPNAME_VERSION_QUALIFIER.get(), 888 INFO_VERSION_DESC_VERSION_QUALIFIER.get(), 889 versionQualifier); 890 } 891 892 if (revisionNumber != null) 893 { 894 addMonitorAttribute(attrs, 895 ATTR_REVISION_NUMBER, 896 INFO_VERSION_DISPNAME_REVISION_NUMBER.get(), 897 INFO_VERSION_DESC_REVISION_NUMBER.get(), 898 revisionNumber); 899 } 900 901 if (revisionID != null) 902 { 903 addMonitorAttribute(attrs, 904 ATTR_REVISION_ID, 905 INFO_VERSION_DISPNAME_REVISION_ID.get(), 906 INFO_VERSION_DESC_REVISION_ID.get(), 907 revisionID); 908 } 909 910 if (fipsCompliantMode != null) 911 { 912 addMonitorAttribute(attrs, 913 ATTR_FIPS_COMPLIANT_MODE, 914 INFO_VERSION_DISPNAME_FIPS_COMPLIANT_MODE.get(), 915 INFO_VERSION_DESC_FIPS_COMPLIANT_MODE.get(), 916 fipsCompliantMode); 917 } 918 919 if (fips1402CompliantMode != null) 920 { 921 addMonitorAttribute(attrs, 922 ATTR_FIPS_140_2_COMPLIANT_MODE, 923 INFO_VERSION_DISPNAME_FIPS_140_2_COMPLIANT_MODE.get(), 924 INFO_VERSION_DESC_FIPS_140_2_COMPLIANT_MODE.get(), 925 fips1402CompliantMode); 926 } 927 928 if (fips1403CompliantMode != null) 929 { 930 addMonitorAttribute(attrs, 931 ATTR_FIPS_140_3_COMPLIANT_MODE, 932 INFO_VERSION_DISPNAME_FIPS_140_3_COMPLIANT_MODE.get(), 933 INFO_VERSION_DESC_FIPS_140_3_COMPLIANT_MODE.get(), 934 fips1403CompliantMode); 935 } 936 937 if (fixIDs != null) 938 { 939 addMonitorAttribute(attrs, 940 ATTR_FIX_IDS, 941 INFO_VERSION_DISPNAME_FIX_IDS.get(), 942 INFO_VERSION_DESC_FIX_IDS.get(), 943 fixIDs); 944 } 945 946 if (groovyVersion != null) 947 { 948 addMonitorAttribute(attrs, 949 ATTR_GROOVY_VERSION, 950 INFO_VERSION_DISPNAME_GROOVY_VERSION.get(), 951 INFO_VERSION_DESC_GROOVY_VERSION.get(), 952 groovyVersion); 953 } 954 955 if (jeVersion != null) 956 { 957 addMonitorAttribute(attrs, 958 ATTR_JE_VERSION, 959 INFO_VERSION_DISPNAME_JE_VERSION.get(), 960 INFO_VERSION_DESC_JE_VERSION.get(), 961 jeVersion); 962 } 963 964 if (jzlibVersion != null) 965 { 966 addMonitorAttribute(attrs, 967 ATTR_JZLIB_VERSION, 968 INFO_VERSION_DISPNAME_JZLIB_VERSION.get(), 969 INFO_VERSION_DESC_JZLIB_VERSION.get(), 970 jzlibVersion); 971 } 972 973 if (ldapSDKVersion != null) 974 { 975 addMonitorAttribute(attrs, 976 ATTR_LDAP_SDK_VERSION, 977 INFO_VERSION_DISPNAME_LDAP_SDK_VERSION.get(), 978 INFO_VERSION_DESC_LDAP_SDK_VERSION.get(), 979 ldapSDKVersion); 980 } 981 982 if (serverSDKVersion != null) 983 { 984 addMonitorAttribute(attrs, 985 ATTR_SERVER_SDK_VERSION, 986 INFO_VERSION_DISPNAME_SERVER_SDK_VERSION.get(), 987 INFO_VERSION_DESC_SERVER_SDK_VERSION.get(), 988 serverSDKVersion); 989 } 990 991 if (snmp4jVersion != null) 992 { 993 addMonitorAttribute(attrs, 994 ATTR_SNMP4J_VERSION, 995 INFO_VERSION_DISPNAME_SNMP4J_VERSION.get(), 996 INFO_VERSION_DESC_SNMP4J_VERSION.get(), 997 snmp4jVersion); 998 } 999 1000 if (snmp4jAgentVersion != null) 1001 { 1002 addMonitorAttribute(attrs, 1003 ATTR_SNMP4J_AGENT_VERSION, 1004 INFO_VERSION_DISPNAME_SNMP4J_AGENT_VERSION.get(), 1005 INFO_VERSION_DESC_SNMP4J_AGENT_VERSION.get(), 1006 snmp4jAgentVersion); 1007 } 1008 1009 if (snmp4jAgentXVersion != null) 1010 { 1011 addMonitorAttribute(attrs, 1012 ATTR_SNMP4J_AGENTX_VERSION, 1013 INFO_VERSION_DISPNAME_SNMP4J_AGENTX_VERSION.get(), 1014 INFO_VERSION_DESC_SNMP4J_AGENTX_VERSION.get(), 1015 snmp4jAgentXVersion); 1016 } 1017 1018 return Collections.unmodifiableMap(attrs); 1019 } 1020}