const char *pn_reactor_get_connection_address(pn_reactor_t *reactor,
pn_connection_t *connection)
{
(void)reactor; // ignored
if (!connection) return NULL;
pn_record_t *record = pn_connection_attachments(connection);
pn_url_t *url = (pn_url_t *)pn_record_get(record, PNI_CONN_URL);
if (!url) return NULL;
return pn_url_str(url);
}
void listener_dispatch(pn_handler_t *h, pn_event_t *event, pn_event_type_t type)
{
global_context_t *gc = global_context(h);
if (type == PN_REACTOR_QUIESCED)
gc->quiesce_count++;
else
gc->quiesce_count = 0;
switch (type) {
case PN_CONNECTION_INIT:
{
pn_connection_t *connection = pn_event_connection(event);
// New incoming connection on listener socket. Give each a separate handler.
pn_handler_t *ch = connection_handler(gc);
pn_handshaker_t *handshaker = pn_handshaker();
pn_handler_add(ch, handshaker);
pn_decref(handshaker);
pn_record_t *record = pn_connection_attachments(connection);
pn_record_set_handler(record, ch);
pn_decref(ch);
}
break;
case PN_REACTOR_QUIESCED:
{
// Two quiesce in a row means we have been idle for a timout period
if (gc->opts->timeout != -1 && gc->quiesce_count > 1)
global_shutdown(gc);
}
break;
case PN_REACTOR_INIT:
{
pn_reactor_t *reactor = pn_event_reactor(event);
start_listener(gc, reactor);
// hack to let test scripts know when the receivers are ready (so
// that the senders may be started)
if (gc->opts->ready_text) {
fprintf(stdout, "%s\n", gc->opts->ready_text);
fflush(stdout);
}
if (gc->opts->timeout != -1)
pn_reactor_set_timeout(pn_event_reactor(event), gc->opts->timeout);
}
break;
case PN_REACTOR_FINAL:
{
if (gc->received == 0) statistics_start(gc->stats);
statistics_report(gc->stats, gc->sent, gc->received);
}
break;
default:
break;
}
}
pn_connection_t *pn_reactor_connection(pn_reactor_t *reactor, pn_handler_t *handler) {
assert(reactor);
pn_connection_t *connection = pn_connection();
pn_record_t *record = pn_connection_attachments(connection);
pn_record_set_handler(record, handler);
pn_connection_collect(connection, pn_reactor_collector(reactor));
pn_list_add(pn_reactor_children(reactor), connection);
pni_record_init_reactor(record, reactor);
pn_decref(connection);
return connection;
}
void pni_reactor_set_connection_peer_address(pn_connection_t *connection,
const char *host,
const char *port)
{
pn_url_t *url = pn_url();
pn_url_set_host(url, host);
pn_url_set_port(url, port);
pn_record_t *record = pn_connection_attachments(connection);
if (!pn_record_has(record, PNI_CONN_PEER_ADDRESS)) {
pn_record_def(record, PNI_CONN_PEER_ADDRESS, PN_OBJECT);
}
pn_record_set(record, PNI_CONN_PEER_ADDRESS, url);
pn_decref(url);
}
void
listener_dispatch ( pn_handler_t *h, pn_event_t * event, pn_event_type_t type )
{
global_context_t * gc = global_context ( h );
if ( type == PN_REACTOR_QUIESCED )
gc->quiesce_count++;
else
gc->quiesce_count = 0;
switch (type)
{
case PN_CONNECTION_INIT:
{
pn_connection_t * connection = pn_event_connection ( event );
// New incoming connection on listener socket. Give each a separate handler.
pn_handler_t *ch = connection_handler(gc);
pn_handshaker_t *handshaker = pn_handshaker();
pn_handler_add(ch, handshaker);
pn_decref(handshaker);
pn_record_t *record = pn_connection_attachments(connection);
pn_record_set_handler(record, ch);
pn_decref(ch);
}
break;
case PN_REACTOR_INIT:
{
pn_reactor_t *reactor = pn_event_reactor(event);
start_listener(gc, reactor);
}
break;
case PN_REACTOR_FINAL:
{
if (gc->received == 0)
statistics_start(gc->stats);
//statistics_report(gc->stats, gc->sent, gc->received);
fclose ( gc->report_fp );
if ( gc->received > 0 )
fprintf ( stderr, "reactor-recv received %d messages.\n", gc->received );
}
break;
default:
break;
}
}
void pn_reactor_set_connection_host(pn_reactor_t *reactor,
pn_connection_t *connection,
const char *host,
const char *port)
{
(void)reactor; // ignored
pn_url_t *url = pn_url();
pn_url_set_host(url, host);
pn_url_set_port(url, port);
pn_record_t *record = pn_connection_attachments(connection);
if (!pn_record_has(record, PNI_CONN_URL)) {
pn_record_def(record, PNI_CONN_URL, PN_OBJECT);
}
pn_record_set(record, PNI_CONN_URL, url);
pn_decref(url);
}
void pni_handle_bound(pn_reactor_t *reactor, pn_event_t *event) {
assert(reactor);
assert(event);
pn_connection_t *conn = pn_event_connection(event);
pn_transport_t *transport = pn_event_transport(event);
pn_record_t *record = pn_connection_attachments(conn);
pn_url_t *url = (pn_url_t *)pn_record_get(record, PNI_CONN_PEER_ADDRESS);
const char *host = NULL;
const char *port = "5672";
pn_string_t *str = NULL;
// link the new transport to its reactor:
pni_record_init_reactor(pn_transport_attachments(transport), reactor);
if (pn_connection_acceptor(conn) != NULL) {
// this connection was created by the acceptor. There is already a
// socket assigned to this connection. Nothing needs to be done.
return;
}
if (url) {
host = pn_url_get_host(url);
const char *uport = pn_url_get_port(url);
if (uport) {
port = uport;
} else {
const char *scheme = pn_url_get_scheme(url);
if (scheme && strcmp(scheme, "amqps") == 0) {
port = "5671";
}
}
if (!pn_connection_get_user(conn)) {
// user did not manually set auth info
const char *user = pn_url_get_username(url);
if (user) pn_connection_set_user(conn, user);
const char *passwd = pn_url_get_password(url);
if (passwd) pn_connection_set_password(conn, passwd);
}
} else {
// for backward compatibility, see if the connection's hostname can be
// used for the remote address. See JIRA PROTON-1133
const char *hostname = pn_connection_get_hostname(conn);
if (hostname) {
str = pn_string(hostname);
char *h = pn_string_buffer(str);
// see if a port has been included in the hostname. This is not
// allowed by the spec, but the old reactor interface allowed it.
char *colon = strrchr(h, ':');
if (colon) {
*colon = '\0';
port = colon + 1;
}
host = h;
}
}
if (!host) {
// error: no address configured
pn_condition_t *cond = pn_transport_condition(transport);
pn_condition_set_name(cond, "proton:io");
pn_condition_set_description(cond, "Connection failed: no address configured");
pn_transport_close_tail(transport);
pn_transport_close_head(transport);
} else {
pn_socket_t sock = pn_connect(pni_reactor_io(reactor), host, port);
// invalid sockets are ignored by poll, so we need to do this manually
if (sock == PN_INVALID_SOCKET) {
pn_condition_t *cond = pn_transport_condition(transport);
pn_condition_set_name(cond, "proton:io");
pn_condition_set_description(cond, pn_error_text(pn_reactor_error(reactor)));
pn_transport_close_tail(transport);
pn_transport_close_head(transport);
} else {
pn_reactor_selectable_transport(reactor, sock, transport);
}
}
pn_free(str);
}
