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
53 SAXParserFactory factory = SAXParserFactory.newInstance();
54 try {
55
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 }