feat: Orchestrator start with context

src/main/kotlin/org/rooftop/netx/api/Orchestrator.kt

@@ -8,7 +8,15 @@ interface Orchestrator<T : Any, V : Any> {
 
     fun transaction(timeoutMillis: Long, request: T): Mono<Result<V>>
 
+    fun transaction(request: T, context: MutableMap<String, Any>): Mono<Result<V>>
+
+    fun transaction(timeoutMillis: Long, request: T, context: MutableMap<String, Any>): Mono<Result<V>>
+
     fun transactionSync(request: T): Result<V>
 
     fun transactionSync(timeoutMillis: Long, request: T): Result<V>
+
+    fun transactionSync(request: T, context: MutableMap<String, Any>): Result<V>
+
+    fun transactionSync(timeoutMillis: Long, request: T, context: MutableMap<String, Any>): Result<V>
 }

src/main/kotlin/org/rooftop/netx/engine/OrchestratorManager.kt

@@ -23,11 +23,37 @@ class OrchestratorManager<T : Any, V : Any> internal constructor(
             ?: throw TransactionException("Cannot start transaction \"$request\"")
     }
 
+    override fun transactionSync(request: T, context: MutableMap<String, Any>): Result<V> {
+        return transaction(request, context).block()
+            ?: throw TransactionException("Cannot start transaction \"$request\"")
+    }
+
+    override fun transactionSync(
+        timeoutMillis: Long,
+        request: T,
+        context: MutableMap<String, Any>
+    ): Result<V> {
+        return transaction(timeoutMillis, request, context).block()
+            ?: throw TransactionException("Cannot start transaction \"$request\"")
+    }
+
     override fun transaction(request: T): Mono<Result<V>> {
-        return transaction(TEN_SECONDS_TO_TIME_OUT, request)
+        return transaction(TEN_SECONDS_TO_TIME_OUT, request, mutableMapOf())
     }
 
     override fun transaction(timeoutMillis: Long, request: T): Mono<Result<V>> {
+        return transaction(timeoutMillis, request, mutableMapOf())
+    }
+
+    override fun transaction(request: T, context: MutableMap<String, Any>): Mono<Result<V>> {
+        return transaction(TEN_SECONDS_TO_TIME_OUT, request, context)
+    }
+
+    override fun transaction(
+        timeoutMillis: Long,
+        request: T,
+        context: MutableMap<String, Any>
+    ): Mono<Result<V>> {
         return Mono.just(request)
             .doOnNext { _ ->
                 orchestrateListener.setCastableType(request::class)
@@ -37,7 +63,7 @@ class OrchestratorManager<T : Any, V : Any> internal constructor(
                 OrchestrateEvent(
                     orchestratorId = orchestratorId,
                     clientEvent = codec.encode(request),
-                    context = codec.encode(mutableMapOf<String, String>())
+                    context = codec.encode(context.mapValues { codec.encode(it.value) })
                 )
             }
             .flatMap { transactionManager.start(UNDO, it) }

src/test/kotlin/org/rooftop/netx/engine/OrchestratorConfigurer.kt

@@ -197,6 +197,17 @@ class OrchestratorConfigurer(
             })
     }
 
+    @Bean(name = ["startWithContextOrchestrator"])
+    fun startWithContextOrchestrator(): Orchestrator<String, String> {
+        return orchestratorFactory.create<String>("startWithContextOrchestrator")
+            .startWithContext({ context, _ ->
+                context.decodeContext("key", String::class)
+            })
+            .commitWithContext({ context, _ ->
+                context.decodeContext("key", String::class)
+            })
+    }
+
     object PairOrchestrate :
         Orchestrate<Pair<OrchestratorTest.Foo, OrchestratorTest.Foo>, Pair<OrchestratorTest.Foo, OrchestratorTest.Foo>> {
         override fun orchestrate(request: Pair<OrchestratorTest.Foo, OrchestratorTest.Foo>): Pair<OrchestratorTest.Foo, OrchestratorTest.Foo> {

src/test/kotlin/org/rooftop/netx/engine/OrchestratorTest.kt

@@ -34,6 +34,7 @@ class OrchestratorTest(
     @Qualifier("monoRollbackOrchestrator") private val monoRollbackOrchestrator: Orchestrator<String, String>,
     @Qualifier("contextOrchestrator") private val contextOrchestrator: Orchestrator<String, String>,
     @Qualifier("pairOrchestrator") private val pairOrchestrator: Orchestrator<String, Pair<Foo, Foo>>,
+    @Qualifier("startWithContextOrchestrator") private val startWithContextOrchestrator: Orchestrator<String, String>,
 ) : DescribeSpec({
 
     describe("numberOrchestrator 구현채는") {
@@ -173,6 +174,19 @@ class OrchestratorTest(
             }
         }
     }
+
+    describe("startWithContextOrchestrator 구현채는") {
+        context("context와 함께 transaction 메소드가 호출되면,") {
+            it("key에 해당하는 context를 반환한다.") {
+                val result = startWithContextOrchestrator.transactionSync(
+                    "ignored request",
+                    mutableMapOf("key" to "hello")
+                )
+
+                result.decodeResultOrThrow(String::class) shouldBeEqual "hello"
+            }
+        }
+    }
 }) {
     data class Home(
         val address: String,