zhenyi
9a0c26e5f6
- Add voting mechanism with term tracking and vote persistence - Implement election triggering logic with majority vote counting - Add primary/replica role transition handling with state management - Integrate health check failure detection for automatic elections - Refactor actor messaging system for distributed coordination - Update repository registration to query cluster for existing primary - Add broadcast mechanism for role change notifications - Implement proper term comparison and duplicate request filtering - Upgrade dependency versions including tokio-util for async utilities - Optimize code formatting and line wrapping for improved readability - Remove redundant blank lines and improve code structure consistency - Enhance error logging and trace information for debugging purposes
854 lines
35 KiB
Rust
854 lines
35 KiB
Rust
use crate::pb::repository_service_client::RepositoryServiceClient;
|
|
use crate::pb::*;
|
|
|
|
use super::{GitksService, git_cmd, into_status, repository_maint};
|
|
use tokio_stream::wrappers::ReceiverStream;
|
|
|
|
remote_client!(
|
|
remote_repository_client,
|
|
RepositoryServiceClient<tonic::transport::Channel>,
|
|
"repository"
|
|
);
|
|
|
|
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 m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/GetRepository");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
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?
|
|
{
|
|
m.record("ok");
|
|
return client.get_repository(inner).await;
|
|
}
|
|
crate::metrics::record_rpc_error(&m, &err);
|
|
return Err(err);
|
|
}
|
|
Err(err) => {
|
|
crate::metrics::record_rpc_error(&m, &err);
|
|
return Err(err);
|
|
}
|
|
};
|
|
let bare = gb.bare_dir.join("HEAD").exists();
|
|
let object_format = gb.object_format();
|
|
m.record("ok");
|
|
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 m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/InitRepository");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
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)?;
|
|
if let Some(ref hm) = self.hook_manager {
|
|
hm.install_hooks(&gb.bare_dir).map_err(into_status)?;
|
|
}
|
|
tracing::info!(%repo, bare = inner.bare, "repository initialized");
|
|
self.notify_ref_update(&repo, "HEAD", "", "");
|
|
m.record("ok");
|
|
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 m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/DeleteRepository");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
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()
|
|
&& let Some(mut client) =
|
|
remote_repository_client(self, inner.repository.as_ref(), true).await?
|
|
{
|
|
m.record("ok");
|
|
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, "", "", "");
|
|
crate::rate_limit::remove_repository(&repo);
|
|
m.record("ok");
|
|
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
|
|
&& 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);
|
|
git_cmd(&gb, &["symbolic-ref", "HEAD", &refname])?;
|
|
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"])?;
|
|
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 {
|
|
crate::sanitize::validate_config_key(key)
|
|
.map_err(|e| tonic::Status::invalid_argument(e.to_string()))?;
|
|
let out = git_cmd(&gb, &["config", "--get-all", key])?;
|
|
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 {
|
|
crate::sanitize::validate_config_key(&entry.key)
|
|
.map_err(|e| tonic::Status::invalid_argument(e.to_string()))?;
|
|
if entry.values.is_empty() {
|
|
git_cmd(&gb, &["config", "--unset-all", &entry.key])?;
|
|
} else {
|
|
git_cmd(
|
|
&gb,
|
|
&["config", "--replace-all", &entry.key, &entry.values[0]],
|
|
)?;
|
|
for v in entry.values.iter().skip(1) {
|
|
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))
|
|
}
|
|
|
|
async fn list_hooks(
|
|
&self,
|
|
request: tonic::Request<ListHooksRequest>,
|
|
) -> Result<tonic::Response<ListHooksResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let hook_mgr = self.hook_manager.as_ref();
|
|
let hooks = if let Some(hm) = hook_mgr {
|
|
hm.list_hooks(&gb.bare_dir)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
let resp = ListHooksResponse {
|
|
hooks: hooks
|
|
.into_iter()
|
|
.map(|h| crate::pb::HookInfo {
|
|
hook_type: h.hook_type,
|
|
level: h.level.to_string(),
|
|
path: h.path,
|
|
})
|
|
.collect(),
|
|
};
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn set_custom_hook(
|
|
&self,
|
|
request: tonic::Request<SetCustomHookRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let hook_mgr = self.hook_manager.as_ref();
|
|
if let Some(hm) = hook_mgr {
|
|
hm.set_custom_hook(&gb.bare_dir, &inner.hook_name, &inner.content)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
} else {
|
|
return Err(tonic::Status::failed_precondition("hooks not enabled"));
|
|
}
|
|
tracing::info!(repo = %gb.bare_dir.display(), hook = %inner.hook_name, "custom hook set");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
async fn remove_custom_hook(
|
|
&self,
|
|
request: tonic::Request<RemoveCustomHookRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let hook_mgr = self.hook_manager.as_ref();
|
|
if let Some(hm) = hook_mgr {
|
|
hm.remove_custom_hook(&gb.bare_dir, &inner.hook_name)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
} else {
|
|
return Err(tonic::Status::failed_precondition("hooks not enabled"));
|
|
}
|
|
tracing::info!(repo = %gb.bare_dir.display(), hook = %inner.hook_name, "custom hook removed");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
async fn create_snapshot(
|
|
&self,
|
|
request: tonic::Request<CreateSnapshotRequest>,
|
|
) -> Result<tonic::Response<CreateSnapshotResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.create_snapshot", %repo);
|
|
let _enter = span.enter();
|
|
|
|
let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
|
|
self.repo_prefix.join("+gitks-snapshots"),
|
|
);
|
|
let snapshot_id = crate::snapshot::ops::create_and_store_snapshot(&gb, &repo, &storage)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
let head_oid = crate::snapshot::ops::get_head_oid_internal(&gb)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
use crate::snapshot::storage::SnapshotStorageBackend;
|
|
let actual_size = storage
|
|
.read_snapshot(&snapshot_id)
|
|
.map(|d| d.len() as u64)
|
|
.unwrap_or(0);
|
|
|
|
tracing::info!(%repo, snapshot_id = %snapshot_id, size_bytes = actual_size, "snapshot created");
|
|
Ok(tonic::Response::new(CreateSnapshotResponse {
|
|
snapshot_id,
|
|
size_bytes: actual_size,
|
|
head_oid,
|
|
}))
|
|
}
|
|
|
|
async fn restore_snapshot(
|
|
&self,
|
|
request: tonic::Request<RestoreSnapshotRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let target_repo = self.repo_label(inner.target_repository.as_ref());
|
|
let span = tracing::info_span!("repo.restore_snapshot", %target_repo);
|
|
let _enter = span.enter();
|
|
|
|
let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
|
|
self.repo_prefix.join("+gitks-snapshots"),
|
|
);
|
|
|
|
let target_path = self.resolve_for_init(inner.target_repository.as_ref())?;
|
|
|
|
crate::snapshot::ops::restore_from_storage(&target_path, &inner.snapshot_id, &storage)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
tracing::info!(%target_repo, snapshot_id = %inner.snapshot_id, "snapshot restored");
|
|
self.notify_ref_update(&target_repo, "HEAD", "", "");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
async fn list_snapshots(
|
|
&self,
|
|
request: tonic::Request<ListSnapshotsRequest>,
|
|
) -> Result<tonic::Response<ListSnapshotsResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
|
|
let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
|
|
self.repo_prefix.join("+gitks-snapshots"),
|
|
);
|
|
use crate::snapshot::storage::SnapshotStorageBackend;
|
|
let snapshots = storage
|
|
.list_snapshots(&repo)
|
|
.map_err(tonic::Status::internal)?;
|
|
|
|
let resp = ListSnapshotsResponse {
|
|
snapshots: snapshots
|
|
.into_iter()
|
|
.map(|s| crate::pb::SnapshotInfo {
|
|
snapshot_id: s.snapshot_id,
|
|
relative_path: s.relative_path,
|
|
size_bytes: s.size_bytes,
|
|
created_at: s.created_at,
|
|
head_oid: s.head_oid,
|
|
})
|
|
.collect(),
|
|
};
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn delete_snapshot(
|
|
&self,
|
|
request: tonic::Request<DeleteSnapshotRequest>,
|
|
) -> Result<tonic::Response<()>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
|
|
let storage = crate::snapshot::storage::LocalSnapshotStorage::new(
|
|
self.repo_prefix.join("+gitks-snapshots"),
|
|
);
|
|
use crate::snapshot::storage::SnapshotStorageBackend;
|
|
storage
|
|
.delete_snapshot(&inner.snapshot_id)
|
|
.map_err(tonic::Status::internal)?;
|
|
|
|
tracing::info!(snapshot_id = %inner.snapshot_id, "snapshot deleted");
|
|
Ok(tonic::Response::new(()))
|
|
}
|
|
|
|
type FetchRepositoryDataStream =
|
|
ReceiverStream<Result<FetchRepositoryDataResponse, tonic::Status>>;
|
|
|
|
async fn move_repository(
|
|
&self,
|
|
request: tonic::Request<MoveRepositoryRequest>,
|
|
) -> Result<tonic::Response<MoveRepositoryResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let source_repo = self.repo_label(inner.source_repository.as_ref());
|
|
let span = tracing::info_span!("repo.move_repository", %source_repo);
|
|
let _enter = span.enter();
|
|
|
|
let gb = self.resolve(inner.source_repository.as_ref())?;
|
|
|
|
let target_path = self.resolve_for_init(inner.target_repository.as_ref())?;
|
|
// Prevent accidental self-move that would destroy the source repository.
|
|
if target_path == gb.bare_dir {
|
|
return Err(tonic::Status::invalid_argument(
|
|
"source and target repository paths are the same",
|
|
));
|
|
}
|
|
|
|
let bundle_data = crate::snapshot::ops::create_snapshot(&gb)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
let target_gb = crate::bare::GitBare::new(target_path.clone());
|
|
target_gb
|
|
.init_repository(true)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
crate::snapshot::ops::restore_snapshot(&target_path, &bundle_data)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
if let Some(ref hm) = self.hook_manager {
|
|
hm.install_hooks(&target_path)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
}
|
|
|
|
let source_path = gb.bare_dir.clone();
|
|
std::fs::remove_dir_all(&source_path)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
self.notify_ref_update(&source_repo, "HEAD", "", "");
|
|
|
|
tracing::info!(source = %source_repo, "repository moved successfully");
|
|
Ok(tonic::Response::new(MoveRepositoryResponse {
|
|
state: MoveRepositoryState::MoveStateCompleted as i32,
|
|
error_message: String::new(),
|
|
}))
|
|
}
|
|
|
|
async fn fetch_repository_data(
|
|
&self,
|
|
request: tonic::Request<FetchRepositoryDataRequest>,
|
|
) -> Result<tonic::Response<Self::FetchRepositoryDataStream>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("repo.fetch_repository_data", %repo);
|
|
let _enter = span.enter();
|
|
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let bundle_data = crate::snapshot::ops::create_snapshot(&gb)
|
|
.map_err(|e| tonic::Status::internal(e.to_string()))?;
|
|
|
|
let (tx, rx) = tokio::sync::mpsc::channel(16);
|
|
tokio::spawn(async move {
|
|
const CHUNK_SIZE: usize = 65536;
|
|
let total = bundle_data.len();
|
|
if total == 0 {
|
|
let _ = tx
|
|
.send(Ok(FetchRepositoryDataResponse {
|
|
data: vec![],
|
|
done: true,
|
|
}))
|
|
.await;
|
|
return;
|
|
}
|
|
for offset in (0..total).step_by(CHUNK_SIZE) {
|
|
let end = (offset + CHUNK_SIZE).min(total);
|
|
let chunk_data = bundle_data[offset..end].to_vec();
|
|
let is_done = end >= total;
|
|
if tx
|
|
.send(Ok(FetchRepositoryDataResponse {
|
|
data: chunk_data,
|
|
done: is_done,
|
|
}))
|
|
.await
|
|
.is_err()
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
Ok(tonic::Response::new(ReceiverStream::new(rx)))
|
|
}
|
|
|
|
async fn find_merge_base(
|
|
&self,
|
|
request: tonic::Request<FindMergeBaseRequest>,
|
|
) -> Result<tonic::Response<FindMergeBaseResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/FindMergeBase");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.find_merge_base(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn write_ref(
|
|
&self,
|
|
request: tonic::Request<WriteRefRequest>,
|
|
) -> Result<tonic::Response<WriteRefResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/WriteRef");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.write_ref(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn search_files_by_content(
|
|
&self,
|
|
request: tonic::Request<SearchFilesByContentRequest>,
|
|
) -> Result<tonic::Response<SearchFilesByContentResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/SearchFilesByContent");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.search_files_by_content(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn search_files_by_name(
|
|
&self,
|
|
request: tonic::Request<SearchFilesByNameRequest>,
|
|
) -> Result<tonic::Response<SearchFilesByNameResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/SearchFilesByName");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.search_files_by_name(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn objects_size(
|
|
&self,
|
|
request: tonic::Request<ObjectsSizeRequest>,
|
|
) -> Result<tonic::Response<ObjectsSizeResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/ObjectsSize");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.objects_size(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn repository_size(
|
|
&self,
|
|
request: tonic::Request<RepositorySizeRequest>,
|
|
) -> Result<tonic::Response<RepositorySizeResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/RepositorySize");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.repository_size().map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn fetch_remote(
|
|
&self,
|
|
request: tonic::Request<FetchRemoteRequest>,
|
|
) -> Result<tonic::Response<FetchRemoteResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/FetchRemote");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.fetch_remote(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn create_repository_from_url(
|
|
&self,
|
|
request: tonic::Request<CreateRepositoryFromUrlRequest>,
|
|
) -> Result<tonic::Response<CreateRepositoryFromUrlResponse>, tonic::Status> {
|
|
let m =
|
|
crate::metrics::RequestMetrics::new("gitks.RepositoryService/CreateRepositoryFromURL");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let bare_dir = self.resolve_for_init(inner.repository.as_ref())?;
|
|
let gb = crate::bare::GitBare::new(bare_dir);
|
|
gb.create_repository_from_url(&inner.remote_url, inner.mirror)
|
|
.map_err(into_status)?;
|
|
if let Some(ref hm) = self.hook_manager {
|
|
hm.install_hooks(&gb.bare_dir).map_err(into_status)?;
|
|
}
|
|
self.notify_ref_update(&self.repo_label(inner.repository.as_ref()), "HEAD", "", "");
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(CreateRepositoryFromUrlResponse {
|
|
repository: Some(Repository {
|
|
header: inner.repository,
|
|
bare: true,
|
|
..Default::default()
|
|
}),
|
|
}))
|
|
}
|
|
|
|
async fn find_license(
|
|
&self,
|
|
request: tonic::Request<FindLicenseRequest>,
|
|
) -> Result<tonic::Response<FindLicenseResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/FindLicense");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.find_license().map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn optimize_repository(
|
|
&self,
|
|
request: tonic::Request<OptimizeRepositoryRequest>,
|
|
) -> Result<tonic::Response<OptimizeRepositoryResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/OptimizeRepository");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.optimize_repository(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn get_raw_changes(
|
|
&self,
|
|
request: tonic::Request<GetRawChangesRequest>,
|
|
) -> Result<tonic::Response<GetRawChangesResponse>, tonic::Status> {
|
|
let m = crate::metrics::RequestMetrics::new("gitks.RepositoryService/GetRawChanges");
|
|
let inner = request.into_inner();
|
|
let _rate = self.acquire_rate_limit(inner.repository.as_ref()).await?;
|
|
let gb = self.resolve(inner.repository.as_ref())?;
|
|
let resp = gb.get_raw_changes(inner).map_err(into_status)?;
|
|
m.record("ok");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
}
|