KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > admin > wsmgmt > transform > FilterChain


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */

23 package com.sun.enterprise.admin.wsmgmt.transform;
24
25 import com.sun.enterprise.admin.wsmgmt.config.spi.Constants;
26 import com.sun.enterprise.admin.wsmgmt.filter.spi.Filter;
27 import com.sun.enterprise.admin.wsmgmt.filter.spi.FilterContext;
28
29 import javax.xml.transform.stream.*;
30 import javax.xml.transform.*;
31 import com.sun.enterprise.admin.wsmgmt.SOAPMessageContext;
32 import javax.xml.soap.SOAPMessage JavaDoc;
33 import javax.xml.soap.MessageFactory JavaDoc;
34 import javax.xml.soap.SOAPPart JavaDoc;
35
36 import java.io.StringBufferInputStream JavaDoc;
37 import java.io.StringWriter JavaDoc;
38
39 import javax.xml.parsers.FactoryConfigurationError JavaDoc;
40 import javax.xml.parsers.ParserConfigurationException JavaDoc;
41 import javax.xml.parsers.SAXParser JavaDoc;
42 import javax.xml.parsers.SAXParserFactory JavaDoc;
43  
44 import org.xml.sax.SAXException JavaDoc;
45 import org.xml.sax.SAXParseException JavaDoc;
46 import org.xml.sax.InputSource JavaDoc;
47 import org.xml.sax.XMLReader JavaDoc;
48 import org.xml.sax.XMLFilter JavaDoc;
49
50 import javax.xml.transform.Transformer JavaDoc;
51 import javax.xml.transform.TransformerException JavaDoc;
52 import javax.xml.transform.TransformerFactory JavaDoc;
53 import javax.xml.transform.TransformerConfigurationException JavaDoc;
54
55 import javax.xml.transform.sax.SAXTransformerFactory JavaDoc;
56 import javax.xml.transform.sax.SAXSource JavaDoc;
57 import javax.xml.transform.sax.SAXResult JavaDoc;
58
59 import javax.xml.transform.stream.StreamSource JavaDoc;
60 import javax.xml.transform.stream.StreamResult JavaDoc;
61
62 import java.io.File JavaDoc;
63 import java.util.LinkedList JavaDoc;
64 import java.util.List JavaDoc;
65 import java.util.HashMap JavaDoc;
66 import com.sun.enterprise.admin.wsmgmt.config.spi.TransformationRule;
67 import com.sun.enterprise.util.SystemPropertyConstants;
68
69 import java.util.logging.Logger JavaDoc;
70 import java.util.logging.Level JavaDoc;
71 import com.sun.logging.LogDomains;
72 import com.sun.enterprise.util.i18n.StringManager;
73
74 /**
75  * Ordered XSLT filter chain.
76  */

77 public class FilterChain {
78
79     /**
80      * Public Constructor.
81      *
82      * @param appId name of the application
83      * @param endpoint end point name for which stats are collected
84      */

85     public FilterChain() throws TransformException {
86         try {
87             // Set up to the Transformer
88
SAXParserFactory JavaDoc spf = SAXParserFactory.newInstance();
89             SAXParser JavaDoc parser = spf.newSAXParser();
90             _reader = parser.getXMLReader();
91    
92             _stf = (SAXTransformerFactory JavaDoc) TransformerFactory.newInstance();
93             _transformer = _stf.newTransformer();
94         } catch(Exception JavaDoc e) {
95             throw new TransformException(e);
96         }
97     }
98
99     public synchronized void addFilter(TransformationRule[] tRules,
100             boolean reverse) throws TransformException {
101         if ((tRules == null) || (tRules.length == 0)) {
102             return;
103         }
104         if ( reverse == false) {
105             for(int idx =0; idx < tRules.length; idx++) {
106                 addFilter(idx, tRules[idx]);
107             }
108         } else {
109             int index =0;
110             for(int idx = tRules.length -1; idx > -1; idx--) {
111                 addFilter(index, tRules[idx]);
112                 index++;
113             }
114         }
115     }
116
117     public synchronized void addFilter(int index, TransformationRule tRule)
118             throws TransformException {
119         try {
120             if (tRule == null) {
121                 return;
122             }
123             String JavaDoc name = tRule.getName();
124             // check if the Rule File Location is relative, then prepend the
125
// instance root to the path
126
File JavaDoc stylesheet = new File JavaDoc(tRule.getRuleFileLocation());
127             if ( !stylesheet.isAbsolute()) {
128                 // construct the absolute path
129
String JavaDoc instanceRoot = System.getProperty(
130                     SystemPropertyConstants.INSTANCE_ROOT_PROPERTY);
131
132                 stylesheet = new File JavaDoc( instanceRoot
133                  + File.separator+tRule.getRuleFileLocation());
134             }
135             XMLFilter JavaDoc filter = _stf.newXMLFilter(new StreamSource JavaDoc(stylesheet));
136             addToList(index,name,filter);
137         } catch(Exception JavaDoc e) {
138             String JavaDoc msg = _stringMgr.getString("rule_not_compiled",
139             tRule.getRuleFileLocation(), tRule.getName());
140             _logger.log(Level.WARNING, msg);
141             throw new TransformException(e);
142         }
143     }
144
145     public synchronized void removeFilter(int index) {
146         removeFromList(index);
147     }
148
149     private void addToList(int index, String JavaDoc name, XMLFilter JavaDoc filter) {
150         FilterData parent = null;
151         if ( index == 0) {
152             parent = null;
153             filter.setParent(_reader);
154         } else {
155             parent = (FilterData) filterList.get(index-1);
156             filter.setParent(parent.getFilter());
157             // check if child the exists
158
if ( filterList.size() -1 > index) {
159                 FilterData child = (FilterData) filterList.get(index);
160                 if ( child != null) {
161                     child.getFilter().setParent(filter);
162                 }
163             }
164         }
165
166         filterList.add(index, new FilterData(name,filter));
167     }
168
169     private void removeFromList(int index) {
170         FilterData current = (FilterData) filterList.get(index);
171
172         if ( current == null) {
173             return;
174         }
175
176         FilterData parent = null;
177         if ( index == 0) {
178             parent = null;
179         } else {
180             parent = (FilterData) filterList.get(index-1);
181         }
182
183         FilterData child = null;
184         if ( index +1 < filterList.size()) {
185             child = (FilterData) filterList.get(index+1);
186         }
187         if ( child != null) {
188             if ( parent == null) {
189                 child.getFilter().setParent(_reader);
190             } else {
191                 child.getFilter().setParent(parent.getFilter());
192             }
193         }
194     }
195
196     /**
197      * Invoke the filter.
198      *
199      * @param context filter context
200      */

201     public synchronized void process(FilterContext context)
202             throws TransformException {
203
204         if (( filterList.size() == 0 ) || (context == null)) {
205             return;
206         }
207
208         try {
209
210              SOAPMessageContext smc = context.getMessageContext();
211              SOAPMessage JavaDoc sm = smc.getMessage();
212              SOAPPart JavaDoc sp = sm.getSOAPPart();
213              // gets the SOAP envelope as a JAXP Source object.
214
Source JavaDoc s = sp.getContent();
215
216             // Set up the transformer to process the SAX events generated
217
// by the last filter in the chain
218
InputSource JavaDoc inputSrc = SAXSource.sourceToInputSource(s);
219             SAXSource JavaDoc transformSource = new SAXSource JavaDoc(
220                 ((FilterData)filterList.getLast()).getFilter(), inputSrc);
221
222              StringWriter JavaDoc sw = new StringWriter JavaDoc(STRING_WRITER_INIT_SIZE);
223              Result JavaDoc r = new StreamResult JavaDoc(sw);
224              _transformer.transform(transformSource, r);
225              // get the string from the result.
226
sw.flush();
227              sw.close();
228              StringBufferInputStream JavaDoc in = new StringBufferInputStream JavaDoc(
229                             sw.toString());
230              MessageFactory JavaDoc mFactory = MessageFactory.newInstance();
231              SOAPMessage JavaDoc resMsg = mFactory.createMessage(null, in);
232                  smc.setMessage(resMsg);
233
234
235         } catch(Exception JavaDoc e) {
236             _logger.fine("XSLT transformation failed for "
237                 + context.getFullyQualifiedName());
238             throw new TransformException(e);
239         }
240
241     }
242
243     // -- PRIVATE - VARIABLES -------------------------
244
LinkedList JavaDoc filterList = new LinkedList JavaDoc();
245     XMLReader JavaDoc _reader = null;
246     SAXTransformerFactory JavaDoc _stf = null;
247     Transformer JavaDoc _transformer = null;
248
249     // intial size for StringWriter
250
static final int STRING_WRITER_INIT_SIZE = 4028;
251
252      private static final Logger JavaDoc _logger =
253         Logger.getLogger(LogDomains.ADMIN_LOGGER);
254     private static final StringManager _stringMgr =
255         StringManager.getManager(FilterChain.class);
256
257 }
258
Popular Tags