void messaging_adapter::on_connection_remote_open(proton_event &pe) { pn_connection_t *conn = pn_event_connection(pe.pn_event()); connection c(make_wrapper(conn)); transport t(make_wrapper(pn_event_transport(pe.pn_event()))); delegate_.on_transport_open(t); delegate_.on_connection_open(c); if (!is_local_open(pn_connection_state(conn)) && is_local_unititialised(pn_connection_state(conn))) { pn_connection_open(conn); } }
connection_engine::connection_engine(class container& cont, link_namer& namer, event_loop* loop) : handler_(0), connection_(make_wrapper(internal::take_ownership(pn_connection()).get())), transport_(make_wrapper(internal::take_ownership(pn_transport()).get())), collector_(internal::take_ownership(pn_collector()).get()), container_(cont) { if (!connection_ || !transport_ || !collector_) throw proton::error("connection_engine create failed"); pn_transport_bind(unwrap(transport_), unwrap(connection_)); pn_connection_collect(unwrap(connection_), collector_.get()); connection_context& ctx = connection_context::get(connection_); ctx.container = &container_; ctx.link_gen = &namer; ctx.event_loop.reset(loop); }
void messaging_adapter::on_connection_remote_close(proton_event &pe) { pn_event_t *cevent = pe.pn_event(); pn_connection_t *conn = pn_event_connection(cevent); connection c(make_wrapper(conn)); if (pn_condition_is_set(pn_connection_remote_condition(conn))) { delegate_.on_connection_error(c); } delegate_.on_connection_close(c); pn_connection_close(conn); }
session connection::default_session() { connection_context& ctx = connection_context::get(pn_object()); if (!ctx.default_session) { // Note we can't use a proton::session here because we don't want to own // a session reference. The connection owns the session, owning it here as well // would create a circular ownership. ctx.default_session = pn_session(pn_object()); pn_session_open(ctx.default_session); } return make_wrapper(ctx.default_session); }
void messaging_adapter::on_transport_tail_closed(proton_event &pe) { pn_connection_t *conn = pn_event_connection(pe.pn_event()); if (conn && is_local_open(pn_connection_state(conn))) { pn_transport_t *tspt = pn_event_transport(pe.pn_event()); transport t(make_wrapper(tspt)); if (pn_condition_is_set(pn_transport_condition(tspt))) { delegate_.on_transport_error(t); } delegate_.on_transport_close(t); } }
void connector::connect() { pn_transport_t *pnt = pn_transport(); transport t(make_wrapper(pnt)); if (!address_.user().empty()) connection_.user(address_.user()); if (!address_.password().empty()) connection_.password(address_.password()); pn_transport_bind(pnt, unwrap(connection_)); pn_decref(pnt); // Apply options to the new transport. options_.apply(connection_); // if virtual-host not set, use host from address as default if (!options_.is_virtual_host_set()) pn_connection_set_hostname(unwrap(connection_), address_.host().c_str()); transport_configured_ = true; }
connection reactor::connection(pn_handler_t* h) const { return make_wrapper(pn_reactor_connection(pn_object(), h)); }
error_condition link::error() const { return make_wrapper(pn_link_remote_condition(pn_object())); }
class session link::session() const { return make_wrapper(pn_link_session(pn_object())); }
class connection link::connection() const { return make_wrapper(pn_session_connection(pn_link_session(pn_object()))); }
void value::reset(pn_data_t *d) { data_ = make_wrapper(d); }
sender::sender(pn_link_t *l): link(make_wrapper(l)) {}
receiver::receiver(pn_link_t* r): link(make_wrapper(r)) {}
error_condition connection::error() const { return make_wrapper(pn_connection_remote_condition(pn_object())); }
value terminus::node_properties() const { value x(make_wrapper(pn_terminus_properties(object_))); return x; }
acceptor reactor::listen(const url& url){ return make_wrapper(pn_reactor_acceptor(pn_object(), url.host().c_str(), url.port().c_str(), 0)); }
delivery::delivery(pn_delivery_t* d): transfer(make_wrapper(d)) {}
connection transfer::connection() const { return make_wrapper(pn_session_connection(pn_link_session(pn_delivery_link(pn_object())))); }
session_range connection::sessions() const { return session_range(session_iterator(make_wrapper(pn_session_head(pn_object(), 0)))); }
transport connection::transport() const { return make_wrapper(pn_connection_transport(pn_object())); }
connection reactor::connection_to_host(const std::string &host, const std::string &port, pn_handler_t* h) const { return make_wrapper(pn_reactor_connection_to_host(pn_object(), host.c_str(), port.c_str(), h)); }
connection session::connection() const { return make_wrapper(pn_session_connection(pn_object())); }