1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.module.model.reader;
35
36 import info.magnolia.cms.util.ClasspathResourcesUtil;
37 import info.magnolia.module.ModuleManagementException;
38 import info.magnolia.module.model.ModuleDefinition;
39 import info.magnolia.module.model.Version;
40 import org.apache.commons.betwixt.io.BeanReader;
41 import org.apache.commons.io.IOUtils;
42 import org.jdom.DocType;
43 import org.jdom.Document;
44 import org.jdom.JDOMException;
45 import org.jdom.input.SAXBuilder;
46 import org.jdom.output.XMLOutputter;
47 import org.xml.sax.SAXException;
48 import org.xml.sax.SAXParseException;
49
50 import java.beans.IntrospectionException;
51 import java.io.IOException;
52 import java.io.InputStreamReader;
53 import java.io.Reader;
54 import java.io.StringReader;
55 import java.io.StringWriter;
56 import java.net.URL;
57 import java.util.HashMap;
58 import java.util.Map;
59 import java.util.regex.Matcher;
60 import java.util.regex.Pattern;
61 import javax.inject.Singleton;
62
63
64
65
66
67
68
69
70 @Singleton
71 public class BetwixtModuleDefinitionReader implements ModuleDefinitionReader {
72 private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(BetwixtModuleDefinitionReader.class);
73
74 private static final String DTD = "/info/magnolia/module/model/module.dtd";
75
76 private final String dtdUrl;
77 private final BeanReader beanReader;
78
79 public BetwixtModuleDefinitionReader() {
80 final URL dtd = getClass().getResource(DTD);
81 if (dtd == null) {
82 throw new IllegalStateException("DTD not found at " + DTD);
83 }
84 dtdUrl = dtd.toString();
85
86 final BetwixtBindingStrategy bindingStrategy = new BetwixtBindingStrategy();
87 bindingStrategy.registerConverter(Version.class, new VersionConverter());
88
89 beanReader = new BeanReader();
90 try {
91 beanReader.getXMLIntrospector().getConfiguration().setTypeBindingStrategy(bindingStrategy);
92 beanReader.setValidating(true);
93 beanReader.setErrorHandler(new ErrorHandler());
94 beanReader.registerBeanClass(ModuleDefinition.class);
95 } catch (IntrospectionException e) {
96 throw new RuntimeException(e);
97 }
98 }
99
100 @Override
101 public Map<String, ModuleDefinition> readAll() throws ModuleManagementException {
102 final Map<String, ModuleDefinition> moduleDefinitions = new HashMap<String, ModuleDefinition>();
103
104 final String[] defResources = findModuleDescriptors();
105
106 for (final String resourcePath : defResources) {
107 log.debug("Parsing module file {}", resourcePath);
108 final ModuleDefinition def = readFromResource(resourcePath);
109 moduleDefinitions.put(def.getName(), def);
110 }
111 return moduleDefinitions;
112 }
113
114 protected String[] findModuleDescriptors() {
115 return ClasspathResourcesUtil.findResources(new ClasspathResourcesUtil.Filter() {
116 @Override
117 public boolean accept(String name) {
118 return name.startsWith("/META-INF/magnolia/") && name.endsWith(".xml");
119 }
120 });
121 }
122
123 @Override
124 public ModuleDefinition read(Reader in) throws ModuleManagementException {
125 try {
126 final Reader replacedDtd = replaceDtd(in);
127 return (ModuleDefinition) beanReader.parse(replacedDtd);
128 } catch (IOException e) {
129 throw new ModuleManagementException("Can't read module definition file: " + e.getMessage(), e);
130 } catch (SAXException e) {
131 throw new ModuleManagementException(e.getMessage(), e);
132 }
133 }
134
135 @Override
136 public ModuleDefinition readFromResource(String resourcePath) throws ModuleManagementException {
137 final InputStreamReader reader = new InputStreamReader(getClass().getResourceAsStream(resourcePath));
138 try {
139 return read(reader);
140 } finally {
141 try {
142 reader.close();
143 } catch (IOException e) {
144 log.error("Can't close input for " + resourcePath);
145 }
146 }
147 }
148
149
150
151
152
153
154
155
156 private Reader replaceDtd(Reader reader) throws IOException {
157 String content = IOUtils.toString(reader);
158
159
160 Pattern pattern = Pattern.compile("<!DOCTYPE .*>");
161 Matcher matcher = pattern.matcher(content);
162 content = matcher.replaceFirst("");
163
164
165 try {
166 Document doc = new SAXBuilder().build(new StringReader(content));
167 doc.setDocType(new DocType("module", dtdUrl));
168
169 XMLOutputter outputter = new XMLOutputter();
170 StringWriter writer = new StringWriter();
171 outputter.output(doc, writer);
172 final String replacedDtd = writer.toString();
173 return new StringReader(replacedDtd);
174 } catch (JDOMException e) {
175 throw new RuntimeException(e);
176 }
177 }
178
179 private static class ErrorHandler implements org.xml.sax.ErrorHandler {
180
181 @Override
182 public void warning(SAXParseException e) throws SAXException {
183 log.warn("Warning on module definition " + getSaxParseExceptionMessage(e));
184 }
185
186 @Override
187 public void error(SAXParseException e) throws SAXException {
188 throw new SAXException("Invalid module definition file, error " + getSaxParseExceptionMessage(e), e);
189 }
190
191 @Override
192 public void fatalError(SAXParseException e) throws SAXException {
193 throw new SAXException("Invalid module definition file, fatal error " + getSaxParseExceptionMessage(e), e);
194 }
195 }
196
197 private static String getSaxParseExceptionMessage(SAXParseException e) {
198 return "at line " + e.getLineNumber() + " column " + e.getColumnNumber() + ": " + e.getMessage();
199 }
200 }