001: /**
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */package org.apache.geronimo.kernel.config;
017:
018: import java.util.Collections;
019: import java.util.HashMap;
020: import java.util.HashSet;
021: import java.util.Map;
022: import java.util.Set;
023:
024: import junit.framework.TestCase;
025: import org.apache.geronimo.gbean.AbstractName;
026: import org.apache.geronimo.gbean.AbstractNameQuery;
027: import org.apache.geronimo.gbean.GBeanData;
028: import org.apache.geronimo.gbean.GBeanInfo;
029: import org.apache.geronimo.gbean.GBeanInfoBuilder;
030: import org.apache.geronimo.kernel.GBeanNotFoundException;
031: import org.apache.geronimo.kernel.Kernel;
032: import org.apache.geronimo.kernel.KernelFactory;
033: import org.apache.geronimo.kernel.management.State;
034: import org.apache.geronimo.kernel.mock.MockConfigStore;
035: import org.apache.geronimo.kernel.mock.MockRepository;
036: import org.apache.geronimo.kernel.repository.Artifact;
037: import org.apache.geronimo.kernel.repository.ArtifactManager;
038: import org.apache.geronimo.kernel.repository.DefaultArtifactManager;
039: import org.apache.geronimo.kernel.repository.DefaultArtifactResolver;
040: import org.apache.geronimo.kernel.repository.Environment;
041: import org.apache.geronimo.kernel.repository.ImportType;
042: import org.apache.geronimo.kernel.repository.ListableRepository;
043: import org.apache.geronimo.kernel.repository.Version;
044:
045: /**
046: * @version $Rev: 566893 $ $Date: 2007-08-16 17:52:52 -0700 (Thu, 16 Aug 2007) $
047: */
048: public class ConfigurationManagerTest extends TestCase {
049: private static Kernel kernel;
050: private Artifact artifact1;
051: private Artifact artifact2;
052: private Artifact artifact3;
053: private Artifact artifact3NoVersion;
054: private Map<Artifact, ConfigurationData> configurations = new HashMap<Artifact, ConfigurationData>();
055: private ConfigurationManager configurationManager;
056: private AbstractName gbean1;
057: private AbstractName gbean2;
058: private AbstractName gbean3;
059: private AbstractName gbean3newer;
060: private ConfigurationStore configStore = new MockConfigStore();
061:
062: public void testLoad() throws Exception {
063: configurationManager.loadConfiguration(artifact3);
064: assertTrue(configurationManager.isLoaded(artifact3));
065: assertTrue(configurationManager.isLoaded(artifact2));
066: assertTrue(configurationManager.isLoaded(artifact1));
067: assertFalse(configurationManager.isRunning(artifact3));
068: assertFalse(configurationManager.isRunning(artifact2));
069: assertFalse(configurationManager.isRunning(artifact1));
070: assertTrue(kernel.isLoaded(Configuration
071: .getConfigurationAbstractName(artifact3)));
072: assertTrue(kernel.isLoaded(Configuration
073: .getConfigurationAbstractName(artifact2)));
074: assertTrue(kernel.isLoaded(Configuration
075: .getConfigurationAbstractName(artifact1)));
076: assertEquals(State.RUNNING_INDEX, kernel
077: .getGBeanState(Configuration
078: .getConfigurationAbstractName(artifact3)));
079: assertEquals(State.RUNNING_INDEX, kernel
080: .getGBeanState(Configuration
081: .getConfigurationAbstractName(artifact2)));
082: assertEquals(State.RUNNING_INDEX, kernel
083: .getGBeanState(Configuration
084: .getConfigurationAbstractName(artifact1)));
085: assertFalse(kernel.isLoaded(gbean1));
086: assertFalse(kernel.isLoaded(gbean2));
087: assertFalse(kernel.isLoaded(gbean3));
088:
089: configurationManager.unloadConfiguration(artifact3);
090: assertFalse(configurationManager.isLoaded(artifact3));
091: assertFalse(configurationManager.isLoaded(artifact2));
092: assertFalse(configurationManager.isLoaded(artifact1));
093: assertFalse(configurationManager.isRunning(artifact3));
094: assertFalse(configurationManager.isRunning(artifact2));
095: assertFalse(configurationManager.isRunning(artifact1));
096: assertFalse(kernel.isLoaded(Configuration
097: .getConfigurationAbstractName(artifact3)));
098: assertFalse(kernel.isLoaded(Configuration
099: .getConfigurationAbstractName(artifact2)));
100: assertFalse(kernel.isLoaded(Configuration
101: .getConfigurationAbstractName(artifact1)));
102: }
103:
104: public void testStart() throws Exception {
105: configurationManager.loadConfiguration(artifact3);
106: assertTrue(configurationManager.isLoaded(artifact3));
107: assertTrue(configurationManager.isLoaded(artifact2));
108: assertTrue(configurationManager.isLoaded(artifact1));
109: assertFalse(configurationManager.isRunning(artifact3));
110: assertFalse(configurationManager.isRunning(artifact2));
111: assertFalse(configurationManager.isRunning(artifact1));
112: assertTrue(kernel.isLoaded(Configuration
113: .getConfigurationAbstractName(artifact3)));
114: assertTrue(kernel.isLoaded(Configuration
115: .getConfigurationAbstractName(artifact2)));
116: assertTrue(kernel.isLoaded(Configuration
117: .getConfigurationAbstractName(artifact1)));
118: assertEquals(State.RUNNING_INDEX, kernel
119: .getGBeanState(Configuration
120: .getConfigurationAbstractName(artifact3)));
121: assertEquals(State.RUNNING_INDEX, kernel
122: .getGBeanState(Configuration
123: .getConfigurationAbstractName(artifact2)));
124: assertEquals(State.RUNNING_INDEX, kernel
125: .getGBeanState(Configuration
126: .getConfigurationAbstractName(artifact1)));
127: assertFalse(kernel.isLoaded(gbean1));
128: assertFalse(kernel.isLoaded(gbean2));
129: assertFalse(kernel.isLoaded(gbean3));
130:
131: configurationManager.startConfiguration(artifact3);
132: assertTrue(configurationManager.isRunning(artifact3));
133: assertTrue(configurationManager.isRunning(artifact2));
134: assertTrue(configurationManager.isRunning(artifact1));
135: assertTrue(kernel.isLoaded(gbean1));
136: assertTrue(kernel.isLoaded(gbean2));
137: assertTrue(kernel.isLoaded(gbean3));
138: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
139: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
140: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean3));
141:
142: configurationManager.stopConfiguration(artifact3);
143: assertTrue(configurationManager.isLoaded(artifact3));
144: assertTrue(configurationManager.isLoaded(artifact2));
145: assertTrue(configurationManager.isLoaded(artifact1));
146: assertFalse(configurationManager.isRunning(artifact3));
147: assertFalse(configurationManager.isRunning(artifact2));
148: assertFalse(configurationManager.isRunning(artifact1));
149: assertFalse(kernel.isLoaded(gbean1));
150: assertFalse(kernel.isLoaded(gbean2));
151: assertFalse(kernel.isLoaded(gbean3));
152:
153: configurationManager.unloadConfiguration(artifact3);
154: assertFalse(configurationManager.isLoaded(artifact3));
155: assertFalse(configurationManager.isLoaded(artifact2));
156: assertFalse(configurationManager.isRunning(artifact3));
157: assertFalse(configurationManager.isRunning(artifact2));
158: assertFalse(configurationManager.isRunning(artifact1));
159: assertFalse(configurationManager.isLoaded(artifact1));
160: assertFalse(kernel.isLoaded(Configuration
161: .getConfigurationAbstractName(artifact3)));
162: assertFalse(kernel.isLoaded(Configuration
163: .getConfigurationAbstractName(artifact2)));
164: assertFalse(kernel.isLoaded(Configuration
165: .getConfigurationAbstractName(artifact1)));
166: }
167:
168: public void testRestart() throws Exception {
169: configurationManager.loadConfiguration(artifact3);
170: configurationManager.startConfiguration(artifact3);
171: Object g1 = kernel.getGBean(gbean1);
172: Object g2 = kernel.getGBean(gbean2);
173: Object g3 = kernel.getGBean(gbean3);
174: assertSame(g1, kernel.getGBean(gbean1));
175: assertSame(g2, kernel.getGBean(gbean2));
176: assertSame(g3, kernel.getGBean(gbean3));
177:
178: //
179: // restart artifact1 which should cascade to the children
180: //
181: LifecycleResults results = configurationManager
182: .restartConfiguration(artifact1);
183:
184: // all three should have been stopped and then started
185: assertTrue(results.wasStopped(artifact1));
186: assertTrue(results.wasStopped(artifact2));
187: assertTrue(results.wasStopped(artifact3));
188: assertTrue(results.wasStarted(artifact1));
189: assertTrue(results.wasStarted(artifact2));
190: assertTrue(results.wasStarted(artifact3));
191:
192: // none of them should have been unloaded, loaded or failed
193: assertFalse(results.wasUnloaded(artifact1));
194: assertFalse(results.wasUnloaded(artifact2));
195: assertFalse(results.wasUnloaded(artifact3));
196: assertFalse(results.wasLoaded(artifact1));
197: assertFalse(results.wasLoaded(artifact2));
198: assertFalse(results.wasLoaded(artifact3));
199: assertFalse(results.wasFailed(artifact1));
200: assertFalse(results.wasFailed(artifact2));
201: assertFalse(results.wasFailed(artifact3));
202:
203: // check the state of the kernel
204: assertTrue(kernel.isLoaded(Configuration
205: .getConfigurationAbstractName(artifact3)));
206: assertTrue(kernel.isLoaded(Configuration
207: .getConfigurationAbstractName(artifact2)));
208: assertTrue(kernel.isLoaded(Configuration
209: .getConfigurationAbstractName(artifact1)));
210: assertEquals(State.RUNNING_INDEX, kernel
211: .getGBeanState(Configuration
212: .getConfigurationAbstractName(artifact3)));
213: assertEquals(State.RUNNING_INDEX, kernel
214: .getGBeanState(Configuration
215: .getConfigurationAbstractName(artifact2)));
216: assertEquals(State.RUNNING_INDEX, kernel
217: .getGBeanState(Configuration
218: .getConfigurationAbstractName(artifact1)));
219: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
220: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
221: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean3));
222: assertNotSame(g1, kernel.getGBean(gbean1));
223: assertNotSame(g2, kernel.getGBean(gbean2));
224: assertNotSame(g3, kernel.getGBean(gbean3));
225:
226: configurationManager.stopConfiguration(artifact3);
227: assertFalse(kernel.isLoaded(gbean2));
228: assertFalse(kernel.isLoaded(gbean3));
229:
230: // bean3 should still be running because it is now user started due to the restart above
231: assertTrue(kernel.isLoaded(gbean1));
232: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
233:
234: configurationManager.unloadConfiguration(artifact3);
235: assertFalse(configurationManager.isLoaded(artifact3));
236: assertFalse(configurationManager.isLoaded(artifact2));
237: assertFalse(kernel.isLoaded(Configuration
238: .getConfigurationAbstractName(artifact3)));
239: assertFalse(kernel.isLoaded(Configuration
240: .getConfigurationAbstractName(artifact2)));
241:
242: // artifact 1 should still be loaded and running since it was user started above
243: assertTrue(configurationManager.isLoaded(artifact1));
244: assertTrue(kernel.isLoaded(Configuration
245: .getConfigurationAbstractName(artifact1)));
246: assertTrue(kernel.isLoaded(gbean1));
247: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
248:
249: configurationManager.unloadConfiguration(artifact1);
250: assertFalse(configurationManager.isLoaded(artifact1));
251: assertFalse(kernel.isLoaded(Configuration
252: .getConfigurationAbstractName(artifact1)));
253: assertFalse(kernel.isLoaded(gbean1));
254:
255: }
256:
257: public void testRestartException() throws Exception {
258: configurationManager.loadConfiguration(artifact3);
259: configurationManager.startConfiguration(artifact3);
260: Object g1 = kernel.getGBean(gbean1);
261: Object g2 = kernel.getGBean(gbean2);
262: kernel.getGBean(gbean3);
263:
264: // make gbean3 fail and restart all configs
265: shouldFail.add(gbean3.getObjectName().getCanonicalName());
266: LifecycleResults results = configurationManager
267: .restartConfiguration(artifact1);
268:
269: // 3 should have been stopped and failed, but not started
270: assertTrue(results.wasStopped(artifact3));
271: assertTrue(results.wasFailed(artifact3));
272: assertFalse(results.wasStarted(artifact3));
273:
274: // one and two shoudld have stopped and then started and not failed
275: assertTrue(results.wasStopped(artifact1));
276: assertTrue(results.wasStopped(artifact2));
277: assertTrue(results.wasStarted(artifact1));
278: assertTrue(results.wasStarted(artifact2));
279: assertFalse(results.wasFailed(artifact1));
280: assertFalse(results.wasFailed(artifact2));
281:
282: // none of them should have been unloaded or loaded
283: assertFalse(results.wasUnloaded(artifact1));
284: assertFalse(results.wasUnloaded(artifact2));
285: assertFalse(results.wasUnloaded(artifact3));
286: assertFalse(results.wasLoaded(artifact1));
287: assertFalse(results.wasLoaded(artifact2));
288: assertFalse(results.wasLoaded(artifact3));
289:
290: // all configuration should be loaded
291: assertTrue(configurationManager.isLoaded(artifact3));
292: assertTrue(configurationManager.isLoaded(artifact2));
293: assertTrue(configurationManager.isLoaded(artifact1));
294: assertTrue(kernel.isLoaded(Configuration
295: .getConfigurationAbstractName(artifact3)));
296: assertTrue(kernel.isLoaded(Configuration
297: .getConfigurationAbstractName(artifact2)));
298: assertTrue(kernel.isLoaded(Configuration
299: .getConfigurationAbstractName(artifact1)));
300: assertEquals(State.RUNNING_INDEX, kernel
301: .getGBeanState(Configuration
302: .getConfigurationAbstractName(artifact3)));
303: assertEquals(State.RUNNING_INDEX, kernel
304: .getGBeanState(Configuration
305: .getConfigurationAbstractName(artifact2)));
306: assertEquals(State.RUNNING_INDEX, kernel
307: .getGBeanState(Configuration
308: .getConfigurationAbstractName(artifact1)));
309:
310: // but configuration 3 should not be running
311: assertTrue(configurationManager.isRunning(artifact1));
312: assertTrue(configurationManager.isRunning(artifact2));
313: assertFalse(configurationManager.isRunning(artifact3));
314: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
315: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
316: assertFalse(kernel.isLoaded(gbean3));
317:
318: // make sure that gbean 1 and 2 were recreated
319: assertNotSame(g1, kernel.getGBean(gbean1));
320: assertNotSame(g2, kernel.getGBean(gbean2));
321:
322: configurationManager.unloadConfiguration(artifact1);
323: assertFalse(configurationManager.isLoaded(artifact3));
324: assertFalse(configurationManager.isLoaded(artifact2));
325: assertFalse(configurationManager.isLoaded(artifact1));
326: assertFalse(kernel.isLoaded(Configuration
327: .getConfigurationAbstractName(artifact3)));
328: assertFalse(kernel.isLoaded(Configuration
329: .getConfigurationAbstractName(artifact2)));
330: assertFalse(kernel.isLoaded(Configuration
331: .getConfigurationAbstractName(artifact1)));
332: }
333:
334: public void testReload() throws Exception {
335: configurationManager.loadConfiguration(artifact3);
336: configurationManager.startConfiguration(artifact3);
337: Object g1 = kernel.getGBean(gbean1);
338: Object g2 = kernel.getGBean(gbean2);
339: Object g3 = kernel.getGBean(gbean3);
340: assertSame(g1, kernel.getGBean(gbean1));
341: assertSame(g2, kernel.getGBean(gbean2));
342: assertSame(g3, kernel.getGBean(gbean3));
343: Configuration configuration1 = configurationManager
344: .getConfiguration(artifact1);
345: Configuration configuration2 = configurationManager
346: .getConfiguration(artifact2);
347: Configuration configuration3 = configurationManager
348: .getConfiguration(artifact3);
349:
350: LifecycleResults results = configurationManager
351: .reloadConfiguration(artifact1);
352:
353: // check the results
354: // all three should have been stopped, unloaded, loaded and then started
355: assertTrue(results.wasStopped(artifact1));
356: assertTrue(results.wasStopped(artifact2));
357: assertTrue(results.wasStopped(artifact3));
358: assertTrue(results.wasUnloaded(artifact1));
359: assertTrue(results.wasUnloaded(artifact2));
360: assertTrue(results.wasUnloaded(artifact3));
361: assertTrue(results.wasLoaded(artifact1));
362: assertTrue(results.wasLoaded(artifact2));
363: assertTrue(results.wasLoaded(artifact3));
364: assertTrue(results.wasStarted(artifact1));
365: assertTrue(results.wasStarted(artifact2));
366: assertTrue(results.wasStarted(artifact3));
367:
368: // none of them should have been failed
369: assertFalse(results.wasFailed(artifact1));
370: assertFalse(results.wasFailed(artifact2));
371: assertFalse(results.wasFailed(artifact3));
372:
373: // check the state of the configuration manager
374: assertTrue(configurationManager.isLoaded(artifact1));
375: assertTrue(configurationManager.isLoaded(artifact2));
376: assertTrue(configurationManager.isLoaded(artifact3));
377: assertTrue(configurationManager.isRunning(artifact1));
378: assertTrue(configurationManager.isRunning(artifact2));
379: assertTrue(configurationManager.isRunning(artifact3));
380: assertNotSame(configuration1, configurationManager
381: .getConfiguration(artifact1));
382: assertNotSame(configuration2, configurationManager
383: .getConfiguration(artifact2));
384: assertNotSame(configuration3, configurationManager
385: .getConfiguration(artifact3));
386:
387: // check the state of the kernel
388: assertTrue(kernel.isLoaded(Configuration
389: .getConfigurationAbstractName(artifact3)));
390: assertTrue(kernel.isLoaded(Configuration
391: .getConfigurationAbstractName(artifact2)));
392: assertTrue(kernel.isLoaded(Configuration
393: .getConfigurationAbstractName(artifact1)));
394: assertTrue(kernel.isRunning(Configuration
395: .getConfigurationAbstractName(artifact3)));
396: assertTrue(kernel.isRunning(Configuration
397: .getConfigurationAbstractName(artifact2)));
398: assertTrue(kernel.isRunning(Configuration
399: .getConfigurationAbstractName(artifact1)));
400: assertEquals(State.RUNNING_INDEX, kernel
401: .getGBeanState(Configuration
402: .getConfigurationAbstractName(artifact3)));
403: assertEquals(State.RUNNING_INDEX, kernel
404: .getGBeanState(Configuration
405: .getConfigurationAbstractName(artifact2)));
406: assertEquals(State.RUNNING_INDEX, kernel
407: .getGBeanState(Configuration
408: .getConfigurationAbstractName(artifact1)));
409: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
410: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
411: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean3));
412: assertNotSame(g1, kernel.getGBean(gbean1));
413: assertNotSame(g2, kernel.getGBean(gbean2));
414: assertNotSame(g3, kernel.getGBean(gbean3));
415:
416: configurationManager.stopConfiguration(artifact3);
417: assertFalse(kernel.isLoaded(gbean1));
418: assertFalse(kernel.isLoaded(gbean2));
419: assertFalse(kernel.isLoaded(gbean3));
420:
421: configurationManager.unloadConfiguration(artifact3);
422: assertFalse(configurationManager.isLoaded(artifact3));
423: assertFalse(configurationManager.isLoaded(artifact2));
424: assertFalse(kernel.isLoaded(Configuration
425: .getConfigurationAbstractName(artifact3)));
426: assertFalse(kernel.isLoaded(Configuration
427: .getConfigurationAbstractName(artifact2)));
428:
429: // artifact 1 should still be loaded since it was user loaded above
430: assertTrue(configurationManager.isLoaded(artifact1));
431: assertTrue(kernel.isLoaded(Configuration
432: .getConfigurationAbstractName(artifact1)));
433:
434: configurationManager.unloadConfiguration(artifact1);
435: assertFalse(configurationManager.isLoaded(artifact1));
436: assertFalse(kernel.isLoaded(Configuration
437: .getConfigurationAbstractName(artifact1)));
438: }
439:
440: public void testReloadException() throws Exception {
441: configurationManager.loadConfiguration(artifact3);
442: configurationManager.startConfiguration(artifact3);
443: Object g1 = kernel.getGBean(gbean1);
444: Object g2 = kernel.getGBean(gbean2);
445: kernel.getGBean(gbean3);
446:
447: // make gbean3 fail and Reload all configs
448: shouldFail.add(gbean3.getObjectName().getCanonicalName());
449: LifecycleResults results = configurationManager
450: .reloadConfiguration(artifact1);
451:
452: // check the results
453:
454: // 3 should have been stopped, unloaded and then failed
455: assertTrue(results.wasStopped(artifact3));
456: assertTrue(results.wasUnloaded(artifact3));
457: assertTrue(results.wasFailed(artifact3));
458: assertFalse(results.wasLoaded(artifact3));
459: assertFalse(results.wasStarted(artifact3));
460:
461: // 1 and 2 should have been stopped, unloaded, loaded and then started
462: assertTrue(results.wasStopped(artifact1));
463: assertTrue(results.wasStopped(artifact2));
464: assertTrue(results.wasUnloaded(artifact1));
465: assertTrue(results.wasUnloaded(artifact2));
466: assertTrue(results.wasLoaded(artifact1));
467: assertTrue(results.wasLoaded(artifact2));
468: assertTrue(results.wasStarted(artifact1));
469: assertTrue(results.wasStarted(artifact2));
470:
471: // all configuration except 3 should be loaded
472: assertFalse(configurationManager.isLoaded(artifact3));
473: assertTrue(configurationManager.isLoaded(artifact2));
474: assertTrue(configurationManager.isLoaded(artifact1));
475: assertFalse(kernel.isLoaded(Configuration
476: .getConfigurationAbstractName(artifact3)));
477: assertTrue(kernel.isLoaded(Configuration
478: .getConfigurationAbstractName(artifact2)));
479: assertTrue(kernel.isLoaded(Configuration
480: .getConfigurationAbstractName(artifact1)));
481: assertEquals(State.RUNNING_INDEX, kernel
482: .getGBeanState(Configuration
483: .getConfigurationAbstractName(artifact2)));
484: assertEquals(State.RUNNING_INDEX, kernel
485: .getGBeanState(Configuration
486: .getConfigurationAbstractName(artifact1)));
487:
488: // configuration 3 should not be running
489: assertTrue(configurationManager.isRunning(artifact1));
490: assertTrue(configurationManager.isRunning(artifact2));
491: assertFalse(configurationManager.isRunning(artifact3));
492: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
493: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
494: assertFalse(kernel.isLoaded(gbean3));
495:
496: // make sure that gbean 1 and 2 were recreated
497: assertNotSame(g1, kernel.getGBean(gbean1));
498: assertNotSame(g2, kernel.getGBean(gbean2));
499:
500: configurationManager.unloadConfiguration(artifact1);
501: assertFalse(configurationManager.isLoaded(artifact3));
502: assertFalse(configurationManager.isLoaded(artifact2));
503: assertFalse(configurationManager.isLoaded(artifact1));
504: assertFalse(kernel.isLoaded(Configuration
505: .getConfigurationAbstractName(artifact3)));
506: assertFalse(kernel.isLoaded(Configuration
507: .getConfigurationAbstractName(artifact2)));
508: assertFalse(kernel.isLoaded(Configuration
509: .getConfigurationAbstractName(artifact1)));
510: }
511:
512: public void testReloadFallback() throws Exception {
513: configurationManager.loadConfiguration(artifact3);
514: configurationManager.startConfiguration(artifact3);
515: Object g1 = kernel.getGBean(gbean1);
516: Object g2 = kernel.getGBean(gbean2);
517: Object g3 = kernel.getGBean(gbean3);
518: assertSame(g1, kernel.getGBean(gbean1));
519: assertSame(g2, kernel.getGBean(gbean2));
520: assertSame(g3, kernel.getGBean(gbean3));
521: Configuration configuration1 = configurationManager
522: .getConfiguration(artifact1);
523: Configuration configuration2 = configurationManager
524: .getConfiguration(artifact2);
525: Configuration configuration3 = configurationManager
526: .getConfiguration(artifact3);
527:
528: ConfigurationData configurationData1 = new ConfigurationData(
529: artifact1, kernel.getNaming());
530: configStore.install(configurationData1);
531: GBeanData gbeanData = configurationData1.addGBean("gbean1",
532: TestBean.getGBeanInfo());
533: gbeanData.setReferencePattern("nonExistantReference",
534: new AbstractNameQuery("some.non.existant.Clazz"));
535: configurations.put(artifact1, configurationData1);
536:
537: LifecycleResults results = null;
538: try {
539: configurationManager.reloadConfiguration(artifact1);
540: fail("Expected LifecycleException");
541: } catch (LifecycleException expected) {
542: results = expected.getLifecycleResults();
543: }
544:
545: // check the results
546:
547: // 1 should be failed
548: assertTrue(results.wasFailed(artifact1));
549:
550: // but all three did stop, unload, load and start
551: assertTrue(results.wasStopped(artifact1));
552: assertTrue(results.wasStopped(artifact2));
553: assertTrue(results.wasStopped(artifact3));
554: assertTrue(results.wasUnloaded(artifact1));
555: assertTrue(results.wasUnloaded(artifact2));
556: assertTrue(results.wasUnloaded(artifact3));
557: assertTrue(results.wasLoaded(artifact1));
558: assertTrue(results.wasLoaded(artifact2));
559: assertTrue(results.wasLoaded(artifact3));
560: assertTrue(results.wasStarted(artifact1));
561: assertTrue(results.wasStarted(artifact2));
562: assertTrue(results.wasStarted(artifact3));
563:
564: // check the state of the configuration manager
565: assertTrue(configurationManager.isLoaded(artifact1));
566: assertTrue(configurationManager.isLoaded(artifact2));
567: assertTrue(configurationManager.isLoaded(artifact3));
568: assertTrue(configurationManager.isRunning(artifact1));
569: assertTrue(configurationManager.isRunning(artifact2));
570: assertTrue(configurationManager.isRunning(artifact3));
571: assertNotSame(configuration1, configurationManager
572: .getConfiguration(artifact1));
573: assertNotSame(configuration2, configurationManager
574: .getConfiguration(artifact2));
575: assertNotSame(configuration3, configurationManager
576: .getConfiguration(artifact3));
577:
578: // check the state of the kernel
579: assertTrue(kernel.isLoaded(Configuration
580: .getConfigurationAbstractName(artifact3)));
581: assertTrue(kernel.isLoaded(Configuration
582: .getConfigurationAbstractName(artifact2)));
583: assertTrue(kernel.isLoaded(Configuration
584: .getConfigurationAbstractName(artifact1)));
585: assertTrue(kernel.isRunning(Configuration
586: .getConfigurationAbstractName(artifact3)));
587: assertTrue(kernel.isRunning(Configuration
588: .getConfigurationAbstractName(artifact2)));
589: assertTrue(kernel.isRunning(Configuration
590: .getConfigurationAbstractName(artifact1)));
591: assertEquals(State.RUNNING_INDEX, kernel
592: .getGBeanState(Configuration
593: .getConfigurationAbstractName(artifact3)));
594: assertEquals(State.RUNNING_INDEX, kernel
595: .getGBeanState(Configuration
596: .getConfigurationAbstractName(artifact2)));
597: assertEquals(State.RUNNING_INDEX, kernel
598: .getGBeanState(Configuration
599: .getConfigurationAbstractName(artifact1)));
600: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
601: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
602: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean3));
603: assertNotSame(g1, kernel.getGBean(gbean1));
604: assertNotSame(g2, kernel.getGBean(gbean2));
605: assertNotSame(g3, kernel.getGBean(gbean3));
606:
607: configurationManager.stopConfiguration(artifact3);
608: assertFalse(kernel.isLoaded(gbean1));
609: assertFalse(kernel.isLoaded(gbean2));
610: assertFalse(kernel.isLoaded(gbean3));
611:
612: configurationManager.unloadConfiguration(artifact3);
613: assertFalse(configurationManager.isLoaded(artifact3));
614: assertFalse(configurationManager.isLoaded(artifact2));
615: assertFalse(kernel.isLoaded(Configuration
616: .getConfigurationAbstractName(artifact3)));
617: assertFalse(kernel.isLoaded(Configuration
618: .getConfigurationAbstractName(artifact2)));
619:
620: // artifact 1 should still be loaded since it was user loaded above
621: assertTrue(configurationManager.isLoaded(artifact1));
622: assertTrue(kernel.isLoaded(Configuration
623: .getConfigurationAbstractName(artifact1)));
624:
625: configurationManager.unloadConfiguration(artifact1);
626: assertFalse(configurationManager.isLoaded(artifact1));
627: assertFalse(kernel.isLoaded(Configuration
628: .getConfigurationAbstractName(artifact1)));
629: }
630:
631: public void testReloadNewerConfiguration() throws Exception {
632: configurationManager.loadConfiguration(artifact3);
633: configurationManager.startConfiguration(artifact3);
634: Object g1 = kernel.getGBean(gbean1);
635: Object g2 = kernel.getGBean(gbean2);
636: Object g3 = kernel.getGBean(gbean3);
637: try {
638: kernel.getGBean(gbean3newer);
639: fail("Should not have found the newer GBean yet");
640: } catch (GBeanNotFoundException e) {
641: }
642: assertSame(g1, kernel.getGBean(gbean1));
643: assertSame(g2, kernel.getGBean(gbean2));
644: assertSame(g3, kernel.getGBean(gbean3));
645: Configuration configuration1 = configurationManager
646: .getConfiguration(artifact1);
647: Configuration configuration2 = configurationManager
648: .getConfiguration(artifact2);
649: Configuration configuration3 = configurationManager
650: .getConfiguration(artifact3);
651: assertNull(configurationManager
652: .getConfiguration(artifact3NoVersion));
653:
654: LifecycleResults results = configurationManager
655: .reloadConfiguration(artifact1);
656:
657: // check the results
658: assertTrue(results.wasStopped(artifact1));
659: assertTrue(results.wasStopped(artifact2));
660: assertTrue(results.wasStopped(artifact3));
661: assertTrue(results.wasUnloaded(artifact1));
662: assertTrue(results.wasUnloaded(artifact2));
663: assertTrue(results.wasUnloaded(artifact3));
664: assertTrue(results.wasLoaded(artifact1));
665: assertTrue(results.wasLoaded(artifact2));
666: assertTrue(results.wasLoaded(artifact3));
667: assertTrue(results.wasStarted(artifact1));
668: assertTrue(results.wasStarted(artifact2));
669: assertTrue(results.wasStarted(artifact3));
670: assertFalse(results.wasFailed(artifact3NoVersion));
671: assertFalse(results.wasLoaded(artifact3NoVersion));
672: assertFalse(results.wasLoaded(artifact3NoVersion));
673: assertFalse(results.wasStarted(artifact3NoVersion));
674: assertFalse(results.wasStarted(artifact3NoVersion));
675: assertFalse(results.wasStopped(artifact3NoVersion));
676: assertFalse(results.wasUnloaded(artifact3NoVersion));
677:
678: // check the state of the configuration manager
679: assertTrue(configurationManager.isLoaded(artifact1));
680: assertTrue(configurationManager.isLoaded(artifact2));
681: assertTrue(configurationManager.isLoaded(artifact3));
682: assertFalse(configurationManager.isLoaded(artifact3NoVersion));
683: assertTrue(configurationManager.isRunning(artifact1));
684: assertTrue(configurationManager.isRunning(artifact2));
685: assertTrue(configurationManager.isRunning(artifact3));
686: assertFalse(configurationManager.isRunning(artifact3NoVersion));
687: assertNotSame(configuration1, configurationManager
688: .getConfiguration(artifact1));
689: assertNotSame(configuration2, configurationManager
690: .getConfiguration(artifact2));
691: assertNotSame(configuration3, configurationManager
692: .getConfiguration(artifact3));
693:
694: // check the state of the kernel
695: assertTrue(kernel.isLoaded(Configuration
696: .getConfigurationAbstractName(artifact3)));
697: assertTrue(kernel.isLoaded(Configuration
698: .getConfigurationAbstractName(artifact2)));
699: assertTrue(kernel.isLoaded(Configuration
700: .getConfigurationAbstractName(artifact1)));
701: assertFalse(kernel.isLoaded(Configuration
702: .getConfigurationAbstractName(artifact3NoVersion)));
703: assertTrue(kernel.isRunning(Configuration
704: .getConfigurationAbstractName(artifact3)));
705: assertTrue(kernel.isRunning(Configuration
706: .getConfigurationAbstractName(artifact2)));
707: assertTrue(kernel.isRunning(Configuration
708: .getConfigurationAbstractName(artifact1)));
709: assertFalse(kernel.isRunning(Configuration
710: .getConfigurationAbstractName(artifact3NoVersion)));
711: assertEquals(State.RUNNING_INDEX, kernel
712: .getGBeanState(Configuration
713: .getConfigurationAbstractName(artifact3)));
714: assertEquals(State.RUNNING_INDEX, kernel
715: .getGBeanState(Configuration
716: .getConfigurationAbstractName(artifact2)));
717: assertEquals(State.RUNNING_INDEX, kernel
718: .getGBeanState(Configuration
719: .getConfigurationAbstractName(artifact1)));
720: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
721: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
722: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean3));
723: assertNotSame(g1, kernel.getGBean(gbean1));
724: assertNotSame(g2, kernel.getGBean(gbean2));
725: assertNotSame(g3, kernel.getGBean(gbean3));
726:
727: //
728: // Reload a newer version of artifact3 (artifact3NoVersion, which has a timestamp as the version number)
729: //
730: results = configurationManager.reloadConfiguration(artifact3,
731: artifact3NoVersion.getVersion());
732:
733: // artifact 3 should be stopped, unloaded and 3noVersion should have been loaded and started in it's place
734: assertTrue(results.wasStopped(artifact3));
735: assertTrue(results.wasUnloaded(artifact3));
736: assertTrue(results.wasLoaded(artifact3NoVersion));
737: assertTrue(results.wasStarted(artifact3NoVersion));
738: assertFalse(results.wasLoaded(artifact3));
739: assertFalse(results.wasStarted(artifact3));
740:
741: // artifact 1 and 2 should not have been touched
742: assertFalse(results.wasStopped(artifact1));
743: assertFalse(results.wasStopped(artifact2));
744: assertFalse(results.wasUnloaded(artifact1));
745: assertFalse(results.wasUnloaded(artifact2));
746: assertFalse(results.wasLoaded(artifact1));
747: assertFalse(results.wasLoaded(artifact2));
748: assertFalse(results.wasStarted(artifact1));
749: assertFalse(results.wasStarted(artifact2));
750:
751: // nothing should have failed
752: assertFalse(results.wasFailed(artifact1));
753: assertFalse(results.wasFailed(artifact2));
754: assertFalse(results.wasFailed(artifact3));
755: assertFalse(results.wasFailed(artifact3NoVersion));
756:
757: // check the state of the configuration manager
758: assertTrue(configurationManager.isLoaded(artifact1));
759: assertTrue(configurationManager.isLoaded(artifact2));
760: assertFalse(configurationManager.isLoaded(artifact3));
761: assertTrue(configurationManager.isLoaded(artifact3NoVersion));
762: assertTrue(configurationManager.isRunning(artifact1));
763: assertTrue(configurationManager.isRunning(artifact2));
764: assertFalse(configurationManager.isRunning(artifact3));
765: assertTrue(configurationManager.isRunning(artifact3NoVersion));
766:
767: // check the state of the kernel
768: assertFalse(kernel.isLoaded(Configuration
769: .getConfigurationAbstractName(artifact3)));
770: assertTrue(kernel.isLoaded(Configuration
771: .getConfigurationAbstractName(artifact2)));
772: assertTrue(kernel.isLoaded(Configuration
773: .getConfigurationAbstractName(artifact1)));
774: assertTrue(kernel.isLoaded(Configuration
775: .getConfigurationAbstractName(artifact3NoVersion)));
776: assertFalse(kernel.isRunning(Configuration
777: .getConfigurationAbstractName(artifact3)));
778: assertTrue(kernel.isRunning(Configuration
779: .getConfigurationAbstractName(artifact2)));
780: assertTrue(kernel.isRunning(Configuration
781: .getConfigurationAbstractName(artifact1)));
782: assertTrue(kernel.isRunning(Configuration
783: .getConfigurationAbstractName(artifact3NoVersion)));
784: assertEquals(
785: State.RUNNING_INDEX,
786: kernel
787: .getGBeanState(Configuration
788: .getConfigurationAbstractName(artifact3NoVersion)));
789: assertEquals(State.RUNNING_INDEX, kernel
790: .getGBeanState(Configuration
791: .getConfigurationAbstractName(artifact2)));
792: assertEquals(State.RUNNING_INDEX, kernel
793: .getGBeanState(Configuration
794: .getConfigurationAbstractName(artifact1)));
795: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean1));
796: assertEquals(State.RUNNING_INDEX, kernel.getGBeanState(gbean2));
797: assertEquals(State.RUNNING_INDEX, kernel
798: .getGBeanState(gbean3newer));
799: }
800:
801: private static final Set<String> shouldFail = new HashSet<String>();
802:
803: private static void checkFail(String objectName) {
804: if (shouldFail.contains(objectName)) {
805: throw new RuntimeException("FAILING");
806: }
807: }
808:
809: protected void setUp() throws Exception {
810: super .setUp();
811:
812: shouldFail.clear();
813:
814: kernel = KernelFactory.newInstance().createKernel("test");
815: kernel.boot();
816:
817: GBeanData artifactManagerData = buildGBeanData("name",
818: "ArtifactManager", DefaultArtifactManager.GBEAN_INFO);
819: kernel.loadGBean(artifactManagerData, getClass()
820: .getClassLoader());
821: kernel.startGBean(artifactManagerData.getAbstractName());
822: assertEquals(State.RUNNING_INDEX, kernel
823: .getGBeanState(artifactManagerData.getAbstractName()));
824: ArtifactManager artifactManager = (ArtifactManager) kernel
825: .getGBean(artifactManagerData.getAbstractName());
826:
827: ListableRepository testRepository = new MockRepository(
828: configurations.keySet());
829: DefaultArtifactResolver artifactResolver = new DefaultArtifactResolver(
830: artifactManager, testRepository);
831:
832: artifact1 = new Artifact("test", "1", "1.1", "bar");
833: artifact2 = new Artifact("test", "2", "2.2", "bar");
834: artifact3 = new Artifact("test", "3", "3.3", "bar");
835: // As if it was deployed with no version, now its version is a timestamp
836: artifact3NoVersion = new Artifact(artifact3.getGroupId(),
837: artifact3.getArtifactId(), new Version(Long
838: .toString(System.currentTimeMillis())),
839: artifact3.getType());
840:
841: ConfigurationData configurationData1 = configStore
842: .loadConfiguration(artifact1);
843: gbean1 = configurationData1.addGBean("gbean1",
844: TestBean.getGBeanInfo()).getAbstractName();
845: configurations.put(artifact1, configurationData1);
846:
847: Environment e2 = new Environment();
848: e2.setConfigId(artifact2);
849: e2.addDependency(new Artifact("test", "1", (Version) null,
850: "bar"), ImportType.ALL);
851: ConfigurationData configurationData2 = new ConfigurationData(
852: e2, kernel.getNaming());
853: gbean2 = configurationData2.addGBean("gbean2",
854: TestBean.getGBeanInfo()).getAbstractName();
855: configStore.install(configurationData2);
856: configurations.put(artifact2, configurationData2);
857:
858: { // Make it obvious if these temp variables are reused
859: Environment e3 = new Environment();
860: e3.setConfigId(artifact3);
861: e3.addDependency(new Artifact("test", "2", (Version) null,
862: "bar"), ImportType.ALL);
863: ConfigurationData configurationData3 = new ConfigurationData(
864: e3, kernel.getNaming());
865: gbean3 = configurationData3.addGBean("gbean3",
866: TestBean.getGBeanInfo()).getAbstractName();
867: configStore.install(configurationData3);
868: configurations.put(artifact3, configurationData3);
869: }
870:
871: {
872: Environment e3newer = new Environment();
873: e3newer.setConfigId(artifact3NoVersion);
874: e3newer.addDependency(new Artifact("test", "2",
875: (Version) null, "bar"), ImportType.ALL);
876: ConfigurationData configurationData3newer = new ConfigurationData(
877: e3newer, kernel.getNaming());
878: gbean3newer = configurationData3newer.addGBean("gbean3",
879: TestBean.getGBeanInfo()).getAbstractName();
880: configStore.install(configurationData3newer);
881: configurations.put(artifact3NoVersion,
882: configurationData3newer);
883: }
884:
885: configurationManager = new KernelConfigurationManager(kernel,
886: Collections.singleton(configStore), null, null,
887: artifactManager, artifactResolver, Collections
888: .singleton(testRepository),
889: Collections.EMPTY_SET, KernelConfigurationManager.class
890: .getClassLoader());
891: }
892:
893: protected void tearDown() throws Exception {
894: kernel.shutdown();
895: super .tearDown();
896: }
897:
898: private GBeanData buildGBeanData(String key, String value,
899: GBeanInfo info) {
900: AbstractName abstractName = kernel.getNaming().createRootName(
901: new Artifact("test", "foo", "1", "car"), value, key);
902: return new GBeanData(abstractName, info);
903: }
904:
905: public static class TestBean {
906: public TestBean(String objectName) {
907: checkFail(objectName);
908: }
909:
910: private static final GBeanInfo GBEAN_INFO;
911: static {
912: GBeanInfoBuilder builder = GBeanInfoBuilder
913: .createStatic(TestBean.class);
914: builder.addAttribute("objectName", String.class, false);
915: builder.setConstructor(new String[] { "objectName" });
916: GBEAN_INFO = builder.getBeanInfo();
917: }
918:
919: public static GBeanInfo getGBeanInfo() {
920: return GBEAN_INFO;
921: }
922: }
923: }
|