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
          """
          LOGGER.debug("rabbitmq.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'] = ''
          if 'MSG_CORRELATION_ID' not in my_args['properties']:
              self.corr_id = str(uuid.uuid4())
              my_args['properties']['MSG_CORRELATION_ID'] = self.corr_id
          else:
              self.corr_id = my_args['properties']['MSG_CORRELATION_ID']
  
          self.response = None
          self.corr_id = str(uuid.uuid4())
  
          props = my_args['properties']
          if 'sessionID' in props and props['sessionID'] is not None and props['sessionID']:
              request_q = str(props['sessionID']) + '-' + self.requestQ
          else:
              request_q = self.requestQ
  
          if self.trace:
              props['MSG_TRACE'] = True
  
          if not self.fire_and_forget:
              properties = pika.BasicProperties(content_type=None, content_encoding=None,
                                                headers=props, delivery_mode=None,
                                                priority=None, correlation_id=self.corr_id,
                                                reply_to=self.callback_queue, expiration=None,
                                                message_id=None, timestamp=None,
                                                type=None, user_id=None,
                                                app_id=None, cluster_id=None)
          else:
              properties = pika.BasicProperties(content_type=None, content_encoding=None,
                                                headers=props, delivery_mode=None,
                                                priority=None, expiration=None,
                                                message_id=None, timestamp=None,
                                                type=None, user_id=None,
                                                app_id=None, cluster_id=None)
  
          self.channel.basic_publish(exchange='',
                                     routing_key=request_q,
                                     properties=properties,
                                     body=str(my_args['body']))
  
          LOGGER.debug("rabbitmq.Requester.call - published msg {"+str(my_args['body'])+","+str(properties)+"}")
  
          if not self.fire_and_forget:
              start_time = timeit.default_timer()
              timeout = self.rpc_timeout if self.rpc_timeout > 0 else 0
              while self.response is None and timeout >= 0:
                  timeout_id = None
                  if timeout > 0:
                      timeout_id = self.connection.add_timeout(timeout, self.on_response)
                  self.connection.process_data_events()
                  if timeout_id is not None:
                      self.connection.remove_timeout(timeout_id)
                  timeout = round(self.rpc_timeout - (timeit.default_timer() - start_time))
              rpc_time = timeit.default_timer() - start_time
  
              if self.response is None:
                  if self.rpc_retry > 0:
                      if 'retry_count' not in my_args:
                          my_args['retry_count'] = 1
                          LOGGER.debug("rabbitmq.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("rabbitmq.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("rabbitmq.Requester.call - Retry (" + str(my_args['retry_count']) + ")")
                          return self.call(my_args)
                      else:
                          raise ArianeMessagingTimeoutError('rabbitmq.Requester.call',
                                                            'Request timeout (' + str(self.rpc_timeout) + '*' +
                                                            str(self.rpc_retry) + ' sec) occured')
                  else:
                      raise ArianeMessagingTimeoutError('rabbitmq.Requester.call',
                                                        'Request timeout (' + str(self.rpc_timeout) + '*' +
                                                        str(self.rpc_retry) + ' sec) occured')
              else:
                  if self.rpc_timeout > 0 and rpc_time > self.rpc_timeout*3/5:
                      LOGGER.debug('rabbitmq.Requester.call - slow RPC time (' + str(rpc_time) + ') on request ' +
                                   str(properties))
                  self.trace = False
  
                  rc_ = self.response['props'].headers['RC']
                  if rc_ != 0:
                      try:
                          content = json.loads(self.response['body'].decode("UTF-8"))
                      except ValueError:
                          content = self.response['body'].decode("UTF-8")
                      return DriverResponse(
                          rc=rc_,
                          error_message=self.response['props'].headers['SERVER_ERROR_MESSAGE']
                          if 'SERVER_ERROR_MESSAGE' in self.response['props'].headers else '',
                          response_content=content
                      )
                  else:
                      try:
                          if 'MSG_PROPERTIES' in self.response['props'].headers:
                              props = json.loads(self.response['props'].headers['MSG_PROPERTIES'])
                          else:
                              props = None
                      except ValueError:
                          if 'MSG_PROPERTIES' in self.response['props'].headers:
                              props = self.response['props'].headers['MSG_PROPERTIES']
                          else:
                              props = None
                      try:
                          content = json.loads(self.response['body'].decode("UTF-8"))
                      except ValueError:
                          content = self.response['body'].decode("UTF-8")
                      return DriverResponse(
                          rc=rc_,
                          response_properties=props,
                          response_content=content
                      )