fix rebase master

PKUHPC · Feb 25, 2025 · 4f5bd93 · 4f5bd93
1 parent 0ad2e4f
commit 4f5bd93
Show file tree

Hide file tree

Showing 3 changed files with 42 additions and 15 deletions.
diff --git a/src/CraneCtld/AccountManager.cpp b/src/CraneCtld/AccountManager.cpp
@@ -507,8 +507,30 @@ CraneExpected<void> AccountManager::ModifyAdminLevel(
   return SetUserAdminLevel_(name, new_level);
 }
 
-CraneExpected<void> AccountManager::ModifyUserDefaultQos(
-    uint32_t uid, const std::string& name, const std::string& partition,
+CraneExpected<void> AccountManager::ModifyUserDefaultAccount(
+    uint32_t uid, const std::string& user, const std::string& def_account) {
+  util::write_lock_guard user_guard(m_rw_user_mutex_);
+  CraneExpected<void> result{};
+
+  auto user_result = GetUserInfoByUidNoLock_(uid);
+  if (!user_result) return std::unexpected(user_result.error());
+  const User* op_user = user_result.value();
+
+  const User* user_ptr = GetExistedUserInfoNoLock_(user);
+  if (!user_ptr) return std::unexpected(CraneErrCode::ERR_INVALID_USER);
+
+  result = CheckIfUserHasHigherPrivThan_(*op_user, user_ptr->admin_level);
+  if (!result) return std::unexpected(CraneErrCode::ERR_PERMISSION_USER);
+
+  if (!user_ptr->account_to_attrs_map.contains(def_account))
+    return std::unexpected(CraneErrCode::ERR_USER_ALLOWED_ACCOUNT);
+
+  if (user_ptr->default_account == def_account) return result;
+
+  return SetUserDefaultAccount_(user, def_account);
+}
+
+CraneExpected<void> AccountManager::ModifyUserDefaultQos(    uint32_t uid, const std::string& name, const std::string& partition,
     const std::string& account, const std::string& value) {
   util::write_lock_guard user_guard(m_rw_user_mutex_);
 
@@ -909,15 +931,15 @@ CraneExpected<void> AccountManager::CheckIfUserOfAccountIsEnabled(
   do {
     const Account* account_ptr = GetExistedAccountInfoNoLock_(account_name);
     if (account_ptr->blocked) {
-      CRANE_ERROR("Ancestor account '{}' is blocked", account_ptr->name);
+      CRANE_DEBUG("Ancestor account '{}' is blocked", account_ptr->name);
       return std::unexpected(CraneErrCode::ERR_BLOCKED_ACCOUNT);
     }
     account_name = account_ptr->parent_account;
   } while (!account_name.empty());
 
   const User* user_ptr = GetExistedUserInfoNoLock_(user);
   if (user_ptr->account_to_attrs_map.at(account).blocked) {
-    CRANE_ERROR("User '{}' is blocked", user_ptr->name);
+    CRANE_DEBUG("User '{}' is blocked", user_ptr->name);
     return std::unexpected(CraneErrCode::ERR_BLOCKED_USER);
   }
   return {};
@@ -992,17 +1014,17 @@ CraneExpected<void> AccountManager::CheckAndApplyQosLimitOnTask(
   return {};
 }
 
-std::expected<void, std::string> AccountManager::CheckUidIsAdmin(uint32_t uid) {
+CraneExpected<std::string> AccountManager::CheckUidIsAdmin(uint32_t uid) {
   util::read_lock_guard user_guard(m_rw_user_mutex_);
   auto user_result = GetUserInfoByUidNoLock_(uid);
   if (!user_result) {
-    return std::unexpected("User is not a user of Crane.");
+    return std::unexpected(CraneErrCode::ERR_INVALID_USER);
   }
   const User* user_ptr = user_result.value();
 
   if (user_ptr->admin_level >= User::Operator) return {};
 
-  return std::unexpected("User has insufficient privilege.");
+  return std::unexpected(CraneErrCode::ERR_USER_NO_PRIVILEGE);
 }
 
 CraneExpected<void> AccountManager::CheckIfUidHasPermOnUser(
@@ -1936,7 +1958,7 @@ CraneExpected<void> AccountManager::SetUserAdminLevel_(
   return {};
 }
 
-CraneErrCodeExpected<void> AccountManager::SetUserDefaultAccount_(
+CraneExpected<void> AccountManager::SetUserDefaultAccount_(
     const std::string& user, const std::string& def_account) {
   // Update to database
   mongocxx::client_session::with_transaction_cb callback =
@@ -1954,7 +1976,7 @@ CraneErrCodeExpected<void> AccountManager::SetUserDefaultAccount_(
   return {};
 }
 
-CraneErrCodeExpected<void> AccountManager::SetUserDefaultQos_(
+CraneExpected<void> AccountManager::SetUserDefaultQos_(
     const User& user, const std::string& account, const std::string& partition,
     const std::string& qos) {
   const std::string& name = user.name;

diff --git a/src/CraneCtld/AccountManager.h b/src/CraneCtld/AccountManager.h
@@ -135,7 +135,7 @@ class AccountManager {
                                        const std::string& account,
                                        TaskInCtld* task);
 
-  std::expected<void, std::string> CheckUidIsAdmin(uint32_t uid);
+  CraneExpected<std::string> CheckUidIsAdmin(uint32_t uid);
 
   CraneExpected<void> CheckIfUidHasPermOnUser(uint32_t uid,
                                               const std::string& username,
@@ -263,13 +263,10 @@ class AccountManager {
 
   CraneExpected<void> SetUserAdminLevel_(const std::string& name,
                                          User::AdminLevel new_level);
-<<<<<<< HEAD
 
   CraneExpected<void> SetUserDefaultAccount_(const std::string& user,
                                              const std::string& def_account);
 
-=======
->>>>>>> 58e20be (del craneErr)
   CraneExpected<void> SetUserDefaultQos_(const User& user,
                                          const std::string& account,
                                          const std::string& partition,

diff --git a/src/CraneCtld/CtldGrpcServer.cpp b/src/CraneCtld/CtldGrpcServer.cpp
@@ -155,7 +155,11 @@ grpc::Status CraneCtldServiceImpl::ModifyTask(
   if (!res) {
     for (auto task_id : request->task_ids()) {
       response->add_not_modified_tasks(task_id);
-      response->add_not_modified_reasons(res.error());
+      if (res.error() == CraneErrCode::ERR_INVALID_USER) {
+        response->add_not_modified_reasons("User is not a user of Crane");
+      } else if (res.error() == CraneErrCode::ERR_USER_NO_PRIVILEGE) {
+        response->add_not_modified_reasons("User has insufficient privilege");
+      }
     }
     return grpc::Status::OK;
   }
@@ -237,7 +241,11 @@ grpc::Status CraneCtldServiceImpl::ModifyNode(
   if (!res) {
     for (auto crane_id : request->craned_ids()) {
       response->add_not_modified_nodes(crane_id);
-      response->add_not_modified_reasons(res.error());
+      if (res.error() == CraneErrCode::ERR_INVALID_USER) {
+        response->add_not_modified_reasons("User is not a user of Crane");
+      } else if (res.error() == CraneErrCode::ERR_USER_NO_PRIVILEGE) {
+        response->add_not_modified_reasons("User has insufficient privilege");
+      }
     }
     return grpc::Status::OK;
   }