[GitHub] [kafka] hachikuji commented on a change in pull request #9732: KAFKA-10842; Use `InterBrokerSendThread` for raft's outbound network channel

[GitBox]

hachikuji commented on a change in pull request #9732:
URL: https://github.com/apache/kafka/pull/9732#discussion_r546905110



##########
File path: 
core/src/main/scala/kafka/server/BrokerToControllerChannelManager.scala
##########
@@ -152,76 +151,89 @@ abstract class ControllerRequestCompletionHandler extends 
RequestCompletionHandl
   def onTimeout(): Unit
 }
 
-case class BrokerToControllerQueueItem(request: AbstractRequest.Builder[_ <: 
AbstractRequest],
-                                       callback: 
ControllerRequestCompletionHandler,
-                                       deadlineMs: Long)
-
-class BrokerToControllerRequestThread(networkClient: KafkaClient,
-                                      metadataUpdater: ManualMetadataUpdater,
-                                      requestQueue: 
LinkedBlockingDeque[BrokerToControllerQueueItem],
-                                      metadataCache: 
kafka.server.MetadataCache,
-                                      config: KafkaConfig,
-                                      listenerName: ListenerName,
-                                      time: Time,
-                                      threadName: String)
-  extends InterBrokerSendThread(threadName, networkClient, time, 
isInterruptible = false) {
-
+case class BrokerToControllerQueueItem(
+  createdTimeMs: Long,
+  request: AbstractRequest.Builder[_ <: AbstractRequest],
+  callback: ControllerRequestCompletionHandler
+)
+
+class BrokerToControllerRequestThread(
+  networkClient: KafkaClient,
+  metadataUpdater: ManualMetadataUpdater,
+  metadataCache: kafka.server.MetadataCache,
+  config: KafkaConfig,
+  listenerName: ListenerName,
+  time: Time,
+  threadName: String,
+  retryTimeoutMs: Long
+) extends InterBrokerSendThread(threadName, networkClient, 
config.controllerSocketTimeoutMs, time, isInterruptible = false) {
+
+  private val requestQueue = new 
LinkedBlockingDeque[BrokerToControllerQueueItem]()
   private var activeController: Option[Node] = None
 
-  override def requestTimeoutMs: Int = config.controllerSocketTimeoutMs
+  def enqueue(request: BrokerToControllerQueueItem): Unit = {
+    requestQueue.add(request)
+    if (activeController.isDefined) {
+      wakeup()
+    }
+  }
 
-  override def generateRequests(): Iterable[RequestAndCompletionHandler] = {
-    val requestsToSend = new mutable.Queue[RequestAndCompletionHandler]
-    val topRequest = requestQueue.poll()
-    if (topRequest != null) {
-      val request = RequestAndCompletionHandler(
-        activeController.get,
-        topRequest.request,
-        handleResponse(topRequest)
-      )
+  def queueSize: Int = {
+    requestQueue.size
+  }
 
-      requestsToSend.enqueue(request)
+  override def generateRequests(): Iterable[RequestAndCompletionHandler] = {
+    val currentTimeMs = time.milliseconds()
+    val requestIter = requestQueue.iterator()

Review comment:
       Yeah, I just thought it was a little simpler.




----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org