qdr_core_t *qdr_core(qd_dispatch_t *qd, qd_router_mode_t mode, const char *area, const char *id)
{
qdr_core_t *core = NEW(qdr_core_t);
ZERO(core);
core->qd = qd;
core->router_mode = mode;
core->router_area = area;
core->router_id = id;
//
// Set up the logging sources for the router core
//
core->log = qd_log_source("ROUTER_CORE");
core->agent_log = qd_log_source("AGENT");
//
// Report on the configuration for unsettled multicasts
//
qd_log(core->log, QD_LOG_INFO, "Allow Unsettled Multicast: %s", qd->allow_unsettled_multicast ? "yes" : "no");
//
// Set up the threading support
//
core->action_cond = sys_cond();
core->action_lock = sys_mutex();
core->running = true;
DEQ_INIT(core->action_list);
core->work_lock = sys_mutex();
DEQ_INIT(core->work_list);
core->work_timer = qd_timer(core->qd, qdr_general_handler, core);
//
// Set up the unique identifier generator
//
core->next_identifier = 1;
core->id_lock = sys_mutex();
//
// Launch the core thread
//
core->thread = sys_thread(router_core_thread, core);
//
// Perform outside-of-thread setup for the management agent
//
core->agent_subscription_mobile = qdr_core_subscribe(core, "$management", 'M', '0',
QD_TREATMENT_ANYCAST_CLOSEST,
qdr_management_agent_on_message, core);
core->agent_subscription_local = qdr_core_subscribe(core, "$management", 'L', '0',
QD_TREATMENT_ANYCAST_CLOSEST,
qdr_management_agent_on_message, core);
return core;
}
static int LogAdapter_init(LogAdapter *self, PyObject *args, PyObject *kwds)
{
const char *text;
if (!PyArg_ParseTuple(args, "s", &text))
return -1;
self->module_name = PyString_FromString(text);
self->log_source = qd_log_source(text);
return 0;
}
void qd_python_initialize(qd_dispatch_t *qd, const char *python_pkgdir)
{
log_source = qd_log_source("PYTHON");
dispatch = qd;
ilock = sys_mutex();
if (python_pkgdir)
dispatch_python_pkgdir = PyString_FromString(python_pkgdir);
qd_python_lock_state_t ls = qd_python_lock();
Py_Initialize();
qd_python_setup();
qd_python_unlock(ls);
}
qd_router_t *qd_router(qd_dispatch_t *qd, qd_router_mode_t mode, const char *area, const char *id)
{
if (!type_registered) {
type_registered = 1;
qd_container_register_node_type(qd, &router_node);
}
size_t dplen = 9 + strlen(area) + strlen(id);
node_id = (char*) malloc(dplen);
strcpy(node_id, area);
strcat(node_id, "/");
strcat(node_id, id);
qd_router_t *router = NEW(qd_router_t);
ZERO(router);
router_node.type_context = router;
qd->router = router;
router->qd = qd;
router->router_core = 0;
router->log_source = qd_log_source("ROUTER");
router->router_mode = mode;
router->router_area = area;
router->router_id = id;
router->node = qd_container_set_default_node_type(qd, &router_node, (void*) router, QD_DIST_BOTH);
router->lock = sys_mutex();
router->timer = qd_timer(qd, qd_router_timer_handler, (void*) router);
//
// Inform the field iterator module of this router's id and area. The field iterator
// uses this to offload some of the address-processing load from the router.
//
qd_iterator_set_address(area, id);
//
// Seed the random number generator
//
unsigned int seed = (unsigned int) time(0);
srandom(seed);
switch (router->router_mode) {
case QD_ROUTER_MODE_STANDALONE: qd_log(router->log_source, QD_LOG_INFO, "Router started in Standalone mode"); break;
case QD_ROUTER_MODE_INTERIOR: qd_log(router->log_source, QD_LOG_INFO, "Router started in Interior mode, area=%s id=%s", area, id); break;
case QD_ROUTER_MODE_EDGE: qd_log(router->log_source, QD_LOG_INFO, "Router started in Edge mode"); break;
case QD_ROUTER_MODE_ENDPOINT: qd_log(router->log_source, QD_LOG_INFO, "Router started in Endpoint mode"); break;
}
return router;
}
void qd_log_initialize(void)
{
DEQ_INIT(entries);
DEQ_INIT(source_list);
DEQ_INIT(sink_list);
// Set up level_names for use in error messages.
ZERO((char*)level_names);
char *begin = (char*)level_names, *end = (char*)level_names+sizeof(level_names);
aprintf(&begin, end, "%s", levels[NONE].name);
for (level_index_t i = NONE + 1; i < N_LEVELS; ++i)
aprintf(&begin, end, ", %s", levels[i].name);
log_lock = sys_mutex();
log_source_lock = sys_mutex();
default_log_source = qd_log_source(SOURCE_DEFAULT);
default_log_source->mask = levels[INFO].mask;
default_log_source->timestamp = true;
default_log_source->source = 0;
default_log_source->sink = log_sink_lh(SINK_STDERR);
logging_log_source = qd_log_source(SOURCE_LOGGING);
}
qd_connection_manager_t *qd_connection_manager(qd_dispatch_t *qd)
{
qd_connection_manager_t *cm = NEW(qd_connection_manager_t);
if (!cm)
return 0;
cm->log_source = qd_log_source("CONN_MGR");
cm->server = qd->server;
DEQ_INIT(cm->config_listeners);
DEQ_INIT(cm->config_connectors);
DEQ_INIT(cm->on_demand_connectors);
return cm;
}
qd_connection_manager_t *qd_connection_manager(qd_dispatch_t *qd)
{
qd_connection_manager_t *cm = NEW(qd_connection_manager_t);
if (!cm)
return 0;
cm->log_source = qd_log_source("CONN_MGR");
cm->ssl_profile_lock = sys_mutex();
cm->server = qd->server;
DEQ_INIT(cm->config_listeners);
DEQ_INIT(cm->config_connectors);
DEQ_INIT(cm->config_ssl_profiles);
return cm;
}
/** Create the policy structure
* @param[in] qd pointer the the qd
**/
qd_policy_t *qd_policy(qd_dispatch_t *qd)
{
qd_policy_t *policy = NEW(qd_policy_t);
policy->qd = qd;
policy->log_source = qd_log_source("POLICY");
policy->max_connection_limit = 65535;
policy->policyDir = 0;
policy->enableVhostPolicy = false;
policy->connections_processed= 0;
policy->connections_denied = 0;
policy->connections_current = 0;
qd_log(policy->log_source, QD_LOG_TRACE, "Policy Initialized");
return policy;
}
qd_container_t *qd_container(qd_dispatch_t *qd)
{
qd_container_t *container = NEW(qd_container_t);
container->qd = qd;
container->log_source = qd_log_source("CONTAINER");
container->server = qd->server;
container->node_type_map = qd_hash(6, 4, 1); // 64 buckets, item batches of 4
container->node_map = qd_hash(10, 32, 0); // 1K buckets, item batches of 32
container->lock = sys_mutex();
container->default_node = 0;
DEQ_INIT(container->nodes);
DEQ_INIT(container->node_type_list);
qd_server_set_conn_handler(qd, handler, pn_event_handler, container);
qd_log(container->log_source, QD_LOG_TRACE, "Container Initialized");
return container;
}
static void main_process(const char *config_path, const char *python_pkgdir, int fd)
{
dispatch = qd_dispatch(python_pkgdir);
check(fd);
log_source = qd_log_source("MAIN"); /* Logging is initialized by qd_dispatch. */
qd_dispatch_validate_config(config_path);
check(fd);
qd_dispatch_load_config(dispatch, config_path);
check(fd);
signal(SIGHUP, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
if (fd > 2) { /* Daemon mode, fd is one end of a pipe not stdout or stderr */
#ifdef __sun
const char * okResult = "ok";
write(fd, okResult, (strlen(okResult)+1));
#else
dprintf(fd, "ok"); // Success signal
#endif
close(fd);
}
qd_server_run(dispatch);
qd_dispatch_t *d = dispatch;
dispatch = NULL;
qd_dispatch_free(d);
fflush(stdout);
if (exit_with_sigint) {
signal(SIGINT, SIG_DFL);
kill(getpid(), SIGINT);
}
}
qd_error_t qd_router_python_setup(qd_router_t *router)
{
qd_error_clear();
log_source = qd_log_source("ROUTER");
qdr_core_route_table_handlers(router->router_core,
router,
qd_router_mobile_added,
qd_router_mobile_removed,
qd_router_link_lost);
//
// If we are not operating as an interior router, don't start the
// router module.
//
if (router->router_mode != QD_ROUTER_MODE_INTERIOR)
return QD_ERROR_NONE;
PyObject *pDispatchModule = qd_python_module();
RouterAdapterType.tp_new = PyType_GenericNew;
PyType_Ready(&RouterAdapterType);
QD_ERROR_PY_RET();
PyTypeObject *raType = &RouterAdapterType;
Py_INCREF(raType);
PyModule_AddObject(pDispatchModule, "RouterAdapter", (PyObject*) &RouterAdapterType);
//
// Attempt to import the Python Router module
//
PyObject* pId;
PyObject* pArea;
PyObject* pMaxRouters;
PyObject* pModule;
PyObject* pClass;
PyObject* pArgs;
pModule = PyImport_ImportModule("qpid_dispatch_internal.router");
QD_ERROR_PY_RET();
pClass = PyObject_GetAttrString(pModule, "RouterEngine");
Py_DECREF(pModule);
QD_ERROR_PY_RET();
PyObject *adapterType = PyObject_GetAttrString(pDispatchModule, "RouterAdapter");
QD_ERROR_PY_RET();
PyObject *adapterInstance = PyObject_CallObject(adapterType, 0);
QD_ERROR_PY_RET();
((RouterAdapter*) adapterInstance)->router = router;
//
// Constructor Arguments for RouterEngine
//
pArgs = PyTuple_New(4);
// arg 0: adapter instance
PyTuple_SetItem(pArgs, 0, adapterInstance);
// arg 1: router_id
pId = PyString_FromString(router->router_id);
PyTuple_SetItem(pArgs, 1, pId);
// arg 2: area_id
pArea = PyString_FromString(router->router_area);
PyTuple_SetItem(pArgs, 2, pArea);
// arg 3: max_routers
pMaxRouters = PyInt_FromLong((long) qd_bitmask_width());
PyTuple_SetItem(pArgs, 3, pMaxRouters);
//
// Instantiate the router
//
pyRouter = PyInstance_New(pClass, pArgs, 0);
Py_DECREF(pArgs);
Py_DECREF(adapterType);
QD_ERROR_PY_RET();
pyTick = PyObject_GetAttrString(pyRouter, "handleTimerTick");
QD_ERROR_PY_RET();
pyAdded = PyObject_GetAttrString(pyRouter, "addressAdded");
QD_ERROR_PY_RET();
pyRemoved = PyObject_GetAttrString(pyRouter, "addressRemoved");
QD_ERROR_PY_RET();
pyLinkLost = PyObject_GetAttrString(pyRouter, "linkLost");
QD_ERROR_PY_RET();
return qd_error_code();
}
void qd_error_initialize() {
log_source = qd_log_source("ERROR");
}
void qd_message_initialize() {
log_source = qd_log_source("MESSAGE");
}
