1 /*
2 Loader - tool for transfering data from one JDBC source to another and
3 doing transformations during copy.
4 Copyright (C) 2002 Together
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13 You should have received a copy of the GNU Lesser General Public
14 License along with this library; if not, write to the Free Software
15 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 LoaderXIncluder.java
17 Date: 22.09.2001.
18 @version 1.0
19 @author:
20 Milosevic Sinisa
21 */
22
23
24 package org.webdocwf.util.loader;
25
26 import java.io.BufferedInputStream;
27 import java.io.BufferedReader;
28 import java.io.File;
29 import java.io.IOException;
30 import java.io.InputStream;
31 import java.io.InputStreamReader;
32 import java.io.OutputStream;
33 import java.io.OutputStreamWriter;
34 import java.io.UnsupportedEncodingException;
35 import java.io.Writer;
36 import java.net.MalformedURLException;
37 import java.net.URL;
38 import java.net.URLConnection;
39
40 import org.apache.xerces.parsers.SAXParser;
41 import org.webdocwf.util.loader.logging.Logger;
42 import org.xml.sax.AttributeList;
43 import org.xml.sax.HandlerBase;
44 import org.xml.sax.InputSource;
45 import org.xml.sax.SAXException;
46 import org.xml.sax.SAXParseException;
47
48 /***
49 * LoaderXIncluder.java
50 * This class parses a document (text or xml file) and writes the documents
51 * contents back to standard output.
52 */
53 public class LoaderXIncluder
54 extends HandlerBase {
55 private Writer out;
56 private String encoding;
57 private int level = 0;
58 //counter for dtd file
59 private int counter1 = 1;
60
61 //counter for sql files
62 private int counter2 = 0;
63
64 //counter for xml (import definition) file
65 private int counter3 = 0;
66
67 //counter for line before dtd file
68 private int counter4 = 0;
69
70 //counter for LoaderJob.xml (part) file
71 private int counter5 = 0;
72
73 //for create and drop database
74 private int counter6 = 0;
75
76 private boolean firstPartXml = true;
77
78 private String loaderJobPath="";
79
80 /*** Main program entry point.
81 * @param argv represents input parmeters
82 */
83 public static void main(String argv[]) {
84 if (argv.length == 0) {
85 System.out.println("Usage: java LoaderXIncluder uri");
86 System.out.println(" where uri is the URI of your XML document.");
87 System.out.println(" Sample: java LoaderXIncluder demo.xml");
88 System.exit(1);
89 }
90 LoaderXIncluder s1 = new LoaderXIncluder();
91 s1.parseURI(argv[0]);
92 }
93
94 /***
95 * Constructor of class without parameters.
96 */
97 public LoaderXIncluder() {
98 }
99
100 /***
101 * Construct object LoaderXIncluder with associated outputStream and encoding.
102 * @param out - OutputStream where will be written final XML.
103 * @param encoding - encoding String representation of encoding.
104 * @throws UnsupportedEncodingException
105 */
106 public LoaderXIncluder(OutputStream out, String encoding) throws UnsupportedEncodingException {
107 this.out = new OutputStreamWriter(out, encoding);
108 this.encoding = encoding;
109 }
110
111 /***
112 * Construct object LoaderXIncluder with associated outputStream.
113 * Class uses default "UTF-8" encoding.
114 * @param out - OutputStream where will be written final XML.
115 */
116 public LoaderXIncluder(OutputStream out) {
117 try {
118 this.out = new OutputStreamWriter(out, "UTF8");
119 this.encoding = "UTF-8";
120 }
121 catch (UnsupportedEncodingException e) {}
122 }
123
124 /***
125 * Method parseUri parses a file "uri" and writes the file
126 * contents back to standard output including contents of 'include' files .
127 * @param uri - Name of XML file.
128 */
129 public void parseURI(String uri) {
130 try {
131 SAXParser parser = new SAXParser();
132 parser.setDocumentHandler(this);
133 parser.setEntityResolver(this);
134 parser.setFeature("http://xml.org/sax/features/validation", false);
135 parser.setErrorHandler(this);
136 // System.out.println("Loader loads XML file : "+ uri+"\n");
137 Logger.getCentralLogger().write("normal", "Loader loads XML file : " + uri);
138
139 File f = new File(uri);
140 this.loaderJobPath=f.getCanonicalFile().getParent();
141 URL xml = f.toURL();
142
143 InputStreamReader xmlStream = new InputStreamReader(xml.openStream());
144 BufferedReader reader = new BufferedReader(xmlStream);
145 String intro = "";
146 while ( (intro = reader.readLine()) != null) {
147 if (intro.indexOf("include") == -1)
148 counter6++;
149 else
150 break;
151 }
152 counter6 = counter6 - 4;
153 LocationOfException.setJdbcNumber(counter6);
154 reader.close();
155 xmlStream.close();
156 parser.parse(uri);
157 }
158 catch (Exception e) {
159 // System.err.println();
160 e.printStackTrace();
161 Logger.getCentralLogger().write("normal", e.getMessage());
162 }
163 }
164
165 boolean hasDTD = false;
166 /*** Processing DOCTYPE deklaration
167 * @param publicId is public ID of document
168 * @param systemId is system ID of document
169 * @return null
170 */
171 public InputSource resolveEntity(String publicId, String systemId) {
172 hasDTD = true;
173 try {
174 if (systemId != null) {
175 out.write("<!DOCTYPE loaderJob SYSTEM \"" + systemId + "\">" + "\n");
176 counter4++;
177 } else if (publicId != null) {
178 out.write("<!DOCTYPE loaderJob PUBLIC \"" + publicId + "\">" + "\n");
179 counter4++;
180 }
181 }
182 catch (Exception e) {
183 System.err.println(e);
184 }
185 return null;
186 }
187
188 /*** Processing instruction.
189 *@param target is target
190 *@param data is target data
191 */
192 public void processingInstruction(String target, String data) {
193 try {
194 out.write("<?");
195 out.write(target);
196 if (data != null && data.length() > 0) {
197 out.write(' ');
198 out.write(data);
199 }
200 out.write("?>");
201 counter4++;
202 }
203 catch (IOException e) {
204 System.err.println(e);
205 }
206 }
207
208 /*** Start document. */
209 public void startDocument() {
210 if (level == 0) {
211 try {
212 out.write("<?xml version=\"1.0\"?>\r\n");
213 counter4++;
214 }
215 catch (IOException e) {
216 System.err.println(e);
217 }
218 LocationOfException.setIntroNumber(counter4);
219 }
220 }
221
222 /*** Start element.
223 * @param name is name of the tag
224 * @param atts is attributes of the tag
225 */
226 public void startElement(String name, AttributeList atts) {
227 try {
228 //if DTD or SCHEMA is not defined use default
229 if (name.equalsIgnoreCase("loaderJob")) {
230 /*
231 if (!hasDTD) {
232 String OCTOPUS_HOME = System.getProperty("OCTOPUS_HOME");
233 if (OCTOPUS_HOME != null) {
234 if (! (OCTOPUS_HOME.endsWith("//") || OCTOPUS_HOME.endsWith("/")))
235 OCTOPUS_HOME += "/";
236 String url = "file:///" + OCTOPUS_HOME + "XmlTransform/xml/dtd/loaderJob.dtd";
237 out.write("<!DOCTYPE loaderJob SYSTEM \"" + url + "\">" + "\n");
238 } else {
239 URL dtdURL = this.getClass().getClassLoader().getResource("xml/dtd/loaderJob.dtd");
240 InputStreamReader dtdStream = new InputStreamReader(dtdURL.openStream());
241 BufferedReader reader = new BufferedReader(dtdStream);
242 StringBuffer sb = new StringBuffer();
243 String nextLine = "";
244 boolean firstLine = true;
245 while ( (nextLine = reader.readLine()) != null) {
246 if (!firstLine) {
247 sb.append(nextLine + "\n");
248 counter1++;
249 } else
250 firstLine = false;
251 }
252 out.write("<!DOCTYPE loaderJob [" + sb.toString() + "\n]>");
253 counter1++;
254 LocationOfException.setDtdNumber(counter1);
255 }
256 }
257 */
258 }
259 if (name.equalsIgnoreCase("include")) {
260 String href = atts.getValue("href");
261 if (href == null) {
262 System.out.println("Missing href attribute in include Element");
263 System.exit(1);
264 }
265
266 File file=new File(href);
267 if(!file.isAbsolute()){
268 String tmp=this.loaderJobPath + System.getProperty("file.separator") + href;
269 File fileHref=new File(tmp);
270 href = fileHref.getCanonicalPath();
271 }
272
273 String parse = atts.getValue("parse");
274 if (parse == null)
275 parse = "xml";
276 if (parse.equals("text")) {
277 String encoding = atts.getValue("encoding");
278 includeTextDocument(href, encoding);
279 } else if (parse.equals("xml")) {
280 level++;
281 includeXMLDocument(href);
282 level--;
283 } else {
284 System.out.println("Illegal value for parse attribute: " + parse);
285 Logger.getCentralLogger().write("normal", "Illegal value for parse attribute: " + parse);
286 System.exit(1);
287 }
288 } else if (name.equalsIgnoreCase("definitionInclude")) {
289 } else {
290 out.write("<" + name);
291 if (name.equals("loaderJob")) {
292 out.write(" xmlns='http://www.objectweb.org'");
293 out.write(" xmlns:xsi=\'http://www.w3.org/2001/XMLSchema-instance\'");
294 out.write(" xsi:schemaLocation='http://www.objectweb.org http://octopus.objectweb.org/doc/XmlTransform/xml/xmlschema/loaderJob.xsd'");
295 out.write(" ");
296 }
297 // if(name.startsWith("jdbc"))
298 // counter5++;
299 // if(!name.startsWith("jdbc") && counter5!=0 && firstPartXml==true){
300 // LocationOfException.setJdbcNumber(counter5);
301 // firstPartXml=false;
302 // counter5=0;
303 // }
304 //System.out.println("atts="+atts);
305 for (int i = 0; i < atts.getLength(); i++) {
306 out.write(" ");
307 out.write(atts.getName(i));
308 out.write("='");
309 String value = atts.getValue(i);
310 // + 4 allows space for one entitiy reference.
311 // If there's more than that, then the StringBuffer
312 // will automatically expand
313 // Need to use character references if the encoding
314 // can't support the character
315 StringBuffer encodedValue = new StringBuffer(value.length() + 4);
316 for (int j = 0; j < value.length(); j++) {
317 char c = value.charAt(j);
318 if (c == '&')
319 encodedValue.append("&");
320 else if (c == '<')
321 encodedValue.append("<");
322 else if (c == '>')
323 encodedValue.append(">");
324 else if (c == '\'')
325 encodedValue.append("'");
326 else
327 encodedValue.append(c);
328 }
329 out.write(encodedValue.toString());
330 out.write("'");
331 }
332 out.write(">");
333 }
334 }
335 catch (IOException e) {
336 System.err.println(e);
337 Logger.getCentralLogger().write("normal", e.getMessage());
338 }
339 catch (SAXException ex) {
340 System.err.println(ex);
341 Logger.getCentralLogger().write("normal", ex.getMessage());
342 }
343 }
344
345 /*** Characters.
346 * @param ch is array of characters
347 * @param start is int
348 * @param length is length of the input parameters
349 * @throws SAXException
350 */
351 public void characters(char ch[], int start, int length) throws SAXException {
352 try {
353 for (int i = 0; i < length; i++) {
354 char c = ch[start + i];
355 if (c == '&')
356 out.write("&");
357 else if (c == '<')
358 out.write("<");
359 else if (c == '\n') {
360 counter2++;
361 out.write(c);
362 } else
363 out.write(c);
364 }
365 }
366 catch (IOException e) {
367 System.err.println(e);
368 Logger.getCentralLogger().write("normal", e.getMessage());
369 }
370 }
371
372 /*** Ignorable whitespace.
373 * @param ch is array of characters
374 * @param start is int
375 * @param length is length of the input parameters
376 */
377 public void ignorableWhitespace(char ch[], int start, int length) {
378 try {
379 this.characters(ch, start, length);
380 }
381 catch (SAXException e) {
382 System.err.println(e);
383 Logger.getCentralLogger().write("normal", e.getMessage());
384 }
385 }
386
387 /*** End element.
388 * @param name is name of the tag
389 */
390 public void endElement(String name) {
391 if (!name.equalsIgnoreCase("include") && !name.equalsIgnoreCase("definitionInclude")) {
392 // if(name.startsWith("jdbc")&&name.endsWith("s"))
393 // counter5++;
394 try {
395 out.write("</");
396 out.write(name);
397 out.write(">");
398 }
399 catch (IOException e) {
400 System.err.println(e);
401 Logger.getCentralLogger().write("normal", e.getMessage());
402 }
403 }
404 }
405
406 /*** End document. */
407 public void endDocument() {
408 try {
409 out.flush();
410 }
411 catch (IOException e) {
412 System.err.println(e);
413 Logger.getCentralLogger().write("normal", e.getMessage());
414 }
415 }
416
417 //
418 // ErrorHandler methods
419 //
420 /*** Warning.
421 * @param ex is SAXParseException exception
422 */
423 public void warning(SAXParseException ex) {
424 System.err.println("[Warning] " + getLocationString(ex) + ": " + ex.getMessage());
425 Logger.getCentralLogger().write("normal",
426 "[Warning] " + getLocationString(ex) + ": " + ex.getMessage());
427 }
428
429 /*** Error.
430 * @param ex is SAXParseException exception
431 */
432 public void error(SAXParseException ex) {
433 System.err.println("[Error] " + getLocationString(ex) + ": " + ex.getMessage());
434 Logger.getCentralLogger().write("normal",
435 "[Error] " + getLocationString(ex) + ": " + ex.getMessage());
436 }
437
438 /*** Fatal error.
439 * @param ex is SAXParseException exception
440 * @throws SAXException
441 */
442 public void fatalError(SAXParseException ex) throws SAXException {
443 System.err.println("[Fatal Error] " + getLocationString(ex) + ": " + ex.getMessage());
444 Logger.getCentralLogger().write("normal",
445 "[Fatal Error] " + getLocationString(ex) + ": " + ex.getMessage());
446 throw ex;
447 }
448
449 /*** Returns a string of the location.
450 * @param ex is SAXParseException exception
451 * @return string
452 */
453 private String getLocationString(SAXParseException ex) {
454 StringBuffer str = new StringBuffer();
455 String systemId = ex.getSystemId();
456 if (systemId != null) {
457 int index = systemId.lastIndexOf('/');
458 if (index != -1)
459 systemId = systemId.substring(index + 1);
460 str.append(systemId);
461 }
462 str.append(':');
463 str.append(ex.getLineNumber());
464 str.append(':');
465 str.append(ex.getColumnNumber());
466 return str.toString();
467 }
468
469 /***
470 * <p>
471 * This utility method reads a document at a specified URL
472 * and fires off calls to <code>characters()</code>.
473 * It's used to include files with <code>parse="text"</code>
474 * </p>
475 *
476 * @param url URL of the document that will be read
477 * @param encoding Encoding of the document; e.g. UTF-8,
478 * ISO-8859-1, etc.
479 * @throws SAXException if the requested document cannot
480 * be downloaded from the specified URL
481 * or if the encoding is not recognized
482 */
483 private void includeTextDocument(String url, String encoding) throws SAXException {
484 if (encoding == null || encoding.trim().equals(""))
485 encoding = "UTF-8";
486 File sourceXml = new File(url);
487 URL source;
488 counter2 = 1;
489 try {
490 source = sourceXml.toURL();
491 }
492 catch (MalformedURLException e) {
493 Logger.getCentralLogger().write("normal", "Unresolvable URL :" + e.getMessage());
494 throw new SAXException("Unresolvable URL :", e);
495 }
496 try {
497 URLConnection uc = source.openConnection();
498 String encodingFromHeader = uc.getContentEncoding();
499 if (encodingFromHeader != null)
500 encoding = encodingFromHeader;
501 InputStream in = new BufferedInputStream(uc.getInputStream());
502 InputStreamReader reader = new InputStreamReader(in, encoding);
503 char[] c = new char[1024];
504 while (true) {
505 int charsRead = reader.read(c, 0, 1024);
506 if (charsRead == -1)
507 break;
508 if (charsRead > 0)
509 this.characters(c, 0, charsRead);
510 }
511 counter2 = counter2 + 4;
512 LocationOfException.setFileLineNumber(counter2, url);
513 // System.out.println("Sql file "+url+"ima broj linija :"+counter2);
514 counter2 = 0;
515 }
516 catch (UnsupportedEncodingException e) {
517 Logger.getCentralLogger().write("normal", "Unsupported encoding: " + encoding);
518 throw new SAXException("Unsupported encoding: " + encoding, e);
519 }
520 catch (IOException e) {
521 Logger.getCentralLogger().write("normal", "Document not found: " + source.toExternalForm());
522 throw new SAXException("Document not found: " + source.toExternalForm(), e);
523 }
524 }
525
526 /***
527 * <p>
528 * This utility method reads a document at a specified URL
529 * and fires off calls to various <code>DocumentHandler</code> methods.
530 * It's used to include files with <code>parse="xml"</code>
531 * </p>
532 *
533 * @param url URL of the document that will be read
534 * @throws SAXException if the requested document cannot
535 be downloaded from the specified URL.
536 */
537 private void includeXMLDocument(String url) throws SAXException {
538 File sourceXml = new File(url);
539 URL source;
540 InputStream includeXML = null;
541 // int counter3=0;
542 try {
543 source = sourceXml.toURL();
544 includeXML = source.openStream();
545 InputStreamReader isr = new InputStreamReader(includeXML);
546 BufferedReader br = new BufferedReader(isr);
547 while (br.readLine() != null)
548 counter3++;
549 counter3 = counter3 + 2;
550 LocationOfException.setFileLineNumber(counter3, url);
551 // System.out.println("xml file " + url+" ima broj linija :"+counter3);
552 counter3 = 0;
553 // LocationOfException.setJdbcNumber(counter2);
554
555 }
556 catch (MalformedURLException e) {
557 Logger.getCentralLogger().write("normal", "Unresolvable URL :" + e.getMessage());
558 throw new SAXException("Unresolvable URL :", e);
559 }
560 catch (IOException e) {
561 Logger.getCentralLogger().write("normal", "Error in opening input stream :" + e.getMessage());
562 throw new SAXException("Error in opening input stream :", e);
563 }
564
565 SAXParser includeParser = new SAXParser();
566 includeParser.setDocumentHandler(this);
567 includeParser.setEntityResolver(this);
568 includeParser.setErrorHandler(this);
569 try {
570 includeParser.parse(url);
571 }
572 catch (Exception e) {
573 System.err.println(e);
574 Logger.getCentralLogger().write("normal", e.getMessage());
575 }
576 }
577
578
579 }
This page was automatically generated by Maven