int pn_messenger_tsync(pn_messenger_t *messenger, bool (*predicate)(pn_messenger_t *), int timeout)
{
for (int i = 0; i < messenger->size; i++) {
pn_connector_process(messenger->connectors[i]);
}
struct timeval now;
if (gettimeofday(&now, NULL)) pn_fatal("gettimeofday failed\n");
long int deadline = millis(now) + timeout;
bool pred;
while (true) {
pred = predicate(messenger);
int remaining = deadline - millis(now);
if (pred || (timeout >= 0 && remaining < 0)) break;
pn_driver_wait(messenger->driver, remaining);
pn_listener_t *l;
while ((l = pn_driver_listener(messenger->driver))) {
pn_connector_t *c = pn_listener_accept(l);
pn_sasl_t *sasl = pn_connector_sasl(c);
pn_sasl_mechanisms(sasl, "ANONYMOUS");
pn_sasl_server(sasl);
pn_sasl_done(sasl, PN_SASL_OK);
pn_connection_t *conn = pn_connection();
pn_connection_set_container(conn, messenger->name);
pn_connector_set_connection(c, conn);
messenger->connectors[messenger->size++] = c;
}
pn_connector_t *c;
while ((c = pn_driver_connector(messenger->driver))) {
pn_connector_process(c);
pn_connection_t *conn = pn_connector_connection(c);
pn_messenger_endpoints(messenger, conn);
if (pn_connector_closed(c)) {
for (int i = 0; i < messenger->size; i++) {
if (c == messenger->connectors[i]) {
memmove(messenger->connectors + i, messenger->connectors + i + 1, messenger->size - i - 1);
messenger->size--;
pn_connector_free(c);
pn_messenger_reclaim(messenger, conn);
pn_connection_free(conn);
pn_messenger_flow(messenger);
break;
}
}
} else {
pn_connector_process(c);
}
}
if (timeout >= 0) {
if (gettimeofday(&now, NULL)) pn_fatal("gettimeofday failed\n");
}
}
return pred ? 0 : PN_TIMEOUT;
}
int main(int argc, char **argv)
{
char *url = NULL;
char *address = "queue";
char *mechanism = "ANONYMOUS";
int count = 1;
bool quiet = false;
int high = 100;
int low = 50;
int size = 32;
int opt;
while ((opt = getopt(argc, argv, "c:a:m:n:s:u:l:qhVXY")) != -1)
{
switch (opt) {
case 'c':
if (url) pn_fatal("multiple connect urls not allowed\n");
url = optarg;
break;
case 'a':
address = optarg;
break;
case 'm':
mechanism = optarg;
break;
case 'n':
count = atoi(optarg);
break;
case 's':
size = atoi(optarg);
break;
case 'u':
high = atoi(optarg);
break;
case 'l':
low = atoi(optarg);
break;
case 'q':
quiet = true;
break;
case 'V':
printf("proton version %i.%i\n", PN_VERSION_MAJOR, PN_VERSION_MINOR);
exit(EXIT_SUCCESS);
case 'X':
value(argc, argv);
exit(EXIT_SUCCESS);
case 'Y':
buffer(argc, argv);
exit(EXIT_SUCCESS);
case 'h':
printf("Usage: %s [-h] [-c [user[:password]@]host[:port]] [-a <address>] [-m <sasl-mech>]\n", argv[0]);
printf("\n");
printf(" -c The connect url.\n");
printf(" -a The AMQP address.\n");
printf(" -m The SASL mechanism.\n");
printf(" -n The number of messages.\n");
printf(" -s Message size.\n");
printf(" -u Upper flow threshold.\n");
printf(" -l Lower flow threshold.\n");
printf(" -q Supress printouts.\n");
printf(" -h Print this help.\n");
exit(EXIT_SUCCESS);
default: /* '?' */
pn_fatal("Usage: %s -h\n", argv[0]);
}
}
char *user = NULL;
char *pass = NULL;
char *host = "0.0.0.0";
char *port = "5672";
parse_url(url, &user, &pass, &host, &port);
pn_driver_t *drv = pn_driver();
if (url) {
struct client_context ctx = {false, false, count, count, drv, quiet, size, high, low};
ctx.username = user;
ctx.password = pass;
ctx.mechanism = mechanism;
ctx.hostname = host;
ctx.address = address;
pn_connector_t *ctor = pn_connector(drv, host, port, &ctx);
if (!ctor) pn_fatal("connector failed\n");
pn_connector_set_connection(ctor, pn_connection());
while (!ctx.done) {
pn_driver_wait(drv, -1);
pn_connector_t *c;
while ((c = pn_driver_connector(drv))) {
pn_connector_process(c);
client_callback(c);
if (pn_connector_closed(c)) {
pn_connection_free(pn_connector_connection(c));
pn_connector_free(c);
} else {
pn_connector_process(c);
}
}
}
} else {
struct server_context ctx = {0, quiet, size};
if (!pn_listener(drv, host, port, &ctx)) pn_fatal("listener failed\n");
while (true) {
pn_driver_wait(drv, -1);
pn_listener_t *l;
pn_connector_t *c;
while ((l = pn_driver_listener(drv))) {
c = pn_listener_accept(l);
pn_connector_set_context(c, &ctx);
}
while ((c = pn_driver_connector(drv))) {
pn_connector_process(c);
server_callback(c);
if (pn_connector_closed(c)) {
pn_connection_free(pn_connector_connection(c));
pn_connector_free(c);
} else {
pn_connector_process(c);
}
}
}
}
pn_driver_free(drv);
return 0;
}
int
main ( int argc, char ** argv )
{
char info[1000];
int expected = (argc > 1) ? atoi(argv[1]) : 100000;
int received = 0;
int size = 32;
int msg_size = 50;
bool done = false;
int initial_credit = 500,
new_credit = 250,
low_credit_limit = 250;
char const * host = "0.0.0.0";
char const * port = "5672";
bool sasl_done = false;
pn_driver_t * driver;
pn_listener_t * listener;
pn_connector_t * connector;
pn_connection_t * connection;
pn_session_t * session;
pn_link_t * link;
pn_delivery_t * delivery;
char * message_data = (char *) malloc ( MY_BUF_SIZE );
int message_data_capacity = MY_BUF_SIZE;
fprintf ( stderr, "drecv expecting %d messages.\n", expected );
driver = pn_driver ( );
if ( ! pn_listener(driver, host, port, 0) )
{
fprintf ( stderr, "listener creation failed.\n" );
exit ( 1 );
}
while ( ! done)
{
pn_driver_wait ( driver, -1 );
if ( (listener = pn_driver_listener(driver)) )
pn_listener_accept( listener );
if ( (connector = pn_driver_connector(driver)) )
{
pn_connector_process ( connector );
if ( ! sasl_done )
if( ! (sasl_done = get_sasl_over_with(connector) ))
continue;
connection = pn_connector_connection ( connector );
/*=========================================================
Open everything that is ready on the
other side but not here.
=========================================================*/
pn_state_t hes_ready_im_not = PN_LOCAL_UNINIT | PN_REMOTE_ACTIVE;
if (pn_connection_state(connection) == hes_ready_im_not)
pn_connection_open( connection);
for ( session = pn_session_head(connection, hes_ready_im_not);
session;
session = pn_session_next(session, hes_ready_im_not)
)
pn_session_open(session);
for ( link = pn_link_head(connection, hes_ready_im_not);
link;
link = pn_link_next(link, hes_ready_im_not)
)
{
pn_terminus_copy(pn_link_source(link), pn_link_remote_source(link));
pn_terminus_copy(pn_link_target(link), pn_link_remote_target(link));
pn_link_open ( link );
if ( pn_link_is_receiver(link) )
pn_link_flow ( link, initial_credit );
}
/*==========================================================
Get all available deliveries.
==========================================================*/
for ( delivery = pn_work_head ( connection );
delivery;
delivery = pn_work_next ( delivery )
)
{
if ( pn_delivery_readable(delivery) )
{
link = pn_delivery_link ( delivery );
while ( PN_EOS != pn_link_recv(link, message_data, MY_BUF_SIZE) )
;
pn_link_advance ( link );
pn_delivery_update ( delivery, PN_ACCEPTED );
pn_delivery_settle ( delivery );
if ( ++ received >= expected )
{
sprintf ( info, "received %d messages", received );
print_timestamp ( stderr, info );
done = true;
}
// a progress report for long tests.
if ( ! (received % 5000000) )
fprintf ( stderr, "received: %d\n", received );
if ( pn_link_credit(link) <= low_credit_limit )
pn_link_flow ( link, new_credit );
}
else
{
// TODO
// Why am I getting writables?
// And what to do with them?
}
}
/*===============================================================
Shut down everything that the other side has closed.
===============================================================*/
pn_state_t active_here_closed_there = PN_LOCAL_ACTIVE | PN_REMOTE_CLOSED;
if ( pn_connection_state(connection) == active_here_closed_there )
pn_connection_close ( connection );
for ( session = pn_session_head(connection, active_here_closed_there);
session;
session = pn_session_next(session, active_here_closed_there)
)
pn_session_close ( session );
for ( link = pn_link_head(connection, active_here_closed_there);
link;
link = pn_link_next(link, active_here_closed_there)
)
pn_link_close ( link );
if ( pn_connector_closed(connector) )
{
pn_connection_free ( pn_connector_connection(connector) );
pn_connector_free ( connector );
done = true;
}
else
pn_connector_process(connector);
}
}
pn_driver_free(driver);
return 0;
}