|
1
23
24 package org.continuent.sequoia.controller.monitoring.datacollector;
25
26 import java.util.ArrayList  ;
27
28 import javax.management.NotCompliantMBeanException ;
29 import javax.management.ObjectName ;
30
31 import org.continuent.sequoia.common.exceptions.DataCollectorException;
32 import org.continuent.sequoia.common.i18n.Translate;
33 import org.continuent.sequoia.common.jmx.JmxConstants;
34 import org.continuent.sequoia.common.jmx.JmxException;
35 import org.continuent.sequoia.common.jmx.mbeans.DataCollectorMBean;
36 import org.continuent.sequoia.common.jmx.monitoring.AbstractDataCollector;
37 import org.continuent.sequoia.common.jmx.monitoring.DataCollection;
38 import org.continuent.sequoia.common.jmx.monitoring.backend.ActiveConnectionsCollector;
39 import org.continuent.sequoia.common.jmx.monitoring.backend.ActiveTransactionCollector;
40 import org.continuent.sequoia.common.jmx.monitoring.backend.PendingRequestsCollector;
41 import org.continuent.sequoia.common.jmx.monitoring.backend.ReadRequestsCollector;
42 import org.continuent.sequoia.common.jmx.monitoring.backend.RequestsCollector;
43 import org.continuent.sequoia.common.jmx.monitoring.backend.TransactionsCollector;
44 import org.continuent.sequoia.common.jmx.monitoring.backend.WriteRequestsCollector;
45 import org.continuent.sequoia.common.jmx.monitoring.cache.CacheEntriesCollector;
46 import org.continuent.sequoia.common.jmx.monitoring.cache.CountHitsCollector;
47 import org.continuent.sequoia.common.jmx.monitoring.cache.CountInsertCollector;
48 import org.continuent.sequoia.common.jmx.monitoring.cache.CountSelectCollector;
49 import org.continuent.sequoia.common.jmx.monitoring.cache.HitsRatioCollector;
50 import org.continuent.sequoia.common.jmx.monitoring.client.ClientActiveTimeCollector;
51 import org.continuent.sequoia.common.jmx.monitoring.controller.ControllerIdleThreadsCollector;
52 import org.continuent.sequoia.common.jmx.monitoring.controller.ControllerWorkerPendingQueueCollector;
53 import org.continuent.sequoia.common.jmx.monitoring.controller.ThreadsCountCollector;
54 import org.continuent.sequoia.common.jmx.monitoring.controller.TotalMemoryCollector;
55 import org.continuent.sequoia.common.jmx.monitoring.controller.UsedMemoryCollector;
56 import org.continuent.sequoia.common.jmx.monitoring.scheduler.NumberReadCollector;
57 import org.continuent.sequoia.common.jmx.monitoring.scheduler.NumberRequestsCollector;
58 import org.continuent.sequoia.common.jmx.monitoring.scheduler.NumberWriteCollector;
59 import org.continuent.sequoia.common.jmx.monitoring.scheduler.PendingTransactionsCollector;
60 import org.continuent.sequoia.common.jmx.monitoring.scheduler.PendingWritesCollector;
61 import org.continuent.sequoia.common.jmx.monitoring.virtualdatabase.ActiveDatabaseThreadCollector;
62 import org.continuent.sequoia.common.jmx.monitoring.virtualdatabase.DatabaseThreadsCollector;
63 import org.continuent.sequoia.common.jmx.monitoring.virtualdatabase.PendingDatabaseConnectionCollector;
64 import org.continuent.sequoia.common.log.Trace;
65 import org.continuent.sequoia.controller.backend.DatabaseBackend;
66 import org.continuent.sequoia.controller.cache.result.AbstractResultCache;
67 import org.continuent.sequoia.controller.core.Controller;
68 import org.continuent.sequoia.controller.jmx.AbstractStandardMBean;
69 import org.continuent.sequoia.controller.jmx.MBeanServerManager;
70 import org.continuent.sequoia.controller.recoverylog.RecoveryLog;
71 import org.continuent.sequoia.controller.scheduler.AbstractScheduler;
72 import org.continuent.sequoia.controller.virtualdatabase.VirtualDatabase;
73 import org.continuent.sequoia.controller.virtualdatabase.VirtualDatabaseWorkerThread;
74
75
83 public class DataCollector extends AbstractStandardMBean
84 implements
85 DataCollectorMBean
86 {
87
88 static Trace logger = Trace
89 .getLogger("org.continuent.sequoia.controller.jmx");
90 Controller controller;
91
92
95 public static final String NO_CACHE_ENABLED = "No cache enabled";
96
99 public static final String NOT_IMPLEMENTED = "Not Implemented";
100
103 public static final String BACKEND_NOT_ACCESSIBLE = "Cannot reach backend";
104
105
108 public static final String BACKEND_CANNOT_BE_DISABLED = "Backend cannot be disabled";
109
110
113 public static final String CLIENT_NOT_FOUND = "Client not found";
114
117 public static final String INVALID_COLLECTOR_TYPE = "Invalid Collector Type";
118
121 public static final String AUTHENTICATION_FAILED = "Authentication failed";
122
125 public static final String DATABASE_NOT_FOUND = "Database does not exists";
126
127
136 public DataCollector(Controller controller)
137 throws NotCompliantMBeanException , JmxException
138 {
139 super(DataCollectorMBean.class);
140 this.controller = controller;
141 ObjectName objectName = JmxConstants.getDataCollectorObjectName();
142 MBeanServerManager.registerMBean(this, objectName);
143
144 }
145
146
149 public String getAssociatedString()
150 {
151 return "datacollector";
152 }
153
154
161 private VirtualDatabase getVirtualDatabase(String name)
162 throws DataCollectorException
163 {
164 VirtualDatabase vd = controller.getVirtualDatabase(name);
165 if (vd == null)
166 throw new DataCollectorException("Unknown Database");
167 return vd;
168 }
169
170
173 public String [][] retrieveBackendsData() throws DataCollectorException
174 {
175 throw new DataCollectorException("Not Implemented");
176 }
177
178
181 public String [][] retrieveBackendsData(String virtualDatabasename)
182 throws DataCollectorException
183 {
184 VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
185 try
186 {
187 vdb.acquireReadLockBackendLists();
188 }
189 catch (InterruptedException e)
190 {
191 String msg = Translate.get("virtualdatabase.fail.read.lock", e);
192 throw new DataCollectorException(msg);
193 }
194 ArrayList backends = vdb.getBackends();
195 int backendListSize = backends.size();
196 String [][] data = new String [backendListSize][];
197 for (int i = 0; i < backendListSize; i++)
198 {
199 data[i] = ((DatabaseBackend) backends.get(i)).getBackendData();
200 }
201 vdb.releaseReadLockBackendLists();
202 return data;
203 }
204
205
208 public String [][] retrieveCacheData() throws DataCollectorException
209 {
210 throw new DataCollectorException(NOT_IMPLEMENTED);
211 }
212
213
216 public String [][] retrieveRecoveryLogData(String databaseName)
217 throws DataCollectorException
218 {
219 VirtualDatabase vdb = getVirtualDatabase(databaseName);
220 RecoveryLog log = vdb.getRequestManager().getRecoveryLog();
221 if (log == null)
222 throw new DataCollectorException("Recovery log is not defined");
223 return log.getData();
224 }
225
226
229 public String [][] retrieveCacheData(String virtualDatabasename)
230 throws DataCollectorException
231 {
232 VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
233 AbstractResultCache cache = vdb.getRequestManager().getResultCache();
234 if (cache == null)
235 throw new DataCollectorException(NO_CACHE_ENABLED);
236 else
237 {
238 try
239 {
240 return cache.getCacheData();
241 }
242 catch (Exception e)
243 {
244 throw new DataCollectorException(e.getMessage());
245 }
246 }
247 }
248
249
252 public String [][] retrieveCacheStatsData() throws DataCollectorException
253 {
254 throw new DataCollectorException(NOT_IMPLEMENTED);
255 }
256
257
260 public String [][] retrieveCacheStatsData(String virtualDatabasename)
261 throws DataCollectorException
262 {
263 VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
264 AbstractResultCache cache = vdb.getRequestManager().getResultCache();
265 if (cache == null)
266 throw new DataCollectorException("No Cache enabled.");
267 else
268 {
269 try
270 {
271 return cache.getCacheStatsData();
272 }
273 catch (Exception e)
274 {
275 throw new DataCollectorException(e.getMessage());
276 }
277 }
278 }
279
280
283 public String [][] retrieveClientsData() throws DataCollectorException
284 {
285 throw new DataCollectorException("Not Implemented");
286 }
287
288
291 public String [][] retrieveClientsData(String virtualDatabasename)
292 throws DataCollectorException
293 {
294 VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
295 ArrayList activeThreads = vdb.getActiveThreads();
296 int size = activeThreads.size();
297 String [][] data = new String [size][];
298 for (int i = 0; i < size; i++)
299 {
300 data[i] = ((VirtualDatabaseWorkerThread) activeThreads.get(i))
301 .retrieveClientData();
302 }
303 return data;
304 }
305
306
309 public String [][] retrieveControllerLoadData()
310 {
311 long total = Runtime.getRuntime().totalMemory();
312 long free = Runtime.getRuntime().freeMemory();
313 String [][] data = new String [1][6];
314 data[0][0] = controller.getIPAddress();
315 data[0][1] = String.valueOf(total / 1024 / 1024);
316 data[0][2] = String.valueOf((total - free) / 1024 / 1024);
317 data[0][3] = String.valueOf(Thread.activeCount());
318 data[0][4] = String.valueOf(controller.getConnectionThread()
319 .getControllerServerThreadPendingQueueSize());
320 data[0][5] = String.valueOf(controller.getConnectionThread()
321 .getIdleWorkerThreads());
322 return data;
323 }
324
325
328 public String [][] retrieveSQLStats() throws DataCollectorException
329 {
330 throw new DataCollectorException("Not Implemented");
331 }
332
333
336 public String [][] retrieveSQLStats(String virtualDatabasename)
337 throws DataCollectorException
338 {
339 VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
340 if (vdb.getSQLMonitor() == null)
341 throw new DataCollectorException("No SQL monitoring enabled.");
342 else
343 return vdb.getSQLMonitor().getAllStatsInformation();
344 }
345
346
349 public String [][] retrieveVirtualDatabasesData()
350 {
351 ArrayList dbs = controller.getVirtualDatabases();
352 int size = dbs.size();
353 String [][] data = new String [size][4];
354 VirtualDatabase db;
355 for (int i = 0; i < size; i++)
356 {
357 db = (VirtualDatabase) dbs.get(i);
358 data[i][0] = db.getVirtualDatabaseName();
359 data[i][1] = String.valueOf(db.getActiveThreads().size());
360 data[i][2] = String.valueOf(db.getPendingConnections().size());
361 data[i][3] = String.valueOf(db.getCurrentNbOfThreads());
362 }
363 return data;
364 }
365
366
369 public Controller getController()
370 {
371 return controller;
372 }
373
374
377 public String [][] retrieveSchedulerData(String virtualDatabasename)
378 throws DataCollectorException
379 {
380 VirtualDatabase vdb = getVirtualDatabase(virtualDatabasename);
381 AbstractScheduler scheduler = vdb.getRequestManager().getScheduler();
382 String [][] data = new String [1][];
383 data[0] = scheduler.getSchedulerData();
384 return data;
385 }
386
387
390 public AbstractDataCollector retrieveDataCollectorInstance(int dataType,
391 String targetName, String virtualDbName) throws DataCollectorException
392 {
393 switch (dataType)
394 {
395
398 case DataCollection.CONTROLLER_TOTAL_MEMORY :
399 return new TotalMemoryCollector(controller);
400 case DataCollection.CONTROLLER_USED_MEMORY :
401 return new UsedMemoryCollector(controller);
402 case DataCollection.CONTROLLER_WORKER_PENDING_QUEUE :
403 return new ControllerWorkerPendingQueueCollector(controller);
404 case DataCollection.CONTROLLER_THREADS_NUMBER :
405 return new ThreadsCountCollector(controller);
406 case DataCollection.CONTROLLER_IDLE_WORKER_THREADS :
407 return new ControllerIdleThreadsCollector(controller);
408
411 case DataCollection.BACKEND_ACTIVE_TRANSACTION :
412 return new ActiveTransactionCollector(targetName, virtualDbName);
413 case DataCollection.BACKEND_PENDING_REQUESTS :
414 return new PendingRequestsCollector(targetName, virtualDbName);
415 case DataCollection.BACKEND_TOTAL_ACTIVE_CONNECTIONS :
416 return new ActiveConnectionsCollector(targetName, virtualDbName);
417 case DataCollection.BACKEND_TOTAL_REQUEST :
418 return new RequestsCollector(targetName, virtualDbName);
419 case DataCollection.BACKEND_TOTAL_READ_REQUEST :
420 return new ReadRequestsCollector(targetName, virtualDbName);
421 case DataCollection.BACKEND_TOTAL_WRITE_REQUEST :
422 return new WriteRequestsCollector(targetName, virtualDbName);
423 case DataCollection.BACKEND_TOTAL_TRANSACTIONS :
424 return new TransactionsCollector(targetName, virtualDbName);
425
428 case DataCollection.DATABASES_ACTIVE_THREADS :
429 return new ActiveDatabaseThreadCollector(virtualDbName);
430 case DataCollection.DATABASES_PENDING_CONNECTIONS :
431 return new PendingDatabaseConnectionCollector(virtualDbName);
432 case DataCollection.DATABASES_NUMBER_OF_THREADS :
433 return new DatabaseThreadsCollector(virtualDbName);
434
437 case DataCollection.CACHE_STATS_COUNT_HITS :
438 return new CountHitsCollector(virtualDbName);
439 case DataCollection.CACHE_STATS_COUNT_INSERT :
440 return new CountInsertCollector(virtualDbName);
441 case DataCollection.CACHE_STATS_COUNT_SELECT :
442 return new CountSelectCollector(virtualDbName);
443 case DataCollection.CACHE_STATS_HITS_PERCENTAGE :
444 return new HitsRatioCollector(virtualDbName);
445 case DataCollection.CACHE_STATS_NUMBER_ENTRIES :
446 return new CacheEntriesCollector(virtualDbName);
447
450 case DataCollection.SCHEDULER_NUMBER_READ :
451 return new NumberReadCollector(virtualDbName);
452 case DataCollection.SCHEDULER_NUMBER_REQUESTS :
453 return new NumberRequestsCollector(virtualDbName);
454 case DataCollection.SCHEDULER_NUMBER_WRITES :
455 return new NumberWriteCollector(virtualDbName);
456 case DataCollection.SCHEDULER_PENDING_TRANSACTIONS :
457 return new PendingTransactionsCollector(virtualDbName);
458 case DataCollection.SCHEDULER_PENDING_WRITES :
459 return new PendingWritesCollector(virtualDbName);
460
463 case DataCollection.CLIENT_TIME_ACTIVE :
464 return new ClientActiveTimeCollector(virtualDbName, targetName);
465
466
469 default :
470 throw new DataCollectorException(INVALID_COLLECTOR_TYPE);
471 }
472 }
473
474
477 public long retrieveData(AbstractDataCollector collector)
478 throws DataCollectorException
479 {
480 collector.setController(controller);
483 return collector.collectValue();
484 }
485
486
489 public boolean hasVirtualDatabase(String name)
490 {
491 return controller.hasVirtualDatabase(name);
492 }
493 } |
Popular Tags |
Java API By Example, From Geeks To Geeks.