1use std::ffi::{CStr, CString};
4
5#[cfg(feature = "xet-storage")]
6use std::marker::PhantomData;
7
8#[cfg(feature = "xet-storage")]
9use std::pin::Pin;
10
11#[cfg(feature = "xet-storage")]
12use std::sync::Arc;
13
14#[cfg(feature = "xet-storage")]
15use libc::c_char;
16
17#[cfg(feature = "xet-storage")]
18use crate::ffi::GitFilter;
19
20#[cfg(feature = "xet-storage")]
21use crate::storage::{StorageBackend, XetStorage};
22
23#[cfg(feature = "xet-storage")]
24use crate::runtime::XetRuntime;
25
26#[cfg(feature = "xet-storage")]
27use crate::error::{Result, XetError, XetErrorKind};
28
29#[cfg(feature = "xet-storage")]
31pub struct Unregistered;
32
33#[cfg(feature = "xet-storage")]
34pub struct Registered;
35
36#[cfg(feature = "xet-storage")]
38pub struct XetFilter<State = Unregistered> {
39 inner: Pin<Box<GitFilter>>,
40 payload: Option<Box<XetFilterPayload>>,
41 name: String,
42 attributes_cstr: Option<CString>,
43 _state: PhantomData<State>,
44}
45
46#[cfg(feature = "xet-storage")]
48#[derive(Clone)]
49pub struct XetFilterPayload {
50 pub storage: Arc<dyn StorageBackend>,
51 pub runtime: Arc<XetRuntime>,
52}
53
54#[cfg(feature = "xet-storage")]
55impl XetFilter<Unregistered> {
56 pub async fn new(config: crate::config::XetConfig) -> Result<Self> {
58 let (runtime, storage) = std::thread::spawn(move || {
62 let runtime = XetRuntime::new()?;
63 let storage = runtime.block_on_unchecked(async { XetStorage::new(&config).await })?;
64 Ok::<_, XetError>((
65 Arc::new(runtime),
66 Arc::new(storage) as Arc<dyn StorageBackend>,
67 ))
68 })
69 .join()
70 .map_err(|e| {
71 XetError::new(
72 XetErrorKind::RuntimeError,
73 format!("Thread join error: {e:?}"),
74 )
75 })??;
76
77 let payload = Box::new(XetFilterPayload { storage, runtime });
79
80 let attributes_cstr = CString::new("filter=xet")
84 .map_err(|_| XetError::new(XetErrorKind::RuntimeError, "Invalid attributes string"))?;
85 let attributes_ptr = attributes_cstr.as_ptr() as *const c_char;
86
87 let filter = Box::pin(GitFilter {
89 version: crate::ffi::GIT_FILTER_VERSION,
90 attributes: attributes_ptr,
91 initialize: Some(crate::callbacks::xet_filter_initialize),
92 shutdown: Some(crate::callbacks::xet_filter_shutdown),
93 check: Some(crate::callbacks::xet_filter_check),
94 reserved: std::ptr::null_mut(),
95 stream: Some(crate::callbacks::xet_filter_stream),
96 cleanup: Some(crate::callbacks::xet_filter_cleanup),
97 });
98
99 Ok(Self {
100 inner: filter,
101 payload: Some(payload),
102 name: "xet".to_owned(),
103 attributes_cstr: Some(attributes_cstr),
104 _state: PhantomData,
105 })
106 }
107
108 pub fn register(mut self, priority: i32) -> Result<XetFilter<Registered>> {
112 unsafe { git2::opts::set_mwindow_size(crate::ffi::LIBGIT2_MWINDOW_SIZE).ok() };
115
116 let name_cstr = CString::new(self.name.as_str())
117 .map_err(|_| XetError::new(XetErrorKind::RuntimeError, "Invalid filter name"))?;
118
119 unsafe {
122 let unregister_result = crate::ffi::git_filter_unregister(name_cstr.as_ptr());
124 if unregister_result == 0 {
125 tracing::debug!(
126 "Unregistered existing '{}' filter before re-registering",
127 self.name
128 );
129 }
130
131 let filter_ptr = Pin::as_mut(&mut self.inner).get_unchecked_mut() as *mut GitFilter;
132
133 let init_result =
135 crate::ffi::git_filter_init(filter_ptr, crate::ffi::GIT_FILTER_VERSION);
136 if init_result < 0 {
137 tracing::warn!(
138 "git_filter_init returned {} (continuing anyway)",
139 init_result
140 );
141 }
142
143 (*filter_ptr).attributes = self
145 .attributes_cstr
146 .as_ref()
147 .ok_or_else(|| {
148 XetError::new(XetErrorKind::RuntimeError, "attributes_cstr not set")
149 })?
150 .as_ptr();
151 (*filter_ptr).initialize = Some(crate::callbacks::xet_filter_initialize);
152 (*filter_ptr).shutdown = Some(crate::callbacks::xet_filter_shutdown);
153 (*filter_ptr).check = Some(crate::callbacks::xet_filter_check);
154 (*filter_ptr).stream = Some(crate::callbacks::xet_filter_stream);
155 (*filter_ptr).cleanup = Some(crate::callbacks::xet_filter_cleanup);
156
157 let payload = self
160 .payload
161 .take()
162 .ok_or_else(|| XetError::new(XetErrorKind::RuntimeError, "payload not set"))?;
163 crate::callbacks::register_payload(
164 filter_ptr as *const crate::ffi::OpaqueGitFilter,
165 *payload,
166 );
167
168 let result = crate::ffi::git_filter_register(name_cstr.as_ptr(), filter_ptr, priority);
169
170 if result < 0 {
171 let git_error = git2::Error::last_error(result);
173
174 const GIT_EEXISTS: i32 = -4;
177 if result == GIT_EEXISTS {
178 tracing::warn!("XET filter was already registered, continuing anyway");
179 } else {
181 let _ = crate::callbacks::unregister_payload(
183 filter_ptr as *const crate::ffi::OpaqueGitFilter,
184 );
185
186 tracing::error!(
188 "git_filter_register failed: result={}, error={:?}, version={}, attributes={:?}",
189 result,
190 git_error,
191 (*filter_ptr).version,
192 CStr::from_ptr((*filter_ptr).attributes)
193 );
194
195 return Err(XetError::new(
196 XetErrorKind::RuntimeError,
197 format!("git_filter_register failed (code {result}): {git_error:?}"),
198 ));
199 }
200 }
201 }
202
203 Ok(XetFilter {
205 inner: self.inner,
206 payload: None, name: self.name,
208 attributes_cstr: self.attributes_cstr,
209 _state: PhantomData,
210 })
211 }
212}
213
214#[cfg(feature = "xet-storage")]
215impl XetFilter<Registered> {
216 pub fn unregister(mut self) -> Result<XetFilter<Unregistered>> {
220 let name_cstr = CString::new(self.name.as_str())
221 .map_err(|_| XetError::new(XetErrorKind::RuntimeError, "Invalid filter name"))?;
222
223 unsafe {
224 let filter_ptr = Pin::as_mut(&mut self.inner).get_unchecked_mut() as *mut GitFilter;
225
226 let result = crate::ffi::git_filter_unregister(name_cstr.as_ptr());
227
228 if result < 0 {
229 return Err(XetError::new(
230 XetErrorKind::RuntimeError,
231 "git_filter_unregister failed",
232 ));
233 }
234
235 let payload = crate::callbacks::unregister_payload(
238 filter_ptr as *const crate::ffi::OpaqueGitFilter,
239 )
240 .ok_or_else(|| {
241 XetError::new(
242 XetErrorKind::RuntimeError,
243 "Payload not found in registry - filter may have been double-unregistered",
244 )
245 })?;
246
247 let payload_box = Box::new((*payload).clone());
249
250 Ok(XetFilter {
251 inner: self.inner,
252 payload: Some(payload_box),
253 name: self.name,
254 attributes_cstr: self.attributes_cstr,
255 _state: PhantomData,
256 })
257 }
258 }
259}
260
261#[cfg(feature = "xet-storage")]
263unsafe impl Send for XetFilter<Unregistered> {}
264
265#[cfg(feature = "xet-storage")]
266unsafe impl Sync for XetFilter<Unregistered> {}
267
268#[cfg(feature = "xet-storage")]
271unsafe impl Send for XetFilter<Registered> {}
272
273#[cfg(feature = "xet-storage")]
274unsafe impl Sync for XetFilter<Registered> {}
275
276