Skip to main content

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

1use alloc::{string::String as RustString, vec, vec::Vec};
2
3use jvm::{Array, ClassInstanceRef, Jvm, Result, runtime::JavaLangString};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{
8    RuntimeClassProto, RuntimeContext,
9    classes::java::{
10        lang::{Object, String},
11        util::{
12            Hashtable,
13            logging::{ConsoleHandler, Handler, Level, Logger},
14        },
15    },
16};
17
18// public class java.util.logging.LogManager
19pub struct LogManager;
20
21impl LogManager {
22    pub fn as_proto() -> RuntimeClassProto {
23        RuntimeClassProto {
24            name: "java/util/logging/LogManager",
25            parent_class: Some("java/lang/Object"),
26            interfaces: vec![],
27            methods: vec![
28                JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
29                JavaMethodProto::new("<init>", "()V", Self::init, MethodAccessFlags::PROTECTED),
30                JavaMethodProto::new(
31                    "getLogManager",
32                    "()Ljava/util/logging/LogManager;",
33                    Self::get_log_manager,
34                    MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
35                ),
36                JavaMethodProto::new("addLogger", "(Ljava/util/logging/Logger;)Z", Self::add_logger, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new(
38                    "registerLogger",
39                    "(Ljava/lang/String;Ljava/util/logging/Logger;)Z",
40                    Self::register_logger,
41                    MethodAccessFlags::PRIVATE | MethodAccessFlags::SYNCHRONIZED,
42                ),
43                JavaMethodProto::new(
44                    "getLogger",
45                    "(Ljava/lang/String;)Ljava/util/logging/Logger;",
46                    Self::get_logger,
47                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
48                ),
49                JavaMethodProto::new(
50                    "getLoggerNames",
51                    "()Ljava/util/Enumeration;",
52                    Self::get_logger_names,
53                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
54                ),
55                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
56                JavaMethodProto::new(
57                    "snapshotLoggers",
58                    "()[Ljava/util/logging/Logger;",
59                    Self::snapshot_loggers,
60                    MethodAccessFlags::PRIVATE | MethodAccessFlags::SYNCHRONIZED,
61                ),
62                JavaMethodProto::new("checkAccess", "()V", Self::check_access, MethodAccessFlags::PUBLIC),
63            ],
64            fields: vec![
65                JavaFieldProto::new(
66                    "manager",
67                    "Ljava/util/logging/LogManager;",
68                    FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC,
69                ),
70                JavaFieldProto::new("loggers", "Ljava/util/Hashtable;", FieldAccessFlags::PRIVATE),
71                JavaFieldProto::new("root", "Ljava/util/logging/Logger;", FieldAccessFlags::PRIVATE),
72            ],
73            access_flags: ClassAccessFlags::PUBLIC,
74        }
75    }
76
77    async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
78        tracing::debug!("java.util.logging.LogManager::<clinit>()");
79        let manager = jvm.new_class("java/util/logging/LogManager", "()V", ()).await?;
80        jvm.put_static_field("java/util/logging/LogManager", "manager", "Ljava/util/logging/LogManager;", manager)
81            .await
82    }
83
84    async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
85        tracing::debug!("java.util.logging.LogManager::<init>({this:?})");
86
87        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
88        let loggers: ClassInstanceRef<Hashtable> = jvm.new_class("java/util/Hashtable", "()V", ()).await?.into();
89        jvm.put_field(&mut this, "loggers", "Ljava/util/Hashtable;", loggers.clone()).await?;
90
91        let root_name = JavaLangString::from_rust_string(jvm, "").await?;
92        let resource_bundle_name: ClassInstanceRef<String> = None.into();
93        let mut root: ClassInstanceRef<Logger> = jvm
94            .new_class(
95                "java/util/logging/Logger",
96                "(Ljava/lang/String;Ljava/lang/String;)V",
97                (root_name.clone(), resource_bundle_name),
98            )
99            .await?
100            .into();
101        let info: ClassInstanceRef<Level> = jvm
102            .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
103            .await?;
104        jvm.put_field(&mut root, "level", "Ljava/util/logging/Level;", info).await?;
105        jvm.put_field(&mut root, "useParentHandlers", "Z", false).await?;
106        let console: ClassInstanceRef<ConsoleHandler> = jvm.new_class("java/util/logging/ConsoleHandler", "()V", ()).await?.into();
107        let _: () = jvm
108            .invoke_virtual(
109                &root,
110                "java/util/logging/Logger",
111                "addHandler",
112                "(Ljava/util/logging/Handler;)V",
113                (console,),
114            )
115            .await?;
116        let _: ClassInstanceRef<Object> = jvm
117            .invoke_virtual(
118                &loggers,
119                "java/util/Hashtable",
120                "put",
121                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
122                (root_name, root.clone()),
123            )
124            .await?;
125        jvm.put_field(&mut this, "root", "Ljava/util/logging/Logger;", root.clone()).await?;
126
127        let global_name: ClassInstanceRef<String> = jvm
128            .get_static_field("java/util/logging/Logger", "GLOBAL_LOGGER_NAME", "Ljava/lang/String;")
129            .await?;
130        let mut global: ClassInstanceRef<Logger> = jvm
131            .get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
132            .await?;
133        jvm.put_field(&mut global, "parent", "Ljava/util/logging/Logger;", root).await?;
134        let _: ClassInstanceRef<Object> = jvm
135            .invoke_virtual(
136                &loggers,
137                "java/util/Hashtable",
138                "put",
139                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
140                (global_name, global),
141            )
142            .await?;
143        Ok(())
144    }
145
146    async fn get_log_manager(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
147        tracing::debug!("java.util.logging.LogManager::getLogManager()");
148        jvm.get_static_field("java/util/logging/LogManager", "manager", "Ljava/util/logging/LogManager;")
149            .await
150    }
151
152    async fn add_logger(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, logger: ClassInstanceRef<Logger>) -> Result<bool> {
153        tracing::debug!("java.util.logging.LogManager::addLogger({this:?}, {logger:?})");
154        if logger.is_null() {
155            return Err(jvm.exception("java/lang/NullPointerException", "logger").await);
156        }
157        let name: ClassInstanceRef<String> = jvm
158            .invoke_virtual(&logger, "java/util/logging/Logger", "getName", "()Ljava/lang/String;", ())
159            .await?;
160        if name.is_null() {
161            return Err(jvm.exception("java/lang/NullPointerException", "logger name").await);
162        }
163
164        jvm.invoke_special(
165            &this,
166            "java/util/logging/LogManager",
167            "registerLogger",
168            "(Ljava/lang/String;Ljava/util/logging/Logger;)Z",
169            (name, logger),
170        )
171        .await
172    }
173
174    async fn register_logger(
175        jvm: &Jvm,
176        _: &mut RuntimeContext,
177        this: ClassInstanceRef<Self>,
178        name: ClassInstanceRef<String>,
179        logger: ClassInstanceRef<Logger>,
180    ) -> Result<bool> {
181        let loggers: ClassInstanceRef<Hashtable> = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?;
182        let existing: ClassInstanceRef<Object> = jvm
183            .invoke_virtual(
184                &loggers,
185                "java/util/Hashtable",
186                "get",
187                "(Ljava/lang/Object;)Ljava/lang/Object;",
188                (name.clone(),),
189            )
190            .await?;
191        if !existing.is_null() {
192            return Ok(false);
193        }
194        let _: ClassInstanceRef<Object> = jvm
195            .invoke_virtual(
196                &loggers,
197                "java/util/Hashtable",
198                "put",
199                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
200                (name, logger),
201            )
202            .await?;
203        Self::reconnect_parents(jvm, &this, &loggers).await?;
204        Ok(true)
205    }
206
207    async fn get_logger(
208        jvm: &Jvm,
209        _: &mut RuntimeContext,
210        this: ClassInstanceRef<Self>,
211        name: ClassInstanceRef<String>,
212    ) -> Result<ClassInstanceRef<Logger>> {
213        tracing::debug!("java.util.logging.LogManager::getLogger({this:?}, {name:?})");
214        if name.is_null() {
215            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
216        }
217        let loggers: ClassInstanceRef<Hashtable> = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?;
218        jvm.invoke_virtual(&loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (name,))
219            .await
220    }
221
222    async fn get_logger_names(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
223        tracing::debug!("java.util.logging.LogManager::getLoggerNames({this:?})");
224        let loggers: ClassInstanceRef<Hashtable> = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?;
225        jvm.invoke_virtual(&loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
226            .await
227    }
228
229    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
230        tracing::debug!("java.util.logging.LogManager::reset({this:?})");
231        let loggers: ClassInstanceRef<Array<Logger>> = jvm
232            .invoke_special(
233                &this,
234                "java/util/logging/LogManager",
235                "snapshotLoggers",
236                "()[Ljava/util/logging/Logger;",
237                (),
238            )
239            .await?;
240        let root: ClassInstanceRef<Logger> = jvm.get_field(&this, "root", "Ljava/util/logging/Logger;").await?;
241        let length = jvm.array_length(&loggers).await?;
242        let loggers: Vec<ClassInstanceRef<Logger>> = jvm.load_array(&loggers, 0, length).await?;
243        for logger in loggers {
244            let handlers: ClassInstanceRef<Array<Handler>> = jvm
245                .invoke_special(
246                    &logger,
247                    "java/util/logging/Logger",
248                    "reset",
249                    "(Z)[Ljava/util/logging/Handler;",
250                    (logger.identity() == root.identity(),),
251                )
252                .await?;
253            let length = jvm.array_length(&handlers).await?;
254            let handlers: Vec<ClassInstanceRef<Handler>> = jvm.load_array(&handlers, 0, length).await?;
255            for handler in handlers {
256                let _: () = jvm.invoke_virtual(&handler, "java/util/logging/Handler", "close", "()V", ()).await?;
257            }
258        }
259        Ok(())
260    }
261
262    async fn snapshot_loggers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Logger>>> {
263        let loggers: ClassInstanceRef<Hashtable> = jvm.get_field(&this, "loggers", "Ljava/util/Hashtable;").await?;
264        let values: ClassInstanceRef<Object> = jvm
265            .invoke_virtual(&loggers, "java/util/Hashtable", "elements", "()Ljava/util/Enumeration;", ())
266            .await?;
267        let mut snapshot: Vec<ClassInstanceRef<Logger>> = Vec::new();
268        while jvm
269            .invoke_virtual::<_, bool>(&values, &values.class_definition().name(), "hasMoreElements", "()Z", ())
270            .await?
271        {
272            snapshot.push(
273                jvm.invoke_virtual(&values, &values.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
274                    .await?,
275            );
276        }
277
278        let mut result: ClassInstanceRef<Array<Logger>> = jvm.instantiate_array("Ljava/util/logging/Logger;", snapshot.len()).await?.into();
279        for (index, logger) in snapshot.into_iter().enumerate() {
280            jvm.store_array(&mut result, index, [logger]).await?;
281        }
282        Ok(result)
283    }
284
285    async fn check_access(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
286        tracing::debug!("java.util.logging.LogManager::checkAccess({this:?})");
287        Ok(())
288    }
289
290    async fn reconnect_parents(jvm: &Jvm, manager: &ClassInstanceRef<Self>, loggers: &ClassInstanceRef<Hashtable>) -> Result<()> {
291        let names: ClassInstanceRef<Object> = jvm
292            .invoke_virtual(loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
293            .await?;
294        let mut keys = Vec::new();
295        while jvm
296            .invoke_virtual::<_, bool>(&names, &names.class_definition().name(), "hasMoreElements", "()Z", ())
297            .await?
298        {
299            keys.push(
300                jvm.invoke_virtual(&names, &names.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
301                    .await?,
302            );
303        }
304
305        let root: ClassInstanceRef<Logger> = jvm.get_field(manager, "root", "Ljava/util/logging/Logger;").await?;
306        for key in keys {
307            let name: RustString = JavaLangString::to_rust_string(jvm, &key).await?;
308            if name.is_empty() {
309                continue;
310            }
311            let mut logger: ClassInstanceRef<Logger> = jvm
312                .invoke_virtual(loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (key,))
313                .await?;
314            let mut parent = root.clone();
315            let mut prefix = name.as_str();
316            while let Some(index) = prefix.rfind('.') {
317                prefix = &prefix[..index];
318                let candidate_name = JavaLangString::from_rust_string(jvm, prefix).await?;
319                let candidate: ClassInstanceRef<Logger> = jvm
320                    .invoke_virtual(
321                        loggers,
322                        "java/util/Hashtable",
323                        "get",
324                        "(Ljava/lang/Object;)Ljava/lang/Object;",
325                        (candidate_name,),
326                    )
327                    .await?;
328                if !candidate.is_null() {
329                    parent = candidate;
330                    break;
331                }
332            }
333            jvm.put_field(&mut logger, "parent", "Ljava/util/logging/Logger;", parent).await?;
334        }
335        Ok(())
336    }
337}