KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > axis > FaultableHandler


1 /*
2  * The Apache Software License, Version 1.1
3  *
4  *
5  * Copyright (c) 2001-2003 The Apache Software Foundation. All rights
6  * reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in
17  * the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * 3. The end-user documentation included with the redistribution,
21  * if any, must include the following acknowledgment:
22  * "This product includes software developed by the
23  * Apache Software Foundation (http://www.apache.org/)."
24  * Alternately, this acknowledgment may appear in the software itself,
25  * if and wherever such third-party acknowledgments normally appear.
26  *
27  * 4. The names "Axis" and "Apache Software Foundation" must
28  * not be used to endorse or promote products derived from this
29  * software without prior written permission. For written
30  * permission, please contact apache@apache.org.
31  *
32  * 5. Products derived from this software may not be called "Apache",
33  * nor may "Apache" appear in their name, without prior written
34  * permission of the Apache Software Foundation.
35  *
36  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47  * SUCH DAMAGE.
48  * ====================================================================
49  *
50  * This software consists of voluntary contributions made by many
51  * individuals on behalf of the Apache Software Foundation. For more
52  * information on the Apache Software Foundation, please see
53  * <http://www.apache.org/>.
54  */
55
56 package org.jboss.axis;
57
58 import org.jboss.axis.handlers.BasicHandler;
59 import org.jboss.axis.utils.Messages;
60 import org.jboss.logging.Logger;
61
62 import javax.xml.namespace.QName JavaDoc;
63 import java.util.Enumeration JavaDoc;
64 import java.util.Hashtable JavaDoc;
65
66 /**
67  * A <code>FaultableHandler</code> is essentially a wrapper for any other
68  * Handler which provides flexible fault handling semantics.
69  *
70  * @author Doug Davis (dug@us.ibm.com)
71  * @author Glen Daniels (gdaniels@macromedia.com)
72  */
73 public class FaultableHandler extends BasicHandler
74 {
75    private static Logger log = Logger.getLogger(FaultableHandler.class.getName());
76
77    protected Handler workHandler;
78
79    /**
80     * Constructor
81     *
82     * @param workHandler the Handler we're going to wrap with Fault semantics.
83     */
84    public FaultableHandler(Handler workHandler)
85    {
86       this.workHandler = workHandler;
87    }
88
89    public void init()
90    {
91       workHandler.init();
92    }
93
94    public void cleanup()
95    {
96       workHandler.cleanup();
97    }
98
99    /**
100     * Invokes the specified handler. If there's a fault the appropriate
101     * key will be calculated and used to find the fault chain to be
102     * invoked. This assumes that the workHandler has caught the exception
103     * and already done its fault processing - as needed.
104     */
105    public void invoke(MessageContext msgContext) throws AxisFault
106    {
107       log.debug("Enter: FaultableHandler::invoke");
108       try
109       {
110          workHandler.invoke(msgContext);
111       }
112       catch (Exception JavaDoc e)
113       {
114          log.info(Messages.getMessage("toAxisFault00"), e);
115          AxisFault fault = AxisFault.makeFault(e);
116
117 // AxisEngine engine = msgContext.getAxisEngine();
118
119          /** Index off fault code.
120           *
121           * !!! TODO: This needs to be able to handle searching by faultcode
122           * hierarchy, i.e. "Server.General.*" or "Server.*", with the
123           * most specific match winning.
124           */
125          /*
126          QFault key = fault.getFaultCode() ;
127          Handler faultHandler = (Handler) faultHandlers.get( key );
128          */
129          Handler faultHandler = null;
130
131          Hashtable JavaDoc options = getOptions();
132          if (options != null)
133          {
134             Enumeration JavaDoc en = options.keys();
135             while (en.hasMoreElements())
136             {
137                String JavaDoc s = (String JavaDoc)en.nextElement();
138                if (s.equals("fault-" + fault.getFaultCode().getLocalPart()))
139                {
140                   faultHandler = (Handler)options.get(s);
141                }
142             }
143          }
144
145          if (faultHandler != null)
146          {
147             /** faultHandler will (re)throw if it's appropriate, but it
148              * might also eat the fault. Which brings up another issue -
149              * should we have a way to pass the Fault directly to the
150              * faultHandler? Maybe another well-known MessageContext
151              * property?
152              */
153             faultHandler.invoke(msgContext);
154          }
155          else
156          {
157             throw fault;
158          }
159       }
160       log.debug("Exit: FaultableHandler::invoke");
161    }
162
163    /**
164     * Some handler later on has faulted so we need to process the fault.
165     */
166    public void onFault(MessageContext msgContext)
167    {
168       log.debug("Enter: FaultableHandler::onFault");
169       workHandler.onFault(msgContext);
170       log.debug("Exit: FaultableHandler::onFault");
171    }
172
173    public boolean canHandleBlock(QName JavaDoc qname)
174    {
175       return (workHandler.canHandleBlock(qname));
176    }
177 }
178
179 ;
180
Popular Tags