docs: def call(self, my_args=None):
          """
          setup the request and call the remote service. Wait the answer (blocking call)
          :param my_args: dict like {properties, body}
          :return response
          """
          if not self.is_started:
              raise ArianeError('natsd.Requester.call',
                                'Requester not started !')
  
          LOGGER.debug("natsd.Requester.call")
          if my_args is None:
              raise exceptions.ArianeConfError("requestor call arguments")
          if 'properties' not in my_args or my_args['properties'] is None:
              raise exceptions.ArianeConfError('requestor call properties')
          if 'body' not in my_args or my_args['body'] is None:
              my_args['body'] = ''
  
          self.response = None
  
          if not self.fire_and_forget:
              if DriverTools.MSG_CORRELATION_ID not in my_args['properties']:
                  self.corr_id = str(uuid.uuid4())
                  properties = my_args['properties']
                  properties[DriverTools.MSG_CORRELATION_ID] = self.corr_id
              else:
                  properties = my_args['properties']
                  self.corr_id = properties[DriverTools.MSG_CORRELATION_ID]
          else:
              properties = my_args['properties']
  
          if 'sessionID' in properties and properties['sessionID'] is not None and properties['sessionID']:
              request_q = str(properties['sessionID']) + '-' + self.requestQ
          else:
              request_q = self.requestQ
  
          if self.trace:
              properties[DriverTools.MSG_TRACE] = True
  
          typed_properties = []
          for key, value in properties.items():
              typed_properties.append(DriverTools.property_params(key, value))
  
          body = my_args['body']
          if body:
              body = base64.b64encode(b''+bytes(body, 'utf8')).decode("utf-8")
  
          msg_data = json.dumps({
              'properties': typed_properties,
              'body': body
          })
          msgb = b''+bytes(msg_data, 'utf8')
  
          split_mid = None
          messages = []
          if sys.getsizeof(msgb) > self.max_payload:
              split_mid = str(uuid.uuid4())
              messages = self._split_msg(split_mid, properties, my_args['body'])
          else:
              messages.append(msgb)
  
          if not self.fire_and_forget:
              if split_mid is not None and ('sessionID' not in properties or properties['sessionID'] is None or
                                            not properties['sessionID']):
                  request_q += "_" + split_mid
                  self._init_split_msg_group(split_mid, request_q)
  
              for msgb in messages:
                  try:
                      LOGGER.debug("natsd.Requester.call - publish splitted request " + str(typed_properties) +
                                   " (size: " + str(sys.getsizeof(msgb)) + " bytes) on " + request_q)
                      next(self.nc.publish_request(request_q, self.responseQ, msgb))
                  except StopIteration as e:
                      pass
                  LOGGER.debug("natsd.Requester.call - waiting answer from " + self.responseQ)
          else:
              try:
                  LOGGER.debug("natsd.Requester.call - publish request " + str(typed_properties) + " on " + request_q)
                  next(self.nc.publish(request_q, b''+bytes(msg_data, 'utf8')))
              except StopIteration as e:
                  pass
  
          try:
              next(self.nc.flush(1))
          except StopIteration as e:
              pass
  
          start_time = timeit.default_timer()
          if not self.fire_and_forget:
              # Wait rpc_timeout sec before raising error
              if self.rpc_timeout > 0:
                  exit_count = self.rpc_timeout * 100
              else:
                  exit_count = 1
              while self.response is None and exit_count > 0:
                  time.sleep(0.01)
                  if self.rpc_timeout > 0:
                      exit_count -= 1
  
              if self.response is None:
                  if self.rpc_retry > 0:
                      if 'retry_count' not in my_args:
                          my_args['retry_count'] = 1
                          LOGGER.debug("natsd.Requester.call - Retry (" + str(my_args['retry_count']) + ")")
                          return self.call(my_args)
                      elif 'retry_count' in my_args and (self.rpc_retry - my_args['retry_count']) > 0:
                          LOGGER.warn("natsd.Requester.call - No response returned from request on " + request_q +
                                      " queue after " + str(self.rpc_timeout) + '*' +
                                      str(self.rpc_retry) + " sec ...")
                          self.trace = True
                          my_args['retry_count'] += 1
                          LOGGER.warn("natsd.Requester.call - Retry (" + str(my_args['retry_count']) + ")")
                          return self.call(my_args)
                      else:
                          self.rpc_retry_timeout_err_count += 1
                          if self.rpc_retry_timeout_err_count >= self.rpc_retry_timeout_err_count_max:
                              self._restart_after_max_timeout_err_count()
                          raise ArianeMessagingTimeoutError('natsd.Requester.call',
                                                            'Request timeout (' + str(self.rpc_timeout) + '*' +
                                                            str(self.rpc_retry) + ' sec) occured')
                  else:
                      self.rpc_retry_timeout_err_count += 1
                      if self.rpc_retry_timeout_err_count >= self.rpc_retry_timeout_err_count_max:
                          self._restart_after_max_timeout_err_count()
                      raise ArianeMessagingTimeoutError('natsd.Requester.call',
                                                        'Request timeout (' + str(self.rpc_timeout) + '*' +
                                                        str(self.rpc_retry) + ' sec) occured')
  
              rpc_time = timeit.default_timer()-start_time
              LOGGER.debug('natsd.Requester.call - RPC time : ' + str(rpc_time))
              if self.rpc_timeout > 0 and rpc_time > self.rpc_timeout*3/5:
                  LOGGER.debug('natsd.Requester.call - slow RPC time (' + str(rpc_time) + ') on request ' +
                               str(typed_properties))
              self.trace = False
              self.rpc_retry_timeout_err_count = 0
              rc_ = int(self.response['properties']['RC'])
  
              if rc_ != 0:
                  try:
                      content = json.loads(self.response['body'].decode("UTF-8"))
                  except ValueError:
                      content = self.response['body'].decode("UTF-8")
                  dr = DriverResponse(
                      rc=rc_,
                      error_message=self.response['properties']['SERVER_ERROR_MESSAGE']
                      if 'SERVER_ERROR_MESSAGE' in self.response['properties'] else '',
                      response_content=content
                  )
              else:
                  try:
                      if DriverTools.MSG_PROPERTIES in self.response['properties']:
                          props = json.loads(self.response['properties'][DriverTools.MSG_PROPERTIES])
                      else:
                          props = None
                  except ValueError:
                      if DriverTools.MSG_PROPERTIES in self.response['properties']:
                          props = self.response['props'][DriverTools.MSG_PROPERTIES]
                      else:
                          props = None
                  try:
                      content = json.loads(self.response['body'].decode("UTF-8"))
                  except ValueError:
                      content = self.response['body'].decode("UTF-8")
                  dr = DriverResponse(
                      rc=rc_,
                      response_properties=props,
                      response_content=content
                  )
  
              if split_mid is not None and ('sessionID' not in properties or properties['sessionID'] is None or
                                                not properties['sessionID']):
                  self._end_split_msg_group(split_mid)
                  request_q = request_q.split("_" + split_mid)[0]
  
              return dr