KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > nightlabs > ipanema > asyncinvoke > AsyncInvoke


1 /*
2  * Created on Mar 23, 2005
3  */

4 package com.nightlabs.ipanema.asyncinvoke;
5
6 import java.io.IOException JavaDoc;
7
8 import javax.ejb.CreateException JavaDoc;
9 import javax.jms.JMSException JavaDoc;
10 import javax.jms.Message JavaDoc;
11 import javax.jms.Queue JavaDoc;
12 import javax.jms.QueueConnection JavaDoc;
13 import javax.jms.QueueConnectionFactory JavaDoc;
14 import javax.jms.QueueSender JavaDoc;
15 import javax.jms.QueueSession JavaDoc;
16 import javax.jms.Session JavaDoc;
17 import javax.naming.InitialContext JavaDoc;
18 import javax.naming.NamingException JavaDoc;
19 import javax.security.auth.callback.Callback JavaDoc;
20 import javax.security.auth.callback.CallbackHandler JavaDoc;
21 import javax.security.auth.callback.NameCallback JavaDoc;
22 import javax.security.auth.callback.PasswordCallback JavaDoc;
23 import javax.security.auth.callback.UnsupportedCallbackException JavaDoc;
24 import javax.security.auth.login.LoginContext JavaDoc;
25 import javax.security.auth.login.LoginException JavaDoc;
26
27 import com.nightlabs.ipanema.base.IpanemaServerLocalLoginManager;
28 import com.nightlabs.ipanema.servermanager.j2ee.JMSConnectionFactoryLookup;
29
30 /**
31  * This class is your entry point for asynchronous method invocation. Simply create an
32  * instance and call one of the <tt>asyncInvoke(...)</tt> methods. This class is intended
33  * for throw-away-usage. Means, you should obtain a new instance in every bean method where
34  * you need it.
35  *
36  * @author Marco Schulze - marco at nightlabs dot de
37  */

38 public class AsyncInvoke
39 {
40     protected static final String JavaDoc QUEUE_INVOCATION = "queue/ipanema/IpanemaBaseBean/AsyncInvokerInvocationQueue";
41     protected static final String JavaDoc QUEUE_SUCCESSCALLBACK = "queue/ipanema/IpanemaBaseBean/AsyncInvokerSuccessCallbackQueue";
42     protected static final String JavaDoc QUEUE_ERRORCALLBACK = "queue/ipanema/IpanemaBaseBean/AsyncInvokerErrorCallbackQueue";
43     protected static final String JavaDoc QUEUE_UNDELIVERABLECALLBACK = "queue/ipanema/IpanemaBaseBean/AsyncInvokerUndeliverableCallbackQueue";
44
45     private InitialContext JavaDoc initialContext = null;
46
47     public AsyncInvoke()
48     {
49     }
50
51     /**
52      * This is a convenience method which calls {@link #asyncInvoke(Invocation, SuccessCallback, ErrorCallback, UndeliverableCallback)}.
53      * @throws CreateException
54      */

55     public void exec(Invocation invocation)
56     throws JMSException JavaDoc, NamingException JavaDoc, LoginException JavaDoc
57     {
58         exec(invocation, null, null, null);
59     }
60
61     /**
62      * This is a convenience method which calls {@link #asyncInvoke(Invocation, SuccessCallback, ErrorCallback, UndeliverableCallback)}.
63      * @throws CreateException
64      */

65     public void exec(
66             Invocation invocation, SuccessCallback successCallback)
67     throws JMSException JavaDoc, NamingException JavaDoc, LoginException JavaDoc
68     {
69         exec(invocation, successCallback, null, null);
70     }
71
72     /**
73      * This is a convenience method which calls {@link #asyncInvoke(Invocation, SuccessCallback, ErrorCallback, UndeliverableCallback)}.
74      * @throws CreateException
75      */

76     public void exec(
77             Invocation invocation, ErrorCallback errorCallback)
78     throws JMSException JavaDoc, NamingException JavaDoc, LoginException JavaDoc
79     {
80         exec(invocation, null, errorCallback, null);
81     }
82
83     /**
84      * This is a convenience method which calls {@link #asyncInvoke(Invocation, SuccessCallback, ErrorCallback, UndeliverableCallback)}.
85      * @throws CreateException
86      */

87     public void exec(
88             Invocation invocation, UndeliverableCallback undeliverableCallback)
89     throws JMSException JavaDoc, NamingException JavaDoc, LoginException JavaDoc
90     {
91         exec(invocation, null, null, undeliverableCallback);
92     }
93
94     /**
95      * @param invocation The <tt>Invocation</tt> that should be done asynchronously.
96      * <tt>invocation</tt> MUST NOT be <tt>null</tt>.
97      *
98      * @param successCallback An optional callback that is executed in a separate asynchronous
99      * transaction (means a failure does not affect the previous <tt>Invocation</tt>). To include
100      * your success callback in the same XATransaction as the invocation, leave this param <tt>null</tt>
101      * and do your callback directly in <tt>invocation</tt>. <tt>successCallback</tt> might be <tt>null</tt>.
102      *
103      * @param errorCallback An optional callback that is triggered every time the <tt>invocation</tt>
104      * failed. It is executed asynchronously within a separate XATransaction (unlinked to the
105      * <tt>invocation</tt> which is a necessity as the original XATransaction will be rolled back in
106      * case of an error). <tt>errorCallback</tt> might be <tt>null</tt>.
107      *
108      * @param undeliverableCallback After a certain number of failed invocation retries, the <tt>invocation</tt>
109      * is given up and this callback triggered. The default configuration is to retry an <tt>invocation</tt> once
110      * per hour and to give up after a month (31 days). <tt>undeliverableCallback</tt> might be <tt>null</tt>.
111      *
112      * @throws JMSException
113      * @throws NamingException
114      * @throws CreateException
115      */

116     public void exec(
117             Invocation invocation, SuccessCallback successCallback,
118             ErrorCallback errorCallback, UndeliverableCallback undeliverableCallback)
119     throws JMSException JavaDoc, NamingException JavaDoc, LoginException JavaDoc
120     {
121         AsyncInvokeEnvelope envelope = new AsyncInvokeEnvelope(
122                 invocation, successCallback, errorCallback, undeliverableCallback);
123         enqueue(QUEUE_INVOCATION, envelope);
124     }
125     
126     protected static class AuthCallbackHandler implements CallbackHandler JavaDoc
127     {
128         private String JavaDoc userName;
129         private char[] password;
130
131         public AuthCallbackHandler(String JavaDoc userName, char[] password) {
132             this.userName = userName;
133             this.password = password;
134         }
135
136         /**
137          * @see javax.security.auth.callback.CallbackHandler#handle(javax.security.auth.callback.Callback[])
138          */

139         public void handle(Callback JavaDoc[] callbacks)
140         throws IOException JavaDoc,
141                 UnsupportedCallbackException JavaDoc
142         {
143             for (int i = 0; i < callbacks.length; ++i) {
144                 Callback JavaDoc cb = callbacks[i];
145                 if (cb instanceof NameCallback JavaDoc) {
146                     ((NameCallback JavaDoc)cb).setName(userName);
147                 }
148                 else if (cb instanceof PasswordCallback JavaDoc) {
149                     ((PasswordCallback JavaDoc)cb).setPassword(password);
150                 }
151                 else throw new UnsupportedCallbackException JavaDoc(cb);
152             }
153         }
154     }
155
156     protected AuthCallbackHandler mqCallbackHandler = null;
157
158     protected void enqueue(String JavaDoc queueJNDIName, AsyncInvokeEnvelope envelope)
159     throws JMSException JavaDoc, NamingException JavaDoc, LoginException JavaDoc
160     {
161         if (initialContext == null)
162             initialContext = new InitialContext JavaDoc();
163
164         if (mqCallbackHandler == null) {
165             IpanemaServerLocalLoginManager m = IpanemaServerLocalLoginManager.getIpanemaServerLocalLoginManager(initialContext);
166
167             mqCallbackHandler = new AuthCallbackHandler(
168                     IpanemaServerLocalLoginManager.PRINCIPAL_LOCALQUEUEWRITER,
169                     m.getPrincipal(IpanemaServerLocalLoginManager.PRINCIPAL_LOCALQUEUEWRITER).getPassword().toCharArray());
170         }
171
172         LoginContext JavaDoc loginContext = new LoginContext JavaDoc("ipanemaLocal", mqCallbackHandler);
173         loginContext.login();
174         try {
175             QueueConnectionFactory JavaDoc connectionFactory = JMSConnectionFactoryLookup.lookupQueueConnectionFactory(initialContext);
176
177             QueueConnection JavaDoc connection = null;
178             QueueSession JavaDoc session = null;
179             QueueSender JavaDoc sender = null;
180
181             try {
182                 connection = connectionFactory.createQueueConnection();
183                 session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
184                 Queue JavaDoc queue = (Queue JavaDoc) initialContext.lookup(queueJNDIName);
185                 sender = session.createSender(queue);
186     
187                 Message JavaDoc message = session.createObjectMessage(envelope);
188                 sender.send(message);
189             } finally {
190                 if (sender != null) sender.close();
191                 if (session != null) session.close();
192                 if (connection != null) connection.close();
193             }
194         } finally {
195             loginContext.logout();
196         }
197     }
198
199 }
200
Popular Tags