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(&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}