View Javadoc
1   package net.logAnalyzer.config;
2   
3   import java.io.File;
4   import java.io.IOException;
5   import java.util.Vector;
6   
7   import javax.xml.parsers.ParserConfigurationException;
8   import javax.xml.parsers.SAXParser;
9   import javax.xml.parsers.SAXParserFactory;
10  
11  import net.logAnalyzer.analysis.LAAnalyzer;
12  import net.logAnalyzer.patternParser.PatternParsingException;
13  import net.logAnalyzer.reports.LAReportRenderer;
14  
15  import org.xml.sax.Attributes;
16  import org.xml.sax.SAXException;
17  import org.xml.sax.helpers.DefaultHandler;
18  
19  /***
20   * This class uses an xml File to load the configuration. The "logAnalyzer" file
21   * must be well-formed as specified in "logAnalyzer.dtd".
22   * 
23   * @author Karim REFEYTON
24   * @version 0.1
25   */
26  class XMLCommandsLoader extends DefaultHandler {
27  
28      private String pattern = null;
29  
30      private Vector analyzers = null;
31  
32      private LAAnalyzer[] analyzersCommands = null;
33  
34      private Vector renderers = null;
35  
36      private LAReportRenderer[] renderersCommands = null;
37  
38      /***
39       * Loads the specified xml commands file.
40       * @param xmlFilename XML configuration file to load.
41       * @return Configuration.
42       */
43      public CommandsManager loadCommands(String xmlFilename) {
44          File xmlFile = new File(xmlFilename);
45          if (!xmlFile.exists()) {
46              System.err.println("File not found : " + xmlFile.getAbsolutePath());
47              System.exit(1);
48          }
49          pattern = null;
50          analyzers = new Vector();
51          renderers = new Vector();
52          // Use the default (non-validating) parser
53          SAXParserFactory factory = SAXParserFactory.newInstance();
54          try {
55              // Parse the input
56              SAXParser saxParser = factory.newSAXParser();
57              saxParser.parse(xmlFile, this);
58          } catch (ParserConfigurationException pce) {
59              pce.printStackTrace();
60              System.exit(1);
61          } catch (SAXException spe) {
62              spe.printStackTrace();
63              System.exit(1);
64          } catch (IOException ioe) {
65              ioe.printStackTrace();
66              System.exit(1);
67          }
68          return new CommandsManager(pattern, analyzersCommands,
69                  renderersCommands);
70      }
71  
72      private static final int STATE_START = 0;
73  
74      private static final int STATE_COMMANDS = 1;
75  
76      private static final int STATE_ANALYZERS = 11;
77  
78      private static final int STATE_ANALYZER = 110;
79  
80      private static final int STATE_PATTERN = 120;
81  
82      private static final int STATE_RENDERERS = 13;
83  
84      private static final int STATE_RENDERER = 130;
85  
86      private static final int STATE_END = 2;
87  
88      private int currentState = -1;
89  
90      private static final String BADFORMAT_EXCEPTION = "Unexpected content, see commands.dtd";
91  
92      /***
93       * Modification to the inherited behavior.
94       * 
95       * @see org.xml.sax.helpers.DefaultHandler#characters(char[], int, int)
96       */
97      public void characters(char[] chars, int start, int length)
98              throws SAXException {
99          switch (currentState) {
100         case STATE_PATTERN:
101             addPatternContent(new String(chars, start, length));
102             break;
103         default:
104             throw new SAXException(BADFORMAT_EXCEPTION);
105         }
106     }
107 
108     /***
109      * Modification to the inherited behavior.
110      * 
111      * @see org.xml.sax.helpers.DefaultHandler#endDocument()
112      */
113     public void endDocument() throws SAXException {
114         switch (currentState) {
115         case STATE_END:
116             currentState = -1;
117             break;
118         default:
119             throw new SAXException(BADFORMAT_EXCEPTION);
120         }
121     }
122 
123     /***
124      * Modification to the inherited behavior.
125      * 
126      * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String,
127      *      java.lang.String, java.lang.String)
128      */
129     public void endElement(String uri, String localName, String qName)
130             throws SAXException {
131         switch (currentState) {
132         case STATE_COMMANDS:
133             if ("commands".equals(qName)) {
134                 currentState = STATE_END;
135             }
136             break;
137         case STATE_ANALYZERS:
138             if ("analyzers".equals(qName)) {
139                 currentState = STATE_COMMANDS;
140                 finalizeAnalyzers();
141             }
142             break;
143         case STATE_ANALYZER:
144             if ("analyzer".equals(qName)) {
145                 currentState = STATE_ANALYZERS;
146             }
147             break;
148         case STATE_PATTERN:
149             if ("pattern".equals(qName)) {
150                 currentState = STATE_COMMANDS;
151                 addPattern(patternContent);
152             }
153             break;
154         case STATE_RENDERERS:
155             if ("renderers".equals(qName)) {
156                 currentState = STATE_COMMANDS;
157                 finalizeRenderers();
158             }
159             break;
160         case STATE_RENDERER:
161             if ("renderer".equals(qName)) {
162                 currentState = STATE_RENDERERS;
163             }
164             break;
165         default:
166             throw new SAXException(BADFORMAT_EXCEPTION);
167         }
168     }
169 
170     /***
171      * Modification to the inherited behavior.
172      * 
173      * @see org.xml.sax.helpers.DefaultHandler#startDocument()
174      */
175     public void startDocument() throws SAXException {
176         currentState = STATE_START;
177     }
178 
179     /***
180      * Modification to the inherited behavior.
181      * 
182      * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String,
183      *      java.lang.String, java.lang.String, org.xml.sax.Attributes)
184      */
185     public void startElement(String uri, String localName, String qName,
186             Attributes attributes) throws SAXException {
187         switch (currentState) {
188         case STATE_START:
189             if ("commands".equals(qName)) {
190                 currentState = STATE_COMMANDS;
191             } else {
192                 throw new SAXException(BADFORMAT_EXCEPTION);
193             }
194             break;
195         case STATE_COMMANDS:
196             if ("analyzers".equals(qName)) {
197                 currentState = STATE_ANALYZERS;
198             } else if ("pattern".equals(qName)) {
199                 currentState = STATE_PATTERN;
200                 preparePattern();
201             } else if ("renderers".equals(qName)) {
202                 currentState = STATE_RENDERERS;
203             } else {
204                 throw new SAXException(BADFORMAT_EXCEPTION);
205             }
206             break;
207         case STATE_ANALYZERS:
208             if ("analyzer".equals(qName)) {
209                 currentState = STATE_ANALYZER;
210                 addAnalyzer(attributes.getValue("name"));
211             } else {
212                 throw new SAXException(BADFORMAT_EXCEPTION);
213             }
214             break;
215         case STATE_RENDERERS:
216             if ("renderer".equals(qName)) {
217                 currentState = STATE_RENDERER;
218                 addRenderer(attributes.getValue("name"));
219             } else {
220                 throw new SAXException(BADFORMAT_EXCEPTION);
221             }
222             break;
223         default:
224             throw new SAXException(BADFORMAT_EXCEPTION);
225         }
226     }
227 
228     private void addAnalyzer(String name) {
229         if ((name == null || name.trim().length() == 0)) {
230             System.err.println("Bad analyzer definition for analyzers");
231             System.exit(1);
232         }
233 
234         try {
235             analyzers.add(ConfigurationManager.getInstance().createAnalyzer(
236                     name));
237         } catch (PatternParsingException nsme) {
238             System.err.println("No such analyzer [name='" + name + "']");
239             System.exit(1);
240         }
241     }
242 
243     private String patternContent = null;
244 
245     private void preparePattern() {
246         patternContent = "";
247     }
248 
249     private void addPatternContent(String content) {
250         patternContent += content;
251     }
252 
253     private void addPattern(String patternString) {
254         if ((patternString == null || patternString.trim().length() == 0)) {
255             System.err.println("Bad pattern specification");
256             System.exit(1);
257         }
258         pattern = patternContent;
259         patternContent = null;
260     }
261 
262     private void addRenderer(String name) {
263         if ((name == null || name.trim().length() == 0)) {
264             System.err.println("Bad renderer definition for renderers");
265             System.exit(1);
266         }
267 
268         try {
269             renderers.add(ConfigurationManager.getInstance().createRenderer(
270                     name, analyzersCommands));
271         } catch (PatternParsingException nsme) {
272             System.err.println("No such renderer [name='" + name + "']");
273             System.exit(1);
274         }
275     }
276 
277     private void finalizeAnalyzers() {
278         analyzersCommands = new LAAnalyzer[analyzers.size()];
279 
280         analyzersCommands = (LAAnalyzer[]) analyzers.toArray(analyzersCommands);
281     }
282 
283     private void finalizeRenderers() {
284         renderersCommands = new LAReportRenderer[renderers.size()];
285 
286         renderersCommands = (LAReportRenderer[]) renderers
287                 .toArray(renderersCommands);
288 
289     }
290 }