1 |
|
package org.apache.jcs.auxiliary.disk.jdbc; |
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
|
22 |
|
import java.io.IOException; |
23 |
|
import java.io.Serializable; |
24 |
|
import java.sql.Connection; |
25 |
|
import java.sql.Date; |
26 |
|
import java.sql.PreparedStatement; |
27 |
|
import java.sql.ResultSet; |
28 |
|
import java.sql.SQLException; |
29 |
|
import java.sql.Statement; |
30 |
|
import java.util.ArrayList; |
31 |
|
import java.util.Arrays; |
32 |
|
import java.util.List; |
33 |
|
import java.util.Set; |
34 |
|
|
35 |
|
import org.apache.commons.logging.Log; |
36 |
|
import org.apache.commons.logging.LogFactory; |
37 |
|
import org.apache.jcs.auxiliary.AuxiliaryCacheAttributes; |
38 |
|
import org.apache.jcs.auxiliary.disk.AbstractDiskCache; |
39 |
|
import org.apache.jcs.engine.CacheConstants; |
40 |
|
import org.apache.jcs.engine.behavior.ICacheElement; |
41 |
|
import org.apache.jcs.engine.behavior.IElementSerializer; |
42 |
|
import org.apache.jcs.engine.stats.StatElement; |
43 |
|
import org.apache.jcs.engine.stats.behavior.IStatElement; |
44 |
|
import org.apache.jcs.engine.stats.behavior.IStats; |
45 |
|
import org.apache.jcs.utils.serialization.StandardSerializer; |
46 |
|
|
47 |
|
|
48 |
|
|
49 |
|
|
50 |
|
|
51 |
|
|
52 |
|
|
53 |
|
|
54 |
|
|
55 |
|
|
56 |
|
|
57 |
|
|
58 |
|
|
59 |
|
|
60 |
|
|
61 |
|
|
62 |
|
|
63 |
|
|
64 |
|
|
65 |
|
|
66 |
|
|
67 |
|
|
68 |
|
|
69 |
|
|
70 |
|
|
71 |
|
|
72 |
|
|
73 |
|
|
74 |
|
|
75 |
|
|
76 |
|
|
77 |
|
|
78 |
|
|
79 |
|
|
80 |
|
|
81 |
|
public class JDBCDiskCache |
82 |
|
extends AbstractDiskCache |
83 |
|
{ |
84 |
70 |
private final static Log log = LogFactory.getLog( JDBCDiskCache.class ); |
85 |
|
|
86 |
|
private static final long serialVersionUID = -7169488308515823492L; |
87 |
|
|
88 |
49 |
private IElementSerializer elementSerializer = new StandardSerializer(); |
89 |
|
|
90 |
|
private JDBCDiskCacheAttributes jdbcDiskCacheAttributes; |
91 |
|
|
92 |
49 |
private int updateCount = 0; |
93 |
|
|
94 |
49 |
private int getCount = 0; |
95 |
|
|
96 |
|
|
97 |
|
private static final int LOG_INTERVAL = 100; |
98 |
|
|
99 |
49 |
private JDBCDiskCachePoolAccess poolAccess = null; |
100 |
|
|
101 |
|
private TableState tableState; |
102 |
|
|
103 |
|
|
104 |
|
|
105 |
|
|
106 |
|
|
107 |
|
|
108 |
|
|
109 |
|
|
110 |
|
public JDBCDiskCache( JDBCDiskCacheAttributes cattr, TableState tableState ) |
111 |
|
{ |
112 |
49 |
super( cattr ); |
113 |
|
|
114 |
49 |
this.setTableState( tableState ); |
115 |
|
|
116 |
49 |
setJdbcDiskCacheAttributes( cattr ); |
117 |
|
|
118 |
49 |
if ( log.isInfoEnabled() ) |
119 |
|
{ |
120 |
49 |
log.info( "jdbcDiskCacheAttributes = " + getJdbcDiskCacheAttributes() ); |
121 |
|
} |
122 |
|
|
123 |
|
|
124 |
|
|
125 |
|
|
126 |
49 |
initializePoolAccess( cattr ); |
127 |
|
|
128 |
|
|
129 |
49 |
alive = true; |
130 |
49 |
} |
131 |
|
|
132 |
|
|
133 |
|
|
134 |
|
|
135 |
|
|
136 |
|
protected void initializePoolAccess( JDBCDiskCacheAttributes cattr ) |
137 |
|
{ |
138 |
|
try |
139 |
|
{ |
140 |
|
try |
141 |
|
{ |
142 |
|
|
143 |
49 |
Class.forName( cattr.getDriverClassName() ); |
144 |
|
} |
145 |
0 |
catch ( ClassNotFoundException e ) |
146 |
|
{ |
147 |
0 |
log.error( "Couldn't find class for driver [" + cattr.getDriverClassName() + "]", e ); |
148 |
49 |
} |
149 |
|
|
150 |
49 |
poolAccess = new JDBCDiskCachePoolAccess( cattr.getName() ); |
151 |
|
|
152 |
49 |
poolAccess.setupDriver( cattr.getUrl() + cattr.getDatabase(), cattr.getUserName(), cattr.getPassword(), |
153 |
|
cattr.getMaxActive() ); |
154 |
|
|
155 |
49 |
poolAccess.logDriverStats(); |
156 |
|
} |
157 |
0 |
catch ( Exception e ) |
158 |
|
{ |
159 |
0 |
log.error( "Problem getting connection.", e ); |
160 |
49 |
} |
161 |
49 |
} |
162 |
|
|
163 |
|
|
164 |
|
|
165 |
|
|
166 |
|
|
167 |
|
public void doUpdate( ICacheElement ce ) |
168 |
|
{ |
169 |
6355 |
incrementUpdateCount(); |
170 |
|
|
171 |
6356 |
if ( log.isDebugEnabled() ) |
172 |
|
{ |
173 |
0 |
log.debug( "updating, ce = " + ce ); |
174 |
|
} |
175 |
|
|
176 |
|
Connection con; |
177 |
|
try |
178 |
|
{ |
179 |
6351 |
con = poolAccess.getConnection(); |
180 |
|
} |
181 |
0 |
catch ( SQLException e ) |
182 |
|
{ |
183 |
0 |
log.error( "Problem getting conenction.", e ); |
184 |
0 |
return; |
185 |
6356 |
} |
186 |
|
|
187 |
|
try |
188 |
|
{ |
189 |
|
|
190 |
6356 |
Statement sStatement = null; |
191 |
|
try |
192 |
|
{ |
193 |
6356 |
sStatement = con.createStatement(); |
194 |
6356 |
alive = true; |
195 |
|
} |
196 |
0 |
catch ( SQLException e ) |
197 |
|
{ |
198 |
0 |
log.error( "Problem creating statement.", e ); |
199 |
0 |
alive = false; |
200 |
|
} |
201 |
|
finally |
202 |
|
{ |
203 |
0 |
try |
204 |
|
{ |
205 |
6355 |
sStatement.close(); |
206 |
|
} |
207 |
0 |
catch ( SQLException e ) |
208 |
|
{ |
209 |
0 |
log.error( "Problem closing statement.", e ); |
210 |
6356 |
} |
211 |
0 |
} |
212 |
|
|
213 |
6356 |
if ( !alive ) |
214 |
|
{ |
215 |
0 |
if ( log.isInfoEnabled() ) |
216 |
|
{ |
217 |
0 |
log.info( "Disk is not alive, aborting put." ); |
218 |
|
} |
219 |
|
return; |
220 |
|
} |
221 |
|
|
222 |
6356 |
if ( log.isDebugEnabled() ) |
223 |
|
{ |
224 |
0 |
log.debug( "Putting [" + ce.getKey() + "] on disk." ); |
225 |
|
} |
226 |
|
|
227 |
|
byte[] element; |
228 |
|
|
229 |
|
try |
230 |
|
{ |
231 |
6356 |
element = serialize( ce ); |
232 |
|
} |
233 |
0 |
catch ( IOException e ) |
234 |
|
{ |
235 |
0 |
log.error( "Could not serialize element", e ); |
236 |
|
return; |
237 |
6355 |
} |
238 |
|
|
239 |
6355 |
boolean exists = false; |
240 |
|
|
241 |
|
|
242 |
6354 |
if ( this.getJdbcDiskCacheAttributes().isTestBeforeInsert() ) |
243 |
|
{ |
244 |
0 |
exists = doesElementExist( ce ); |
245 |
|
} |
246 |
|
|
247 |
|
|
248 |
6355 |
if ( !exists ) |
249 |
|
{ |
250 |
|
try |
251 |
|
{ |
252 |
6353 |
String sqlI = "insert into " |
253 |
|
+ getJdbcDiskCacheAttributes().getTableName() |
254 |
|
+ " (CACHE_KEY, REGION, ELEMENT, MAX_LIFE_SECONDS, IS_ETERNAL, CREATE_TIME, CREATE_TIME_SECONDS, SYSTEM_EXPIRE_TIME_SECONDS) " |
255 |
|
+ " values (?, ?, ?, ?, ?, ?, ?, ?)"; |
256 |
|
|
257 |
6356 |
PreparedStatement psInsert = con.prepareStatement( sqlI ); |
258 |
6355 |
psInsert.setString( 1, (String) ce.getKey() ); |
259 |
6356 |
psInsert.setString( 2, this.getCacheName() ); |
260 |
6355 |
psInsert.setBytes( 3, element ); |
261 |
6355 |
psInsert.setLong( 4, ce.getElementAttributes().getMaxLifeSeconds() ); |
262 |
6355 |
if ( ce.getElementAttributes().getIsEternal() ) |
263 |
|
{ |
264 |
1407 |
psInsert.setString( 5, "T" ); |
265 |
1407 |
} |
266 |
|
else |
267 |
|
{ |
268 |
4949 |
psInsert.setString( 5, "F" ); |
269 |
|
} |
270 |
6355 |
Date createTime = new Date( ce.getElementAttributes().getCreateTime() ); |
271 |
6355 |
psInsert.setDate( 6, createTime ); |
272 |
|
|
273 |
6356 |
long now = System.currentTimeMillis() / 1000; |
274 |
6355 |
psInsert.setLong( 7, now ); |
275 |
|
|
276 |
6356 |
long expireTime = now + ce.getElementAttributes().getMaxLifeSeconds(); |
277 |
6356 |
psInsert.setLong( 8, expireTime ); |
278 |
|
|
279 |
6356 |
psInsert.execute(); |
280 |
5635 |
psInsert.close(); |
281 |
|
} |
282 |
721 |
catch ( SQLException e ) |
283 |
|
{ |
284 |
721 |
if ( e.toString().indexOf( "Violation of unique index" ) != -1 |
285 |
|
|| e.getMessage().indexOf( "Violation of unique index" ) != -1 |
286 |
|
|| e.getMessage().indexOf( "Duplicate entry" ) != -1 ) |
287 |
|
{ |
288 |
0 |
exists = true; |
289 |
0 |
} |
290 |
|
else |
291 |
|
{ |
292 |
721 |
log.error( "Could not insert element", e ); |
293 |
|
} |
294 |
|
|
295 |
|
|
296 |
721 |
if ( !exists && !this.getJdbcDiskCacheAttributes().isTestBeforeInsert() ) |
297 |
|
{ |
298 |
721 |
exists = doesElementExist( ce ); |
299 |
|
} |
300 |
5635 |
} |
301 |
|
} |
302 |
|
|
303 |
|
|
304 |
6356 |
if ( exists ) |
305 |
|
{ |
306 |
721 |
String sqlU = null; |
307 |
|
try |
308 |
|
{ |
309 |
721 |
sqlU = "update " + getJdbcDiskCacheAttributes().getTableName() |
310 |
|
+ " set ELEMENT = ?, CREATE_TIME = ?, CREATE_TIME_SECONDS = ?, " |
311 |
|
+ " SYSTEM_EXPIRE_TIME_SECONDS = ? " + " where CACHE_KEY = ? and REGION = ?"; |
312 |
721 |
PreparedStatement psUpdate = con.prepareStatement( sqlU ); |
313 |
721 |
psUpdate.setBytes( 1, element ); |
314 |
|
|
315 |
721 |
Date createTime = new Date( ce.getElementAttributes().getCreateTime() ); |
316 |
721 |
psUpdate.setDate( 2, createTime ); |
317 |
|
|
318 |
721 |
long now = System.currentTimeMillis() / 1000; |
319 |
721 |
psUpdate.setLong( 3, now ); |
320 |
|
|
321 |
721 |
long expireTime = now + ce.getElementAttributes().getMaxLifeSeconds(); |
322 |
721 |
psUpdate.setLong( 4, expireTime ); |
323 |
|
|
324 |
721 |
psUpdate.setString( 5, (String) ce.getKey() ); |
325 |
721 |
psUpdate.setString( 6, this.getCacheName() ); |
326 |
721 |
psUpdate.execute(); |
327 |
721 |
psUpdate.close(); |
328 |
|
|
329 |
721 |
if ( log.isDebugEnabled() ) |
330 |
|
{ |
331 |
0 |
log.debug( "ran update " + sqlU ); |
332 |
|
} |
333 |
|
} |
334 |
0 |
catch ( SQLException e2 ) |
335 |
|
{ |
336 |
0 |
log.error( "e2 sql [" + sqlU + "] Exception: ", e2 ); |
337 |
721 |
} |
338 |
|
} |
339 |
|
} |
340 |
|
finally |
341 |
|
{ |
342 |
0 |
try |
343 |
|
{ |
344 |
6354 |
con.close(); |
345 |
|
} |
346 |
0 |
catch ( SQLException e ) |
347 |
|
{ |
348 |
0 |
log.error( "Problem closing connection.", e ); |
349 |
6355 |
} |
350 |
0 |
} |
351 |
|
|
352 |
6356 |
if ( log.isInfoEnabled() ) |
353 |
|
{ |
354 |
6356 |
if ( updateCount % LOG_INTERVAL == 0 ) |
355 |
|
{ |
356 |
|
|
357 |
70 |
log.info( "Update Count [" + updateCount + "]" ); |
358 |
|
} |
359 |
|
} |
360 |
6356 |
} |
361 |
|
|
362 |
|
|
363 |
|
|
364 |
|
|
365 |
|
|
366 |
|
|
367 |
|
|
368 |
|
protected boolean doesElementExist( ICacheElement ce ) |
369 |
|
{ |
370 |
721 |
boolean exists = false; |
371 |
|
|
372 |
|
Connection con; |
373 |
|
try |
374 |
|
{ |
375 |
721 |
con = poolAccess.getConnection(); |
376 |
|
} |
377 |
0 |
catch ( SQLException e ) |
378 |
|
{ |
379 |
0 |
log.error( "Problem getting conenction.", e ); |
380 |
0 |
return exists; |
381 |
721 |
} |
382 |
|
|
383 |
721 |
PreparedStatement psSelect = null; |
384 |
|
try |
385 |
|
{ |
386 |
|
|
387 |
721 |
String sqlS = "select CACHE_KEY from " + getJdbcDiskCacheAttributes().getTableName() |
388 |
|
+ " where REGION = ? and CACHE_KEY = ?"; |
389 |
|
|
390 |
721 |
psSelect = con.prepareStatement( sqlS ); |
391 |
721 |
psSelect.setString( 1, this.getCacheName() ); |
392 |
721 |
psSelect.setString( 2, (String) ce.getKey() ); |
393 |
|
|
394 |
721 |
ResultSet rs = psSelect.executeQuery(); |
395 |
|
|
396 |
721 |
if ( rs.next() ) |
397 |
|
{ |
398 |
721 |
exists = true; |
399 |
|
} |
400 |
|
|
401 |
721 |
if ( log.isDebugEnabled() ) |
402 |
|
{ |
403 |
0 |
log.debug( "[" + ce.getKey() + "] existing status is " + exists ); |
404 |
|
} |
405 |
|
|
406 |
721 |
rs.close(); |
407 |
|
} |
408 |
0 |
catch ( SQLException e ) |
409 |
|
{ |
410 |
0 |
log.error( "Problem looking for item before insert.", e ); |
411 |
|
} |
412 |
|
finally |
413 |
|
{ |
414 |
0 |
try |
415 |
|
{ |
416 |
721 |
if ( psSelect != null ) |
417 |
|
{ |
418 |
721 |
psSelect.close(); |
419 |
|
} |
420 |
721 |
psSelect.close(); |
421 |
|
} |
422 |
0 |
catch ( SQLException e1 ) |
423 |
|
{ |
424 |
0 |
log.error( "Problem closing statement.", e1 ); |
425 |
721 |
} |
426 |
|
|
427 |
|
try |
428 |
|
{ |
429 |
721 |
con.close(); |
430 |
|
} |
431 |
0 |
catch ( SQLException e ) |
432 |
|
{ |
433 |
0 |
log.error( "Problem closing connection.", e ); |
434 |
721 |
} |
435 |
0 |
} |
436 |
|
|
437 |
721 |
return exists; |
438 |
|
} |
439 |
|
|
440 |
|
|
441 |
|
|
442 |
|
|
443 |
|
|
444 |
|
|
445 |
|
|
446 |
|
public ICacheElement doGet( Serializable key ) |
447 |
|
{ |
448 |
10080 |
incrementGetCount(); |
449 |
|
|
450 |
10080 |
if ( log.isDebugEnabled() ) |
451 |
|
{ |
452 |
0 |
log.debug( "Getting " + key + " from disk" ); |
453 |
|
} |
454 |
|
|
455 |
10080 |
if ( !alive ) |
456 |
|
{ |
457 |
0 |
return null; |
458 |
|
} |
459 |
|
|
460 |
10080 |
ICacheElement obj = null; |
461 |
|
|
462 |
10080 |
byte[] data = null; |
463 |
|
try |
464 |
|
{ |
465 |
|
|
466 |
10080 |
String selectString = "select ELEMENT from " + getJdbcDiskCacheAttributes().getTableName() |
467 |
|
+ " where REGION = ? and CACHE_KEY = ?"; |
468 |
|
|
469 |
10080 |
Connection con = poolAccess.getConnection(); |
470 |
|
try |
471 |
|
{ |
472 |
10080 |
PreparedStatement psSelect = null; |
473 |
|
try |
474 |
|
{ |
475 |
10080 |
psSelect = con.prepareStatement( selectString ); |
476 |
10080 |
psSelect.setString( 1, this.getCacheName() ); |
477 |
10080 |
psSelect.setString( 2, key.toString() ); |
478 |
|
|
479 |
10080 |
ResultSet rs = psSelect.executeQuery(); |
480 |
|
try |
481 |
|
{ |
482 |
10080 |
if ( rs.next() ) |
483 |
|
{ |
484 |
5434 |
data = rs.getBytes( 1 ); |
485 |
|
} |
486 |
10080 |
if ( data != null ) |
487 |
|
{ |
488 |
|
try |
489 |
|
{ |
490 |
|
|
491 |
5434 |
obj = (ICacheElement) getElementSerializer().deSerialize( data ); |
492 |
|
} |
493 |
0 |
catch ( IOException ioe ) |
494 |
|
{ |
495 |
0 |
log.error( ioe ); |
496 |
|
} |
497 |
0 |
catch ( Exception e ) |
498 |
|
{ |
499 |
0 |
log.error( "Problem getting item.", e ); |
500 |
5434 |
} |
501 |
|
} |
502 |
|
} |
503 |
|
finally |
504 |
|
{ |
505 |
10080 |
if ( rs != null ) |
506 |
|
{ |
507 |
10080 |
rs.close(); |
508 |
|
} |
509 |
10080 |
rs.close(); |
510 |
10080 |
} |
511 |
|
} |
512 |
|
finally |
513 |
|
{ |
514 |
10080 |
if ( psSelect != null ) |
515 |
|
{ |
516 |
10080 |
psSelect.close(); |
517 |
|
} |
518 |
10080 |
psSelect.close(); |
519 |
10080 |
} |
520 |
|
} |
521 |
|
finally |
522 |
|
{ |
523 |
10080 |
if ( con != null ) |
524 |
|
{ |
525 |
10080 |
con.close(); |
526 |
10080 |
} |
527 |
0 |
} |
528 |
|
} |
529 |
0 |
catch ( SQLException sqle ) |
530 |
|
{ |
531 |
0 |
log.error( sqle ); |
532 |
10080 |
} |
533 |
|
|
534 |
10080 |
if ( log.isInfoEnabled() ) |
535 |
|
{ |
536 |
10080 |
if ( getCount % LOG_INTERVAL == 0 ) |
537 |
|
{ |
538 |
|
|
539 |
98 |
log.info( "Get Count [" + getCount + "]" ); |
540 |
|
} |
541 |
|
} |
542 |
|
|
543 |
10080 |
return obj; |
544 |
|
} |
545 |
|
|
546 |
|
|
547 |
|
|
548 |
|
|
549 |
|
|
550 |
|
|
551 |
|
|
552 |
|
|
553 |
|
public boolean doRemove( Serializable key ) |
554 |
|
{ |
555 |
|
|
556 |
5651 |
String sql = "delete from " + getJdbcDiskCacheAttributes().getTableName() |
557 |
|
+ " where REGION = ? and CACHE_KEY = ?"; |
558 |
|
|
559 |
|
try |
560 |
|
{ |
561 |
5651 |
boolean partial = false; |
562 |
5651 |
if ( key instanceof String && key.toString().endsWith( CacheConstants.NAME_COMPONENT_DELIMITER ) ) |
563 |
|
{ |
564 |
|
|
565 |
7 |
sql = "delete from " + getJdbcDiskCacheAttributes().getTableName() |
566 |
|
+ " where REGION = ? and CACHE_KEY like ?"; |
567 |
7 |
partial = true; |
568 |
|
} |
569 |
5651 |
Connection con = poolAccess.getConnection(); |
570 |
5651 |
PreparedStatement psSelect = null; |
571 |
|
try |
572 |
|
{ |
573 |
5651 |
psSelect = con.prepareStatement( sql ); |
574 |
5651 |
psSelect.setString( 1, this.getCacheName() ); |
575 |
5651 |
if ( partial ) |
576 |
|
{ |
577 |
7 |
psSelect.setString( 2, key.toString() + "%" ); |
578 |
7 |
} |
579 |
|
else |
580 |
|
{ |
581 |
5644 |
psSelect.setString( 2, key.toString() ); |
582 |
|
} |
583 |
|
|
584 |
5651 |
psSelect.executeUpdate( ); |
585 |
|
|
586 |
5651 |
alive = true; |
587 |
|
} |
588 |
0 |
catch ( SQLException e ) |
589 |
|
{ |
590 |
0 |
log.error( "Problem creating statement. sql [" + sql + "]", e ); |
591 |
0 |
alive = false; |
592 |
|
} |
593 |
|
finally |
594 |
|
{ |
595 |
0 |
try |
596 |
|
{ |
597 |
5651 |
if ( psSelect != null ) |
598 |
|
{ |
599 |
5651 |
psSelect.close(); |
600 |
|
} |
601 |
5651 |
con.close(); |
602 |
|
} |
603 |
0 |
catch ( SQLException e1 ) |
604 |
|
{ |
605 |
0 |
log.error( "Problem closing statement.", e1 ); |
606 |
5651 |
} |
607 |
0 |
} |
608 |
|
|
609 |
|
} |
610 |
0 |
catch ( Exception e ) |
611 |
|
{ |
612 |
0 |
log.error( "Problem updating cache.", e ); |
613 |
0 |
reset(); |
614 |
5651 |
} |
615 |
5651 |
return false; |
616 |
|
} |
617 |
|
|
618 |
|
|
619 |
|
public void doRemoveAll() |
620 |
|
{ |
621 |
|
|
622 |
0 |
if ( this.jdbcDiskCacheAttributes.isAllowRemoveAll() ) |
623 |
|
{ |
624 |
|
try |
625 |
|
{ |
626 |
0 |
String sql = "delete from " + getJdbcDiskCacheAttributes().getTableName() + " where REGION = ?"; |
627 |
0 |
Connection con = poolAccess.getConnection(); |
628 |
0 |
PreparedStatement psDelete = null; |
629 |
|
try |
630 |
|
{ |
631 |
0 |
psDelete = con.prepareStatement( sql ); |
632 |
0 |
psDelete.setString( 1, this.getCacheName() ); |
633 |
0 |
alive = true; |
634 |
0 |
psDelete.executeUpdate( ); |
635 |
|
} |
636 |
0 |
catch ( SQLException e ) |
637 |
|
{ |
638 |
0 |
log.error( "Problem creating statement.", e ); |
639 |
0 |
alive = false; |
640 |
|
} |
641 |
|
finally |
642 |
|
{ |
643 |
0 |
try |
644 |
|
{ |
645 |
0 |
if ( psDelete != null ) |
646 |
|
{ |
647 |
0 |
psDelete.close(); |
648 |
|
} |
649 |
0 |
con.close(); |
650 |
|
} |
651 |
0 |
catch ( SQLException e1 ) |
652 |
|
{ |
653 |
0 |
log.error( "Problem closing statement.", e1 ); |
654 |
0 |
} |
655 |
0 |
} |
656 |
|
} |
657 |
0 |
catch ( Exception e ) |
658 |
|
{ |
659 |
0 |
log.error( "Problem removing all.", e ); |
660 |
0 |
reset(); |
661 |
0 |
} |
662 |
0 |
} |
663 |
|
else |
664 |
|
{ |
665 |
0 |
if ( log.isInfoEnabled() ) |
666 |
|
{ |
667 |
0 |
log.info( "RemoveAll was requested but the request was not fulfilled: allowRemoveAll is set to false." ); |
668 |
|
} |
669 |
|
} |
670 |
0 |
} |
671 |
|
|
672 |
|
|
673 |
|
|
674 |
|
|
675 |
|
|
676 |
|
|
677 |
|
protected int deleteExpired() |
678 |
|
{ |
679 |
26 |
int deleted = 0; |
680 |
|
|
681 |
|
try |
682 |
|
{ |
683 |
26 |
getTableState().setState( TableState.DELETE_RUNNING ); |
684 |
|
|
685 |
26 |
long now = System.currentTimeMillis() / 1000; |
686 |
|
|
687 |
|
|
688 |
|
|
689 |
|
|
690 |
|
|
691 |
|
|
692 |
|
|
693 |
26 |
String sql = "delete from " + getJdbcDiskCacheAttributes().getTableName() |
694 |
|
+ " where IS_ETERNAL = ? and REGION = ? and ? > SYSTEM_EXPIRE_TIME_SECONDS"; |
695 |
|
|
696 |
26 |
Connection con = poolAccess.getConnection(); |
697 |
26 |
PreparedStatement psDelete = null; |
698 |
|
try |
699 |
|
{ |
700 |
26 |
psDelete = con.prepareStatement( sql ); |
701 |
26 |
psDelete.setString( 1, "F" ); |
702 |
26 |
psDelete.setString( 2, this.getCacheName() ); |
703 |
26 |
psDelete.setLong( 3, now ); |
704 |
|
|
705 |
26 |
alive = true; |
706 |
|
|
707 |
26 |
deleted = psDelete.executeUpdate( ); |
708 |
|
} |
709 |
0 |
catch ( SQLException e ) |
710 |
|
{ |
711 |
0 |
log.error( "Problem creating statement.", e ); |
712 |
0 |
alive = false; |
713 |
|
} |
714 |
|
finally |
715 |
|
{ |
716 |
0 |
try |
717 |
|
{ |
718 |
26 |
if ( psDelete != null ) |
719 |
|
{ |
720 |
26 |
psDelete.close(); |
721 |
|
} |
722 |
26 |
con.close(); |
723 |
|
} |
724 |
0 |
catch ( SQLException e1 ) |
725 |
|
{ |
726 |
0 |
log.error( "Problem closing statement.", e1 ); |
727 |
26 |
} |
728 |
0 |
} |
729 |
|
} |
730 |
0 |
catch ( Exception e ) |
731 |
|
{ |
732 |
0 |
log.error( "Problem removing expired elements from the table.", e ); |
733 |
0 |
reset(); |
734 |
|
} |
735 |
|
finally |
736 |
|
{ |
737 |
26 |
getTableState().setState( TableState.FREE ); |
738 |
26 |
} |
739 |
|
|
740 |
26 |
return deleted; |
741 |
|
} |
742 |
|
|
743 |
|
|
744 |
|
|
745 |
|
|
746 |
|
|
747 |
|
public void reset() |
748 |
|
{ |
749 |
|
|
750 |
0 |
} |
751 |
|
|
752 |
|
|
753 |
|
public void doDispose() |
754 |
|
{ |
755 |
|
try |
756 |
|
{ |
757 |
0 |
poolAccess.shutdownDriver(); |
758 |
|
} |
759 |
0 |
catch ( Exception e ) |
760 |
|
{ |
761 |
0 |
log.error( "Problem shutting down.", e ); |
762 |
0 |
} |
763 |
0 |
} |
764 |
|
|
765 |
|
|
766 |
|
|
767 |
|
|
768 |
|
|
769 |
|
|
770 |
|
public int getSize() |
771 |
|
{ |
772 |
112 |
int size = 0; |
773 |
|
|
774 |
|
|
775 |
112 |
String selectString = "select count(*) from " + getJdbcDiskCacheAttributes().getTableName() |
776 |
|
+ " where REGION = ?"; |
777 |
|
|
778 |
|
Connection con; |
779 |
|
try |
780 |
|
{ |
781 |
112 |
con = poolAccess.getConnection(); |
782 |
|
} |
783 |
0 |
catch ( SQLException e1 ) |
784 |
|
{ |
785 |
0 |
log.error( "Problem getting conenction.", e1 ); |
786 |
0 |
return size; |
787 |
112 |
} |
788 |
|
try |
789 |
|
{ |
790 |
112 |
PreparedStatement psSelect = null; |
791 |
|
try |
792 |
|
{ |
793 |
112 |
psSelect = con.prepareStatement( selectString ); |
794 |
112 |
psSelect.setString( 1, this.getCacheName() ); |
795 |
112 |
ResultSet rs = null; |
796 |
|
|
797 |
112 |
rs = psSelect.executeQuery(); |
798 |
|
try |
799 |
|
{ |
800 |
112 |
if ( rs.next() ) |
801 |
|
{ |
802 |
112 |
size = rs.getInt( 1 ); |
803 |
|
} |
804 |
|
} |
805 |
|
finally |
806 |
|
{ |
807 |
112 |
if ( rs != null ) |
808 |
|
{ |
809 |
112 |
rs.close(); |
810 |
|
} |
811 |
112 |
rs.close(); |
812 |
112 |
} |
813 |
|
} |
814 |
|
finally |
815 |
|
{ |
816 |
112 |
if ( psSelect != null ) |
817 |
|
{ |
818 |
112 |
psSelect.close(); |
819 |
|
} |
820 |
112 |
psSelect.close(); |
821 |
112 |
} |
822 |
|
} |
823 |
0 |
catch ( SQLException e ) |
824 |
|
{ |
825 |
0 |
log.error( "Problem getting size.", e ); |
826 |
|
} |
827 |
|
finally |
828 |
|
{ |
829 |
0 |
try |
830 |
|
{ |
831 |
112 |
con.close(); |
832 |
|
} |
833 |
0 |
catch ( SQLException e ) |
834 |
|
{ |
835 |
0 |
log.error( "Problem closing connection.", e ); |
836 |
112 |
} |
837 |
0 |
} |
838 |
112 |
return size; |
839 |
|
} |
840 |
|
|
841 |
|
|
842 |
|
|
843 |
|
|
844 |
|
|
845 |
|
|
846 |
|
|
847 |
|
|
848 |
|
protected byte[] serialize( Serializable obj ) |
849 |
|
throws IOException |
850 |
|
{ |
851 |
6356 |
return getElementSerializer().serialize( obj ); |
852 |
|
} |
853 |
|
|
854 |
|
|
855 |
|
|
856 |
|
|
857 |
|
|
858 |
|
public Set getGroupKeys( String groupName ) |
859 |
|
{ |
860 |
|
if ( true ) |
861 |
|
{ |
862 |
0 |
throw new UnsupportedOperationException( "Groups not implemented." ); |
863 |
|
} |
864 |
|
return null; |
865 |
|
} |
866 |
|
|
867 |
|
|
868 |
|
|
869 |
|
|
870 |
|
|
871 |
|
public void setElementSerializer( IElementSerializer elementSerializer ) |
872 |
|
{ |
873 |
0 |
this.elementSerializer = elementSerializer; |
874 |
0 |
} |
875 |
|
|
876 |
|
|
877 |
|
|
878 |
|
|
879 |
|
public IElementSerializer getElementSerializer() |
880 |
|
{ |
881 |
11788 |
return elementSerializer; |
882 |
|
} |
883 |
|
|
884 |
|
|
885 |
|
private synchronized void incrementUpdateCount() |
886 |
|
{ |
887 |
6356 |
updateCount++; |
888 |
6356 |
} |
889 |
|
|
890 |
|
|
891 |
|
private synchronized void incrementGetCount() |
892 |
|
{ |
893 |
10080 |
getCount++; |
894 |
10080 |
} |
895 |
|
|
896 |
|
|
897 |
|
|
898 |
|
|
899 |
|
|
900 |
|
protected void setJdbcDiskCacheAttributes( JDBCDiskCacheAttributes jdbcDiskCacheAttributes ) |
901 |
|
{ |
902 |
49 |
this.jdbcDiskCacheAttributes = jdbcDiskCacheAttributes; |
903 |
49 |
} |
904 |
|
|
905 |
|
|
906 |
|
|
907 |
|
|
908 |
|
protected JDBCDiskCacheAttributes getJdbcDiskCacheAttributes() |
909 |
|
{ |
910 |
30847 |
return jdbcDiskCacheAttributes; |
911 |
|
} |
912 |
|
|
913 |
|
|
914 |
|
|
915 |
|
|
916 |
|
public AuxiliaryCacheAttributes getAuxiliaryCacheAttributes() |
917 |
|
{ |
918 |
0 |
return this.getJdbcDiskCacheAttributes(); |
919 |
|
} |
920 |
|
|
921 |
|
|
922 |
|
|
923 |
|
|
924 |
|
public IStats getStatistics() |
925 |
|
{ |
926 |
112 |
IStats stats = super.getStatistics(); |
927 |
112 |
stats.setTypeName( "JDBC/Abstract Disk Cache" ); |
928 |
112 |
stats.getStatElements(); |
929 |
|
|
930 |
112 |
ArrayList elems = new ArrayList(); |
931 |
|
|
932 |
112 |
IStatElement se = null; |
933 |
|
|
934 |
112 |
se = new StatElement(); |
935 |
112 |
se.setName( "Update Count" ); |
936 |
112 |
se.setData( "" + updateCount ); |
937 |
112 |
elems.add( se ); |
938 |
|
|
939 |
112 |
se = new StatElement(); |
940 |
112 |
se.setName( "Get Count" ); |
941 |
112 |
se.setData( "" + getCount ); |
942 |
112 |
elems.add( se ); |
943 |
|
|
944 |
112 |
se = new StatElement(); |
945 |
112 |
se.setName( "Size" ); |
946 |
112 |
se.setData( "" + getSize() ); |
947 |
112 |
elems.add( se ); |
948 |
|
|
949 |
112 |
se = new StatElement(); |
950 |
112 |
se.setName( "Active DB Connections" ); |
951 |
112 |
se.setData( "" + poolAccess.getNumActiveInPool() ); |
952 |
112 |
elems.add( se ); |
953 |
|
|
954 |
112 |
se = new StatElement(); |
955 |
112 |
se.setName( "Idle DB Connections" ); |
956 |
112 |
se.setData( "" + poolAccess.getNumIdleInPool() ); |
957 |
112 |
elems.add( se ); |
958 |
|
|
959 |
112 |
se = new StatElement(); |
960 |
112 |
se.setName( "DB URL" ); |
961 |
112 |
se.setData( this.jdbcDiskCacheAttributes.getUrl() ); |
962 |
112 |
elems.add( se ); |
963 |
|
|
964 |
|
|
965 |
|
|
966 |
112 |
IStatElement[] eqSEs = stats.getStatElements(); |
967 |
112 |
List eqL = Arrays.asList( eqSEs ); |
968 |
112 |
elems.addAll( eqL ); |
969 |
|
|
970 |
|
|
971 |
112 |
IStatElement[] ses = (IStatElement[]) elems.toArray( new StatElement[0] ); |
972 |
112 |
stats.setStatElements( ses ); |
973 |
|
|
974 |
112 |
return stats; |
975 |
|
} |
976 |
|
|
977 |
|
|
978 |
|
|
979 |
|
|
980 |
|
|
981 |
|
|
982 |
|
protected String getTableName() |
983 |
|
{ |
984 |
26 |
String name = "UNDEFINED"; |
985 |
26 |
if ( this.getJdbcDiskCacheAttributes() != null ) |
986 |
|
{ |
987 |
26 |
name = this.getJdbcDiskCacheAttributes().getTableName(); |
988 |
|
} |
989 |
26 |
return name; |
990 |
|
} |
991 |
|
|
992 |
|
|
993 |
|
|
994 |
|
|
995 |
|
public void setTableState( TableState tableState ) |
996 |
|
{ |
997 |
49 |
this.tableState = tableState; |
998 |
49 |
} |
999 |
|
|
1000 |
|
|
1001 |
|
|
1002 |
|
|
1003 |
|
public TableState getTableState() |
1004 |
|
{ |
1005 |
276 |
return tableState; |
1006 |
|
} |
1007 |
|
|
1008 |
|
|
1009 |
|
|
1010 |
|
|
1011 |
|
public String toString() |
1012 |
|
{ |
1013 |
0 |
return this.getStats(); |
1014 |
|
} |
1015 |
|
} |