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.io.Serializable;
026 import java.util.Collections;
027 import java.util.Map;
028 import java.util.TreeMap;
029
030 import com.unboundid.ldap.sdk.Attribute;
031 import com.unboundid.ldap.sdk.Entry;
032 import com.unboundid.ldap.sdk.OperationType;
033 import com.unboundid.util.Debug;
034 import com.unboundid.util.NotMutable;
035 import com.unboundid.util.StaticUtils;
036 import com.unboundid.util.ThreadSafety;
037 import com.unboundid.util.ThreadSafetyLevel;
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 provides a data structure that provides information about the
049 * result codes associated with various types of extended operations.
050 */
051 @NotMutable()
052 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
053 public final class ExtendedOperationResultCodeInfo
054 implements Serializable
055 {
056 /**
057 * The serial version UID for this serializable class.
058 */
059 private static final long serialVersionUID = 2412562905271298484L;
060
061
062
063 // The percentage of all extended operations that failed.
064 private final Double failedPercent;
065
066 // The total number of operations of the associated type that failed.
067 private final Long failedCount;
068
069 // The total number of operations of the associated type.
070 private final Long totalCount;
071
072 // The percentage of extended operations that failed, indexed by OID.
073 private final Map<String,Double> failedPercentsByOID;
074
075 // The number of extended operations that failed, indexed by OID.
076 private final Map<String,Long> failedCountsByOID;
077
078 // The number of extended operations processed, indexed by OID.
079 private final Map<String,Long> totalCountsByOID;
080
081 // Information about each result code returned for each type of extended
082 // operation, indexed first by extended request OID, then by the result code's
083 // integer value.
084 private final Map<String,Map<Integer,ResultCodeInfo>> resultCodeInfoMap;
085
086 // The names of the types of extended operations processed, indexed by OID.
087 private final Map<String,String> requestNamesByOID;
088
089
090
091 /**
092 * Creates a new extended operation result code information object from the
093 * provided information.
094 *
095 * @param entry The monitor entry to use to obtain the result code
096 * information.
097 */
098 ExtendedOperationResultCodeInfo(final MonitorEntry entry)
099 {
100 totalCount = entry.getLong("extended-op-total-count");
101 failedCount = entry.getLong("extended-op-failed-count");
102 failedPercent = entry.getDouble("extended-op-failed-percent");
103
104 final TreeMap<String,String> names = new TreeMap<String,String>();
105 final TreeMap<String,Long> totalCounts = new TreeMap<String,Long>();
106 final TreeMap<String,Long> failedCounts = new TreeMap<String,Long>();
107 final TreeMap<String,Double> failedPercents = new TreeMap<String,Double>();
108 final TreeMap<String,Map<Integer,ResultCodeInfo>> rcMaps =
109 new TreeMap<String,Map<Integer,ResultCodeInfo>>();
110 final Entry e = entry.getEntry();
111 for (final Attribute a : e.getAttributes())
112 {
113 try
114 {
115 final String lowerName = StaticUtils.toLowerCase(a.getName());
116 if (lowerName.startsWith("extended-op-") &&
117 lowerName.endsWith("-total-count"))
118 {
119 final String dashedOID =
120 lowerName.substring(12, (lowerName.length() - 12));
121 final String dottedOID = dashedOID.replace('-', '.');
122
123 final String name = entry.getString(
124 "extended-op-" + dashedOID + "-name");
125 final long total = a.getValueAsLong();
126 final long failed = entry.getLong(
127 "extended-op-" + dashedOID + "-failed-count");
128 final double failedPct = entry.getDouble(
129 "extended-op-" + dashedOID + "-failed-percent");
130
131 names.put(dottedOID, name);
132 totalCounts.put(dottedOID, total);
133 failedCounts.put(dottedOID, failed);
134 failedPercents.put(dottedOID, failedPct);
135 rcMaps.put(dottedOID,
136 getRCMap(e, "extended-op-" + dashedOID + "-result-"));
137 }
138 }
139 catch (final Exception ex)
140 {
141 Debug.debugException(ex);
142 }
143 }
144
145 requestNamesByOID = Collections.unmodifiableMap(names);
146 totalCountsByOID = Collections.unmodifiableMap(totalCounts);
147 failedCountsByOID = Collections.unmodifiableMap(failedCounts);
148 failedPercentsByOID = Collections.unmodifiableMap(failedPercents);
149 resultCodeInfoMap = Collections.unmodifiableMap(rcMaps);
150 }
151
152
153
154 /**
155 * Retrieves a map with result code information for a particular type of
156 * extended operation.
157 *
158 * @param entry The entry to be examined.
159 * @param prefix The prefix that will be used for all attributes of
160 * interest.
161 *
162 * @return A map with result code information for a particular type of
163 * extended operation.
164 */
165 private static Map<Integer,ResultCodeInfo> getRCMap(final Entry entry,
166 final String prefix)
167 {
168 final TreeMap<Integer,ResultCodeInfo> m =
169 new TreeMap<Integer,ResultCodeInfo>();
170
171 for (final Attribute a : entry.getAttributes())
172 {
173 try
174 {
175 final String lowerName = StaticUtils.toLowerCase(a.getName());
176 if (lowerName.startsWith(prefix) && lowerName.endsWith("-name"))
177 {
178 final int intValue = Integer.parseInt(lowerName.substring(
179 prefix.length(), (lowerName.length() - 5)));
180 final String name = a.getValue();
181 final long count = entry.getAttributeValueAsLong(
182 prefix + intValue + "-count");
183 final double percent = Double.parseDouble(
184 entry.getAttributeValue(prefix + intValue + "-percent"));
185 final double totalResponseTimeMillis = Double.parseDouble(
186 entry.getAttributeValue(prefix + intValue +
187 "-total-response-time-millis"));
188 final double averageResponseTimeMillis = Double.parseDouble(
189 entry.getAttributeValue(prefix + intValue +
190 "-average-response-time-millis"));
191 m.put(intValue, new ResultCodeInfo(intValue, name,
192 OperationType.EXTENDED, count, percent, totalResponseTimeMillis,
193 averageResponseTimeMillis));
194 }
195 }
196 catch (final Exception ex)
197 {
198 Debug.debugException(ex);
199 }
200 }
201
202 return Collections.unmodifiableMap(m);
203 }
204
205
206
207 /**
208 * Retrieves the total number of extended operations of all types that have
209 * been processed, if available.
210 *
211 * @return The total number of extended operations of all types that have
212 * been processed, or {@code null} if this information was not in the
213 * monitor entry.
214 */
215 public Long getTotalCount()
216 {
217 return totalCount;
218 }
219
220
221
222 /**
223 * Retrieves the number of extended operations of each type that have been
224 * processed, indexed by extended request OID, if available.
225 *
226 * @return The number of extended operations of each type that have been
227 * processed, or an empty map if this information was not in the
228 * monitor entry.
229 */
230 public Map<String,Long> getTotalCountsByOID()
231 {
232 return totalCountsByOID;
233 }
234
235
236
237 /**
238 * Retrieves the number of extended operations of all types that resulted in
239 * failure, if available.
240 *
241 * @return The number of extended operations of all types that resulted in
242 * failure, or {@code null} if this information was not in the
243 * monitor entry.
244 */
245 public Long getFailedCount()
246 {
247 return failedCount;
248 }
249
250
251
252 /**
253 * Retrieves the number of extended operations of each type that resulted in
254 * failure, indexed by extended request OID, if available.
255 *
256 * @return The number of extended operations of each type that resulted in
257 * failure, or an empty map if this information was not in the
258 * monitor entry.
259 */
260 public Map<String,Long> getFailedCountsByOID()
261 {
262 return failedCountsByOID;
263 }
264
265
266
267 /**
268 * Retrieves the percent of extended operations of all types that resulted in
269 * failure, if available.
270 *
271 * @return The percent of extended operations of all types that resulted in
272 * failure, or {@code null} if this information was not in the
273 * monitor entry.
274 */
275 public Double getFailedPercent()
276 {
277 return failedPercent;
278 }
279
280
281
282 /**
283 * Retrieves the percent of extended operations of each type that resulted in
284 * failure, indexed by extended request OID, if available.
285 *
286 * @return The percent of extended operations of each type that resulted in
287 * failure, or an empty map if this information was not in the
288 * monitor entry.
289 */
290 public Map<String,Double> getFailedPercentsByOID()
291 {
292 return failedPercentsByOID;
293 }
294
295
296
297 /**
298 * Retrieves a map with information about the result codes that have been
299 * returned for extended operations of each type, indexed first by extended
300 * request OID, and then by the result code's integer value.
301 *
302 * @return A map with information about the result codes that have been
303 * returned for extended operations of each type, or an empty map if
304 * this information was not in the monitor entry.
305 */
306 public Map<String,Map<Integer,ResultCodeInfo>> getResultCodeInfoMap()
307 {
308 return resultCodeInfoMap;
309 }
310
311
312
313 /**
314 * Retrieves a map with the human-readable names for each type of extended
315 * request, indexed by request OID, if available.
316 *
317 * @return A map with the human-readable names for each type of extended
318 * request, or an empty map if this information was not in the
319 * monitor entry.
320 */
321 public Map<String,String> getExtendedRequestNamesByOID()
322 {
323 return requestNamesByOID;
324 }
325 }