zhenyi
d243dce027
- Replaced manual remote client functions with remote_client! macro for archive, blame, branch, commit, and diff services - Simplified remote client creation logic using declarative macro approach - Maintained same functionality while reducing code duplication across services security(bare): enhance path traversal protection with comprehensive validation - Added early relative_path validation to prevent path traversal attacks - Implemented unified path validation to avoid TOCTOU race conditions - Enhanced canonicalization checks for both existing and non-existent paths - Added detailed logging for path traversal detection attempts feat(cache): migrate from CLruCache to Moka with TTL and invalidation support - Replaced clru dependency with moka for improved caching capabilities - Added 300-second time-to-live for cache entries - Implemented repository-specific cache invalidation mechanism - Enhanced cache operations with thread-safe async support refactor(commit): improve security validation for commit operations - Added ref name validation to prevent command injection in cherry_pick_commit - Implemented revision validation for commit selectors - Added comprehensive input validation for create_commit parameters - Enhanced file path validation to prevent traversal
274 lines
11 KiB
Rust
274 lines
11 KiB
Rust
use tokio_stream::StreamExt;
|
|
use tokio_stream::wrappers::ReceiverStream;
|
|
|
|
use crate::pb::pack_service_client::PackServiceClient;
|
|
use crate::pb::*;
|
|
|
|
use super::{GitksService, into_status};
|
|
|
|
remote_client!(remote_pack_client, PackServiceClient<tonic::transport::Channel>, "pack");
|
|
|
|
#[tonic::async_trait]
|
|
impl pack_service_server::PackService for GitksService {
|
|
type UploadPackStream = ReceiverStream<Result<UploadPackResponse, tonic::Status>>;
|
|
type ReceivePackStream = ReceiverStream<Result<ReceivePackResponse, tonic::Status>>;
|
|
type PackObjectsStream = ReceiverStream<Result<PackfileChunk, tonic::Status>>;
|
|
|
|
async fn advertise_refs(
|
|
&self,
|
|
request: tonic::Request<AdvertiseRefsRequest>,
|
|
) -> Result<tonic::Response<AdvertiseRefsResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("pack.advertise_refs", %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_pack_client(self, inner.repository.as_ref(), false).await?
|
|
{
|
|
return client.advertise_refs(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = gb.advertise_refs(inner).map_err(into_status)?;
|
|
tracing::info!(%repo, refs = resp.references.len(), "advertise_refs done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn upload_pack(
|
|
&self,
|
|
request: tonic::Request<tonic::Streaming<UploadPackRequest>>,
|
|
) -> Result<tonic::Response<Self::UploadPackStream>, tonic::Status> {
|
|
let mut stream = request.into_inner();
|
|
let first = stream
|
|
.next()
|
|
.await
|
|
.ok_or_else(|| tonic::Status::invalid_argument("empty upload-pack stream"))??;
|
|
let repo = self.repo_label(first.repository.as_ref());
|
|
let span = tracing::info_span!("pack.upload_pack", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(first.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) =
|
|
remote_pack_client(self, first.repository.as_ref(), false).await?
|
|
{
|
|
let (tx, rx) = tokio::sync::mpsc::channel(16);
|
|
let _ = tx.send(first).await;
|
|
tokio::spawn(async move {
|
|
use tokio_stream::StreamExt;
|
|
while let Some(msg) = stream.next().await {
|
|
match msg {
|
|
Ok(m) => {
|
|
if tx.send(m).await.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
Err(_) => break,
|
|
}
|
|
}
|
|
});
|
|
let resp = client
|
|
.upload_pack(tokio_stream::wrappers::ReceiverStream::new(rx))
|
|
.await?;
|
|
let out = super::bridge_server_stream(resp.into_inner());
|
|
return Ok(tonic::Response::new(out));
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
tracing::info!(%repo, "upload-pack streaming started");
|
|
|
|
let (tx, rx) = tokio::sync::mpsc::channel(16);
|
|
tx.send(Ok(first))
|
|
.await
|
|
.map_err(|_| tonic::Status::internal("channel closed"))?;
|
|
tokio::spawn(async move {
|
|
while let Some(msg) = stream.next().await {
|
|
if tx.send(msg).await.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
let result = gb.upload_pack(ReceiverStream::new(rx)).await?;
|
|
Ok(tonic::Response::new(result))
|
|
}
|
|
|
|
async fn receive_pack(
|
|
&self,
|
|
request: tonic::Request<tonic::Streaming<ReceivePackRequest>>,
|
|
) -> Result<tonic::Response<Self::ReceivePackStream>, tonic::Status> {
|
|
let mut stream = request.into_inner();
|
|
let first = stream
|
|
.next()
|
|
.await
|
|
.ok_or_else(|| tonic::Status::invalid_argument("empty receive-pack stream"))??;
|
|
let repo = self.repo_label(first.repository.as_ref());
|
|
let span = tracing::info_span!("pack.receive_pack", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(first.repository.as_ref()) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) =
|
|
remote_pack_client(self, first.repository.as_ref(), false).await?
|
|
{
|
|
let (tx, rx) = tokio::sync::mpsc::channel(16);
|
|
let _ = tx.send(first).await;
|
|
tokio::spawn(async move {
|
|
use tokio_stream::StreamExt;
|
|
while let Some(msg) = stream.next().await {
|
|
match msg {
|
|
Ok(m) => {
|
|
if tx.send(m).await.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
Err(_) => break,
|
|
}
|
|
}
|
|
});
|
|
let resp = client
|
|
.receive_pack(tokio_stream::wrappers::ReceiverStream::new(rx))
|
|
.await?;
|
|
let out = super::bridge_server_stream(resp.into_inner());
|
|
return Ok(tonic::Response::new(out));
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
tracing::info!(%repo, "receive-pack streaming started");
|
|
|
|
let (tx, rx) = tokio::sync::mpsc::channel(16);
|
|
tx.send(Ok(first))
|
|
.await
|
|
.map_err(|_| tonic::Status::internal("channel closed"))?;
|
|
tokio::spawn(async move {
|
|
while let Some(msg) = stream.next().await {
|
|
if tx.send(msg).await.is_err() {
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
|
|
let result = gb.receive_pack(ReceiverStream::new(rx)).await?;
|
|
Ok(tonic::Response::new(result))
|
|
}
|
|
|
|
async fn pack_objects(
|
|
&self,
|
|
request: tonic::Request<PackObjectsRequest>,
|
|
) -> Result<tonic::Response<Self::PackObjectsStream>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("pack.pack_objects", %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_pack_client(self, inner.repository.as_ref(), false).await?
|
|
{
|
|
let resp = client.pack_objects(inner).await?;
|
|
let stream = super::bridge_server_stream(resp.into_inner());
|
|
return Ok(tonic::Response::new(stream));
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let stream = gb.pack_objects(inner).await?;
|
|
tracing::info!(%repo, "pack-objects streaming started");
|
|
Ok(tonic::Response::new(stream))
|
|
}
|
|
|
|
async fn index_pack(
|
|
&self,
|
|
request: tonic::Request<tonic::Streaming<IndexPackRequest>>,
|
|
) -> Result<tonic::Response<IndexPackResponse>, tonic::Status> {
|
|
let mut stream = request.into_inner();
|
|
let mut inputs = Vec::new();
|
|
while let Some(msg) = stream.next().await {
|
|
inputs.push(msg?);
|
|
}
|
|
let repo = self.repo_label(inputs.first().and_then(|r| r.repository.as_ref()));
|
|
let span = tracing::info_span!("pack.index_pack", %repo);
|
|
let _enter = span.enter();
|
|
let gb = match self.resolve(inputs.first().and_then(|r| r.repository.as_ref())) {
|
|
Ok(gb) => gb,
|
|
Err(err) if err.code() == tonic::Code::NotFound => {
|
|
if let Some(mut client) = remote_pack_client(
|
|
self,
|
|
inputs.first().and_then(|r| r.repository.as_ref()),
|
|
false,
|
|
)
|
|
.await?
|
|
{
|
|
return client.index_pack(tokio_stream::iter(inputs)).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = gb.index_pack(inputs).map_err(into_status)?;
|
|
tracing::info!(%repo, objects = resp.object_count, "index_pack done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn list_packfiles(
|
|
&self,
|
|
request: tonic::Request<ListPackfilesRequest>,
|
|
) -> Result<tonic::Response<ListPackfilesResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("pack.list_packfiles", %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_pack_client(self, inner.repository.as_ref(), false).await?
|
|
{
|
|
return client.list_packfiles(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = gb.list_packfiles(inner).map_err(into_status)?;
|
|
tracing::info!(%repo, count = resp.packfiles.len(), "list_packfiles done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
|
|
async fn fsck(
|
|
&self,
|
|
request: tonic::Request<FsckRequest>,
|
|
) -> Result<tonic::Response<FsckResponse>, tonic::Status> {
|
|
let inner = request.into_inner();
|
|
let repo = self.repo_label(inner.repository.as_ref());
|
|
let span = tracing::info_span!("pack.fsck", %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_pack_client(self, inner.repository.as_ref(), false).await?
|
|
{
|
|
return client.fsck(inner).await;
|
|
}
|
|
return Err(err);
|
|
}
|
|
Err(err) => return Err(err),
|
|
};
|
|
let resp = gb.fsck(inner).map_err(into_status)?;
|
|
tracing::info!(%repo, ok = resp.ok, errors = resp.errors.len(), warnings = resp.warnings.len(), "fsck done");
|
|
Ok(tonic::Response::new(resp))
|
|
}
|
|
}
|