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()));
}
