void qd_policy_apply_session_settings(pn_session_t *ssn, qd_connection_t *qd_conn)
{
if (qd_conn->policy_settings && qd_conn->policy_settings->maxSessionWindow) {
pn_session_set_incoming_capacity(ssn, qd_conn->policy_settings->maxSessionWindow);
} else {
pn_session_set_incoming_capacity(ssn, 1000000);
}
}
qd_link_t *qd_link(qd_node_t *node, qd_connection_t *conn, qd_direction_t dir, const char* name)
{
qd_link_t *link = new_qd_link_t();
link->pn_sess = pn_session(qd_connection_pn(conn));
pn_session_set_incoming_capacity(link->pn_sess, 1000000);
if (dir == QD_OUTGOING)
link->pn_link = pn_sender(link->pn_sess, name);
else
link->pn_link = pn_receiver(link->pn_sess, name);
link->direction = dir;
link->context = node->context;
link->node = node;
link->drain_mode = pn_link_get_drain(link->pn_link);
link->remote_snd_settle_mode = pn_link_remote_snd_settle_mode(link->pn_link);
link->close_sess_with_link = true;
//
// Keep the borrowed references
//
pn_incref(link->pn_link);
pn_incref(link->pn_sess);
pn_link_set_context(link->pn_link, link);
pn_session_open(link->pn_sess);
return link;
}
static pn_event_type_t message_stream_handler(test_handler_t *th, pn_event_t *e) {
struct message_stream_context *ctx = (struct message_stream_context*)th->context;
switch (pn_event_type(e)) {
case PN_CONNECTION_BOUND:
pn_transport_set_max_frame(pn_event_transport(e), FRAME);
return PN_EVENT_NONE;
case PN_SESSION_INIT:
pn_session_set_incoming_capacity(pn_event_session(e), FRAME); /* Single frame incoming */
pn_session_set_outgoing_window(pn_event_session(e), 1); /* Single frame outgoing */
return PN_EVENT_NONE;
case PN_LINK_REMOTE_OPEN:
common_handler(th, e);
if (pn_link_is_receiver(pn_event_link(e))) {
pn_link_flow(pn_event_link(e), 1);
} else {
ctx->sender = pn_event_link(e);
}
return PN_EVENT_NONE;
case PN_LINK_FLOW: /* Start a delivery */
if (pn_link_is_sender(pn_event_link(e)) && !ctx->dlv) {
ctx->dlv = pn_delivery(pn_event_link(e), pn_dtag("x", 1));
}
return PN_LINK_FLOW;
case PN_CONNECTION_WAKE: { /* Send a chunk */
ssize_t remains = ctx->size - ctx->sent;
ssize_t n = (CHUNK < remains) ? CHUNK : remains;
TEST_CHECK(th->t, n == pn_link_send(ctx->sender, ctx->send_buf.start + ctx->sent, n));
ctx->sent += n;
if (ctx->sent == ctx->size) {
TEST_CHECK(th->t, pn_link_advance(ctx->sender));
}
return PN_CONNECTION_WAKE;
}
case PN_DELIVERY: { /* Receive a delivery - smaller than a chunk? */
pn_delivery_t *dlv = pn_event_delivery(e);
if (pn_delivery_readable(dlv)) {
ssize_t n = pn_delivery_pending(dlv);
rwbytes_ensure(&ctx->recv_buf, ctx->received + n);
TEST_ASSERT(n == pn_link_recv(pn_event_link(e), ctx->recv_buf.start + ctx->received, n));
ctx->received += n;
}
ctx->complete = !pn_delivery_partial(dlv);
return PN_DELIVERY;
}
default:
return common_handler(th, e);
}
}
void qd_policy_apply_session_settings(pn_session_t *ssn, qd_connection_t *qd_conn)
{
size_t capacity;
if (qd_conn->policy_settings && qd_conn->policy_settings->maxSessionWindow) {
capacity = qd_conn->policy_settings->maxSessionWindow;
} else {
const qd_server_config_t * cf = qd_connection_config(qd_conn);
capacity = cf->incoming_capacity;
}
pn_session_set_incoming_capacity(ssn, capacity);
}