Coverage Report

Coverage Report - org.apache.commons.messagelet.Main

Classes in this File

Line Coverage

Branch Coverage

Complexity

Main

0/67

0/10

2.143

 /*
  * Copyright (C) The Apache Software Foundation. All rights reserved.
  *
  * This software is published under the terms of the Apache Software License
  * version 1.1, a copy of which has been included with this distribution in
  * the LICENSE file.
  * 
  * $Id: Main.java 155459 2005-02-26 13:24:44Z dirkv $
  */
 package org.apache.commons.messagelet;
 
 import java.util.Iterator;
 
 import javax.jms.JMSException;
 import javax.servlet.ServletContext;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.commons.messagelet.model.SubscriptionDigester;
 import org.apache.commons.messagelet.model.SubscriptionList;
 import org.apache.commons.messenger.Messenger;
 import org.apache.commons.messenger.MessengerManager;
 
 /** 
  * <p><code>Main</code> is a simple command line program that will
  * create a number of subscriptions and consume messages using just regular 
  * MDO and MessageListener classes.
  *
  * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
  * @version $Revision: 155459 $
  */
 public class Main {
 
     /** Logger */
     private static final Log log = LogFactory.getLog(Main.class);
 
     /** The JMS connections */    
     private MessengerManager manager;
 
     /** The JMS Subscriptions */
     private SubscriptionList subscriptionList;
     
     /** The URI that connections are loaded from */
     private String connectionsConfig = "Messenger.xml";
     
     /** The URI where subscriptions are loaded from */
     private String subscriptionsConfig = "subscriptions.xml";
 
     /** Should we use a stopwatch to output performance metrics */
     private boolean useStopWatch = false;
 
     
     public static void main(String[] args) {
         Main main = new Main();
         if ( args.length <= 0 ) {
             System.out.println( "Usage <subscriptionConfigFile> [<connectionsConfigFile>]" );
             return;
         }
         if ( args.length > 0 ) {
             main.setSubscriptionsConfig( args[0] );
         }
         if ( args.length > 1 ) {
             main.setConnectionsConfig( args[1] );
         }
 
         try {
             main.run();
         }        
         catch (Exception e) {
             log.error( "Caught: " + e, e );
         }
     }
     
     public Main() {
     }
 
 
     /**
      * Starts all the JMS connections and consumes JMS messages, 
      * passing them onto the MessageListener and Message Driven Objects
      */
     public void run() throws Exception {
 
         // force lazy construction
         SubscriptionManager subscriber = new SubscriptionManager();
         subscriber.setMessengerManager( getMessengerManager() );
         subscriber.setSubscriptionList( createSubscriptionList() );
         subscriber.setServletContext( getServletContext() );
         
         subscriber.subscribe();
         
         // now lets start all the connections...
         for (Iterator iter = manager.getMessengerNames(); iter.hasNext(); ) {
             String name = (String) iter.next();
             Messenger messenger = manager.getMessenger( name );
             try {
                 messenger.getConnection().start();
             }
             catch (JMSException e) {
                 log.error( "Caught exception trying to start messenger: " + name + ". Exception: " + e, e );
             }
         }
         
         //waitForever();
     }
 
     
     public Messenger getMessenger(String name) throws JMSException {
         return getMessengerManager().getMessenger( name );
     }
     
     
     // Properties
     //-------------------------------------------------------------------------    
 
     public String getConnectionsConfig() {
         return connectionsConfig;
     }
     
     public void setConnectionsConfig(String connectionsConfig) {
         this.connectionsConfig = connectionsConfig;
     }
     
     public String getSubscriptionsConfig() {
         return subscriptionsConfig;
     }
     
     public void setSubscriptionsConfig(String subscriptionsConfig) {
         this.subscriptionsConfig = subscriptionsConfig;
     }
     
     public MessengerManager getMessengerManager() throws JMSException {
         if ( manager == null ) {
             manager = createMessengerManager();
             MessengerManager.setInstance( manager );
         }
         return manager;
     }
     
     public void setMessengerManager(MessengerManager manager) {
         this.manager = manager;
     }
     
     // Implementation methods
     //-------------------------------------------------------------------------    
     protected MessengerManager createMessengerManager() throws JMSException {
         String config = connectionsConfig;
         
         log.info( "Creating the JMS connections from the file: " + config );
         
         try {
             return MessengerManager.load( config );
         }
         catch (JMSException e) {
             log.error( "Could not parse Messenger connection XML deployment document for URL: " + config, e );
             
             throw new JMSException(
                 "Could not parse Messenger connection XML deployment document for URL: " + config
                 + " reason: " + e
             );
         }
     }
     
     protected SubscriptionList createSubscriptionList() throws JMSException {
         String config = subscriptionsConfig;
         
         log.info( "Loading the JMS subscriptions from: " + config );
         
         try {
             SubscriptionDigester digester = new SubscriptionDigester();
             return (SubscriptionList) digester.parse( config );
         }
         catch (Exception e) {
             log.error( "Could not parse Messenger subscription XML deployment document for URL: " + config, e );
             
             throw new JMSException(
                 "Could not parse Messenger subscription XML deployment document for URL: " + config
                 + " reason: " + e
             );
         }
     }
     
     protected ServletContext getServletContext() {
         return null;
     }
     
     /**
      * This method blocks the current thread indefinitely until the JVM is terminated.
      */
     protected void waitForever() {
         Object lock = new Object();
         synchronized (lock) {
             while (true) {
                 try {
                     lock.wait();
                 }
                 catch (Exception e) {
                     log.warn( "Main thread interupted: " + e, e );
                 }
             }
         }
     }
 }

1		/*
2		* Copyright (C) The Apache Software Foundation. All rights reserved.
3		*
4		* This software is published under the terms of the Apache Software License
5		* version 1.1, a copy of which has been included with this distribution in
6		* the LICENSE file.
7		*
8		* $Id: Main.java 155459 2005-02-26 13:24:44Z dirkv $
9		*/
10		package org.apache.commons.messagelet;
11
12		import java.util.Iterator;
13
14		import javax.jms.JMSException;
15		import javax.servlet.ServletContext;
16
17		import org.apache.commons.logging.Log;
18		import org.apache.commons.logging.LogFactory;
19		import org.apache.commons.messagelet.model.SubscriptionDigester;
20		import org.apache.commons.messagelet.model.SubscriptionList;
21		import org.apache.commons.messenger.Messenger;
22		import org.apache.commons.messenger.MessengerManager;
23
24		/**
25		* <p><code>Main</code> is a simple command line program that will
26		* create a number of subscriptions and consume messages using just regular
27		* MDO and MessageListener classes.
28		*
29		* @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
30		* @version $Revision: 155459 $
31		*/
32		public class Main {
33
34		/** Logger */
35	0	private static final Log log = LogFactory.getLog(Main.class);
36
37		/** The JMS connections */
38		private MessengerManager manager;
39
40		/** The JMS Subscriptions */
41		private SubscriptionList subscriptionList;
42
43		/** The URI that connections are loaded from */
44	0	private String connectionsConfig = "Messenger.xml";
45
46		/** The URI where subscriptions are loaded from */
47	0	private String subscriptionsConfig = "subscriptions.xml";
48
49		/** Should we use a stopwatch to output performance metrics */
50	0	private boolean useStopWatch = false;
51
52
53		public static void main(String[] args) {
54	0	Main main = new Main();
55	0	if ( args.length <= 0 ) {
56	0	System.out.println( "Usage <subscriptionConfigFile> [<connectionsConfigFile>]" );
57	0	return;
58		}
59	0	if ( args.length > 0 ) {
60	0	main.setSubscriptionsConfig( args[0] );
61		}
62	0	if ( args.length > 1 ) {
63	0	main.setConnectionsConfig( args[1] );
64		}
65
66		try {
67	0	main.run();
68		}
69	0	catch (Exception e) {
70	0	log.error( "Caught: " + e, e );
71	0	}
72	0	}
73
74	0	public Main() {
75	0	}
76
77
78		/**
79		* Starts all the JMS connections and consumes JMS messages,
80		* passing them onto the MessageListener and Message Driven Objects
81		*/
82		public void run() throws Exception {
83
84		// force lazy construction
85	0	SubscriptionManager subscriber = new SubscriptionManager();
86	0	subscriber.setMessengerManager( getMessengerManager() );
87	0	subscriber.setSubscriptionList( createSubscriptionList() );
88	0	subscriber.setServletContext( getServletContext() );
89
90	0	subscriber.subscribe();
91
92		// now lets start all the connections...
93	0	for (Iterator iter = manager.getMessengerNames(); iter.hasNext(); ) {
94	0	String name = (String) iter.next();
95	0	Messenger messenger = manager.getMessenger( name );
96		try {
97	0	messenger.getConnection().start();
98		}
99	0	catch (JMSException e) {
100	0	log.error( "Caught exception trying to start messenger: " + name + ". Exception: " + e, e );
101	0	}
102	0	}
103
104		//waitForever();
105	0	}
106
107
108		public Messenger getMessenger(String name) throws JMSException {
109	0	return getMessengerManager().getMessenger( name );
110		}
111
112
113		// Properties
114		//-------------------------------------------------------------------------
115
116		public String getConnectionsConfig() {
117	0	return connectionsConfig;
118		}
119
120		public void setConnectionsConfig(String connectionsConfig) {
121	0	this.connectionsConfig = connectionsConfig;
122	0	}
123
124		public String getSubscriptionsConfig() {
125	0	return subscriptionsConfig;
126		}
127
128		public void setSubscriptionsConfig(String subscriptionsConfig) {
129	0	this.subscriptionsConfig = subscriptionsConfig;
130	0	}
131
132		public MessengerManager getMessengerManager() throws JMSException {
133	0	if ( manager == null ) {
134	0	manager = createMessengerManager();
135	0	MessengerManager.setInstance( manager );
136		}
137	0	return manager;
138		}
139
140		public void setMessengerManager(MessengerManager manager) {
141	0	this.manager = manager;
142	0	}
143
144		// Implementation methods
145		//-------------------------------------------------------------------------
146		protected MessengerManager createMessengerManager() throws JMSException {
147	0	String config = connectionsConfig;
148
149	0	log.info( "Creating the JMS connections from the file: " + config );
150
151		try {
152	0	return MessengerManager.load( config );
153		}
154	0	catch (JMSException e) {
155	0	log.error( "Could not parse Messenger connection XML deployment document for URL: " + config, e );
156
157	0	throw new JMSException(
158		"Could not parse Messenger connection XML deployment document for URL: " + config
159		+ " reason: " + e
160		);
161		}
162		}
163
164		protected SubscriptionList createSubscriptionList() throws JMSException {
165	0	String config = subscriptionsConfig;
166
167	0	log.info( "Loading the JMS subscriptions from: " + config );
168
169		try {
170	0	SubscriptionDigester digester = new SubscriptionDigester();
171	0	return (SubscriptionList) digester.parse( config );
172		}
173	0	catch (Exception e) {
174	0	log.error( "Could not parse Messenger subscription XML deployment document for URL: " + config, e );
175
176	0	throw new JMSException(
177		"Could not parse Messenger subscription XML deployment document for URL: " + config
178		+ " reason: " + e
179		);
180		}
181		}
182
183		protected ServletContext getServletContext() {
184	0	return null;
185		}
186
187		/**
188		* This method blocks the current thread indefinitely until the JVM is terminated.
189		*/
190		protected void waitForever() {
191	0	Object lock = new Object();
192	0	synchronized (lock) {
193		while (true) {
194		try {
195	0	lock.wait();
196		}
197	0	catch (Exception e) {
198	0	log.warn( "Main thread interupted: " + e, e );
199	0	}
200		}
201	0	}
202		}
203		}