1   /**
2    *  Copyright 2003-2007 Greg Luck
3    *
4    *  Licensed under the Apache License, Version 2.0 (the "License");
5    *  you may not use this file except in compliance with the License.
6    *  You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *  Unless required by applicable law or agreed to in writing, software
11   *  distributed under the License is distributed on an "AS IS" BASIS,
12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *  See the License for the specific language governing permissions and
14   *  limitations under the License.
15   */
16  
17  package net.sf.ehcache.distribution;
18  
19  import junit.framework.TestCase;
20  import net.sf.ehcache.AbstractCacheTest;
21  import net.sf.ehcache.Cache;
22  import net.sf.ehcache.CacheManager;
23  import net.sf.ehcache.Ehcache;
24  import net.sf.ehcache.Status;
25  import net.sf.ehcache.event.CacheEventListener;
26  import net.sf.ehcache.event.CountingCacheEventListener;
27  
28  import java.rmi.Remote;
29  import java.rmi.RemoteException;
30  import java.util.List;
31  
32  /**
33   * Unit tests for the RMICacheManagerPeerListener
34   * <p/>
35   * Note these tests need a live network interface running in multicast mode to work
36   *
37   * @author <a href="mailto:gluck@thoughtworks.com">Greg Luck</a>
38   * @version $Id: RMICacheManagerPeerListenerTest.java 512 2007-07-10 09:18:45Z gregluck $
39   */
40  public class RMICacheManagerPeerListenerTest extends TestCase {
41  
42      /**
43       * CacheManager 1 in the cluster
44       */
45      protected CacheManager manager1;
46      /**
47       * CacheManager 2 in the cluster
48       */
49      protected CacheManager manager2;
50      /**
51       * CacheManager 3 in the cluster
52       */
53      protected CacheManager manager3;
54      /**
55       * CacheManager 4 in the cluster
56       */
57      protected CacheManager manager4;
58      /**
59       * CacheManager 5 in the cluster
60       */
61      protected CacheManager manager5;
62      /**
63       * CacheManager 6 in the cluster
64       */
65      protected CacheManager manager6;
66  
67      /**
68       * The name of the cache under test
69       */
70      protected String cacheName = "sampleCache1";
71      /**
72       * CacheManager 1 of 2s cache being replicated
73       */
74      protected Ehcache cache1;
75  
76      /**
77       * CacheManager 2 of 2s cache being replicated
78       */
79      protected Ehcache cache2;
80  
81      /**
82       * {@inheritDoc}
83       * Sets up two caches: cache1 is local. cache2 is to be receive updates
84       *
85       * @throws Exception
86       */
87      protected void setUp() throws Exception {
88          if (JVMUtil.isSingleRMIRegistryPerVM()) {
89              return;
90          }
91  
92          CountingCacheEventListener.resetCounters();
93          manager1 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR + "distribution/ehcache-distributed1.xml");
94          manager2 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR + "distribution/ehcache-distributed2.xml");
95          manager3 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR + "distribution/ehcache-distributed3.xml");
96          manager4 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR + "distribution/ehcache-distributed4.xml");
97          manager5 = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR + "distribution/ehcache-distributed5.xml");
98  
99          manager1.getCache(cacheName).removeAll();
100 
101         cache1 = manager1.getCache(cacheName);
102         cache1.removeAll();
103 
104         cache2 = manager2.getCache(cacheName);
105         cache2.removeAll();
106 
107         //allow cluster to be established
108         Thread.sleep(100);
109 
110     }
111 
112 
113     /**
114      * {@inheritDoc}
115      *
116      * @throws Exception
117      */
118     protected void tearDown() throws Exception {
119         if (JVMUtil.isSingleRMIRegistryPerVM()) {
120             return;
121         }
122 
123 
124         manager1.shutdown();
125         manager2.shutdown();
126         manager3.shutdown();
127         manager4.shutdown();
128         if (manager5 != null) {
129             manager5.shutdown();
130         }
131 
132         if (manager6 != null) {
133             manager6.shutdown();
134         }
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.getCachePeerListener()).getBoundCachePeers();
148         assertEquals(55, cachePeers1.size());
149         String[] boundCachePeers1 = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
150         assertEquals(55, boundCachePeers1.length);
151         assertEquals(cachePeers1.size(), boundCachePeers1.length);
152 
153         List cachePeers2 = ((RMICacheManagerPeerListener) manager2.getCachePeerListener()).getBoundCachePeers();
154         assertEquals(55, cachePeers2.size());
155         String[] boundCachePeers2 = ((RMICacheManagerPeerListener) manager2.getCachePeerListener()).listBoundRMICachePeers();
156         assertEquals(55, boundCachePeers2.length);
157         assertEquals(cachePeers2.size(), boundCachePeers2.length);
158 
159 
160         List cachePeers3 = ((RMICacheManagerPeerListener) manager3.getCachePeerListener()).getBoundCachePeers();
161         assertEquals(55, cachePeers3.size());
162         String[] boundCachePeers3 = ((RMICacheManagerPeerListener) manager3.getCachePeerListener()).listBoundRMICachePeers();
163         assertEquals(55, boundCachePeers3.length);
164         assertEquals(cachePeers3.size(), boundCachePeers3.length);
165 
166 
167         List cachePeers4 = ((RMICacheManagerPeerListener) manager4.getCachePeerListener()).getBoundCachePeers();
168         assertEquals(55, cachePeers4.size());
169         String[] boundCachePeers4 = ((RMICacheManagerPeerListener) manager4.getCachePeerListener()).listBoundRMICachePeers();
170         assertEquals(55, boundCachePeers4.length);
171         assertEquals(cachePeers4.size(), boundCachePeers4.length);
172 
173         List cachePeers5 = ((RMICacheManagerPeerListener) manager5.getCachePeerListener()).getBoundCachePeers();
174         assertEquals(55, cachePeers5.size());
175         String[] boundCachePeers5 = ((RMICacheManagerPeerListener) manager5.getCachePeerListener()).listBoundRMICachePeers();
176         assertEquals(55, boundCachePeers5.length);
177         assertEquals(cachePeers5.size(), boundCachePeers5.length);
178     }
179 
180 
181     /**
182      * Are all of the replicated caches bound to the listener and working?
183      */
184     public void testBoundListenerPeers() throws RemoteException {
185 
186         if (JVMUtil.isSingleRMIRegistryPerVM()) {
187             return;
188         }
189 
190         String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
191         validateBoundCachePeer(boundCachePeers);
192     }
193 
194     /**
195      * Are all of the CachePeers for replicated caches bound to the listener and working?
196      */
197     public void testBoundListenerPeersAfterDefaultCacheAdd() throws RemoteException {
198 
199         if (JVMUtil.isSingleRMIRegistryPerVM()) {
200             return;
201         }
202 
203         String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
204         assertEquals(55, boundCachePeers.length);
205         validateBoundCachePeer(boundCachePeers);
206 
207         //Add from default which is has a CacheReplicator configured.
208         manager1.addCache("fromDefaultCache");
209         boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
210         assertEquals(56, boundCachePeers.length);
211         validateBoundCachePeer(boundCachePeers);
212     }
213 
214     /**
215      * Are all of the CachePeers for replicated caches bound to the listener and working?
216      */
217     public void testBoundListenerPeersAfterProgrammaticCacheAdd() throws RemoteException {
218 
219         if (JVMUtil.isSingleRMIRegistryPerVM()) {
220             return;
221         }
222 
223         String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
224         assertEquals(55, boundCachePeers.length);
225         validateBoundCachePeer(boundCachePeers);
226 
227         //Add from default which is has a CacheReplicator configured.
228 
229 
230         RMICacheReplicatorFactory factory = new RMICacheReplicatorFactory();
231         CacheEventListener replicatingListener = factory.createCacheEventListener(null);
232         Cache cache = new Cache("programmaticallyAdded",
233                 10, null, true, System.getProperty("java.io.tmpdir"), false, 10, 10, false, 60, null);
234         cache.getCacheEventNotificationService().registerListener(replicatingListener);
235 
236         manager1.addCache(cache);
237         boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
238         assertEquals(56, boundCachePeers.length);
239         validateBoundCachePeer(boundCachePeers);
240     }
241 
242     /**
243      * Are all of the CachePeers for replicated caches bound to the listener and working?
244      */
245     public void testBoundListenerPeersAfterCacheRemove() throws RemoteException {
246 
247         if (JVMUtil.isSingleRMIRegistryPerVM()) {
248             return;
249         }
250 
251         String[] boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
252         assertEquals(55, boundCachePeers.length);
253         validateBoundCachePeer(boundCachePeers);
254 
255         //Remove a replicated cache
256         manager1.removeCache("sampleCache1");
257         boundCachePeers = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).listBoundRMICachePeers();
258         assertEquals(54, boundCachePeers.length);
259         validateBoundCachePeer(boundCachePeers);
260     }
261 
262 
263     private void validateBoundCachePeer(String[] boundCachePeers) {
264         for (int i = 0; i < boundCachePeers.length; i++) {
265             String boundCacheName = boundCachePeers[i];
266             Remote remote = ((RMICacheManagerPeerListener) manager1.getCachePeerListener()).lookupPeer(boundCacheName);
267             assertNotNull(remote);
268         }
269     }
270 
271 
272     /**
273      * Does the RMI listener stop?
274      */
275     public void testListenerShutsdown() {
276 
277         if (JVMUtil.isSingleRMIRegistryPerVM()) {
278             return;
279         }
280 
281         CacheManagerPeerListener cachePeerListener = manager1.getCachePeerListener();
282         List cachePeers1 = cachePeerListener.getBoundCachePeers();
283         assertEquals(55, cachePeers1.size());
284         assertEquals(Status.STATUS_ALIVE, cachePeerListener.getStatus());
285 
286         manager1.shutdown();
287         assertEquals(Status.STATUS_SHUTDOWN, cachePeerListener.getStatus());
288 
289     }
290 
291     /**
292      * Does the RMI listener stop?
293      * <p/>
294      * This test does not actually do test the shutdown hook automatically. But you should be able to
295      * see "VM shutting down with the RMICacheManagerPeerListener for localhost still active. Calling dispose..."
296      * 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.
297      */
298     public void testListenerShutsdownFromShutdownHook() {
299 
300         if (JVMUtil.isSingleRMIRegistryPerVM()) {
301             return;
302         }
303 
304         CacheManager manager = new CacheManager(AbstractCacheTest.TEST_CONFIG_DIR + "distribution/ehcache-distributed6.xml");
305 
306         CacheManagerPeerListener cachePeerListener = manager.getCachePeerListener();
307         List cachePeers1 = cachePeerListener.getBoundCachePeers();
308         assertEquals(55, cachePeers1.size());
309         assertEquals(Status.STATUS_ALIVE, cachePeerListener.getStatus());
310 
311     }
312 }