static void CORE_delivery_update(void *context, qdr_delivery_t *dlv, uint64_t disp, bool settled) { pn_delivery_t *pnd = (pn_delivery_t*) qdr_delivery_get_context(dlv); if (!pnd) return; // // If the disposition has changed, update the proton delivery. // if (disp != pn_delivery_remote_state(pnd)) { if (disp == PN_MODIFIED) pn_disposition_set_failed(pn_delivery_local(pnd), true); pn_delivery_update(pnd, disp); } // // If the delivery is settled, remove the linkage and settle the proton delivery. // if (settled) { qdr_delivery_set_context(dlv, 0); pn_delivery_set_context(pnd, 0); pn_delivery_settle(pnd); qdr_delivery_decref(dlv); } }
uint64_t BufferedTransfer::updated() { disposition = pn_delivery_remote_state(out.handle); if (disposition) { pn_delivery_settle(out.handle); out.settled = true; } return disposition; }
int pni_store_update(pni_store_t *store, pn_sequence_t id, pn_status_t status, int flags, bool settle, bool match) { assert(store); if (!pni_store_tracking(store, id)) { return 0; } size_t start; if (PN_CUMULATIVE & flags) { start = store->lwm; } else { start = id; } for (pn_sequence_t i = start; i <= id; i++) { pni_entry_t *e = pni_store_entry(store, i); if (e) { pn_delivery_t *d = e->delivery; if (d) { if (!pn_delivery_local_state(d)) { if (match) { pn_delivery_update(d, pn_delivery_remote_state(d)); } else { switch (status) { case PN_STATUS_ACCEPTED: pn_delivery_update(d, PN_ACCEPTED); break; case PN_STATUS_REJECTED: pn_delivery_update(d, PN_REJECTED); break; default: break; } } pni_entry_updated(e); } } if (settle) { if (d) { pn_delivery_settle(d); } pn_hash_del(store->tracked, e->id); } } } while (store->hwm - store->lwm > 0 && !pn_hash_get(store->tracked, store->lwm)) { store->lwm++; } return 0; }
void pni_entry_updated(pni_entry_t *entry) { assert(entry); pn_delivery_t *d = entry->delivery; if (d) { if (pn_delivery_remote_state(d)) { entry->status = disp2status(pn_delivery_remote_state(d)); } else if (pn_delivery_settled(d)) { uint64_t disp = pn_delivery_local_state(d); if (disp) { entry->status = disp2status(disp); } else { entry->status = PN_STATUS_SETTLED; } } else { entry->status = PN_STATUS_PENDING; } } }
/** * Delivery Disposition Handler */ static void router_disp_handler(void* context, dx_link_t *link, pn_delivery_t *delivery) { pn_link_t *pn_link = pn_delivery_link(delivery); if (pn_link_is_sender(pn_link)) { pn_disposition_t disp = pn_delivery_remote_state(delivery); dx_message_t *msg = pn_delivery_get_context(delivery); pn_delivery_t *activate = 0; if (msg) { assert(delivery == dx_message_out_delivery(msg)); if (disp != 0) { activate = dx_message_in_delivery(msg); pn_delivery_update(activate, disp); // TODO - handling of the data accompanying RECEIVED/MODIFIED } if (pn_delivery_settled(delivery)) { // // Downstream delivery has been settled. Propagate the settlement // upstream. // activate = dx_message_in_delivery(msg); pn_delivery_settle(activate); pn_delivery_settle(delivery); dx_free_message(msg); } if (activate) { // // Activate the upstream/incoming link so that the settlement will // get pushed out. // dx_link_t *act_link = (dx_link_t*) pn_link_get_context(pn_delivery_link(activate)); dx_link_activate(act_link); } return; } } pn_delivery_settle(delivery); }
/** * Delivery Disposition Handler */ static void AMQP_disposition_handler(void* context, qd_link_t *link, pn_delivery_t *pnd) { qd_router_t *router = (qd_router_t*) context; qdr_delivery_t *delivery = (qdr_delivery_t*) pn_delivery_get_context(pnd); bool give_reference = false; // // It's important to not do any processing without a qdr_delivery. When pre-settled // multi-frame deliveries arrive, it's possible for the settlement to register before // the whole message arrives. Such premature settlement indications must be ignored. // if (!delivery) return; // // If the delivery is settled, remove the linkage between the PN and QDR deliveries. // if (pn_delivery_settled(pnd)) { pn_delivery_set_context(pnd, 0); qdr_delivery_set_context(delivery, 0); // // Don't decref the delivery here. Rather, we will _give_ the reference to the core. // give_reference = true; } // // Update the disposition of the delivery // qdr_delivery_update_disposition(router->router_core, delivery, pn_delivery_remote_state(pnd), pn_delivery_settled(pnd), give_reference); // // If settled, close out the delivery // if (pn_delivery_settled(pnd)) pn_delivery_settle(pnd); }
void messaging_adapter::on_delivery(proton_event &pe) { pn_event_t *cevent = pe.pn_event(); pn_link_t *lnk = pn_event_link(cevent); pn_delivery_t *dlv = pn_event_delivery(cevent); link_context& lctx = link_context::get(lnk); if (pn_link_is_receiver(lnk)) { delivery d(make_wrapper<delivery>(dlv)); if (!pn_delivery_partial(dlv) && pn_delivery_readable(dlv)) { // generate on_message pn_connection_t *pnc = pn_session_connection(pn_link_session(lnk)); connection_context& ctx = connection_context::get(pnc); // Reusable per-connection message. // Avoid expensive heap malloc/free overhead. // See PROTON-998 class message &msg(ctx.event_message); msg.decode(d); if (pn_link_state(lnk) & PN_LOCAL_CLOSED) { if (lctx.auto_accept) d.release(); } else { delegate_.on_message(d, msg); if (lctx.auto_accept && !d.settled()) d.accept(); if (lctx.draining && !pn_link_credit(lnk)) { lctx.draining = false; receiver r(make_wrapper<receiver>(lnk)); delegate_.on_receiver_drain_finish(r); } } } else if (pn_delivery_updated(dlv) && d.settled()) { delegate_.on_delivery_settle(d); } if (lctx.draining && pn_link_credit(lnk) == 0) { lctx.draining = false; pn_link_set_drain(lnk, false); receiver r(make_wrapper<receiver>(lnk)); delegate_.on_receiver_drain_finish(r); if (lctx.pending_credit) { pn_link_flow(lnk, lctx.pending_credit); lctx.pending_credit = 0; } } credit_topup(lnk); } else { tracker t(make_wrapper<tracker>(dlv)); // sender if (pn_delivery_updated(dlv)) { uint64_t rstate = pn_delivery_remote_state(dlv); if (rstate == PN_ACCEPTED) { delegate_.on_tracker_accept(t); } else if (rstate == PN_REJECTED) { delegate_.on_tracker_reject(t); } else if (rstate == PN_RELEASED || rstate == PN_MODIFIED) { delegate_.on_tracker_release(t); } if (t.settled()) { delegate_.on_tracker_settle(t); } if (lctx.auto_settle) t.settle(); } } }
/* Process each event emitted by the protocol engine */ static void dispatcher(pn_handler_t *handler, pn_event_t *event, pn_event_type_t type) { protocolState_t *ps = PROTOCOL_STATE(handler); const configSettings_t *cfg = ps->config; //DBGPRINTF("omamqp1: Event received: %s\n", pn_event_type_name(type)); switch (type) { case PN_LINK_REMOTE_OPEN: DBGPRINTF("omamqp1: Message bus opened link.\n"); break; case PN_DELIVERY: // has the message been delivered to the message bus? if (ps->delivery) { assert(ps->delivery == pn_event_delivery(event)); if (pn_delivery_updated(ps->delivery)) { rsRetVal result = RS_RET_IDLE; uint64_t rs = pn_delivery_remote_state(ps->delivery); switch (rs) { case PN_ACCEPTED: DBGPRINTF("omamqp1: Message ACCEPTED by message bus\n"); result = RS_RET_OK; break; case PN_REJECTED: dbgprintf("omamqp1: message bus rejected log message: invalid message - dropping\n"); // message bus considers this a 'bad message'. Cannot be redelivered. // Likely a configuration error. Drop the message by returning OK result = RS_RET_OK; break; case PN_RELEASED: case PN_MODIFIED: // the message bus cannot accept the message. This may be temporary - retry // up to maxRetries before dropping if (++ps->retries >= cfg->maxRetries) { dbgprintf("omamqp1: message bus failed to accept message - dropping\n"); result = RS_RET_OK; } else { dbgprintf("omamqp1: message bus cannot accept message, retrying\n"); result = RS_RET_SUSPENDED; } break; case PN_RECEIVED: // not finished yet, wait for next delivery update break; default: // no other terminal states defined, so ignore anything else dbgprintf("omamqp1: unknown delivery state=0x%lX, assuming message accepted\n", (unsigned long) pn_delivery_remote_state(ps->delivery)); result = RS_RET_OK; break; } if (result != RS_RET_IDLE) { // the command is complete threadIPC_t *ipc = ps->ipc; pthread_mutex_lock(&ipc->lock); assert(ipc->command == COMMAND_SEND); ipc->result = result; ipc->command = COMMAND_DONE; pthread_cond_signal(&ipc->condition); pthread_mutex_unlock(&ipc->lock); pn_delivery_settle(ps->delivery); ps->delivery = NULL; if (result == RS_RET_OK) { ps->retries = 0; } } } } break; case PN_CONNECTION_BOUND: if (!cfg->bDisableSASL) { // force use of SASL, even allowing PLAIN authentication pn_sasl_t *sasl = pn_sasl(pn_event_transport(event)); #if PN_VERSION_MAJOR == 0 && PN_VERSION_MINOR >= 10 pn_sasl_set_allow_insecure_mechs(sasl, true); #else // proton version <= 0.9 only supports PLAIN authentication const char *user = cfg->username ? (char *)cfg->username : pn_url_get_username(cfg->url); if (user) { pn_sasl_plain(sasl, user, (cfg->password ? (char *) cfg->password : pn_url_get_password(cfg->url))); } #endif } if (cfg->idleTimeout) { // configured as seconds, set as milliseconds pn_transport_set_idle_timeout(pn_event_transport(event), cfg->idleTimeout * 1000); } break; case PN_CONNECTION_UNBOUND: DBGPRINTF("omamqp1: cleaning up connection resources\n"); pn_connection_release(pn_event_connection(event)); ps->conn = NULL; ps->sender = NULL; ps->delivery = NULL; break; case PN_TRANSPORT_ERROR: { // TODO: if auth failure, does it make sense to retry??? pn_transport_t *tport = pn_event_transport(event); pn_condition_t *cond = pn_transport_condition(tport); if (pn_condition_is_set(cond)) { _log_error("transport failure", cond); } dbgprintf("omamqp1: network transport failed, reconnecting...\n"); // the protocol thread will attempt to reconnect if it is not // being shut down } break; default: break; } }
enum transfer::state transfer::state() const { return static_cast<enum state>(pn_delivery_remote_state(pn_object())); }
bool SenderContext::Delivery::accepted() { return pn_delivery_remote_state(token) == PN_ACCEPTED; }
/* Process each event posted by the reactor. */ static void event_handler(pn_handler_t *handler, pn_event_t *event, pn_event_type_t type) { app_data_t *data = GET_APP_DATA(handler); switch (type) { case PN_CONNECTION_INIT: { // Create and open all the endpoints needed to send a message // pn_connection_t *conn; pn_session_t *ssn; pn_link_t *sender; conn = pn_event_connection(event); pn_connection_open(conn); ssn = pn_session(conn); pn_session_open(ssn); sender = pn_sender(ssn, "MySender"); // we do not wait for ack until the last message pn_link_set_snd_settle_mode(sender, PN_SND_MIXED); if (!data->anon) { pn_terminus_set_address(pn_link_target(sender), data->target); } pn_link_open(sender); } break; case PN_LINK_FLOW: { // the remote has given us some credit, now we can send messages // static long tag = 0; // a simple tag generator pn_delivery_t *delivery; pn_link_t *sender = pn_event_link(event); int credit = pn_link_credit(sender); while (credit > 0 && data->count > 0) { --credit; --data->count; ++tag; delivery = pn_delivery(sender, pn_dtag((const char *)&tag, sizeof(tag))); pn_link_send(sender, data->msg_data, data->msg_len); pn_link_advance(sender); if (data->count > 0) { // send pre-settled until the last one, then wait for an ack on // the last sent message. This allows the sender to send // messages as fast as possible and then exit when the consumer // has dealt with the last one. // pn_delivery_settle(delivery); } } } break; case PN_DELIVERY: { // Since the example sends all messages but the last pre-settled // (pre-acked), only the last message's delivery will get updated with // the remote state (acked/nacked). // pn_delivery_t *dlv = pn_event_delivery(event); if (pn_delivery_updated(dlv) && pn_delivery_remote_state(dlv)) { uint64_t rs = pn_delivery_remote_state(dlv); int done = 1; switch (rs) { case PN_RECEIVED: // This is not a terminal state - it is informational, and the // peer is still processing the message. done = 0; break; case PN_ACCEPTED: pn_delivery_settle(dlv); if (!quiet) fprintf(stdout, "Send complete!\n"); break; case PN_REJECTED: case PN_RELEASED: case PN_MODIFIED: pn_delivery_settle(dlv); fprintf(stderr, "Message not accepted - code:%lu\n", (unsigned long)rs); break; default: // ??? no other terminal states defined, so ignore anything else pn_delivery_settle(dlv); fprintf(stderr, "Unknown delivery failure - code=%lu\n", (unsigned long)rs); break; } if (done) { // initiate clean shutdown of the endpoints pn_link_t *link = pn_delivery_link(dlv); pn_session_t *ssn = pn_link_session(link); pn_link_close(link); pn_session_close(ssn); pn_connection_close(pn_session_connection(ssn)); } } } break; case PN_TRANSPORT_ERROR: { // The connection to the peer failed. // pn_transport_t *tport = pn_event_transport(event); pn_condition_t *cond = pn_transport_condition(tport); fprintf(stderr, "Network transport failed!\n"); if (pn_condition_is_set(cond)) { const char *name = pn_condition_get_name(cond); const char *desc = pn_condition_get_description(cond); fprintf(stderr, " Error: %s Description: %s\n", (name) ? name : "<error name not provided>", (desc) ? desc : "<no description provided>"); } // pn_reactor_process() will exit with a false return value, stopping // the main loop. } break; default: break; } }