Skip to main content

rustjava_runtime/classes/java/util/logging/
stream_handler.rs

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
17// public class java.util.logging.StreamHandler
18pub 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, "headerWritten", "Z", false).await
91    }
92
93    async fn init_with_output(
94        jvm: &Jvm,
95        _: &mut RuntimeContext,
96        this: ClassInstanceRef<Self>,
97        output: ClassInstanceRef<OutputStream>,
98        formatter: ClassInstanceRef<Formatter>,
99    ) -> Result<()> {
100        tracing::debug!("java.util.logging.StreamHandler::<init>({this:?}, {output:?}, {formatter:?})");
101
102        if output.is_null() {
103            return Err(jvm.exception("java/lang/NullPointerException", "output").await);
104        }
105        if formatter.is_null() {
106            return Err(jvm.exception("java/lang/NullPointerException", "formatter").await);
107        }
108
109        let _: () = jvm.invoke_special(&this, "java/util/logging/StreamHandler", "<init>", "()V", ()).await?;
110        let _: () = jvm
111            .invoke_special(
112                &this,
113                "java/util/logging/Handler",
114                "setFormatter",
115                "(Ljava/util/logging/Formatter;)V",
116                (formatter,),
117            )
118            .await?;
119        jvm.invoke_special(
120            &this,
121            "java/util/logging/StreamHandler",
122            "setOutputStream",
123            "(Ljava/io/OutputStream;)V",
124            (output,),
125        )
126        .await
127    }
128
129    async fn close(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
130        tracing::debug!("java.util.logging.StreamHandler::close({this:?})");
131
132        let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
133        if writer.is_null() {
134            return Ok(());
135        }
136
137        Self::write_tail(jvm, &this).await?;
138        let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
139        let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "close", "()V", ()).await?;
140        let output: ClassInstanceRef<OutputStream> = None.into();
141        let writer: ClassInstanceRef<OutputStreamWriter> = None.into();
142        jvm.put_field(&mut this, "output", "Ljava/io/OutputStream;", output).await?;
143        jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await?;
144        jvm.put_field(&mut this, "headerWritten", "Z", false).await
145    }
146
147    async fn flush(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
148        tracing::debug!("java.util.logging.StreamHandler::flush({this:?})");
149
150        let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
151        if writer.is_null() {
152            return Ok(());
153        }
154        jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await
155    }
156
157    async fn is_loggable(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<bool> {
158        tracing::debug!("java.util.logging.StreamHandler::isLoggable({this:?}, {record:?})");
159
160        let output: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "output", "Ljava/io/OutputStream;").await?;
161        if output.is_null() || record.is_null() {
162            return Ok(false);
163        }
164
165        jvm.invoke_special(
166            &this,
167            "java/util/logging/Handler",
168            "isLoggable",
169            "(Ljava/util/logging/LogRecord;)Z",
170            (record,),
171        )
172        .await
173    }
174
175    async fn publish(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, record: ClassInstanceRef<LogRecord>) -> Result<()> {
176        tracing::debug!("java.util.logging.StreamHandler::publish({this:?}, {record:?})");
177
178        let loggable: bool = jvm
179            .invoke_virtual(
180                &this,
181                "java/util/logging/StreamHandler",
182                "isLoggable",
183                "(Ljava/util/logging/LogRecord;)Z",
184                (record.clone(),),
185            )
186            .await?;
187        if !loggable {
188            return Ok(());
189        }
190
191        if let Err(JavaError::JavaException(exception)) = Self::write_head(jvm, &this).await {
192            if !jvm.is_instance(&*exception, "java/lang/Exception") {
193                return Err(JavaError::JavaException(exception));
194            }
195            let message: ClassInstanceRef<String> = None.into();
196            let exception: ClassInstanceRef<Exception> = exception.into();
197            let _: () = jvm
198                .invoke_virtual(
199                    &this,
200                    "java/util/logging/StreamHandler",
201                    "reportError",
202                    "(Ljava/lang/String;Ljava/lang/Exception;I)V",
203                    (message, exception, 1),
204                )
205                .await?;
206            return Ok(());
207        }
208        let formatter: ClassInstanceRef<Formatter> = jvm.get_field(&this, "formatter", "Ljava/util/logging/Formatter;").await?;
209        let formatted: ClassInstanceRef<String> = match jvm
210            .invoke_virtual(
211                &formatter,
212                "java/util/logging/Formatter",
213                "format",
214                "(Ljava/util/logging/LogRecord;)Ljava/lang/String;",
215                (record,),
216            )
217            .await
218        {
219            Ok(formatted) => formatted,
220            Err(JavaError::JavaException(exception)) => {
221                if !jvm.is_instance(&*exception, "java/lang/Exception") {
222                    return Err(JavaError::JavaException(exception));
223                }
224                let message: ClassInstanceRef<String> = None.into();
225                let exception: ClassInstanceRef<Exception> = exception.into();
226                let _: () = jvm
227                    .invoke_virtual(
228                        &this,
229                        "java/util/logging/StreamHandler",
230                        "reportError",
231                        "(Ljava/lang/String;Ljava/lang/Exception;I)V",
232                        (message, exception, 5),
233                    )
234                    .await?;
235                return Ok(());
236            }
237        };
238        let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
239        if let Err(JavaError::JavaException(exception)) = jvm
240            .invoke_virtual::<_, ()>(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (formatted,))
241            .await
242        {
243            if !jvm.is_instance(&*exception, "java/lang/Exception") {
244                return Err(JavaError::JavaException(exception));
245            }
246            let message: ClassInstanceRef<String> = None.into();
247            let exception: ClassInstanceRef<Exception> = exception.into();
248            let _: () = jvm
249                .invoke_virtual(
250                    &this,
251                    "java/util/logging/StreamHandler",
252                    "reportError",
253                    "(Ljava/lang/String;Ljava/lang/Exception;I)V",
254                    (message, exception, 1),
255                )
256                .await?;
257        }
258        Ok(())
259    }
260
261    async fn set_encoding(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, encoding: ClassInstanceRef<String>) -> Result<()> {
262        tracing::debug!("java.util.logging.StreamHandler::setEncoding({this:?}, {encoding:?})");
263
264        let _: () = jvm
265            .invoke_special(
266                &this,
267                "java/util/logging/Handler",
268                "setEncoding",
269                "(Ljava/lang/String;)V",
270                (encoding.clone(),),
271            )
272            .await?;
273
274        let output: ClassInstanceRef<OutputStream> = jvm.get_field(&this, "output", "Ljava/io/OutputStream;").await?;
275        if output.is_null() {
276            return Ok(());
277        }
278
279        let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
280        let _: () = jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "flush", "()V", ()).await?;
281        let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
282            jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output,))
283                .await?
284                .into()
285        } else {
286            jvm.new_class(
287                "java/io/OutputStreamWriter",
288                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
289                (output, encoding),
290            )
291            .await?
292            .into()
293        };
294        jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await
295    }
296
297    async fn set_output_stream(
298        jvm: &Jvm,
299        _: &mut RuntimeContext,
300        mut this: ClassInstanceRef<Self>,
301        output: ClassInstanceRef<OutputStream>,
302    ) -> Result<()> {
303        tracing::debug!("java.util.logging.StreamHandler::setOutputStream({this:?}, {output:?})");
304
305        if output.is_null() {
306            return Err(jvm.exception("java/lang/NullPointerException", "output").await);
307        }
308
309        let current_writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(&this, "writer", "Ljava/io/OutputStreamWriter;").await?;
310        if !current_writer.is_null() {
311            Self::write_tail(jvm, &this).await?;
312            let _: () = jvm
313                .invoke_virtual(&current_writer, "java/io/OutputStreamWriter", "flush", "()V", ())
314                .await?;
315            let _: () = jvm
316                .invoke_virtual(&current_writer, "java/io/OutputStreamWriter", "close", "()V", ())
317                .await?;
318        }
319
320        let encoding: ClassInstanceRef<String> = jvm.get_field(&this, "encoding", "Ljava/lang/String;").await?;
321        let writer: ClassInstanceRef<OutputStreamWriter> = if encoding.is_null() {
322            jvm.new_class("java/io/OutputStreamWriter", "(Ljava/io/OutputStream;)V", (output.clone(),))
323                .await?
324                .into()
325        } else {
326            jvm.new_class(
327                "java/io/OutputStreamWriter",
328                "(Ljava/io/OutputStream;Ljava/lang/String;)V",
329                (output.clone(), encoding),
330            )
331            .await?
332            .into()
333        };
334        jvm.put_field(&mut this, "output", "Ljava/io/OutputStream;", output).await?;
335        jvm.put_field(&mut this, "writer", "Ljava/io/OutputStreamWriter;", writer).await?;
336        jvm.put_field(&mut this, "headerWritten", "Z", false).await
337    }
338
339    async fn write_head(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
340        if jvm.get_field::<bool>(this, "headerWritten", "Z").await? {
341            return Ok(());
342        }
343
344        let formatter: ClassInstanceRef<Formatter> = jvm.get_field(this, "formatter", "Ljava/util/logging/Formatter;").await?;
345        let head: ClassInstanceRef<String> = jvm
346            .invoke_virtual(
347                &formatter,
348                "java/util/logging/Formatter",
349                "getHead",
350                "(Ljava/util/logging/Handler;)Ljava/lang/String;",
351                (this.clone(),),
352            )
353            .await?;
354        let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "writer", "Ljava/io/OutputStreamWriter;").await?;
355        let _: () = jvm
356            .invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (head,))
357            .await?;
358        let mut this = this.clone();
359        jvm.put_field(&mut this, "headerWritten", "Z", true).await
360    }
361
362    async fn write_tail(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<()> {
363        Self::write_head(jvm, this).await?;
364        let formatter: ClassInstanceRef<Formatter> = jvm.get_field(this, "formatter", "Ljava/util/logging/Formatter;").await?;
365        let tail: ClassInstanceRef<String> = jvm
366            .invoke_virtual(
367                &formatter,
368                "java/util/logging/Formatter",
369                "getTail",
370                "(Ljava/util/logging/Handler;)Ljava/lang/String;",
371                (this.clone(),),
372            )
373            .await?;
374        let writer: ClassInstanceRef<OutputStreamWriter> = jvm.get_field(this, "writer", "Ljava/io/OutputStreamWriter;").await?;
375        jvm.invoke_virtual(&writer, "java/io/OutputStreamWriter", "write", "(Ljava/lang/String;)V", (tail,))
376            .await
377    }
378}