unit tests coverage

Coverage report

%line %branch

org.apache.jcs.auxiliary.remote.server.RemoteCacheServer
64%

78%

1
package org.apache.jcs.auxiliary.remote.server;

2

3
/*

4
* Licensed to the Apache Software Foundation (ASF) under one

5
* or more contributor license agreements. See the NOTICE file

6
* distributed with this work for additional information

7
* regarding copyright ownership. The ASF licenses this file

8
* to you under the Apache License, Version 2.0 (the

9
* "License"); you may not use this file except in compliance

10
* with the License. You may obtain a copy of the License at

11
*

12
* http://www.apache.org/licenses/LICENSE-2.0

13
*

14
* Unless required by applicable law or agreed to in writing,

15
* software distributed under the License is distributed on an

16
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

17
* KIND, either express or implied. See the License for the

18
* specific language governing permissions and limitations

19
* under the License.

20
*/

21

22
import java.io.IOException;

23
import java.io.Serializable;

24
import java.rmi.RemoteException;

25
import java.rmi.registry.Registry;

26
import java.rmi.server.UnicastRemoteObject;

27
import java.rmi.server.Unreferenced;

28
import java.util.Collections;

29
import java.util.Enumeration;

30
import java.util.Hashtable;

31
import java.util.Iterator;

32
import java.util.Map;

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.remote.behavior.IRemoteCacheAttributes;

38
import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheListener;

39
import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheObserver;

40
import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService;

41
import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheServiceAdmin;

42
import org.apache.jcs.auxiliary.remote.server.behavior.IRemoteCacheServerAttributes;

43
import org.apache.jcs.engine.CacheEventQueueFactory;

44
import org.apache.jcs.engine.CacheListeners;

45
import org.apache.jcs.engine.behavior.ICacheElement;

46
import org.apache.jcs.engine.behavior.ICacheEventQueue;

47
import org.apache.jcs.engine.behavior.ICacheListener;

48
import org.apache.jcs.engine.control.CompositeCache;

49
import org.apache.jcs.engine.control.CompositeCacheManager;

50

51
/**

52
* This class provides remote cache services. The remote cache server propagates

53
* events from local caches to other local caches. It can also store cached

54
* data, making it available to new clients.

55
* 

56
* Remote cache servers can be clustered. If the cache used by this remote cache

57
* is configured to use a remote cache of type cluster, the two remote caches

58
* will communicate with each other. Remote and put requests can be sent from

59
* one remote to another. If they are configured to broadcast such event to

60
* their client, then remove an puts can be sent to all locals in the cluster.

61
* 

62
* Get requests are made between clustered servers if AllowClusterGet is true. You can setup

63
* several clients to use one remote server and several to use another. The get

64
* locad will be distributed between the two servers. Since caches are usually

65
* high get and low put, this should allow you to scale.

66
*/

67
class RemoteCacheServer

68
extends UnicastRemoteObject

69
implements IRemoteCacheService, IRemoteCacheObserver, IRemoteCacheServiceAdmin, Unreferenced

70
{

71
private static final long serialVersionUID = -8072345435941473116L;

72

73 42
private final static Log log = LogFactory.getLog( RemoteCacheServer.class );

74

75
/** timing -- if we should record operation times. */

76
protected final static boolean timing = true;

77

78 56
private int puts = 0;

79

80
// Maps cache name to CacheListeners object.

81
// association of listeners (regions).

82 56
private final Hashtable cacheListenersMap = new Hashtable();

83

84 56
private final Hashtable clusterListenersMap = new Hashtable();

85

86
private CompositeCacheManager cacheManager;

87

88
// relates listener id with a type

89 56
private final Hashtable idTypeMap = new Hashtable();

90

91
// private transient int listenerId = 0;

92 56
private int[] listenerId = new class="keyword">int[1];

93

94
/** Configuration settings. */

95
protected IRemoteCacheServerAttributes rcsa;

96

97
/** The interval at which we will log updates. */

98 56
private int logInterval = 100;

99

100
/**

101
* Constructor for the RemoteCacheServer object. Thiks initializes the

102
* server with the values from the config file.

103
* 

104
* @param rcsa

105
* @throws RemoteException

106
* @exception IOException

107
*/

108
RemoteCacheServer( IRemoteCacheServerAttributes rcsa )

109
throws RemoteException

110
{

111 56
super( rcsa.getServicePort() );

112 56
this.rcsa = rcsa;

113 56
init( rcsa.getConfigFileName() );

114 56
}

115

116
/**

117
* Initialize the RMI Cache Server from a properties file.

118
* 

119
* @param prop

120
*/

121
private void init( String prop )

122
{

123 56
cacheManager = createCacheManager( prop );

124

125
// cacheManager would have created a number of ICache objects.

126
// Use these objects to set up the cacheListenersMap.

127 56
String[] list = cacheManager.getCacheNames();

128 147
for ( int i = 0; i < list.length; i++ )

129
{

130 91
String name = list[i];

131 91
cacheListenersMap.put( name, new CacheListeners( cacheManager.getCache( name ) ) );

132
}

133 56
}

134

135
/**

136
* Subclass can override this method to create the specific cache manager.

137
* 

138
* @param prop

139
* The anem of the configuration file.

140
* @return The cache hub configured with this configuration file.

141
*/

142
private CompositeCacheManager createCacheManager( String prop )

143
{

144 56
CompositeCacheManager hub = CompositeCacheManager.getUnconfiguredInstance();

145

146 56
if ( prop == null )

147
{

148 0
hub.configure( "/remote.cache.ccf" );

149 0
}

150
else

151
{

152 56
hub.configure( prop );

153
}

154 56
return hub;

155
}

156

157
/**

158
* Returns the cache listener for the specified cache. Creates the cache and

159
* the cache descriptor if they do not already exist.

160
* 

161
* @param cacheName

162
* @return The cacheListeners value

163
*/

164
protected CacheListeners getCacheListeners( String cacheName )

165
{

166 1029
CacheListeners cacheListeners = (CacheListeners) cacheListenersMap.get( cacheName );

167 1029
synchronized ( cacheListenersMap )

168
{

169 1029
if ( cacheListeners == null )

170
{

171 49
cacheListeners = (CacheListeners) cacheListenersMap.get( cacheName );

172 49
if ( cacheListeners == null )

173
{

174 49
cacheListeners = new CacheListeners( cacheManager.getCache( cacheName ) );

175 49
cacheListenersMap.put( cacheName, cacheListeners );

176
}

177
}

178 1029
}

179 1029
return cacheListeners;

180
}

181

182
/**

183
* Gets the clusterListeners attribute of the RemoteCacheServer object.

184
* 

185
* @todo may be able to remove this

186
*

187
* @param cacheName

188
* @return The clusterListeners value

189
*/

190
protected CacheListeners getClusterListeners( String cacheName )

191
{

192 42
CacheListeners cacheListeners = (CacheListeners) clusterListenersMap.get( cacheName );

193 42
synchronized ( clusterListenersMap )

194
{

195 42
if ( cacheListeners == null )

196
{

197 14
cacheListeners = (CacheListeners) clusterListenersMap.get( cacheName );

198 14
if ( cacheListeners == null )

199
{

200 14
cacheListeners = new CacheListeners( cacheManager.getCache( cacheName ) );

201 14
clusterListenersMap.put( cacheName, cacheListeners );

202
}

203
}

204 42
}

205 42
return cacheListeners;

206
}

207

208
/**

209
* Puts a cache bean to the remote cache and notifies all listeners which

210
* 

211
* <ol>

212
* <li>have a different listener id than the originating host;

213
* <li>are currently subscribed to the related cache.

214
* </ol>

215
* 

216
* @param item

217
* @throws IOException

218
*

219
*/

220
public void put( ICacheElement item )

221
throws IOException

222
{

223 0
update( item );

224 0
}

225

226
/*

227
* (non-Javadoc)

228
*

229
* @see org.apache.jcs.engine.behavior.ICacheService#update(org.apache.jcs.engine.behavior.ICacheElement)

230
*/

231
public void update( ICacheElement item )

232
throws IOException

233
{

234 0
update( item, 0 );

235 0
}

236

237
/**

238
* An update can come from either a local cache's remote auxiliary, or it

239
* can come from a remote server. A remote server is considered a a source

240
* of type cluster.

241
* 

242
* If the update came from a cluster, then we should tell the cache manager

243
* that this was a remote put. This way, any lateral and remote auxiliaries

244
* configured for the region will not be updated. This is basically how a

245
* remote listener works when plugged into a local cache.

246
* 

247
* If the cluster is configured to keep local cluster consistency, then all

248
* listeners will be updated. This allows cluster server A to update cluster

249
* server B and then B to update its clients if it is told to keep local

250
* cluster consistency. Otherwise, server A will update server B and B will

251
* not tell its clients. If you cluster using lateral caches for instance,

252
* this is how it will work. Updates to a cluster node, will never get to

253
* the leavess. The remote cluster, with local cluster consistency, allows

254
* you to update leaves. This basically allows you to have a failover remote

255
* server.

256
* 

257
* Since currently a cluster will not try to get from other cluster servers,

258
* you can scale a bit with a cluster configuration. Puts and removes will

259
* be broadcasted to all clients, but the get load on a remote server can be

260
* reduced.

261
* 

262
* @param item

263
* @param requesterId

264
* @throws IOException

265
*/

266
public void update( ICacheElement item, long requesterId )

267
throws IOException

268
{

269

270 861
long start = 0;

271
if ( timing )

272
{

273 861
start = System.currentTimeMillis();

274
}

275

276 861
if ( log.isInfoEnabled() )

277
{

278
// not thread safe, but it doesn't have to be accurate

279 861
puts++;

280 861
if ( puts % logInterval == 0 )

281
{

282 7
log.info( "puts = " + puts );

283
}

284
}

285

286 861
if ( log.isDebugEnabled() )

287
{

288 0
log.debug( "In update, put [" + item.getKey() + "] in [" + item.getCacheName() + "]" );

289
}

290

291
try

292
{

293 861
CacheListeners cacheDesc = getCacheListeners( item.getCacheName() );

294 861
/* Object val = */item.getVal();

295

296 861
Integer remoteTypeL = (Integer) idTypeMap.get( new Long( requesterId ) );

297 861
if ( log.isDebugEnabled() )

298
{

299 0
log.debug( "In update, requesterId = [" + requesterId + "] remoteType = " + remoteTypeL );

300
}

301

302 861
boolean fromCluster = false;

303 861
if ( remoteTypeL != null && remoteTypeL.intValue() == IRemoteCacheAttributes.CLUSTER )

304
{

305 70
fromCluster = true;

306
}

307
// ordered cache item update and notification.

308 861
synchronized ( cacheDesc )

309
{

310
try

311
{

312 861
CompositeCache c = (CompositeCache) cacheDesc.cache;

313

314
// If the source of this request was not from a cluster,

315
// then consider it a local update. The cache manager will

316
// try to

317
// update all auxiliaries.

318
//

319
// This requires that two local caches not be connected to

320
// two clustered remote caches. The failover runner will

321
// have to make sure of this. ALos, the local cache needs

322
// avoid updating this source. Will need to pass the source

323
// id somehow. The remote cache should udate all local

324
// caches

325
// but not update the cluster source. Cluster remote caches

326
// should only be updated by the server and not the

327
// RemoteCache.

328 861
if ( fromCluster )

329
{

330 70
if ( log.isDebugEnabled() )

331
{

332 0
log.debug( "Put FROM cluster, NOT updating other auxiliaries for region. "

333
+ " requesterId [" + requesterId + "]" );

334
}

335 70
c.localUpdate( item );

336 70
}

337
else

338
{

339 791
if ( log.isDebugEnabled() )

340
{

341 0
log.debug( "Put NOT from cluster, updating other auxiliaries for region. "

342
+ " requesterId [" + requesterId + "]" );

343
}

344 791
c.update( item );

345
}

346
}

347 0
catch ( Exception ce )

348
{

349
// swallow

350 0
if ( log.isInfoEnabled() )

351
{

352 0
log.info( "Exception caught updating item. requesterId [" + requesterId + "] "

353
+ ce.getMessage() );

354
}

355 861
}

356

357
// UPDATE LOCALS IF A REQUEST COMES FROM A CLUSTER

358
// IF LOCAL CLUSTER CONSISTENCY IS CONFIGURED

359 861
if ( !fromCluster || ( fromCluster && rcsa.getLocalClusterConsistency() ) )

360
{

361 861
ICacheEventQueue[] qlist = getEventQList( cacheDesc, requesterId );

362

363 861
if ( qlist != null )

364
{

365 861
if ( log.isDebugEnabled() )

366
{

367 0
log.debug( "qlist.length = " + qlist.length );

368
}

369 1708
for ( int i = 0; i < qlist.length; i++ )

370
{

371 847
qlist[i].addPutEvent( item );

372
}

373 861
}

374
else

375
{

376 0
if ( log.isDebugEnabled() )

377
{

378 0
log.debug( "q list is null" );

379
}

380
}

381
}

382 861
}

383
}

384 0
catch ( Exception e )

385
{

386 0
log.error( "Trouble in Update. requesterId [" + requesterId + "]", e );

387 861
}

388

389
// TODO use JAMON for timing

390
if ( timing )

391
{

392 861
long end = System.currentTimeMillis();

393 861
if ( log.isDebugEnabled() )

394
{

395 0
log.debug( "put took " + String.valueOf( end - start ) + " ms." );

396
}

397
}

398

399 861
return;

400
}

401

402
/**

403
* Gets the eventQList attribute of the RemoteCacheServer object. This

404
* returns the event queues stored in the cacheListeners object for a

405
* particuylar region, if the queue is not for this requester.

406
* 

407
* Basically, this makes sure that a request from a particular local cache,

408
* identified by its listener id, does not result in a call to that same

409
* listener.

410
* 

411
* @param cacheListeners

412
* @param requesterId

413
* @return The eventQList value

414
*/

415
private ICacheEventQueue[] getEventQList( CacheListeners cacheListeners, long requesterId )

416
{

417 938
ICacheEventQueue[] list = null;

418 938
synchronized ( cacheListeners.eventQMap )

419
{

420 938
list = (ICacheEventQueue[]) cacheListeners.eventQMap.values().toArray( new ICacheEventQueue[0] );

421 938
}

422 938
int count = 0;

423
// Set those not qualified to null; Count those qualified.

424 2583
for ( int i = 0; i < list.length; i++ )

425
{

426 1645
ICacheEventQueue q = list[i];

427 1645
if ( q.isWorking() && q.getListenerId() != requesterId )

428
{

429 917
count++;

430 917
}

431
else

432
{

433 728
list[i] = null;

434
}

435
}

436 938
if ( count == list.length )

437
{

438
// All qualified.

439 210
return list;

440
}

441

442
// Returns only the qualified.

443 728
ICacheEventQueue[] qq = new ICacheEventQueue[count];

444 728
count = 0;

445 2163
for ( int i = 0; i < list.length; i++ )

446
{

447 1435
if ( list[i] != null )

448
{

449 707
qq[count++] = list[i];

450
}

451
}

452 728
return qq;

453
}

454

455
/**

456
* Returns a cache value from the specified remote cache; or null if the

457
* cache or key does not exist.

458
* 

459
* @param cacheName

460
* @param key

461
* @return ICacheElement

462
* @throws IOException

463
*/

464
public ICacheElement get( String cacheName, Serializable key )

465
throws IOException

466
{

467 0
return this.get( cacheName, key, 0 );

468
}

469

470
/**

471
* Returns a cache bean from the specified cache; or null if the key does

472
* not exist.

473
* 

474
* Adding the requestor id, allows the cache to determine the sournce of the

475
* get.

476
* 

477
* @param cacheName

478
* @param key

479
* @param requesterId

480
* @return ICacheElement

481
* @throws IOException

482
*/

483
public ICacheElement get( String cacheName, Serializable key, long requesterId )

484
throws IOException

485
{

486 21
Integer remoteTypeL = (Integer) idTypeMap.get( new Long( requesterId ) );

487

488 21
if ( log.isDebugEnabled() )

489
{

490 0
log.debug( "get [" + key + "] from cache [" + cacheName + "] requesterId = [" + requesterId + "] remoteType = "

491
+ remoteTypeL );

492
}

493

494
// Since a non-receiving remote cache client will not register a

495
// listener, it will not have a listener id assigned from the server. As

496
// such the remote server cannot determine if it is a cluster or a

497
// normal client. It will assume that it is a normal client.

498

499 21
boolean fromCluster = false;

500 21
if ( remoteTypeL != null && remoteTypeL.intValue() == IRemoteCacheAttributes.CLUSTER )

501
{

502 0
fromCluster = true;

503
}

504

505 21
CacheListeners cacheDesc = null;

506
try

507
{

508 21
cacheDesc = getCacheListeners( cacheName );

509
}

510 0
catch ( Exception e )

511
{

512 0
log.error( "Problem getting listeners.", e );

513 21
}

514

515 21
if ( cacheDesc == null )

516
{

517 0
return null;

518
}

519 21
CompositeCache c = (CompositeCache) cacheDesc.cache;

520

521 21
ICacheElement element = null;

522

523
// If we have a get come in from a client and we don't have the item

524
// locally, we will allow the cache to look in other non local sources,

525
// such as a remote cache or a lateral.

526
//

527
// Since remote servers never get from clients and clients never go

528
// remote from a remote call, this

529
// will not result in any loops.

530
//

531
// This is the only instance I can think of where we allow a remote get

532
// from a remote call. The purpose is to allow remote cache servers to

533
// talk to each other. If one goes down, you want it to be able to get

534
// data from those that were up when the failed server comes back o

535
// line.

536

537 21
if ( !fromCluster && this.rcsa.getAllowClusterGet() )

538
{

539 21
if ( log.isDebugEnabled() )

540
{

541 0
log.debug( "NonLocalGet. fromCluster [" + fromCluster + "] AllowClusterGet [" + this.rcsa.getAllowClusterGet() + "]" );

542
}

543 21
element = c.get( key );

544 21
}

545
else

546
{

547
// Gets from cluster type remote will end up here.

548
// Gets from all clients will end up here if allow cluster get is

549
// false.

550

551 0
if ( log.isDebugEnabled() )

552
{

553 0
log.debug( "LocalGet. fromCluster [" + fromCluster + "] AllowClusterGet [" + this.rcsa.getAllowClusterGet() + "]" );

554
}

555 0
element = c.localGet( key );

556
}

557

558 21
return element;

559
}

560

561
/**

562
* Gets the set of keys of objects currently in the group.

563
* 

564
* @param cacheName

565
* @param group

566
* @return A Set of group keys

567
*/

568
public Set getGroupKeys( String cacheName, String group )

569
{

570 0
CacheListeners cacheDesc = null;

571
try

572
{

573 0
cacheDesc = getCacheListeners( cacheName );

574
}

575 0
catch ( Exception e )

576
{

577 0
log.error( "Problem getting listeners.", e );

578 0
}

579

580 0
if ( cacheDesc == null )

581
{

582 0
return Collections.EMPTY_SET;

583
}

584 0
CompositeCache c = (CompositeCache) cacheDesc.cache;

585 0
return c.getGroupKeys( group );

586
}

587

588
/**

589
* Removes the given key from the specified remote cache. Defaults the

590
* listener id to 0.

591
* 

592
* @param cacheName

593
* @param key

594
* @throws IOException

595
*/

596
public void remove( String cacheName, Serializable key )

597
throws IOException

598
{

599 0
remove( cacheName, key, 0 );

600 0
}

601

602
/**

603
* Remove the key from the cache region and don't tell the source listener

604
* about it.

605
* 

606
* @param cacheName

607
* @param key

608
* @param requesterId

609
* @throws IOException

610
*/

611
public void remove( String cacheName, Serializable key, long requesterId )

612
throws IOException

613
{

614 77
if ( log.isDebugEnabled() )

615
{

616 0
log.debug( "remove [" + key + "] from cache [" + cacheName + "]" );

617
}

618 77
CacheListeners cacheDesc = (CacheListeners) cacheListenersMap.get( cacheName );

619

620 77
Integer remoteTypeL = (Integer) idTypeMap.get( new Long( requesterId ) );

621 77
boolean fromCluster = false;

622 77
if ( remoteTypeL != null && remoteTypeL.intValue() == IRemoteCacheAttributes.CLUSTER )

623
{

624 0
fromCluster = true;

625
}

626

627 77
if ( cacheDesc != null )

628
{

629
// best attempt to achieve ordered cache item removal and

630
// notification.

631 77
synchronized ( cacheDesc )

632
{

633 77
boolean removeSuccess = false;

634

635
// No need to notify if it was not cached.

636 77
CompositeCache c = (CompositeCache) cacheDesc.cache;

637

638 77
if ( fromCluster )

639
{

640 0
if ( log.isDebugEnabled() )

641
{

642 0
log.debug( "Remove FROM cluster, NOT updating other auxiliaries for region" );

643
}

644 0
removeSuccess = c.localRemove( key );

645 0
}

646
else

647
{

648 77
if ( log.isDebugEnabled() )

649
{

650 0
log.debug( "Remove NOT from cluster, updating other auxiliaries for region" );

651
}

652 77
removeSuccess = c.remove( key );

653
}

654

655 77
if ( log.isDebugEnabled() )

656
{

657 0
log.debug( "remove [" + key + "] from cache [" + cacheName + "] success (was it found) = "

658
+ removeSuccess );

659
}

660

661
// UPDATE LOCALS IF A REQUEST COMES FROM A CLUSTER

662
// IF LOCAL CLUSTER CONSISTENCY IS CONFIGURED

663 77
if ( !fromCluster || ( fromCluster && rcsa.getLocalClusterConsistency() ) )

664
{

665 77
ICacheEventQueue[] qlist = getEventQList( cacheDesc, requesterId );

666

667 147
for ( int i = 0; i < qlist.length; i++ )

668
{

669 70
qlist[i].addRemoveEvent( key );

670
}

671
}

672 77
}

673
}

674 77
return;

675
}

676

677
/**

678
* Remove all keys from the sepcified remote cache.

679
* 

680
* @param cacheName

681
* @throws IOException

682
*/

683
public void removeAll( String cacheName )

684
throws IOException

685
{

686 0
removeAll( cacheName, 0 );

687 0
}

688

689
/**

690
* Remove all keys from the specified remote cache.

691
* 

692
* @param cacheName

693
* @param requesterId

694
* @throws IOException

695
*/

696
public void removeAll( String cacheName, long requesterId )

697
throws IOException

698
{

699 0
CacheListeners cacheDesc = (CacheListeners) cacheListenersMap.get( cacheName );

700

701 0
Integer remoteTypeL = (Integer) idTypeMap.get( new Long( requesterId ) );

702 0
boolean fromCluster = false;

703 0
if ( remoteTypeL != null && remoteTypeL.intValue() == IRemoteCacheAttributes.CLUSTER )

704
{

705 0
fromCluster = true;

706
}

707

708 0
if ( cacheDesc != null )

709
{

710
// best attempt to achieve ordered cache item removal and

711
// notification.

712 0
synchronized ( cacheDesc )

713
{

714
// No need to broadcast, or notify if it was not cached.

715 0
CompositeCache c = (CompositeCache) cacheDesc.cache;

716

717 0
if ( fromCluster )

718
{

719 0
if ( log.isDebugEnabled() )

720
{

721 0
log.debug( "RemoveALL FROM cluster, NOT updating other auxiliaries for region" );

722
}

723 0
c.localRemoveAll();

724 0
}

725
else

726
{

727 0
if ( log.isDebugEnabled() )

728
{

729 0
log.debug( "RemoveALL NOT from cluster, updating other auxiliaries for region" );

730
}

731 0
c.removeAll();

732
}

733

734
// update registered listeners

735 0
if ( !fromCluster || ( fromCluster && rcsa.getLocalClusterConsistency() ) )

736
{

737 0
ICacheEventQueue[] qlist = getEventQList( cacheDesc, requesterId );

738

739 0
for ( int i = 0; i < qlist.length; i++ )

740
{

741 0
qlist[i].addRemoveAllEvent();

742
}

743
}

744 0
}

745
}

746 0
return;

747
}

748

749
/**

750
* How many put events have we received.

751
* 

752
* @return puts

753
*/

754
protected int getPutCount()

755
{

756 56
return puts;

757
}

758

759
/**

760
* Frees the specified remote cache.

761
* 

762
* @param cacheName

763
* @throws IOException

764
*/

765
public void dispose( String cacheName )

766
throws IOException

767
{

768 0
dispose( cacheName, 0 );

769 0
}

770

771
/**

772
* Frees the specified remote cache.

773
* 

774
* @param cacheName

775
* @param requesterId

776
* @throws IOException

777
*/

778
public void dispose( String cacheName, long requesterId )

779
throws IOException

780
{

781 0
if ( log.isInfoEnabled() )

782
{

783 0
log.info( "Dispose request received from listener [" + requesterId + "]" );

784
}

785

786 0
CacheListeners cacheDesc = (CacheListeners) cacheListenersMap.get( cacheName );

787

788
// this is dangerous

789 0
if ( cacheDesc != null )

790
{

791
// best attempt to achieve ordered free-cache-op and notification.

792 0
synchronized ( cacheDesc )

793
{

794 0
ICacheEventQueue[] qlist = getEventQList( cacheDesc, requesterId );

795

796 0
for ( int i = 0; i < qlist.length; i++ )

797
{

798 0
qlist[i].addDisposeEvent();

799
}

800 0
cacheManager.freeCache( cacheName );

801 0
}

802
}

803 0
return;

804
}

805

806
/**

807
* Frees all remote caches.

808
* 

809
* @throws IOException

810
*/

811
public void release()

812
throws IOException

813
{

814 0
synchronized ( cacheListenersMap )

815
{

816 0
for ( Enumeration en = cacheListenersMap.elements(); en.hasMoreElements(); )

817
{

818 0
CacheListeners cacheDesc = (CacheListeners) en.nextElement();

819 0
ICacheEventQueue[] qlist = getEventQList( cacheDesc, 0 );

820

821 0
for ( int i = 0; i < qlist.length; i++ )

822
{

823 0
qlist[i].addDisposeEvent();

824
}

825 0
}

826 0
cacheManager.release();

827 0
}

828 0
return;

829
}

830

831
/**

832
* Removes dead event queues. Should clean out deregistered listeners.

833
* 

834
* @param eventQMap

835
*/

836
private static void cleanupEventQMap( Map eventQMap )

837
{

838 175
synchronized ( eventQMap )

839
{

840 175
for ( Iterator itr = eventQMap.entrySet().iterator(); itr.hasNext(); )

841
{

842 119
Map.Entry e = (Map.Entry) itr.next();

843 119
ICacheEventQueue q = (ICacheEventQueue) e.getValue();

844

845
// this does not care if the q is alive (i.e. if

846
// there are active threads; it cares if the queue

847
// is working -- if it has not encoutnered errors

848
// above the failure threshhold

849 119
if ( !q.isWorking() )

850
{

851 0
itr.remove();

852 0
log.warn( "Cache event queue " + q + " is not working and removed from cache server." );

853
}

854 119
}

855 175
}

856 175
}

857

858
/**

859
* Subscribes to the specified remote cache.

860
* 

861
* If the client id is 0, then the remote cache server will increment it's

862
* local count and assign an id to the client.

863
* 

864
* @param cacheName

865
* the specified remote cache.

866
* @param listener

867
* object to notify for cache changes. must be synchronized since

868
* there are remote calls involved.

869
* @throws IOException

870
*/

871
public void addCacheListener( String cacheName, ICacheListener listener )

872
throws IOException

873
{

874 119
if ( cacheName == null || listener == class="keyword">null )

875
{

876 0
throw new IllegalArgumentException( "cacheName and listener must not be null" );

877
}

878
CacheListeners cacheDesc;

879

880 119
IRemoteCacheListener ircl = (IRemoteCacheListener) listener;

881

882 119
String listenerAddress = ircl.getLocalHostAddress();

883

884 119
int remoteType = ircl.getRemoteType();

885 119
if ( remoteType == IRemoteCacheAttributes.CLUSTER )

886
{

887 21
log.debug( "adding cluster listener, listenerAddress [" + listenerAddress + "]" );

888 21
cacheDesc = getClusterListeners( cacheName );

889 21
}

890
else

891
{

892 98
log.debug( "adding normal listener, listenerAddress [" + listenerAddress + "]" );

893 98
cacheDesc = getCacheListeners( cacheName );

894
}

895 119
Map eventQMap = cacheDesc.eventQMap;

896 119
cleanupEventQMap( eventQMap );

897

898
// synchronized ( listenerId )

899 119
synchronized ( ICacheListener.class )

900
{

901 119
long id = 0;

902
try

903
{

904 119
id = listener.getListenerId();

905
// clients problably shouldn't do this.

906 119
if ( id == 0 )

907
{

908
// must start at one so the next gets recognized

909 119
long listenerIdB = nextListenerId();

910 119
if ( log.isDebugEnabled() )

911
{

912 0
log.debug( "listener id=" + ( listenerIdB & 0xff ) + " addded for cache [" + cacheName

913
+ "], listenerAddress [" + listenerAddress + "]" );

914
}

915 119
listener.setListenerId( listenerIdB );

916 119
id = listenerIdB;

917

918
// in case it needs synchronization

919 119
if ( log.isInfoEnabled() )

920
{

921 119
log.info( "adding vm listener under new id = [" + listenerIdB + "], listenerAddress ["

922
+ listenerAddress + "]" );

923
}

924 119
}

925
else

926
{

927 0
if ( log.isInfoEnabled() )

928
{

929 0
log.info( "adding listener under existing id = [" + id + "], listenerAddress ["

930
+ listenerAddress + "]" );

931
}

932
// should confirm the the host is the same as we have on

933
// record, just in case a client has made a mistake.

934
}

935

936
// relate the type to an id

937 119
this.idTypeMap.put( new Long( id ), class="keyword">new Integer( remoteType ) );

938
}

939 0
catch ( IOException ioe )

940
{

941 0
log.error( "Problem setting listener id, listenerAddress [" + listenerAddress + "]", ioe );

942 119
}

943

944 119
CacheEventQueueFactory fact = new CacheEventQueueFactory();

945 119
ICacheEventQueue q = fact.createCacheEventQueue( listener, id, cacheName, rcsa.getEventQueuePoolName(),

946
rcsa.getEventQueueTypeFactoryCode() );

947

948 119
eventQMap.put( new Long( listener.getListenerId() ), q );

949

950 119
if ( log.isInfoEnabled() )

951
{

952 119
log.info( "Region " + cacheName + "'s listener size = " + cacheDesc.eventQMap.size() );

953
}

954 119
}

955 119
}

956

957
/**

958
* Subscribes to all remote caches.

959
* 

960
* @param listener

961
* The feature to be added to the CacheListener attribute

962
* @throws IOException

963
*/

964
public void addCacheListener( ICacheListener listener )

965
throws IOException

966
{

967 14
for ( Enumeration en = cacheListenersMap.keys(); en.hasMoreElements(); )

968
{

969 14
String cacheName = (String) en.nextElement();

970 14
addCacheListener( cacheName, listener );

971

972 14
if ( log.isDebugEnabled() )

973
{

974 0
log.debug( "Adding listener for cache [" + cacheName + "]" );

975
}

976 14
}

977 14
}

978

979
/**

980
* Unsubscribe this listener from this region. If the listener is

981
* registered, it will be removed from the event queue map list.

982
* 

983
* @param cacheName

984
* @param listenerId

985
*/

986
public void removeCacheListener( String cacheName, ICacheListener listener )

987
throws IOException

988
{

989 21
removeCacheListener( cacheName, listener.getListenerId() );

990 21
}

991

992
/**

993
* Unsubscribe this listener from this region. If the listener is

994
* registered, it will be removed from the event queue map list.

995
* 

996
* @param cacheName

997
* @param listenerId

998
*/

999
public void removeCacheListener( String cacheName, long listenerId )

1000
{

1001 35
if ( log.isInfoEnabled() )

1002
{

1003 35
log.info( "Removing listener for cache region = [" + cacheName + "] and listenerId [" + listenerId + "]" );

1004
}

1005

1006 35
Integer remoteTypeL = (Integer) idTypeMap.get( new Long( listenerId ) );

1007 35
boolean isClusterListener = false;

1008 35
if ( remoteTypeL != null && remoteTypeL.intValue() == IRemoteCacheAttributes.CLUSTER )

1009
{

1010 7
isClusterListener = true;

1011
}

1012

1013 35
CacheListeners cacheDesc = null;

1014

1015 35
if ( isClusterListener )

1016
{

1017 7
cacheDesc = getClusterListeners( cacheName );

1018 7
}

1019
else

1020
{

1021 28
cacheDesc = getCacheListeners( cacheName );

1022
}

1023 35
Map eventQMap = cacheDesc.eventQMap;

1024 35
cleanupEventQMap( eventQMap );

1025 35
ICacheEventQueue q = (ICacheEventQueue) eventQMap.remove( new Long( listenerId ) );

1026

1027 35
if ( q != null )

1028
{

1029 21
if ( log.isDebugEnabled() )

1030
{

1031 0
log.debug( "Found queue for cache region = [" + cacheName + "] and listenerId [" + listenerId + "]" );

1032
}

1033 21
q.destroy();

1034 21
cleanupEventQMap( eventQMap );

1035 21
}

1036
else

1037
{

1038 14
if ( log.isDebugEnabled() )

1039
{

1040 0
log.debug( "Did not find queue for cache region = [" + cacheName + "] and listenerId [" + listenerId

1041
+ "]" );

1042
}

1043
}

1044

1045 35
if ( log.isInfoEnabled() )

1046
{

1047 35
log.info( "After removing listener [" + listenerId + "] cache region " + cacheName + "'s listener size ["

1048
+ cacheDesc.eventQMap.size() + "]" );

1049
}

1050 35
}

1051

1052
/**

1053
* Unsubscribes from all remote caches.

1054
* 

1055
* @param listener

1056
* @throws IOException

1057
*/

1058
public void removeCacheListener( ICacheListener listener )

1059
throws IOException

1060
{

1061 7
for ( Enumeration en = cacheListenersMap.keys(); en.hasMoreElements(); )

1062
{

1063 21
String cacheName = (String) en.nextElement();

1064 21
removeCacheListener( cacheName, listener );

1065

1066 21
if ( log.isInfoEnabled() )

1067
{

1068 21
log.info( "Removing listener for cache [" + cacheName + "]" );

1069
}

1070 21
}

1071 7
return;

1072
}

1073

1074
/**

1075
* Shuts down the remote server.

1076
* 

1077
* @throws IOException

1078
*/

1079
public void shutdown()

1080
throws IOException

1081
{

1082 0
RemoteCacheServerFactory.shutdownImpl( "", Registry.REGISTRY_PORT );

1083 0
}

1084

1085
/**

1086
* Shuts down a server at a particular host and port. Then it calls shutdown on the cache itself.

1087
* 

1088
* @param host

1089
* @param port

1090
* @throws IOException

1091
*/

1092
public void shutdown( String host, int port )

1093
throws IOException

1094
{

1095 0
if ( log.isInfoEnabled() )

1096
{

1097 0
log.info( "Received shutdown request. Shutting down server." );

1098
}

1099 0
RemoteCacheServerFactory.shutdownImpl( host, port );

1100 0
this.cacheManager.shutDown();

1101 0
}

1102

1103
/**

1104
* Called by the RMI runtime sometime after the runtime determines that the

1105
* reference list, the list of clients referencing the remote object,

1106
* becomes empty.

1107
*/

1108
// TODO: test out the DGC.

1109
public void unreferenced()

1110
{

1111 0
if ( log.isInfoEnabled() )

1112
{

1113 0
log.info( "*** Server now unreferenced and subject to GC. ***" );

1114
}

1115 0
}

1116

1117
/**

1118
* Returns the next generated listener id [0,255].

1119
* 

1120
* @return the listener id of a client. This should be unique for this

1121
* server.

1122
*/

1123
private long nextListenerId()

1124
{

1125 119
long id = 0;

1126 119
if ( listenerId[0] == Long.MAX_VALUE )

1127
{

1128 0
synchronized ( listenerId )

1129
{

1130 0
id = listenerId[0];

1131 0
listenerId[0] = 0;

1132
// TODO: record & check if the generated id is currently being

1133
// used by a valid listener. Currently if the id wraps after

1134
// Long.MAX_VALUE,

1135
// we just assume it won't collide with an existing listener who

1136
// is live.

1137 0
}

1138 0
}

1139
else

1140
{

1141 119
synchronized ( listenerId )

1142
{

1143 119
id = ++listenerId[0];

1144 119
}

1145
}

1146 119
return id;

1147
}

1148

1149
/**

1150
* Gets the stats attribute of the RemoteCacheServer object.

1151
* 

1152
* @return The stats value

1153
* @throws IOException

1154
*/

1155
public String getStats()

1156
throws IOException

1157
{

1158 28
return cacheManager.getStats();

1159
}

1160
}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.