eba4fd1
use tonic::{Request, Response, Status};
use crate::proto as pb;
use crate::proto::admin_server::Admin;
use crate::service::AdminRpc;
#[tonic::async_trait]
impl Admin for AdminRpc {
async fn system_status(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::SystemStatus>, Status> {
crate::service::system::system_status(self, request).await
}
async fn system_config(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::SystemConfig>, Status> {
crate::service::system::system_config(self, request).await
}
async fn dashboard(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::Dashboard>, Status> {
crate::service::system::dashboard(self, request).await
}
async fn list_repos(
&self,
request: Request<pb::ListReposRequest>,
) -> Result<Response<pb::RepoPage>, Status> {
crate::service::repos::list_repos(self, request).await
}
async fn get_repo(
&self,
request: Request<pb::GetRepoRequest>,
) -> Result<Response<pb::Repo>, Status> {
crate::service::repos::get_repo(self, request).await
}
async fn update_repo(
&self,
request: Request<pb::UpdateRepoRequest>,
) -> Result<Response<pb::Repo>, Status> {
crate::service::repos::update_repo(self, request).await
}
async fn list_mcp_tools(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::McpToolList>, Status> {
crate::service::mcp::list_mcp_tools(self, request).await
}
async fn update_mcp_tool(
&self,
request: Request<pb::UpdateMcpToolRequest>,
) -> Result<Response<pb::McpTool>, Status> {
crate::service::mcp::update_mcp_tool(self, request).await
}
async fn get_act_summary(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::ActSummary>, Status> {
crate::service::act::get_act_summary(self, request).await
}
async fn list_act_runs(
&self,
request: Request<pb::ListActRunsRequest>,
) -> Result<Response<pb::ActRunPage>, Status> {
crate::service::act::list_act_runs(self, request).await
}
async fn cancel_act_run(
&self,
request: Request<pb::CancelActRunRequest>,
) -> Result<Response<pb::ActRunRef>, Status> {
crate::service::act::cancel_act_run(self, request).await
}
async fn rerun_act_run(
&self,
request: Request<pb::RerunActRunRequest>,
) -> Result<Response<pb::ActRunRef>, Status> {
crate::service::act::rerun_act_run(self, request).await
}
async fn get_storage_overview(
&self,
request: Request<pb::GetStorageOverviewRequest>,
) -> Result<Response<pb::StorageOverview>, Status> {
crate::service::storage::get_storage_overview(self, request).await
}
async fn list_storage_objects(
&self,
request: Request<pb::ListStorageObjectsRequest>,
) -> Result<Response<pb::StorageObjectPage>, Status> {
crate::service::storage::list_storage_objects(self, request).await
}
async fn get_storage_download_url(
&self,
request: Request<pb::GetStorageDownloadUrlRequest>,
) -> Result<Response<pb::DownloadUrl>, Status> {
crate::service::storage::get_storage_download_url(self, request).await
}
async fn delete_storage_object(
&self,
request: Request<pb::DeleteStorageObjectRequest>,
) -> Result<Response<pb::DeleteObjectResp>, Status> {
crate::service::storage::delete_storage_object(self, request).await
}
async fn list_queues(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::QueueList>, Status> {
crate::service::queues::list_queues(self, request).await
}
async fn list_queue_failed_jobs(
&self,
request: Request<pb::ListQueueFailedJobsRequest>,
) -> Result<Response<pb::JobLogPage>, Status> {
crate::service::queues::list_queue_failed_jobs(self, request).await
}
async fn requeue_queue_failed(
&self,
request: Request<pb::RequeueQueueFailedRequest>,
) -> Result<Response<pb::QueueActionResp>, Status> {
crate::service::queues::requeue_queue_failed(self, request).await
}
async fn purge_queue(
&self,
request: Request<pb::PurgeQueueRequest>,
) -> Result<Response<pb::QueueActionResp>, Status> {
crate::service::queues::purge_queue(self, request).await
}
async fn list_job_logs(
&self,
request: Request<pb::ListJobLogsRequest>,
) -> Result<Response<pb::JobLogPage>, Status> {
crate::service::logs::list_job_logs(self, request).await
}
async fn list_users(
&self,
request: Request<pb::ListUsersRequest>,
) -> Result<Response<pb::AdminUserPage>, Status> {
crate::service::users::list_users(self, request).await
}
async fn create_user(
&self,
request: Request<pb::CreateUserRequest>,
) -> Result<Response<pb::CreateUserResp>, Status> {
crate::service::users::create_user(self, request).await
}
async fn get_user(
&self,
request: Request<pb::GetUserRequest>,
) -> Result<Response<pb::AdminUserDetail>, Status> {
crate::service::users::get_user(self, request).await
}
async fn update_user(
&self,
request: Request<pb::UpdateUserRequest>,
) -> Result<Response<pb::AdminUser>, Status> {
crate::service::users::update_user(self, request).await
}
async fn delete_user(
&self,
request: Request<pb::DeleteUserRequest>,
) -> Result<Response<pb::DeleteUserResp>, Status> {
crate::service::users::delete_user(self, request).await
}
async fn suspend_user(
&self,
request: Request<pb::SuspendUserRequest>,
) -> Result<Response<pb::AdminSuspension>, Status> {
crate::service::users::suspend_user(self, request).await
}
async fn revoke_suspension(
&self,
request: Request<pb::RevokeSuspensionRequest>,
) -> Result<Response<pb::Empty>, Status> {
crate::service::users::revoke_suspension(self, request).await
}
async fn reset_user_password(
&self,
request: Request<pb::ResetUserPasswordRequest>,
) -> Result<Response<pb::Empty>, Status> {
crate::service::users::reset_user_password(self, request).await
}
async fn revoke_user_sessions(
&self,
request: Request<pb::RevokeUserSessionsRequest>,
) -> Result<Response<pb::RevokeSessionsResp>, Status> {
crate::service::users::revoke_user_sessions(self, request).await
}
async fn list_user_sessions(
&self,
request: Request<pb::ListUserSessionsRequest>,
) -> Result<Response<pb::AdminUserSessionPage>, Status> {
crate::service::users::list_user_sessions(self, request).await
}
async fn revoke_user_session(
&self,
request: Request<pb::RevokeUserSessionRequest>,
) -> Result<Response<pb::Empty>, Status> {
crate::service::users::revoke_user_session(self, request).await
}
async fn get_user_security(
&self,
request: Request<pb::GetUserSecurityRequest>,
) -> Result<Response<pb::AdminUserSecurity>, Status> {
crate::service::users::get_user_security(self, request).await
}
async fn clear_user_two_factor(
&self,
request: Request<pb::ClearUserTwoFactorRequest>,
) -> Result<Response<pb::Empty>, Status> {
crate::service::users::clear_user_two_factor(self, request).await
}
async fn bulk_users(
&self,
request: Request<pb::BulkUsersRequest>,
) -> Result<Response<pb::BulkUsersResp>, Status> {
crate::service::users::bulk_users(self, request).await
}
async fn export_users(
&self,
request: Request<pb::ExportUsersRequest>,
) -> Result<Response<pb::ExportUsersResp>, Status> {
crate::service::users::export_users(self, request).await
}
async fn list_spaces(
&self,
request: Request<pb::ListSpacesRequest>,
) -> Result<Response<pb::AdminSpacePage>, Status> {
crate::service::spaces::list_spaces(self, request).await
}
async fn get_space(
&self,
request: Request<pb::GetSpaceRequest>,
) -> Result<Response<pb::AdminSpaceDetail>, Status> {
crate::service::spaces::get_space(self, request).await
}
async fn update_space(
&self,
request: Request<pb::UpdateSpaceRequest>,
) -> Result<Response<pb::AdminSpaceDetail>, Status> {
crate::service::spaces::update_space(self, request).await
}
async fn transfer_space(
&self,
request: Request<pb::TransferSpaceRequest>,
) -> Result<Response<pb::AdminSpaceDetail>, Status> {
crate::service::spaces::transfer_space(self, request).await
}
async fn delete_space(
&self,
request: Request<pb::DeleteSpaceRequest>,
) -> Result<Response<pb::Empty>, Status> {
crate::service::spaces::delete_space(self, request).await
}
async fn list_space_members(
&self,
request: Request<pb::ListSpaceMembersRequest>,
) -> Result<Response<pb::AdminSpaceMemberPage>, Status> {
crate::service::spaces::list_space_members(self, request).await
}
async fn add_space_member(
&self,
request: Request<pb::AddSpaceMemberRequest>,
) -> Result<Response<pb::AddSpaceMemberResp>, Status> {
crate::service::spaces::add_space_member(self, request).await
}
async fn remove_space_member(
&self,
request: Request<pb::RemoveSpaceMemberRequest>,
) -> Result<Response<pb::RemoveSpaceMemberResp>, Status> {
crate::service::spaces::remove_space_member(self, request).await
}
async fn list_tasks(
&self,
request: Request<pb::ListTasksRequest>,
) -> Result<Response<pb::TaskPage>, Status> {
crate::service::tasks::list_tasks(self, request).await
}
async fn get_task(
&self,
request: Request<pb::GetTaskRequest>,
) -> Result<Response<pb::TaskDetail>, Status> {
crate::service::tasks::get_task(self, request).await
}
async fn retry_task(
&self,
request: Request<pb::RetryTaskRequest>,
) -> Result<Response<pb::TaskActionResp>, Status> {
crate::service::tasks::retry_task(self, request).await
}
async fn cancel_task(
&self,
request: Request<pb::CancelTaskRequest>,
) -> Result<Response<pb::TaskActionResp>, Status> {
crate::service::tasks::cancel_task(self, request).await
}
async fn delete_task(
&self,
request: Request<pb::DeleteTaskRequest>,
) -> Result<Response<pb::Empty>, Status> {
crate::service::tasks::delete_task(self, request).await
}
async fn get_task_stats(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::TaskStats>, Status> {
crate::service::tasks::get_task_stats(self, request).await
}
async fn bulk_tasks(
&self,
request: Request<pb::BulkTasksRequest>,
) -> Result<Response<pb::BulkTasksResp>, Status> {
crate::service::tasks::bulk_tasks(self, request).await
}
async fn list_runners(
&self,
request: Request<pb::ListRunnersRequest>,
) -> Result<Response<pb::RunnerPage>, Status> {
crate::service::runners::list_runners(self, request).await
}
async fn update_runner(
&self,
request: Request<pb::UpdateRunnerRequest>,
) -> Result<Response<pb::Runner>, Status> {
crate::service::runners::update_runner(self, request).await
}
async fn delete_runner(
&self,
request: Request<pb::DeleteRunnerRequest>,
) -> Result<Response<pb::RunnerList>, Status> {
crate::service::runners::delete_runner(self, request).await
}
async fn list_runner_tokens(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::RunnerTokenList>, Status> {
crate::service::runners::list_runner_tokens(self, request).await
}
async fn create_runner_token(
&self,
request: Request<pb::CreateRunnerTokenRequest>,
) -> Result<Response<pb::CreatedRunnerToken>, Status> {
crate::service::runners::create_runner_token(self, request).await
}
async fn revoke_runner_token(
&self,
request: Request<pb::RevokeRunnerTokenRequest>,
) -> Result<Response<pb::RunnerTokenList>, Status> {
crate::service::runners::revoke_runner_token(self, request).await
}
async fn list_environments(
&self,
request: Request<pb::ListEnvironmentsRequest>,
) -> Result<Response<pb::EnvironmentAdminList>, Status> {
crate::service::runners::list_environments(self, request).await
}
async fn upsert_environment(
&self,
request: Request<pb::UpsertEnvironmentRequest>,
) -> Result<Response<pb::EnvironmentAdmin>, Status> {
crate::service::runners::upsert_environment(self, request).await
}
async fn delete_environment(
&self,
request: Request<pb::DeleteEnvironmentRequest>,
) -> Result<Response<pb::EnvironmentAdminList>, Status> {
crate::service::runners::delete_environment(self, request).await
}
async fn upsert_environment_secret(
&self,
request: Request<pb::UpsertEnvironmentSecretRequest>,
) -> Result<Response<pb::EnvironmentAdminList>, Status> {
crate::service::runners::upsert_environment_secret(self, request).await
}
async fn delete_environment_secret(
&self,
request: Request<pb::DeleteEnvironmentSecretRequest>,
) -> Result<Response<pb::EnvironmentAdminList>, Status> {
crate::service::runners::delete_environment_secret(self, request).await
}
async fn get_chat_stats(
&self,
request: Request<pb::Empty>,
) -> Result<Response<pb::AdminChatStats>, Status> {
crate::service::chat::get_chat_stats(self, request).await
}
async fn list_chat_rooms(
&self,
request: Request<pb::ListChatRoomsRequest>,
) -> Result<Response<pb::AdminChatRoomPage>, Status> {
crate::service::chat::list_chat_rooms(self, request).await
}
async fn get_chat_room(
&self,
request: Request<pb::GetChatRoomRequest>,
) -> Result<Response<pb::AdminChatRoomDetail>, Status> {
crate::service::chat::get_chat_room(self, request).await
}
async fn update_chat_room(
&self,
request: Request<pb::UpdateChatRoomRequest>,
) -> Result<Response<pb::AdminChatRoomDetail>, Status> {
crate::service::chat::update_chat_room(self, request).await
}
async fn delete_chat_room(
&self,
request: Request<pb::DeleteChatRoomRequest>,
) -> Result<Response<pb::DeleteChatRoomResp>, Status> {
crate::service::chat::delete_chat_room(self, request).await
}
async fn list_chat_room_members(
&self,
request: Request<pb::ListChatRoomMembersRequest>,
) -> Result<Response<pb::AdminChatRoomMemberPage>, Status> {
crate::service::chat::list_chat_room_members(self, request).await
}
async fn remove_chat_room_member(
&self,
request: Request<pb::RemoveChatRoomMemberRequest>,
) -> Result<Response<pb::RemoveChatMemberResp>, Status> {
crate::service::chat::remove_chat_room_member(self, request).await
}
async fn purge_chat_room(
&self,
request: Request<pb::PurgeChatRoomRequest>,
) -> Result<Response<pb::PurgeChatMessagesResp>, Status> {
crate::service::chat::purge_chat_room(self, request).await
}
async fn list_chat_messages(
&self,
request: Request<pb::ListChatMessagesRequest>,
) -> Result<Response<pb::AdminChatMessagePage>, Status> {
crate::service::chat::list_chat_messages(self, request).await
}
async fn export_chat_messages(
&self,
request: Request<pb::ExportChatMessagesRequest>,
) -> Result<Response<pb::ExportChatMessagesResp>, Status> {
crate::service::chat::export_chat_messages(self, request).await
}
async fn get_chat_message(
&self,
request: Request<pb::GetChatMessageRequest>,
) -> Result<Response<pb::AdminChatMessageDetail>, Status> {
crate::service::chat::get_chat_message(self, request).await
}
async fn bulk_delete_chat_messages(
&self,
request: Request<pb::BulkDeleteChatMessagesRequest>,
) -> Result<Response<pb::BulkDeleteChatMessagesResp>, Status> {
crate::service::chat::bulk_delete_chat_messages(self, request).await
}
async fn list_chat_attachments(
&self,
request: Request<pb::ListChatAttachmentsRequest>,
) -> Result<Response<pb::AdminChatAttachmentPage>, Status> {
crate::service::chat::list_chat_attachments(self, request).await
}
async fn delete_chat_attachment(
&self,
request: Request<pb::DeleteChatAttachmentRequest>,
) -> Result<Response<pb::DeleteChatAttachmentResp>, Status> {
crate::service::chat::delete_chat_attachment(self, request).await
}
}