KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > webservice > server > InvokerProvider


1 /*
2  * JBoss, the OpenSource J2EE webOS
3  *
4  * Distributable under LGPL license.
5  * See terms of license at gnu.org.
6  */
7 package org.jboss.webservice.server;
8
9 // $Id: InvokerProvider.java,v 1.20.2.9 2005/06/17 22:33:06 tdiesler Exp $
10
11 import org.jboss.axis.AxisFault;
12 import org.jboss.axis.MessageContext;
13 import org.jboss.axis.handlers.soap.SOAPService;
14 import org.jboss.axis.message.SOAPEnvelopeAxisImpl;
15 import org.jboss.axis.providers.java.RPCInvocation;
16 import org.jboss.axis.providers.java.RPCProvider;
17 import org.jboss.axis.transport.http.HTTPConstants;
18 import org.jboss.deployment.DeploymentInfo;
19 import org.jboss.logging.Logger;
20 import org.jboss.mx.util.MBeanServerLocator;
21 import org.jboss.webservice.AxisServiceMBean;
22 import org.jboss.webservice.PortComponentInfo;
23 import org.jboss.webservice.handler.ServerHandlerChain;
24 import org.jboss.webservice.metadata.PortComponentMetaData;
25 import org.jboss.webservice.metadata.WebserviceDescriptionMetaData;
26 import org.jboss.webservice.metadata.serviceref.HandlerMetaData;
27 import org.jboss.webservice.metadata.serviceref.InitParamMetaData;
28 import org.w3c.dom.Document JavaDoc;
29
30 import javax.management.MBeanServer JavaDoc;
31 import javax.servlet.http.HttpServletRequest JavaDoc;
32 import javax.xml.namespace.QName JavaDoc;
33 import javax.xml.rpc.handler.HandlerInfo JavaDoc;
34 import java.lang.reflect.Method JavaDoc;
35 import java.util.ArrayList JavaDoc;
36 import java.util.Arrays JavaDoc;
37 import java.util.HashMap JavaDoc;
38 import java.util.HashSet JavaDoc;
39
40 /**
41  * An RPC provider base that provides access to some
42  * webservice specific meta-data artifacts through JMX.
43  *
44  * @author Thomas.Diesler@jboss.org
45  * @since 15-April-2004
46  */
47 public abstract class InvokerProvider extends RPCProvider
48 {
49    /** @since 4.0.2 */
50    static final long serialVersionUID = 3036485550614460123L;
51    // provide logging
52 private Logger log = Logger.getLogger(InvokerProvider.class);
53
54    // The MBeanServer
55 protected MBeanServer JavaDoc server;
56
57    // This endpoint's port component
58 protected PortComponentInfo portComponentInfo;
59    // This port components handler chain
60 protected ServerHandlerChain handlerChain;
61
62    /**
63     * Get deployment meta info
64     * <p/>
65     * Note, the msgContext may be null if the request is not a SOAP message
66     * this is the case for the list operation http://localhost:8080/ws4ee/servlet/AxisServlet
67     *
68     * @param msgContext the SOAP MessageContext, or null
69     */
70    public void initServiceDesc(SOAPService service, MessageContext msgContext)
71            throws AxisFault
72    {
73       log.debug("initServiceDesc: service=" + service.getName());
74
75       try
76       {
77          // locate the MBeanServer
78 server = MBeanServerLocator.locateJBoss();
79
80          String JavaDoc wsID = (String JavaDoc)service.getOption(PortComponentMetaData.PARAMETER_WEBSERVICE_ID);
81          portComponentInfo = (PortComponentInfo)server.invoke(AxisServiceMBean.OBJECT_NAME,
82                  "getPortComponentInfo", new Object JavaDoc[]{wsID}, new String JavaDoc[]{String JavaDoc.class.getName()});
83          if (portComponentInfo == null)
84             throw new ServiceException("Cannot obtain port component info for: " + wsID);
85
86          // init the handler chain
87 initHandlerChain();
88       }
89       catch (Exception JavaDoc e)
90       {
91          throw new ServiceException("Cannot initialize webservice", e);
92       }
93
94       // delegate to parent
95 super.initServiceDesc(service, msgContext);
96    }
97
98    /**
99     * Init the handler chain
100     */
101    private void initHandlerChain() throws Exception JavaDoc
102    {
103       ClassLoader JavaDoc cl = getContextClassLoader();
104
105       HashSet JavaDoc handlerRoles = new HashSet JavaDoc();
106       ArrayList JavaDoc handlerInfos = new ArrayList JavaDoc();
107
108       HandlerMetaData[] handlers = portComponentInfo.getPortComponentMetaData().getHandlers();
109       for (int i = 0; i < handlers.length; i++)
110       {
111          HandlerMetaData hMetaData = handlers[i];
112          handlerRoles.addAll(Arrays.asList(hMetaData.getSoapRoles()));
113
114          Class JavaDoc hClass = cl.loadClass(hMetaData.getHandlerClass());
115
116          HashMap JavaDoc hConfig = new HashMap JavaDoc();
117          InitParamMetaData[] params = hMetaData.getInitParams();
118          for (int j = 0; j < params.length; j++)
119          {
120             InitParamMetaData param = params[j];
121             hConfig.put(param.getParamName(), param.getParamValue());
122          }
123          QName JavaDoc[] hHeaders = hMetaData.getSoapHeaders();
124          HandlerInfo JavaDoc info = new HandlerInfo JavaDoc(hClass, hConfig, hHeaders);
125
126          String JavaDoc serviceName = portComponentInfo.getPortComponentMetaData().getPortComponentName();
127          log.debug("Adding server side handler to service '" + serviceName + "': " + info);
128
129          handlerInfos.add(info);
130       }
131
132       handlerChain = new ServerHandlerChain(handlerInfos, handlerRoles);
133
134       ClassLoader JavaDoc ccl = Thread.currentThread().getContextClassLoader();
135       try
136       {
137          Thread.currentThread().setContextClassLoader(getContextClassLoader());
138
139          if (handlerChain.getState() == ServerHandlerChain.STATE_CREATED)
140          {
141             // what is the config for a handler chain?
142 handlerChain.init(null);
143          }
144       }
145       finally
146       {
147          Thread.currentThread().setContextClassLoader(ccl);
148       }
149    }
150
151    /**
152     * Get the context CLassLoader for this service
153     */
154    abstract protected ClassLoader JavaDoc getContextClassLoader();
155
156    /**
157     * Generate the WSDL for this service.
158     * <p/>
159     * Put in the "WSDL" property of the message context
160     * as a org.w3c.dom.Document
161     */
162    public void generateWSDL(MessageContext msgContext) throws AxisFault
163    {
164       HttpServletRequest JavaDoc req = (HttpServletRequest JavaDoc)msgContext.getProperty(HTTPConstants.MC_HTTP_SERVLETREQUEST);
165       if (req == null)
166          throw new IllegalStateException JavaDoc("Cannot obtain HttpServletRequest from msg context");
167
168       try
169       {
170          // For the base document the resourcePath should be null
171 String JavaDoc resourcePath = (String JavaDoc)msgContext.getProperty(MessageContext.WSDLGEN_RESOURCE);
172          String JavaDoc requestURI = req.getRequestURI();
173
174          WebserviceDescriptionMetaData webserviceDescription = portComponentInfo.getPortComponentMetaData().getWebserviceDescription();
175          DeploymentInfo di = portComponentInfo.getDeploymentInfo();
176          WSDLRequestHandler wsdlRequestHandler = new WSDLRequestHandler(webserviceDescription, di);
177          Document JavaDoc document = wsdlRequestHandler.getDocumentForPath(requestURI, resourcePath);
178
179          msgContext.setProperty("WSDL", document);
180       }
181       catch (Exception JavaDoc e)
182       {
183          log.error("Cannot process WSDL document", e);
184       }
185    }
186
187    public RPCInvocation createRPCInvocation(MessageContext msgContext, SOAPEnvelopeAxisImpl reqEnv, SOAPEnvelopeAxisImpl resEnv, Object JavaDoc obj)
188    {
189       RPCInvocation invocation = new JBossRPCInvocation(this, msgContext, reqEnv, resEnv, obj);
190       return invocation;
191    }
192
193    public PortComponentInfo getPortComponentInfo()
194    {
195       return portComponentInfo;
196    }
197
198    /**
199     * Returns the Class info about the service class.
200     */
201    protected Class JavaDoc getServiceClass(String JavaDoc clsName, SOAPService service, MessageContext msgContext)
202            throws AxisFault
203    {
204       ClassLoader JavaDoc ccl = Thread.currentThread().getContextClassLoader();
205       try
206       {
207          // The super implementation tries the classloader that is set in the msgContext
208 // if not found it falls back to the context class loader
209 Thread.currentThread().setContextClassLoader(getContextClassLoader());
210
211          String JavaDoc seiName = portComponentInfo.getPortComponentMetaData().getServiceEndpointInterface();
212          return super.getServiceClass(seiName, service, msgContext);
213       }
214       finally
215       {
216          Thread.currentThread().setContextClassLoader(ccl);
217       }
218    }
219
220    /**
221     * Return the class name of the service.
222     * We return the SEI instead.
223     */
224    protected String JavaDoc getServiceClassName(org.jboss.axis.Handler handler)
225    {
226       return portComponentInfo.getPortComponentMetaData().getServiceEndpointInterface();
227    }
228
229    /**
230     * Invoke the service endpoint.
231     */
232    protected final Object JavaDoc invokeMethod(MessageContext msgContext, Method JavaDoc method, Object JavaDoc obj, Object JavaDoc[] argValues) throws Exception JavaDoc
233    {
234       ClassLoader JavaDoc ccl = Thread.currentThread().getContextClassLoader();
235       try
236       {
237          Thread.currentThread().setContextClassLoader(getContextClassLoader());
238          return invokeServiceEndpoint(msgContext, method, obj, argValues);
239       }
240       finally
241       {
242          Thread.currentThread().setContextClassLoader(ccl);
243       }
244    }
245
246    /**
247     * Overwrite for EJB, and JSE endpoint invocation
248     */
249    protected abstract Object JavaDoc invokeServiceEndpoint(MessageContext msgContext, Method JavaDoc method, Object JavaDoc obj, Object JavaDoc[] argValues) throws Exception JavaDoc;
250 }
251
Popular Tags