View Javadoc

1   package org.codehaus.xfire;
2   
3   import java.io.IOException;
4   import java.io.InputStream;
5   import java.io.OutputStream;
6   
7   import javax.wsdl.WSDLException;
8   import javax.xml.stream.XMLInputFactory;
9   import javax.xml.stream.XMLStreamException;
10  import javax.xml.stream.XMLStreamReader;
11  
12  import org.apache.commons.logging.Log;
13  import org.apache.commons.logging.LogFactory;
14  import org.codehaus.xfire.fault.XFireFault;
15  import org.codehaus.xfire.handler.Handler;
16  import org.codehaus.xfire.service.DefaultServiceRegistry;
17  import org.codehaus.xfire.service.Service;
18  import org.codehaus.xfire.service.ServiceRegistry;
19  import org.codehaus.xfire.transport.DefaultTransportManager;
20  import org.codehaus.xfire.transport.Transport;
21  import org.codehaus.xfire.transport.TransportManager;
22  import org.codehaus.xfire.wsdl.WSDLWriter;
23  
24  /***
25   * @author <a href="mailto:dan@envoisolutions.com">Dan Diephouse</a>
26   * @since Feb 13, 2004
27   */
28  public class DefaultXFire
29      extends AbstractXFireComponent
30      implements XFire
31  {
32      private ServiceRegistry registry;
33  
34      private TransportManager transportManager;
35  
36      private static final Log logger = LogFactory.getLog( DefaultXFire.class );
37  
38      public DefaultXFire()
39      {
40          registry = new DefaultServiceRegistry();
41          transportManager = new DefaultTransportManager(registry);
42      }
43  
44      public DefaultXFire( final ServiceRegistry registry,
45                           final TransportManager transportManager )
46      {
47          this.registry = registry;
48          this.transportManager = transportManager;
49      }
50  
51      public void invoke( final XMLStreamReader reader,
52                          final MessageContext context )
53      {
54          final String serviceName =  context.getServiceName();
55          final Service service = findService( serviceName );
56  
57          Handler handler = null;
58          try
59          {
60              final Transport transport = context.getTransport();
61              
62              // Verify that the transport can be used for this service.
63              if (transport != null 
64                  &&
65                  !getTransportManager().isEnabled(context.getServiceName(), transport.getName()))
66              {
67                  throw new XFireFault("Service " + serviceName + 
68                                           " is unavailable for current transport.", 
69                                       XFireFault.SENDER);
70              }
71              
72              context.setService( service );
73              context.setXMLStreamReader( reader );
74  
75              if( service == null )
76              {
77                  throw new XFireRuntimeException( "No such service." );
78              }
79  
80              handler = service.getServiceHandler();
81  
82              handler.invoke( context );
83          }
84          catch( Exception e )
85          {
86              handleException(context, service, handler, e);
87          }
88      }
89  
90      /***
91       * @param context
92       * @param service
93       * @param handler
94       * @param e
95       */
96      protected void handleException(final MessageContext context, 
97                                     final Service service, 
98                                     final Handler handler, 
99                                     final Exception e)
100     {
101         if(e instanceof XFireRuntimeException)
102         {
103             throw (XFireRuntimeException)e;
104         }
105         else if( handler != null )
106         {
107             XFireFault fault = XFireFault.createFault(e);
108             logger.error("Fault occurred.", fault);
109             
110             handler.handleFault(fault, context);
111             
112             if (service.getFaultHandler() != null)
113                 service.getFaultHandler().handleFault(fault, context);
114         }
115         else
116         {
117             throw new XFireRuntimeException("Couldn't process message.", e);
118         }
119     }
120 
121     protected Service findService( final String serviceName )
122     {
123         return getServiceRegistry().getService( serviceName );
124     }
125 
126     public void invoke( final InputStream stream,
127                         final MessageContext context )
128     {
129         final XMLInputFactory factory = XMLInputFactory.newInstance();
130 
131         try
132         {
133             invoke( factory.createXMLStreamReader( stream ),
134                     context );
135         }
136         catch( XMLStreamException e )
137         {
138             throw new XFireRuntimeException( "Couldn't parse stream.", e );
139         }
140     }
141 
142     public void generateWSDL( final String serviceName, final OutputStream out )
143     {
144         try
145         {
146             final WSDLWriter wsdl = getWSDL( serviceName );
147 
148             wsdl.write( out );
149         }
150         catch( WSDLException e )
151         {
152             throw new XFireRuntimeException( "Couldn't generate WSDL.", e );
153         }
154         catch( IOException e )
155         {
156             throw new XFireRuntimeException( "Couldn't generate WSDL.", e );
157         }
158     }
159 
160     private WSDLWriter getWSDL( final String serviceName )
161         throws WSDLException
162     {
163         final Service service = findService( serviceName );
164 
165         return service.getWSDLWriter();
166     }
167 
168     public ServiceRegistry getServiceRegistry()
169     {
170         return registry;
171     }
172 
173     public TransportManager getTransportManager()
174     {
175         return transportManager;
176     }
177 }