setup the request and call the remote service. Wait the answer (blocking call)
        :param my_args: dict like {properties, body}
        :return response

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
                    )