001 /* 002 * Copyright 2014-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.Collections; 026 import java.util.LinkedHashMap; 027 import java.util.Map; 028 029 import com.unboundid.ldap.sdk.Entry; 030 import com.unboundid.util.NotMutable; 031 import com.unboundid.util.ThreadSafety; 032 import com.unboundid.util.ThreadSafetyLevel; 033 034 import static com.unboundid.ldap.sdk.unboundidds.monitors.MonitorMessages.*; 035 036 037 038 /** 039 * <BLOCKQUOTE> 040 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 041 * LDAP SDK for Java. It is not available for use in applications that 042 * include only the Standard Edition of the LDAP SDK, and is not supported for 043 * use in conjunction with non-UnboundID products. 044 * </BLOCKQUOTE> 045 * This class defines a monitor entry that provides information about the group 046 * cache and the number and types of groups available in the server. 047 */ 048 @NotMutable() 049 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 050 public final class GroupCacheMonitorEntry 051 extends MonitorEntry 052 { 053 /** 054 * The structural object class used in group cache monitor entries. 055 */ 056 static final String GROUP_CACHE_MONITOR_OC = 057 "ds-group-cache-monitor-entry"; 058 059 060 061 /** 062 * The name of the attribute that contains information about the amount of 063 * memory required by the group cache, in bytes. 064 */ 065 private static final String ATTR_CURRENT_CACHE_USED_BYTES = 066 "current-cache-used-bytes"; 067 068 069 070 /** 071 * The name of the attribute that contains information about the amount of 072 * memory required by the group cache, as a percentage of the total JVM heap 073 * size. 074 */ 075 private static final String ATTR_CURRENT_CACHE_USED_PERCENT = 076 "current-cache-used-as-percentage-of-max-heap"; 077 078 079 080 /** 081 * The name of the attribute that contains information about the length of 082 * time required to determine group cache memory usage. 083 */ 084 private static final String ATTR_CURRENT_CACHE_USED_UPDATE_MILLIS = 085 "current-cache-used-update-ms"; 086 087 088 089 /** 090 * The name of the attribute that contains information about the number of 091 * dynamic group entries defined in the server. 092 */ 093 private static final String ATTR_DYNAMIC_GROUP_ENTRIES = 094 "dynamic-group-entries"; 095 096 097 098 /** 099 * The name of the attribute that contains information about the number of 100 * static group entries defined in the server. 101 */ 102 private static final String ATTR_STATIC_GROUP_ENTRIES = 103 "static-group-entries"; 104 105 106 107 /** 108 * The name of the attribute that contains information about the total number 109 * of static group members defined in the server. 110 */ 111 private static final String ATTR_TOTAL_STATIC_GROUP_MEMBERS = 112 "static-group-members"; 113 114 115 116 /** 117 * The name of the attribute that contains information about the number of 118 * unique static group members defined in the server. 119 */ 120 private static final String ATTR_UNIQUE_STATIC_GROUP_MEMBERS = 121 "static-group-unique-members"; 122 123 124 125 /** 126 * The name of the attribute that contains information about the number of 127 * virtual static group entries defined in the server. 128 */ 129 private static final String ATTR_VIRTUAL_STATIC_GROUP_ENTRIES = 130 "virtual-static-group-entries"; 131 132 133 134 /** 135 * The serial version UID for this serializable class. 136 */ 137 private static final long serialVersionUID = -5665905374595185773L; 138 139 140 141 // The length of time in milliseconds required to determine the current cache 142 // usage. 143 private final Double currentCacheUsedUpdateMillis; 144 145 // The percentage of the JVM heap used by the group cache. 146 private final Integer currentCacheUsedPercent; 147 148 // The amount of memory (in bytes) currently in use by the group cache. 149 private final Long currentCacheUsedBytes; 150 151 // The number of dynamic group entries defined in the server. 152 private final Long dynamicGroupEntries; 153 154 // The number of static group entries defined in the server. 155 private final Long staticGroupEntries; 156 157 // The number of total static group members defined in the server. 158 private final Long staticGroupMembers; 159 160 // The number of unique static group members defined in the server. 161 private final Long staticGroupUniqueMembers; 162 163 // The number of virtual static group entries defined in the server. 164 private final Long virtualStaticGroupEntries; 165 166 167 168 /** 169 * Creates a new group cache monitor entry from the provided entry. 170 * 171 * @param entry The entry to be parsed as a group cache monitor entry. It 172 * must not be {@code null}. 173 */ 174 public GroupCacheMonitorEntry(final Entry entry) 175 { 176 super(entry); 177 178 staticGroupEntries = getLong(ATTR_STATIC_GROUP_ENTRIES); 179 staticGroupMembers = getLong(ATTR_TOTAL_STATIC_GROUP_MEMBERS); 180 staticGroupUniqueMembers = getLong(ATTR_UNIQUE_STATIC_GROUP_MEMBERS); 181 dynamicGroupEntries = getLong(ATTR_DYNAMIC_GROUP_ENTRIES); 182 virtualStaticGroupEntries = getLong(ATTR_VIRTUAL_STATIC_GROUP_ENTRIES); 183 currentCacheUsedBytes = getLong(ATTR_CURRENT_CACHE_USED_BYTES); 184 currentCacheUsedPercent = getInteger(ATTR_CURRENT_CACHE_USED_PERCENT); 185 currentCacheUsedUpdateMillis = 186 getDouble(ATTR_CURRENT_CACHE_USED_UPDATE_MILLIS); 187 } 188 189 190 191 /** 192 * Retrieves the number of static group entries defined in the server, if 193 * available. 194 * 195 * @return The number of static group entries defined in the server, or 196 * {@code null} if it was not included in the monitor entry. 197 */ 198 public Long getStaticGroupEntries() 199 { 200 return staticGroupEntries; 201 } 202 203 204 205 /** 206 * Retrieves the total number of static group members defined in the server, 207 * if available. Users that are members of multiple static groups will be 208 * counted multiple times. 209 * 210 * @return The total number of static group members defined in the server, or 211 * {@code null} if it was not included in the monitor entry. 212 */ 213 public Long getTotalStaticGroupMembers() 214 { 215 return staticGroupMembers; 216 } 217 218 219 220 /** 221 * Retrieves the number of unique static group members defined in the server, 222 * if available. Users that are members of multiple static groups will only 223 * be counted once. 224 * 225 * @return The number of unique static group members defined in the server, 226 * or {@code null} if it was not included in the monitor entry. 227 */ 228 public Long getUniqueStaticGroupMembers() 229 { 230 return staticGroupUniqueMembers; 231 } 232 233 234 235 /** 236 * Retrieves the number of dynamic group entries defined in the server, if 237 * available. 238 * 239 * @return The number of dynamic group entries defined in the server, or 240 * {@code null} if it was not included in the monitor entry. 241 */ 242 public Long getDynamicGroupEntries() 243 { 244 return dynamicGroupEntries; 245 } 246 247 248 249 /** 250 * Retrieves the number of virtual static group entries defined in the server, 251 * if available. 252 * 253 * @return The number of virtual static group entries defined in the server, 254 * or {@code null} if it was not included in the monitor entry. 255 */ 256 public Long getVirtualStaticGroupEntries() 257 { 258 return virtualStaticGroupEntries; 259 } 260 261 262 263 /** 264 * Retrieves the amount of memory in bytes used by the group cache, if 265 * available. 266 * 267 * @return The amount of memory in bytes used by the group cache, or 268 * {@code null} if it was not included in the monitor entry. 269 */ 270 public Long getCurrentCacheUsedBytes() 271 { 272 return currentCacheUsedBytes; 273 } 274 275 276 277 /** 278 * Retrieves the amount of memory used by the group cache as a percentage of 279 * the maximum heap size, if available. 280 * 281 * @return The amount of memory in bytes used by the group cache, or 282 * {@code null} if it was not included in the monitor entry. 283 */ 284 public Integer getCurrentCacheUsedAsPercentOfMaxHeap() 285 { 286 return currentCacheUsedPercent; 287 } 288 289 290 291 /** 292 * Retrieves the length of time in milliseconds required to compute the group 293 * cache size, if available. 294 * 295 * @return The length of time in milliseconds required to compute the group 296 * cache size, or {@code null} if it was not included in the monitor 297 * entry. 298 */ 299 public Double getCurrentCacheUsedUpdateDurationMillis() 300 { 301 return currentCacheUsedUpdateMillis; 302 } 303 304 305 306 /** 307 * {@inheritDoc} 308 */ 309 @Override() 310 public String getMonitorDisplayName() 311 { 312 return INFO_GROUP_CACHE_MONITOR_DISPNAME.get(); 313 } 314 315 316 317 /** 318 * {@inheritDoc} 319 */ 320 @Override() 321 public String getMonitorDescription() 322 { 323 return INFO_GROUP_CACHE_MONITOR_DESC.get(); 324 } 325 326 327 328 /** 329 * {@inheritDoc} 330 */ 331 @Override() 332 public Map<String,MonitorAttribute> getMonitorAttributes() 333 { 334 final LinkedHashMap<String,MonitorAttribute> attrs = 335 new LinkedHashMap<String,MonitorAttribute>(8); 336 337 if (staticGroupEntries != null) 338 { 339 addMonitorAttribute(attrs, 340 ATTR_STATIC_GROUP_ENTRIES, 341 INFO_GROUP_CACHE_DISPNAME_STATIC_GROUP_ENTRIES.get(), 342 INFO_GROUP_CACHE_DESC_STATIC_GROUP_ENTRIES.get(), 343 staticGroupEntries); 344 } 345 346 if (staticGroupMembers != null) 347 { 348 addMonitorAttribute(attrs, 349 ATTR_TOTAL_STATIC_GROUP_MEMBERS, 350 INFO_GROUP_CACHE_DISPNAME_STATIC_GROUP_MEMBERS.get(), 351 INFO_GROUP_CACHE_DESC_STATIC_GROUP_MEMBERS.get(), 352 staticGroupMembers); 353 } 354 355 if (staticGroupUniqueMembers != null) 356 { 357 addMonitorAttribute(attrs, 358 ATTR_UNIQUE_STATIC_GROUP_MEMBERS, 359 INFO_GROUP_CACHE_DISPNAME_STATIC_GROUP_UNIQUE_MEMBERS.get(), 360 INFO_GROUP_CACHE_DESC_STATIC_GROUP_UNIQUE_MEMBERS.get(), 361 staticGroupUniqueMembers); 362 } 363 364 if (dynamicGroupEntries != null) 365 { 366 addMonitorAttribute(attrs, 367 ATTR_DYNAMIC_GROUP_ENTRIES, 368 INFO_GROUP_CACHE_DISPNAME_DYNAMIC_GROUP_ENTRIES.get(), 369 INFO_GROUP_CACHE_DESC_DYNAMIC_GROUP_ENTRIES.get(), 370 dynamicGroupEntries); 371 } 372 373 if (virtualStaticGroupEntries != null) 374 { 375 addMonitorAttribute(attrs, 376 ATTR_VIRTUAL_STATIC_GROUP_ENTRIES, 377 INFO_GROUP_CACHE_DISPNAME_VIRTUAL_STATIC_GROUP_ENTRIES.get(), 378 INFO_GROUP_CACHE_DESC_VIRTUAL_STATIC_GROUP_ENTRIES.get(), 379 virtualStaticGroupEntries); 380 } 381 382 if (currentCacheUsedBytes != null) 383 { 384 addMonitorAttribute(attrs, 385 ATTR_CURRENT_CACHE_USED_BYTES, 386 INFO_GROUP_CACHE_DISPNAME_CACHE_SIZE_BYTES.get(), 387 INFO_GROUP_CACHE_DESC_CACHE_SIZE_BYTES.get(), 388 currentCacheUsedBytes); 389 } 390 391 if (currentCacheUsedPercent != null) 392 { 393 addMonitorAttribute(attrs, 394 ATTR_CURRENT_CACHE_USED_PERCENT, 395 INFO_GROUP_CACHE_DISPNAME_CACHE_SIZE_PERCENT.get(), 396 INFO_GROUP_CACHE_DESC_CACHE_SIZE_PERCENT.get(), 397 currentCacheUsedPercent); 398 } 399 400 if (currentCacheUsedUpdateMillis != null) 401 { 402 addMonitorAttribute(attrs, 403 ATTR_CURRENT_CACHE_USED_UPDATE_MILLIS, 404 INFO_GROUP_CACHE_DISPNAME_CACHE_SIZE_UPDATE_MILLIS.get(), 405 INFO_GROUP_CACHE_DESC_CACHE_SIZE_UPDATE_MILLIS.get(), 406 currentCacheUsedUpdateMillis); 407 } 408 409 return Collections.unmodifiableMap(attrs); 410 } 411 }