View Javadoc

1   /**
2      This file is part of GoldenGate Project (named also GoldenGate or GG).
3   
4      Copyright 2009, Frederic Bregier, and individual contributors by the @author
5      tags. See the COPYRIGHT.txt in the distribution for a full listing of
6      individual contributors.
7   
8      All GoldenGate Project is free software: you can redistribute it and/or 
9      modify it under the terms of the GNU General Public License as published 
10     by the Free Software Foundation, either version 3 of the License, or
11     (at your option) any later version.
12  
13     GoldenGate is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16     GNU General Public License for more details.
17  
18     You should have received a copy of the GNU General Public License
19     along with GoldenGate .  If not, see <http://www.gnu.org/licenses/>.
20   */
21  package openr66.protocol.localhandler;
22  
23  import java.util.Date;
24  
25  import org.jboss.netty.handler.traffic.TrafficCounter;
26  
27  import goldengate.common.database.DbAdmin;
28  import goldengate.common.database.DbPreparedStatement;
29  import goldengate.common.database.DbSession;
30  import goldengate.common.database.data.AbstractDbData.UpdatedInfo;
31  import goldengate.common.database.exception.GoldenGateDatabaseNoConnectionException;
32  import goldengate.common.database.exception.GoldenGateDatabaseSqlException;
33  import goldengate.common.database.model.DbModelFactory;
34  import goldengate.common.logging.GgInternalLogger;
35  import goldengate.common.logging.GgInternalLoggerFactory;
36  import goldengate.snmp.GgSnmpAgent;
37  import goldengate.snmp.interf.GgInterfaceMonitor;
38  import goldengate.snmp.r66.GgPrivateMib.MibLevel;
39  import goldengate.snmp.r66.GgPrivateMib.goldenGateDetailedValuesIndex;
40  import goldengate.snmp.r66.GgPrivateMib.goldenGateErrorValuesIndex;
41  import goldengate.snmp.r66.GgPrivateMib.goldenGateGlobalValuesIndex;
42  import openr66.commander.CommanderNoDb;
43  import openr66.context.ErrorCode;
44  import openr66.database.DbConstant;
45  import openr66.database.data.DbTaskRunner;
46  import openr66.database.data.DbTaskRunner.TASKSTEP;
47  import openr66.protocol.configuration.Configuration;
48  import openr66.protocol.snmp.R66PrivateMib;
49  
50  /**
51   * Monitoring class as an helper to get values of interest. Also used by SNMP support.
52   * 
53   * @author Frederic Bregier
54   *
55   */
56  public class Monitoring implements GgInterfaceMonitor {
57      /**
58       * Internal Logger
59       */
60      private static GgInternalLogger logger = GgInternalLoggerFactory
61              .getLogger(Monitoring.class);
62  
63      public GgSnmpAgent agent;
64  
65      // global informations
66      public long nbNetworkConnection = 0;
67      public long secondsRunning = 0;
68      public long nbThread = 0;
69      public long bandwidthIn = 0;
70      public long bandwidthOut = 0;
71      
72      // Internal data
73      private long startMonitor = System.currentTimeMillis();
74      private long pastLimit = 0;
75      private long currentLimit = 0;
76      private long minimalDelay = 0;
77      private long lastTry = 0;
78      private DbSession dbSession = null;
79      private TrafficCounter trafficCounter =
80          Configuration.configuration.getGlobalTrafficShapingHandler().getTrafficCounter();
81  
82      // Overall status including past, future and current transfers
83      private DbPreparedStatement countInfo = null;
84  
85      // Current situation of all transfers, running or not
86      private DbPreparedStatement countInActiveTransfer = null;
87      private DbPreparedStatement countOutActiveTransfer = null;
88      private DbPreparedStatement countInTotalTransfer = null;
89      private DbPreparedStatement countOutTotalTransfer = null;
90      private DbPreparedStatement countInErrorTransfer = null;
91      private DbPreparedStatement countOutErrorTransfer = null;
92      private DbPreparedStatement countStepAllTransfer = null;
93      private DbPreparedStatement countStepNotask = null;
94      private DbPreparedStatement countStepPretask = null;
95      private DbPreparedStatement countStepTransfer = null;
96      private DbPreparedStatement countStepPosttask = null;
97      private DbPreparedStatement countStepAllDone = null;
98      private DbPreparedStatement countStepError = null;
99      
100     // First on Running Transfers only
101     private DbPreparedStatement countAllRunningStep = null;
102     private DbPreparedStatement countRunningStep = null;
103     private DbPreparedStatement countInitOkStep = null;
104     private DbPreparedStatement countPreProcessingOkStep = null;
105     private DbPreparedStatement countTransferOkStep = null;
106     private DbPreparedStatement countPostProcessingOkStep = null;
107     private DbPreparedStatement countCompleteOkStep = null;
108     
109     // Error Status on all transfers
110     private DbPreparedStatement countStatus = null;
111 
112     // Overall status including past, future and current transfers
113     public long nbCountInfoUnknown = 0;
114     public long nbCountInfoNotUpdated = 0;
115     public long nbCountInfoInterrupted = 0;
116     public long nbCountInfoToSubmit = 0;
117     public long nbCountInfoError = 0;
118     public long nbCountInfoRunning = 0;
119     public long nbCountInfoDone = 0;
120 
121     public long nbInActiveTransfer = 0;
122     public long nbOutActiveTransfer = 0;
123     public long lastInActiveTransfer = System.currentTimeMillis();
124     public long lastOutActiveTransfer = System.currentTimeMillis();
125     public long nbInTotalTransfer = 0;
126     public long nbOutTotalTransfer = 0;
127     public long nbInErrorTransfer = 0;
128     public long nbOutErrorTransfer = 0;
129 
130     // Current situation of all transfers, running or not
131     public long nbCountStepAllTransfer = 0;
132     public long nbCountStepNotask = 0;
133     public long nbCountStepPretask = 0;
134     public long nbCountStepTransfer = 0;
135     public long nbCountStepPosttask = 0;
136     public long nbCountStepAllDone = 0;
137     public long nbCountStepError = 0;
138     
139     // First on Running Transfers only
140     public long nbCountAllRunningStep = 0;
141     public long nbCountRunningStep = 0;
142     public long nbCountInitOkStep = 0;
143     public long nbCountPreProcessingOkStep = 0;
144     public long nbCountTransferOkStep = 0;
145     public long nbCountPostProcessingOkStep = 0;
146     public long nbCountCompleteOkStep = 0;
147     
148     // Error Status on all transfers
149     public long nbCountStatusConnectionImpossible = 0;
150     public long nbCountStatusServerOverloaded = 0;
151     public long nbCountStatusBadAuthent = 0;
152     public long nbCountStatusExternalOp = 0;
153     public long nbCountStatusTransferError = 0;
154     public long nbCountStatusMD5Error = 0;
155     public long nbCountStatusDisconnection = 0;
156     public long nbCountStatusFinalOp = 0;
157     public long nbCountStatusUnimplemented = 0;
158     public long nbCountStatusInternal = 0;
159     public long nbCountStatusWarning = 0;
160     public long nbCountStatusQueryAlreadyFinished = 0;
161     public long nbCountStatusQueryStillRunning = 0;
162     public long nbCountStatusNotKnownHost = 0;
163     public long nbCountStatusQueryRemotelyUnknown = 0;
164     public long nbCountStatusCommandNotFound = 0;
165     public long nbCountStatusPassThroughMode = 0;
166     public long nbCountStatusRemoteShutdown = 0;
167     public long nbCountStatusShutdown = 0;
168     public long nbCountStatusRemoteError = 0;
169     public long nbCountStatusStopped = 0;
170     public long nbCountStatusCanceled = 0;
171     public long nbCountStatusFileNotFound = 0;
172     public long nbCountStatusUnknown = 0;
173     
174     
175     /**
176      * @param pastLimit
177      * @param minimalDelay
178      * @param session
179      */
180     public Monitoring(long pastLimit, long minimalDelay, DbSession session) {
181         this.pastLimit = pastLimit;
182         this.minimalDelay = minimalDelay;
183         if (session != null) {
184             dbSession = session;
185         } else {
186             dbSession = DbConstant.admin.session;
187         }
188         this.initialize();
189     }
190     /**
191      * Initialize the Db Requests after constructor or after use of releaseResources
192      */
193     public void initialize() {
194         if (dbSession == null || dbSession.isDisconnected) {
195             logger.warn("Cannot Initialize monitoring");
196             return;
197         }
198         try {
199             logger.debug("Initialize monitoring");
200             // Overall status including past, future and current transfers
201             countInfo = DbTaskRunner.getCountInfoPrepareStatement(dbSession);
202             // Count of Active/All In/Out transfers
203             countInActiveTransfer = DbTaskRunner.getCountInOutRunningPrepareStatement(dbSession, true, true);
204             countOutActiveTransfer = DbTaskRunner.getCountInOutRunningPrepareStatement(dbSession, false, true);
205             countInTotalTransfer = DbTaskRunner.getCountInOutRunningPrepareStatement(dbSession, true, false);
206             countOutTotalTransfer = DbTaskRunner.getCountInOutRunningPrepareStatement(dbSession, false, false);
207             
208             countInErrorTransfer = DbTaskRunner.getCountInOutErrorPrepareStatement(dbSession, true);
209             countOutErrorTransfer = DbTaskRunner.getCountInOutErrorPrepareStatement(dbSession, false);
210             
211             // Current situation of all transfers, running or not
212             countStepAllTransfer = DbTaskRunner.getCountStepPrepareStatement(
213                     dbSession, null);
214             countStepNotask = DbTaskRunner.getCountStepPrepareStatement(
215                     dbSession, TASKSTEP.NOTASK);
216             countStepPretask = DbTaskRunner.getCountStepPrepareStatement(
217                     dbSession, TASKSTEP.PRETASK);
218             countStepTransfer = DbTaskRunner.getCountStepPrepareStatement(
219                     dbSession, TASKSTEP.TRANSFERTASK);
220             countStepPosttask = DbTaskRunner.getCountStepPrepareStatement(
221                     dbSession, TASKSTEP.POSTTASK);
222             countStepAllDone = DbTaskRunner.getCountStepPrepareStatement(
223                     dbSession, TASKSTEP.ALLDONETASK);
224             countStepError = DbTaskRunner.getCountStepPrepareStatement(
225                     dbSession, TASKSTEP.ERRORTASK);
226             
227             // First on Running Transfers only
228             countAllRunningStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
229                     null);
230             countRunningStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
231                     ErrorCode.Running);
232             countInitOkStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
233                     ErrorCode.InitOk);
234             countPreProcessingOkStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
235                     ErrorCode.PreProcessingOk);
236             countTransferOkStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
237                     ErrorCode.TransferOk);
238             countPostProcessingOkStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
239                     ErrorCode.PostProcessingOk);
240             countCompleteOkStep = DbTaskRunner.getCountStatusRunningPrepareStatement(dbSession,
241                     ErrorCode.CompleteOk);
242             
243             // Error Status on all transfers
244             countStatus = DbTaskRunner.getCountStatusPrepareStatement(dbSession);
245         } catch (GoldenGateDatabaseNoConnectionException e) {
246         } catch (GoldenGateDatabaseSqlException e) {
247         }
248     }
249     /**
250      * Release all Db Requests
251      */
252     public void releaseResources() {
253         if (dbSession == null || dbSession.isDisconnected) {
254             return;
255         }
256         try {
257             logger.debug("Release monitoring");
258             // Overall status including past, future and current transfers
259             countInfo.realClose();
260             
261             countInActiveTransfer.realClose();
262             countOutActiveTransfer.realClose();
263             countInTotalTransfer.realClose();
264             countOutTotalTransfer.realClose();
265             countInErrorTransfer.realClose();
266             countOutErrorTransfer.realClose();
267             
268             // Current situation of all transfers, running or not
269             countStepAllTransfer.realClose();
270             countStepNotask.realClose();
271             countStepPretask.realClose();
272             countStepTransfer.realClose();
273             countStepPosttask.realClose();
274             countStepAllDone.realClose();
275             countStepError.realClose();
276             
277             // First on Running Transfers only
278             countAllRunningStep.realClose();
279             countRunningStep.realClose();
280             countInitOkStep.realClose();
281             countPreProcessingOkStep.realClose();
282             countTransferOkStep.realClose();
283             countPostProcessingOkStep.realClose();
284             countCompleteOkStep.realClose();
285             
286             // Error Status on all transfers
287             countStatus.realClose();
288         } catch (NullPointerException e) {
289         }
290     }
291     /**
292      * 
293      * @return the last Time in ms of the execution
294      */
295     public long lastRunTimeMs() {
296         return lastTry;
297     }
298     /**
299      * Default execution of testing with default pastLimit
300      */
301     public void run() {
302         this.run(-1, false);
303     }
304     /**
305      * 
306      * @param nbSecond as specific PastLimit
307      */
308     public void run(long nbSecond) {
309         this.run(nbSecond, false);
310     }
311     /**
312      * Default execution of testing with default pastLimit
313      * 
314      * @param detail as to get detailed information
315      */
316     public void run(boolean detail) {
317         this.run(-1, detail);
318     }
319     /**
320      * 
321      * @return False if too early, else return True
322      */
323     private boolean reCompute() {
324         long limitDate = System.currentTimeMillis();
325         if (limitDate < lastTry+minimalDelay) {
326             // too early
327             return false;
328         }
329         lastTry = limitDate;
330         return true;
331     }
332     /**
333      * 
334      * @param nbSecond as specific PastLimit
335      * @param detail as to get detailed information
336      */
337     public void run(long nbSecond, boolean detail) {
338         synchronized (trafficCounter) {
339             long limitDate = System.currentTimeMillis();
340             long nbMs = pastLimit;
341             if (nbSecond <= 0) {
342                 nbMs = pastLimit;
343             } else {
344                 nbMs = nbSecond*1000;
345             }
346             if (dbSession == null || dbSession.isDisconnected) {
347                 nbNetworkConnection = 
348                     Configuration.configuration.getHttpChannelGroup().size() +
349                     Configuration.configuration.getServerChannelGroup().size();
350                 bandwidthIn = trafficCounter.getLastReadThroughput()>>7;// B/s -> Kb/s
351                 bandwidthOut = trafficCounter.getLastWriteThroughput()>>7;
352                 nbThread = Thread.activeCount();
353                 secondsRunning = (limitDate - startMonitor) / 1000;
354     
355                 if (!reCompute()) {
356                     // too early
357                     return;
358                 }
359                 limitDate -= nbMs;
360                 currentLimit = limitDate;
361                 // Update value
362                 // Overall status including past, future and current transfers
363                 nbCountInfoToSubmit = CommanderNoDb.todoList.size();
364                 nbCountInfoRunning = Configuration.configuration.getInternalRunner().nbInternalRunner();
365                 // Current situation of all transfers, running or not
366                 nbCountAllRunningStep = nbCountInfoRunning;
367             } else {
368                 nbNetworkConnection = DbAdmin.getNbConnection();
369                 bandwidthIn = trafficCounter.getLastReadThroughput()>>7;// B/s -> Kb/s
370                 bandwidthOut = trafficCounter.getLastWriteThroughput()>>7;
371                 nbThread = Thread.activeCount();
372                 secondsRunning = (limitDate - startMonitor) / 1000;
373     
374                 if (!reCompute()) {
375                     // too early
376                     return;
377                 }
378                 limitDate -= nbMs;
379                 currentLimit = limitDate;
380                 // Update value
381                 try {
382                     // Overall status including past, future and current transfers
383                     nbCountInfoUnknown = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
384                             UpdatedInfo.UNKNOWN, limitDate);
385                     nbCountInfoNotUpdated = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
386                             UpdatedInfo.NOTUPDATED, limitDate);
387                     nbCountInfoInterrupted = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
388                             UpdatedInfo.INTERRUPTED, limitDate);
389                     nbCountInfoToSubmit = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
390                             UpdatedInfo.TOSUBMIT, limitDate);
391                     nbCountInfoError = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
392                             UpdatedInfo.INERROR, limitDate);
393                     nbCountInfoRunning = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
394                             UpdatedInfo.RUNNING, limitDate);
395                     nbCountInfoDone = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
396                             UpdatedInfo.DONE, limitDate);
397             
398                     // Current situation of all transfers, running or not
399                     DbTaskRunner.finishSelectOrCountPrepareStatement(countInActiveTransfer, limitDate);
400                     nbInActiveTransfer = DbTaskRunner.getResultCountPrepareStatement(countInActiveTransfer);
401                     DbTaskRunner.finishSelectOrCountPrepareStatement(countOutActiveTransfer, limitDate);
402                     nbOutActiveTransfer = DbTaskRunner.getResultCountPrepareStatement(countOutActiveTransfer);
403                     DbTaskRunner.finishSelectOrCountPrepareStatement(countInTotalTransfer, limitDate);
404                     nbInTotalTransfer = DbTaskRunner.getResultCountPrepareStatement(countInTotalTransfer);
405                     DbTaskRunner.finishSelectOrCountPrepareStatement(countOutTotalTransfer, limitDate);
406                     nbOutTotalTransfer = DbTaskRunner.getResultCountPrepareStatement(countOutTotalTransfer);
407     
408                     DbTaskRunner.finishSelectOrCountPrepareStatement(countOutErrorTransfer, limitDate);
409                     nbOutErrorTransfer = DbTaskRunner.getResultCountPrepareStatement(countOutErrorTransfer);
410                     DbTaskRunner.finishSelectOrCountPrepareStatement(countInErrorTransfer, limitDate);
411                     nbInErrorTransfer = DbTaskRunner.getResultCountPrepareStatement(countInErrorTransfer);
412                     
413                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepAllTransfer, limitDate);
414                     nbCountStepAllTransfer = DbTaskRunner.getResultCountPrepareStatement(countStepAllTransfer);
415                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepNotask, limitDate);
416                     nbCountStepNotask = DbTaskRunner.getResultCountPrepareStatement(countStepNotask);
417                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepPretask, limitDate);
418                     nbCountStepPretask = DbTaskRunner.getResultCountPrepareStatement(countStepPretask);
419                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepTransfer, limitDate);
420                     nbCountStepTransfer = DbTaskRunner.getResultCountPrepareStatement(countStepTransfer);
421                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepPosttask, limitDate);
422                     nbCountStepPosttask = DbTaskRunner.getResultCountPrepareStatement(countStepPosttask);
423                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepAllDone, limitDate);
424                     nbCountStepAllDone = DbTaskRunner.getResultCountPrepareStatement(countStepAllDone);
425                     DbTaskRunner.finishSelectOrCountPrepareStatement(countStepError, limitDate);
426                     nbCountStepError = DbTaskRunner.getResultCountPrepareStatement(countStepError);
427                     
428                     DbTaskRunner.finishSelectOrCountPrepareStatement(countAllRunningStep, limitDate);
429                     nbCountAllRunningStep = DbTaskRunner.getResultCountPrepareStatement(countAllRunningStep);
430     
431                     if (detail) {
432                         // First on Running Transfers only
433                         DbTaskRunner.finishSelectOrCountPrepareStatement(countRunningStep, limitDate);
434                         nbCountRunningStep = DbTaskRunner.getResultCountPrepareStatement(countRunningStep);
435                         DbTaskRunner.finishSelectOrCountPrepareStatement(countInitOkStep, limitDate);
436                         nbCountInitOkStep = DbTaskRunner.getResultCountPrepareStatement(countInitOkStep);
437                         DbTaskRunner.finishSelectOrCountPrepareStatement(countPreProcessingOkStep, limitDate);
438                         nbCountPreProcessingOkStep = DbTaskRunner.getResultCountPrepareStatement(countPreProcessingOkStep);
439                         DbTaskRunner.finishSelectOrCountPrepareStatement(countTransferOkStep, limitDate);
440                         nbCountTransferOkStep = DbTaskRunner.getResultCountPrepareStatement(countTransferOkStep);
441                         DbTaskRunner.finishSelectOrCountPrepareStatement(countPostProcessingOkStep, limitDate);
442                         nbCountPostProcessingOkStep = DbTaskRunner.getResultCountPrepareStatement(countPostProcessingOkStep);
443                         DbTaskRunner.finishSelectOrCountPrepareStatement(countCompleteOkStep, limitDate);
444                         nbCountCompleteOkStep = DbTaskRunner.getResultCountPrepareStatement(countCompleteOkStep);
445                         
446                         // Error Status on all transfers
447                         nbCountStatusConnectionImpossible = DbTaskRunner.getResultCountPrepareStatement(countStatus,
448                                 ErrorCode.ConnectionImpossible, limitDate);
449                         nbCountStatusServerOverloaded = DbTaskRunner.getResultCountPrepareStatement(countStatus,
450                                 ErrorCode.ServerOverloaded, limitDate);
451                         nbCountStatusBadAuthent = DbTaskRunner.getResultCountPrepareStatement(countStatus,
452                                 ErrorCode.BadAuthent, limitDate);
453                         nbCountStatusExternalOp = DbTaskRunner.getResultCountPrepareStatement(countStatus,
454                                 ErrorCode.ExternalOp, limitDate);
455                         nbCountStatusTransferError = DbTaskRunner.getResultCountPrepareStatement(countStatus,
456                                 ErrorCode.TransferError, limitDate);
457                         nbCountStatusMD5Error = DbTaskRunner.getResultCountPrepareStatement(countStatus,
458                                 ErrorCode.MD5Error, limitDate);
459                         nbCountStatusDisconnection = DbTaskRunner.getResultCountPrepareStatement(countStatus,
460                                 ErrorCode.Disconnection, limitDate);
461                         nbCountStatusFinalOp = DbTaskRunner.getResultCountPrepareStatement(countStatus,
462                                 ErrorCode.FinalOp, limitDate);
463                         nbCountStatusUnimplemented = DbTaskRunner.getResultCountPrepareStatement(countStatus,
464                                 ErrorCode.Unimplemented, limitDate);
465                         nbCountStatusInternal = DbTaskRunner.getResultCountPrepareStatement(countStatus,
466                                 ErrorCode.Internal, limitDate);
467                         nbCountStatusWarning = DbTaskRunner.getResultCountPrepareStatement(countStatus,
468                                 ErrorCode.Warning, limitDate);
469                         nbCountStatusQueryAlreadyFinished = DbTaskRunner.getResultCountPrepareStatement(countStatus,
470                                 ErrorCode.QueryAlreadyFinished, limitDate);
471                         nbCountStatusQueryStillRunning = DbTaskRunner.getResultCountPrepareStatement(countStatus,
472                                 ErrorCode.QueryStillRunning, limitDate);
473                         nbCountStatusNotKnownHost = DbTaskRunner.getResultCountPrepareStatement(countStatus,
474                                 ErrorCode.NotKnownHost, limitDate);
475                         nbCountStatusQueryRemotelyUnknown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
476                                 ErrorCode.QueryRemotelyUnknown, limitDate);
477                         nbCountStatusCommandNotFound = DbTaskRunner.getResultCountPrepareStatement(countStatus,
478                                 ErrorCode.CommandNotFound, limitDate);
479                         nbCountStatusPassThroughMode = DbTaskRunner.getResultCountPrepareStatement(countStatus,
480                                 ErrorCode.PassThroughMode, limitDate);
481                         nbCountStatusRemoteShutdown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
482                                 ErrorCode.RemoteShutdown, limitDate);
483                         nbCountStatusShutdown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
484                                 ErrorCode.Shutdown, limitDate);
485                         nbCountStatusRemoteError = DbTaskRunner.getResultCountPrepareStatement(countStatus,
486                                 ErrorCode.RemoteError, limitDate);
487                         nbCountStatusStopped = DbTaskRunner.getResultCountPrepareStatement(countStatus,
488                                 ErrorCode.StoppedTransfer, limitDate);
489                         nbCountStatusCanceled = DbTaskRunner.getResultCountPrepareStatement(countStatus,
490                                 ErrorCode.CanceledTransfer, limitDate);
491                         nbCountStatusFileNotFound = DbTaskRunner.getResultCountPrepareStatement(countStatus,
492                                 ErrorCode.FileNotFound, limitDate);
493                         nbCountStatusUnknown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
494                                 ErrorCode.Unknown, limitDate);
495                     }
496                 } catch (GoldenGateDatabaseNoConnectionException e) {
497                 } catch (GoldenGateDatabaseSqlException e) {
498                 }
499             }
500         }
501     }
502     /**
503      * @param detail
504      * @return The XML representation of the current status
505      */
506     public String exportXml(boolean detail) {
507         StringBuilder builder = new StringBuilder();
508         builder.append("<STATUS>");
509         // Global Informations
510         builder.append("<HostID>");
511         builder.append(Configuration.configuration.HOST_ID);
512         builder.append("</HostID>");
513         builder.append("<Date>");
514         builder.append(new Date());
515         builder.append("</Date>");
516         builder.append("<LastRun>");
517         builder.append(new Date(lastTry));
518         builder.append("</LastRun>");
519         builder.append("<FromDate>");
520         builder.append(new Date(currentLimit));
521         builder.append("</FromDate>");
522         builder.append("<SecondsRunning>");
523         builder.append(secondsRunning);
524         builder.append("</SecondsRunning>");
525         builder.append("<NetworkConnections>");
526         builder.append(nbNetworkConnection);
527         builder.append("</NetworkConnections>");
528         builder.append("<NbThreads>");
529         builder.append(nbThread);
530         builder.append("</NbThreads>");
531         builder.append("<InBandwidth>");
532         builder.append(bandwidthIn);
533         builder.append("</InBandwidth>");
534         builder.append("<OutBandwidth>");
535         builder.append(bandwidthOut);
536         builder.append("</OutBandwidth>");
537         
538         // Overall status including past, future and current transfers
539         builder.append("<OVERALL>");
540         builder.append("<AllTransfer>");
541         builder.append(nbCountStepAllTransfer);
542         builder.append("</AllTransfer>");
543         builder.append("<Unknown>");
544         builder.append(nbCountInfoUnknown);
545         builder.append("</Unknown>");
546         builder.append("<NotUpdated>");
547         builder.append(nbCountInfoNotUpdated);
548         builder.append("</NotUpdated>");
549         builder.append("<Interrupted>");
550         builder.append(nbCountInfoInterrupted);
551         builder.append("</Interrupted>");
552         builder.append("<ToSubmit>");
553         builder.append(nbCountInfoToSubmit);
554         builder.append("</ToSubmit>");
555         builder.append("<Error>");
556         builder.append(nbCountInfoError);
557         builder.append("</Error>");
558         builder.append("<Running>");
559         builder.append(nbCountInfoRunning);
560         builder.append("</Running>");
561         builder.append("<Done>");
562         builder.append(nbCountInfoDone);
563         builder.append("</Done>");
564         builder.append("<InRunning>");
565         builder.append(nbInActiveTransfer);
566         builder.append("</InRunning>");
567         builder.append("<OutRunning>");
568         builder.append(nbOutActiveTransfer);
569         builder.append("</OutRunning>");
570         builder.append("<LastInRunning>");
571         builder.append((new Date(lastInActiveTransfer)).toString());
572         builder.append("</LastInRunning>");
573         builder.append("<LastOutRunning>");
574         builder.append((new Date(lastOutActiveTransfer)).toString());
575         builder.append("</LastOutRunning>");
576         builder.append("<InAll>");
577         builder.append(nbInTotalTransfer);
578         builder.append("</InAll>");
579         builder.append("<OutAll>");
580         builder.append(nbOutTotalTransfer);
581         builder.append("</OutAll>");
582         builder.append("<InError>");
583         builder.append(nbInErrorTransfer);
584         builder.append("</InError>");
585         builder.append("<OutError>");
586         builder.append(nbOutErrorTransfer);
587         builder.append("</OutError>");
588         builder.append("</OVERALL>");
589 
590         // Current situation of all transfers, running or not
591         builder.append("<STEPS>");
592         builder.append("<Notask>");
593         builder.append(nbCountStepNotask);
594         builder.append("</Notask>");
595         builder.append("<Pretask>");
596         builder.append(nbCountStepPretask);
597         builder.append("</Pretask>");
598         builder.append("<Transfer>");
599         builder.append(nbCountStepTransfer);
600         builder.append("</Transfer>");
601         builder.append("<Posttask>");
602         builder.append(nbCountStepPosttask);
603         builder.append("</Posttask>");
604         builder.append("<AllDone>");
605         builder.append(nbCountStepAllDone);
606         builder.append("</AllDone>");
607         builder.append("<Error>");
608         builder.append(nbCountStepError);
609         builder.append("</Error>");
610         builder.append("</STEPS>");
611 
612         // On Running Transfers only
613         builder.append("<RUNNINGSTEPS>");
614         builder.append("<AllRunning>");
615         builder.append(nbCountAllRunningStep);
616         builder.append("</AllRunning>");
617         if (detail) {
618             builder.append("<Running>");
619             builder.append(nbCountRunningStep);
620             builder.append("</Running>");
621             builder.append("<InitOk>");
622             builder.append(nbCountInitOkStep);
623             builder.append("</InitOk>");
624             builder.append("<PreProcessingOk>");
625             builder.append(nbCountPreProcessingOkStep);
626             builder.append("</PreProcessingOk>");
627             builder.append("<TransferOk>");
628             builder.append(nbCountTransferOkStep);
629             builder.append("</TransferOk>");
630             builder.append("<PostProcessingOk>");
631             builder.append(nbCountPostProcessingOkStep);
632             builder.append("</PostProcessingOk>");
633             builder.append("<CompleteOk>");
634             builder.append(nbCountCompleteOkStep);
635             builder.append("</CompleteOk>");
636         }
637         builder.append("</RUNNINGSTEPS>");
638         
639         if (detail) {
640             // Error Status on all transfers
641             builder.append("<ERRORTYPES>");
642             builder.append("<ConnectionImpossible>");
643             builder.append(nbCountStatusConnectionImpossible);
644             builder.append("</ConnectionImpossible>");
645             builder.append("<ServerOverloaded>");
646             builder.append(nbCountStatusServerOverloaded);
647             builder.append("</ServerOverloaded>");
648             builder.append("<BadAuthent>");
649             builder.append(nbCountStatusBadAuthent);
650             builder.append("</BadAuthent>");
651             builder.append("<ExternalOp>");
652             builder.append(nbCountStatusExternalOp);
653             builder.append("</ExternalOp>");
654             builder.append("<TransferError>");
655             builder.append(nbCountStatusTransferError);
656             builder.append("</TransferError>");
657             builder.append("<MD5Error>");
658             builder.append(nbCountStatusMD5Error);
659             builder.append("</MD5Error>");
660             builder.append("<Disconnection>");
661             builder.append(nbCountStatusDisconnection);
662             builder.append("</Disconnection>");
663             builder.append("<FinalOp>");
664             builder.append(nbCountStatusFinalOp);
665             builder.append("</FinalOp>");
666             builder.append("<Unimplemented>");
667             builder.append(nbCountStatusUnimplemented);
668             builder.append("</Unimplemented>");
669             builder.append("<Internal>");
670             builder.append(nbCountStatusInternal);
671             builder.append("</Internal>");
672             builder.append("<Warning>");
673             builder.append(nbCountStatusWarning);
674             builder.append("</Warning>");
675             builder.append("<QueryAlreadyFinished>");
676             builder.append(nbCountStatusQueryAlreadyFinished);
677             builder.append("</QueryAlreadyFinished>");
678             builder.append("<QueryStillRunning>");
679             builder.append(nbCountStatusQueryStillRunning);
680             builder.append("</QueryStillRunning>");
681             builder.append("<KnownHost>");
682             builder.append(nbCountStatusNotKnownHost);
683             builder.append("</KnownHost>");
684             builder.append("<RemotelyUnknown>");
685             builder.append(nbCountStatusQueryRemotelyUnknown);
686             builder.append("</RemotelyUnknown>");
687             builder.append("<CommandNotFound>");
688             builder.append(nbCountStatusCommandNotFound);
689             builder.append("</CommandNotFound>");
690             builder.append("<PassThroughMode>");
691             builder.append(nbCountStatusPassThroughMode);
692             builder.append("</PassThroughMode>");
693             builder.append("<RemoteShutdown>");
694             builder.append(nbCountStatusRemoteShutdown);
695             builder.append("</RemoteShutdown>");
696             builder.append("<Shutdown>");
697             builder.append(nbCountStatusShutdown);
698             builder.append("</Shutdown>");
699             builder.append("<RemoteError>");
700             builder.append(nbCountStatusRemoteError);
701             builder.append("</RemoteError>");
702             builder.append("<Stopped>");
703             builder.append(nbCountStatusStopped);
704             builder.append("</Stopped>");
705             builder.append("<Canceled>");
706             builder.append(nbCountStatusCanceled);
707             builder.append("</Canceled>");
708             builder.append("<FileNotFound>");
709             builder.append(nbCountStatusFileNotFound);
710             builder.append("</FileNotFound>");
711             builder.append("<Unknown>");
712             builder.append(nbCountStatusUnknown);
713             builder.append("</Unknown>");
714             builder.append("</ERRORTYPES>");
715         }
716         builder.append("</STATUS>");
717         return builder.toString();
718     }
719     /* (non-Javadoc)
720      * @see goldengate.snmp.GgInterfaceMonitor#setAgent(goldengate.snmp.GgSnmpAgent)
721      */
722     @Override
723     public void setAgent(GgSnmpAgent agent) {
724         this.agent = agent;
725         this.lastInActiveTransfer = this.agent.getUptimeSystemTime();
726         this.lastOutActiveTransfer= this.agent.getUptimeSystemTime();
727     }
728     /**
729      * Update the value for one particular MIB entry
730      * @param type
731      * @param entry
732      */
733     public void run(int type, int entry) {
734         long nbMs = Configuration.configuration.agentSnmp.getUptime()+100;
735         MibLevel level = MibLevel.values()[type];
736         switch (level) {
737             case globalInfo:// Global
738                 if (((R66PrivateMib) this.agent.mib).rowGlobal != null)
739                     run(nbMs, goldenGateGlobalValuesIndex.values()[entry]);
740                 return;
741             case detailedInfo:// Detailed
742                 if (((R66PrivateMib) this.agent.mib).rowDetailed != null)
743                     run(nbMs, goldenGateDetailedValuesIndex.values()[entry]);
744                 return;
745             case errorInfo:// Error
746                 if (((R66PrivateMib) this.agent.mib).rowError != null)
747                     run(nbMs, goldenGateErrorValuesIndex.values()[entry]);
748                 return;
749         }
750     }
751     /**
752      * Update a value in Global MIB part 
753      * @param rank
754      * @param value
755      */
756     protected void updateGlobalValue(int rank, long value) {
757         ((R66PrivateMib) this.agent.mib).rowGlobal.setValue(rank, value);
758     }
759     /**
760      * Update a value in Detailed MIB part
761      * @param rank
762      * @param value
763      */
764     protected void updateDetailedValue(int rank, long value) {
765         ((R66PrivateMib) this.agent.mib).rowDetailed.setValue(rank, value);
766     }
767     /**
768      * Update a value in Error MIB part
769      * @param rank
770      * @param value
771      */
772     protected void updateErrorValue(int rank, long value) {
773         ((R66PrivateMib) this.agent.mib).rowError.setValue(rank, value);
774     }
775     /**
776      * Update a value in Global MIB part
777      * @param nbMs
778      * @param entry
779      */
780     protected void run(long nbMs, goldenGateGlobalValuesIndex entry) {
781         synchronized (trafficCounter) {
782             long val = 0;
783             long limitDate = System.currentTimeMillis()-nbMs;
784             if (dbSession == null || dbSession.isDisconnected) {
785                 switch (entry) {
786                     case applUptime:
787                         return;
788                     case applOperStatus:
789                         return;
790                     case applLastChange:
791                         return;
792                     case applInboundAssociations:
793                         updateGlobalValue(entry.ordinal(), nbInActiveTransfer);
794                         return;
795                     case applOutboundAssociations:
796                         updateGlobalValue(entry.ordinal(), nbOutActiveTransfer);
797                         return;
798                     case applAccumInboundAssociations:
799                         updateGlobalValue(entry.ordinal(), nbInTotalTransfer);
800                         return;
801                     case applAccumOutboundAssociations:
802                         updateGlobalValue(entry.ordinal(), nbOutTotalTransfer);
803                         return;
804                     case applLastInboundActivity:
805                         val = (lastInActiveTransfer-
806                                 this.agent.getUptimeSystemTime())/10;
807                         if (val < 0)
808                             val = 0;
809                         updateGlobalValue(entry.ordinal(), val);
810                         return;
811                     case applLastOutboundActivity:
812                         val = (lastOutActiveTransfer-
813                                 this.agent.getUptimeSystemTime())/10;
814                         if (val < 0)
815                             val = 0;
816                         updateGlobalValue(entry.ordinal(), val);
817                         return;
818                     case applRejectedInboundAssociations:
819                         updateGlobalValue(entry.ordinal(), nbInErrorTransfer);
820                         return;
821                     case applFailedOutboundAssociations:
822                         updateGlobalValue(entry.ordinal(), nbOutErrorTransfer);
823                         return;
824                     case applInboundBandwidthKBS:
825                         val = trafficCounter.getLastReadThroughput()>>10;// B/s -> KB/s
826                         updateGlobalValue(entry.ordinal(), val);
827                         return;
828                     case applOutboundBandwidthKBS:
829                         val = trafficCounter.getLastWriteThroughput()>>10;
830                         updateGlobalValue(entry.ordinal(), val);
831                         return;
832                     case nbInfoUnknown:
833                         updateGlobalValue(entry.ordinal(), nbCountInfoUnknown);
834                         return;
835                     case nbInfoNotUpdated:
836                         updateGlobalValue(entry.ordinal(), nbCountInfoNotUpdated);
837                         return;
838                     case nbInfoInterrupted:
839                         updateGlobalValue(entry.ordinal(), nbCountInfoInterrupted);
840                         return;
841                     case nbInfoToSubmit:
842                         nbCountInfoToSubmit = CommanderNoDb.todoList.size();
843                         updateGlobalValue(entry.ordinal(), nbCountInfoToSubmit);
844                         return;
845                     case nbInfoError:
846                         updateGlobalValue(entry.ordinal(), nbCountInfoError);
847                         return;
848                     case nbInfoRunning:
849                         nbCountInfoRunning = Configuration.configuration.getInternalRunner().nbInternalRunner();
850                         updateGlobalValue(entry.ordinal(), nbCountInfoRunning);
851                         return;
852                     case nbInfoDone:
853                         updateGlobalValue(entry.ordinal(), nbCountInfoDone);
854                         return;
855                     case nbStepAllTransfer:
856                         updateGlobalValue(entry.ordinal(), nbCountStepAllTransfer);
857                         return;
858                     case memoryTotal:
859                         return;
860                     case memoryFree:
861                         return;
862                     case memoryUsed:
863                         return;
864                     case nbThreads:
865                         nbThread = Thread.activeCount();
866                         updateGlobalValue(entry.ordinal(), nbThread);
867                         return;
868                     case nbNetworkConnection:
869                         nbNetworkConnection = 
870                             Configuration.configuration.getHttpChannelGroup().size() +
871                             Configuration.configuration.getServerChannelGroup().size();
872                         updateGlobalValue(entry.ordinal(), nbNetworkConnection);
873                         return;
874                 }
875                 return;
876             }
877             //Global
878             try {
879                 switch (entry) {
880                     case applUptime:
881                         return;
882                     case applOperStatus:
883                         return;
884                     case applLastChange:
885                         return;
886                     case applInboundAssociations:
887                         DbTaskRunner.finishSelectOrCountPrepareStatement(countInActiveTransfer, limitDate);
888                         nbInActiveTransfer = DbTaskRunner.getResultCountPrepareStatement(countInActiveTransfer);
889                         updateGlobalValue(entry.ordinal(), nbInActiveTransfer);
890                         return;
891                     case applOutboundAssociations:
892                         DbTaskRunner.finishSelectOrCountPrepareStatement(countOutActiveTransfer, limitDate);
893                         nbOutActiveTransfer = DbTaskRunner.getResultCountPrepareStatement(countOutActiveTransfer);
894                         updateGlobalValue(entry.ordinal(), nbOutActiveTransfer);
895                         return;
896                     case applAccumInboundAssociations:
897                         DbTaskRunner.finishSelectOrCountPrepareStatement(countInTotalTransfer, limitDate);
898                         nbInTotalTransfer = DbTaskRunner.getResultCountPrepareStatement(countInTotalTransfer);
899                         updateGlobalValue(entry.ordinal(), nbInTotalTransfer);
900                         return;
901                     case applAccumOutboundAssociations:
902                         DbTaskRunner.finishSelectOrCountPrepareStatement(countOutTotalTransfer, limitDate);
903                         nbOutTotalTransfer = DbTaskRunner.getResultCountPrepareStatement(countOutTotalTransfer);
904                         updateGlobalValue(entry.ordinal(), nbOutTotalTransfer);
905                         return;
906                     case applLastInboundActivity:
907                         val = (lastInActiveTransfer-
908                                 this.agent.getUptimeSystemTime())/10;
909                         if (val < 0)
910                             val = 0;
911                         updateGlobalValue(entry.ordinal(), val);
912                         return;
913                     case applLastOutboundActivity:
914                         val = (lastOutActiveTransfer-
915                                 this.agent.getUptimeSystemTime())/10;
916                         if (val < 0)
917                             val = 0;
918                         updateGlobalValue(entry.ordinal(), val);
919                         return;
920                     case applRejectedInboundAssociations:
921                         DbTaskRunner.finishSelectOrCountPrepareStatement(countInErrorTransfer, limitDate);
922                         nbInErrorTransfer = DbTaskRunner.getResultCountPrepareStatement(countInErrorTransfer);
923                         updateGlobalValue(entry.ordinal(), nbInErrorTransfer);
924                         return;
925                     case applFailedOutboundAssociations:
926                         DbTaskRunner.finishSelectOrCountPrepareStatement(countOutErrorTransfer, limitDate);
927                         nbOutErrorTransfer = DbTaskRunner.getResultCountPrepareStatement(countOutErrorTransfer);
928                         updateGlobalValue(entry.ordinal(), nbOutErrorTransfer);
929                         return;
930                     case applInboundBandwidthKBS:
931                         val = trafficCounter.getLastReadThroughput()>>10;// B/s -> KB/s
932                         updateGlobalValue(entry.ordinal(), val);
933                         return;
934                     case applOutboundBandwidthKBS:
935                         val = trafficCounter.getLastWriteThroughput()>>10;
936                         updateGlobalValue(entry.ordinal(), val);
937                         return;
938                     case nbInfoUnknown:
939                         nbCountInfoUnknown = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
940                                 UpdatedInfo.UNKNOWN, limitDate);
941                         updateGlobalValue(entry.ordinal(), nbCountInfoUnknown);
942                         return;
943                     case nbInfoNotUpdated:
944                         nbCountInfoNotUpdated = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
945                                 UpdatedInfo.NOTUPDATED, limitDate);
946                         updateGlobalValue(entry.ordinal(), nbCountInfoNotUpdated);
947                         return;
948                     case nbInfoInterrupted:
949                         nbCountInfoInterrupted = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
950                                 UpdatedInfo.INTERRUPTED, limitDate);
951                         updateGlobalValue(entry.ordinal(), nbCountInfoInterrupted);
952                         return;
953                     case nbInfoToSubmit:
954                         nbCountInfoToSubmit = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
955                                 UpdatedInfo.TOSUBMIT, limitDate);
956                         updateGlobalValue(entry.ordinal(), nbCountInfoToSubmit);
957                         return;
958                     case nbInfoError:
959                         nbCountInfoError = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
960                                 UpdatedInfo.INERROR, limitDate);
961                         updateGlobalValue(entry.ordinal(), nbCountInfoError);
962                         return;
963                     case nbInfoRunning:
964                         nbCountInfoRunning = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
965                                 UpdatedInfo.RUNNING, limitDate);
966                         updateGlobalValue(entry.ordinal(), nbCountInfoRunning);
967                         return;
968                     case nbInfoDone:
969                         nbCountInfoDone = DbTaskRunner.getResultCountPrepareStatement(countInfo, 
970                                 UpdatedInfo.DONE, limitDate);
971                         updateGlobalValue(entry.ordinal(), nbCountInfoDone);
972                         return;
973                     case nbStepAllTransfer:
974                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepAllTransfer, limitDate);
975                         nbCountStepAllTransfer = DbTaskRunner.getResultCountPrepareStatement(countStepAllTransfer);
976                         updateGlobalValue(entry.ordinal(), nbCountStepAllTransfer);
977                         return;
978                     case memoryTotal:
979                         return;
980                     case memoryFree:
981                         return;
982                     case memoryUsed:
983                         return;
984                     case nbThreads:
985                         nbThread = Thread.activeCount();
986                         updateGlobalValue(entry.ordinal(), nbThread);
987                         return;
988                     case nbNetworkConnection:
989                         nbNetworkConnection = DbAdmin.getNbConnection();
990                         updateGlobalValue(entry.ordinal(), nbNetworkConnection);
991                         return;
992                 }
993             } catch (GoldenGateDatabaseNoConnectionException e) {
994             } catch (GoldenGateDatabaseSqlException e) {
995             }
996         }
997     }
998     /**
999      * Update a value in Detailed MIB part
1000      * @param nbMs
1001      * @param entry
1002      */
1003     protected void run(long nbMs, goldenGateDetailedValuesIndex entry) {
1004         synchronized (trafficCounter) {
1005             long limitDate = System.currentTimeMillis()-nbMs;
1006             if (dbSession == null || dbSession.isDisconnected) {
1007                 switch (entry) {
1008                     case nbStepNotask:
1009                         updateDetailedValue(entry.ordinal(), nbCountStepNotask);
1010                         return;
1011                     case nbStepPretask:
1012                         updateDetailedValue(entry.ordinal(), nbCountStepPretask);
1013                         return;
1014                     case nbStepTransfer:
1015                         updateDetailedValue(entry.ordinal(), nbCountStepTransfer);
1016                         return;
1017                     case nbStepPosttask:
1018                         updateDetailedValue(entry.ordinal(), nbCountStepPosttask);
1019                         return;
1020                     case nbStepAllDone:
1021                         updateDetailedValue(entry.ordinal(), nbCountStepAllDone);
1022                         return;
1023                     case nbStepError:
1024                         updateDetailedValue(entry.ordinal(), nbCountStepError);
1025                         return;
1026                     case nbAllRunningStep:
1027                         nbCountAllRunningStep = Configuration.configuration.getInternalRunner().nbInternalRunner();
1028                         updateDetailedValue(entry.ordinal(), nbCountAllRunningStep);
1029                         return;
1030                     case nbRunningStep:
1031                         updateDetailedValue(entry.ordinal(), nbCountRunningStep);
1032                         return;
1033                     case nbInitOkStep:
1034                         updateDetailedValue(entry.ordinal(), nbCountInitOkStep);
1035                         return;
1036                     case nbPreProcessingOkStep:
1037                         updateDetailedValue(entry.ordinal(), nbCountPreProcessingOkStep);
1038                         return;
1039                     case nbTransferOkStep:
1040                         updateDetailedValue(entry.ordinal(), nbCountTransferOkStep);
1041                         return;
1042                     case nbPostProcessingOkStep:
1043                         updateDetailedValue(entry.ordinal(), nbCountPostProcessingOkStep);
1044                         return;
1045                     case nbCompleteOkStep:
1046                         updateDetailedValue(entry.ordinal(), nbCountCompleteOkStep);
1047                         return;
1048                 }
1049                 return;
1050             }
1051                 //Detailed
1052             try {
1053                 switch (entry) {
1054                     case nbStepNotask:
1055                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepNotask, limitDate);
1056                         nbCountStepNotask = DbTaskRunner.getResultCountPrepareStatement(countStepNotask);
1057                         updateDetailedValue(entry.ordinal(), nbCountStepNotask);
1058                         return;
1059                     case nbStepPretask:
1060                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepPretask, limitDate);
1061                         nbCountStepPretask = DbTaskRunner.getResultCountPrepareStatement(countStepPretask);
1062                         updateDetailedValue(entry.ordinal(), nbCountStepPretask);
1063                         return;
1064                     case nbStepTransfer:
1065                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepTransfer, limitDate);
1066                         nbCountStepTransfer = DbTaskRunner.getResultCountPrepareStatement(countStepTransfer);
1067                         updateDetailedValue(entry.ordinal(), nbCountStepTransfer);
1068                         return;
1069                     case nbStepPosttask:
1070                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepPosttask, limitDate);
1071                         nbCountStepPosttask = DbTaskRunner.getResultCountPrepareStatement(countStepPosttask);
1072                         updateDetailedValue(entry.ordinal(), nbCountStepPosttask);
1073                         return;
1074                     case nbStepAllDone:
1075                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepAllDone, limitDate);
1076                         nbCountStepAllDone = DbTaskRunner.getResultCountPrepareStatement(countStepAllDone);
1077                         updateDetailedValue(entry.ordinal(), nbCountStepAllDone);
1078                         return;
1079                     case nbStepError:
1080                         DbTaskRunner.finishSelectOrCountPrepareStatement(countStepError, limitDate);
1081                         nbCountStepError = DbTaskRunner.getResultCountPrepareStatement(countStepError);
1082                         updateDetailedValue(entry.ordinal(), nbCountStepError);
1083                         return;
1084                     case nbAllRunningStep:
1085                         DbTaskRunner.finishSelectOrCountPrepareStatement(countAllRunningStep, limitDate);
1086                         nbCountAllRunningStep = DbTaskRunner.getResultCountPrepareStatement(countAllRunningStep);
1087                         updateDetailedValue(entry.ordinal(), nbCountAllRunningStep);
1088                         return;
1089                     case nbRunningStep:
1090                         DbTaskRunner.finishSelectOrCountPrepareStatement(countRunningStep, limitDate);
1091                         nbCountRunningStep = DbTaskRunner.getResultCountPrepareStatement(countRunningStep);
1092                         updateDetailedValue(entry.ordinal(), nbCountRunningStep);
1093                         return;
1094                     case nbInitOkStep:
1095                         DbTaskRunner.finishSelectOrCountPrepareStatement(countInitOkStep, limitDate);
1096                         nbCountInitOkStep = DbTaskRunner.getResultCountPrepareStatement(countInitOkStep);
1097                         updateDetailedValue(entry.ordinal(), nbCountInitOkStep);
1098                         return;
1099                     case nbPreProcessingOkStep:
1100                         DbTaskRunner.finishSelectOrCountPrepareStatement(countPreProcessingOkStep, limitDate);
1101                         nbCountPreProcessingOkStep = DbTaskRunner.getResultCountPrepareStatement(countPreProcessingOkStep);
1102                         updateDetailedValue(entry.ordinal(), nbCountPreProcessingOkStep);
1103                         return;
1104                     case nbTransferOkStep:
1105                         DbTaskRunner.finishSelectOrCountPrepareStatement(countTransferOkStep, limitDate);
1106                         nbCountTransferOkStep = DbTaskRunner.getResultCountPrepareStatement(countTransferOkStep);
1107                         updateDetailedValue(entry.ordinal(), nbCountTransferOkStep);
1108                         return;
1109                     case nbPostProcessingOkStep:
1110                         DbTaskRunner.finishSelectOrCountPrepareStatement(countPostProcessingOkStep, limitDate);
1111                         nbCountPostProcessingOkStep = DbTaskRunner.getResultCountPrepareStatement(countPostProcessingOkStep);
1112                         updateDetailedValue(entry.ordinal(), nbCountPostProcessingOkStep);
1113                         return;
1114                     case nbCompleteOkStep:
1115                         DbTaskRunner.finishSelectOrCountPrepareStatement(countCompleteOkStep, limitDate);
1116                         nbCountCompleteOkStep = DbTaskRunner.getResultCountPrepareStatement(countCompleteOkStep);
1117                         updateDetailedValue(entry.ordinal(), nbCountCompleteOkStep);
1118                         return;
1119                 }
1120             } catch (GoldenGateDatabaseNoConnectionException e) {
1121                 logger.info("Database No Connection Error: Cannot execute Monitoring", e);
1122                 try {
1123                     DbModelFactory.dbModel.validConnection(dbSession);
1124                 } catch (GoldenGateDatabaseNoConnectionException e1) {
1125                 }
1126             } catch (GoldenGateDatabaseSqlException e) {
1127                 logger.info("Database No Connection Error: Cannot execute Monitoring", e);
1128                 try {
1129                     DbModelFactory.dbModel.validConnection(dbSession);
1130                 } catch (GoldenGateDatabaseNoConnectionException e1) {
1131                 }
1132             }
1133         }
1134     }
1135     /**
1136      * Update a value in Error MIB part
1137      * @param nbMs
1138      * @param entry
1139      */
1140     protected void run(long nbMs, goldenGateErrorValuesIndex entry) {
1141         synchronized (trafficCounter) {
1142             long limitDate = System.currentTimeMillis()-nbMs;
1143             if (dbSession == null || dbSession.isDisconnected) {
1144                 return;
1145             }
1146             //Error
1147             switch (entry) {
1148                 case nbStatusConnectionImpossible:
1149                     nbCountStatusConnectionImpossible = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1150                             ErrorCode.ConnectionImpossible, limitDate);
1151                     updateErrorValue(entry.ordinal(), nbCountStatusConnectionImpossible);
1152                     return;
1153                 case nbStatusServerOverloaded:
1154                     nbCountStatusServerOverloaded = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1155                             ErrorCode.ServerOverloaded, limitDate);
1156                     updateErrorValue(entry.ordinal(), nbCountStatusServerOverloaded);
1157                     return;
1158                 case nbStatusBadAuthent:
1159                     nbCountStatusBadAuthent = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1160                             ErrorCode.BadAuthent, limitDate);
1161                     updateErrorValue(entry.ordinal(), nbCountStatusBadAuthent);
1162                     return;
1163                 case nbStatusExternalOp:
1164                     nbCountStatusExternalOp = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1165                             ErrorCode.ExternalOp, limitDate);
1166                     updateErrorValue(entry.ordinal(), nbCountStatusExternalOp);
1167                     return;
1168                 case nbStatusTransferError:
1169                     nbCountStatusTransferError = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1170                             ErrorCode.TransferError, limitDate);
1171                     updateErrorValue(entry.ordinal(), nbCountStatusTransferError);
1172                     return;
1173                 case nbStatusMD5Error:
1174                     nbCountStatusMD5Error = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1175                             ErrorCode.MD5Error, limitDate);
1176                     updateErrorValue(entry.ordinal(), nbCountStatusMD5Error);
1177                     return;
1178                 case nbStatusDisconnection:
1179                     nbCountStatusDisconnection = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1180                             ErrorCode.Disconnection, limitDate);
1181                     updateErrorValue(entry.ordinal(), nbCountStatusDisconnection);
1182                     return;
1183                 case nbStatusFinalOp:
1184                     nbCountStatusFinalOp = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1185                             ErrorCode.FinalOp, limitDate);
1186                     updateErrorValue(entry.ordinal(), nbCountStatusFinalOp);
1187                     return;
1188                 case nbStatusUnimplemented:
1189                     nbCountStatusUnimplemented = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1190                             ErrorCode.Unimplemented, limitDate);
1191                     updateErrorValue(entry.ordinal(), nbCountStatusUnimplemented);
1192                     return;
1193                 case nbStatusInternal:
1194                     nbCountStatusInternal = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1195                             ErrorCode.Internal, limitDate);
1196                     updateErrorValue(entry.ordinal(), nbCountStatusInternal);
1197                     return;
1198                 case nbStatusWarning:
1199                     nbCountStatusWarning = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1200                             ErrorCode.Warning, limitDate);
1201                     updateErrorValue(entry.ordinal(), nbCountStatusWarning);
1202                     return;
1203                 case nbStatusQueryAlreadyFinished:
1204                     nbCountStatusQueryAlreadyFinished = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1205                             ErrorCode.QueryAlreadyFinished, limitDate);
1206                     updateErrorValue(entry.ordinal(), nbCountStatusQueryAlreadyFinished);
1207                     return;
1208                 case nbStatusQueryStillRunning:
1209                     nbCountStatusQueryStillRunning = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1210                             ErrorCode.QueryStillRunning, limitDate);
1211                     updateErrorValue(entry.ordinal(), nbCountStatusQueryStillRunning);
1212                     return;
1213                 case nbStatusNotKnownHost:
1214                     nbCountStatusNotKnownHost = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1215                             ErrorCode.NotKnownHost, limitDate);
1216                     updateErrorValue(entry.ordinal(), nbCountStatusNotKnownHost);
1217                     return;
1218                 case nbStatusQueryRemotelyUnknown:
1219                     nbCountStatusQueryRemotelyUnknown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1220                             ErrorCode.QueryRemotelyUnknown, limitDate);
1221                     updateErrorValue(entry.ordinal(), nbCountStatusQueryRemotelyUnknown);
1222                     return;
1223                 case nbStatusCommandNotFound:
1224                     nbCountStatusCommandNotFound = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1225                             ErrorCode.CommandNotFound, limitDate);
1226                     updateErrorValue(entry.ordinal(), nbCountStatusCommandNotFound);
1227                     return;
1228                 case nbStatusPassThroughMode:
1229                     nbCountStatusPassThroughMode = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1230                             ErrorCode.PassThroughMode, limitDate);
1231                     updateErrorValue(entry.ordinal(), nbCountStatusPassThroughMode);
1232                     return;
1233                 case nbStatusRemoteShutdown:
1234                     nbCountStatusRemoteShutdown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1235                             ErrorCode.RemoteShutdown, limitDate);
1236                     updateErrorValue(entry.ordinal(), nbCountStatusRemoteShutdown);
1237                     return;
1238                 case nbStatusShutdown:
1239                     nbCountStatusShutdown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1240                             ErrorCode.Shutdown, limitDate);
1241                     updateErrorValue(entry.ordinal(), nbCountStatusShutdown);
1242                     return;
1243                 case nbStatusRemoteError:
1244                     nbCountStatusRemoteError = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1245                             ErrorCode.RemoteError, limitDate);
1246                     updateErrorValue(entry.ordinal(), nbCountStatusRemoteError);
1247                     return;
1248                 case nbStatusStopped:
1249                     nbCountStatusStopped = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1250                             ErrorCode.StoppedTransfer, limitDate);
1251                     updateErrorValue(entry.ordinal(), nbCountStatusStopped);
1252                     return;
1253                 case nbStatusCanceled:
1254                     nbCountStatusCanceled = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1255                             ErrorCode.CanceledTransfer, limitDate);
1256                     updateErrorValue(entry.ordinal(), nbCountStatusCanceled);
1257                     return;
1258                 case nbStatusFileNotFound:
1259                     nbCountStatusFileNotFound = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1260                             ErrorCode.FileNotFound, limitDate);
1261                     updateErrorValue(entry.ordinal(), nbCountStatusFileNotFound);
1262                     return;
1263                 case nbStatusUnknown:
1264                     nbCountStatusUnknown = DbTaskRunner.getResultCountPrepareStatement(countStatus,
1265                             ErrorCode.Unknown, limitDate);
1266                     updateErrorValue(entry.ordinal(), nbCountStatusUnknown);
1267                     return;
1268             }
1269         }
1270     }
1271 }