001: /**
002: * Copyright 2003-2007 Luck Consulting Pty Ltd
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */package net.sf.ehcache.distribution;
016:
017: import junit.framework.TestCase;
018: import net.sf.ehcache.AbstractCacheTest;
019: import net.sf.ehcache.Cache;
020: import net.sf.ehcache.CacheManager;
021: import net.sf.ehcache.Ehcache;
022: import net.sf.ehcache.Status;
023: import net.sf.ehcache.event.CacheEventListener;
024: import net.sf.ehcache.event.CountingCacheEventListener;
025:
026: import java.rmi.Remote;
027: import java.rmi.RemoteException;
028: import java.util.List;
029:
030: /**
031: * Unit tests for the RMICacheManagerPeerListener
032: * <p/>
033: * Note these tests need a live network interface running in multicast mode to work
034: *
035: * @author <a href="mailto:gluck@thoughtworks.com">Greg Luck</a>
036: * @version $Id: RMICacheManagerPeerListenerTest.java 519 2007-07-27 07:11:45Z gregluck $
037: */
038: public class RMICacheManagerPeerListenerTest extends TestCase {
039:
040: /**
041: * CacheManager 1 in the cluster
042: */
043: protected CacheManager manager1;
044: /**
045: * CacheManager 2 in the cluster
046: */
047: protected CacheManager manager2;
048: /**
049: * CacheManager 3 in the cluster
050: */
051: protected CacheManager manager3;
052: /**
053: * CacheManager 4 in the cluster
054: */
055: protected CacheManager manager4;
056: /**
057: * CacheManager 5 in the cluster
058: */
059: protected CacheManager manager5;
060: /**
061: * CacheManager 6 in the cluster
062: */
063: protected CacheManager manager6;
064:
065: /**
066: * The name of the cache under test
067: */
068: protected String cacheName = "sampleCache1";
069: /**
070: * CacheManager 1 of 2s cache being replicated
071: */
072: protected Ehcache cache1;
073:
074: /**
075: * CacheManager 2 of 2s cache being replicated
076: */
077: protected Ehcache cache2;
078:
079: /**
080: * {@inheritDoc}
081: * Sets up two caches: cache1 is local. cache2 is to be receive updates
082: *
083: * @throws Exception
084: */
085: protected void setUp() throws Exception {
086: if (JVMUtil.isSingleRMIRegistryPerVM()) {
087: return;
088: }
089:
090: CountingCacheEventListener.resetCounters();
091: manager1 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR
092: + "distribution/ehcache-distributed1.xml");
093: manager2 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR
094: + "distribution/ehcache-distributed2.xml");
095: manager3 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR
096: + "distribution/ehcache-distributed3.xml");
097: manager4 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR
098: + "distribution/ehcache-distributed4.xml");
099: manager5 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR
100: + "distribution/ehcache-distributed5.xml");
101:
102: manager1.getCache(cacheName).removeAll();
103:
104: cache1 = manager1.getCache(cacheName);
105: cache1.removeAll();
106:
107: cache2 = manager2.getCache(cacheName);
108: cache2.removeAll();
109:
110: //allow cluster to be established
111: Thread.sleep(100);
112:
113: }
114:
115: /**
116: * {@inheritDoc}
117: *
118: * @throws Exception
119: */
120: protected void tearDown() throws Exception {
121: if (JVMUtil.isSingleRMIRegistryPerVM()) {
122: return;
123: }
124:
125: manager1.shutdown();
126: manager2.shutdown();
127: manager3.shutdown();
128: manager4.shutdown();
129: if (manager5 != null) {
130: manager5.shutdown();
131: }
132:
133: if (manager6 != null) {
134: manager6.shutdown();
135: }
136: }
137:
138: /**
139: * Are all of the replicated caches bound to the RMI listener?
140: */
141: public void testPeersBound() {
142:
143: if (JVMUtil.isSingleRMIRegistryPerVM()) {
144: return;
145: }
146:
147: List cachePeers1 = ((RMICacheManagerPeerListener) manager1
148: .getCachePeerListener()).getBoundCachePeers();
149: assertEquals(55, cachePeers1.size());
150: String[] boundCachePeers1 = ((RMICacheManagerPeerListener) manager1
151: .getCachePeerListener()).listBoundRMICachePeers();
152: assertEquals(55, boundCachePeers1.length);
153: assertEquals(cachePeers1.size(), boundCachePeers1.length);
154:
155: List cachePeers2 = ((RMICacheManagerPeerListener) manager2
156: .getCachePeerListener()).getBoundCachePeers();
157: assertEquals(55, cachePeers2.size());
158: String[] boundCachePeers2 = ((RMICacheManagerPeerListener) manager2
159: .getCachePeerListener()).listBoundRMICachePeers();
160: assertEquals(55, boundCachePeers2.length);
161: assertEquals(cachePeers2.size(), boundCachePeers2.length);
162:
163: List cachePeers3 = ((RMICacheManagerPeerListener) manager3
164: .getCachePeerListener()).getBoundCachePeers();
165: assertEquals(55, cachePeers3.size());
166: String[] boundCachePeers3 = ((RMICacheManagerPeerListener) manager3
167: .getCachePeerListener()).listBoundRMICachePeers();
168: assertEquals(55, boundCachePeers3.length);
169: assertEquals(cachePeers3.size(), boundCachePeers3.length);
170:
171: List cachePeers4 = ((RMICacheManagerPeerListener) manager4
172: .getCachePeerListener()).getBoundCachePeers();
173: assertEquals(55, cachePeers4.size());
174: String[] boundCachePeers4 = ((RMICacheManagerPeerListener) manager4
175: .getCachePeerListener()).listBoundRMICachePeers();
176: assertEquals(55, boundCachePeers4.length);
177: assertEquals(cachePeers4.size(), boundCachePeers4.length);
178:
179: List cachePeers5 = ((RMICacheManagerPeerListener) manager5
180: .getCachePeerListener()).getBoundCachePeers();
181: assertEquals(55, cachePeers5.size());
182: String[] boundCachePeers5 = ((RMICacheManagerPeerListener) manager5
183: .getCachePeerListener()).listBoundRMICachePeers();
184: assertEquals(55, boundCachePeers5.length);
185: assertEquals(cachePeers5.size(), boundCachePeers5.length);
186: }
187:
188: /**
189: * Are all of the replicated caches bound to the listener and working?
190: */
191: public void testBoundListenerPeers() throws RemoteException {
192:
193: if (JVMUtil.isSingleRMIRegistryPerVM()) {
194: return;
195: }
196:
197: String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1
198: .getCachePeerListener()).listBoundRMICachePeers();
199: validateBoundCachePeer(boundCachePeers);
200: }
201:
202: /**
203: * Are all of the CachePeers for replicated caches bound to the listener and working?
204: */
205: public void testBoundListenerPeersAfterDefaultCacheAdd()
206: throws RemoteException {
207:
208: if (JVMUtil.isSingleRMIRegistryPerVM()) {
209: return;
210: }
211:
212: String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1
213: .getCachePeerListener()).listBoundRMICachePeers();
214: assertEquals(55, boundCachePeers.length);
215: validateBoundCachePeer(boundCachePeers);
216:
217: //Add from default which is has a CacheReplicator configured.
218: manager1.addCache("fromDefaultCache");
219: boundCachePeers = ((RMICacheManagerPeerListener) manager1
220: .getCachePeerListener()).listBoundRMICachePeers();
221: assertEquals(56, boundCachePeers.length);
222: validateBoundCachePeer(boundCachePeers);
223: }
224:
225: /**
226: * Are all of the CachePeers for replicated caches bound to the listener and working?
227: */
228: public void testBoundListenerPeersAfterProgrammaticCacheAdd()
229: throws RemoteException {
230:
231: if (JVMUtil.isSingleRMIRegistryPerVM()) {
232: return;
233: }
234:
235: String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1
236: .getCachePeerListener()).listBoundRMICachePeers();
237: assertEquals(55, boundCachePeers.length);
238: validateBoundCachePeer(boundCachePeers);
239:
240: //Add from default which is has a CacheReplicator configured.
241:
242: RMICacheReplicatorFactory factory = new RMICacheReplicatorFactory();
243: CacheEventListener replicatingListener = factory
244: .createCacheEventListener(null);
245: Cache cache = new Cache("programmaticallyAdded", 10, null,
246: true, System.getProperty("java.io.tmpdir"), false, 10,
247: 10, false, 60, null);
248: cache.getCacheEventNotificationService().registerListener(
249: replicatingListener);
250:
251: manager1.addCache(cache);
252: boundCachePeers = ((RMICacheManagerPeerListener) manager1
253: .getCachePeerListener()).listBoundRMICachePeers();
254: assertEquals(56, boundCachePeers.length);
255: validateBoundCachePeer(boundCachePeers);
256: }
257:
258: /**
259: * Are all of the CachePeers for replicated caches bound to the listener and working?
260: */
261: public void testBoundListenerPeersAfterCacheRemove()
262: throws RemoteException {
263:
264: if (JVMUtil.isSingleRMIRegistryPerVM()) {
265: return;
266: }
267:
268: String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1
269: .getCachePeerListener()).listBoundRMICachePeers();
270: assertEquals(55, boundCachePeers.length);
271: validateBoundCachePeer(boundCachePeers);
272:
273: //Remove a replicated cache
274: manager1.removeCache("sampleCache1");
275: boundCachePeers = ((RMICacheManagerPeerListener) manager1
276: .getCachePeerListener()).listBoundRMICachePeers();
277: assertEquals(54, boundCachePeers.length);
278: validateBoundCachePeer(boundCachePeers);
279: }
280:
281: private void validateBoundCachePeer(String[] boundCachePeers) {
282: for (int i = 0; i < boundCachePeers.length; i++) {
283: String boundCacheName = boundCachePeers[i];
284: Remote remote = ((RMICacheManagerPeerListener) manager1
285: .getCachePeerListener()).lookupPeer(boundCacheName);
286: assertNotNull(remote);
287: }
288: }
289:
290: /**
291: * Does the RMI listener stop?
292: */
293: public void testListenerShutsdown() {
294:
295: if (JVMUtil.isSingleRMIRegistryPerVM()) {
296: return;
297: }
298:
299: CacheManagerPeerListener cachePeerListener = manager1
300: .getCachePeerListener();
301: List cachePeers1 = cachePeerListener.getBoundCachePeers();
302: assertEquals(55, cachePeers1.size());
303: assertEquals(Status.STATUS_ALIVE, cachePeerListener.getStatus());
304:
305: manager1.shutdown();
306: assertEquals(Status.STATUS_SHUTDOWN, cachePeerListener
307: .getStatus());
308:
309: }
310:
311: /**
312: * Does the RMI listener stop?
313: * <p/>
314: * This test does not actually do test the shutdown hook automatically. But you should be able to
315: * see "VM shutting down with the RMICacheManagerPeerListener for localhost still active. Calling dispose..."
316: * in the log with FINE level when this test is run individually or as the last test in the run. i.e. on VM shutdown.
317: */
318: public void testListenerShutsdownFromShutdownHook() {
319:
320: if (JVMUtil.isSingleRMIRegistryPerVM()) {
321: return;
322: }
323:
324: CacheManager manager = new CacheManager(
325: AbstractCacheTest.TEST_CONFIG_DIR
326: + "distribution/ehcache-distributed6.xml");
327:
328: CacheManagerPeerListener cachePeerListener = manager
329: .getCachePeerListener();
330: List cachePeers1 = cachePeerListener.getBoundCachePeers();
331: assertEquals(55, cachePeers1.size());
332: assertEquals(Status.STATUS_ALIVE, cachePeerListener.getStatus());
333:
334: }
335: }
|