/
XmlSaxPushParser.java
285 lines (245 loc) · 7.31 KB
/
XmlSaxPushParser.java
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
package nokogiri;
import nokogiri.internals.*;
import org.jruby.Ruby;
import org.jruby.RubyClass;
import org.jruby.RubyException;
import org.jruby.RubyObject;
import org.jruby.anno.JRubyClass;
import org.jruby.anno.JRubyMethod;
import org.jruby.exceptions.RaiseException;
import org.jruby.runtime.ThreadContext;
import org.jruby.runtime.builtin.IRubyObject;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.concurrent.*;
import static nokogiri.internals.NokogiriHelpers.getNokogiriClass;
import static org.jruby.runtime.Helpers.invoke;
/**
* Class for Nokogiri::XML::SAX::PushParser
*
* @author Patrick Mahoney <pat@polycrystal.org>
* @author Yoko Harada <yokolet@gmail.com>
*/
@JRubyClass(name = "Nokogiri::XML::SAX::PushParser")
public class XmlSaxPushParser extends RubyObject
{
ParserContext.Options options;
IRubyObject saxParser;
NokogiriBlockingQueueInputStream stream;
private ParserTask parserTask = null;
private FutureTask<XmlSaxParserContext> futureTask = null;
private ExecutorService executor = null;
RaiseException ex = null;
public
XmlSaxPushParser(Ruby ruby, RubyClass rubyClass)
{
super(ruby, rubyClass);
}
@Override
public void
finalize()
{
try {
terminateImpl();
} catch (Exception e) { /* ignored */ }
}
@JRubyMethod
public IRubyObject
initialize_native(final ThreadContext context, IRubyObject saxParser, IRubyObject fileName)
{
options = new ParserContext.Options(0);
this.saxParser = saxParser;
return this;
}
private transient IRubyObject parse_options;
private IRubyObject
parse_options(final ThreadContext context)
{
if (parse_options == null) {
parse_options = invoke(context, context.runtime.getClassFromPath("Nokogiri::XML::ParseOptions"), "new");
}
return parse_options;
}
@JRubyMethod(name = "options")
public IRubyObject
getOptions(ThreadContext context)
{
return invoke(context, parse_options(context), "options");
}
@JRubyMethod(name = "options=")
public IRubyObject
setOptions(ThreadContext context, IRubyObject opts)
{
invoke(context, parse_options(context), "options=", opts);
options = new ParserContext.Options(opts.convertToInteger().getLongValue());
return getOptions(context);
}
/**
* Can take a boolean assignment.
*
* @param context
* @param value
* @return
*/
@JRubyMethod(name = "replace_entities=")
public IRubyObject
setReplaceEntities(ThreadContext context, IRubyObject value)
{
// Ignore the value.
return this;
}
@JRubyMethod(name = "replace_entities")
public IRubyObject
getReplaceEntities(ThreadContext context)
{
// The java parser always replaces entities.
return context.getRuntime().getTrue();
}
@JRubyMethod
public IRubyObject
native_write(ThreadContext context, IRubyObject chunk,
IRubyObject isLast)
{
if (ex != null) {
// parser has already errored, rethrow the exception
throw ex;
}
try {
initialize_task(context);
} catch (IOException e) {
throw context.runtime.newRuntimeError(e.getMessage());
}
final ByteArrayInputStream data = NokogiriHelpers.stringBytesToStream(chunk);
if (data == null) {
return this;
}
int errorCount0 = parserTask.getErrorCount();
try {
Future<Void> task = stream.addChunk(data);
task.get();
} catch (ClosedStreamException ex) {
// this means the stream is closed, ignore this exception
} catch (Exception e) {
throw context.runtime.newRuntimeError(e.toString());
}
if (isLast.isTrue()) {
parserTask.getNokogiriHandler().endDocument();
terminateTask(context.runtime);
}
if (!options.recover && parserTask.getErrorCount() > errorCount0) {
terminateTask(context.runtime);
ex = parserTask.getLastError().toThrowable();
throw ex;
}
return this;
}
private void
initialize_task(ThreadContext context) throws IOException
{
if (futureTask == null || stream == null) {
stream = new NokogiriBlockingQueueInputStream();
assert saxParser != null : "saxParser null";
parserTask = new ParserTask(context, saxParser, stream);
futureTask = new FutureTask<XmlSaxParserContext>(parserTask);
executor = Executors.newSingleThreadExecutor(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setName("XmlSaxPushParser");
t.setDaemon(true);
return t;
}
});
executor.submit(futureTask);
}
}
private void
terminateTask(final Ruby runtime)
{
if (executor == null) { return; }
try {
terminateImpl();
} catch (InterruptedException e) {
throw runtime.newRuntimeError(e.toString());
} catch (Exception e) {
throw runtime.newRuntimeError(e.toString());
}
}
private synchronized void
terminateImpl() throws InterruptedException, ExecutionException
{
terminateExecution(executor, stream, futureTask);
executor = null;
stream = null;
futureTask = null;
}
// SHARED for Html4SaxPushParser
static void
terminateExecution(final ExecutorService executor, final NokogiriBlockingQueueInputStream stream,
final FutureTask<?> futureTask)
throws InterruptedException, ExecutionException
{
if (executor == null) { return; }
try {
Future<Void> task = stream.addChunk(NokogiriBlockingQueueInputStream.END);
task.get();
} catch (ClosedStreamException ex) {
// ignore this exception, it means the stream was closed
}
futureTask.cancel(true);
executor.shutdown();
}
private static XmlSaxParserContext
parse(final Ruby runtime, final InputStream stream)
{
RubyClass klazz = getNokogiriClass(runtime, "Nokogiri::XML::SAX::ParserContext");
return XmlSaxParserContext.parse_stream(runtime, klazz, stream);
}
static class ParserTask extends ParserContext.ParserTask<XmlSaxParserContext>
{
final InputStream stream;
private
ParserTask(ThreadContext context, IRubyObject handler, InputStream stream)
{
this(context, handler, parse(context.runtime, stream), stream);
}
// IMPL with Html4SaxPushParser
protected
ParserTask(ThreadContext context, IRubyObject handler, XmlSaxParserContext parser, InputStream stream)
{
super(context, handler, parser);
this.stream = stream;
}
@Override
public XmlSaxParserContext
call() throws Exception
{
try {
parser.parse_with(context, handler);
} finally { stream.close(); }
// we have to close the stream before exiting, otherwise someone
// can add a chunk and block on task.get() forever.
return parser;
}
final NokogiriHandler
getNokogiriHandler()
{
return parser.getNokogiriHandler();
}
synchronized final int
getErrorCount()
{
// check for null because thread may not have started yet
if (parser.getNokogiriErrorHandler() == null) { return 0; }
return parser.getNokogiriErrorHandler().getErrors().size();
}
synchronized final RubyException
getLastError()
{
List<RubyException> errors = parser.getNokogiriErrorHandler().getErrors();
return errors.get(errors.size() - 1);
}
}
}