zhenyi
8c95eb230d
- Add is_write parameter to remote clients for read/write routing distinction - Introduce RepoEntry struct with role tracking (primary/replica) for repositories - Replace HashSet with HashMap for repository storage with role metadata - Add ROLE_PRIMARY and ROLE_REPLICA constants for node role identification - Implement FindPrimary and FindReplica RPC methods for role-based routing - Add RefUpdateEvent message type for propagating reference updates - Create sync module with BundleApplicator for handling replica synchronization - Implement notify_ref_update calls after branch/tag/commit operations - Add broadcast_ref_update function to propagate events across cluster nodes - Modify route_repository to prioritize primary for writes and replicas for reads - Update actor message handling to support role-based repository discovery - Implement sync_from_primary function using pack protocol for incremental updates
415 lines
17 KiB
Rust
415 lines
17 KiB
Rust
use crate::pb::*;
|
|
use crate::pb::repository_service_client::RepositoryServiceClient;
|
|
|
|
use super::{GitksService, git_cmd, into_status, repository_maint, remote_endpoint};
|
|
|
|
async fn remote_repository_client(
|
|
svc: &GitksService,
|
|
header: Option<&RepositoryHeader>,
|
|
is_write: bool,
|
|
) -> Result<Option<RepositoryServiceClient<tonic::transport::Channel>>, tonic::Status> {
|
|
let header = match header {
|
|
Some(h) => h,
|
|
None => return Ok(None),
|
|
};
|
|
let Some(route) = svc.route_repository(header, is_write).await? else {
|
|
return Ok(None);
|
|
};
|
|
tracing::info!(storage_name = %route.storage_name, relative_path = %route.relative_path, actor_name = %route.actor_name, grpc_addr = %route.grpc_addr, "forwarding repository rpc");
|
|
let endpoint = remote_endpoint(&route.grpc_addr).await?;
|
|
let client = RepositoryServiceClient::connect(endpoint)
|
|
.await
|
|
.map_err(|e| tonic::Status::unavailable(e.to_string()))?;
|
|
Ok(Some(client))
|
|
}
|
|
|
|
fn default_branch_name(gb: &crate::bare::GitBare) -> String {
|
|
git_cmd(gb, &["symbolic-ref", "HEAD"])
|
|
.ok()
|
|
.and_then(|o| {
|
|
String::from_utf8_lossy(&o.stdout)
|
|
.trim()
|
|
.strip_prefix("refs/heads/")
|
|
.map(|b| b.to_string())
|
|
})
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
#[tonic::async_trait]
|
|
impl repository_service_server::RepositoryService for GitksService {
|
|
async fn get_repository(
|
|
&self,
|
|
request: tonic::Request<GetRepositoryRequest>,
|
|
) -> Result<tonic::Response<Repository>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.get_repository", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.get_repository(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let bare = gb.bare_dir.join("HEAD").exists();
|
|
let object_format = gb.object_format();
|
|
Ok(tonic::Response::new(Repository {
|
|
header: inner.repository,
|
|
bare,
|
|
object_format: object_format as i32,
|
|
default_branch: default_branch_name(&gb),
|
|
..Default::default()
|
|
}))
|
|
}
|
|
|
|
async fn init_repository(
|
|
&self,
|
|
request: tonic::Request<InitRepositoryRequest>,
|
|
) -> Result<tonic::Response<Repository>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.init_repository", %repo);
|
|
let _enter = span.enter();
|
|
let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
|
|
let gb = crate::bare::GitBare::new(bare_dir);
|
|
gb.init_repository(inner.bare).map_err(into_status)?;
|
|
tracing::info!(%repo, bare = inner.bare, "repository initialized");
|
|
self.notify_ref_update(&repo, "HEAD", "", "");
|
|
Ok(tonic::Response::new(Repository {
|
|
header: inner.repository,
|
|
bare: inner.bare,
|
|
..Default::default()
|
|
}))
|
|
}
|
|
|
|
async fn delete_repository(
|
|
&self,
|
|
request: tonic::Request<DeleteRepositoryRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.delete_repository", %repo);
|
|
let _enter = span.enter();
|
|
let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
|
|
if !bare_dir.exists() {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), true).await? {
|
|
return client.delete_repository(inner).await;
|
|
}
|
|
}
|
|
tracing::warn!(%repo, path = %bare_dir.display(), "deleting repository");
|
|
std::fs::remove_dir_all(&bare_dir).map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
tracing::info!(%repo, "repository deleted");
|
|
self.notify_ref_update(&repo, "", "", "");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
async fn repository_exists(
|
|
&self,
|
|
request: tonic::Request<RepositoryExistsRequest>,
|
|
) -> Result<tonic::Response<RepositoryExistsResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.repository_exists", %repo);
|
|
let _enter = span.enter();
|
|
let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
|
|
let exists = bare_dir.exists() && bare_dir.is_dir() && bare_dir.join("HEAD").exists();
|
|
if !exists {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.repository_exists(inner).await;
|
|
}
|
|
}
|
|
Ok(tonic::Response::new(RepositoryExistsResponse { exists }))
|
|
}
|
|
|
|
async fn get_object_format(
|
|
&self,
|
|
request: tonic::Request<RepositoryObjectFormatRequest>,
|
|
) -> Result<tonic::Response<RepositoryObjectFormatResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.get_object_format", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.get_object_format(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
Ok(tonic::Response::new(RepositoryObjectFormatResponse {
|
|
object_format: gb.object_format() as i32,
|
|
}))
|
|
}
|
|
|
|
async fn get_default_branch(
|
|
&self,
|
|
request: tonic::Request<GetDefaultBranchRequest>,
|
|
) -> Result<tonic::Response<GetDefaultBranchResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.get_default_branch", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.get_default_branch(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
Ok(tonic::Response::new(GetDefaultBranchResponse {
|
|
name: default_branch_name(&gb),
|
|
}))
|
|
}
|
|
|
|
async fn set_default_branch(
|
|
&self,
|
|
request: tonic::Request<SetDefaultBranchRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let name = inner.name.clone();
|
|
let span = tracing::info_span!("repo.set_default_branch", %repo, %name);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), true).await? {
|
|
return client.set_default_branch(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let refname = format!("refs/heads/{}", inner.name);
|
|
let out = git_cmd(&gb, &["symbolic-ref", "HEAD", &refname])?;
|
|
if !out.status.success() {
|
|
return Err(tonic::Status::internal(
|
|
String::from_utf8_lossy(&out.stderr).trim().to_string(),
|
|
));
|
|
}
|
|
tracing::info!(%repo, %name, "default branch set");
|
|
self.notify_ref_update(&repo, &refname, "", "");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
async fn get_repository_config(
|
|
&self,
|
|
request: tonic::Request<GetRepositoryConfigRequest>,
|
|
) -> Result<tonic::Response<GetRepositoryConfigResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.get_repository_config", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.get_repository_config(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let mut entries = Vec::new();
|
|
if inner.keys.is_empty() {
|
|
let out = git_cmd(&gb, &["config", "--list"])?;
|
|
if !out.status.success() {
|
|
return Err(tonic::Status::internal(
|
|
String::from_utf8_lossy(&out.stderr).trim().to_string(),
|
|
));
|
|
}
|
|
for line in String::from_utf8_lossy(&out.stdout).lines() {
|
|
if let Some((k, v)) = line.split_once('=') {
|
|
entries.push(RepositoryConfigEntry {
|
|
key: k.trim().to_string(),
|
|
values: vec![v.trim().to_string()],
|
|
});
|
|
}
|
|
}
|
|
} else {
|
|
for key in &inner.keys {
|
|
let out = git_cmd(&gb, &["config", "--get-all", key])?;
|
|
if out.status.success() {
|
|
let vals: Vec<String> = String::from_utf8_lossy(&out.stdout)
|
|
.lines()
|
|
.map(|l| l.trim().to_string())
|
|
.filter(|l| !l.is_empty())
|
|
.collect();
|
|
if !vals.is_empty() {
|
|
entries.push(RepositoryConfigEntry {
|
|
key: key.clone(),
|
|
values: vals,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(tonic::Response::new(GetRepositoryConfigResponse {
|
|
entries,
|
|
}))
|
|
}
|
|
|
|
async fn set_repository_config(
|
|
&self,
|
|
request: tonic::Request<SetRepositoryConfigRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.set_repository_config", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), true).await? {
|
|
return client.set_repository_config(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
for entry in &inner.entries {
|
|
if entry.values.is_empty() {
|
|
git_cmd(&gb, &["config", "--unset-all", &entry.key])?;
|
|
} else {
|
|
let _ = git_cmd(
|
|
&gb,
|
|
&["config", "--replace-all", &entry.key, &entry.values[0]],
|
|
);
|
|
for v in entry.values.iter().skip(1) {
|
|
let _ = git_cmd(&gb, &["config", "--add", &entry.key, v]);
|
|
}
|
|
}
|
|
}
|
|
self.notify_ref_update(&repo, "", "", "");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
async fn get_repository_statistics(
|
|
&self,
|
|
request: tonic::Request<RepositoryStatisticsRequest>,
|
|
) -> Result<tonic::Response<RepositoryStatistics>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.get_repository_statistics", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.get_repository_statistics(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
Ok(tonic::Response::new(repository_maint::get_statistics(&gb)))
|
|
}
|
|
|
|
async fn check_repository_health(
|
|
&self,
|
|
request: tonic::Request<RepositoryHealthRequest>,
|
|
) -> Result<tonic::Response<RepositoryHealthResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.check_repository_health", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), false).await? {
|
|
return client.check_repository_health(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = repository_maint::check_health(&gb, inner.connectivity_only)?;
|
|
tracing::info!(%repo, ok = resp.ok, errors = resp.errors.len(), warnings = resp.warnings.len(), "health check done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn garbage_collect(
|
|
&self,
|
|
request: tonic::Request<GarbageCollectRequest>,
|
|
) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.garbage_collect", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), true).await? {
|
|
return client.garbage_collect(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = repository_maint::run_gc(&gb, inner.prune, inner.aggressive)?;
|
|
tracing::info!(%repo, ok = resp.ok, "gc done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn repack(
|
|
&self,
|
|
request: tonic::Request<RepackRequest>,
|
|
) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.repack", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), true).await? {
|
|
return client.repack(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = repository_maint::run_repack(
|
|
&gb,
|
|
inner.full,
|
|
inner.write_bitmaps,
|
|
inner.write_multi_pack_index,
|
|
)?;
|
|
tracing::info!(%repo, ok = resp.ok, "repack done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn write_commit_graph(
|
|
&self,
|
|
request: tonic::Request<WriteCommitGraphRequest>,
|
|
) -> Result<tonic::Response<RepositoryMaintenanceResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.write_commit_graph", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inner.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_repository_client(self, inner.repository.as_ref(), true).await? {
|
|
return client.write_commit_graph(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = repository_maint::run_commit_graph_write(&gb, inner.split, inner.replace)?;
|
|
tracing::info!(%repo, ok = resp.ok, "commit-graph write done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
}
|