001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2006-2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.monitors;
028
029
030
031 import java.util.LinkedHashSet;
032 import java.util.LinkedList;
033 import java.util.List;
034
035 import org.opends.server.admin.std.server.ConnectionHandlerCfg;
036 import org.opends.server.admin.std.server.MonitorProviderCfg;
037 import org.opends.server.api.ClientConnection;
038 import org.opends.server.api.ConnectionHandler;
039 import org.opends.server.api.MonitorProvider;
040 import org.opends.server.types.Attribute;
041 import org.opends.server.types.AttributeType;
042 import org.opends.server.types.AttributeValue;
043 import org.opends.server.types.ByteStringFactory;
044 import org.opends.server.types.DirectoryConfig;
045 import org.opends.server.types.HostPort;
046 import org.opends.server.types.ObjectClass;
047
048 import static org.opends.server.util.ServerConstants.*;
049
050
051
052 /**
053 * This class implements a monitor provider that will report generic information
054 * for an enabled Directory Server connection handler, including its protocol,
055 * listeners, and established connections.
056 */
057 public class ConnectionHandlerMonitor
058 extends MonitorProvider<MonitorProviderCfg>
059 {
060 // The attribute type that will be used to report the established connections.
061 private AttributeType connectionsType;
062
063 // The attribute type that will be used to report the listeners.
064 private AttributeType listenerType;
065
066 // The attribute type that will be used to report the number of established
067 // client connections.
068 private AttributeType numConnectionsType;
069
070 // The attribute type that will be used to report the protocol.
071 private AttributeType protocolType;
072
073 // The connection handler with which this monitor is associated.
074 private ConnectionHandler<?> connectionHandler;
075
076 // The name for this monitor.
077 private String monitorName;
078
079
080
081 /**
082 * Creates a new instance of this connection handler monitor provider that
083 * will work with the provided connection handler. Most of the initialization
084 * should be handled in the {@code initializeMonitorProvider} method.
085 *
086 * @param connectionHandler The connection handler with which this monitor
087 * is associated.
088 */
089 public ConnectionHandlerMonitor(
090 ConnectionHandler<? extends ConnectionHandlerCfg> connectionHandler)
091 {
092 super(connectionHandler.getConnectionHandlerName());
093
094 this.connectionHandler = connectionHandler;
095 }
096
097
098
099 /**
100 * {@inheritDoc}
101 */
102 public void initializeMonitorProvider(MonitorProviderCfg configuration)
103 {
104 monitorName = connectionHandler.getConnectionHandlerName();
105
106 connectionsType =
107 DirectoryConfig.getAttributeType(ATTR_MONITOR_CONNHANDLER_CONNECTION,
108 true);
109
110 listenerType =
111 DirectoryConfig.getAttributeType(ATTR_MONITOR_CONNHANDLER_LISTENER,
112 true);
113
114 numConnectionsType =
115 DirectoryConfig.getAttributeType(
116 ATTR_MONITOR_CONNHANDLER_NUMCONNECTIONS, true);
117
118 protocolType =
119 DirectoryConfig.getAttributeType(ATTR_MONITOR_CONNHANDLER_PROTOCOL,
120 true);
121 }
122
123
124
125 /**
126 * {@inheritDoc}
127 */
128 public String getMonitorInstanceName()
129 {
130 return monitorName;
131 }
132
133
134
135 /**
136 * Retrieves the objectclass that should be included in the monitor entry
137 * created from this monitor provider.
138 *
139 * @return The objectclass that should be included in the monitor entry
140 * created from this monitor provider.
141 */
142 public ObjectClass getMonitorObjectClass()
143 {
144 return DirectoryConfig.getObjectClass(OC_MONITOR_CONNHANDLER, true);
145 }
146
147
148
149 /**
150 * {@inheritDoc}
151 */
152 public long getUpdateInterval()
153 {
154 // We don't need do anything on a periodic basis.
155 return 0;
156 }
157
158
159
160 /**
161 * {@inheritDoc}
162 */
163 public void updateMonitorData()
164 {
165 // No implementaiton is required.
166 }
167
168
169
170 /**
171 * {@inheritDoc}
172 */
173 public List<Attribute> getMonitorData()
174 {
175 LinkedList<Attribute> attrs = new LinkedList<Attribute>();
176
177 int numConnections = 0;
178 LinkedList<ClientConnection> conns =
179 new LinkedList<ClientConnection>(
180 connectionHandler.getClientConnections());
181 LinkedList<HostPort> listeners =
182 new LinkedList<HostPort>(connectionHandler.getListeners());
183
184 LinkedHashSet<AttributeValue> values = new LinkedHashSet<AttributeValue>();
185 values.add(new AttributeValue(protocolType,
186 ByteStringFactory.create(connectionHandler.getProtocol())));
187 attrs.add(new Attribute(protocolType, ATTR_MONITOR_CONNHANDLER_PROTOCOL,
188 values));
189
190
191 if (! listeners.isEmpty())
192 {
193 values = new LinkedHashSet<AttributeValue>();
194 for (HostPort hp : listeners)
195 {
196 values.add(new AttributeValue(listenerType,
197 ByteStringFactory.create(hp.toString())));
198 }
199 attrs.add(new Attribute(listenerType, ATTR_MONITOR_CONNHANDLER_LISTENER,
200 values));
201 }
202
203 if (! conns.isEmpty())
204 {
205 values = new LinkedHashSet<AttributeValue>();
206 for (ClientConnection c : conns)
207 {
208 numConnections++;
209 values.add(new AttributeValue(connectionsType,
210 ByteStringFactory.create(c.getMonitorSummary())));
211 }
212 attrs.add(new Attribute(connectionsType,
213 ATTR_MONITOR_CONNHANDLER_CONNECTION, values));
214 }
215
216 values = new LinkedHashSet<AttributeValue>();
217 values.add(new AttributeValue(numConnectionsType,
218 ByteStringFactory.create(String.valueOf(numConnections))));
219 attrs.add(new Attribute(numConnectionsType,
220 ATTR_MONITOR_CONNHANDLER_NUMCONNECTIONS, values));
221
222 return attrs;
223 }
224 }
225