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(
90            &mut this,
91            "java/util/logging/LogManager",
92            "loggers",
93            "Ljava/util/Hashtable;",
94            loggers.clone(),
95        )
96        .await?;
97
98        let root_name = JavaLangString::from_rust_string(jvm, "").await?;
99        let resource_bundle_name: ClassInstanceRef<String> = None.into();
100        let mut root: ClassInstanceRef<Logger> = jvm
101            .new_class(
102                "java/util/logging/Logger",
103                "(Ljava/lang/String;Ljava/lang/String;)V",
104                (root_name.clone(), resource_bundle_name),
105            )
106            .await?
107            .into();
108        let info: ClassInstanceRef<Level> = jvm
109            .get_static_field("java/util/logging/Level", "INFO", "Ljava/util/logging/Level;")
110            .await?;
111        jvm.put_field(&mut root, "java/util/logging/Logger", "level", "Ljava/util/logging/Level;", info)
112            .await?;
113        jvm.put_field(&mut root, "java/util/logging/Logger", "useParentHandlers", "Z", false)
114            .await?;
115        let console: ClassInstanceRef<ConsoleHandler> = jvm.new_class("java/util/logging/ConsoleHandler", "()V", ()).await?.into();
116        let _: () = jvm
117            .invoke_virtual(
118                &root,
119                "java/util/logging/Logger",
120                "addHandler",
121                "(Ljava/util/logging/Handler;)V",
122                (console,),
123            )
124            .await?;
125        let _: ClassInstanceRef<Object> = jvm
126            .invoke_virtual(
127                &loggers,
128                "java/util/Hashtable",
129                "put",
130                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
131                (root_name, root.clone()),
132            )
133            .await?;
134        jvm.put_field(
135            &mut this,
136            "java/util/logging/LogManager",
137            "root",
138            "Ljava/util/logging/Logger;",
139            root.clone(),
140        )
141        .await?;
142
143        let global_name: ClassInstanceRef<String> = jvm
144            .get_static_field("java/util/logging/Logger", "GLOBAL_LOGGER_NAME", "Ljava/lang/String;")
145            .await?;
146        let mut global: ClassInstanceRef<Logger> = jvm
147            .get_static_field("java/util/logging/Logger", "global", "Ljava/util/logging/Logger;")
148            .await?;
149        jvm.put_field(&mut global, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", root)
150            .await?;
151        let _: ClassInstanceRef<Object> = jvm
152            .invoke_virtual(
153                &loggers,
154                "java/util/Hashtable",
155                "put",
156                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
157                (global_name, global),
158            )
159            .await?;
160        Ok(())
161    }
162
163    async fn get_log_manager(jvm: &Jvm, _: &mut RuntimeContext) -> Result<ClassInstanceRef<Self>> {
164        tracing::debug!("java.util.logging.LogManager::getLogManager()");
165        jvm.get_static_field("java/util/logging/LogManager", "manager", "Ljava/util/logging/LogManager;")
166            .await
167    }
168
169    async fn add_logger(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, logger: ClassInstanceRef<Logger>) -> Result<bool> {
170        tracing::debug!("java.util.logging.LogManager::addLogger({this:?}, {logger:?})");
171        if logger.is_null() {
172            return Err(jvm.exception("java/lang/NullPointerException", "logger").await);
173        }
174        let name: ClassInstanceRef<String> = jvm
175            .invoke_virtual(&logger, "java/util/logging/Logger", "getName", "()Ljava/lang/String;", ())
176            .await?;
177        if name.is_null() {
178            return Err(jvm.exception("java/lang/NullPointerException", "logger name").await);
179        }
180
181        jvm.invoke_special(
182            &this,
183            "java/util/logging/LogManager",
184            "registerLogger",
185            "(Ljava/lang/String;Ljava/util/logging/Logger;)Z",
186            (name, logger),
187        )
188        .await
189    }
190
191    async fn register_logger(
192        jvm: &Jvm,
193        _: &mut RuntimeContext,
194        this: ClassInstanceRef<Self>,
195        name: ClassInstanceRef<String>,
196        logger: ClassInstanceRef<Logger>,
197    ) -> Result<bool> {
198        let loggers: ClassInstanceRef<Hashtable> = jvm
199            .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
200            .await?;
201        let existing: ClassInstanceRef<Object> = jvm
202            .invoke_virtual(
203                &loggers,
204                "java/util/Hashtable",
205                "get",
206                "(Ljava/lang/Object;)Ljava/lang/Object;",
207                (name.clone(),),
208            )
209            .await?;
210        if !existing.is_null() {
211            return Ok(false);
212        }
213        let _: ClassInstanceRef<Object> = jvm
214            .invoke_virtual(
215                &loggers,
216                "java/util/Hashtable",
217                "put",
218                "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
219                (name, logger),
220            )
221            .await?;
222        Self::reconnect_parents(jvm, &this, &loggers).await?;
223        Ok(true)
224    }
225
226    async fn get_logger(
227        jvm: &Jvm,
228        _: &mut RuntimeContext,
229        this: ClassInstanceRef<Self>,
230        name: ClassInstanceRef<String>,
231    ) -> Result<ClassInstanceRef<Logger>> {
232        tracing::debug!("java.util.logging.LogManager::getLogger({this:?}, {name:?})");
233        if name.is_null() {
234            return Err(jvm.exception("java/lang/NullPointerException", "name").await);
235        }
236        let loggers: ClassInstanceRef<Hashtable> = jvm
237            .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
238            .await?;
239        jvm.invoke_virtual(&loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (name,))
240            .await
241    }
242
243    async fn get_logger_names(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
244        tracing::debug!("java.util.logging.LogManager::getLoggerNames({this:?})");
245        let loggers: ClassInstanceRef<Hashtable> = jvm
246            .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
247            .await?;
248        jvm.invoke_virtual(&loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
249            .await
250    }
251
252    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
253        tracing::debug!("java.util.logging.LogManager::reset({this:?})");
254        let loggers: ClassInstanceRef<Array<Logger>> = jvm
255            .invoke_special(
256                &this,
257                "java/util/logging/LogManager",
258                "snapshotLoggers",
259                "()[Ljava/util/logging/Logger;",
260                (),
261            )
262            .await?;
263        let root: ClassInstanceRef<Logger> = jvm
264            .get_field(&this, "java/util/logging/LogManager", "root", "Ljava/util/logging/Logger;")
265            .await?;
266        let length = jvm.array_length(&loggers).await?;
267        let loggers: Vec<ClassInstanceRef<Logger>> = jvm.load_array(&loggers, 0, length).await?;
268        for logger in loggers {
269            let handlers: ClassInstanceRef<Array<Handler>> = jvm
270                .invoke_special(
271                    &logger,
272                    "java/util/logging/Logger",
273                    "reset",
274                    "(Z)[Ljava/util/logging/Handler;",
275                    (logger.identity() == root.identity(),),
276                )
277                .await?;
278            let length = jvm.array_length(&handlers).await?;
279            let handlers: Vec<ClassInstanceRef<Handler>> = jvm.load_array(&handlers, 0, length).await?;
280            for handler in handlers {
281                let _: () = jvm.invoke_virtual(&handler, "java/util/logging/Handler", "close", "()V", ()).await?;
282            }
283        }
284        Ok(())
285    }
286
287    async fn snapshot_loggers(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Logger>>> {
288        let loggers: ClassInstanceRef<Hashtable> = jvm
289            .get_field(&this, "java/util/logging/LogManager", "loggers", "Ljava/util/Hashtable;")
290            .await?;
291        let values: ClassInstanceRef<Object> = jvm
292            .invoke_virtual(&loggers, "java/util/Hashtable", "elements", "()Ljava/util/Enumeration;", ())
293            .await?;
294        let mut snapshot: Vec<ClassInstanceRef<Logger>> = Vec::new();
295        while jvm
296            .invoke_virtual::<_, bool>(&values, &values.class_definition().name(), "hasMoreElements", "()Z", ())
297            .await?
298        {
299            snapshot.push(
300                jvm.invoke_virtual(&values, &values.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
301                    .await?,
302            );
303        }
304
305        let mut result: ClassInstanceRef<Array<Logger>> = jvm.instantiate_array("Ljava/util/logging/Logger;", snapshot.len()).await?.into();
306        for (index, logger) in snapshot.into_iter().enumerate() {
307            jvm.store_array(&mut result, index, [logger]).await?;
308        }
309        Ok(result)
310    }
311
312    async fn check_access(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
313        tracing::debug!("java.util.logging.LogManager::checkAccess({this:?})");
314        Ok(())
315    }
316
317    async fn reconnect_parents(jvm: &Jvm, manager: &ClassInstanceRef<Self>, loggers: &ClassInstanceRef<Hashtable>) -> Result<()> {
318        let names: ClassInstanceRef<Object> = jvm
319            .invoke_virtual(loggers, "java/util/Hashtable", "keys", "()Ljava/util/Enumeration;", ())
320            .await?;
321        let mut keys = Vec::new();
322        while jvm
323            .invoke_virtual::<_, bool>(&names, &names.class_definition().name(), "hasMoreElements", "()Z", ())
324            .await?
325        {
326            keys.push(
327                jvm.invoke_virtual(&names, &names.class_definition().name(), "nextElement", "()Ljava/lang/Object;", ())
328                    .await?,
329            );
330        }
331
332        let root: ClassInstanceRef<Logger> = jvm
333            .get_field(manager, "java/util/logging/LogManager", "root", "Ljava/util/logging/Logger;")
334            .await?;
335        for key in keys {
336            let name: RustString = JavaLangString::to_rust_string(jvm, &key).await?;
337            if name.is_empty() {
338                continue;
339            }
340            let mut logger: ClassInstanceRef<Logger> = jvm
341                .invoke_virtual(loggers, "java/util/Hashtable", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (key,))
342                .await?;
343            let mut parent = root.clone();
344            let mut prefix = name.as_str();
345            while let Some(index) = prefix.rfind('.') {
346                prefix = &prefix[..index];
347                let candidate_name = JavaLangString::from_rust_string(jvm, prefix).await?;
348                let candidate: ClassInstanceRef<Logger> = jvm
349                    .invoke_virtual(
350                        loggers,
351                        "java/util/Hashtable",
352                        "get",
353                        "(Ljava/lang/Object;)Ljava/lang/Object;",
354                        (candidate_name,),
355                    )
356                    .await?;
357                if !candidate.is_null() {
358                    parent = candidate;
359                    break;
360                }
361            }
362            jvm.put_field(&mut logger, "java/util/logging/Logger", "parent", "Ljava/util/logging/Logger;", parent)
363                .await?;
364        }
365        Ok(())
366    }
367}