'Make a syncronous channel RPC call for a synchronous method frame. If
the channel is already in the blocking state, then enqueue the request,
but don\'t send it at this time; it will be eventually sent by
`_on_synchronous_complete` after the prior blocking request receives a
resposne. If the channel is not in the blocking state and
`acceptable_replies` is not empty, transition the channel to the
blocking state and register for `_on_synchronous_complete` before
sending the request.
NOTE: A callback must be accompanied by non-empty acceptable_replies.
:param pika.amqp_object.Method method: The AMQP method to invoke
:param callable callback: The callback for the RPC response
:param acceptable_replies: A (possibly empty) sequence of
replies this RPC call expects or None
:type acceptable_replies: list or None'

def _rpc(self, method, callback=None, acceptable_replies=None):

    assert method.synchronous, ('Only    synchronous-capable    methods    may    be    used    with    _rpc:    %r' % (method,))
    if (not isinstance(acceptable_replies, (type(None), list))):
        raise TypeError('acceptable_replies    should    be    list    or    None')
    if (callback is not None):
        if (not is_callable(callback)):
            raise TypeError('callback    should    be    None    or    a    callable')
        if (not acceptable_replies):
            raise ValueError('Unexpected    callback    for    asynchronous    (nowait)    operation.')
    if self.is_closed:
        raise exceptions.ChannelClosed
    if self._blocking:
        LOGGER.debug('Already    in    blocking    state,    so    enqueueing    method    %s;    acceptable_replies=%r', method, acceptable_replies)
        return self._blocked.append([method, callback, acceptable_replies])
    if acceptable_replies:
        self._blocking = method.NAME
        LOGGER.debug('Entering    blocking    state    on    frame    %s;    acceptable_replies=%r', method, acceptable_replies)
        for reply in acceptable_replies:
            if isinstance(reply, tuple):
                (reply, arguments) = reply
            else:
                arguments = None
            LOGGER.debug('Adding    on_synchronous_complete    callback')
            self.callbacks.add(self.channel_number, reply, self._on_synchronous_complete, arguments=arguments)
            if (callback is not None):
                LOGGER.debug('Adding    passed-in    callback')
                self.callbacks.add(self.channel_number, reply, callback, arguments=arguments)
    self._send_method(method)
