View Javadoc

1   package org.codehaus.xfire.aegis;
2   
3   import java.io.InputStream;
4   import java.util.Collection;
5   import java.util.HashMap;
6   import java.util.Iterator;
7   import java.util.List;
8   import java.util.Map;
9   import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
10  import org.codehaus.plexus.configuration.PlexusConfiguration;
11  import org.codehaus.plexus.configuration.PlexusConfigurationException;
12  import org.codehaus.plexus.personality.plexus.lifecycle.phase.Initializable;
13  import org.codehaus.xfire.SOAPConstants;
14  import org.codehaus.xfire.XFireRuntimeException;
15  import org.codehaus.xfire.aegis.mapping.TypeRegistry;
16  import org.codehaus.xfire.aegis.operation.WrappedOperation;
17  import org.codehaus.xfire.aegis.wsdl.AegisWSDL;
18  import org.codehaus.xfire.fault.FaultHandler;
19  import org.codehaus.xfire.fault.SOAP11FaultHandler;
20  import org.codehaus.xfire.fault.SOAP12FaultHandler;
21  import org.codehaus.xfire.handler.Handler;
22  import org.codehaus.xfire.handler.dom.DOMHandler;
23  import org.codehaus.xfire.handler.dom.DOMPipelineHandler;
24  import org.codehaus.xfire.plexus.PlexusService;
25  import org.codehaus.xfire.wsdl.WSDLBuilder;
26  import org.dom4j.Document;
27  import org.dom4j.Element;
28  import org.dom4j.QName;
29  import org.dom4j.io.SAXReader;
30  
31  /***
32   * AegisService
33   * 
34   * @author <a href="mailto:dan@envoisolutions.com">Dan Diephouse</a>
35   */
36  public class AegisService
37      extends PlexusService
38      implements Initializable
39  {
40      private Document serviceDescriptor;
41  
42      private Map operations;
43      
44      private String serviceClassName;
45      
46      private TypeRegistry typeRegistry;
47      
48      private PlexusConfiguration[] handlers;
49      
50      private Handler serviceHandler;
51      
52      public AegisService()
53      {
54      	operations = new HashMap();
55      }
56  
57  	/***
58  	 * @see org.codehaus.xfire.service.Service#getFaultHandler()
59  	 */
60  	public FaultHandler getFaultHandler()
61  	{
62  		try
63          {
64              return (FaultHandler) getServiceLocator().lookup( FaultHandler.ROLE, "1.2" );            
65          }
66          catch (ComponentLookupException e)
67          {
68              throw new XFireRuntimeException( "Couldn't find service provider!", e );
69          }
70  	}
71  
72  	/***
73  	 * @see org.apache.avalon.framework.activity.Initializable#initialize()
74  	 */
75  	public void initialize() throws Exception
76  	{
77          super.initialize();
78          
79          DOMPipelineHandler pipe = (DOMPipelineHandler) getServiceHandler();
80  
81          if ( handlers != null && handlers.length > 0 )
82          {
83              for ( int i = 0; i < handlers.length; i++ )
84              {
85                  String hId = handlers[i].getValue();
86                  
87                  DOMHandler handler = (DOMHandler) getServiceLocator().lookup( DOMHandler.ROLE, hId );
88                  
89                  pipe.getHandlers().add( handler );
90              }
91          }
92          else
93          {
94              pipe.getHandlers().add( new AegisServiceHandler() );
95          }
96          
97          typeRegistry = (TypeRegistry) getServiceLocator().lookup(TypeRegistry.ROLE);
98          setWSDLBuilder((WSDLBuilder) getServiceLocator().lookup(WSDLBuilder.ROLE, "aegis"));
99          
100 		SAXReader xmlReader = new SAXReader();
101         serviceDescriptor = xmlReader.read( getServiceDescriptorStream() );
102 
103         createService();
104 
105         AegisWSDL wsdl = (AegisWSDL) getWSDL();
106 	}
107 
108     /***
109      * Create a service and operations from the service descriptor.
110      */
111 	protected void createService()
112 	{
113 		Element root = serviceDescriptor.getRootElement();
114         setDefaultNamespace( root.attribute("targetNamespace").getStringValue() );
115         setSoapVersion( root.attribute("soapVersion").getStringValue() );
116         
117         if ( getSoapVersion().equals ( SOAPConstants.SOAP12_ENVELOPE_NS ))
118         {
119         	setFaultHandlerHint( SOAP12FaultHandler.NAME );
120         }
121         else
122         {
123             setFaultHandlerHint( SOAP11FaultHandler.NAME );
124         }
125         
126         List elements = root.elements("operation");
127         for ( Iterator itr = elements.iterator(); itr.hasNext(); )
128         {
129         	Element opEl = (Element) itr.next();
130             
131             WrappedOperation op = new WrappedOperation();
132             op.configure( opEl, this, getTypeRegistry() );
133             
134             QName opQ = op.getQName();
135 
136             operations.put( opQ, op );
137         }
138 	}
139 
140 	public Collection getOperations()
141 	{
142 		return operations.values();
143 	}
144     
145     public WrappedOperation getOperation( QName name )
146     {
147         return (WrappedOperation) operations.get( name );
148     }
149     
150 	public TypeRegistry getTypeRegistry()
151 	{
152 		return typeRegistry;
153 	}
154 
155 	/***
156      * Returns an InputStream for the descriptor.
157      * @return InputStream representing the descriptor
158      */
159     public InputStream getServiceDescriptorStream()
160     {
161         String name = getServiceDescriptorName();
162         InputStream is = getClass().getResourceAsStream( name );
163         
164         if ( is == null )
165             throw new XFireRuntimeException("No service descriptor found: " + name);
166         
167         return is;
168     }
169 
170     public String getServiceDescriptorName()
171     {
172         String full = getServiceClassName();
173         full = "/" + full.replace('.', '/');
174 
175         return full + ".xml";
176     }
177     
178 	public Document getServiceDescriptor()
179 	{
180 		return serviceDescriptor;
181 	}
182     
183 	public String getServiceClassName()
184 	{
185 		return serviceClassName;
186 	}
187     
188 	public void setServiceClassName(String serviceClassName)
189 	{
190 		this.serviceClassName = serviceClassName;
191 	}
192     
193     public Object createServiceObject()
194     {
195         if ( getServiceLocator().hasComponent(getServiceClassName()) )
196         {
197         	try
198 			{
199 				return getServiceLocator().lookup( getServiceClassName() );
200 			}
201 			catch (ComponentLookupException e)
202 			{
203 				throw new XFireRuntimeException("Couldn't lookup service.", e);
204 			}
205         }
206         else
207         {
208         	ClassLoader cl = Thread.currentThread().getContextClassLoader();
209             
210             Class clazz;
211 			try
212 			{
213 				clazz = cl.loadClass(getServiceClassName());
214                 return clazz.newInstance();
215 			}
216 			catch (Exception e)
217 			{
218 				throw new XFireRuntimeException("Couldn't create service class.", e);
219 			}
220 			
221         }
222     }
223     
224     /***
225      * @see org.apache.avalon.framework.configuration.Configurable#configure(org.apache.avalon.framework.configuration.Configuration)
226      */
227     public void configure( PlexusConfiguration config ) throws PlexusConfigurationException
228     {
229         super.configure( config );
230         
231         setFaultHandlerHint( config.getChild("faultHandler").getValue("aegis") );
232         
233         setServiceClassName( config.getChild("serviceClass").getValue() );
234         setStyle( SOAPConstants.STYLE_WRAPPED );
235         setUse( SOAPConstants.USE_LITERAL );
236         
237         DOMPipelineHandler handler = new DOMPipelineHandler();
238         setServiceHandler( handler );
239         
240         handlers = config.getChild("handlers").getChildren("handler");
241     }
242     
243     
244     public Handler getServiceHandler()
245     {
246         return serviceHandler;
247     }
248     
249     public void setServiceHandler( Handler serviceHandler )
250     {
251         this.serviceHandler = serviceHandler;
252     }
253 }