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 a particular type of operation (or across all
050 * types of operations, if the associated operation type is {@code null}).
051 */
052 @NotMutable()
053 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
054 public final class OperationResultCodeInfo
055 implements Serializable
056 {
057 /**
058 * The serial version UID for this serializable class.
059 */
060 private static final long serialVersionUID = 4688688688915878084L;
061
062
063
064 // The percentage of operations of the associated type that failed.
065 private final Double failedPercent;
066
067 // The total number of operations of the associated type that failed.
068 private final Long failedCount;
069
070 // The total number of operations of the associated type.
071 private final Long totalCount;
072
073 // Information about each result code returned for the associated operation
074 // type, indexed by the result code's integer value.
075 private final Map<Integer,ResultCodeInfo> resultCodeInfoMap;
076
077 // The associated operation type. It may be null if this structure provides
078 // information about all operation types.
079 private final OperationType operationType;
080
081
082
083 /**
084 * Creates a new operation result code information object from the provided
085 * information.
086 *
087 * @param entry The monitor entry to use to obtain the result
088 * code information.
089 * @param operationType The operation type for this object. It may be
090 * {@code null} if the information applies to all
091 * types of operations.
092 * @param opTypeAttrPrefix The prefix that will be used for information
093 * about
094 */
095 OperationResultCodeInfo(final MonitorEntry entry,
096 final OperationType operationType,
097 final String opTypeAttrPrefix)
098 {
099 this.operationType = operationType;
100
101 totalCount = entry.getLong(opTypeAttrPrefix + "total-count");
102 failedCount = entry.getLong(opTypeAttrPrefix + "failed-count");
103 failedPercent = entry.getDouble(opTypeAttrPrefix + "failed-percent");
104
105 final String rcPrefix = opTypeAttrPrefix + "result-";
106 final TreeMap<Integer,ResultCodeInfo> rcMap =
107 new TreeMap<Integer,ResultCodeInfo>();
108 final Entry e = entry.getEntry();
109 for (final Attribute a : e.getAttributes())
110 {
111 try
112 {
113 final String lowerName = StaticUtils.toLowerCase(a.getName());
114 if (lowerName.startsWith(rcPrefix) && lowerName.endsWith("-name"))
115 {
116 final String name = a.getValue();
117 final int intValue = Integer.parseInt(lowerName.substring(
118 rcPrefix.length(), (lowerName.length() - 5)));
119 final long count = entry.getLong(rcPrefix + intValue + "-count");
120 final double percent = entry.getDouble(
121 rcPrefix + intValue + "-percent");
122 final double totalResponseTimeMillis = entry.getDouble(
123 rcPrefix + intValue + "-total-response-time-millis");
124 final double averageResponseTimeMillis = entry.getDouble(
125 rcPrefix + intValue + "-average-response-time-millis");
126 rcMap.put(intValue,
127 new ResultCodeInfo(intValue, name, operationType, count, percent,
128 totalResponseTimeMillis, averageResponseTimeMillis));
129 }
130 }
131 catch (final Exception ex)
132 {
133 Debug.debugException(ex);
134 }
135 }
136
137 resultCodeInfoMap = Collections.unmodifiableMap(rcMap);
138 }
139
140
141
142 /**
143 * Retrieves the type of operation with which this result code information is
144 * associated, if appropriate.
145 *
146 * @return The type of operation with which this result code information is
147 * associated, or {@code null} if this information applies to all
148 * types of operations.
149 */
150 public OperationType getOperationType()
151 {
152 return operationType;
153 }
154
155
156
157 /**
158 * Retrieves the total number of operations of the associated type that have
159 * been processed, if available.
160 *
161 * @return The total number of operations of the associated type that have
162 * been processed, or {@code null} if this information was not in the
163 * monitor entry.
164 */
165 public Long getTotalCount()
166 {
167 return totalCount;
168 }
169
170
171
172 /**
173 * Retrieves the number of operations of the associated type that resulted in
174 * failure, if available.
175 *
176 * @return The number of operations of the associated type that resulted
177 * in failure, or {@code null} if this information was not in the
178 * monitor entry.
179 */
180 public Long getFailedCount()
181 {
182 return failedCount;
183 }
184
185
186
187 /**
188 * Retrieves the percent of operations of the associated type that resulted in
189 * failure, if available.
190 *
191 * @return The percent of operations of the associated type that resulted
192 * in failure, or {@code null} if this information was not in the
193 * monitor entry.
194 */
195 public Double getFailedPercent()
196 {
197 return failedPercent;
198 }
199
200
201
202 /**
203 * Retrieves a map with information about the result codes that have been
204 * returned for operations of the associated type, indexed by the result
205 * code's integer value.
206 *
207 * @return A map with information about the result codes that have been
208 * returned for operations of the associated type.
209 */
210 public Map<Integer,ResultCodeInfo> getResultCodeInfoMap()
211 {
212 return resultCodeInfoMap;
213 }
214 }