fix: write using buffered output

core/src/main/scala/Block.scala

@@ -47,7 +47,7 @@ class Block(val records: LazyList[Record]) extends AnyVal {
 
   def writeTo(path: Path): File = {
     val file = File(path)
-    val writer = file.bufferedWriter()
+    val writer = file.bufferedOutput()
 
     try {
       toChars.foreach(writer.write(_))
@@ -65,7 +65,7 @@ class Block(val records: LazyList[Record]) extends AnyVal {
       .zipWithIndex
       .map({ case (records, index) =>
         val file = File(directory / s"partition.$index")
-        val writer = file.bufferedWriter()
+        val writer = file.bufferedOutput()
 
         try {
           records.foreach(_.toChars.foreach(writer.write(_)))

rpc/src/main/protobuf/exchange.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package kr.ac.postech.paranode.rpc;
+
+import "common.proto";
+
+service Exchange {
+  rpc Save (SaveRequest) returns (SaveReply) {}
+}
+
+
+message SaveRequest {
+  bytes block = 1;
+}
+
+message SaveReply {}

rpc/src/main/scala/ExchangeClient.scala

@@ -0,0 +1,37 @@
+package kr.ac.postech.paranode.rpc
+
+import io.grpc.ManagedChannel
+import io.grpc.ManagedChannelBuilder
+import kr.ac.postech.paranode.core.Block
+import kr.ac.postech.paranode.rpc.exchange.ExchangeGrpc.ExchangeStub
+import kr.ac.postech.paranode.rpc.exchange.SaveReply
+import kr.ac.postech.paranode.rpc.exchange.SaveRequest
+
+import java.util.concurrent.TimeUnit
+import scala.concurrent.Future
+
+import Implicit._
+
+object ExchangeClient {
+  def apply(host: String, port: Int): ExchangeClient = {
+    val channel =
+      ManagedChannelBuilder.forAddress(host, port).usePlaintext().build
+    val stub = exchange.ExchangeGrpc.stub(channel)
+    new ExchangeClient(channel, stub)
+  }
+}
+
+class ExchangeClient private (
+    private val channel: ManagedChannel,
+    private val stub: ExchangeStub
+) {
+  def shutdown(): Unit = {
+    channel.shutdown.awaitTermination(5, TimeUnit.SECONDS)
+  }
+
+  def save(block: Block): Future[SaveReply] = {
+    val request = SaveRequest(block)
+
+    stub.save(request)
+  }
+}

rpc/src/main/scala/ExchangeService.scala

@@ -0,0 +1,50 @@
+package kr.ac.postech.paranode.rpc
+
+import kr.ac.postech.paranode.core.Block
+import org.apache.logging.log4j.scala.Logging
+
+import java.util.UUID
+import scala.concurrent.ExecutionContext
+import scala.concurrent.Future
+import scala.concurrent.Promise
+import scala.reflect.io.Directory
+
+import exchange.{ExchangeGrpc, SaveReply, SaveRequest}
+import Implicit._
+
+class ExchangeService(
+    executionContext: ExecutionContext,
+    outputDirectory: Directory
+) extends ExchangeGrpc.Exchange
+    with Logging {
+  override def save(request: SaveRequest): Future[SaveReply] = {
+    val promise = Promise[SaveReply]
+
+    Future {
+
+      try {
+        logger.info(s"[ExchangeServer] Save ($request)")
+
+        val block: Block = request.block
+
+        val path = outputDirectory / UUID.randomUUID().toString
+
+        logger.info(s"[ExchangeServer] Writing block to $path")
+
+        block.writeTo(path)
+
+        logger.info(s"[ExchangeServer] Block written to $path")
+
+        promise.success(new SaveReply())
+      } catch {
+        case e: Exception => {
+          logger.trace(e)
+          logger.error(s"[ExchangeServer] Error: ${e.getMessage}")
+          promise.failure(e)
+        }
+      }
+    }(executionContext)
+
+    promise.future
+  }
+}