Revision control
Copy as Markdown
// Copyright (C) 2022 The Qt Company Ltd.
// Copyright (C) 2019 Alexey Edelev <semlanik@gmail.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QtGrpc/qgrpcoperationcontext.h>
#include <QtGrpc/qgrpcstream.h>
QT_BEGIN_NAMESPACE
/*!
\class QGrpcServerStream
\inmodule QtGrpc
\since 6.7
\brief The QGrpcServerStream class provides access in handling server-streaming RPCs.
The QGrpcServerStream class provides the interface for handling
server-streaming remote procedure calls (RPCs), which is one of the four
\gRPC \l{Service Methods}{service methods}.
For a high-level overview, refer to the \l {Server Streaming} {Qt GRPC
Client Guide}.
\include qtgrpc-shared.qdocinc rpc-lifetime-note
*/
/*!
\fn void QGrpcServerStream::messageReceived()
//! [message-received-desc]
This signal is emitted when the streaming RPC has received a new message
from the server. The read() methods can then be used to deserialize the
received message.
//! [message-received-desc]
*/
/*!
\since 6.13
\fn void QGrpcClientStream::messageWritten()
//! [message-written-desc]
This signal is emitted when the channel has passed an outgoing message on
to the transport: once for the initial request message and once per
writeMessage() call, in write order.
QGrpcHttp2Channel emits it after the message has been fully written to the
connection, which respects HTTP/2 flow control; when the server stops
consuming data, the emission is delayed until the server grants more send
window.
Messages queue up without limit when they are written faster than the
network transmits them. To bound the queue, write the next message only
after this signal reports the previous one written, matching the
write-then-wait discipline commonly seen in \gRPC implementations.
For medium and large messages this one-at-a-time pacing costs no throughput,
and usually improves it by avoiding a large backlog. For very small,
high-rate messages the per-message wait can dominate instead; there, keep a
few messages in flight: write a small batch up front and write one more on
each emission. bytesToWrite() reports how much of the written data still
awaits transmission.
Once finished() has been emitted the signal is not emitted anymore, even
for messages that were still in transmission when the operation ended.
//! [message-written-desc]
\sa writeMessage(), bytesToWrite()
*/
/*!
\internal
Constructs a new QGrpcServerStream from QGrpcClientBase.
This is indirectly called by the generated client interface.
\sa QGrpcClientBase::serverStream QAbstractGrpcChannel::serverStream
*/
QGrpcServerStream::QGrpcServerStream(QLatin1StringView service, QLatin1StringView method,
const QGrpcCallOptions &options,
std::weak_ptr<QAbstractGrpcChannel> channel,
PrivateConstructor /* unused */)
: QGrpcOperation({ service, method, QtGrpc::RpcType::ServerStreaming }, options,
std::move(channel))
{
QObject::connect(&QGrpcOperation::context(), &QGrpcOperationContext::messageReceived, this,
&QGrpcServerStream::messageReceived);
}
/*!
Destroys the QGrpcServerStream.
*/
QGrpcServerStream::~QGrpcServerStream() = default;
bool QGrpcServerStream::event(QEvent *event)
{
return QGrpcOperation::event(event);
}
/*!
\class QGrpcClientStream
\inmodule QtGrpc
\since 6.7
\brief The QGrpcClientStream class provides access in handling client-streaming RPCs.
The QGrpcClientStream class provides the interface for handling
client-streaming remote procedure calls (RPCs), which is one of the four
\gRPC \l{Service Methods}{service methods}.
For a high-level overview, refer to the \l {Client Streaming} {Qt GRPC
Client Guide}.
\include qtgrpc-shared.qdocinc rpc-lifetime-note
*/
/*!
\internal
Constructs a new QGrpcClientStream from QGrpcClientBase.
This is indirectly called by the generated client interface.
\sa QGrpcClientBase::clientStream QAbstractGrpcChannel::clientStream
*/
QGrpcClientStream::QGrpcClientStream(QLatin1StringView service, QLatin1StringView method,
const QGrpcCallOptions &options,
std::weak_ptr<QAbstractGrpcChannel> channel,
PrivateConstructor /* unused */)
: QGrpcOperation({ service, method, QtGrpc::RpcType::ClientStreaming }, options,
std::move(channel))
{
QObject::connect(&QGrpcOperation::context(), &QGrpcOperationContext::messageWritten, this,
&QGrpcClientStream::messageWritten);
}
/*!
Destroys the QGrpcClientStream.
*/
QGrpcClientStream::~QGrpcClientStream() = default;
/*!
//! [write-message-desc]
Serializes \a message and sends it to the server.
Messages are queued and handed to the transport. The queue is unbounded, so
pace high-rate writes using the messageWritten() signal.
//! [write-message-desc]
\sa messageWritten()
*/
void QGrpcClientStream::writeMessage(const QProtobufMessage &message)
{
QGrpcOperation::writeMessage(message);
}
/*!
\since 6.8
//! [writes-done-desc]
Ends the stream from the client side (half-closing). The server is still allowed to send
responses after this call.
//! [writes-done-desc]
*/
void QGrpcClientStream::writesDone()
{
QGrpcOperation::writesDone();
}
/*!
\since 6.13
//! [bytes-to-write-desc]
Returns the number of bytes the channel has accepted for this stream but
not yet written to the transport. QGrpcHttp2Channel reports the wire size
of the queued messages, including the message currently in transmission,
after framing and optional compression.
The value changes as writeMessage() accepts messages and the transport
consumes them; check it in a messageWritten() handler to decide whether
to write more messages or wait, and to bound the memory the outgoing
queue may occupy.
//! [bytes-to-write-desc]
\sa messageWritten(), writeMessage()
*/
quint64 QGrpcClientStream::bytesToWrite() const noexcept
{
return context().bytesToWrite();
}
bool QGrpcClientStream::event(QEvent *event)
{
return QGrpcOperation::event(event);
}
/*!
\class QGrpcBidiStream
\inmodule QtGrpc
\since 6.7
\brief The QGrpcBidiStream class provides access in handling
bidirectional-streaming RPCs.
The QGrpcBidiStream class provides the interface for handling
bidirectional-streaming remote procedure calls (RPCs), which is one of the
four \gRPC \l{Service Methods}{service methods}.
For a high-level overview, refer to the \l {Bidirectional Streaming} {Qt
GRPC Client Guide}.
\include qtgrpc-shared.qdocinc rpc-lifetime-note
*/
/*!
\fn void QGrpcBidiStream::messageReceived()
\include qgrpcstream.cpp message-received-desc
*/
/*!
\since 6.13
\fn void QGrpcBidiStream::messageWritten()
\include qgrpcstream.cpp message-written-desc
\sa writeMessage()
*/
/*!
\internal
Constructs a new QGrpcBidiStream from QGrpcClientBase.
This is indirectly called by the generated client interface.
\sa QGrpcClientBase::bidiStream QAbstractGrpcChannel::bidiStream
*/
QGrpcBidiStream::QGrpcBidiStream(QLatin1StringView service, QLatin1StringView method,
const QGrpcCallOptions &options,
std::weak_ptr<QAbstractGrpcChannel> channel,
PrivateConstructor /* unused */)
: QGrpcOperation({ service, method, QtGrpc::RpcType::BidiStreaming }, options,
std::move(channel))
{
QObject::connect(&QGrpcOperation::context(), &QGrpcOperationContext::messageReceived,
this, &QGrpcBidiStream::messageReceived);
QObject::connect(&QGrpcOperation::context(), &QGrpcOperationContext::messageWritten, this,
&QGrpcBidiStream::messageWritten);
}
/*!
Destroys the QGrpcBidiStream.
*/
QGrpcBidiStream::~QGrpcBidiStream() = default;
/*!
\include qgrpcstream.cpp write-message-desc
\sa messageWritten()
*/
void QGrpcBidiStream::writeMessage(const QProtobufMessage &message)
{
QGrpcOperation::writeMessage(message);
}
/*!
\since 6.8
\include qgrpcstream.cpp writes-done-desc
*/
void QGrpcBidiStream::writesDone()
{
QGrpcOperation::writesDone();
}
/*!
\since 6.13
\include qgrpcstream.cpp bytes-to-write-desc
\sa messageWritten(), writeMessage()
*/
quint64 QGrpcBidiStream::bytesToWrite() const noexcept
{
return context().bytesToWrite();
}
bool QGrpcBidiStream::event(QEvent *event)
{
return QGrpcOperation::event(event);
}
QT_END_NAMESPACE
#include "moc_qgrpcstream.cpp"