/**
* Connects to receive broadcasts on a given object key
*/
void subscribe_socket::connect(std::string objectkey) {
std::lock_guard<mutex> guard(lock);
if (publishers.count(objectkey) == 0) {
std::string local_address = normalize_address(objectkey);
int ret = nn_connect(z_socket, local_address.c_str());
if (ret > 0) {
publishers[objectkey] = ret;
}
}
}
publish_socket::publish_socket(void* zmq_ctx,
graphlab::zookeeper_util::key_value* keyval,
std::string alternate_bind_address)
:z_ctx(zmq_ctx), zk_keyval(keyval) {
// create a socket
z_socket = zmq_socket(z_ctx, ZMQ_PUB);
set_conservative_socket_parameters(z_socket);
#ifdef ZMQ_PUB_NODROP
{
// if no drop is defined. Set the HWM to something more sensible
int nodrop = 1;
int rc = zmq_setsockopt(z_socket, ZMQ_PUB_NODROP, &nodrop, sizeof(nodrop));
assert(rc == 0);
}
#endif
int hwm = 1024*1024; // 1MB
int rc = zmq_setsockopt(z_socket, ZMQ_SNDHWM, &hwm, sizeof(hwm));
assert(rc == 0);
assert(z_socket != NULL);
if (!alternate_bind_address.empty()) {
local_address = normalize_address(alternate_bind_address);
int rc = zmq_bind(z_socket, local_address.c_str());
if (rc != 0) {
print_zmq_error("publish_socket construction: ");
assert(rc == 0);
}
} else {
// what is the listening socket?
std::string localip = graphlab::get_local_ip_as_str(true);
bool ok = false;
while (!ok) {
size_t port = get_next_port_number();
char port_as_string[128];
sprintf(port_as_string, "%ld", port);
local_address = "tcp://" + localip + ":" + port_as_string;
// try to bind
int rc = zmq_bind(z_socket, local_address.c_str());
ok = (rc == 0);
/*if (rc == EADDRINUSE) {
std::cout << local_address << " in use. Trying another port.\n";
continue;
} else if (rc != 0) {
std::cout << "Unable to bind to " << local_address << ". "
<< "Error(" << rc << ") = " << zmq_strerror(rc) << "\n";
}*/
}
}
// std::cout << "Bound to " << local_address << "\n";
}
/**
* Update and normalize atsi performance information
*
* @param address the address to update
*/
void
GAS_normalization_update_property (struct ATS_Address *address)
{
const struct GNUNET_ATS_Properties *prop = &address->properties;
struct PropertyRange range;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Updating properties for peer `%s'\n",
GNUNET_i2s (&address->peer));
GAS_plugin_solver_lock ();
update_avg (prop->delay.rel_value_us,
&address->norm_delay);
update_avg (prop->distance,
&address->norm_distance);
update_avg (prop->utilization_in,
&address->norm_utilization_in);
update_avg (prop->utilization_in,
&address->norm_utilization_out);
init_range (&range);
GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
&find_min_max_it,
&range);
if (0 != memcmp (&range,
&property_range,
sizeof (struct PropertyRange)))
{
/* limits changed, (re)normalize all addresses */
property_range = range;
GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
&normalize_address,
NULL);
GNUNET_CONTAINER_multipeermap_iterate (GSA_addresses,
¬ify_change,
NULL);
}
else
{
/* renormalize just this one address */
normalize_address (NULL,
&address->peer,
address);
notify_change (NULL,
&address->peer,
address);
}
GAS_plugin_solver_unlock ();
}
reply_socket::reply_socket(void* zmq_ctx,
graphlab::zookeeper_util::key_value* keyval,
callback_type callback,
std::string alternate_bind_address)
:z_ctx(zmq_ctx), zk_keyval(keyval), callback(callback), associated_pollset(NULL) {
// create a socket
z_socket = zmq_socket(z_ctx, ZMQ_ROUTER);
set_conservative_socket_parameters(z_socket);
assert(z_socket != NULL);
if (!alternate_bind_address.empty()) {
local_address = normalize_address(alternate_bind_address);
int rc = zmq_bind(z_socket, local_address.c_str());
if (rc != 0) {
print_zmq_error("reply_socket construction: ");
assert(rc == 0);
}
} else {
// what is the listening socket?
std::string localip = graphlab::get_local_ip_as_str(true);
bool ok = false;
while (!ok) {
size_t port = get_next_port_number();
char port_as_string[128];
sprintf(port_as_string, "%ld", port);
local_address = "tcp://" + localip + ":" + port_as_string;
// try to bind
int rc = zmq_bind(z_socket, local_address.c_str());
ok = (rc == 0);
/*if (rc == EADDRINUSE) {
std::cout << local_address << " in use. Trying another port.\n";
continue;
} else if (rc != 0) {
std::cout << "Unable to bind to " << local_address << ". "
<< "Error(" << rc << ") = " << zmq_strerror(rc) << "\n";
}*/
}
}
// std::cout << "Bound to " << local_address << "\n";
}
void subscribe_socket::timer_callback(socket_receive_pollset* unused,
const zmq_pollitem_t& unused2) {
if (publisher_info_changed == false) return;
else {
// loop though all the subscriptions and check for server changes.
// disconnecting, and reconnecting if necessary
boost::lock_guard<boost::recursive_mutex> guard(lock);
for(size_t i = 0;i < publishers.size(); ++i) {
if (publishers[i].server_changed &&
!publishers[i].connected_server.empty()) {
zmq_disconnect(z_socket, publishers[i].connected_server.c_str());
publishers[i].connected_server.clear();
}
if (!publishers[i].server.empty()) {
std::string local_address = normalize_address(publishers[i].server);
zmq_connect(z_socket, local_address.c_str());
publishers[i].connected_server = publishers[i].server;
}
publishers[i].server_changed = false;
}
publisher_info_changed = false;
}
}
/**
* Connects to receive broadcasts on a given object key
*/
void subscribe_socket::connect(std::string objectkey) {
boost::lock_guard<boost::recursive_mutex> guard(lock);
for (size_t i = 0;i < publishers.size(); ++i) {
if (publishers[i].key == objectkey) {
return;
}
}
publisher_info pi;
pi.key = objectkey;
pi.server_changed = false;
if (zk_keyval) {
pi.server = zk_keyval->get(objectkey).second;
} else {
pi.server = objectkey;
}
pi.connected_server = pi.server;
if (pi.server != "") {
// TODO check return value
std::string local_address = normalize_address(pi.server);
zmq_connect(z_socket, local_address.c_str());
}
publishers.push_back(pi);
}
async_reply_socket::async_reply_socket(void* zmq_ctx,
graphlab::zookeeper_util::key_value* keyval,
callback_type callback,
size_t nthreads,
std::string alternate_bind_address,
std::string secret_key)
:z_ctx(zmq_ctx), zk_keyval(keyval), callback(callback), associated_pollset(NULL) {
// create a socket
z_socket = zmq_socket(z_ctx, ZMQ_ROUTER);
assert(z_socket);
if (!secret_key.empty()) {
const int is_server = 1;
int rc = zmq_setsockopt (z_socket, ZMQ_CURVE_SERVER, &is_server, sizeof(int));
assert (rc == 0);
assert(secret_key.length() == 40);
rc = zmq_setsockopt (z_socket, ZMQ_CURVE_SECRETKEY, secret_key.c_str(), 40);
assert (rc == 0);
}
set_conservative_socket_parameters(z_socket);
assert(z_socket != NULL);
if (!alternate_bind_address.empty()) {
local_address = normalize_address(alternate_bind_address);
int rc = zmq_bind(z_socket, local_address.c_str());
if (rc != 0) {
print_zmq_error("async_reply_socket construction: ");
assert(rc == 0);
}
} else {
// what is the listening socket?
std::string localip = graphlab::get_local_ip_as_str(true);
bool ok = false;
while (!ok) {
size_t port = get_next_port_number();
char port_as_string[128];
sprintf(port_as_string, "%ld", port);
local_address = "tcp://" + localip + ":" + port_as_string;
// try to bind
int rc = zmq_bind(z_socket, local_address.c_str());
ok = (rc == 0);
/*if (rc == EADDRINUSE) {
std::cout << local_address << " in use. Trying another port.\n";
continue;
} else if (rc != 0) {
std::cout << "Unable to bind to " << local_address << ". "
<< "Error(" << rc << ") = " << zmq_strerror(rc) << "\n";
}*/
}
}
local_address = normalize_address(local_address);
// std::cout << "Bound to " << local_address << "\n";
// now construct the threads and the required inproc sockets
char inprocname[64];
size_t socket_number = ASYNC_REPLY_SOCKET_CTR.inc();
sprintf(inprocname, "inproc://async_rep_%ld", socket_number);
inproc_pull_socket = zmq_socket(zmq_ctx, ZMQ_PULL);
if (inproc_pull_socket == NULL) {
print_zmq_error("async_reply_socket");
assert(inproc_pull_socket != NULL);
}
int rc = zmq_bind(inproc_pull_socket, inprocname);
if (rc != 0) {
print_zmq_error("async_reply_socket");
assert(false);
}
assert(nthreads > 0);
threads.resize(nthreads);
queue_terminate = false;
for (size_t i = 0;i < threads.size(); ++i) {
threads[i].parent = this;
threads[i].inproc_push_socket = zmq_socket(zmq_ctx, ZMQ_PUSH);
if (threads[i].inproc_push_socket == NULL) {
print_zmq_error("async_reply_socket");
assert(threads[i].inproc_push_socket != NULL);
}
// connect the push to the pull
int rc = zmq_connect(threads[i].inproc_push_socket, inprocname);
if (rc != 0) {
print_zmq_error("async_reply_socket");
assert(rc == 0);
}
// launch the threads
threads[i].thread = new boost::thread(boost::bind(&async_reply_socket::thread_function,
this,
&threads[i]));
}
}
