docs: @Override
      public void onReceive(Object message) throws Exception {
          try {
              if (message instanceof RequestWorkerMsgType) {
                  switch ((RequestWorkerMsgType) message) {
                  case PROCESS_REQUEST:
                      tryCount++;
  
                      if (tryCount == 1) {
                          sender = getSender();
  
                          ConnectionlessBootstrap udpClient = bootStrapUdpClient();
  
                          // Start the connection attempt.
                          ChannelFuture future = udpClient
                                  .connect(new InetSocketAddress(targetHost,
                                          udpMeta.getUdpPort()));
  
                          // first schedule timeout before the sync wait
                          timeoutDuration = Duration.create(
                                  actorMaxOperationTimeoutSec, TimeUnit.SECONDS);
  
                          timeoutMessageCancellable = getContext()
                                  .system()
                                  .scheduler()
                                  .scheduleOnce(
                                          timeoutDuration,
                                          getSelf(),
                                          RequestWorkerMsgType.PROCESS_ON_TIMEOUT,
                                          getContext().system().dispatcher(),
                                          getSelf());
  
                          // Wait until the connection attempt succeeds or fails.
                          channel = future.awaitUninterruptibly().getChannel();
                          ChannelFuture requestFuture = null;
  
                          // Sends the line to server need. line ending
                          requestFuture = channel.write(udpMeta.getCommand()
                                  + "\r\n");
  
                          // Wait until all messages are flushed before closing
                          // the channel.
                          if (requestFuture != null) {
                              requestFuture.await();
                          }
                      } else {
                          getLogger().error(
                                  "duplicated PROCESS_REQUEST msg. ignore...");
                      }
                      break;
  
                  case CANCEL:
                      if (sender == null)
                          sender = getSender();
                      getLogger().info(
                              "UDP Request was CANCELLED.................{}",
                              targetHost);
                      cancelCancellable();
                      reply(null, true, PcConstants.REQUEST_CANCELED,
                              PcConstants.REQUEST_CANCELED, PcConstants.NA,
                              PcConstants.NA_INT);
                      break;
  
                  case PROCESS_ON_EXCEPTION:
  
                      String errorSummary = PcErrorMsgUtils.replaceErrorMsg(cause
                              .toString());
                      String stackTrace = PcStringUtils.printStackTrace(cause);
                      cancelCancellable();
                      reply(null, true, errorSummary, stackTrace, PcConstants.NA,
                              PcConstants.NA_INT);
  
                      break;
  
                  case PROCESS_ON_TIMEOUT:
  
                      getLogger().error("PROCESS_ON_TIMEOUT.................{}",
                              targetHost);
                      cancelCancellable();
  
                      String errorMsg = String
                              .format("UdpWorker Timedout after %d SEC (no response but no exception catched). Check URL: may be very slow or stuck.",
                                      actorMaxOperationTimeoutSec);
  
                      reply(null, true, errorMsg, errorMsg, PcConstants.NA,
                              PcConstants.NA_INT);
                      break;
  
                  case CHECK_FUTURE_STATE:
                  default:
                      sender = getSender();
                      this.cause = new ActorMessageTypeInvalidException(
                              "ActorMessageTypeInvalidException error for on "
                                      + this.targetHost);
                      getSelf().tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION,
                              getSelf());
                      break;
                  }
              } else {
                  unhandled(message);
                  sender = getSender();
                  this.cause = new ActorMessageTypeInvalidException(
                          "ActorMessageTypeInvalidException error for UDP on "
                                  + this.targetHost);
                  getSelf().tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION,
                          getSelf());
              }
          } catch (Exception e) {
              this.cause = e;
              getSelf()
                      .tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION, getSelf());
          }
      }