1use crate::errors::{Git2DBError, Git2DBResult};
6use crate::registry::{Git2DB, RemoteConfig, RepoId};
7use crate::repo_accessor::RepositoryAccessor;
8use git2::Repository;
9
10pub struct RemoteManager<'a> {
40 registry: &'a Git2DB,
41 repo_id: RepoId,
42}
43
44impl<'a> RepositoryAccessor for RemoteManager<'a> {
45 fn registry(&self) -> &Git2DB {
46 self.registry
47 }
48
49 fn repo_id(&self) -> &RepoId {
50 &self.repo_id
51 }
52}
53
54impl<'a> RemoteManager<'a> {
55 pub(crate) fn new(registry: &'a Git2DB, repo_id: RepoId) -> Self {
57 Self { registry, repo_id }
58 }
59
60 pub async fn add(&self, name: &str, url: &str) -> Git2DBResult<()> {
64 let path = self.repo_path()?;
65 let name = name.to_owned();
66 let url = url.to_owned();
67
68 tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
69 let repo = Repository::open(&path).map_err(|e| {
70 Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
71 })?;
72
73 if repo.find_remote(&name).is_ok() {
75 return Err(Git2DBError::configuration(format!(
76 "Remote '{name}' already exists"
77 )));
78 }
79
80 repo.remote(&name, &url).map_err(|e| {
82 Git2DBError::configuration(format!("Failed to add remote '{name}': {e}"))
83 })?;
84
85 Ok(())
86 })
87 .await
88 .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
89
90 self.update_metadata_remotes().await?;
92
93 Ok(())
94 }
95
96 pub async fn remove(&self, name: &str) -> Git2DBResult<()> {
100 let path = self.repo_path()?;
101 let name = name.to_owned();
102
103 tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
104 let repo = Repository::open(&path).map_err(|e| {
105 Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
106 })?;
107
108 repo.find_remote(&name)
110 .map_err(|_| Git2DBError::configuration(format!("Remote '{name}' not found")))?;
111
112 repo.remote_delete(&name).map_err(|e| {
114 Git2DBError::configuration(format!("Failed to remove remote '{name}': {e}"))
115 })?;
116
117 Ok(())
118 })
119 .await
120 .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
121
122 self.update_metadata_remotes().await?;
124
125 Ok(())
126 }
127
128 pub async fn set_url(&self, name: &str, url: &str) -> Git2DBResult<()> {
132 let path = self.repo_path()?;
133 let name = name.to_owned();
134 let url = url.to_owned();
135
136 tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
137 let repo = Repository::open(&path).map_err(|e| {
138 Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
139 })?;
140
141 repo.find_remote(&name)
143 .map_err(|_| Git2DBError::configuration(format!("Remote '{name}' not found")))?;
144
145 repo.remote_set_url(&name, &url).map_err(|e| {
147 Git2DBError::configuration(format!("Failed to set URL for remote '{name}': {e}"))
148 })?;
149
150 Ok(())
151 })
152 .await
153 .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
154
155 self.update_metadata_remotes().await?;
157
158 Ok(())
159 }
160
161 pub async fn rename(&self, old_name: &str, new_name: &str) -> Git2DBResult<()> {
165 let path = self.repo_path()?;
166 let old_name = old_name.to_owned();
167 let new_name = new_name.to_owned();
168
169 tokio::task::spawn_blocking(move || -> Git2DBResult<()> {
170 let repo = Repository::open(&path).map_err(|e| {
171 Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
172 })?;
173
174 repo.find_remote(&old_name).map_err(|_| {
176 Git2DBError::configuration(format!("Remote '{old_name}' not found"))
177 })?;
178
179 if repo.find_remote(&new_name).is_ok() {
181 return Err(Git2DBError::configuration(format!(
182 "Remote '{new_name}' already exists"
183 )));
184 }
185
186 repo.remote_rename(&old_name, &new_name).map_err(|e| {
188 Git2DBError::configuration(format!(
189 "Failed to rename remote '{old_name}' to '{new_name}': {e}"
190 ))
191 })?;
192
193 Ok(())
194 })
195 .await
196 .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))??;
197
198 self.update_metadata_remotes().await?;
200
201 Ok(())
202 }
203
204 pub async fn list(&self) -> Git2DBResult<Vec<Remote>> {
208 let path = self.repo_path()?;
209
210 tokio::task::spawn_blocking(move || -> Git2DBResult<Vec<Remote>> {
211 let repo = Repository::open(&path).map_err(|e| {
212 Git2DBError::repository(&path, format!("Failed to open repository: {e}"))
213 })?;
214
215 let remote_names = repo
216 .remotes()
217 .map_err(|e| Git2DBError::internal(format!("Failed to list remotes: {e}")))?;
218
219 let mut remotes = Vec::new();
220
221 for name in remote_names.iter().flatten() {
222 if let Ok(remote) = repo.find_remote(name) {
223 let url = remote.url().unwrap_or("").to_owned();
224 let fetch_refspec = remote
225 .fetch_refspecs()
226 .map_err(|_| Git2DBError::internal("Failed to get fetch refspecs"))?;
227
228 let fetch_refs: Vec<String> = fetch_refspec
229 .iter()
230 .flatten()
231 .map(std::borrow::ToOwned::to_owned)
232 .collect();
233
234 remotes.push(Remote {
235 name: name.to_owned(),
236 url,
237 fetch_refs,
238 push_url: remote.pushurl().map(std::borrow::ToOwned::to_owned),
239 });
240 }
241 }
242
243 Ok(remotes)
244 })
245 .await
246 .map_err(|e| Git2DBError::internal(format!("Task join error: {e}")))?
247 }
248
249 pub async fn default(&self) -> Git2DBResult<Option<Remote>> {
251 let remotes = self.list().await?;
252
253 if let Some(origin) = remotes.iter().find(|r| r.name == "origin") {
255 return Ok(Some(origin.clone()));
256 }
257
258 Ok(remotes.into_iter().next())
260 }
261
262 async fn update_metadata_remotes(&self) -> Git2DBResult<()> {
264 let remotes = self.list().await?;
266
267 let _configs: Vec<RemoteConfig> = remotes
269 .into_iter()
270 .map(|r| RemoteConfig {
271 name: r.name,
272 url: r.url,
273 fetch_refs: r.fetch_refs,
274 })
275 .collect();
276
277 Ok(())
284 }
285}
286
287#[derive(Debug, Clone)]
289pub struct Remote {
290 pub name: String,
291 pub url: String,
292 pub fetch_refs: Vec<String>,
293 pub push_url: Option<String>,
294}
295
296impl Remote {
297 pub fn is_default(&self) -> bool {
299 self.name == "origin"
300 }
301
302 pub fn display_url(&self) -> &str {
304 self.push_url.as_deref().unwrap_or(&self.url)
305 }
306}