ri/java/classes/
service_mesh.rs

1//! Copyright © 2025-2026 Wenze Wei. All Rights Reserved.
2//!
3//! This file is part of Ri.
4//! The Ri project belongs to the Dunimd Team.
5//!
6//! Licensed under the Apache License, Version 2.0 (the "License");
7//! You may not use this file except in compliance with the License.
8//! You may obtain a copy of the License at
9//!
10//!     http://www.apache.org/licenses/LICENSE-2.0
11//!
12//! Unless required by applicable law or agreed to in writing, software
13//! distributed under the License is distributed on an "AS IS" BASIS,
14//! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15//! See the License for the specific language governing permissions and
16//! limitations under the License.
17
18//! # Service Mesh Module JNI Bindings
19//!
20//! JNI bindings for Ri service mesh classes.
21
22use jni::JNIEnv;
23use jni::objects::{JClass, JString, JObject, JObjectArray};
24use jni::sys::{jlong, jboolean, jint, jstring, jobjectArray, jdouble, jlongArray};
25use jni::objects::JPrimitiveArray;
26use std::collections::HashMap as FxHashMap;
27use std::time::Duration;
28
29use crate::service_mesh::{
30    RiServiceMesh, RiServiceMeshConfig, RiServiceMeshStats,
31    RiServiceEndpoint, RiServiceHealthStatus,
32    RiServiceDiscovery, RiServiceInstance, RiServiceStatus,
33    RiHealthChecker, RiHealthSummary, RiHealthStatus, RiHealthCheckType,
34    RiTrafficRoute, RiMatchCriteria, RiRouteAction, RiWeightedDestination, RiTrafficManager,
35};
36use crate::service_mesh::traffic_management::{RiRateLimitConfig, RiCircuitBreakerConfig};
37use crate::java::exception::check_not_null;
38
39// =============================================================================
40// RiServiceMeshConfig JNI Bindings
41// =============================================================================
42
43#[no_mangle]
44pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshConfig_new0(
45    _env: JNIEnv,
46    _class: JClass,
47) -> jlong {
48    let config = Box::new(RiServiceMeshConfig::default());
49    Box::into_raw(config) as jlong
50}
51
52#[no_mangle]
53pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshConfig_free0(
54    _env: JNIEnv,
55    _class: JClass,
56    ptr: jlong,
57) {
58    if ptr != 0 {
59        unsafe {
60            let _ = Box::from_raw(ptr as *mut RiServiceMeshConfig);
61        }
62    }
63}
64
65// =============================================================================
66// RiServiceMesh JNI Bindings
67// =============================================================================
68
69#[no_mangle]
70pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMesh_new0(
71    mut env: JNIEnv,
72    _class: JClass,
73    config_ptr: jlong,
74) -> jlong {
75    if !check_not_null(&mut env, config_ptr, "RiServiceMeshConfig") {
76        return 0;
77    }
78    
79    let config = unsafe { &*(config_ptr as *const RiServiceMeshConfig) };
80    match RiServiceMesh::new(config.clone()) {
81        Ok(mesh) => {
82            let boxed = Box::new(mesh);
83            Box::into_raw(boxed) as jlong
84        }
85        Err(_) => 0,
86    }
87}
88
89#[no_mangle]
90pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMesh_free0(
91    _env: JNIEnv,
92    _class: JClass,
93    ptr: jlong,
94) {
95    if ptr != 0 {
96        unsafe {
97            let _ = Box::from_raw(ptr as *mut RiServiceMesh);
98        }
99    }
100}
101
102// =============================================================================
103// RiServiceDiscovery JNI Bindings
104// =============================================================================
105
106#[no_mangle]
107pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_new0(
108    _env: JNIEnv,
109    _class: JClass,
110    enabled: jboolean,
111) -> jlong {
112    let discovery = Box::new(RiServiceDiscovery::new(enabled != 0));
113    Box::into_raw(discovery) as jlong
114}
115
116#[no_mangle]
117pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_register0(
118    mut env: JNIEnv,
119    _class: JClass,
120    ptr: jlong,
121    service_name: JString,
122    host: JString,
123    port: jint,
124    keys: JObjectArray,
125    values: JObjectArray,
126) -> jstring {
127    if !check_not_null(&mut env, ptr, "RiServiceDiscovery") {
128        return std::ptr::null_mut();
129    }
130    
131    let discovery = unsafe { &*(ptr as *const RiServiceDiscovery) };
132    let service_name_str: String = match env.get_string(&service_name) {
133        Ok(s) => s.into(),
134        Err(_) => {
135            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
136            return std::ptr::null_mut();
137        }
138    };
139    let host_str: String = match env.get_string(&host) {
140        Ok(s) => s.into(),
141        Err(_) => {
142            crate::java::exception::throw_ri_error(&mut env, "Failed to get host");
143            return std::ptr::null_mut();
144        }
145    };
146    
147    let mut metadata = FxHashMap::new();
148    let len = env.get_array_length(&keys).unwrap_or(0);
149    for i in 0..len {
150        let key: JString = match env.get_object_array_element(&keys, i) {
151            Ok(e) => e,
152            Err(_) => continue,
153        }
154        .into();
155        let value: JString = match env.get_object_array_element(&values, i) {
156            Ok(e) => e,
157            Err(_) => continue,
158        }
159        .into();
160        let key_str: String = match env.get_string(&key) {
161            Ok(s) => s.into(),
162            Err(_) => {
163                crate::java::exception::throw_ri_error(&mut env, "Failed to get key string");
164                return std::ptr::null_mut();
165            }
166        };
167        let value_str: String = match env.get_string(&value) {
168            Ok(s) => s.into(),
169            Err(_) => {
170                crate::java::exception::throw_ri_error(&mut env, "Failed to get value string");
171                return std::ptr::null_mut();
172            }
173        };
174        metadata.insert(key_str, value_str);
175    }
176    
177    let result = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
178        discovery.register_service(&service_name_str, &host_str, port as u16, metadata).await
179    });
180    
181    match result {
182        Some(Ok(instance_id)) => match env.new_string(&instance_id) {
183        Ok(s) => s.into_raw(),
184        Err(_) => std::ptr::null_mut(),
185    },
186        _ => std::ptr::null_mut(),
187    }
188}
189
190#[no_mangle]
191pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_deregister0(
192    mut env: JNIEnv,
193    _class: JClass,
194    ptr: jlong,
195    instance_id: JString,
196) {
197    if !check_not_null(&mut env, ptr, "RiServiceDiscovery") {
198        return;
199    }
200    
201    let discovery = unsafe { &*(ptr as *const RiServiceDiscovery) };
202    let instance_id_str: String = match env.get_string(&instance_id) {
203        Ok(s) => s.into(),
204        Err(_) => {
205            crate::java::exception::throw_ri_error(&mut env, "Failed to get instance id");
206            return;
207        }
208    };
209    
210    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
211        discovery.deregister_service(&instance_id_str).await
212    });
213}
214
215#[no_mangle]
216pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_discover0(
217    mut env: JNIEnv,
218    _class: JClass,
219    ptr: jlong,
220    service_name: JString,
221) -> jlongArray {
222    if !check_not_null(&mut env, ptr, "RiServiceDiscovery") {
223        return std::ptr::null_mut();
224    }
225    
226    let discovery = unsafe { &*(ptr as *const RiServiceDiscovery) };
227    let service_name_str: String = match env.get_string(&service_name) {
228        Ok(s) => s.into(),
229        Err(_) => {
230            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
231            return std::ptr::null_mut();
232        }
233    };
234    
235    let result = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
236        discovery.discover_service(&service_name_str).await
237    });
238    
239    match result {
240        Some(Ok(instances)) => {
241            let ptrs: Vec<jlong> = instances.iter().map(|i| {
242                let boxed = Box::new(i.clone());
243                Box::into_raw(boxed) as jlong
244            }).collect();
245            
246            let array = match env.new_long_array(ptrs.len() as i32) {
247                Ok(a) => a,
248                Err(_) => { return std::ptr::null_mut(); }
249            };
250            let _ = env.set_long_array_region(&array, 0, &ptrs);
251            array.into_raw()
252        }
253        _ => std::ptr::null_mut(),
254    }
255}
256
257#[no_mangle]
258pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_updateHeartbeat0(
259    mut env: JNIEnv,
260    _class: JClass,
261    ptr: jlong,
262    instance_id: JString,
263) {
264    if !check_not_null(&mut env, ptr, "RiServiceDiscovery") {
265        return;
266    }
267    
268    let discovery = unsafe { &*(ptr as *const RiServiceDiscovery) };
269    let instance_id_str: String = match env.get_string(&instance_id) {
270        Ok(s) => s.into(),
271        Err(_) => {
272            crate::java::exception::throw_ri_error(&mut env, "Failed to get instance id");
273            return;
274        }
275    };
276    
277    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
278        discovery.update_heartbeat(&instance_id_str).await
279    });
280}
281
282#[no_mangle]
283pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_setServiceStatus0(
284    mut env: JNIEnv,
285    _class: JClass,
286    ptr: jlong,
287    instance_id: JString,
288    status_ordinal: jint,
289) {
290    if !check_not_null(&mut env, ptr, "RiServiceDiscovery") {
291        return;
292    }
293    
294    let discovery = unsafe { &*(ptr as *const RiServiceDiscovery) };
295    let instance_id_str: String = match env.get_string(&instance_id) {
296        Ok(s) => s.into(),
297        Err(_) => {
298            crate::java::exception::throw_ri_error(&mut env, "Failed to get instance id");
299            return;
300        }
301    };
302    
303    let status = match status_ordinal {
304        0 => RiServiceStatus::Starting,
305        1 => RiServiceStatus::Running,
306        2 => RiServiceStatus::Stopping,
307        3 => RiServiceStatus::Stopped,
308        4 => RiServiceStatus::Unhealthy,
309        _ => RiServiceStatus::Starting,
310    };
311    
312    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
313        discovery.set_service_status(&instance_id_str, status).await
314    });
315}
316
317#[no_mangle]
318pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_getAllServices0(
319    mut env: JNIEnv,
320    _class: JClass,
321    ptr: jlong,
322) -> jobjectArray {
323    if !check_not_null(&mut env, ptr, "RiServiceDiscovery") {
324        return std::ptr::null_mut();
325    }
326    
327    let discovery = unsafe { &*(ptr as *const RiServiceDiscovery) };
328    
329    let result = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
330        discovery.get_all_services().await
331    });
332    
333    match result {
334        Some(Ok(services)) => {
335            let string_class = match env.find_class("java/lang/String") {
336                Ok(c) => c,
337                Err(_) => { return std::ptr::null_mut(); }
338            };
339            let array = match env.new_object_array(services.len() as i32, &string_class, JObject::null()) {
340                Ok(a) => a,
341                Err(_) => { return std::ptr::null_mut(); }
342            };
343            
344            for (i, service) in services.iter().enumerate() {
345                let jstr = match env.new_string(service) {
346                    Ok(s) => s,
347                    Err(_) => continue,
348                };
349                let _ = env.set_object_array_element(&array, i as i32, &jstr);
350            }
351            
352            array.into_raw()
353        }
354        _ => std::ptr::null_mut(),
355    }
356}
357
358#[no_mangle]
359pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceDiscovery_free0(
360    _env: JNIEnv,
361    _class: JClass,
362    ptr: jlong,
363) {
364    if ptr != 0 {
365        unsafe {
366            let _ = Box::from_raw(ptr as *mut RiServiceDiscovery);
367        }
368    }
369}
370
371// =============================================================================
372// RiServiceInstance JNI Bindings
373// =============================================================================
374
375#[no_mangle]
376pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_new0(
377    mut env: JNIEnv,
378    _class: JClass,
379    id: JString,
380    service_name: JString,
381    host: JString,
382    port: jint,
383) -> jlong {
384    let id_str: String = match env.get_string(&id) {
385        Ok(s) => s.into(),
386        Err(_) => {
387            crate::java::exception::throw_ri_error(&mut env, "Failed to get id");
388            return 0;
389        }
390    };
391    let service_name_str: String = match env.get_string(&service_name) {
392        Ok(s) => s.into(),
393        Err(_) => {
394            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
395            return 0;
396        }
397    };
398    let host_str: String = match env.get_string(&host) {
399        Ok(s) => s.into(),
400        Err(_) => {
401            crate::java::exception::throw_ri_error(&mut env, "Failed to get host");
402            return 0;
403        }
404    };
405    
406    let instance = Box::new(RiServiceInstance {
407        id: id_str,
408        service_name: service_name_str,
409        host: host_str,
410        port: port as u16,
411        metadata: FxHashMap::default(),
412        registered_at: std::time::SystemTime::now(),
413        last_heartbeat: std::time::SystemTime::now(),
414        status: RiServiceStatus::Starting,
415    });
416    Box::into_raw(instance) as jlong
417}
418
419#[no_mangle]
420pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getId0(
421    mut env: JNIEnv,
422    _class: JClass,
423    ptr: jlong,
424) -> jstring {
425    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
426        return std::ptr::null_mut();
427    }
428    
429    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
430    match env.new_string(&instance.id) {
431        Ok(s) => s.into_raw(),
432        Err(_) => std::ptr::null_mut(),
433    }
434}
435
436#[no_mangle]
437pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getServiceName0(
438    mut env: JNIEnv,
439    _class: JClass,
440    ptr: jlong,
441) -> jstring {
442    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
443        return std::ptr::null_mut();
444    }
445    
446    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
447    match env.new_string(&instance.service_name) {
448        Ok(s) => s.into_raw(),
449        Err(_) => std::ptr::null_mut(),
450    }
451}
452
453#[no_mangle]
454pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getHost0(
455    mut env: JNIEnv,
456    _class: JClass,
457    ptr: jlong,
458) -> jstring {
459    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
460        return std::ptr::null_mut();
461    }
462    
463    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
464    match env.new_string(&instance.host) {
465        Ok(s) => s.into_raw(),
466        Err(_) => std::ptr::null_mut(),
467    }
468}
469
470#[no_mangle]
471pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getPort0(
472    mut env: JNIEnv,
473    _class: JClass,
474    ptr: jlong,
475) -> jint {
476    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
477        return 0;
478    }
479    
480    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
481    instance.port as jint
482}
483
484#[no_mangle]
485pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getStatus0(
486    mut env: JNIEnv,
487    _class: JClass,
488    ptr: jlong,
489) -> jint {
490    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
491        return 0;
492    }
493    
494    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
495    match instance.status {
496        RiServiceStatus::Starting => 0,
497        RiServiceStatus::Running => 1,
498        RiServiceStatus::Stopping => 2,
499        RiServiceStatus::Stopped => 3,
500        RiServiceStatus::Unhealthy => 4,
501    }
502}
503
504#[no_mangle]
505pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getMetadataKeys0(
506    mut env: JNIEnv,
507    _class: JClass,
508    ptr: jlong,
509) -> jobjectArray {
510    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
511        return std::ptr::null_mut();
512    }
513    
514    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
515    let keys: Vec<&String> = instance.metadata.keys().collect();
516    
517    let string_class = match env.find_class("java/lang/String") {
518        Ok(c) => c,
519        Err(_) => { return std::ptr::null_mut(); }
520    };
521    let array = match env.new_object_array(keys.len() as i32, &string_class, JObject::null()) {
522        Ok(a) => a,
523        Err(_) => { return std::ptr::null_mut(); }
524    };
525    
526    for (i, key) in keys.iter().enumerate() {
527        let jstr = match env.new_string(key) {
528            Ok(s) => s,
529            Err(_) => continue,
530        };
531                let _ = env.set_object_array_element(&array, i as i32, &jstr);
532    }
533    
534    array.into_raw()
535}
536
537#[no_mangle]
538pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_getMetadataValue0(
539    mut env: JNIEnv,
540    _class: JClass,
541    ptr: jlong,
542    key: JString,
543) -> jstring {
544    if !check_not_null(&mut env, ptr, "RiServiceInstance") {
545        return std::ptr::null_mut();
546    }
547    
548    let instance = unsafe { &*(ptr as *const RiServiceInstance) };
549    let key_str: String = match env.get_string(&key) {
550        Ok(s) => s.into(),
551        Err(_) => {
552            crate::java::exception::throw_ri_error(&mut env, "Failed to get key");
553            return std::ptr::null_mut();
554        }
555    };
556    
557    match instance.metadata.get(&key_str) {
558        Some(value) => match env.new_string(value) {
559            Ok(s) => s.into_raw(),
560            Err(_) => std::ptr::null_mut(),
561        },
562        None => std::ptr::null_mut(),
563    }
564}
565
566#[no_mangle]
567pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceInstance_free0(
568    _env: JNIEnv,
569    _class: JClass,
570    ptr: jlong,
571) {
572    if ptr != 0 {
573        unsafe {
574            let _ = Box::from_raw(ptr as *mut RiServiceInstance);
575        }
576    }
577}
578
579// =============================================================================
580// RiServiceMeshStats JNI Bindings
581// =============================================================================
582
583#[no_mangle]
584pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshStats_new0(
585    _env: JNIEnv,
586    _class: JClass,
587) -> jlong {
588    let stats = Box::new(RiServiceMeshStats {
589        total_services: 0,
590        total_endpoints: 0,
591        healthy_endpoints: 0,
592        unhealthy_endpoints: 0,
593    });
594    Box::into_raw(stats) as jlong
595}
596
597#[no_mangle]
598pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshStats_getTotalServices0(
599    mut env: JNIEnv,
600    _class: JClass,
601    ptr: jlong,
602) -> jlong {
603    if !check_not_null(&mut env, ptr, "RiServiceMeshStats") {
604        return 0;
605    }
606    
607    let stats = unsafe { &*(ptr as *const RiServiceMeshStats) };
608    stats.total_services as jlong
609}
610
611#[no_mangle]
612pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshStats_getTotalEndpoints0(
613    mut env: JNIEnv,
614    _class: JClass,
615    ptr: jlong,
616) -> jlong {
617    if !check_not_null(&mut env, ptr, "RiServiceMeshStats") {
618        return 0;
619    }
620    
621    let stats = unsafe { &*(ptr as *const RiServiceMeshStats) };
622    stats.total_endpoints as jlong
623}
624
625#[no_mangle]
626pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshStats_getHealthyEndpoints0(
627    mut env: JNIEnv,
628    _class: JClass,
629    ptr: jlong,
630) -> jlong {
631    if !check_not_null(&mut env, ptr, "RiServiceMeshStats") {
632        return 0;
633    }
634    
635    let stats = unsafe { &*(ptr as *const RiServiceMeshStats) };
636    stats.healthy_endpoints as jlong
637}
638
639#[no_mangle]
640pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshStats_getUnhealthyEndpoints0(
641    mut env: JNIEnv,
642    _class: JClass,
643    ptr: jlong,
644) -> jlong {
645    if !check_not_null(&mut env, ptr, "RiServiceMeshStats") {
646        return 0;
647    }
648    
649    let stats = unsafe { &*(ptr as *const RiServiceMeshStats) };
650    stats.unhealthy_endpoints as jlong
651}
652
653#[no_mangle]
654pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceMeshStats_free0(
655    _env: JNIEnv,
656    _class: JClass,
657    ptr: jlong,
658) {
659    if ptr != 0 {
660        unsafe {
661            let _ = Box::from_raw(ptr as *mut RiServiceMeshStats);
662        }
663    }
664}
665
666// =============================================================================
667// RiServiceEndpoint JNI Bindings
668// =============================================================================
669
670#[no_mangle]
671pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_new0(
672    mut env: JNIEnv,
673    _class: JClass,
674    service_name: JString,
675    endpoint: JString,
676    weight: jint,
677) -> jlong {
678    let service_name_str: String = match env.get_string(&service_name) {
679        Ok(s) => s.into(),
680        Err(_) => {
681            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
682            return 0;
683        }
684    };
685    let endpoint_str: String = match env.get_string(&endpoint) {
686        Ok(s) => s.into(),
687        Err(_) => {
688            crate::java::exception::throw_ri_error(&mut env, "Failed to get endpoint");
689            return 0;
690        }
691    };
692    
693    let endpoint = Box::new(RiServiceEndpoint {
694        service_name: service_name_str,
695        endpoint: endpoint_str,
696        weight: weight as u32,
697        metadata: FxHashMap::default(),
698        health_status: RiServiceHealthStatus::Unknown,
699        last_health_check: std::time::SystemTime::now(),
700    });
701    Box::into_raw(endpoint) as jlong
702}
703
704#[no_mangle]
705pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_getServiceName0(
706    mut env: JNIEnv,
707    _class: JClass,
708    ptr: jlong,
709) -> jstring {
710    if !check_not_null(&mut env, ptr, "RiServiceEndpoint") {
711        return std::ptr::null_mut();
712    }
713    
714    let endpoint = unsafe { &*(ptr as *const RiServiceEndpoint) };
715    match env.new_string(&endpoint.service_name) {
716        Ok(s) => s.into_raw(),
717        Err(_) => std::ptr::null_mut(),
718    }
719}
720
721#[no_mangle]
722pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_getEndpoint0(
723    mut env: JNIEnv,
724    _class: JClass,
725    ptr: jlong,
726) -> jstring {
727    if !check_not_null(&mut env, ptr, "RiServiceEndpoint") {
728        return std::ptr::null_mut();
729    }
730    
731    let endpoint = unsafe { &*(ptr as *const RiServiceEndpoint) };
732    match env.new_string(&endpoint.endpoint) {
733        Ok(s) => s.into_raw(),
734        Err(_) => std::ptr::null_mut(),
735    }
736}
737
738#[no_mangle]
739pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_getWeight0(
740    mut env: JNIEnv,
741    _class: JClass,
742    ptr: jlong,
743) -> jint {
744    if !check_not_null(&mut env, ptr, "RiServiceEndpoint") {
745        return 0;
746    }
747    
748    let endpoint = unsafe { &*(ptr as *const RiServiceEndpoint) };
749    endpoint.weight as jint
750}
751
752#[no_mangle]
753pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_getHealthStatus0(
754    mut env: JNIEnv,
755    _class: JClass,
756    ptr: jlong,
757) -> jint {
758    if !check_not_null(&mut env, ptr, "RiServiceEndpoint") {
759        return 0;
760    }
761    
762    let endpoint = unsafe { &*(ptr as *const RiServiceEndpoint) };
763    match endpoint.health_status {
764        RiServiceHealthStatus::Healthy => 0,
765        RiServiceHealthStatus::Unhealthy => 1,
766        RiServiceHealthStatus::Unknown => 2,
767    }
768}
769
770#[no_mangle]
771pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_getMetadataKeys0(
772    mut env: JNIEnv,
773    _class: JClass,
774    ptr: jlong,
775) -> jobjectArray {
776    if !check_not_null(&mut env, ptr, "RiServiceEndpoint") {
777        return std::ptr::null_mut();
778    }
779    
780    let endpoint = unsafe { &*(ptr as *const RiServiceEndpoint) };
781    let keys: Vec<&String> = endpoint.metadata.keys().collect();
782    
783    let string_class = match env.find_class("java/lang/String") {
784        Ok(c) => c,
785        Err(_) => { return std::ptr::null_mut(); }
786    };
787    let array = match env.new_object_array(keys.len() as i32, &string_class, JObject::null()) {
788        Ok(a) => a,
789        Err(_) => { return std::ptr::null_mut(); }
790    };
791    
792    for (i, key) in keys.iter().enumerate() {
793        let jstr = match env.new_string(key) {
794            Ok(s) => s,
795            Err(_) => continue,
796        };
797                let _ = env.set_object_array_element(&array, i as i32, &jstr);
798    }
799    
800    array.into_raw()
801}
802
803#[no_mangle]
804pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_getMetadataValue0(
805    mut env: JNIEnv,
806    _class: JClass,
807    ptr: jlong,
808    key: JString,
809) -> jstring {
810    if !check_not_null(&mut env, ptr, "RiServiceEndpoint") {
811        return std::ptr::null_mut();
812    }
813    
814    let endpoint = unsafe { &*(ptr as *const RiServiceEndpoint) };
815    let key_str: String = match env.get_string(&key) {
816        Ok(s) => s.into(),
817        Err(_) => {
818            crate::java::exception::throw_ri_error(&mut env, "Failed to get key");
819            return std::ptr::null_mut();
820        }
821    };
822    
823    match endpoint.metadata.get(&key_str) {
824        Some(value) => match env.new_string(value) {
825            Ok(s) => s.into_raw(),
826            Err(_) => std::ptr::null_mut(),
827        },
828        None => std::ptr::null_mut(),
829    }
830}
831
832#[no_mangle]
833pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiServiceEndpoint_free0(
834    _env: JNIEnv,
835    _class: JClass,
836    ptr: jlong,
837) {
838    if ptr != 0 {
839        unsafe {
840            let _ = Box::from_raw(ptr as *mut RiServiceEndpoint);
841        }
842    }
843}
844
845// =============================================================================
846// RiHealthChecker JNI Bindings
847// =============================================================================
848
849#[no_mangle]
850pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthChecker_new0(
851    _env: JNIEnv,
852    _class: JClass,
853    check_interval_seconds: jlong,
854) -> jlong {
855    let checker = Box::new(RiHealthChecker::new(Duration::from_secs(check_interval_seconds as u64)));
856    Box::into_raw(checker) as jlong
857}
858
859#[no_mangle]
860pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthChecker_startHealthCheck0(
861    mut env: JNIEnv,
862    _class: JClass,
863    ptr: jlong,
864    service_name: JString,
865    endpoint: JString,
866) {
867    if !check_not_null(&mut env, ptr, "RiHealthChecker") {
868        return;
869    }
870    
871    let checker = unsafe { &*(ptr as *const RiHealthChecker) };
872    let service_name_str: String = match env.get_string(&service_name) {
873        Ok(s) => s.into(),
874        Err(_) => {
875            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
876            return;
877        }
878    };
879    let endpoint_str: String = match env.get_string(&endpoint) {
880        Ok(s) => s.into(),
881        Err(_) => {
882            crate::java::exception::throw_ri_error(&mut env, "Failed to get endpoint");
883            return;
884        }
885    };
886    
887    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
888        checker.start_health_check(&service_name_str, &endpoint_str).await
889    });
890}
891
892#[no_mangle]
893pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthChecker_startHealthCheckWithType0(
894    mut env: JNIEnv,
895    _class: JClass,
896    ptr: jlong,
897    service_name: JString,
898    endpoint: JString,
899    check_type_ordinal: jint,
900) {
901    if !check_not_null(&mut env, ptr, "RiHealthChecker") {
902        return;
903    }
904    
905    let checker = unsafe { &*(ptr as *const RiHealthChecker) };
906    let service_name_str: String = match env.get_string(&service_name) {
907        Ok(s) => s.into(),
908        Err(_) => {
909            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
910            return;
911        }
912    };
913    let endpoint_str: String = match env.get_string(&endpoint) {
914        Ok(s) => s.into(),
915        Err(_) => {
916            crate::java::exception::throw_ri_error(&mut env, "Failed to get endpoint");
917            return;
918        }
919    };
920    
921    let check_type = match check_type_ordinal {
922        0 => RiHealthCheckType::Http,
923        1 => RiHealthCheckType::Tcp,
924        2 => RiHealthCheckType::Grpc,
925        3 => RiHealthCheckType::Custom,
926        _ => RiHealthCheckType::Http,
927    };
928    
929    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
930        checker.start_health_check_with_type(&service_name_str, &endpoint_str, check_type).await
931    });
932}
933
934#[no_mangle]
935pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthChecker_stopHealthCheck0(
936    mut env: JNIEnv,
937    _class: JClass,
938    ptr: jlong,
939    service_name: JString,
940    endpoint: JString,
941) {
942    if !check_not_null(&mut env, ptr, "RiHealthChecker") {
943        return;
944    }
945    
946    let checker = unsafe { &*(ptr as *const RiHealthChecker) };
947    let service_name_str: String = match env.get_string(&service_name) {
948        Ok(s) => s.into(),
949        Err(_) => {
950            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
951            return;
952        }
953    };
954    let endpoint_str: String = match env.get_string(&endpoint) {
955        Ok(s) => s.into(),
956        Err(_) => {
957            crate::java::exception::throw_ri_error(&mut env, "Failed to get endpoint");
958            return;
959        }
960    };
961    
962    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
963        checker.stop_health_check(&service_name_str, &endpoint_str).await
964    });
965}
966
967#[no_mangle]
968pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthChecker_getServiceHealthSummary0(
969    mut env: JNIEnv,
970    _class: JClass,
971    ptr: jlong,
972    service_name: JString,
973) -> jlong {
974    if !check_not_null(&mut env, ptr, "RiHealthChecker") {
975        return 0;
976    }
977    
978    let checker = unsafe { &*(ptr as *const RiHealthChecker) };
979    let service_name_str: String = match env.get_string(&service_name) {
980        Ok(s) => s.into(),
981        Err(_) => {
982            crate::java::exception::throw_ri_error(&mut env, "Failed to get service name");
983            return 0;
984        }
985    };
986    
987    let result = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
988        checker.get_service_health_summary(&service_name_str).await
989    });
990    
991    match result {
992        Some(Ok(summary)) => {
993            let boxed = Box::new(summary);
994            Box::into_raw(boxed) as jlong
995        }
996        _ => 0,
997    }
998}
999
1000#[no_mangle]
1001pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthChecker_free0(
1002    _env: JNIEnv,
1003    _class: JClass,
1004    ptr: jlong,
1005) {
1006    if ptr != 0 {
1007        unsafe {
1008            let _ = Box::from_raw(ptr as *mut RiHealthChecker);
1009        }
1010    }
1011}
1012
1013// =============================================================================
1014// RiHealthSummary JNI Bindings
1015// =============================================================================
1016
1017#[no_mangle]
1018pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getServiceName0(
1019    mut env: JNIEnv,
1020    _class: JClass,
1021    ptr: jlong,
1022) -> jstring {
1023    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1024        return std::ptr::null_mut();
1025    }
1026    
1027    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1028    match env.new_string(&summary.service_name) {
1029        Ok(s) => s.into_raw(),
1030        Err(_) => std::ptr::null_mut(),
1031    }
1032}
1033
1034#[no_mangle]
1035pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getTotalChecks0(
1036    mut env: JNIEnv,
1037    _class: JClass,
1038    ptr: jlong,
1039) -> jlong {
1040    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1041        return 0;
1042    }
1043    
1044    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1045    summary.total_checks as jlong
1046}
1047
1048#[no_mangle]
1049pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getHealthyChecks0(
1050    mut env: JNIEnv,
1051    _class: JClass,
1052    ptr: jlong,
1053) -> jlong {
1054    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1055        return 0;
1056    }
1057    
1058    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1059    summary.healthy_checks as jlong
1060}
1061
1062#[no_mangle]
1063pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getUnhealthyChecks0(
1064    mut env: JNIEnv,
1065    _class: JClass,
1066    ptr: jlong,
1067) -> jlong {
1068    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1069        return 0;
1070    }
1071    
1072    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1073    summary.unhealthy_checks as jlong
1074}
1075
1076#[no_mangle]
1077pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getSuccessRate0(
1078    mut env: JNIEnv,
1079    _class: JClass,
1080    ptr: jlong,
1081) -> jdouble {
1082    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1083        return 0.0;
1084    }
1085    
1086    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1087    summary.success_rate
1088}
1089
1090#[no_mangle]
1091pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getAverageResponseTimeMs0(
1092    mut env: JNIEnv,
1093    _class: JClass,
1094    ptr: jlong,
1095) -> jlong {
1096    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1097        return 0;
1098    }
1099    
1100    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1101    summary.average_response_time.as_millis() as jlong
1102}
1103
1104#[no_mangle]
1105pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_getOverallStatus0(
1106    mut env: JNIEnv,
1107    _class: JClass,
1108    ptr: jlong,
1109) -> jint {
1110    if !check_not_null(&mut env, ptr, "RiHealthSummary") {
1111        return 0;
1112    }
1113    
1114    let summary = unsafe { &*(ptr as *const RiHealthSummary) };
1115    match summary.overall_status {
1116        RiHealthStatus::Healthy => 0,
1117        RiHealthStatus::Degraded => 1,
1118        RiHealthStatus::Unhealthy => 2,
1119        RiHealthStatus::Unknown => 3,
1120    }
1121}
1122
1123#[no_mangle]
1124pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiHealthSummary_free0(
1125    _env: JNIEnv,
1126    _class: JClass,
1127    ptr: jlong,
1128) {
1129    if ptr != 0 {
1130        unsafe {
1131            let _ = Box::from_raw(ptr as *mut RiHealthSummary);
1132        }
1133    }
1134}
1135
1136// =============================================================================
1137// RiTrafficRoute JNI Bindings
1138// =============================================================================
1139
1140#[no_mangle]
1141pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_new0(
1142    mut env: JNIEnv,
1143    _class: JClass,
1144    name: JString,
1145    source_service: JString,
1146    destination_service: JString,
1147) -> jlong {
1148    let name_str: String = match env.get_string(&name) {
1149        Ok(s) => s.into(),
1150        Err(_) => {
1151            crate::java::exception::throw_ri_error(&mut env, "Failed to get name");
1152            return 0;
1153        }
1154    };
1155    let source_service_str: String = match env.get_string(&source_service) {
1156        Ok(s) => s.into(),
1157        Err(_) => {
1158            crate::java::exception::throw_ri_error(&mut env, "Failed to get source service");
1159            return 0;
1160        }
1161    };
1162    let destination_service_str: String = match env.get_string(&destination_service) {
1163        Ok(s) => s.into(),
1164        Err(_) => {
1165            crate::java::exception::throw_ri_error(&mut env, "Failed to get destination service");
1166            return 0;
1167        }
1168    };
1169    
1170    let route = Box::new(RiTrafficRoute {
1171        name: name_str,
1172        source_service: source_service_str,
1173        destination_service: destination_service_str,
1174        match_criteria: RiMatchCriteria {
1175            path_prefix: None,
1176            headers: FxHashMap::default(),
1177            method: None,
1178            query_parameters: FxHashMap::default(),
1179        },
1180        route_action: RiRouteAction::Route(vec![]),
1181        retry_policy: None,
1182        timeout: None,
1183        fault_injection: None,
1184    });
1185    Box::into_raw(route) as jlong
1186}
1187
1188#[no_mangle]
1189pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getName0(
1190    mut env: JNIEnv,
1191    _class: JClass,
1192    ptr: jlong,
1193) -> jstring {
1194    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1195        return std::ptr::null_mut();
1196    }
1197    
1198    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1199    match env.new_string(&route.name) {
1200        Ok(s) => s.into_raw(),
1201        Err(_) => std::ptr::null_mut(),
1202    }
1203}
1204
1205#[no_mangle]
1206pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getSourceService0(
1207    mut env: JNIEnv,
1208    _class: JClass,
1209    ptr: jlong,
1210) -> jstring {
1211    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1212        return std::ptr::null_mut();
1213    }
1214    
1215    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1216    match env.new_string(&route.source_service) {
1217        Ok(s) => s.into_raw(),
1218        Err(_) => std::ptr::null_mut(),
1219    }
1220}
1221
1222#[no_mangle]
1223pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getDestinationService0(
1224    mut env: JNIEnv,
1225    _class: JClass,
1226    ptr: jlong,
1227) -> jstring {
1228    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1229        return std::ptr::null_mut();
1230    }
1231    
1232    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1233    match env.new_string(&route.destination_service) {
1234        Ok(s) => s.into_raw(),
1235        Err(_) => std::ptr::null_mut(),
1236    }
1237}
1238
1239#[no_mangle]
1240pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getMatchCriteria0(
1241    mut env: JNIEnv,
1242    _class: JClass,
1243    ptr: jlong,
1244) -> jlong {
1245    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1246        return 0;
1247    }
1248    
1249    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1250    let criteria = Box::new(route.match_criteria.clone());
1251    Box::into_raw(criteria) as jlong
1252}
1253
1254#[no_mangle]
1255pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_setMatchCriteria0(
1256    mut env: JNIEnv,
1257    _class: JClass,
1258    ptr: jlong,
1259    criteria_ptr: jlong,
1260) {
1261    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1262        return;
1263    }
1264    if !check_not_null(&mut env, criteria_ptr, "RiMatchCriteria") {
1265        return;
1266    }
1267    
1268    let route = unsafe { &mut *(ptr as *mut RiTrafficRoute) };
1269    let criteria = unsafe { &*(criteria_ptr as *const RiMatchCriteria) };
1270    route.match_criteria = criteria.clone();
1271}
1272
1273#[no_mangle]
1274pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getRouteAction0(
1275    mut env: JNIEnv,
1276    _class: JClass,
1277    ptr: jlong,
1278) -> jlong {
1279    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1280        return 0;
1281    }
1282    
1283    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1284    let action = Box::new(route.route_action.clone());
1285    Box::into_raw(action) as jlong
1286}
1287
1288#[no_mangle]
1289pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_setRouteAction0(
1290    mut env: JNIEnv,
1291    _class: JClass,
1292    ptr: jlong,
1293    action_ptr: jlong,
1294) {
1295    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1296        return;
1297    }
1298    if !check_not_null(&mut env, action_ptr, "RiRouteAction") {
1299        return;
1300    }
1301    
1302    let route = unsafe { &mut *(ptr as *mut RiTrafficRoute) };
1303    let action = unsafe { &*(action_ptr as *const RiRouteAction) };
1304    route.route_action = action.clone();
1305}
1306
1307#[no_mangle]
1308pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getTimeoutMs0(
1309    mut env: JNIEnv,
1310    _class: JClass,
1311    ptr: jlong,
1312) -> jlong {
1313    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1314        return 0;
1315    }
1316    
1317    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1318    route.timeout.map(|t| t.as_millis() as jlong).unwrap_or(0)
1319}
1320
1321#[no_mangle]
1322pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_setTimeoutMs0(
1323    mut env: JNIEnv,
1324    _class: JClass,
1325    ptr: jlong,
1326    timeout_ms: jlong,
1327) {
1328    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1329        return;
1330    }
1331    
1332    let route = unsafe { &mut *(ptr as *mut RiTrafficRoute) };
1333    route.timeout = Some(Duration::from_millis(timeout_ms as u64));
1334}
1335
1336#[no_mangle]
1337pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_getRetryAttempts0(
1338    mut env: JNIEnv,
1339    _class: JClass,
1340    ptr: jlong,
1341) -> jint {
1342    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1343        return 0;
1344    }
1345    
1346    let route = unsafe { &*(ptr as *const RiTrafficRoute) };
1347    route.retry_policy.as_ref().map(|p| p.attempts as jint).unwrap_or(0)
1348}
1349
1350#[no_mangle]
1351pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_setRetryAttempts0(
1352    mut env: JNIEnv,
1353    _class: JClass,
1354    ptr: jlong,
1355    attempts: jint,
1356) {
1357    if !check_not_null(&mut env, ptr, "RiTrafficRoute") {
1358        return;
1359    }
1360    
1361    let route = unsafe { &mut *(ptr as *mut RiTrafficRoute) };
1362    if let Some(ref mut policy) = route.retry_policy {
1363        policy.attempts = attempts as u32;
1364    } else {
1365        use crate::service_mesh::traffic_management::RiRetryPolicy;
1366        route.retry_policy = Some(RiRetryPolicy {
1367            attempts: attempts as u32,
1368            per_try_timeout: Duration::from_secs(1),
1369            retry_on: vec!["5xx".to_string()],
1370        });
1371    }
1372}
1373
1374#[no_mangle]
1375pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficRoute_free0(
1376    _env: JNIEnv,
1377    _class: JClass,
1378    ptr: jlong,
1379) {
1380    if ptr != 0 {
1381        unsafe {
1382            let _ = Box::from_raw(ptr as *mut RiTrafficRoute);
1383        }
1384    }
1385}
1386
1387// =============================================================================
1388// RiMatchCriteria JNI Bindings
1389// =============================================================================
1390
1391#[no_mangle]
1392pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_new0(
1393    _env: JNIEnv,
1394    _class: JClass,
1395) -> jlong {
1396    let criteria = Box::new(RiMatchCriteria {
1397        path_prefix: None,
1398        headers: FxHashMap::default(),
1399        method: None,
1400        query_parameters: FxHashMap::default(),
1401    });
1402    Box::into_raw(criteria) as jlong
1403}
1404
1405#[no_mangle]
1406pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_getPathPrefix0(
1407    mut env: JNIEnv,
1408    _class: JClass,
1409    ptr: jlong,
1410) -> jstring {
1411    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1412        return std::ptr::null_mut();
1413    }
1414    
1415    let criteria = unsafe { &*(ptr as *const RiMatchCriteria) };
1416    match &criteria.path_prefix {
1417        Some(prefix) => match env.new_string(prefix) {
1418            Ok(s) => s.into_raw(),
1419            Err(_) => std::ptr::null_mut(),
1420        },
1421        None => std::ptr::null_mut(),
1422    }
1423}
1424
1425#[no_mangle]
1426pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_setPathPrefix0(
1427    mut env: JNIEnv,
1428    _class: JClass,
1429    ptr: jlong,
1430    path_prefix: JString,
1431) {
1432    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1433        return;
1434    }
1435    
1436    let criteria = unsafe { &mut *(ptr as *mut RiMatchCriteria) };
1437    let prefix_str: String = match env.get_string(&path_prefix) {
1438        Ok(s) => s.into(),
1439        Err(_) => {
1440            crate::java::exception::throw_ri_error(&mut env, "Failed to get path prefix");
1441            return;
1442        }
1443    };
1444    criteria.path_prefix = Some(prefix_str);
1445}
1446
1447#[no_mangle]
1448pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_getMethod0(
1449    mut env: JNIEnv,
1450    _class: JClass,
1451    ptr: jlong,
1452) -> jstring {
1453    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1454        return std::ptr::null_mut();
1455    }
1456    
1457    let criteria = unsafe { &*(ptr as *const RiMatchCriteria) };
1458    match &criteria.method {
1459        Some(method) => match env.new_string(method) {
1460            Ok(s) => s.into_raw(),
1461            Err(_) => std::ptr::null_mut(),
1462        },
1463        None => std::ptr::null_mut(),
1464    }
1465}
1466
1467#[no_mangle]
1468pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_setMethod0(
1469    mut env: JNIEnv,
1470    _class: JClass,
1471    ptr: jlong,
1472    method: JString,
1473) {
1474    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1475        return;
1476    }
1477    
1478    let criteria = unsafe { &mut *(ptr as *mut RiMatchCriteria) };
1479    let method_str: String = match env.get_string(&method) {
1480        Ok(s) => s.into(),
1481        Err(_) => {
1482            crate::java::exception::throw_ri_error(&mut env, "Failed to get method");
1483            return;
1484        }
1485    };
1486    criteria.method = Some(method_str);
1487}
1488
1489#[no_mangle]
1490pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_getHeaderKeys0(
1491    mut env: JNIEnv,
1492    _class: JClass,
1493    ptr: jlong,
1494) -> jobjectArray {
1495    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1496        return std::ptr::null_mut();
1497    }
1498    
1499    let criteria = unsafe { &*(ptr as *const RiMatchCriteria) };
1500    let keys: Vec<&String> = criteria.headers.keys().collect();
1501    
1502    let string_class = match env.find_class("java/lang/String") {
1503        Ok(c) => c,
1504        Err(_) => { return std::ptr::null_mut(); }
1505    };
1506    let array = match env.new_object_array(keys.len() as i32, &string_class, JObject::null()) {
1507        Ok(a) => a,
1508        Err(_) => { return std::ptr::null_mut(); }
1509    };
1510    
1511    for (i, key) in keys.iter().enumerate() {
1512        let jstr = match env.new_string(key) {
1513            Ok(s) => s,
1514            Err(_) => continue,
1515        };
1516                let _ = env.set_object_array_element(&array, i as i32, &jstr);
1517    }
1518    
1519    array.into_raw()
1520}
1521
1522#[no_mangle]
1523pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_getHeaderValue0(
1524    mut env: JNIEnv,
1525    _class: JClass,
1526    ptr: jlong,
1527    key: JString,
1528) -> jstring {
1529    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1530        return std::ptr::null_mut();
1531    }
1532    
1533    let criteria = unsafe { &*(ptr as *const RiMatchCriteria) };
1534    let key_str: String = match env.get_string(&key) {
1535        Ok(s) => s.into(),
1536        Err(_) => {
1537            crate::java::exception::throw_ri_error(&mut env, "Failed to get key");
1538            return std::ptr::null_mut();
1539        }
1540    };
1541    
1542    match criteria.headers.get(&key_str) {
1543        Some(value) => match env.new_string(value) {
1544            Ok(s) => s.into_raw(),
1545            Err(_) => std::ptr::null_mut(),
1546        },
1547        None => std::ptr::null_mut(),
1548    }
1549}
1550
1551#[no_mangle]
1552pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_addHeader0(
1553    mut env: JNIEnv,
1554    _class: JClass,
1555    ptr: jlong,
1556    key: JString,
1557    value: JString,
1558) {
1559    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1560        return;
1561    }
1562    
1563    let criteria = unsafe { &mut *(ptr as *mut RiMatchCriteria) };
1564    let key_str: String = match env.get_string(&key) {
1565        Ok(s) => s.into(),
1566        Err(_) => {
1567            crate::java::exception::throw_ri_error(&mut env, "Failed to get key");
1568            return;
1569        }
1570    };
1571    let value_str: String = match env.get_string(&value) {
1572        Ok(s) => s.into(),
1573        Err(_) => {
1574            crate::java::exception::throw_ri_error(&mut env, "Failed to get value");
1575            return;
1576        }
1577    };
1578    criteria.headers.insert(key_str, value_str);
1579}
1580
1581#[no_mangle]
1582pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_getQueryParamKeys0(
1583    mut env: JNIEnv,
1584    _class: JClass,
1585    ptr: jlong,
1586) -> jobjectArray {
1587    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1588        return std::ptr::null_mut();
1589    }
1590    
1591    let criteria = unsafe { &*(ptr as *const RiMatchCriteria) };
1592    let keys: Vec<&String> = criteria.query_parameters.keys().collect();
1593    
1594    let string_class = match env.find_class("java/lang/String") {
1595        Ok(c) => c,
1596        Err(_) => { return std::ptr::null_mut(); }
1597    };
1598    let array = match env.new_object_array(keys.len() as i32, &string_class, JObject::null()) {
1599        Ok(a) => a,
1600        Err(_) => { return std::ptr::null_mut(); }
1601    };
1602    
1603    for (i, key) in keys.iter().enumerate() {
1604        let jstr = match env.new_string(key) {
1605            Ok(s) => s,
1606            Err(_) => continue,
1607        };
1608                let _ = env.set_object_array_element(&array, i as i32, &jstr);
1609    }
1610    
1611    array.into_raw()
1612}
1613
1614#[no_mangle]
1615pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_getQueryParamValue0(
1616    mut env: JNIEnv,
1617    _class: JClass,
1618    ptr: jlong,
1619    key: JString,
1620) -> jstring {
1621    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1622        return std::ptr::null_mut();
1623    }
1624    
1625    let criteria = unsafe { &*(ptr as *const RiMatchCriteria) };
1626    let key_str: String = match env.get_string(&key) {
1627        Ok(s) => s.into(),
1628        Err(_) => {
1629            crate::java::exception::throw_ri_error(&mut env, "Failed to get key");
1630            return std::ptr::null_mut();
1631        }
1632    };
1633    
1634    match criteria.query_parameters.get(&key_str) {
1635        Some(value) => match env.new_string(value) {
1636            Ok(s) => s.into_raw(),
1637            Err(_) => std::ptr::null_mut(),
1638        },
1639        None => std::ptr::null_mut(),
1640    }
1641}
1642
1643#[no_mangle]
1644pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_addQueryParameter0(
1645    mut env: JNIEnv,
1646    _class: JClass,
1647    ptr: jlong,
1648    key: JString,
1649    value: JString,
1650) {
1651    if !check_not_null(&mut env, ptr, "RiMatchCriteria") {
1652        return;
1653    }
1654    
1655    let criteria = unsafe { &mut *(ptr as *mut RiMatchCriteria) };
1656    let key_str: String = match env.get_string(&key) {
1657        Ok(s) => s.into(),
1658        Err(_) => {
1659            crate::java::exception::throw_ri_error(&mut env, "Failed to get key");
1660            return;
1661        }
1662    };
1663    let value_str: String = match env.get_string(&value) {
1664        Ok(s) => s.into(),
1665        Err(_) => {
1666            crate::java::exception::throw_ri_error(&mut env, "Failed to get value");
1667            return;
1668        }
1669    };
1670    criteria.query_parameters.insert(key_str, value_str);
1671}
1672
1673#[no_mangle]
1674pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiMatchCriteria_free0(
1675    _env: JNIEnv,
1676    _class: JClass,
1677    ptr: jlong,
1678) {
1679    if ptr != 0 {
1680        unsafe {
1681            let _ = Box::from_raw(ptr as *mut RiMatchCriteria);
1682        }
1683    }
1684}
1685
1686// =============================================================================
1687// RiRouteAction JNI Bindings
1688// =============================================================================
1689
1690#[no_mangle]
1691pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_route0(
1692    env: JNIEnv,
1693    _class: JClass,
1694    destination_ptrs: JPrimitiveArray<jlong>,
1695) -> jlong {
1696    let len = env.get_array_length(&destination_ptrs).unwrap_or(0);
1697    let mut ptrs = vec![0i64; len as usize];
1698    env.get_long_array_region(&destination_ptrs, 0, &mut ptrs).unwrap_or(());
1699    
1700    let destinations: Vec<RiWeightedDestination> = ptrs.iter()
1701        .filter(|&&p| p != 0)
1702        .map(|&p| {
1703            let dest = unsafe { &*(p as *const RiWeightedDestination) };
1704            dest.clone()
1705        })
1706        .collect();
1707    
1708    let action = Box::new(RiRouteAction::Route(destinations));
1709    Box::into_raw(action) as jlong
1710}
1711
1712#[no_mangle]
1713pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_redirect0(
1714    mut env: JNIEnv,
1715    _class: JClass,
1716    uri: JString,
1717) -> jlong {
1718    let uri_str: String = match env.get_string(&uri) {
1719        Ok(s) => s.into(),
1720        Err(_) => {
1721            crate::java::exception::throw_ri_error(&mut env, "Failed to get uri");
1722            return 0;
1723        }
1724    };
1725    
1726    let action = Box::new(RiRouteAction::Redirect(uri_str));
1727    Box::into_raw(action) as jlong
1728}
1729
1730#[no_mangle]
1731pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_directResponse0(
1732    mut env: JNIEnv,
1733    _class: JClass,
1734    status_code: jint,
1735    body: JString,
1736) -> jlong {
1737    let body_str: String = match env.get_string(&body) {
1738        Ok(s) => s.into(),
1739        Err(_) => {
1740            crate::java::exception::throw_ri_error(&mut env, "Failed to get body");
1741            return 0;
1742        }
1743    };
1744    
1745    let action = Box::new(RiRouteAction::DirectResponse(status_code as u16, body_str));
1746    Box::into_raw(action) as jlong
1747}
1748
1749#[no_mangle]
1750pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_getType0(
1751    mut env: JNIEnv,
1752    _class: JClass,
1753    ptr: jlong,
1754) -> jint {
1755    if !check_not_null(&mut env, ptr, "RiRouteAction") {
1756        return 0;
1757    }
1758    
1759    let action = unsafe { &*(ptr as *const RiRouteAction) };
1760    match action {
1761        RiRouteAction::Route(_) => 0,
1762        RiRouteAction::Redirect(_) => 1,
1763        RiRouteAction::DirectResponse(_, _) => 2,
1764    }
1765}
1766
1767#[no_mangle]
1768pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_getDestinations0(
1769    mut env: JNIEnv,
1770    _class: JClass,
1771    ptr: jlong,
1772) -> jlongArray {
1773    if !check_not_null(&mut env, ptr, "RiRouteAction") {
1774        return std::ptr::null_mut();
1775    }
1776    
1777    let action = unsafe { &*(ptr as *const RiRouteAction) };
1778    
1779    match action {
1780        RiRouteAction::Route(destinations) => {
1781            let ptrs: Vec<jlong> = destinations.iter().map(|d| {
1782                let boxed = Box::new(d.clone());
1783                Box::into_raw(boxed) as jlong
1784            }).collect();
1785            
1786            let array = match env.new_long_array(ptrs.len() as i32) {
1787                Ok(a) => a,
1788                Err(_) => { return std::ptr::null_mut(); }
1789            };
1790            let _ = env.set_long_array_region(&array, 0, &ptrs);
1791            array.into_raw()
1792        }
1793        _ => std::ptr::null_mut(),
1794    }
1795}
1796
1797#[no_mangle]
1798pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_getRedirectUri0(
1799    mut env: JNIEnv,
1800    _class: JClass,
1801    ptr: jlong,
1802) -> jstring {
1803    if !check_not_null(&mut env, ptr, "RiRouteAction") {
1804        return std::ptr::null_mut();
1805    }
1806    
1807    let action = unsafe { &*(ptr as *const RiRouteAction) };
1808    
1809    match action {
1810        RiRouteAction::Redirect(uri) => match env.new_string(uri) {
1811            Ok(s) => s.into_raw(),
1812            Err(_) => std::ptr::null_mut(),
1813        },
1814        _ => std::ptr::null_mut(),
1815    }
1816}
1817
1818#[no_mangle]
1819pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_getDirectResponseStatusCode0(
1820    mut env: JNIEnv,
1821    _class: JClass,
1822    ptr: jlong,
1823) -> jint {
1824    if !check_not_null(&mut env, ptr, "RiRouteAction") {
1825        return 0;
1826    }
1827    
1828    let action = unsafe { &*(ptr as *const RiRouteAction) };
1829    
1830    match action {
1831        RiRouteAction::DirectResponse(status_code, _) => *status_code as jint,
1832        _ => 0,
1833    }
1834}
1835
1836#[no_mangle]
1837pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_getDirectResponseBody0(
1838    mut env: JNIEnv,
1839    _class: JClass,
1840    ptr: jlong,
1841) -> jstring {
1842    if !check_not_null(&mut env, ptr, "RiRouteAction") {
1843        return std::ptr::null_mut();
1844    }
1845    
1846    let action = unsafe { &*(ptr as *const RiRouteAction) };
1847    
1848    match action {
1849        RiRouteAction::DirectResponse(_, body) => match env.new_string(body) {
1850            Ok(s) => s.into_raw(),
1851            Err(_) => std::ptr::null_mut(),
1852        },
1853        _ => std::ptr::null_mut(),
1854    }
1855}
1856
1857#[no_mangle]
1858pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiRouteAction_free0(
1859    _env: JNIEnv,
1860    _class: JClass,
1861    ptr: jlong,
1862) {
1863    if ptr != 0 {
1864        unsafe {
1865            let _ = Box::from_raw(ptr as *mut RiRouteAction);
1866        }
1867    }
1868}
1869
1870// =============================================================================
1871// RiWeightedDestination JNI Bindings
1872// =============================================================================
1873
1874#[no_mangle]
1875pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiWeightedDestination_new0(
1876    mut env: JNIEnv,
1877    _class: JClass,
1878    service: JString,
1879    weight: jint,
1880) -> jlong {
1881    let service_str: String = match env.get_string(&service) {
1882        Ok(s) => s.into(),
1883        Err(_) => {
1884            crate::java::exception::throw_ri_error(&mut env, "Failed to get service");
1885            return 0;
1886        }
1887    };
1888    
1889    let dest = Box::new(RiWeightedDestination {
1890        service: service_str,
1891        weight: weight as u32,
1892        subset: None,
1893    });
1894    Box::into_raw(dest) as jlong
1895}
1896
1897#[no_mangle]
1898pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiWeightedDestination_getService0(
1899    mut env: JNIEnv,
1900    _class: JClass,
1901    ptr: jlong,
1902) -> jstring {
1903    if !check_not_null(&mut env, ptr, "RiWeightedDestination") {
1904        return std::ptr::null_mut();
1905    }
1906    
1907    let dest = unsafe { &*(ptr as *const RiWeightedDestination) };
1908    match env.new_string(&dest.service) {
1909        Ok(s) => s.into_raw(),
1910        Err(_) => std::ptr::null_mut(),
1911    }
1912}
1913
1914#[no_mangle]
1915pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiWeightedDestination_getWeight0(
1916    mut env: JNIEnv,
1917    _class: JClass,
1918    ptr: jlong,
1919) -> jint {
1920    if !check_not_null(&mut env, ptr, "RiWeightedDestination") {
1921        return 0;
1922    }
1923    
1924    let dest = unsafe { &*(ptr as *const RiWeightedDestination) };
1925    dest.weight as jint
1926}
1927
1928#[no_mangle]
1929pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiWeightedDestination_getSubset0(
1930    mut env: JNIEnv,
1931    _class: JClass,
1932    ptr: jlong,
1933) -> jstring {
1934    if !check_not_null(&mut env, ptr, "RiWeightedDestination") {
1935        return std::ptr::null_mut();
1936    }
1937    
1938    let dest = unsafe { &*(ptr as *const RiWeightedDestination) };
1939    match &dest.subset {
1940        Some(subset) => match env.new_string(subset) {
1941            Ok(s) => s.into_raw(),
1942            Err(_) => std::ptr::null_mut(),
1943        },
1944        None => std::ptr::null_mut(),
1945    }
1946}
1947
1948#[no_mangle]
1949pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiWeightedDestination_setSubset0(
1950    mut env: JNIEnv,
1951    _class: JClass,
1952    ptr: jlong,
1953    subset: JString,
1954) {
1955    if !check_not_null(&mut env, ptr, "RiWeightedDestination") {
1956        return;
1957    }
1958    
1959    let dest = unsafe { &mut *(ptr as *mut RiWeightedDestination) };
1960    let subset_str: String = match env.get_string(&subset) {
1961        Ok(s) => s.into(),
1962        Err(_) => {
1963            crate::java::exception::throw_ri_error(&mut env, "Failed to get subset");
1964            return;
1965        }
1966    };
1967    dest.subset = Some(subset_str);
1968}
1969
1970#[no_mangle]
1971pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiWeightedDestination_free0(
1972    _env: JNIEnv,
1973    _class: JClass,
1974    ptr: jlong,
1975) {
1976    if ptr != 0 {
1977        unsafe {
1978            let _ = Box::from_raw(ptr as *mut RiWeightedDestination);
1979        }
1980    }
1981}
1982
1983// =============================================================================
1984// RiTrafficManager JNI Bindings
1985// =============================================================================
1986
1987#[no_mangle]
1988pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_new0(
1989    _env: JNIEnv,
1990    _class: JClass,
1991    enabled: jboolean,
1992) -> jlong {
1993    let manager = Box::new(RiTrafficManager::new(enabled != 0));
1994    Box::into_raw(manager) as jlong
1995}
1996
1997#[no_mangle]
1998pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_addRoute0(
1999    mut env: JNIEnv,
2000    _class: JClass,
2001    ptr: jlong,
2002    route_ptr: jlong,
2003) {
2004    if !check_not_null(&mut env, ptr, "RiTrafficManager") {
2005        return;
2006    }
2007    if !check_not_null(&mut env, route_ptr, "RiTrafficRoute") {
2008        return;
2009    }
2010    
2011    let manager = unsafe { &*(ptr as *const RiTrafficManager) };
2012    let route = unsafe { &*(route_ptr as *const RiTrafficRoute) };
2013    
2014    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
2015        manager.add_traffic_route(route.clone()).await
2016    });
2017}
2018
2019#[no_mangle]
2020pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_removeRoute0(
2021    mut env: JNIEnv,
2022    _class: JClass,
2023    ptr: jlong,
2024    source_service: JString,
2025    route_name: JString,
2026) {
2027    if !check_not_null(&mut env, ptr, "RiTrafficManager") {
2028        return;
2029    }
2030    
2031    let manager = unsafe { &*(ptr as *const RiTrafficManager) };
2032    let source_service_str: String = match env.get_string(&source_service) {
2033        Ok(s) => s.into(),
2034        Err(_) => {
2035            crate::java::exception::throw_ri_error(&mut env, "Failed to get source service");
2036            return;
2037        }
2038    };
2039    let route_name_str: String = match env.get_string(&route_name) {
2040        Ok(s) => s.into(),
2041        Err(_) => {
2042            crate::java::exception::throw_ri_error(&mut env, "Failed to get route name");
2043            return;
2044        }
2045    };
2046    
2047    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
2048        manager.remove_traffic_route(&source_service_str, &route_name_str).await
2049    });
2050}
2051
2052#[no_mangle]
2053pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_getRoutes0(
2054    mut env: JNIEnv,
2055    _class: JClass,
2056    ptr: jlong,
2057    source_service: JString,
2058) -> jlongArray {
2059    if !check_not_null(&mut env, ptr, "RiTrafficManager") {
2060        return std::ptr::null_mut();
2061    }
2062    
2063    let manager = unsafe { &*(ptr as *const RiTrafficManager) };
2064    let source_service_str: String = match env.get_string(&source_service) {
2065        Ok(s) => s.into(),
2066        Err(_) => {
2067            crate::java::exception::throw_ri_error(&mut env, "Failed to get source service");
2068            return std::ptr::null_mut();
2069        }
2070    };
2071    
2072    let result = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
2073        manager.get_traffic_routes(&source_service_str).await
2074    });
2075    
2076    match result {
2077        Some(Ok(routes)) => {
2078            let ptrs: Vec<jlong> = routes.iter().map(|r| {
2079                let boxed = Box::new(r.clone());
2080                Box::into_raw(boxed) as jlong
2081            }).collect();
2082            
2083            let array = match env.new_long_array(ptrs.len() as i32) {
2084                Ok(a) => a,
2085                Err(_) => { return std::ptr::null_mut(); }
2086            };
2087            let _ = env.set_long_array_region(&array, 0, &ptrs);
2088            array.into_raw()
2089        }
2090        _ => std::ptr::null_mut(),
2091    }
2092}
2093
2094#[no_mangle]
2095pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_setCircuitBreakerConfig0(
2096    mut env: JNIEnv,
2097    _class: JClass,
2098    ptr: jlong,
2099    service: JString,
2100    consecutive_errors: jint,
2101    max_ejection_percent: jdouble,
2102) {
2103    if !check_not_null(&mut env, ptr, "RiTrafficManager") {
2104        return;
2105    }
2106    
2107    let manager = unsafe { &*(ptr as *const RiTrafficManager) };
2108    let service_str: String = match env.get_string(&service) {
2109        Ok(s) => s.into(),
2110        Err(_) => {
2111            crate::java::exception::throw_ri_error(&mut env, "Failed to get service");
2112            return;
2113        }
2114    };
2115    
2116    let config = RiCircuitBreakerConfig {
2117        consecutive_errors: consecutive_errors as u32,
2118        interval: Duration::from_secs(10),
2119        base_ejection_time: Duration::from_secs(30),
2120        max_ejection_percent,
2121    };
2122    
2123    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
2124        manager.set_circuit_breaker_config(&service_str, config).await
2125    });
2126}
2127
2128#[no_mangle]
2129pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_setRateLimitConfig0(
2130    mut env: JNIEnv,
2131    _class: JClass,
2132    ptr: jlong,
2133    service: JString,
2134    requests_per_second: jint,
2135    burst_size: jint,
2136) {
2137    if !check_not_null(&mut env, ptr, "RiTrafficManager") {
2138        return;
2139    }
2140    
2141    let manager = unsafe { &*(ptr as *const RiTrafficManager) };
2142    let service_str: String = match env.get_string(&service) {
2143        Ok(s) => s.into(),
2144        Err(_) => {
2145            crate::java::exception::throw_ri_error(&mut env, "Failed to get service");
2146            return;
2147        }
2148    };
2149    
2150    let config = RiRateLimitConfig {
2151        requests_per_second: requests_per_second as u32,
2152        burst_size: burst_size as u32,
2153        window: Duration::from_secs(1),
2154    };
2155    
2156    let _ = crate::java::runtime::block_on_local(&mut env, "RiServiceMesh", async {
2157        manager.set_rate_limit_config(&service_str, config).await
2158    });
2159}
2160
2161#[no_mangle]
2162pub extern "system" fn Java_com_dunimd_ri_servicemesh_RiTrafficManager_free0(
2163    _env: JNIEnv,
2164    _class: JClass,
2165    ptr: jlong,
2166) {
2167    if ptr != 0 {
2168        unsafe {
2169            let _ = Box::from_raw(ptr as *mut RiTrafficManager);
2170        }
2171    }
2172}
ri/java/classes/service_mesh.rs

ri/java/classes/
service_mesh.rs
