KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > resource > monitor > ConnectorPoolMonitoringLevelListener


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */
23 package com.sun.enterprise.resource.monitor;
24
25 import java.security.AccessController JavaDoc;
26 import java.security.PrivilegedAction JavaDoc;
27 import java.util.ArrayList JavaDoc;
28 import java.util.HashMap JavaDoc;
29 import java.util.Hashtable JavaDoc;
30 import java.util.Iterator JavaDoc;
31 import java.util.List JavaDoc;
32 import java.util.Map JavaDoc;
33 import java.util.concurrent.ConcurrentHashMap JavaDoc;
34 import java.util.logging.Level JavaDoc;
35 import java.util.logging.Logger JavaDoc;
36
37 import javax.management.j2ee.statistics.Stats JavaDoc;
38
39 import com.sun.enterprise.PoolManager;
40 import com.sun.enterprise.Switch;
41 import com.sun.enterprise.admin.monitor.registry.MonitoredObjectType;
42 import com.sun.enterprise.admin.monitor.registry.MonitoringLevel;
43 import com.sun.enterprise.admin.monitor.registry.MonitoringLevelListener;
44 import com.sun.enterprise.admin.monitor.registry.MonitoringRegistry;
45 import com.sun.enterprise.admin.monitor.stats.ConnectionFactoryStats;
46 import com.sun.enterprise.config.serverbeans.ConnectorConnectionPool;
47 import com.sun.enterprise.connectors.ConnectorConstants;
48 import com.sun.enterprise.connectors.ConnectorRegistry;
49 import com.sun.enterprise.resource.MonitorableResourcePool;
50 import com.sun.enterprise.server.ApplicationServer;
51 import com.sun.enterprise.server.ResourcesUtil;
52 import com.sun.enterprise.server.ServerContext;
53 import com.sun.logging.LogDomains;
54
55 import com.sun.enterprise.resource.MonitorableResourcePool;
56 import com.sun.enterprise.resource.ResourcePool;
57
58 /**
59  * Provides an implementation of the MonitoringLevelListener interface to
60  * receive callbacks from admin regarding change in the monitoring level.
61  * Though there are 3 monitoring levels defined by JSR77, we support
62  * only 2 levels - OFF and ON (HIGH/LOW). So essentially, HIGH and LOW
63  * for us is only ON
64  *
65  * @author Aditya Gore
66  * @since s1aspe 8.0
67  */
68 //cleaned up - removed unnecessary/commented code.
69 public class ConnectorPoolMonitoringLevelListener implements MonitoringLevelListener {
70     private ResourcesUtil resUtil_;
71     private PoolManager poolManager_;
72     
73     private MonitoringRegistry registry_;
74
75     private static final MonitoringLevel OFF = MonitoringLevel.OFF;
76     private static final MonitoringLevel HIGH = MonitoringLevel.HIGH;
77     private static final MonitoringLevel LOW = MonitoringLevel.LOW;
78
79     private static Logger JavaDoc _logger = LogDomains.getLogger(
80         LogDomains.RSR_LOGGER );
81
82     public ConnectorPoolMonitoringLevelListener() {
83     }
84
85     /**
86      * @see com.sun.enterprise.admin.monitor.registry.MonitoringLevelListener#setLevel(com.sun.enterprise.admin.monitor.registry.MonitoringLevel)
87      * @deprecated
88      */
89     //remove after admin removes it
90 public void setLevel( MonitoringLevel level ) {}
91     
92     /**
93      * This is the callback invoked by the MonitoringRegistry
94      * on change in monitoring level
95      *
96      * @param from - the past level
97      * @param to - the new level
98      * @param handback - the Stats object this listener was registered for
99      * @deprecated
100      */
101     public void changeLevel( MonitoringLevel from, MonitoringLevel to,
102         Stats JavaDoc handback ) {}
103
104     public void changeLevel(MonitoringLevel from, MonitoringLevel to,
105             MonitoredObjectType type) {
106         
107         //If we were called, the MonitoredObjectType is definitely
108 //CONNECTOR_CONNECTION_POOL, so we can safely ignore it
109
110         if ( from == to ) {
111             //Its a no-op, so return
112 return;
113         }
114
115         AccessController.doPrivileged(new PrivilegedAction JavaDoc() {
116             public Object JavaDoc run() {
117                 ServerContext ctxt = ApplicationServer.getServerContext();
118                 if (ctxt != null ) {
119                     registry_ = ctxt.getMonitoringRegistry();
120                 }
121                 return null;
122             }
123         });
124
125         if (from == OFF || from == LOW ) {
126             if ( to == HIGH ) {
127                 logFine("Changing level from " + from +" to HIGH");
128                 transitionToHigh();
129             }
130         }
131     
132         if (from == HIGH || from == LOW ) {
133             if ( to == OFF ) {
134                 logFine("Switching level from " + from + " to OFF");
135                 switchOffMonitoring();
136             }
137         }
138
139         if (from == OFF || from == HIGH ) {
140         if ( to == LOW ) {
141         logFine("Changing level from " + from + " to LOW");
142                 transitionToLow();
143         }
144     }
145
146     }
147
148     /**
149      * @param resourceAdapterName
150      * @return
151      */
152     protected String JavaDoc getRAName(String JavaDoc resourceAdapterName) {
153         int delimIdx = resourceAdapterName.indexOf(ConnectorConstants.
154                         EMBEDDEDRAR_NAME_DELIMITER);
155         if (delimIdx == -1) {
156             return resourceAdapterName;
157         } else {
158             return resourceAdapterName.substring(delimIdx + 1);
159         }
160     }
161
162     /**
163      * @param resourceAdapterName
164      * @return
165      */
166     protected String JavaDoc getAppName(String JavaDoc resourceAdapterName) {
167         int delimIdx = resourceAdapterName.indexOf(ConnectorConstants.
168                         EMBEDDEDRAR_NAME_DELIMITER);
169         if (delimIdx == -1) {
170             return null;
171         } else {
172             return resourceAdapterName.substring(0, delimIdx);
173         }
174     }
175     
176
177     /*
178      * Query the resources util and get a list of connector
179      * conncetion pools excluding JMS CFs
180      */
181     private Map JavaDoc<ConnectorConnectionPool, MonitorableResourcePool> getPoolMap() {
182         ResourcesUtil resUtil = ResourcesUtil.getInstance();
183
184         ConnectorConnectionPool[] cp = resUtil.getConnectorConnectionPools();
185         if (cp == null) {
186             return null;
187         }
188         
189         Map JavaDoc<ConnectorConnectionPool, MonitorableResourcePool> poolMap =
190             new HashMap JavaDoc<ConnectorConnectionPool, MonitorableResourcePool>();
191         ConcurrentHashMap JavaDoc allPools = getPoolManager().getPoolTable();
192
193         for( int i = 0 ; i < cp.length; i++ ) {
194             if (!(cp[i].getName().equalsIgnoreCase(
195                             ConnectorConstants.DEFAULT_JMS_ADAPTER))) {
196                 ResourcePool p = (ResourcePool) allPools.get( cp[i].getName() );
197
198                 if (p != null && (p instanceof MonitorableResourcePool )) {
199                     poolMap.put(cp[i], (MonitorableResourcePool)p);
200                 }
201             }
202         }
203         
204         return poolMap;
205     }
206     
207     /*
208     private MonitorableResourcePool[] getConnectionFactories(){
209         ResourcesUtil resUtil = ResourcesUtil.getInstance();
210
211         ConnectorConnectionPool[] cp = resUtil.getConnectorConnectionPools();
212         if (cp == null) {
213             return null;
214         }
215         
216         //ArrayList al = new ArrayList();
217         ArrayList<MonitorableResourcePool> al = new ArrayList();
218         HashMap allPools = getPoolManager().getPoolTable();
219         for( int i = 0 ; i < cp.length; i++ ) {
220             if (cp[i].getName().equalsIgnoreCase(
221                             ConnectorConstants.DEFAULT_JMS_ADAPTER)) {
222                 MonitorableResourcePool p = (MonitorableResourcePool)
223                     allPools.get(cp[i].getName());
224                 al.add(p);
225             }
226         }
227         return (MonitorableResourcePool[])al.toArray(
228             new MonitorableResourcePool[]{});
229     }
230     */
231
232     private PoolManager getPoolManager() {
233         return Switch.getSwitch().getPoolManager();
234     }
235
236     private void transitionToHigh() {
237         AccessController.doPrivileged( new PrivilegedAction JavaDoc() {
238             public Object JavaDoc run() {
239                 //we should create a new pool object everytime since
240 //the stats have to be collected afresh
241 Map JavaDoc<ConnectorConnectionPool, MonitorableResourcePool> poolMap
242                     = getPoolMap();
243                 if (poolMap == null) {
244                     return null;
245                 }
246         
247                 for (ConnectorConnectionPool ccp : poolMap.keySet() ) {
248                     MonitorableResourcePool pool = poolMap.get(ccp);
249                     if ( pool != null ) {
250                         try {
251                             ConnectorConnectionPoolStatsImpl stats = new
252                                 ConnectorConnectionPoolStatsImpl(pool);
253                             getPoolManager().setMonitoringEnabledHigh(
254                                 pool.getPoolName());
255                             registry_.registerConnectorConnectionPoolStats(
256                                 stats, pool.getPoolName(),
257                                 getAppName(ccp.getResourceAdapterName()),
258                                 getRAName(ccp.getResourceAdapterName()),
259                                 null);
260                         } catch (Exception JavaDoc mre) {
261                             try {
262                                 _logger.log( Level.WARNING, "poolmon.cannot_reg",
263                                     mre.getMessage() );
264                                 getPoolManager().disableMonitoring(
265                                     pool.getPoolName());
266                             } catch (Exception JavaDoc ex) {
267                                 //FIXME: ignore?
268 }
269                         }
270                     }
271                 }
272                 return null;
273             }
274         });
275     }
276
277     private void switchOffMonitoring() {
278         //deregister stats
279 AccessController.doPrivileged( new PrivilegedAction JavaDoc() {
280             public Object JavaDoc run() {
281                 //Unregister all connector connection pools
282 Map JavaDoc<ConnectorConnectionPool, MonitorableResourcePool>
283                     pools = getPoolMap();
284                 if (pools == null) {
285                     return null;
286                 }
287                         
288                 for (ConnectorConnectionPool ccp : pools.keySet() ) {
289                     MonitorableResourcePool pool = pools.get(ccp);
290                     if (pool != null) {
291                         try {
292                             registry_.unregisterConnectorConnectionPoolStats(
293                                 pool.getPoolName(),
294                                 getAppName(ccp.getResourceAdapterName()),
295                                 getRAName(ccp.getResourceAdapterName()) );
296                             getPoolManager().disableMonitoring(
297                                 pool.getPoolName());
298                         } catch( Exception JavaDoc mre ) {
299                             _logger.log( Level.INFO, "poolmon.cannot_unreg");
300                         }
301                     }
302                 }
303                        
304                 return null;
305             }
306         });
307     }
308
309     private void transitionToLow() {
310         AccessController.doPrivileged( new PrivilegedAction JavaDoc() {
311             public Object JavaDoc run() {
312                 //we should create a new pool object everytime since
313 //the stats have to be collected afresh
314 Map JavaDoc<ConnectorConnectionPool, MonitorableResourcePool> poolMap
315                     = getPoolMap();
316                 if (poolMap == null) {
317                     return null;
318                 }
319         
320                 for (ConnectorConnectionPool ccp : poolMap.keySet() ) {
321                     MonitorableResourcePool pool = poolMap.get(ccp);
322                     if ( pool != null ) {
323                         try {
324                             ConnectorConnectionPoolStatsImpl stats = new
325                                 ConnectorConnectionPoolStatsImpl(pool);
326                             getPoolManager().setMonitoringEnabledLow(
327                                 pool.getPoolName());
328                             registry_.registerConnectorConnectionPoolStats(
329                                 stats, pool.getPoolName(),
330                                 getAppName(ccp.getResourceAdapterName()),
331                                 getRAName(ccp.getResourceAdapterName()), null);
332                         } catch (Exception JavaDoc mre) {
333                             try {
334                                 _logger.log( Level.WARNING, "poolmon.cannot_reg",
335                                     mre.getMessage() );
336                                 getPoolManager().disableMonitoring(
337                                     pool.getPoolName());
338                             } catch (Exception JavaDoc ex) {
339                                 //FIXME: ignore?
340 }
341                         }
342                     }
343                 }
344                 return null;
345             }
346         });
347     }
348
349     private void logFine( String JavaDoc msg ) {
350         if ( msg != null && _logger.isLoggable( Level.FINE ) ) {
351             _logger.fine( msg );
352         }
353     }
354 }
355
Popular Tags