1use alloc::vec;
2
3use jvm::{ClassInstanceRef, JavaError, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8 RuntimeClassProto, RuntimeContext,
9 classes::java::{
10 io::{OutputStream, OutputStreamWriter},
11 lang::{Exception, String},
12 },
13};
14
15use super::{Formatter, Level, LogRecord, SimpleFormatter};
16
17pub struct StreamHandler;
19
20impl StreamHandler {
21 pub fn as_proto() -> RuntimeClassProto {
22 RuntimeClassProto {
23 name: "java/util/logging/StreamHandler",
24 parent_class: Some("java/util/logging/Handler"),
25 interfaces: vec![],
26 methods: vec![
27 JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PUBLIC),
28 JavaMethodProto::new(
29 "<init>",
30 "(Ljava/io/OutputStream;Ljava/util/logging/Formatter;)V",
31 Self::init_with_output,
32 MethodAccessFlags::PUBLIC,
33 ),
34 JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
35 JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
36 JavaMethodProto::new(
37 "isLoggable",
38 "(Ljava/util/logging/LogRecord;)Z",
39 Self::is_loggable,
40 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
41 ),
42 JavaMethodProto::new(
43 "publish",
44 "(Ljava/util/logging/LogRecord;)V",
45 Self::publish,
46 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
47 ),
48 JavaMethodProto::new(
49 "setEncoding",
50 "(Ljava/lang/String;)V",
51 Self::set_encoding,
52 MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
53 ),
54 JavaMethodProto::new(
55 "setOutputStream",
56 "(Ljava/io/OutputStream;)V",
57 Self::set_output_stream,
58 MethodAccessFlags::PROTECTED | MethodAccessFlags::SYNCHRONIZED,
59 ),
60 ],
61 fields: vec![
62 JavaFieldProto::new("output", "Ljava/io/OutputStream;", FieldAccessFlags::PRIVATE),
63 JavaFieldProto::new("writer", "Ljava/io/OutputStreamWriter;", FieldAccessFlags::PRIVATE),
64 JavaFieldProto::new("headerWritten", "Z", FieldAccessFlags::PRIVATE),
65 ],
66 access_flags: ClassAccessFlags::PUBLIC,
67 }
68 }
69
70 async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
71 tracing::debug!("java.util.logging.StreamHandler::<init>({this:?})");
72
73 let _: () = jvm.invoke_special(&this, "java/util/logging/Handler", "<init>", "()V", ()).await?;
74 let formatter: ClassInstanceRef<SimpleFormatter> = jvm.new_class("java/util/logging/SimpleFormatter", "()V", ()).await?.into();
75 let level: ClassInstanceRef<Level> = jvm
76 .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
77 .await?;
78 let _: () = jvm
79 .invoke_special(
80 &this,
81 "java/util/logging/Handler",
82 "setFormatter",
83 "(Ljava/util/logging/Formatter;)V",
84 (formatter,),
85 )
86 .await?;
87 let _: () = jvm
88 .invoke_special(&this, "java/util/logging/Handler", "setLevel", "(Ljava/util/logging/Level;)V", (level,))
89 .await?;
90 jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false)
91 .await
92 }
93
94 async fn init_with_output(
95 jvm: &Jvm,
96 _: &mut RuntimeContext,
97 this: ClassInstanceRef<Self>,
98 output: ClassInstanceRef<OutputStream>,
99 formatter: ClassInstanceRef<Formatter>,
100 ) -> Result<()> {
101 tracing::debug!("java.util.logging.StreamHandler::<init>({this:?}, {output:?}, {formatter:?})");
102
103 if output.is_null() {
104 return Err(jvm.exception("java/lang/NullPointerException", "output").await);
105 }
106 if formatter.is_null() {
107 return Err(jvm.exception("java/lang/NullPointerException", "formatter").await);
108 }
109
110 let _: () = jvm.invoke_special(&this, "java/util/logging/StreamHandler", "<init>", "()V", ()).await?;
111 let _: () = jvm
112 .invoke_special(
113 &this,
114 "java/util/logging/Handler",
115 "setFormatter",
116 "(Ljava/util/logging/Formatter;)V",
117 (formatter,),
118 )
119 .await?;
120 jvm.invoke_special(
121 &this,
122 "java/util/logging/StreamHandler",
123 "setOutputStream",
124 "(Ljava/io/OutputStream;)V",
125 (output,),
126 )
127 .await
128 }
129
130 async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
131 tracing::debug!("java.util.logging.StreamHandler::close({this:?})");
132
133 let writer: ClassInstanceRef<OutputStreamWriter> = jvm
134 .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
135 .await?;
136 if writer.is_null() {
137 return Ok(());
138 }
139
140 Self::write_tail(jvm, &this).await?;
141 let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
142 let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "close", "()V", ()).await?;
143 let output: ClassInstanceRef<OutputStream> = None.into();
144 let writer: ClassInstanceRef<OutputStreamWriter> = None.into();
145 jvm.put_field(&mut this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;", output)
146 .await?;
147 jvm.put_field(
148 &mut this,
149 "java/util/logging/StreamHandler",
150 "writer",
151 "Ljava/io/OutputStreamWriter;",
152 writer,
153 )
154 .await?;
155 jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false)
156 .await
157 }
158
159 async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
160 tracing::debug!("java.util.logging.StreamHandler::flush({this:?})");
161
162 let writer: ClassInstanceRef<OutputStreamWriter> = jvm
163 .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
164 .await?;
165 if writer.is_null() {
166 return Ok(());
167 }
168 jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await
169 }
170
171 async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<bool> {
172 tracing::debug!("java.util.logging.StreamHandler::isLoggable({this:?}, {record:?})");
173
174 let output: ClassInstanceRef<OutputStream> = jvm
175 .get_field(&this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;")
176 .await?;
177 if output.is_null() || record.is_null() {
178 return Ok(false);
179 }
180
181 jvm.invoke_special(
182 &this,
183 "java/util/logging/Handler",
184 "isLoggable",
185 "(Ljava/util/logging/LogRecord;)Z",
186 (record,),
187 )
188 .await
189 }
190
191 async fn publish(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<()> {
192 tracing::debug!("java.util.logging.StreamHandler::publish({this:?}, {record:?})");
193
194 let loggable: bool = jvm
195 .invoke_virtual(
196 &this,
197 "java/util/logging/StreamHandler",
198 "isLoggable",
199 "(Ljava/util/logging/LogRecord;)Z",
200 (record.clone(),),
201 )
202 .await?;
203 if !loggable {
204 return Ok(());
205 }
206
207 if let Err(JavaError::JavaException(exception)) = Self::write_head(jvm, &this).await {
208 if !jvm.is_instance(&*exception, "java/lang/Exception") {
209 return Err(JavaError::JavaException(exception));
210 }
211 let message: ClassInstanceRef<String> = None.into();
212 let exception: ClassInstanceRef<Exception> = exception.into();
213 let _: () = jvm
214 .invoke_virtual(
215 &this,
216 "java/util/logging/StreamHandler",
217 "reportError",
218 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
219 (message, exception, 1),
220 )
221 .await?;
222 return Ok(());
223 }
224 let formatter: ClassInstanceRef<Formatter> = jvm
225 .get_field(&this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;")
226 .await?;
227 let formatted: ClassInstanceRef<String> = match jvm
228 .invoke_virtual(
229 &formatter,
230 "java/util/logging/Formatter",
231 "format",
232 "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
233 (record,),
234 )
235 .await
236 {
237 Ok(formatted) => formatted,
238 Err(JavaError::JavaException(exception)) => {
239 if !jvm.is_instance(&*exception, "java/lang/Exception") {
240 return Err(JavaError::JavaException(exception));
241 }
242 let message: ClassInstanceRef<String> = None.into();
243 let exception: ClassInstanceRef<Exception> = exception.into();
244 let _: () = jvm
245 .invoke_virtual(
246 &this,
247 "java/util/logging/StreamHandler",
248 "reportError",
249 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
250 (message, exception, 5),
251 )
252 .await?;
253 return Ok(());
254 }
255 };
256 let writer: ClassInstanceRef<OutputStreamWriter> = jvm
257 .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
258 .await?;
259 if let Err(JavaError::JavaException(exception)) = jvm
260 .invoke_virtual::<_, ()>(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (formatted,))
261 .await
262 {
263 if !jvm.is_instance(&*exception, "java/lang/Exception") {
264 return Err(JavaError::JavaException(exception));
265 }
266 let message: ClassInstanceRef<String> = None.into();
267 let exception: ClassInstanceRef<Exception> = exception.into();
268 let _: () = jvm
269 .invoke_virtual(
270 &this,
271 "java/util/logging/StreamHandler",
272 "reportError",
273 "(Ljava/lang/String;Ljava/lang/Exception;I)V",
274 (message, exception, 1),
275 )
276 .await?;
277 }
278 Ok(())
279 }
280
281 async fn set_encoding(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, encoding: ClassInstanceRef<String>) -> Result<()> {
282 tracing::debug!("java.util.logging.StreamHandler::setEncoding({this:?}, {encoding:?})");
283
284 let _: () = jvm
285 .invoke_special(
286 &this,
287 "java/util/logging/Handler",
288 "setEncoding",
289 "(Ljava/lang/String;)V",
290 (encoding.clone(),),
291 )
292 .await?;
293
294 let output: ClassInstanceRef<OutputStream> = jvm
295 .get_field(&this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;")
296 .await?;
297 if output.is_null() {
298 return Ok(());
299 }
300
301 let writer: ClassInstanceRef<OutputStreamWriter> = jvm
302 .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
303 .await?;
304 let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
305 let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
306 jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output,))
307 .await?
308 .into()
309 } else {
310 jvm.new_class(
311 "java/io/OutputStreamWriter",
312 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
313 (output, encoding),
314 )
315 .await?
316 .into()
317 };
318 jvm.put_field(
319 &mut this,
320 "java/util/logging/StreamHandler",
321 "writer",
322 "Ljava/io/OutputStreamWriter;",
323 writer,
324 )
325 .await
326 }
327
328 async fn set_output_stream(
329 jvm: &Jvm,
330 _: &mut RuntimeContext,
331 mut this: ClassInstanceRef<Self>,
332 output: ClassInstanceRef<OutputStream>,
333 ) -> Result<()> {
334 tracing::debug!("java.util.logging.StreamHandler::setOutputStream({this:?}, {output:?})");
335
336 if output.is_null() {
337 return Err(jvm.exception("java/lang/NullPointerException", "output").await);
338 }
339
340 let current_writer: ClassInstanceRef<OutputStreamWriter> = jvm
341 .get_field(&this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
342 .await?;
343 if !current_writer.is_null() {
344 Self::write_tail(jvm, &this).await?;
345 let _: () = jvm
346 .invoke_virtual(¤t_writer, "java/io/OutputStreamWriter", "flush", "()V", ())
347 .await?;
348 let _: () = jvm
349 .invoke_virtual(¤t_writer, "java/io/OutputStreamWriter", "close", "()V", ())
350 .await?;
351 }
352
353 let encoding: ClassInstanceRef<String> = jvm
354 .get_field(&this, "java/util/logging/StreamHandler", "encoding", "Ljava/lang/String;")
355 .await?;
356 let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
357 jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output.clone(),))
358 .await?
359 .into()
360 } else {
361 jvm.new_class(
362 "java/io/OutputStreamWriter",
363 "(Ljava/io/OutputStream;Ljava/lang/String;)V",
364 (output.clone(), encoding),
365 )
366 .await?
367 .into()
368 };
369 jvm.put_field(&mut this, "java/util/logging/StreamHandler", "output", "Ljava/io/OutputStream;", output)
370 .await?;
371 jvm.put_field(
372 &mut this,
373 "java/util/logging/StreamHandler",
374 "writer",
375 "Ljava/io/OutputStreamWriter;",
376 writer,
377 )
378 .await?;
379 jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", false)
380 .await
381 }
382
383 async fn write_head(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
384 if jvm
385 .get_field::<bool>(this, "java/util/logging/StreamHandler", "headerWritten", "Z")
386 .await?
387 {
388 return Ok(());
389 }
390
391 let formatter: ClassInstanceRef<Formatter> = jvm
392 .get_field(this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;")
393 .await?;
394 let head: ClassInstanceRef<String> = jvm
395 .invoke_virtual(
396 &formatter,
397 "java/util/logging/Formatter",
398 "getHead",
399 "(Ljava/util/logging/Handler;)Ljava/lang/String;",
400 (this.clone(),),
401 )
402 .await?;
403 let writer: ClassInstanceRef<OutputStreamWriter> = jvm
404 .get_field(this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
405 .await?;
406 let _: () = jvm
407 .invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (head,))
408 .await?;
409 let mut this = this.clone();
410 jvm.put_field(&mut this, "java/util/logging/StreamHandler", "headerWritten", "Z", true)
411 .await
412 }
413
414 async fn write_tail(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
415 Self::write_head(jvm, this).await?;
416 let formatter: ClassInstanceRef<Formatter> = jvm
417 .get_field(this, "java/util/logging/StreamHandler", "formatter", "Ljava/util/logging/Formatter;")
418 .await?;
419 let tail: ClassInstanceRef<String> = jvm
420 .invoke_virtual(
421 &formatter,
422 "java/util/logging/Formatter",
423 "getTail",
424 "(Ljava/util/logging/Handler;)Ljava/lang/String;",
425 (this.clone(),),
426 )
427 .await?;
428 let writer: ClassInstanceRef<OutputStreamWriter> = jvm
429 .get_field(this, "java/util/logging/StreamHandler", "writer", "Ljava/io/OutputStreamWriter;")
430 .await?;
431 jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (tail,))
432 .await
433 }
434}