fory_core/resolver/
meta_resolver.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18use crate::buffer::{Reader, Writer};
19use crate::error::Error;
20use crate::meta::TypeMeta;
21use crate::resolver::type_resolver::TypeInfo;
22use crate::TypeResolver;
23use std::collections::HashMap;
24use std::rc::Rc;
25
26#[derive(Default)]
27pub struct MetaWriterResolver {
28    type_defs: Vec<Rc<Vec<u8>>>,
29    type_id_index_map: HashMap<std::any::TypeId, usize>,
30}
31
32const MAX_PARSED_NUM_TYPE_DEFS: usize = 8192;
33
34#[allow(dead_code)]
35impl MetaWriterResolver {
36    #[inline(always)]
37    pub fn push(
38        &mut self,
39        type_id: std::any::TypeId,
40        type_resolver: &TypeResolver,
41    ) -> Result<usize, Error> {
42        match self.type_id_index_map.get(&type_id) {
43            None => {
44                let index = self.type_defs.len();
45                self.type_defs
46                    .push(type_resolver.get_type_info(&type_id)?.get_type_def());
47                self.type_id_index_map.insert(type_id, index);
48                Ok(index)
49            }
50            Some(index) => Ok(*index),
51        }
52    }
53
54    #[inline(always)]
55    pub fn to_bytes(&self, writer: &mut Writer) {
56        writer.write_varuint32(self.type_defs.len() as u32);
57        for item in &self.type_defs {
58            writer.write_bytes(item);
59        }
60    }
61
62    #[inline(always)]
63    pub fn empty(&mut self) -> bool {
64        self.type_defs.is_empty()
65    }
66
67    #[inline(always)]
68    pub fn reset(&mut self) {
69        self.type_defs.clear();
70        self.type_id_index_map.clear();
71    }
72}
73
74#[derive(Default)]
75pub struct MetaReaderResolver {
76    pub reading_type_infos: Vec<Rc<TypeInfo>>,
77    parsed_type_infos: HashMap<i64, Rc<TypeInfo>>,
78}
79
80impl MetaReaderResolver {
81    #[inline(always)]
82    pub fn get(&self, index: usize) -> Option<&Rc<TypeInfo>> {
83        self.reading_type_infos.get(index)
84    }
85
86    pub fn load(
87        &mut self,
88        type_resolver: &TypeResolver,
89        reader: &mut Reader,
90    ) -> Result<usize, Error> {
91        let meta_size = reader.read_varuint32()?;
92        // self.reading_type_infos.reserve(meta_size as usize);
93        for _ in 0..meta_size {
94            let meta_header = reader.read_i64()?;
95            if let Some(type_info) = self.parsed_type_infos.get(&meta_header) {
96                self.reading_type_infos.push(type_info.clone());
97                TypeMeta::skip_bytes(reader, meta_header)?;
98            } else {
99                let type_meta = Rc::new(TypeMeta::from_bytes_with_header(
100                    reader,
101                    type_resolver,
102                    meta_header,
103                )?);
104
105                // Try to find local type info
106                let type_info = if type_meta.get_namespace().original.is_empty() {
107                    // Registered by ID
108                    let type_id = type_meta.get_type_id();
109                    if let Some(local_type_info) = type_resolver.get_type_info_by_id(type_id) {
110                        // Use local harness with remote metadata
111                        Rc::new(TypeInfo::from_remote_meta(
112                            type_meta.clone(),
113                            Some(local_type_info.get_harness()),
114                        ))
115                    } else {
116                        // No local type found, use stub harness
117                        Rc::new(TypeInfo::from_remote_meta(type_meta.clone(), None))
118                    }
119                } else {
120                    // Registered by name
121                    let namespace = &type_meta.get_namespace().original;
122                    let type_name = &type_meta.get_type_name().original;
123                    if let Some(local_type_info) =
124                        type_resolver.get_type_info_by_name(namespace, type_name)
125                    {
126                        // Use local harness with remote metadata
127                        Rc::new(TypeInfo::from_remote_meta(
128                            type_meta.clone(),
129                            Some(local_type_info.get_harness()),
130                        ))
131                    } else {
132                        // No local type found, use stub harness
133                        Rc::new(TypeInfo::from_remote_meta(type_meta.clone(), None))
134                    }
135                };
136
137                if self.parsed_type_infos.len() < MAX_PARSED_NUM_TYPE_DEFS {
138                    // avoid malicious type defs to OOM parsed_type_infos
139                    self.parsed_type_infos
140                        .insert(meta_header, type_info.clone());
141                }
142                self.reading_type_infos.push(type_info);
143            }
144        }
145        Ok(reader.get_cursor())
146    }
147
148    #[inline(always)]
149    pub fn reset(&mut self) {
150        self.reading_type_infos.clear();
151    }
152}
fory_core/resolver/meta_resolver.rs

fory_core/resolver/
meta_resolver.rs
