🔀 :: [#717] - 볼륨 마운트 API 추가

src/main/kotlin/com/dcd/server/core/domain/application/service/impl/CreateContainerServiceImpl.kt

@@ -5,21 +5,34 @@ import com.dcd.server.core.domain.application.model.Application
 import com.dcd.server.core.domain.application.service.CreateContainerService
 import com.dcd.server.core.domain.application.spi.CheckExitValuePort
 import com.dcd.server.core.domain.application.util.FailureCase
+import com.dcd.server.core.domain.volume.spi.QueryVolumePort
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.springframework.stereotype.Service
 
 @Service
 class CreateContainerServiceImpl(
     private val commandPort: CommandPort,
+    private val queryVolumePort: QueryVolumePort,
     private val checkExitValuePort: CheckExitValuePort
 ) : CreateContainerService {
     override suspend fun createContainer(application: Application, externalPort: Int) {
         withContext(Dispatchers.IO) {
+            val volumeMountBuilder = StringBuilder()
+            queryVolumePort.findAllMountByApplication(application)
+                .forEach {
+                    val volume = it.volume
+                    volumeMountBuilder.append("-v ${volume.name}:${it.mountPath}")
+                    if (it.readOnly)
+                        volumeMountBuilder.append(":ro")
+                    volumeMountBuilder.append(" ")
+                }
+            val volumeMountFlags = volumeMountBuilder.toString()
             val cmd =
                 "docker create --network ${application.workspace.networkName} " +
-                        "--name ${application.containerName} " +
-                        "-p ${externalPort}:${application.port} ${application.containerName}:latest"
+                "--name ${application.containerName} " +
+                volumeMountFlags +
+                "-p ${externalPort}:${application.port} ${application.containerName}:latest"
 
             commandPort.executeShellCommand(cmd)
                 .also {exitValue ->

src/main/kotlin/com/dcd/server/core/domain/volume/dto/request/MountVolumeReqDto.kt

@@ -0,0 +1,6 @@
+package com.dcd.server.core.domain.volume.dto.request
+
+data class MountVolumeReqDto(
+    val mountPath: String,
+    val readOnly: Boolean,
+)

src/main/kotlin/com/dcd/server/core/domain/volume/spi/CommandVolumePort.kt

@@ -1,9 +1,12 @@
 package com.dcd.server.core.domain.volume.spi
 
 import com.dcd.server.core.domain.volume.model.Volume
+import com.dcd.server.core.domain.volume.model.VolumeMount
 
 interface CommandVolumePort {
     fun save(volume: Volume)
 
     fun delete(volume: Volume)
+
+    fun saveMount(volumeMount: VolumeMount)
 }

src/main/kotlin/com/dcd/server/core/domain/volume/usecase/MountVolumeUseCase.kt

@@ -0,0 +1,52 @@
+package com.dcd.server.core.domain.volume.usecase
+
+import com.dcd.server.core.common.annotation.UseCase
+import com.dcd.server.core.common.data.WorkspaceInfo
+import com.dcd.server.core.domain.application.event.DeployApplicationEvent
+import com.dcd.server.core.domain.application.exception.ApplicationNotFoundException
+import com.dcd.server.core.domain.application.spi.QueryApplicationPort
+import com.dcd.server.core.domain.volume.dto.request.MountVolumeReqDto
+import com.dcd.server.core.domain.volume.exception.VolumeNotFoundException
+import com.dcd.server.core.domain.volume.model.VolumeMount
+import com.dcd.server.core.domain.volume.spi.CommandVolumePort
+import com.dcd.server.core.domain.volume.spi.QueryVolumePort
+import com.dcd.server.core.domain.workspace.exception.WorkspaceNotFoundException
+import org.springframework.context.ApplicationEventPublisher
+import java.util.UUID
+
+@UseCase
+class MountVolumeUseCase(
+    private val queryVolumePort: QueryVolumePort,
+    private val queryApplicationPort: QueryApplicationPort,
+    private val commandVolumePort: CommandVolumePort,
+    private val workspaceInfo: WorkspaceInfo,
+    private val eventPublisher: ApplicationEventPublisher,
+) {
+    fun execute(volumeId: UUID, applicationId: String, mountVolumeReqDto: MountVolumeReqDto) {
+        val workspace = (workspaceInfo.workspace
+            ?: throw WorkspaceNotFoundException())
+
+        val volume = (queryVolumePort.findById(volumeId)
+            ?: throw VolumeNotFoundException())
+
+        if (volume.workspace != workspace)
+            throw VolumeNotFoundException()
+
+        val application = (queryApplicationPort.findById(applicationId)
+            ?: throw ApplicationNotFoundException())
+        if (application.workspace != workspace)
+            throw ApplicationNotFoundException()
+
+        val volumeMount = VolumeMount(
+            id = UUID.randomUUID(),
+            application = application,
+            volume = volume,
+            mountPath = mountVolumeReqDto.mountPath,
+            readOnly = mountVolumeReqDto.readOnly
+        )
+        commandVolumePort.saveMount(volumeMount)
+
+        //마운트 생성후 대상 애플리케이션 재배포
+        eventPublisher.publishEvent(DeployApplicationEvent(listOf(application.id)))
+    }
+}

src/main/kotlin/com/dcd/server/infrastructure/global/config/SecurityConfig.kt

@@ -104,6 +104,7 @@ class SecurityConfig(
                 it.requestMatchers(HttpMethod.PUT, "/{workspaceId}/volume/{volumeId}").authenticated()
                 it.requestMatchers(HttpMethod.GET, "/{workspaceId}/volume").authenticated()
                 it.requestMatchers(HttpMethod.GET, "/{workspaceId}/volume/{volumeId}").authenticated()
+                it.requestMatchers(HttpMethod.POST, "/{workspaceId}/volume/{volumeId}/mount").authenticated()
 
                 //when url not set
                 it.anyRequest().denyAll()

src/main/kotlin/com/dcd/server/persistence/volume/VolumePersistenceAdapter.kt

@@ -28,6 +28,10 @@ class VolumePersistenceAdapter(
         volumeRepository.deleteById(volume.id)
     }
 
+    override fun saveMount(volumeMount: VolumeMount) {
+        volumeMountRepository.save(volumeMount.toEntity())
+    }
+
     override fun findById(id: UUID): Volume? =
         volumeRepository.findByIdOrNull(id)
             ?.toDomain()

src/main/kotlin/com/dcd/server/presentation/domain/volume/VolumeWebAdapter.kt

@@ -5,11 +5,13 @@ import com.dcd.server.core.domain.volume.usecase.CreateVolumeUseCase
 import com.dcd.server.core.domain.volume.usecase.DeleteVolumeUseCase
 import com.dcd.server.core.domain.volume.usecase.GetAllVolumeUseCase
 import com.dcd.server.core.domain.volume.usecase.GetOneVolumeUseCase
+import com.dcd.server.core.domain.volume.usecase.MountVolumeUseCase
 import com.dcd.server.core.domain.volume.usecase.UpdateVolumeUseCase
 import com.dcd.server.presentation.common.annotation.WebAdapter
 import com.dcd.server.presentation.domain.volume.data.extension.toDto
 import com.dcd.server.presentation.domain.volume.data.extension.toResponse
 import com.dcd.server.presentation.domain.volume.data.request.CreateVolumeRequest
+import com.dcd.server.presentation.domain.volume.data.request.MountVolumeRequest
 import com.dcd.server.presentation.domain.volume.data.request.UpdateVolumeRequest
 import com.dcd.server.presentation.domain.volume.data.response.VolumeDetailResponse
 import com.dcd.server.presentation.domain.volume.data.response.VolumeListResponse
@@ -21,6 +23,7 @@ import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.PutMapping
 import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestParam
 import java.util.UUID
 
 @WebAdapter("/{workspaceId}/volume")
@@ -29,7 +32,8 @@ class VolumeWebAdapter(
     private val deleteVolumeUseCase: DeleteVolumeUseCase,
     private val updateVolumeUseCase: UpdateVolumeUseCase,
     private val getAllVolumeUseCase: GetAllVolumeUseCase,
-    private val getOneVolumeUseCase: GetOneVolumeUseCase
+    private val getOneVolumeUseCase: GetOneVolumeUseCase,
+    private val mountVolumeUseCase: MountVolumeUseCase
 ) {
     @PostMapping
     @WorkspaceOwnerVerification("#workspaceId")
@@ -73,4 +77,15 @@ class VolumeWebAdapter(
     ): ResponseEntity<VolumeDetailResponse> =
         getOneVolumeUseCase.execute(volumeId)
             .let { ResponseEntity.ok(it.toResponse()) }
+
+    @PostMapping("/{volumeId}/mount")
+    @WorkspaceOwnerVerification("#workspaceId")
+    fun mountVolume(
+        @PathVariable workspaceId: String,
+        @PathVariable volumeId: UUID,
+        @RequestParam applicationId: String,
+        @Validated @RequestBody mountVolumeRequest: MountVolumeRequest
+    ): ResponseEntity<Void> =
+        mountVolumeUseCase.execute(volumeId, applicationId, mountVolumeRequest.toDto())
+            .run { ResponseEntity.ok().build() }
 }

src/main/kotlin/com/dcd/server/presentation/domain/volume/data/extension/VolumeRequestExtension.kt

@@ -1,8 +1,10 @@
 package com.dcd.server.presentation.domain.volume.data.extension
 
 import com.dcd.server.core.domain.volume.dto.request.CreateVolumeReqDto
+import com.dcd.server.core.domain.volume.dto.request.MountVolumeReqDto
 import com.dcd.server.core.domain.volume.dto.request.UpdateVolumeReqDto
 import com.dcd.server.presentation.domain.volume.data.request.CreateVolumeRequest
+import com.dcd.server.presentation.domain.volume.data.request.MountVolumeRequest
 import com.dcd.server.presentation.domain.volume.data.request.UpdateVolumeRequest
 
 fun CreateVolumeRequest.toDto(): CreateVolumeReqDto =
@@ -15,4 +17,10 @@ fun UpdateVolumeRequest.toDto(): UpdateVolumeReqDto =
     UpdateVolumeReqDto(
         name = this.name,
         description = this.description
+    )
+
+fun MountVolumeRequest.toDto(): MountVolumeReqDto =
+    MountVolumeReqDto(
+        mountPath = this.mountPath,
+        readOnly = this.readOnly
     )

src/main/kotlin/com/dcd/server/presentation/domain/volume/data/request/MountVolumeRequest.kt

@@ -0,0 +1,11 @@
+package com.dcd.server.presentation.domain.volume.data.request
+
+import jakarta.validation.constraints.NotBlank
+import jakarta.validation.constraints.Pattern
+
+data class MountVolumeRequest(
+    @field:NotBlank
+    @field:Pattern(regexp = "^(?!(?:/(?:proc|sys|dev|etc)?$))/(?:(?:[A-Za-z0-9._-]+/)*[A-Za-z0-9._-]+)?$")
+    val mountPath: String,
+    val readOnly: Boolean,
+)

src/test/kotlin/com/dcd/server/core/domain/application/service/CreateContainerServiceImplTest.kt

@@ -4,22 +4,26 @@ import com.dcd.server.core.common.command.CommandPort
 import com.dcd.server.core.domain.application.service.impl.CreateContainerServiceImpl
 import com.dcd.server.core.domain.application.spi.CheckExitValuePort
 import com.dcd.server.core.domain.application.util.FailureCase
+import com.dcd.server.core.domain.volume.spi.QueryVolumePort
 import io.kotest.core.spec.style.BehaviorSpec
+import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.CoroutineScope
 import util.application.ApplicationGenerator
 
 class CreateContainerServiceImplTest : BehaviorSpec({
     val commandPort = mockk<CommandPort>(relaxed = true)
+    val queryVolumePort = mockk<QueryVolumePort>(relaxed = true)
     val checkExitValuePort = mockk<CheckExitValuePort>(relaxUnitFun = true)
-    val createContainerService = CreateContainerServiceImpl(commandPort, checkExitValuePort)
+    val createContainerService = CreateContainerServiceImpl(commandPort, queryVolumePort, checkExitValuePort)
 
     given("애플리케이션이 주어지고") {
         val application = ApplicationGenerator.generateApplication()
 
         `when`("service를 실행할때") {
             createContainerService.createContainer(application, application.externalPort)
+            every { queryVolumePort.findAllMountByApplication(application) } returns listOf()
 
             then("컨테이너를 실행하는 명령을 실행해야함") {
                 verify {

src/test/kotlin/com/dcd/server/core/domain/application/usecase/DeployApplicationUseCaseTest.kt

@@ -4,6 +4,7 @@ import com.dcd.server.core.common.command.CommandPort
 import com.dcd.server.core.domain.application.exception.ApplicationNotFoundException
 import com.dcd.server.core.domain.application.exception.CanNotDeployApplicationException
 import com.dcd.server.core.domain.application.model.enums.ApplicationStatus
+import com.dcd.server.core.domain.application.service.CreateContainerService
 import com.dcd.server.core.domain.application.service.impl.CreateDockerFileServiceImpl
 import com.dcd.server.core.domain.application.spi.CommandApplicationPort
 import com.dcd.server.core.domain.application.spi.QueryApplicationPort
@@ -18,6 +19,7 @@ import com.ninjasquad.springmockk.MockkBean
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
+import io.mockk.verify
 import org.springframework.boot.test.context.SpringBootTest
 import org.springframework.test.context.ActiveProfiles
 import org.springframework.transaction.annotation.Transactional
@@ -32,6 +34,8 @@ class DeployApplicationUseCaseTest(
     private val commandPort: CommandPort,
     @MockkBean(relaxUnitFun = true)
     private val createDockerFileService: CreateDockerFileServiceImpl,
+    @MockkBean(relaxUnitFun = true)
+    private val createContainerService: CreateContainerService,
     private val commandUserPort: CommandUserPort,
     private val commandWorkspacePort: CommandWorkspacePort,
     private val commandApplicationPort: CommandApplicationPort,
@@ -64,13 +68,7 @@ class DeployApplicationUseCaseTest(
                 coVerify { commandPort.executeShellCommand("docker rmi ${result.containerName}") }
                 coVerify { commandPort.executeShellCommand("git clone ${result.githubUrl} '${result.name}'") }
                 coVerify { commandPort.executeShellCommand("cd ./'${result.name}' && docker build -t ${result.containerName}:latest .") }
-                coVerify {
-                    commandPort.executeShellCommand(
-                        "docker create --network ${result.workspace.title.replace(' ', '_')} " +
-                            "--name ${result.containerName} " +
-                            "-p ${result.externalPort}:${result.port} ${result.containerName}:latest"
-                    )
-                }
+                coVerify { createContainerService.createContainer(result, result.externalPort) }
                 coVerify { commandPort.executeShellCommand("rm -rf '${result.name}'") }
             }
         }