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
18pub 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}