qd_listener_t *qd_dispatch_configure_listener(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_connection_manager_t *cm = qd->connection_manager;
qd_listener_t *li = qd_server_listener(qd->server);
if (!li || load_server_config(qd, &li->config, entity, true) != QD_ERROR_NONE) {
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create listener: %s", qd_error_message());
qd_listener_decref(li);
return 0;
}
char *fol = qd_entity_opt_string(entity, "failoverList", 0);
if (fol) {
li->config.failover_list = qd_failover_list(fol);
free(fol);
if (li->config.failover_list == 0) {
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create listener, bad failover list: %s",
qd_error_message());
qd_listener_decref(li);
return 0;
}
} else {
li->config.failover_list = 0;
}
DEQ_ITEM_INIT(li);
DEQ_INSERT_TAIL(cm->listeners, li);
log_config(cm->log_source, &li->config, "Listener");
return li;
}
static void check(int fd) {
if (qd_error_code()) {
qd_log(log_source, QD_LOG_CRITICAL, "Router start-up failed: %s", qd_error_message());
#ifdef __sun
FILE *file = fdopen(fd, "a+");
fprintf(file, "%s: %s\n", argv0, qd_error_message());
#else
dprintf(fd, "%s: %s\n", argv0, qd_error_message());
#endif
close(fd);
exit(1);
}
}
int main(int argc, char** argv)
{
if (argc != 2) {
fprintf(stderr, "usage: %s <config-file>\n", argv[0]);
exit(1);
}
int result = 0;
// Call qd_dispatch() first initialize allocator used by other tests.
qd_dispatch_t *qd = qd_dispatch(0);
qd_dispatch_load_config(qd, argv[1]);
if (qd_error_code()) {
printf("Config failed: %s\n", qd_error_message());
return 1;
}
result += timer_tests();
result += server_tests(qd);
result += tool_tests();
result += parse_tests();
result += compose_tests();
#if USE_MEMORY_POOL
result += alloc_tests();
#endif
result += policy_tests();
qd_dispatch_free(qd); // dispatch_free last.
return result;
}
static int IoAdapter_init(IoAdapter *self, PyObject *args, PyObject *kwds)
{
PyObject *addr;
char aclass = 'L';
char phase = '0';
int treatment = QD_TREATMENT_ANYCAST_CLOSEST;
if (!PyArg_ParseTuple(args, "OO|cci", &self->handler, &addr, &aclass, &phase, &treatment))
return -1;
if (!PyCallable_Check(self->handler)) {
PyErr_SetString(PyExc_TypeError, "IoAdapter.__init__ handler is not callable");
return -1;
}
if (treatment == QD_TREATMENT_ANYCAST_BALANCED) {
PyErr_SetString(PyExc_TypeError, "IoAdapter: ANYCAST_BALANCED is not supported for in-process subscriptions");
return -1;
}
Py_INCREF(self->handler);
self->qd = dispatch;
self->core = qd_router_core(self->qd);
const char *address = PyString_AsString(addr);
if (!address) return -1;
qd_error_clear();
self->sub = qdr_core_subscribe(self->core, address, aclass, phase, treatment, qd_io_rx_handler, self);
if (qd_error_code()) {
PyErr_SetString(PyExc_RuntimeError, qd_error_message());
return -1;
}
return 0;
}
qd_connector_t *qd_dispatch_configure_connector(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_connection_manager_t *cm = qd->connection_manager;
qd_connector_t *ct = qd_server_connector(qd->server);
if (ct && load_server_config(qd, &ct->config, entity, false) == QD_ERROR_NONE) {
DEQ_ITEM_INIT(ct);
DEQ_INSERT_TAIL(cm->connectors, ct);
log_config(cm->log_source, &ct->config, "Connector");
//
// Add the first item to the ct->conn_info_list
// The initial connection information and any backup connection information is stored in the conn_info_list
//
qd_failover_item_t *item = NEW(qd_failover_item_t);
ZERO(item);
item->scheme = 0;
item->host = strdup(ct->config.host);
item->port = strdup(ct->config.port);
item->hostname = 0;
int hplen = strlen(item->host) + strlen(item->port) + 2;
item->host_port = malloc(hplen);
snprintf(item->host_port, hplen, "%s:%s", item->host , item->port);
DEQ_INSERT_TAIL(ct->conn_info_list, item);
return ct;
}
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create connector: %s", qd_error_message());
qd_connector_decref(ct);
return 0;
}
qd_config_listener_t *qd_dispatch_configure_listener(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_error_clear();
qd_connection_manager_t *cm = qd->connection_manager;
qd_config_listener_t *cl = NEW(qd_config_listener_t);
cl->is_connector = false;
cl->state = QD_BIND_NONE;
cl->listener = 0;
qd_config_ssl_profile_t *ssl_profile = 0;
if (load_server_config(qd, &cl->configuration, entity, &ssl_profile) != QD_ERROR_NONE) {
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create config listener: %s", qd_error_message());
qd_config_listener_free(qd->connection_manager, cl);
return 0;
}
cl->ssl_profile = ssl_profile;
DEQ_ITEM_INIT(cl);
DEQ_INSERT_TAIL(cm->config_listeners, cl);
qd_log(cm->log_source, QD_LOG_INFO, "Configured Listener: %s:%s proto=%s, role=%s%s%s",
cl->configuration.host, cl->configuration.port,
cl->configuration.protocol_family ? cl->configuration.protocol_family : "any",
cl->configuration.role,
cl->ssl_profile ? ", sslProfile=":"",
cl->ssl_profile ? cl->ssl_profile->name:"");
return cl;
}
qd_config_ssl_profile_t *qd_dispatch_configure_ssl_profile(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_error_clear();
qd_connection_manager_t *cm = qd->connection_manager;
qd_config_ssl_profile_t *ssl_profile = NEW(qd_config_ssl_profile_t);
DEQ_ITEM_INIT(ssl_profile);
DEQ_INSERT_TAIL(cm->config_ssl_profiles, ssl_profile);
ssl_profile->name = qd_entity_opt_string(entity, "name", 0); CHECK();
ssl_profile->ssl_certificate_file = qd_entity_opt_string(entity, "certFile", 0); CHECK();
ssl_profile->ssl_private_key_file = qd_entity_opt_string(entity, "keyFile", 0); CHECK();
ssl_profile->ssl_password = qd_entity_opt_string(entity, "password", 0); CHECK();
ssl_profile->ssl_trusted_certificate_db = qd_entity_opt_string(entity, "certDb", 0); CHECK();
ssl_profile->ssl_trusted_certificates = qd_entity_opt_string(entity, "trustedCerts", 0); CHECK();
ssl_profile->ssl_uid_format = qd_entity_opt_string(entity, "uidFormat", 0); CHECK();
ssl_profile->ssl_display_name_file = qd_entity_opt_string(entity, "displayNameFile", 0); CHECK();
sys_atomic_init(&ssl_profile->ref_count, 0);
qd_log(cm->log_source, QD_LOG_INFO, "Created SSL Profile with name %s ", ssl_profile->name);
return ssl_profile;
error:
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create ssl profile: %s", qd_error_message());
qd_config_ssl_profile_free(cm, ssl_profile);
return 0;
}
qd_error_t qd_error_errno_impl(int errnum, const char *file, int line, const char *fmt, ...) {
if (errnum) {
ts.error_code = QD_ERROR_SYSTEM;
char buf[ERROR_MAX];
char *errstr = strerror_r(errno, buf, sizeof(buf));
char *begin = ts.error_message;
char *end = begin + ERROR_MAX;
va_list arglist;
va_start(arglist, fmt);
vaprintf(&begin, end, fmt, arglist);
va_end(arglist);
aprintf(&begin, end, ": %s", errstr);
qd_log_impl(log_source, QD_LOG_ERROR, file, line, "%s", qd_error_message());
return qd_error_code();
}
else
return qd_error_clear();
}
static PyObject *qd_python_send(PyObject *self, PyObject *args)
{
qd_error_clear();
IoAdapter *ioa = (IoAdapter*) self;
qd_composed_field_t *field = 0;
PyObject *message = 0;
int no_echo = 1;
int control = 0;
if (!PyArg_ParseTuple(args, "O|ii", &message, &no_echo, &control))
return 0;
if (compose_python_message(&field, message, ioa->qd) == QD_ERROR_NONE) {
qd_message_t *msg = qd_message();
qd_message_compose_2(msg, field);
qd_composed_field_t *ingress = qd_compose_subfield(0);
qd_compose_insert_string(ingress, qd_router_id(ioa->qd));
qd_composed_field_t *trace = qd_compose_subfield(0);
qd_compose_start_list(trace);
qd_compose_insert_string(trace, qd_router_id(ioa->qd));
qd_compose_end_list(trace);
qd_message_set_ingress_annotation(msg, ingress);
qd_message_set_trace_annotation(msg, trace);
PyObject *address = PyObject_GetAttrString(message, "address");
if (address) {
qdr_send_to2(ioa->core, msg, PyString_AsString(address), (bool) no_echo, (bool) control);
Py_DECREF(address);
}
qd_compose_free(field);
qd_message_free(msg);
Py_RETURN_NONE;
}
if (!PyErr_Occurred())
PyErr_SetString(PyExc_RuntimeError, qd_error_message());
return 0;
}
qd_error_t qd_error_impl(qd_error_t code, const char *file, int line, const char *fmt, ...) {
ts.error_code = code;
if (code) {
char *begin = ts.error_message;
char *end = begin + ERROR_MAX;
(void)aprintf;
const char* name = qd_error_name(code);
if (name)
aprintf(&begin, end, "%s: ", name);
else
aprintf(&begin, end, "%d: ", code);
va_list arglist;
va_start(arglist, fmt);
vaprintf(&begin, end, fmt, arglist);
va_end(arglist);
// NOTE: Use the file/line from the qd_error macro, not this line in error.c
qd_log_impl(log_source, QD_LOG_ERROR, file, line, "%s", qd_error_message());
return code;
}
else
qd_error_clear();
return 0;
}
qd_config_connector_t *qd_dispatch_configure_connector(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_error_clear();
qd_connection_manager_t *cm = qd->connection_manager;
qd_config_connector_t *cc = NEW(qd_config_connector_t);
ZERO(cc);
cc->is_connector = true;
if (load_server_config(qd, &cc->configuration, entity) != QD_ERROR_NONE) {
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create config connector: %s", qd_error_message());
qd_config_connector_free(cc);
return 0;
}
DEQ_ITEM_INIT(cc);
DEQ_INSERT_TAIL(cm->config_connectors, cc);
qd_log(cm->log_source, QD_LOG_INFO, "Configured Connector: %s:%s proto=%s role=%s",
cc->configuration.host, cc->configuration.port,
cc->configuration.protocol_family ? cc->configuration.protocol_family : "any",
cc->configuration.role);
return cc;
}
qd_config_sasl_plugin_t *qd_dispatch_configure_sasl_plugin(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_error_clear();
qd_connection_manager_t *cm = qd->connection_manager;
qd_config_sasl_plugin_t *sasl_plugin = NEW(qd_config_sasl_plugin_t);
DEQ_ITEM_INIT(sasl_plugin);
DEQ_INSERT_TAIL(cm->config_sasl_plugins, sasl_plugin);
sasl_plugin->name = qd_entity_opt_string(entity, "name", 0); CHECK();
sasl_plugin->auth_service = qd_entity_opt_string(entity, "authService", 0); CHECK();
sasl_plugin->sasl_init_hostname = qd_entity_opt_string(entity, "saslInitHostname", 0); CHECK();
sasl_plugin->auth_ssl_profile = qd_entity_opt_string(entity, "authSslProfile", 0); CHECK();
qd_log(cm->log_source, QD_LOG_INFO, "Created SASL plugin config with name %s", sasl_plugin->name);
return sasl_plugin;
error:
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create SASL plugin config: %s", qd_error_message());
config_sasl_plugin_free(cm, sasl_plugin);
return 0;
}
qd_config_ssl_profile_t *qd_dispatch_configure_ssl_profile(qd_dispatch_t *qd, qd_entity_t *entity)
{
qd_error_clear();
qd_connection_manager_t *cm = qd->connection_manager;
qd_config_ssl_profile_t *ssl_profile = NEW(qd_config_ssl_profile_t);
DEQ_ITEM_INIT(ssl_profile);
DEQ_INSERT_TAIL(cm->config_ssl_profiles, ssl_profile);
ssl_profile->name = qd_entity_opt_string(entity, "name", 0); CHECK();
ssl_profile->ssl_certificate_file = qd_entity_opt_string(entity, "certFile", 0); CHECK();
ssl_profile->ssl_private_key_file = qd_entity_opt_string(entity, "keyFile", 0); CHECK();
ssl_profile->ssl_password = qd_entity_opt_string(entity, "password", 0); CHECK();
if (!ssl_profile->ssl_password) {
// SSL password not provided. Check if passwordFile property is specified.
char *password_file = qd_entity_opt_string(entity, "passwordFile", 0); CHECK();
if (password_file) {
FILE *file = fopen(password_file, "r");
if (file) {
char buffer[200];
int c;
int i=0;
while (i < 200 - 1) {
c = fgetc(file);
if (c == EOF || c == '\n')
break;
buffer[i++] = c;
}
if (i != 0) {
buffer[i] = '\0';
free(ssl_profile->ssl_password);
ssl_profile->ssl_password = strdup(buffer);
}
fclose(file);
}
}
free(password_file);
}
ssl_profile->ciphers = qd_entity_opt_string(entity, "ciphers", 0); CHECK();
ssl_profile->ssl_trusted_certificate_db = qd_entity_opt_string(entity, "certDb", 0); CHECK();
ssl_profile->ssl_trusted_certificates = qd_entity_opt_string(entity, "trustedCerts", 0); CHECK();
ssl_profile->ssl_uid_format = qd_entity_opt_string(entity, "uidFormat", 0); CHECK();
ssl_profile->ssl_display_name_file = qd_entity_opt_string(entity, "displayNameFile", 0); CHECK();
//
// Process the password to handle any modifications or lookups needed
//
qd_config_ssl_profile_process_password(ssl_profile); CHECK();
qd_log(cm->log_source, QD_LOG_INFO, "Created SSL Profile with name %s ", ssl_profile->name);
return ssl_profile;
error:
qd_log(cm->log_source, QD_LOG_ERROR, "Unable to create ssl profile: %s", qd_error_message());
config_ssl_profile_free(cm, ssl_profile);
return 0;
}
