diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/RequestChannelNotifier.java b/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/RequestChannelNotifier.java index aa8af321..6d5c30b8 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/RequestChannelNotifier.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/alarm/service/RequestChannelNotifier.java @@ -167,8 +167,8 @@ public void sendContainerCreatedNotification(Request request, String sshPort, St image == null ? "-" : SlackText.line(image.getImageName() + ":" + image.getImageVersion()), // {6} serverProfileRegistry.publicPort(serverName, sshPort), // {7} serverProfileRegistry.publicPort(serverName, jupyterPort), // {8} - String.valueOf(user.getUbuntuUid()), // {9} - String.valueOf(user.getUbuntuGid())); // {10} + String.valueOf(request.getUbuntuUid()), // {9} + String.valueOf(request.getUbuntuGid())); // {10} replyToRequest(message, requestChannel(request, serverName), request.getSlackMessageTs()); }); } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/home/entity/HomeCleanup.java b/src/main/java/DGU_AI_LAB/admin_be/domain/home/entity/HomeCleanup.java index 6af6fa41..d786983d 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/home/entity/HomeCleanup.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/home/entity/HomeCleanup.java @@ -66,7 +66,7 @@ public class HomeCleanup extends BaseTimeEntity { private HomeCleanup(User user, LocalDateTime lastContainerEndedAt) { this.user = user; - this.ubuntuUsername = user.getUbuntuUsername(); + this.ubuntuUsername = user.ubuntuUsernameOn(User.PRIMARY_SERVER); this.ubuntuUid = user.getUbuntuUid(); this.lastContainerEndedAt = lastContainerEndedAt; } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupService.java index 26c1d897..0c4333c9 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupService.java @@ -50,10 +50,11 @@ static Target of(HomeCleanup cleanup) { @Transactional public Optional begin(Long userId, LocalDateTime now) { User user = userRepository.findByIdForUpdate(userId).orElseThrow(); - if (user.getUbuntuUsername() == null || user.getUbuntuUid() == null || user.hasOpenRequest()) { + if (user.getUbuntuUsername() == null || user.getUbuntuUid() == null + || user.hasOpenRequest(User.PRIMARY_SERVER)) { return Optional.empty(); } - Optional endedAt = user.lastContainerEndedAt() + Optional endedAt = user.lastContainerEndedAt(User.PRIMARY_SERVER) .filter(ended -> ended.isBefore(retentionPolicy.deletableEndedBefore(now))); if (endedAt.isEmpty() || cleanupRepository.existsByUser_UserIdAndStatusInAndLastContainerEndedAtGreaterThanEqual( userId, SETTLED_OR_RUNNING, endedAt.get())) { diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRows.java b/src/main/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRows.java index 83fcb0ff..d2129ae2 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRows.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRows.java @@ -53,13 +53,13 @@ private static List row(Request request, List ports, LocalDate h return List.of( text(request.getRequestId()), text(user.getName()), - text(user.getUbuntuUsername()), + text(request.getUbuntuUsername()), user.getUserGroups().stream() .map(userGroup -> userGroup.getGroup().getGroupName()) .sorted().collect(Collectors.joining(", ")), text(request.getNodeName()), - text(user.getUbuntuUid()), - text(user.getUbuntuGid()), + text(request.getUbuntuUid()), + text(request.getUbuntuGid()), String.join(", ", ports), date(request.getExpiresAt()), text(homeDeletionDate), diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java index 0bb34df3..558c44e4 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/entity/Request.java @@ -340,18 +340,23 @@ public void deleteAfterCleanup() { this.jobId = null; } - /** 신청 유저네임은 웹 계정에 한 번 정해지면 바뀌지 않는 값이라 따로 저장하지 않고 소유자에게서 읽는다. */ + /** 이 신청이 쓰는 서버(리소스 그룹의 serverName). */ + public String getServerName() { + return resourceGroup.getServerName(); + } + + /** 신청의 서버에 있는 계정의 유저네임. 계정 행이 아직 없으면 가입 때 고른 이름이다. */ public String getUbuntuUsername() { - return user.getUbuntuUsername(); + return user.ubuntuUsernameOn(getServerName()); } - /** UID/GID는 사람에게 영구히 귀속된다(User). 신청은 소유자의 값을 그대로 보여 준다. */ + /** UID/GID는 사람에게, 서버별로 영구히 귀속된다(UbuntuAccount). 계정이 아직 없으면 null이다. */ public Long getUbuntuUid() { - return user.getUbuntuUid(); + return user.ubuntuUidOn(getServerName()); } public Long getUbuntuGid() { - return user.getUbuntuGid(); + return user.ubuntuGidOn(getServerName()); } /** diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java index be0d7ac2..966335c7 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandService.java @@ -154,7 +154,7 @@ public SaveRequestResponseDTO approveRequest(ApproveRequestDTO dto) { // 이용 정지 중에는 새 컨테이너를 만들지 않는다. 신청은 대기로 남아 정지가 끝난 뒤 승인할 수 있다. suspensionGuard.requireNotSuspendedLocked(owner.getUserId()); // 계정 회수가 도는 중이면 새 컨테이너가 곧 지워질 계정을 쓰게 된다. 회수가 끝난 뒤 승인하면 되살린다. - if (owner.isReleasingUbuntuAccount()) { + if (owner.isReleasingUbuntuAccount(req.getServerName())) { throw new BusinessException(ErrorCode.UBUNTU_ACCOUNT_RELEASING); } // 비밀번호 교체 작업이 도는 중이면 이 컨테이너만 옛 비밀번호로 만들어진다. 교체가 끝난 뒤 승인한다. @@ -176,7 +176,7 @@ public SaveRequestResponseDTO approveRequest(ApproveRequestDTO dto) { req.getUbuntuUsername(), false, supplementaryGroups, - previousUbuntuUid(req.getUser()) + previousUbuntuUid(req.getUser(), req.getServerName()) ); // 응답은 트랜잭션 안에서 만든다. 밖에서 만들면 DTO가 새로 읽는 lazy 연관(예: user.userGroups)마다 // 초기화 목록을 따로 맞춰야 하고, 빠뜨리면 승인은 진행됐는데 관리자는 500을 받는다. @@ -214,7 +214,7 @@ public SaveRequestResponseDTO approveRequest(ApproveRequestDTO dto) { boolean reuseAccount = Boolean.TRUE.equals(new TransactionTemplate(transactionManager).execute(status -> userRepository.findByIdForUpdate(userId) .orElseThrow(() -> new BusinessException(ErrorCode.USER_NOT_FOUND)) - .hasUbuntuAccount())); + .hasUbuntuAccount(serverName))); // 계정을 새로 만드는 경우의 그룹은 작업이 계정을 만들 때 함께 넣는다. // 재사용 계정의 경우, config-server의 provision 제어기가 Pod 생성 후 그룹을 추가하므로 @@ -296,8 +296,8 @@ private static RuntimeException asRuntime(Exception e) { * 원장 UID가 같을 때만 이어받고, 없으면 NAS 홈 소유자가 이 값일 때 같은 UID로 다시 만든다. * 첫 승인이면 null이라 새 번호를 받는다. */ - private Long previousUbuntuUid(User user) { - return user.hasUbuntuAccount() ? null : user.getUbuntuUid(); + private Long previousUbuntuUid(User user, String serverName) { + return user.hasUbuntuAccount(serverName) ? null : user.ubuntuUidOn(serverName); } /** @@ -335,10 +335,10 @@ public void completeApprovalJob(Long requestId, JobResultResponseDTO.Result made status.setRollbackOnly(); return new ApprovalOutcome(null, groupProblem); } - if (!owner.hasUbuntuAccount() && made.uid() != null && made.gid() != null) { + if (!owner.hasUbuntuAccount(req.getServerName()) && made.uid() != null && made.gid() != null) { // 작업이 계정을 새로 만들었거나 원장에 남은 계정을 이어받은 경우다. 이미 기록이 있으면 // 재사용 경로라 결과의 UID는 같은 값이다. - owner.assignUbuntuAccount(made.uid(), made.gid()); + owner.assignUbuntuAccount(req.getServerName(), made.uid(), made.gid()); } req.assignPodInfo(made.podName(), made.node()); req.completeApproval(); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/AccountRevokeJobPoller.java b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/AccountRevokeJobPoller.java index a2b8375e..a8618fab 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/AccountRevokeJobPoller.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/AccountRevokeJobPoller.java @@ -1,6 +1,5 @@ package DGU_AI_LAB.admin_be.domain.scheduler; -import DGU_AI_LAB.admin_be.domain.users.entity.UbuntuAccountStatus; import DGU_AI_LAB.admin_be.domain.users.entity.User; import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; import DGU_AI_LAB.admin_be.domain.users.service.UbuntuAccountReleaseService; @@ -20,7 +19,7 @@ public class AccountRevokeJobPoller { @Scheduled(fixedDelayString = "${operations.revoke.poll-ms:3000}") public void pollAccountRevokes() { - for (User user : userRepository.findAllByUbuntuAccountStatus(UbuntuAccountStatus.RELEASING)) { + for (User user : userRepository.findAllWithReleasingAccount()) { try { ubuntuAccountReleaseService.advance(user.getUserId()); } catch (Exception e) { diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupScheduler.java b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupScheduler.java index feccab97..575cb6a8 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupScheduler.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupScheduler.java @@ -39,7 +39,7 @@ public class HomeCleanupScheduler { public void runHomeCleanup() { LocalDateTime now = LocalDateTime.now(ZoneId.of("Asia/Seoul")); for (User user : userRepository.findHomeCleanupCandidates( - retentionPolicy.deletableEndedBefore(now), Status.openStatuses())) { + retentionPolicy.deletableEndedBefore(now), Status.openStatuses(), User.PRIMARY_SERVER)) { try { // 사용자별 독립 트랜잭션 — 한 사용자의 실패가 나머지를 막지 않게 한다. homeCleanupService.begin(user.getUserId(), now).ifPresent(this::register); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java index 65de3151..38d02c15 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderScheduler.java @@ -60,7 +60,7 @@ void remind(LocalDate today) { LocalDate firstEnded = retentionPolicy.containerEndDateFor(today.plusDays(1)); LocalDate lastEnded = retentionPolicy.containerEndDateFor(today.plusDays(window)); List users = userRepository.findHomeReminderCandidates( - firstEnded.atStartOfDay(), lastEnded.plusDays(1).atStartOfDay(), Status.openStatuses()); + firstEnded.atStartOfDay(), lastEnded.plusDays(1).atStartOfDay(), Status.openStatuses(), User.PRIMARY_SERVER); for (User user : users) { try { remind(user, today); @@ -72,7 +72,7 @@ void remind(LocalDate today) { } private void remind(User user, LocalDate today) { - Optional endedAt = user.lastContainerEndedAt(); + Optional endedAt = user.lastContainerEndedAt(User.PRIMARY_SERVER); if (endedAt.isEmpty()) { return; } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/UbuntuAccount.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/UbuntuAccount.java new file mode 100644 index 00000000..73e56990 --- /dev/null +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/UbuntuAccount.java @@ -0,0 +1,116 @@ +package DGU_AI_LAB.admin_be.domain.users.entity; + +import DGU_AI_LAB.admin_be.error.ErrorCode; +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import DGU_AI_LAB.admin_be.global.common.BaseTimeEntity; +import jakarta.persistence.*; +import lombok.AccessLevel; +import lombok.Getter; +import lombok.NoArgsConstructor; + +/** + * 서버(리소스 그룹의 serverName)마다 따로 가지는 리눅스 계정. 서버마다 AD·NAS가 다르므로 사용자 한 명이 서버 수만큼 + * 계정(유저네임·UID·GID)을 가질 수 있다. UID/GID/유저네임은 사람에게 영구히 남아, 회수돼도 지우지 않는다 — 다시 승인되면 + * 같은 번호·같은 홈으로 돌아온다. + */ +@Entity +@Table(name = "ubuntu_accounts", uniqueConstraints = { + @UniqueConstraint(name = "uk_ubuntu_accounts_user_server", columnNames = {"user_id", "server_name"}), + @UniqueConstraint(name = "uk_ubuntu_accounts_server_username", columnNames = {"server_name", "username"}), + @UniqueConstraint(name = "uk_ubuntu_accounts_server_uid", columnNames = {"server_name", "uid"}) +}) +@Getter +@NoArgsConstructor(access = AccessLevel.PROTECTED) +public class UbuntuAccount extends BaseTimeEntity { + + @Id + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Column(name = "ubuntu_account_id") + private Long ubuntuAccountId; + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "user_id", nullable = false) + private User user; + + @Column(name = "server_name", nullable = false, length = 300) + private String serverName; + + /** 이 서버에서 쓰는 유저네임. 가입 때 고른 이름이 기본값이고, 서버가 달라 이름이 다른 사람(이전 계정)은 다른 값을 가진다. */ + @Column(name = "username", length = 100) + private String username; + + @Column(name = "uid") + private Long uid; + + @Column(name = "gid") + private Long gid; + + @Enumerated(EnumType.STRING) + @Column(name = "status", nullable = false, length = 20) + private UbuntuAccountStatus status = UbuntuAccountStatus.NONE; + + UbuntuAccount(User user, String serverName, String username) { + this.user = user; + this.serverName = serverName; + this.username = username; + } + + public boolean isServer(String serverName) { + return this.serverName.equalsIgnoreCase(serverName); + } + + public boolean isActive() { + return status == UbuntuAccountStatus.ACTIVE; + } + + public boolean isReleasing() { + return status == UbuntuAccountStatus.RELEASING; + } + + /** + * 계정이 만들어졌거나 되살아났음을 기록한다. 예전에 받은 UID/GID가 있으면 같은 값이어야 한다(멱등) — 다른 값이면 + * 보존된 홈의 소유자와 어긋나고 옛 번호가 다른 사람에게 넘어간 것처럼 보인다. + */ + public void assign(Long uid, Long gid) { + if (uid == null || gid == null || uid <= 0 || gid <= 0) { + throw new BusinessException(ErrorCode.UID_ALLOCATION_FAILED); + } + if (this.uid != null && (!this.uid.equals(uid) || !gid.equals(this.gid))) { + throw new BusinessException( + "이미 다른 UID/GID가 배정된 계정입니다.", ErrorCode.UBUNTU_ACCOUNT_ALREADY_ASSIGNED); + } + if (isReleasing()) { + throw new BusinessException(ErrorCode.UBUNTU_ACCOUNT_RELEASING); + } + this.uid = uid; + this.gid = gid; + this.status = UbuntuAccountStatus.ACTIVE; + } + + /** 회수를 시작한다. 이미 회수 중이면 그대로 둔다(재시도). 계정이 없으면 회수할 것도 없다. */ + public boolean beginRelease() { + if (status == UbuntuAccountStatus.NONE) { + return false; + } + this.status = UbuntuAccountStatus.RELEASING; + return true; + } + + /** 회수할 노드를 몰라 계정을 지우지 못했을 때 살아 있는 상태로 되돌린다. */ + public void abortRelease() { + requireReleasing(); + this.status = UbuntuAccountStatus.ACTIVE; + } + + /** 리눅스 계정이 실제로 삭제됐음을 기록한다. 유저네임·UID·GID는 남긴다. */ + public void release() { + requireReleasing(); + this.status = UbuntuAccountStatus.NONE; + } + + private void requireReleasing() { + if (!isReleasing()) { + throw new BusinessException("회수 중인 계정이 아닙니다.", ErrorCode.INVALID_REQUEST_STATUS); + } + } +} diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java index cd58b7be..1ad9258d 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/entity/User.java @@ -120,6 +120,14 @@ public class User extends BaseTimeEntity { @OneToMany(mappedBy = "user", cascade = CascadeType.REMOVE, orphanRemoval = true) private List requests = new ArrayList<>(); + /** + * 서버별 리눅스 계정. 서버(resource_groups.server_name)마다 AD·NAS가 달라 한 사람이 서버 수만큼 가진다. 신청의 유저네임·UID를 + * 읽는 곳이 트랜잭션 밖(알림·이벤트 리스너)에도 많아 즉시 로딩한다. 한 사람에 몇 건뿐이다. + */ + @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER) + @org.hibernate.annotations.BatchSize(size = 100) // 사용자 목록을 읽을 때 계정을 사용자마다 따로 읽지 않게 묶는다 + private Set ubuntuAccounts = new HashSet<>(); + /** * 이 계정이 실제로 가진 그룹. Request 단위가 아니라 계정 단위다 — 같은 웹 계정의 * 모든 컨테이너가 같은 우분투 계정을 쓰므로(ubuntuUsername), 그룹도 계정 하나에 대해 @@ -217,9 +225,48 @@ public void changeUbuntuPasswordHash(String ubuntuPasswordHash) { this.ubuntuPasswordHash = ubuntuPasswordHash; } - /** 리눅스 계정이 지금 살아 있는지. false면 승인 시 계정 생성(또는 같은 UID로 되살리기)을 요청해야 한다. */ + /** + * 롤백 안전을 위해 옛 단일 계정 컬럼(ubuntu_uid/gid/account_status)에 미러링하는 기본 서버. 이 서버 계정의 쓰기만 옛 컬럼에도 + * 적는다. shortcut: 서버 이름을 코드에 둠, 옛 컬럼을 지우는 후속 버전에서 이 상수와 미러링을 함께 제거한다. + */ + public static final String PRIMARY_SERVER = "FARM"; + + /** 이 서버의 계정. 한 번도 만들어지지 않은 서버면 비어 있다. */ + public Optional ubuntuAccount(String serverName) { + return this.ubuntuAccounts.stream().filter(a -> a.isServer(serverName)).findFirst(); + } + + /** 이 서버의 계정 행. 없으면 가입 때 고른 유저네임으로 만든다(아직 원장에 없는 NONE 상태). */ + public UbuntuAccount ubuntuAccountFor(String serverName) { + return ubuntuAccount(serverName).orElseGet(() -> { + UbuntuAccount created = new UbuntuAccount(this, serverName, this.ubuntuUsername); + this.ubuntuAccounts.add(created); + return created; + }); + } + + /** 이 서버에서 쓸 유저네임. 계정 행이 있으면 그 값, 없으면 가입 때 고른 이름이다. */ + public String ubuntuUsernameOn(String serverName) { + return ubuntuAccount(serverName).map(UbuntuAccount::getUsername).orElse(this.ubuntuUsername); + } + + /** 이 서버 계정의 UID. 계정이 한 번도 만들어지지 않았으면 null. */ + public Long ubuntuUidOn(String serverName) { + return ubuntuAccount(serverName).map(UbuntuAccount::getUid).orElse(null); + } + + public Long ubuntuGidOn(String serverName) { + return ubuntuAccount(serverName).map(UbuntuAccount::getGid).orElse(null); + } + + /** 이 서버의 리눅스 계정이 지금 살아 있는지. false면 승인 시 계정 생성(또는 같은 UID로 되살리기)을 요청해야 한다. */ + public boolean hasUbuntuAccount(String serverName) { + return ubuntuAccount(serverName).map(UbuntuAccount::isActive).orElse(false); + } + + /** 기본 서버 기준. 서버를 아는 호출부는 {@link #hasUbuntuAccount(String)}을 쓴다. */ public boolean hasUbuntuAccount() { - return this.ubuntuAccountStatus == UbuntuAccountStatus.ACTIVE; + return hasUbuntuAccount(PRIMARY_SERVER); } /** @@ -227,7 +274,17 @@ public boolean hasUbuntuAccount() { * 행이 바뀌지 않는다. 컨테이너를 쓴 적이 없으면 비어 있다. */ public Optional lastContainerEndedAt() { + return lastContainerEndedAt(r -> true); + } + + /** 이 서버에서 마지막 컨테이너가 끝난 시각. 홈은 서버마다 따로라 홈 삭제 판단은 서버 단위로 한다. */ + public Optional lastContainerEndedAt(String serverName) { + return lastContainerEndedAt(r -> serverName.equalsIgnoreCase(r.getServerName())); + } + + private Optional lastContainerEndedAt(java.util.function.Predicate scope) { return this.requests.stream() + .filter(scope) .filter(r -> r.getStatus() == Status.DELETED && r.getApprovedAt() != null) .map(Request::getUpdatedAt) .filter(Objects::nonNull) @@ -239,68 +296,107 @@ public boolean hasOpenRequest() { return this.requests.stream().anyMatch(r -> Status.openStatuses().contains(r.getStatus())); } + /** 이 서버에 끝나지 않은 신청이 있는가. */ + public boolean hasOpenRequest(String serverName) { + return this.requests.stream().anyMatch(r -> serverName.equalsIgnoreCase(r.getServerName()) + && Status.openStatuses().contains(r.getStatus())); + } + /** 계정 회수 작업이 도는 중인지. 그 사이 승인·비밀번호 변경은 거절해야 한다 — 지워질 계정에 반영된다. */ + public boolean isReleasingUbuntuAccount(String serverName) { + return ubuntuAccount(serverName).map(UbuntuAccount::isReleasing).orElse(false); + } + + /** 어느 서버든 회수 중인 계정이 있는지. */ public boolean isReleasingUbuntuAccount() { - return this.ubuntuAccountStatus == UbuntuAccountStatus.RELEASING; + return this.ubuntuAccounts.stream().anyMatch(UbuntuAccount::isReleasing); } - /** - * 계정이 만들어졌거나 되살아났음을 기록한다. 이 사람이 예전에 받은 UID/GID가 있으면 그 값과 - * 같아야 한다(멱등) — 다른 값이면 실패시킨다. 한 사람이 두 번호를 가리키면 보존된 홈 디렉터리의 - * 소유자와 어긋나고, 옛 번호가 다른 사람에게 넘어간 것처럼 보인다. - */ + /** 기본 서버 기준. 서버를 아는 호출부는 {@link #assignUbuntuAccount(String, Long, Long)}을 쓴다. */ public void assignUbuntuAccount(Long ubuntuUid, Long ubuntuGid) { - if (ubuntuUid == null || ubuntuGid == null || ubuntuUid <= 0 || ubuntuGid <= 0) { - throw new BusinessException(ErrorCode.UID_ALLOCATION_FAILED); - } - if (this.ubuntuUid != null - && (!this.ubuntuUid.equals(ubuntuUid) || !ubuntuGid.equals(this.ubuntuGid))) { - throw new BusinessException( - "이미 다른 UID/GID가 배정된 계정입니다.", ErrorCode.UBUNTU_ACCOUNT_ALREADY_ASSIGNED); - } - if (isReleasingUbuntuAccount()) { - throw new BusinessException(ErrorCode.UBUNTU_ACCOUNT_RELEASING); - } - this.ubuntuUid = ubuntuUid; - this.ubuntuGid = ubuntuGid; - this.ubuntuAccountStatus = UbuntuAccountStatus.ACTIVE; + assignUbuntuAccount(PRIMARY_SERVER, ubuntuUid, ubuntuGid); + } + + /** 이 서버의 계정이 만들어졌거나 되살아났음을 기록한다. 예전 UID/GID와 다르면 실패한다({@link UbuntuAccount#assign}). */ + public void assignUbuntuAccount(String serverName, Long ubuntuUid, Long ubuntuGid) { + UbuntuAccount account = ubuntuAccountFor(serverName); + account.assign(ubuntuUid, ubuntuGid); + mirrorToLegacyColumns(account); + } + + /** 기본 서버 기준. {@link #beginUbuntuAccountRelease(String)} 참고. */ + public boolean beginUbuntuAccountRelease() { + return beginUbuntuAccountRelease(PRIMARY_SERVER); } /** - * 계정 회수를 시작한다. 이미 회수 중이면 그대로 둔다(관리자의 재시도). 계정이 없으면 회수할 것도 없다. + * 이 서버의 계정 회수를 시작한다. 이미 회수 중이면 그대로 둔다(관리자의 재시도). 계정이 없으면 회수할 것도 없다. * * @return 회수가 진행 중이면 true — 계정 회수 폴러가 컨테이너 회수가 끝나기를 기다렸다가 계정을 지운다 */ - public boolean beginUbuntuAccountRelease() { - if (this.ubuntuAccountStatus == UbuntuAccountStatus.NONE) { - return false; + public boolean beginUbuntuAccountRelease(String serverName) { + return ubuntuAccount(serverName).map(a -> { + boolean releasing = a.beginRelease(); + mirrorToLegacyColumns(a); + return releasing; + }).orElse(false); + } + + /** 모든 서버의 계정 회수를 시작한다(관리자 계정 삭제·탈퇴). 회수할 계정이 하나라도 있으면 true. */ + public boolean beginUbuntuAccountReleaseOnAllServers() { + boolean releasing = false; + for (UbuntuAccount account : this.ubuntuAccounts) { + releasing |= beginUbuntuAccountRelease(account.getServerName()); } - this.ubuntuAccountStatus = UbuntuAccountStatus.RELEASING; - return true; + return releasing; } - /** 회수할 노드를 몰라 계정을 지우지 못했을 때 계정이 살아 있는 상태로 되돌린다. */ + /** 원장에 계정이 하나라도 남아 있는지(ACTIVE 또는 회수 중). */ + public boolean hasAnyUbuntuAccountInLedger() { + return this.ubuntuAccounts.stream().anyMatch(a -> a.getStatus() != UbuntuAccountStatus.NONE); + } + + /** 기본 서버 기준. */ public void abortUbuntuAccountRelease() { - requireReleasing(); - this.ubuntuAccountStatus = UbuntuAccountStatus.ACTIVE; + abortUbuntuAccountRelease(PRIMARY_SERVER); + } + + /** 회수할 노드를 몰라 계정을 지우지 못했을 때 계정이 살아 있는 상태로 되돌린다. */ + public void abortUbuntuAccountRelease(String serverName) { + UbuntuAccount account = requireAccount(serverName); + account.abortRelease(); + mirrorToLegacyColumns(account); + } + + /** 기본 서버 기준. */ + public void releaseUbuntuAccount() { + releaseUbuntuAccount(PRIMARY_SERVER); } /** - * 리눅스 계정이 실제로 삭제됐음을 기록한다. 유저네임·UID·GID는 남긴다 — 사람을 가리키는 값이라 - * 재활성화 후 같은 번호·같은 홈으로 돌아와야 한다. 다음 승인은 이 UID를 expected_uid로 보내고, - * config-server는 NAS 홈 소유자가 그 번호일 때 같은 번호로 계정을 되살린다. + * 이 서버의 리눅스 계정이 실제로 삭제됐음을 기록한다. 유저네임·UID·GID는 남긴다 — 다시 승인되면 같은 번호·같은 홈으로 + * 돌아와야 한다. 그룹 소속은 기본 서버 계정을 지울 때만 비운다(AD에서 사용자째 사라지므로). 그룹이 아직 서버별로 + * 나뉘지 않아, 다른 서버 계정을 지울 때 비우면 기본 서버의 소속이 DB에서만 사라진다. */ - public void releaseUbuntuAccount() { - requireReleasing(); - this.ubuntuAccountStatus = UbuntuAccountStatus.NONE; - // 계정 삭제는 AD 사용자째 지우므로 그룹 소속도 함께 사라진다. 남겨 두면 화면엔 여전히 - // 멤버로 보이고, 다시 승인될 때 AD에 없는 소속이 새 Pod 에 실린다. - this.userGroups.clear(); + public void releaseUbuntuAccount(String serverName) { + UbuntuAccount account = requireAccount(serverName); + account.release(); + mirrorToLegacyColumns(account); + if (account.isServer(PRIMARY_SERVER)) { + this.userGroups.clear(); + } + } + + private UbuntuAccount requireAccount(String serverName) { + return ubuntuAccount(serverName).orElseThrow(() -> + new BusinessException("회수 중인 계정이 아닙니다.", ErrorCode.INVALID_REQUEST_STATUS)); } - private void requireReleasing() { - if (!isReleasingUbuntuAccount()) { - throw new BusinessException("회수 중인 계정이 아닙니다.", ErrorCode.INVALID_REQUEST_STATUS); + private void mirrorToLegacyColumns(UbuntuAccount account) { + if (account.isServer(PRIMARY_SERVER)) { + this.ubuntuUid = account.getUid(); + this.ubuntuGid = account.getGid(); + this.ubuntuAccountStatus = account.getStatus(); } } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java index c8dd0a09..b1ce600a 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepository.java @@ -2,7 +2,6 @@ import DGU_AI_LAB.admin_be.domain.requests.entity.Status; import DGU_AI_LAB.admin_be.domain.users.entity.Role; -import DGU_AI_LAB.admin_be.domain.users.entity.UbuntuAccountStatus; import DGU_AI_LAB.admin_be.domain.users.entity.User; import jakarta.persistence.LockModeType; import org.springframework.data.jpa.repository.JpaRepository; @@ -26,9 +25,14 @@ public interface UserRepository extends JpaRepository { boolean existsByEmail(String email); - boolean existsByUbuntuUsername(String ubuntuUsername); + /** 가입 때 고른 이름이거나 어느 서버의 계정 유저네임이든 이미 쓰이는 이름인가. */ + @Query("SELECT COUNT(u) > 0 FROM User u WHERE u.ubuntuUsername = :ubuntuUsername " + + "OR EXISTS (SELECT a FROM UbuntuAccount a WHERE a.username = :ubuntuUsername)") + boolean existsByUbuntuUsername(@Param("ubuntuUsername") String ubuntuUsername); - List findAllByUbuntuAccountStatus(UbuntuAccountStatus ubuntuAccountStatus); + /** 회수 중인 계정(서버 어느 쪽이든)이 하나라도 있는 사용자. */ + @Query("SELECT DISTINCT a.user FROM UbuntuAccount a WHERE a.status = DGU_AI_LAB.admin_be.domain.users.entity.UbuntuAccountStatus.RELEASING") + List findAllWithReleasingAccount(); /** * 이 권한의 활성 사용자 행을 모두 잠근다. "마지막 활성 관리자" 확인과 권한·활성 변경을 한 트랜잭션에서 @@ -102,12 +106,15 @@ List findGraduatingUsers(@Param("graduationBefore") LocalDate graduationBe */ @Query("SELECT u FROM User u " + "WHERE u.ubuntuUsername IS NOT NULL AND u.ubuntuUid IS NOT NULL " + - " AND NOT EXISTS (SELECT r FROM Request r WHERE r.user = u AND r.status IN :openStatuses) " + + " AND NOT EXISTS (SELECT r FROM Request r WHERE r.user = u AND r.status IN :openStatuses " + + " AND LOWER(r.resourceGroup.serverName) = LOWER(:serverName)) " + " AND (SELECT MAX(d.updatedAt) FROM Request d WHERE d.user = u " + + " AND LOWER(d.resourceGroup.serverName) = LOWER(:serverName) " + " AND d.status = DGU_AI_LAB.admin_be.domain.requests.entity.Status.DELETED " + " AND d.approvedAt IS NOT NULL) < :endedBefore") List findHomeCleanupCandidates(@Param("endedBefore") LocalDateTime endedBefore, - @Param("openStatuses") Collection openStatuses); + @Param("openStatuses") Collection openStatuses, + @Param("serverName") String serverName); /** * 홈 삭제 직전 안내 후보. {@link #findHomeCleanupCandidates}와 같은 조건에, 마지막 컨테이너가 끝난 시각이 @@ -115,14 +122,18 @@ List findHomeCleanupCandidates(@Param("endedBefore") LocalDateTime endedBe */ @Query("SELECT u FROM User u " + "WHERE u.ubuntuUsername IS NOT NULL AND u.ubuntuUid IS NOT NULL AND u.deletedAt IS NULL AND u.isActive = true " + - " AND NOT EXISTS (SELECT r FROM Request r WHERE r.user = u AND r.status IN :openStatuses) " + + " AND NOT EXISTS (SELECT r FROM Request r WHERE r.user = u AND r.status IN :openStatuses " + + " AND LOWER(r.resourceGroup.serverName) = LOWER(:serverName)) " + " AND (SELECT MAX(d.updatedAt) FROM Request d WHERE d.user = u " + + " AND LOWER(d.resourceGroup.serverName) = LOWER(:serverName) " + " AND d.status = DGU_AI_LAB.admin_be.domain.requests.entity.Status.DELETED " + " AND d.approvedAt IS NOT NULL) >= :from " + " AND (SELECT MAX(d.updatedAt) FROM Request d WHERE d.user = u " + + " AND LOWER(d.resourceGroup.serverName) = LOWER(:serverName) " + " AND d.status = DGU_AI_LAB.admin_be.domain.requests.entity.Status.DELETED " + " AND d.approvedAt IS NOT NULL) < :to") List findHomeReminderCandidates(@Param("from") LocalDateTime from, @Param("to") LocalDateTime to, - @Param("openStatuses") Collection openStatuses); + @Param("openStatuses") Collection openStatuses, + @Param("serverName") String serverName); } diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java index d9516d35..5740a5d3 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/AdminUserService.java @@ -10,7 +10,6 @@ import DGU_AI_LAB.admin_be.domain.scheduler.UserLifecycleTransactionalService; import DGU_AI_LAB.admin_be.domain.users.dto.response.UserSummaryDTO; import DGU_AI_LAB.admin_be.domain.users.entity.Role; -import DGU_AI_LAB.admin_be.domain.users.entity.UbuntuAccountStatus; import DGU_AI_LAB.admin_be.domain.users.entity.User; import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; import DGU_AI_LAB.admin_be.error.ErrorCode; @@ -102,7 +101,7 @@ private void cleanupUserRequests(User user, String logPrefix) { log.warn("[{}] userId={} 승인/마이그레이션 진행 중인 요청이 있어 정리를 거부합니다.", logPrefix, userId); throw new ConflictException(ErrorCode.REQUEST_MIGRATION_IN_PROGRESS); } - if (managed.beginUbuntuAccountRelease()) { + if (managed.beginUbuntuAccountReleaseOnAllServers()) { // 이전 회수 주기나 실패한 시도의 계정 회수 작업 번호를 비워 모든 노드를 새로 등록하게 한다. current.stream() .filter(r -> r.getStatus() == Status.DELETED && r.getJobId() != null) @@ -243,7 +242,7 @@ private void withdrawWithCleanup(Long userId, User user, String logPrefix, Strin public void deleteUbuntuAccountOfUser(Long userId) { User user = new TransactionTemplate(transactionManager).execute(status -> userRepository.findById(userId) .orElseThrow(() -> new EntityNotFoundException(ErrorCode.USER_NOT_FOUND))); - if (user.getUbuntuAccountStatus() == UbuntuAccountStatus.NONE) { + if (!user.hasAnyUbuntuAccountInLedger()) { throw new EntityNotFoundException(ErrorCode.ENTITY_NOT_FOUND); } log.warn("[deleteUbuntuAccount] 우분투 계정 회수 시작: userId={}", userId); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetService.java index e0d4e93b..a53a3f34 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetService.java @@ -118,13 +118,19 @@ public PasswordResetSummaryDTO approve(Long changeRequestId, Long adminId, Strin throw new BusinessException(ErrorCode.UBUNTU_PASSWORD_CHANGE_WHILE_PROVISIONING); } User admin = userRepository.getReferenceById(adminId); + // 비밀번호 교체 작업은 기본 서버의 config-server 하나에만 등록한다. 다른 서버에 살아 있는 계정이 있으면 그 계정만 옛 + // 비밀번호로 남으므로, 서버별 작업 경로가 생기기 전에는 조용히 넘기지 않고 막는다. + if (user.getUbuntuAccounts().stream().anyMatch(acc -> acc.isActive() && !acc.isServer(User.PRIMARY_SERVER))) { + throw new BusinessException("기본 서버 밖에 활성 계정이 있어 비밀번호 재설정을 승인할 수 없습니다.", + ErrorCode.INVALID_REQUEST_STATUS); + } if (!user.hasUbuntuAccount()) { apply(user, reset.hashes()); reset.applyWithoutJob(admin, adminComment); return new Outcome(PasswordResetSummaryDTO.fromEntity(reset), ChangeRequestDecision.of(reset.getChangeRequest())); } reset.startProcessing(admin, adminComment, - registerJob(reset.getPasswordResetRequestId(), user.getUbuntuUsername(), reset.getUbuntuPasswordHash())); + registerJob(reset.getPasswordResetRequestId(), user.ubuntuUsernameOn(User.PRIMARY_SERVER), reset.getUbuntuPasswordHash())); return new Outcome(PasswordResetSummaryDTO.fromEntity(reset), null); }); log.info("[passwordReset] changeRequestId={} 승인: adminId={}, status={}", changeRequestId, adminId, approval.request().status()); diff --git a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseService.java b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseService.java index 4a93b56c..670267c9 100644 --- a/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseService.java +++ b/src/main/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseService.java @@ -9,6 +9,7 @@ import DGU_AI_LAB.admin_be.domain.requests.entity.Status; import DGU_AI_LAB.admin_be.domain.requests.repository.RequestRepository; import DGU_AI_LAB.admin_be.domain.requests.service.UbuntuAccountService; +import DGU_AI_LAB.admin_be.domain.users.entity.UbuntuAccount; import DGU_AI_LAB.admin_be.domain.users.entity.User; import DGU_AI_LAB.admin_be.domain.users.repository.UserRepository; import DGU_AI_LAB.admin_be.error.ErrorCode; @@ -59,13 +60,31 @@ private record NodeJob(String nodeName, Long requestId, Long jobId) {} private record Snapshot(String username, boolean containersRemain, List nodes) {} + /** 이 사용자의 회수 중인 계정(서버별)을 모두 한 단계씩 진행한다. */ public void advance(Long userId) { - Snapshot snapshot = new TransactionTemplate(transactionManager).execute(status -> snapshot(userId)); + List servers = new TransactionTemplate(transactionManager).execute(status -> + userRepository.findById(userId).map(u -> u.getUbuntuAccounts().stream() + .filter(UbuntuAccount::isReleasing).map(UbuntuAccount::getServerName).toList()) + .orElse(List.of())); + if (servers != null) { + for (String server : servers) { + // 한 서버의 실패가 다른 서버 회수를 굶기지 않게 서버마다 따로 막는다. 다음 바퀴에 다시 본다. + try { + advance(userId, server); + } catch (Exception e) { + log.warn("[계정 회수] 진행 실패 - userId={}, server={}", userId, server, e); + } + } + } + } + + private void advance(Long userId, String serverName) { + Snapshot snapshot = new TransactionTemplate(transactionManager).execute(status -> snapshot(userId, serverName)); if (snapshot == null || snapshot.containersRemain()) { return; } if (snapshot.nodes().isEmpty()) { - abortForUnknownNodes(userId, snapshot.username()); + abortForUnknownNodes(userId, serverName, snapshot.username()); return; } @@ -80,30 +99,33 @@ public void advance(Long userId) { } new TransactionTemplate(transactionManager).execute(status -> { userRepository.findByIdForUpdate(userId) - .filter(User::isReleasingUbuntuAccount) - .ifPresent(User::releaseUbuntuAccount); + .filter(u -> u.isReleasingUbuntuAccount(serverName)) + .ifPresent(u -> u.releaseUbuntuAccount(serverName)); return null; }); log.info("[계정 회수] 완료: userId={}, username={}, nodes={}", userId, snapshot.username(), snapshot.nodes().stream().map(NodeJob::nodeName).toList()); } - private Snapshot snapshot(Long userId) { + private Snapshot snapshot(Long userId, String serverName) { User user = userRepository.findById(userId).orElse(null); - if (user == null || !user.isReleasingUbuntuAccount()) { + if (user == null || !user.isReleasingUbuntuAccount(serverName)) { return null; } + // 다른 서버의 컨테이너·노드는 이 서버 계정과 무관하다. boolean containersRemain = requestRepository.findAllByUser_UserId(user.getUserId()).stream() + .filter(r -> serverName.equalsIgnoreCase(r.getServerName())) .anyMatch(r -> Status.activeStatuses().contains(r.getStatus()) || r.getStatus() == Status.PROCESSING); // 최신순이므로 노드마다 처음 보이는 신청이 그 노드에서 계정을 마지막으로 쓴 신청이다. Set seen = new LinkedHashSet<>(); List nodes = new ArrayList<>(); for (Request r : requestRepository.findAllWithNodeByUserIdOrderByRequestIdDesc(userId)) { - if (r.getStatus() == Status.DELETED && seen.add(r.getNodeName())) { + if (r.getStatus() == Status.DELETED && serverName.equalsIgnoreCase(r.getServerName()) + && seen.add(r.getNodeName())) { nodes.add(new NodeJob(r.getNodeName(), r.getRequestId(), r.getJobId())); } } - return new Snapshot(user.getUbuntuUsername(), containersRemain, nodes); + return new Snapshot(user.ubuntuUsernameOn(serverName), containersRemain, nodes); } /** @@ -111,11 +133,11 @@ private Snapshot snapshot(Long userId) { * 그 위험을 감수하느니 계정을 살아 있는 상태로 되돌리고 관리자에게 알린다 — 남은 계정은 수동으로 정리할 수 * 있지만, 잘못 지운 남의 계정은 되돌릴 수 없다. */ - private void abortForUnknownNodes(Long userId, String username) { + private void abortForUnknownNodes(Long userId, String serverName, String username) { new TransactionTemplate(transactionManager).execute(status -> { userRepository.findByIdForUpdate(userId) - .filter(User::isReleasingUbuntuAccount) - .ifPresent(User::abortUbuntuAccountRelease); + .filter(u -> u.isReleasingUbuntuAccount(serverName)) + .ifPresent(u -> u.abortUbuntuAccountRelease(serverName)); return null; }); alert("notification.admin.account-revoke.unknown-nodes", diff --git a/src/main/resources/db/migration/V23__ubuntu_accounts.sql b/src/main/resources/db/migration/V23__ubuntu_accounts.sql new file mode 100644 index 00000000..8849f57c --- /dev/null +++ b/src/main/resources/db/migration/V23__ubuntu_accounts.sql @@ -0,0 +1,32 @@ +-- 리눅스 계정을 서버(resource_groups.server_name)별로 나눈다. 서버마다 AD·NAS가 달라 한 사람이 서버 수만큼 계정을 가진다. +-- 1단계: 새 표를 만들고 기존 값을 복사한다. users 의 ubuntu_uid/gid/account_status 컬럼은 롤백 안전을 위해 남겨 두고 +-- 코드가 기본 서버 계정의 쓰기를 거기에도 미러링한다. 컬럼 삭제는 검증 뒤 후속 버전에서 한다. +CREATE TABLE `ubuntu_accounts` ( + `ubuntu_account_id` bigint NOT NULL AUTO_INCREMENT, + `created_at` datetime(6) NOT NULL, + `updated_at` datetime(6) DEFAULT NULL, + `user_id` bigint NOT NULL, + `server_name` varchar(300) NOT NULL, + `username` varchar(100) DEFAULT NULL, + `uid` bigint DEFAULT NULL, + `gid` bigint DEFAULT NULL, + `status` varchar(20) NOT NULL DEFAULT 'NONE', + PRIMARY KEY (`ubuntu_account_id`), + UNIQUE KEY `uk_ubuntu_accounts_user_server` (`user_id`,`server_name`), + UNIQUE KEY `uk_ubuntu_accounts_server_username` (`server_name`,`username`), + UNIQUE KEY `uk_ubuntu_accounts_server_uid` (`server_name`,`uid`), + CONSTRAINT `fk_ubuntu_accounts_user` FOREIGN KEY (`user_id`) REFERENCES `users` (`user_id`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci; + +-- uid 를 받은 적 있는 사용자만 옮긴다(승인 전 사용자는 가입 때 고른 이름만 users 에 있다). 서버는 그 사용자가 처음 +-- 승인받은 신청의 리소스 그룹에서 찾고, 승인 기록이 없으면 리소스 그룹 중 이름순 첫 서버로 둔다. +INSERT INTO `ubuntu_accounts` (`created_at`, `updated_at`, `user_id`, `server_name`, `username`, `uid`, `gid`, `status`) +SELECT NOW(6), NOW(6), u.`user_id`, + COALESCE( + (SELECT rg.`server_name` FROM `requests` r JOIN `resource_groups` rg ON rg.`rsgroup_id` = r.`rsgroup_id` + WHERE r.`user_id` = u.`user_id` AND r.`approved_at` IS NOT NULL + ORDER BY r.`approved_at` LIMIT 1), + (SELECT MIN(`server_name`) FROM `resource_groups` WHERE `server_name` IS NOT NULL)), + u.`ubuntu_username`, u.`ubuntu_uid`, u.`ubuntu_gid`, u.`ubuntu_account_status` +FROM `users` u +WHERE u.`ubuntu_uid` IS NOT NULL; diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java index d30fcca1..c7699868 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/alarm/service/AlarmServiceTest.java @@ -835,8 +835,8 @@ private Request fulfilledRequest(String serverName) { when(request.getRequestId()).thenReturn(1234L); when(request.getCreatedAt()).thenReturn(java.time.LocalDateTime.of(2026, 10, 6, 13, 5)); when(request.getNodeName()).thenReturn("farm6"); - when(request.getUser().getUbuntuUid()).thenReturn(10148L); - when(request.getUser().getUbuntuGid()).thenReturn(10148L); + when(request.getUbuntuUid()).thenReturn(10148L); + when(request.getUbuntuGid()).thenReturn(10148L); when(serverProfileRegistry.publicPort(eq(serverName), anyString())).thenAnswer(inv -> inv.getArgument(1)); return request; } diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupServiceTest.java index 69bdbe74..a2b2fe26 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/home/service/HomeCleanupServiceTest.java @@ -48,9 +48,10 @@ void setUp() { service = new HomeCleanupService(userRepository, cleanupRepository, new HomeRetentionPolicy()); when(userRepository.findByIdForUpdate(USER_ID)).thenReturn(Optional.of(user)); when(user.getUbuntuUsername()).thenReturn("hong"); + when(user.ubuntuUsernameOn(any())).thenReturn("hong"); when(user.getUbuntuUid()).thenReturn(55010L); - when(user.hasOpenRequest()).thenReturn(false); - when(user.lastContainerEndedAt()).thenReturn(Optional.of(ENDED_LONG_AGO)); + when(user.hasOpenRequest(User.PRIMARY_SERVER)).thenReturn(false); + when(user.lastContainerEndedAt(User.PRIMARY_SERVER)).thenReturn(Optional.of(ENDED_LONG_AGO)); when(cleanupRepository.save(any(HomeCleanup.class))).thenAnswer(inv -> inv.getArgument(0)); } @@ -77,7 +78,7 @@ void beginSkipsUserWithoutAccount() { @Test @DisplayName("후보 조회 뒤 새로 신청했으면 만들지 않는다") void beginSkipsUserWithOpenRequest() { - when(user.hasOpenRequest()).thenReturn(true); + when(user.hasOpenRequest(User.PRIMARY_SERVER)).thenReturn(true); assertThat(service.begin(USER_ID, NOW)).isEmpty(); verify(cleanupRepository, never()).save(any()); @@ -86,7 +87,7 @@ void beginSkipsUserWithOpenRequest() { @Test @DisplayName("보존 기간이 아직 지나지 않았으면 만들지 않는다") void beginSkipsBeforeRetentionEnds() { - when(user.lastContainerEndedAt()).thenReturn(Optional.of(NOW.minusDays(40).plusMinutes(1))); + when(user.lastContainerEndedAt(User.PRIMARY_SERVER)).thenReturn(Optional.of(NOW.minusDays(40).plusMinutes(1))); assertThat(service.begin(USER_ID, NOW)).isEmpty(); verify(cleanupRepository, never()).save(any()); @@ -95,7 +96,7 @@ void beginSkipsBeforeRetentionEnds() { @Test @DisplayName("컨테이너를 쓴 적이 없으면 만들지 않는다") void beginSkipsUserWhoNeverHadContainer() { - when(user.lastContainerEndedAt()).thenReturn(Optional.empty()); + when(user.lastContainerEndedAt(User.PRIMARY_SERVER)).thenReturn(Optional.empty()); assertThat(service.begin(USER_ID, NOW)).isEmpty(); } diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRowsTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRowsTest.java index f59a004e..34b92ca8 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRowsTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/issuanceSheet/IssuanceSheetRowsTest.java @@ -19,6 +19,7 @@ import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -35,8 +36,9 @@ static Request request(long id, long userId, String serverName, Status status, S when(user.getUserId()).thenReturn(userId); when(user.getName()).thenReturn(name); when(user.getUbuntuUsername()).thenReturn("user" + userId); - when(user.getUbuntuUid()).thenReturn(55000L + userId); - when(user.getUbuntuGid()).thenReturn(56000L + userId); + when(user.ubuntuUsernameOn(any())).thenReturn("user" + userId); + when(user.ubuntuUidOn(any())).thenReturn(55000L + userId); + when(user.ubuntuGidOn(any())).thenReturn(56000L + userId); when(user.getEmail()).thenReturn("user" + userId + "@example.test"); when(user.getPhone()).thenReturn("01000000000"); @@ -63,6 +65,9 @@ static Request request(long id, long userId, String serverName, Status status, S when(request.getRequestId()).thenReturn(id); when(request.getStatus()).thenReturn(status); when(request.getUser()).thenReturn(user); + when(request.getUbuntuUsername()).thenReturn("user" + userId); + when(request.getUbuntuUid()).thenReturn(55000L + userId); + when(request.getUbuntuGid()).thenReturn(56000L + userId); when(request.getContainerImage()).thenReturn(image); when(request.getResourceGroup()).thenReturn(resourceGroup); when(request.getNodeName()).thenReturn(nodeName); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java index 026ebc25..d7f1dc13 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceApprovalContractTest.java @@ -111,7 +111,7 @@ transactionManager, new InMemoryAlertDeduplicator() when(mockUser.getUserId()).thenReturn(100L); when(mockUser.getName()).thenReturn("테스트유저"); - when(mockUser.hasUbuntuAccount()).thenReturn(false); + when(mockUser.hasUbuntuAccount(any())).thenReturn(false); when(userRepository.findByIdForUpdate(100L)).thenReturn(Optional.of(mockUser)); when(containerImageRepository.findById(1L)).thenReturn(Optional.of(mockImage)); when(resourceGroupRepository.findById(1)).thenReturn(Optional.of(mockRg)); @@ -179,8 +179,8 @@ void doesNotRecordProfessorApprovalWithoutAdmin() { void sendsOwnUidWhenAccountReleased() { Long requestId = 304L; approvableRequest(requestId); - when(mockUser.hasUbuntuAccount()).thenReturn(false); - when(mockUser.getUbuntuUid()).thenReturn(55000L); + when(mockUser.hasUbuntuAccount(any())).thenReturn(false); + when(mockUser.ubuntuUidOn(any())).thenReturn(55000L); service.approveRequest(new ApproveRequestDTO(requestId, 1L, 1, null)); @@ -208,7 +208,7 @@ void recordsRegisteredJobId() { void reusedAccountApprovalSendsGroupsWithRegistration() { Long requestId = 302L; Request request = approvableRequest(requestId); - when(mockUser.hasUbuntuAccount()).thenReturn(true); + when(mockUser.hasUbuntuAccount(any())).thenReturn(true); service.approveRequest(new ApproveRequestDTO(requestId, 1L, 1, null)); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceTest.java index 773031f4..fe71e09f 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/requests/service/AdminRequestCommandServiceTest.java @@ -126,7 +126,7 @@ transactionManager, new InMemoryAlertDeduplicator() when(mockUser.getName()).thenReturn("테스트유저"); when(mockUser.getUserId()).thenReturn(100L); // 기본값: 아직 리눅스 계정이 없는 사용자 → 승인 시 계정 생성 API를 호출한다. - when(mockUser.hasUbuntuAccount()).thenReturn(false); + when(mockUser.hasUbuntuAccount(any())).thenReturn(false); // UID/GID 배정은 User 행을 잠그고 수행한다 (같은 사용자의 동시 승인 직렬화). when(userRepository.findByIdForUpdate(100L)).thenReturn(Optional.of(mockUser)); when(mockImage.getImageId()).thenReturn(1L); @@ -513,7 +513,7 @@ void rejectsWhenAnotherRequestOfSameUserIsAlreadyProcessing() { void rejectsWhileAccountReleasing() { Long requestId = 206L; buildMockedRequest(requestId); - when(mockUser.isReleasingUbuntuAccount()).thenReturn(true); + when(mockUser.isReleasingUbuntuAccount(any())).thenReturn(true); assertThatThrownBy(() -> service.approveRequest(new ApproveRequestDTO(requestId, 1L, 1, null))) .isInstanceOf(BusinessException.class) @@ -541,7 +541,7 @@ void registersPodOnlyWhenAccountExists() { // Given Long requestId = 202L; buildMockedRequest(requestId); - when(mockUser.hasUbuntuAccount()).thenReturn(true); + when(mockUser.hasUbuntuAccount(any())).thenReturn(true); // When service.approveRequest(new ApproveRequestDTO(requestId, 1L, 1, null)); @@ -671,7 +671,7 @@ void completesApprovalFromJobResult() { // Given Long requestId = 204L; Request request = processingRequest(requestId); - when(mockUser.getUbuntuUid()).thenReturn(50001L); + when(mockUser.ubuntuUidOn(any())).thenReturn(50001L); when(mockUser.getUbuntuGid()).thenReturn(50001L); when(podExternalPortRepository.save(any(PodExternalPort.class))).thenAnswer(inv -> inv.getArgument(0)); @@ -684,7 +684,7 @@ void completesApprovalFromJobResult() { service.completeApprovalJob(requestId, made); // Then - verify(mockUser).assignUbuntuAccount(50001L, 50001L); + verify(mockUser).assignUbuntuAccount(any(), eq(50001L), eq(50001L)); verify(request).assignPodInfo("ailab-testuser-abcd", "farm2"); verify(request).completeApproval(); verify(podExternalPortRepository, times(2)).save(any(PodExternalPort.class)); @@ -922,7 +922,7 @@ void completionWithoutGidHaltsAndAlertsOnce() { assertThat(pending.getUbuntuGid()).isNull(); verify(request, never()).completeApproval(); verify(request, never()).assignPodInfo(any(), any()); - verify(mockUser, never()).assignUbuntuAccount(any(), any()); + verify(mockUser, never()).assignUbuntuAccount(any(), any(), any()); verify(transactionStatus, times(2)).setRollbackOnly(); assertThat(Alerts.needsAction(alarmService)).filteredOn(alert -> alert.contains("vision-lab")).hasSize(1); verify(userGuideMailer, never()).sendContainerCreatedEmail(any(), any(), any()); diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupSchedulerTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupSchedulerTest.java index 24c7f692..c4fb5aeb 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupSchedulerTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeCleanupSchedulerTest.java @@ -60,7 +60,7 @@ private void candidates(Long... userIds) { when(user.getUserId()).thenReturn(id); return user; }).toList(); - when(userRepository.findHomeCleanupCandidates(any(), any())).thenReturn(users); + when(userRepository.findHomeCleanupCandidates(any(), any(), any())).thenReturn(users); } @Test diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java index b4134830..2f19c949 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/scheduler/HomeDeletionReminderSchedulerTest.java @@ -56,7 +56,7 @@ void setUp() { when(valueOps.setIfAbsent(anyString(), any(), any(Duration.class))).thenReturn(true); when(messageUtils.get(anyString(), any(Object[].class))).thenAnswer(i -> i.getArgument(0)); when(alarmService.notifyUser(anyString(), anyString(), anyString(), anyString())).thenReturn(true); - when(userRepository.findHomeReminderCandidates(any(), any(), any())).thenReturn(List.of()); + when(userRepository.findHomeReminderCandidates(any(), any(), any(), any())).thenReturn(List.of()); scheduler = new HomeDeletionReminderScheduler( userRepository, new HomeRetentionPolicy(), alarmService, messageUtils, redisTemplate); } @@ -67,12 +67,12 @@ private User user(Long id, String name, String email, String username, LocalDate when(user.getName()).thenReturn(name); when(user.getEmail()).thenReturn(email); when(user.getUbuntuUsername()).thenReturn(username); - when(user.lastContainerEndedAt()).thenReturn(Optional.of(endedOn.atStartOfDay())); + when(user.lastContainerEndedAt(User.PRIMARY_SERVER)).thenReturn(Optional.of(endedOn.atStartOfDay())); return user; } private void candidates(User... users) { - when(userRepository.findHomeReminderCandidates(any(), any(), any())).thenReturn(List.of(users)); + when(userRepository.findHomeReminderCandidates(any(), any(), any(), any())).thenReturn(List.of(users)); } @Test @@ -82,7 +82,7 @@ void queriesCatchUpWindow() { // 삭제일 11/11~11/17 = 끝난 날 10/12~10/18. 끝난 시각 [10/12 0시, 10/19 0시). verify(userRepository).findHomeReminderCandidates( - eq(LocalDateTime.of(2026, 10, 12, 0, 0)), eq(LocalDateTime.of(2026, 10, 19, 0, 0)), any()); + eq(LocalDateTime.of(2026, 10, 12, 0, 0)), eq(LocalDateTime.of(2026, 10, 19, 0, 0)), any(), eq(User.PRIMARY_SERVER)); } @Test diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UbuntuAccountTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UbuntuAccountTest.java new file mode 100644 index 00000000..ffb91b70 --- /dev/null +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UbuntuAccountTest.java @@ -0,0 +1,86 @@ +package DGU_AI_LAB.admin_be.domain.users.entity; + +import DGU_AI_LAB.admin_be.error.exception.BusinessException; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +class UbuntuAccountTest { + + private UbuntuAccount account; + + @BeforeEach + void setUp() { + account = new UbuntuAccount(null, "LAB", "hong"); + } + + @Test + void startsWithoutAccount() { + assertThat(account.getStatus()).isEqualTo(UbuntuAccountStatus.NONE); + assertThat(account.isActive()).isFalse(); + assertThat(account.getUid()).isNull(); + } + + @Test + void assign_isIdempotentAndRejectsConflictingIds() { + account.assign(10002L, 10002L); + account.assign(10002L, 10002L); + + assertThat(account.isActive()).isTrue(); + assertThatThrownBy(() -> account.assign(10003L, 10003L)).isInstanceOf(BusinessException.class); + assertThat(account.getUid()).isEqualTo(10002L); + } + + @Test + void assign_rejectsInvalidIds() { + assertThatThrownBy(() -> account.assign(null, 1L)).isInstanceOf(BusinessException.class); + assertThatThrownBy(() -> account.assign(1L, 0L)).isInstanceOf(BusinessException.class); + } + + @Test + void assign_rejectedWhileReleasing() { + account.assign(10002L, 10002L); + account.beginRelease(); + + assertThatThrownBy(() -> account.assign(10002L, 10002L)).isInstanceOf(BusinessException.class); + } + + @Test + void releaseLifecycle_keepsIdentity() { + assertThat(account.beginRelease()).isFalse(); + assertThatThrownBy(account::release).isInstanceOf(BusinessException.class); + + account.assign(10002L, 10002L); + assertThatThrownBy(account::release).isInstanceOf(BusinessException.class); + assertThat(account.beginRelease()).isTrue(); + assertThat(account.beginRelease()).isTrue(); + assertThat(account.isReleasing()).isTrue(); + + account.release(); + assertThat(account.getStatus()).isEqualTo(UbuntuAccountStatus.NONE); + assertThat(account.getUid()).isEqualTo(10002L); + assertThat(account.getUsername()).isEqualTo("hong"); + + account.assign(10002L, 10002L); + assertThat(account.isActive()).isTrue(); + } + + @Test + void abortRelease_restoresActive() { + account.assign(10002L, 10002L); + account.beginRelease(); + + account.abortRelease(); + + assertThat(account.isActive()).isTrue(); + assertThatThrownBy(account::abortRelease).isInstanceOf(BusinessException.class); + } + + @Test + void sameServer_matchesIgnoringCase() { + assertThat(account.isServer("lab")).isTrue(); + assertThat(account.isServer("FARM")).isFalse(); + } +} diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java index 7756f958..1d1793af 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/entity/UserTest.java @@ -162,6 +162,82 @@ void releaseUbuntuAccount_clearsGroups() { assertThat(user.getUserGroups()).isEmpty(); } + + @Test + @DisplayName("서버마다 계정이 따로다 — 다른 서버 계정은 기본 서버 옛 컬럼을 건드리지 않는다") + void accountsAreSeparatePerServer() { + user.assignUbuntuAccount("LAB", 10002L, 10002L); + + assertThat(user.hasUbuntuAccount("LAB")).isTrue(); + assertThat(user.hasUbuntuAccount(User.PRIMARY_SERVER)).isFalse(); + assertThat(user.getUbuntuUid()).isNull(); + assertThat(user.ubuntuUidOn("lab")).isEqualTo(10002L); + + user.assignUbuntuAccount(User.PRIMARY_SERVER, 20001L, 20001L); + assertThat(user.getUbuntuUid()).isEqualTo(20001L); + assertThat(user.getUbuntuAccountStatus()).isEqualTo(UbuntuAccountStatus.ACTIVE); + assertThat(user.ubuntuUidOn("LAB")).isEqualTo(10002L); + } + + @Test + @DisplayName("기본 서버 계정의 변경은 옛 컬럼에 미러링된다(롤백 안전)") + void primaryServerWritesAreMirrored() { + user.assignUbuntuAccount(User.PRIMARY_SERVER, 20001L, 20001L); + user.beginUbuntuAccountRelease(User.PRIMARY_SERVER); + assertThat(user.getUbuntuAccountStatus()).isEqualTo(UbuntuAccountStatus.RELEASING); + + user.releaseUbuntuAccount(User.PRIMARY_SERVER); + assertThat(user.getUbuntuAccountStatus()).isEqualTo(UbuntuAccountStatus.NONE); + assertThat(user.getUbuntuUid()).isEqualTo(20001L); + } + + @Test + @DisplayName("다른 서버 계정을 회수해도 기본 서버의 그룹 소속은 남는다") + void releasingOtherServerKeepsGroups() { + user.assignUbuntuAccount(User.PRIMARY_SERVER, 20001L, 20001L); + user.assignUbuntuAccount("LAB", 10002L, 10002L); + user.addGroupIfAbsent(Group.builder().groupName("team").ubuntuGid(70001L).build()); + + user.beginUbuntuAccountRelease("LAB"); + user.releaseUbuntuAccount("LAB"); + + assertThat(user.getUserGroups()).hasSize(1); + assertThat(user.hasUbuntuAccount(User.PRIMARY_SERVER)).isTrue(); + assertThat(user.isReleasingUbuntuAccount()).isFalse(); + } + + @Test + @DisplayName("전 서버 회수는 계정 있는 서버만 RELEASING으로 바꾸고 NONE 계정은 건드리지 않는다") + void beginReleaseOnAllServers_onlyAffectsExistingAccounts() { + user.assignUbuntuAccount(User.PRIMARY_SERVER, 20001L, 20001L); + user.assignUbuntuAccount("LAB", 10002L, 10002L); + user.beginUbuntuAccountRelease("LAB"); + user.releaseUbuntuAccount("LAB"); + user.assignUbuntuAccount("LAB", 10002L, 10002L); + + assertThat(user.beginUbuntuAccountReleaseOnAllServers()).isTrue(); + assertThat(user.isReleasingUbuntuAccount(User.PRIMARY_SERVER)).isTrue(); + assertThat(user.isReleasingUbuntuAccount("LAB")).isTrue(); + assertThat(user.getUbuntuAccountStatus()).isEqualTo(UbuntuAccountStatus.RELEASING); + + user.releaseUbuntuAccount("LAB"); + assertThat(user.isReleasingUbuntuAccount(User.PRIMARY_SERVER)).isTrue(); + assertThat(user.isReleasingUbuntuAccount()).isTrue(); + } + + @Test + @DisplayName("회수할 계정이 없으면 전 서버 회수는 false다") + void beginReleaseOnAllServers_noAccounts() { + assertThat(user.beginUbuntuAccountReleaseOnAllServers()).isFalse(); + } + + @Test + @DisplayName("계정이 없는 서버의 유저네임은 가입 때 고른 이름이다") + void usernameFallsBackToChosenName() { + assertThat(user.ubuntuUsernameOn("LAB")).isEqualTo("honggildong"); + assertThat(user.beginUbuntuAccountRelease("LAB")).isFalse(); + assertThat(user.hasAnyUbuntuAccountInLedger()).isFalse(); + } } @Nested diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java index 7030ad14..d01d1518 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/repository/UserRepositoryTest.java @@ -252,11 +252,11 @@ void windowIsHalfOpen() { deletedRequest(user1, from); // 포함(경계) deletedRequest(user2, to); // 제외(상한 미포함) - List result = userRepository.findHomeReminderCandidates(from, to, Status.openStatuses()); + List result = userRepository.findHomeReminderCandidates(from, to, Status.openStatuses(), User.PRIMARY_SERVER); assertThat(result).extracting(User::getEmail).containsExactly("active@dgu.ac.kr"); // 안내 후보는 삭제 후보의 부분집합이어야 한다 — 두 질의의 공통 조건이 어긋나면 여기서 드러난다. - assertThat(userRepository.findHomeCleanupCandidates(to.plusDays(1), Status.openStatuses())) + assertThat(userRepository.findHomeCleanupCandidates(to.plusDays(1), Status.openStatuses(), User.PRIMARY_SERVER)) .containsAll(result); } @@ -267,7 +267,7 @@ void usesLatestEnd() { deletedRequest(user1, from.plusHours(1)); deletedRequest(user1, to.plusDays(5)); - assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses(), User.PRIMARY_SERVER)).isEmpty(); } @Test @@ -277,7 +277,7 @@ void excludes() { withAccount(user2); deletedRequest(user2, from.plusHours(1)); persistRequest(user2); // 열린 신청 - assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses(), User.PRIMARY_SERVER)).isEmpty(); User gone = userRepository.save(User.builder().email("gone@dgu.ac.kr").password("p") .name("탈퇴").studentId("2021008888").phone("010-8888-8888").department("컴퓨터공학과").build()); @@ -286,7 +286,7 @@ void excludes() { gone = userRepository.findById(gone.getUserId()).orElseThrow(); gone.withdraw(); userRepository.saveAndFlush(gone); - assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses(), User.PRIMARY_SERVER)).isEmpty(); } @Test @@ -298,10 +298,39 @@ void excludesInactive() { user1.deactivate(); userRepository.saveAndFlush(user1); - assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses())).isEmpty(); + assertThat(userRepository.findHomeReminderCandidates(from, to, Status.openStatuses(), User.PRIMARY_SERVER)).isEmpty(); } } + @Test + @DisplayName("existsByUbuntuUsername은 다른 서버 계정에 이미 있는 유저네임도 사용 중으로 본다") + void existsByUbuntuUsername_seesAccountNames() { + user1.assignUbuntuAccount("LAB", 10002L, 10002L); + ReflectionTestUtils.setField(user1.ubuntuAccount("LAB").orElseThrow(), "username", "legacyname"); + userRepository.saveAndFlush(user1); + entityManager.clear(); + + assertThat(userRepository.existsByUbuntuUsername("legacyname")).isTrue(); + assertThat(userRepository.existsByUbuntuUsername("nobody-has-this")).isFalse(); + } + + @Test + @DisplayName("홈 삭제 후보는 기본 서버의 신청만 본다 — 다른 서버 컨테이너가 끝났다고 그 서버 홈을 지우지 않는다") + void homeCleanupCandidates_areScopedToServer() { + user1.assignUbuntuAccount(60001L, 60001L); + ReflectionTestUtils.setField(user1, "ubuntuUsername", "scoped1"); + userRepository.saveAndFlush(user1); + Long id = persistRequest(user1); + entityManager.getEntityManager() + .createNativeQuery("UPDATE requests SET status = 'DELETED', approved_at = :t, updated_at = :t WHERE request_id = :id") + .setParameter("t", LocalDateTime.of(2026, 1, 1, 0, 0)).setParameter("id", id).executeUpdate(); + entityManager.clear(); + LocalDateTime cutoff = LocalDateTime.of(2026, 6, 1, 0, 0); + + assertThat(userRepository.findHomeCleanupCandidates(cutoff, Status.openStatuses(), "FARM")).contains(user1); + assertThat(userRepository.findHomeCleanupCandidates(cutoff, Status.openStatuses(), "LAB")).doesNotContain(user1); + } + private Long persistRequest(User user) { ResourceGroup rg = entityManager.persist(ResourceGroup.builder() .resourceGroupName("rg" + System.nanoTime()).description("GPU").serverName("FARM").build()); @@ -335,4 +364,24 @@ void replacesOnlyMissingOrWeakHash() { .isEqualTo(CURRENT + "s$new2"); } } + + @Nested + @DisplayName("findAllWithReleasingAccount") + class ReleasingAccounts { + + @Test + @DisplayName("어느 서버든 RELEASING 계정이 있는 사용자만, 중복 없이 돌려준다") + void returnsDistinctUsersWithReleasingAccount() { + user1.assignUbuntuAccount("FARM", 20001L, 20001L); + user1.assignUbuntuAccount("LAB", 10001L, 10001L); + user1.beginUbuntuAccountReleaseOnAllServers(); + user2.assignUbuntuAccount("LAB", 10002L, 10002L); + userRepository.saveAll(List.of(user1, user2)); + entityManager.flush(); + entityManager.clear(); + + assertThat(userRepository.findAllWithReleasingAccount()) + .extracting(User::getUserId).containsExactly(user1.getUserId()); + } + } } diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetServiceTest.java index fe88e038..af35b708 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/PasswordResetServiceTest.java @@ -250,6 +250,21 @@ void locksUserBeforeReadingState() { order.verify(jobClient).registerPasswordChange(any()); } + @Test + @DisplayName("기본 서버 밖에 활성 계정이 있으면 작업을 등록하지 않고 막는다") + void rejectsWhenActiveAccountOutsidePrimaryServer() { + withAccount(); + user.assignUbuntuAccount("LAB", 10002L, 10002L); + PasswordResetRequest reset = pendingReset(); + + assertThatThrownBy(() -> service.approve(CHANGE_ID, ADMIN_ID, "확인")) + .isInstanceOf(BusinessException.class) + .hasFieldOrPropertyWithValue("errorCode", ErrorCode.INVALID_REQUEST_STATUS); + assertThat(reset.getStatus()).isEqualTo(Status.PENDING); + verifyNoInteractions(jobClient); + assertUserUnchanged(); + } + @Test @DisplayName("컨테이너 생성 중이면 409로 막고 작업을 등록하지 않는다") void rejectsWhileProvisioning() { diff --git a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseServiceTest.java b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseServiceTest.java index 5e72bbdf..53f57cf2 100644 --- a/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseServiceTest.java +++ b/src/test/java/DGU_AI_LAB/admin_be/domain/users/service/UbuntuAccountReleaseServiceTest.java @@ -86,6 +86,7 @@ private Request request(long requestId, Status status, String node, Long jobId) when(r.getStatus()).thenReturn(status); when(r.getNodeName()).thenReturn(node); when(r.getJobId()).thenReturn(jobId); + when(r.getServerName()).thenReturn(User.PRIMARY_SERVER); when(requestRepository.findByIdForUpdate(requestId)).thenReturn(Optional.of(r)); requests.add(r); return r;