001 /* 002 * Copyright 2009-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.LinkedHashMap; 028 import java.util.List; 029 import java.util.Map; 030 031 import com.unboundid.ldap.sdk.Entry; 032 import com.unboundid.util.Debug; 033 import com.unboundid.util.NotMutable; 034 import com.unboundid.util.ThreadSafety; 035 import com.unboundid.util.ThreadSafetyLevel; 036 037 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 038 039 040 041 /** 042 * <BLOCKQUOTE> 043 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 044 * LDAP SDK for Java. It is not available for use in applications that 045 * include only the Standard Edition of the LDAP SDK, and is not supported for 046 * use in conjunction with non-UnboundID products. 047 * </BLOCKQUOTE> 048 * This class defines a monitor entry that provides information about a 049 * load-balancing algorithm used by the UnboundID Directory Proxy Server. 050 * Information that it may make available includes: 051 * <UL> 052 * <LI>The aggregate health check state for servers associated with the 053 * load-balancing algorithm.</LI> 054 * <LI>Information about each server associated with the load-balancing 055 * algorithm, including the address, port, and health check state for the 056 * server.</LI> 057 * <LI>The number of available, degraded, and unavailable servers associated 058 * with the load-balancing algorithm.</LI> 059 * </UL> 060 * The server should present a load-balancing algorithm monitor entry for each 061 * load-balancing algorithm used by a proxying request processor. These entries 062 * can be retrieved using the 063 * {@link MonitorManager#getLoadBalancingAlgorithmMonitorEntries} method. These 064 * entries provide specific methods for accessing this information. 065 * Alternately, the information may be accessed using the generic API. See the 066 * {@link MonitorManager} class documentation for an example that demonstrates 067 * the use of the generic API for accessing monitor data. 068 */ 069 @NotMutable() 070 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 071 public final class LoadBalancingAlgorithmMonitorEntry 072 extends MonitorEntry 073 { 074 /** 075 * The structural object class used in LDAP external server monitor entries. 076 */ 077 protected static final String LOAD_BALANCING_ALGORITHM_MONITOR_OC = 078 "ds-load-balancing-algorithm-monitor-entry"; 079 080 081 082 /** 083 * The name of the attribute used to provide the name of the load-balancing 084 * algorithm. 085 */ 086 private static final String ATTR_ALGORITHM_NAME = "algorithm-name"; 087 088 089 090 /** 091 * The name of the attribute used to provide the DN of the configuration entry 092 * for the load-balancing algorithm. 093 */ 094 private static final String ATTR_CONFIG_ENTRY_DN = "config-entry-dn"; 095 096 097 098 /** 099 * The name of the attribute used to provide the aggregate health check state 100 * for the load-balancing algorithm. 101 */ 102 private static final String ATTR_HEALTH_CHECK_STATE = "health-check-state"; 103 104 105 106 /** 107 * The name of the attribute used to provide information about the health 108 * check states of each of the LDAP external servers associated with the 109 * load-balancing algorithm. 110 */ 111 private static final String ATTR_LDAP_EXTERNAL_SERVER = 112 "ldap-external-server"; 113 114 115 116 /** 117 * The name of the attribute used to provide the aggregate health check state 118 * for local servers for the load-balancing algorithm. 119 */ 120 private static final String ATTR_LOCAL_SERVERS_HEALTH_CHECK_STATE = 121 "local-servers-health-check-state"; 122 123 124 125 /** 126 * The name of the attribute used to provide the aggregate health check state 127 * for non-local servers for the load-balancing algorithm. 128 */ 129 private static final String ATTR_NON_LOCAL_SERVERS_HEALTH_CHECK_STATE = 130 "non-local-servers-health-check-state"; 131 132 133 134 /** 135 * The name of the attribute used to provide the number of servers associated 136 * with the load-balancing algorithm with a health check state of AVAILABLE. 137 */ 138 private static final String ATTR_NUM_AVAILABLE = "num-available-servers"; 139 140 141 142 /** 143 * The name of the attribute used to provide the number of servers associated 144 * with the load-balancing algorithm with a health check state of DEGRADED. 145 */ 146 private static final String ATTR_NUM_DEGRADED = "num-degraded-servers"; 147 148 149 150 /** 151 * The name of the attribute used to provide the number of servers associated 152 * with the load-balancing algorithm with a health check state of UNAVAILABLE. 153 */ 154 private static final String ATTR_NUM_UNAVAILABLE = "num-unavailable-servers"; 155 156 157 158 /** 159 * The serial version UID for this serializable class. 160 */ 161 private static final long serialVersionUID = -5251924301718025205L; 162 163 164 165 // The aggregate health check state for the load-balancing algorithm. 166 private final HealthCheckState healthCheckState; 167 168 // The aggregate health check state for local servers for the load-balancing 169 // algorithm. 170 private final HealthCheckState localServersHealthCheckState; 171 172 // The aggregate health check state for non-local servers for the 173 // load-balancing algorithm. 174 private final HealthCheckState nonLocalServersHealthCheckState; 175 176 // The list of server availability objects. 177 private final List<LoadBalancingAlgorithmServerAvailabilityData> 178 serverAvailabilityData; 179 180 // The number of servers with a health check state of AVAILABLE. 181 private final Long numAvailableServers; 182 183 // The number of servers with a health check state of DEGRADED. 184 private final Long numDegradedServers; 185 186 // The number of servers with a health check state of UNAVAILABLE. 187 private final Long numUnavailableServers; 188 189 // The name of the load-balancing algorithm. 190 private final String algorithmName; 191 192 // The DN of the configuration entry for the load-balancing algorithm. 193 private final String configEntryDN; 194 195 196 197 /** 198 * Creates a new load-balancing algorithm monitor entry from the provided 199 * entry. 200 * 201 * @param entry The entry to be parsed as a load-balancing algorithm monitor 202 * entry. It must not be {@code null}. 203 */ 204 public LoadBalancingAlgorithmMonitorEntry(final Entry entry) 205 { 206 super(entry); 207 208 algorithmName = getString(ATTR_ALGORITHM_NAME); 209 configEntryDN = getString(ATTR_CONFIG_ENTRY_DN); 210 numAvailableServers = getLong(ATTR_NUM_AVAILABLE); 211 numDegradedServers = getLong(ATTR_NUM_DEGRADED); 212 numUnavailableServers = getLong(ATTR_NUM_UNAVAILABLE); 213 214 final String hcStateStr = getString(ATTR_HEALTH_CHECK_STATE); 215 if (hcStateStr == null) 216 { 217 healthCheckState = null; 218 } 219 else 220 { 221 healthCheckState = HealthCheckState.forName(hcStateStr); 222 } 223 224 final String localHCStateStr = 225 getString(ATTR_LOCAL_SERVERS_HEALTH_CHECK_STATE); 226 if (localHCStateStr == null) 227 { 228 localServersHealthCheckState = null; 229 } 230 else 231 { 232 localServersHealthCheckState = HealthCheckState.forName(localHCStateStr); 233 } 234 235 final String nonLocalHCStateStr = 236 getString(ATTR_NON_LOCAL_SERVERS_HEALTH_CHECK_STATE); 237 if (nonLocalHCStateStr == null) 238 { 239 nonLocalServersHealthCheckState = null; 240 } 241 else 242 { 243 nonLocalServersHealthCheckState = 244 HealthCheckState.forName(nonLocalHCStateStr); 245 } 246 247 final List<String> externalServerStrings = 248 getStrings(ATTR_LDAP_EXTERNAL_SERVER); 249 final ArrayList<LoadBalancingAlgorithmServerAvailabilityData> serverData = 250 new ArrayList<LoadBalancingAlgorithmServerAvailabilityData>( 251 externalServerStrings.size()); 252 for (final String s : externalServerStrings) 253 { 254 try 255 { 256 serverData.add(new LoadBalancingAlgorithmServerAvailabilityData(s)); 257 } 258 catch (final Exception e) 259 { 260 Debug.debugException(e); 261 } 262 } 263 serverAvailabilityData = Collections.unmodifiableList(serverData); 264 } 265 266 267 268 /** 269 * Retrieves the name of the load-balancing algorithm. 270 * 271 * @return The name of the load-balancing algorithm, or {@code null} if it 272 * was not included in the monitor entry. 273 */ 274 public String getAlgorithmName() 275 { 276 return algorithmName; 277 } 278 279 280 281 /** 282 * Retrieves the DN of the configuration entry for the load-balancing 283 * algorithm. 284 * 285 * @return The DN of the configuration entry for the load-balancing 286 * algorithm, or {@code null} if it was not included in the monitor 287 * entry. 288 */ 289 public String getConfigEntryDN() 290 { 291 return configEntryDN; 292 } 293 294 295 296 /** 297 * Retrieves the aggregate health check state for the load-balancing 298 * algorithm. 299 * 300 * @return The aggregate health check state for the load-balancing algorithm, 301 * or {@code null} if it was not included in the monitor 302 * entry. 303 */ 304 public HealthCheckState getHealthCheckState() 305 { 306 return healthCheckState; 307 } 308 309 310 311 /** 312 * Retrieves the aggregate health check state for local servers for the 313 * load-balancing algorithm. 314 * 315 * @return The aggregate health check state for local servers for the 316 * load-balancing algorithm, or {@code null} if it was not included 317 * in the monitor entry. 318 */ 319 public HealthCheckState getLocalServersHealthCheckState() 320 { 321 return localServersHealthCheckState; 322 } 323 324 325 326 /** 327 * Retrieves the aggregate health check state for non-local servers for the 328 * load-balancing algorithm. 329 * 330 * @return The aggregate health check state for non-local servers for the 331 * load-balancing algorithm, or {@code null} if it was not included 332 * in the monitor entry. 333 */ 334 public HealthCheckState getNonLocalServersHealthCheckState() 335 { 336 return nonLocalServersHealthCheckState; 337 } 338 339 340 341 /** 342 * Retrieves a list with information about the healths of the individual LDAP 343 * external servers associated with the load-balancing algorithm. 344 * 345 * @return A list with information about the healths of the individual LDAP 346 * external servers associated with the load-balancing algorithm, or 347 * an empty list if it was not included in the monitor entry. 348 */ 349 public List<LoadBalancingAlgorithmServerAvailabilityData> 350 getServerAvailabilityData() 351 { 352 return serverAvailabilityData; 353 } 354 355 356 357 /** 358 * Retrieves the number of servers associated with the load-balancing 359 * algorithm that have a health check state of AVAILABLE. 360 * 361 * @return The number of servers associated with the load-balancing algorithm 362 * that have a health check state of AVAILABLE, or {@code null} if it 363 * was not included in the monitor entry. 364 */ 365 public Long getNumAvailableServers() 366 { 367 return numAvailableServers; 368 } 369 370 371 372 /** 373 * Retrieves the number of servers associated with the load-balancing 374 * algorithm that have a health check state of DEGRADED. 375 * 376 * @return The number of servers associated with the load-balancing algorithm 377 * that have a health check state of DEGRADED, or {@code null} if it 378 * was not included in the monitor entry. 379 */ 380 public Long getNumDegradedServers() 381 { 382 return numDegradedServers; 383 } 384 385 386 387 /** 388 * Retrieves the number of servers associated with the load-balancing 389 * algorithm that have a health check state of UNAVAILABLE. 390 * 391 * @return The number of servers associated with the load-balancing algorithm 392 * that have a health check state of UNAVAILABLE, or {@code null} if 393 * it was not included in the monitor entry. 394 */ 395 public Long getNumUnavailableServers() 396 { 397 return numUnavailableServers; 398 } 399 400 401 402 /** 403 * {@inheritDoc} 404 */ 405 @Override() 406 public String getMonitorDisplayName() 407 { 408 return INFO_LOAD_BALANCING_ALGORITHM_MONITOR_DISPNAME.get(); 409 } 410 411 412 413 /** 414 * {@inheritDoc} 415 */ 416 @Override() 417 public String getMonitorDescription() 418 { 419 return INFO_LOAD_BALANCING_ALGORITHM_MONITOR_DESC.get(); 420 } 421 422 423 424 /** 425 * {@inheritDoc} 426 */ 427 @Override() 428 public Map<String,MonitorAttribute> getMonitorAttributes() 429 { 430 final LinkedHashMap<String,MonitorAttribute> attrs = 431 new LinkedHashMap<String,MonitorAttribute>(9); 432 433 if (algorithmName != null) 434 { 435 addMonitorAttribute(attrs, 436 ATTR_ALGORITHM_NAME, 437 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_ALGORITHM_NAME.get(), 438 INFO_LOAD_BALANCING_ALGORITHM_DESC_ALGORITHM_NAME.get(), 439 algorithmName); 440 } 441 442 if (configEntryDN != null) 443 { 444 addMonitorAttribute(attrs, 445 ATTR_CONFIG_ENTRY_DN, 446 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_CONFIG_ENTRY_DN.get(), 447 INFO_LOAD_BALANCING_ALGORITHM_DESC_CONFIG_ENTRY_DN.get(), 448 configEntryDN); 449 } 450 451 if (healthCheckState != null) 452 { 453 addMonitorAttribute(attrs, 454 ATTR_HEALTH_CHECK_STATE, 455 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_HEALTH_CHECK_STATE.get(), 456 INFO_LOAD_BALANCING_ALGORITHM_DESC_HEALTH_CHECK_STATE.get(), 457 healthCheckState.name()); 458 } 459 460 if (localServersHealthCheckState != null) 461 { 462 addMonitorAttribute(attrs, 463 ATTR_LOCAL_SERVERS_HEALTH_CHECK_STATE, 464 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_L_HEALTH_CHECK_STATE.get(), 465 INFO_LOAD_BALANCING_ALGORITHM_DESC_L_HEALTH_CHECK_STATE.get(), 466 localServersHealthCheckState.name()); 467 } 468 469 if (nonLocalServersHealthCheckState != null) 470 { 471 addMonitorAttribute(attrs, 472 ATTR_NON_LOCAL_SERVERS_HEALTH_CHECK_STATE, 473 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_NL_HEALTH_CHECK_STATE.get(), 474 INFO_LOAD_BALANCING_ALGORITHM_DESC_NL_HEALTH_CHECK_STATE.get(), 475 nonLocalServersHealthCheckState.name()); 476 } 477 478 if ((serverAvailabilityData != null) && 479 (! serverAvailabilityData.isEmpty())) 480 { 481 final ArrayList<String> availabilityStrings = 482 new ArrayList<String>(serverAvailabilityData.size()); 483 for (final LoadBalancingAlgorithmServerAvailabilityData d : 484 serverAvailabilityData) 485 { 486 availabilityStrings.add(d.toCompactString()); 487 } 488 addMonitorAttribute(attrs, 489 ATTR_LDAP_EXTERNAL_SERVER, 490 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_SERVER_DATA.get(), 491 INFO_LOAD_BALANCING_ALGORITHM_DESC_SERVER_DATA.get(), 492 availabilityStrings); 493 } 494 495 if (numAvailableServers != null) 496 { 497 addMonitorAttribute(attrs, 498 ATTR_NUM_AVAILABLE, 499 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_NUM_AVAILABLE.get(), 500 INFO_LOAD_BALANCING_ALGORITHM_DESC_NUM_AVAILABLE.get(), 501 numAvailableServers); 502 } 503 504 if (numDegradedServers != null) 505 { 506 addMonitorAttribute(attrs, 507 ATTR_NUM_DEGRADED, 508 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_NUM_DEGRADED.get(), 509 INFO_LOAD_BALANCING_ALGORITHM_DESC_NUM_DEGRADED.get(), 510 numDegradedServers); 511 } 512 513 if (numUnavailableServers != null) 514 { 515 addMonitorAttribute(attrs, 516 ATTR_NUM_UNAVAILABLE, 517 INFO_LOAD_BALANCING_ALGORITHM_DISPNAME_NUM_UNAVAILABLE.get(), 518 INFO_LOAD_BALANCING_ALGORITHM_DESC_NUM_UNAVAILABLE.get(), 519 numUnavailableServers); 520 } 521 522 return Collections.unmodifiableMap(attrs); 523 } 524 }