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();
                          timeoutDuration = Duration.create(
                                  actorMaxOperationTimeoutSec, TimeUnit.SECONDS);
                          timeoutMessageCancellable = getContext()
                                  .system()
                                  .scheduler()
                                  .scheduleOnce(
                                          timeoutDuration,
                                          getSelf(),
                                          RequestWorkerMsgType.PROCESS_ON_TIMEOUT,
                                          getContext().system().dispatcher(),
                                          getSelf());
  
                          SshTask sshTask = new SshTask(sshMeta, targetHost);
                          setResponseFuture(TcpUdpSshPingResourceStore.getInstance()
                                  .getThreadPoolForSshPing().submit(sshTask));
  
                          getContext()
                                  .system()
                                  .scheduler()
                                  .scheduleOnce(
                                          (FiniteDuration) Duration.create(0.5,
                                                  TimeUnit.SECONDS),
                                          new Runnable() {
                                              @Override
                                              public void run() {
                                                  getSelf()
                                                          .tell(RequestWorkerMsgType.CHECK_FUTURE_STATE,
                                                                  getSelf());
                                              }
                                          }, getContext().system().dispatcher());
  
                      } else {
                          getLogger().error(
                                  "duplicated PROCESS_REQUEST msg. ignore...");
                      }
  
                      break;
  
                  case CHECK_FUTURE_STATE:
                      getLogger().debug(
                              "checking if SSH callable future completed... for "
                                      + targetHost);
                      if (getResponseFuture().isDone()) {
                          getLogger().debug(
                                  "SSH Provider callable returned. for "
                                          + targetHost);
                          ResponseOnSingeRequest sshResponse = getResponseFuture()
                                  .get();
                          onComplete(sshResponse);
                          break;
                      } else {
                          // schedule again
                          getContext()
                                  .system()
                                  .scheduler()
                                  .scheduleOnce(
                                          (FiniteDuration) Duration.create(
                                                  ParallecGlobalConfig.sshFutureCheckIntervalSec,
                                                  TimeUnit.SECONDS),
                                          new Runnable() {
                                              @Override
                                              public void run() {
                                                  getSelf()
                                                          .tell(RequestWorkerMsgType.CHECK_FUTURE_STATE,
                                                                  getSelf());
                                              }
                                          }, getContext().system().dispatcher());
  
                      }
                      break;
                  case CANCEL:
                      getLogger()
                              .info("Request was CANCELLED.................on SSH host {}",
                                      targetHost);
                      cancelCancellable();
                      if (sender == null)
                          sender = getSender();
                      reply(null, true, PcConstants.REQUEST_CANCELED,
                              PcConstants.REQUEST_CANCELED, PcConstants.NA,
                              PcConstants.NA_INT);
                      break;
  
                  case PROCESS_ON_EXCEPTION:
  
                      String displayError = PcErrorMsgUtils.replaceErrorMsg(cause
                              .toString());
  
                      String stackTrace = PcStringUtils.printStackTrace(cause);
  
                      cancelCancellable();
                      reply(null, true, displayError, stackTrace, PcConstants.NA,
                              PcConstants.NA_INT);
  
                      break;
  
                  case PROCESS_ON_TIMEOUT:
                      getLogger().error(
                              "Inside PROCESS_ON_TIMEOUT.................target: "
                                      + this.targetHost + "......... at "
                                      + PcDateUtils.getNowDateTimeStrStandard());
                      cancelCancellable();
  
                      String errorMsg = String
                              .format("SshWorker Timedout after %d SEC (no response but no exception catched). Details more info",
                                      actorMaxOperationTimeoutSec);
                      reply(null, true, errorMsg, errorMsg, PcConstants.NA,
                              PcConstants.NA_INT);
                      break;
  
                  default:
                      break;
                  }
              } else {
                  unhandled(message);
                  this.cause = new ActorMessageTypeInvalidException(
                          "ActorMessageTypeInvalidException error for host "
                                  + this.targetHost);
                  getSelf().tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION,
                          getSelf());
              }
          } catch (Exception e) {
              this.cause = e;
              getSelf()
                      .tell(RequestWorkerMsgType.PROCESS_ON_EXCEPTION, getSelf());
          }
      }