flux_cli_t * flux_cli_init(const char * broker_url, int timeout, int verbose) {
flux_cli_t * client;
if(verbose) printf("Client starting on %s...\n", broker_url);
client = malloc(sizeof(flux_cli_t));
if(!client) return NULL;
memset(client, 0, sizeof(flux_cli_t));
client->verbose = verbose;
client->timeout = timeout;
client->n_servers = 0;
client->servers = NULL;
// Bind to broker SURVEYOR socket
client->broker_sock = nn_socket(AF_SP, NN_REQ);
assert(client->broker_sock >= 0);
assert(nn_setsockopt(client->broker_sock, NN_SOL_SOCKET, NN_RCVTIMEO, &client->timeout, sizeof(int)) >= 0);
assert(nn_setsockopt(client->broker_sock, NN_SOL_SOCKET, NN_SNDTIMEO, &client->timeout, sizeof(int)) >= 0);
if(nn_connect(client->broker_sock, broker_url) < 0) {
printf("Unable to init flux client: %s\n", nn_strerror(errno));
return NULL;
}
return client;
}
bool pnet_internal_create_socket(pnet_socket *socket, pint16 type)
{
if (unlikely(!socket)) {
plog_error("pnet_internal_create_socket() нет объекта socket");
return false;
}
int sock = nn_socket(AF_SP_RAW, type);
if (unlikely(sock < 0)) {
plog_error("pnet_internal_create_socket() не удалось создать сокет | %s (%d)", nn_strerror(nn_errno()), nn_errno());
return false;
}
socket->socket_fd = sock;
int val = 1;
if (unlikely(nn_setsockopt(socket->socket_fd, NN_TCP, NN_TCP_NODELAY, &val, sizeof(val)))) {
plog_error("pnet_internal_create_socket() не удалось выставить NN_TCP_NODELAY | %s (%d)", nn_strerror(nn_errno()), nn_errno());
return false;
}
val = 0;
if (unlikely(nn_setsockopt(socket->socket_fd, NN_SOL_SOCKET, NN_LINGER, &val, sizeof(val)))) {
plog_error("pnet_internal_create_socket() не удалось выставить NN_LINGER | %s (%d)", nn_strerror(nn_errno()), nn_errno());
return false;
}
val = 10000;
if (unlikely(nn_setsockopt(socket->socket_fd, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX, &val, sizeof(val)))) {
plog_error("pnet_internal_create_socket() не удалось выставить NN_RECONNECT_IVL_MAX | %s (%d)", nn_strerror(nn_errno()), nn_errno());
return false;
}
return true;
}
static void proxy_init_feeders (proxy_t *p, char **feeds)
{
int opt;
if (0 > (p->nn_feed = nn_socket(AF_SP, NN_PULL))) {
LOG("feeder.socket() failed");
exit(2);
}
opt = 32768;
nn_setsockopt(p->nn_feed, NN_SOL_SOCKET, NN_RCVBUF, &opt, sizeof(opt));
opt = 1000;
nn_setsockopt(p->nn_feed, NN_SOL_SOCKET, NN_RECONNECT_IVL, &opt, sizeof(opt));
opt = 1000;
nn_setsockopt(p->nn_feed, NN_SOL_SOCKET, NN_RECONNECT_IVL_MAX, &opt, sizeof(opt));
for (char **purl = feeds; *purl ;++purl) {
if (0 > nn_connect (p->nn_feed, *purl)) {
LOG("feeder.connect(%s) failed", *purl);
exit(2);
} else {
LOG("feeder.connect(%s)", *purl);
}
}
}
int32_t _lb_socket(uint16_t port,uint16_t globalport,uint16_t relaysport,int32_t maxmillis,char servers[][MAX_SERVERNAME],int32_t num,char backups[][MAX_SERVERNAME],int32_t numbacks,char failsafes[][MAX_SERVERNAME],int32_t numfailsafes)
{
int32_t lbsock,timeout,retrymillis,priority = 1;
if ( (lbsock= nn_socket(AF_SP,NN_REQ)) >= 0 )
{
retrymillis = (maxmillis / 30) + 1;
printf("!!!!!!!!!!!! lbsock.%d !!!!!!!!!!!\n",lbsock);
if ( nn_setsockopt(lbsock,NN_SOL_SOCKET,NN_RECONNECT_IVL,&retrymillis,sizeof(retrymillis)) < 0 )
printf("error setting NN_REQ NN_RECONNECT_IVL_MAX socket %s\n",nn_errstr());
else if ( nn_setsockopt(lbsock,NN_SOL_SOCKET,NN_RECONNECT_IVL_MAX,&maxmillis,sizeof(maxmillis)) < 0 )
fprintf(stderr,"error setting NN_REQ NN_RECONNECT_IVL_MAX socket %s\n",nn_errstr());
timeout = SUPERNET.PLUGINTIMEOUT;
if ( nn_setsockopt(lbsock,NN_SOL_SOCKET,NN_RCVTIMEO,&timeout,sizeof(timeout)) < 0 )
printf("error setting NN_SOL_SOCKET NN_RCVTIMEO socket %s\n",nn_errstr());
timeout = 100;
if ( nn_setsockopt(lbsock,NN_SOL_SOCKET,NN_SNDTIMEO,&timeout,sizeof(timeout)) < 0 )
printf("error setting NN_SOL_SOCKET NN_SNDTIMEO socket %s\n",nn_errstr());
if ( num > 0 )
priority = nn_add_lbservers(port,globalport,relaysport,priority,lbsock,servers,num);
if ( numbacks > 0 )
priority = nn_add_lbservers(port,globalport,relaysport,priority,lbsock,backups,numbacks);
if ( numfailsafes > 0 )
priority = nn_add_lbservers(port,globalport,relaysport,priority,lbsock,failsafes,numfailsafes);
} else printf("error getting req socket %s\n",nn_errstr());
//printf("RELAYS.lb.num %d\n",RELAYS.lb.num);
return(lbsock);
}
int main ()
{
int rc;
int push;
int pull1;
int pull2;
int sndprio;
pull1 = test_socket (AF_SP, NN_PULL);
test_bind (pull1, SOCKET_ADDRESS_A);
pull2 = test_socket (AF_SP, NN_PULL);
test_bind (pull2, SOCKET_ADDRESS_B);
push = test_socket (AF_SP, NN_PUSH);
sndprio = 1;
rc = nn_setsockopt (push, NN_SOL_SOCKET, NN_SNDPRIO,
&sndprio, sizeof (sndprio));
errno_assert (rc == 0);
test_connect (push, SOCKET_ADDRESS_A);
sndprio = 2;
rc = nn_setsockopt (push, NN_SOL_SOCKET, NN_SNDPRIO,
&sndprio, sizeof (sndprio));
errno_assert (rc == 0);
test_connect (push, SOCKET_ADDRESS_B);
test_send (push, "ABC");
test_send (push, "DEF");
test_recv (pull1, "ABC");
test_recv (pull1, "DEF");
test_close (pull1);
test_close (push);
test_close (pull2);
/* Test removing a pipe from the list. */
push = test_socket (AF_SP, NN_PUSH);
test_bind (push, SOCKET_ADDRESS_A);
pull1 = test_socket (AF_SP, NN_PULL);
test_connect (pull1, SOCKET_ADDRESS_A);
test_send (push, "ABC");
test_recv (pull1, "ABC");
test_close (pull1);
rc = nn_send (push, "ABC", 3, NN_DONTWAIT);
nn_assert (rc == -1 && nn_errno() == EAGAIN);
pull1 = test_socket (AF_SP, NN_PULL);
test_connect (pull1, SOCKET_ADDRESS_A);
test_send (push, "ABC");
test_recv (pull1, "ABC");
test_close (pull1);
test_close (push);
return 0;
}
int ftw_socket_inbox_construct(struct ftw_socket_inbox **inst, LVUserEventRef *msg_to_lv_event,
struct ftw_socket_inbox **sock, const LStrHandleArray **addresses, int linger, int max_recv_size)
{
char *addr;
int rcb;
int rcs;
int rco;
int i;
/* Preconditions expected of LabVIEW. */
ftw_assert(inst && *inst && addresses && *addresses && msg_to_lv_event && sock);
rcs = nn_socket(AF_SP_RAW, NN_REP);
/* Socket creation failure? */
if (rcs < 0) {
*sock = NULL;
return rcs;
}
rco = nn_setsockopt(rcs, NN_SOL_SOCKET, NN_LINGER, &linger, sizeof(linger));
if (rco < 0) {
*sock = NULL;
return rco;
}
rco = nn_setsockopt(rcs, NN_SOL_SOCKET, NN_RCVMAXSIZE, &max_recv_size, sizeof(max_recv_size));
if (rco < 0) {
*sock = NULL;
return rco;
}
for (i = 0; i < (*addresses)->dimsize; i++) {
addr = ftw_support_LStrHandle_to_CStr((*addresses)->element[i]);
rcb = nn_bind(rcs, addr);
ftw_free (addr);
if (rcb < 0) {
nn_close(rcs);
*sock = NULL;
return rcb;
}
}
(*inst)->incoming_msg_notifier_event = *msg_to_lv_event;
(*inst)->id = rcs;
/* Launch thread and wait for it to initialize. */
nn_sem_init(&(*inst)->deinitialized);
nn_sem_init(&(*inst)->initialized);
nn_sem_init(&(*inst)->msg_acknowledged);
nn_thread_init(&(*inst)->async_recv_thread, ftw_socket_inbox_async_recv_worker, *inst);
nn_sem_wait(&(*inst)->initialized);
*sock = *inst;
return 0;
}
int main ()
{
int rc;
int pub1;
int pub2;
int sub1;
int sub2;
char buf [3];
pub1 = test_socket (AF_SP, NN_PUB);
test_bind (pub1, SOCKET_ADDRESS);
sub1 = test_socket (AF_SP, NN_SUB);
rc = nn_setsockopt (sub1, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
test_connect (sub1, SOCKET_ADDRESS);
sub2 = test_socket (AF_SP, NN_SUB);
rc = nn_setsockopt (sub2, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
test_connect (sub2, SOCKET_ADDRESS);
/* Wait till connections are established to prevent message loss. */
nn_sleep (10);
test_send (pub1, "0123456789012345678901234567890123456789");
test_recv (sub1, "0123456789012345678901234567890123456789");
test_recv (sub2, "0123456789012345678901234567890123456789");
test_close (pub1);
test_close (sub1);
test_close (sub2);
/* Check receiving messages from two publishers. */
sub1 = test_socket (AF_SP, NN_SUB);
rc = nn_setsockopt (sub1, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
test_bind (sub1, SOCKET_ADDRESS);
pub1 = test_socket (AF_SP, NN_PUB);
test_connect (pub1, SOCKET_ADDRESS);
pub2 = test_socket (AF_SP, NN_PUB);
test_connect (pub2, SOCKET_ADDRESS);
nn_sleep (100);
test_send (pub1, "0123456789012345678901234567890123456789");
test_send (pub2, "0123456789012345678901234567890123456789");
test_recv (sub1, "0123456789012345678901234567890123456789");
test_recv (sub1, "0123456789012345678901234567890123456789");
test_close (pub2);
test_close (pub1);
test_close (sub1);
return 0;
}
void process_json(cJSON *json,char *remoteaddr,int32_t localaccess)
{
int32_t sock,len,checklen,sendtimeout,recvtimeout; uint32_t apitag; uint64_t tag;
char endpoint[128],numstr[64],*resultstr,*jsonstr;
jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' ');
len = (int32_t)strlen(jsonstr)+1;
apitag = _crc32(0,jsonstr,len);
sprintf(endpoint,"ipc://api.%u",apitag);
free(jsonstr);
if ( (recvtimeout= juint(json,"timeout")) == 0 )
recvtimeout = 30000;
sendtimeout = 30000;
randombytes((uint8_t *)&tag,sizeof(tag));
if ( cJSON_GetObjectItem(json,"tag") == 0 )
sprintf(numstr,"%llu",(long long)tag), cJSON_AddItemToObject(json,"tag",cJSON_CreateString(numstr));
if ( cJSON_GetObjectItem(json,"apitag") == 0 )
cJSON_AddItemToObject(json,"apitag",cJSON_CreateString(endpoint));
if ( remoteaddr != 0 )
cJSON_AddItemToObject(json,"broadcast",cJSON_CreateString("remoteaccess"));
if ( localaccess != 0 )
cJSON_AddItemToObject(json,"localaccess",cJSON_CreateNumber(1));
jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' ');
//fprintf(stderr,"localacess.%d remote.(%s) jsonstr.(%s)\r\n",localaccess,remoteaddr!=0?remoteaddr:"",jsonstr);
len = (int32_t)strlen(jsonstr)+1;
if ( jsonstr != 0 )
{
if ( (sock= nn_socket(AF_SP,NN_PAIR)) >= 0 )
{
if ( sendtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_SNDTIMEO,&sendtimeout,sizeof(sendtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
if ( nn_connect(sock,SUPERNET_APIENDPOINT) < 0 )
printf("error connecting to apiendpoint sock.%d type.%d (%s) %s\r\n",sock,NN_PUSH,SUPERNET_APIENDPOINT,nn_errstr());
else if ( (checklen= nn_send(sock,jsonstr,len,0)) != len )
printf("checklen.%d != len.%d for nn_send to (%s)\r\n",checklen,len,SUPERNET_APIENDPOINT);
else
{
if ( recvtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_RCVTIMEO,&recvtimeout,sizeof(recvtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
if ( nn_recv(sock,&resultstr,NN_MSG,0) > 0 )
{
printf("Content-Length: %ld\r\n\r\n",strlen(resultstr)+2);
printf("%s\r\n",resultstr);
nn_freemsg(resultstr);
} else printf("error getting results %s\r\n",nn_errstr());
}
nn_shutdown(sock,0);
} else printf("error getting pushsock.%s\r\n",nn_errstr());
}
free(jsonstr);
}
int32_t nn_settimeouts(int32_t sock,int32_t sendtimeout,int32_t recvtimeout)
{
int32_t retrymillis,maxmillis;
maxmillis = SUPERNET.PLUGINTIMEOUT, retrymillis = maxmillis/40;
if ( nn_setsockopt(sock,NN_SOL_SOCKET,NN_RECONNECT_IVL,&retrymillis,sizeof(retrymillis)) < 0 )
fprintf(stderr,"error setting NN_REQ NN_RECONNECT_IVL_MAX socket %s\n",nn_errstr());
else if ( nn_setsockopt(sock,NN_SOL_SOCKET,NN_RECONNECT_IVL_MAX,&maxmillis,sizeof(maxmillis)) < 0 )
fprintf(stderr,"error setting NN_REQ NN_RECONNECT_IVL_MAX socket %s\n",nn_errstr());
else if ( sendtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_SNDTIMEO,&sendtimeout,sizeof(sendtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
else if ( recvtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_RCVTIMEO,&recvtimeout,sizeof(recvtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
else return(0);
return(-1);
}
int main ()
{
int rc;
int pub;
int sub1;
int sub2;
char buf [3];
pub = nn_socket (AF_SP, NN_PUB);
errno_assert (pub != -1);
rc = nn_bind (pub, SOCKET_ADDRESS);
errno_assert (rc >= 0);
sub1 = nn_socket (AF_SP, NN_SUB);
errno_assert (sub1 != -1);
rc = nn_setsockopt (sub1, NN_SUB, NN_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
rc = nn_connect (sub1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
sub2 = nn_socket (AF_SP, NN_SUB);
errno_assert (sub2 != -1);
rc = nn_setsockopt (sub2, NN_SUB, NN_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
rc = nn_connect (sub2, SOCKET_ADDRESS);
errno_assert (rc >= 0);
/* Wait till connections are established to prevent message loss. */
nn_sleep (10);
rc = nn_send (pub, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (sub1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (sub2, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (pub);
errno_assert (rc == 0);
rc = nn_close (sub1);
errno_assert (rc == 0);
rc = nn_close (sub2);
errno_assert (rc == 0);
return 0;
}
int ftw_nanomsg_sync_server_reply(struct ftw_socket ** const sock,
const int timeout, const LStrHandle response)
{
struct ftw_socket const *s;
const void *msg;
size_t len;
int rc;
s = *sock;
if (s == NULL) {
errno = EBADF;
return -1;
}
rc = nn_setsockopt(s->id, NN_SOL_SOCKET, NN_SNDTIMEO, &timeout, sizeof(timeout));
if (rc < 0)
return rc;
msg = LHStrBuf(response);
len = LHStrLen(response);
rc = nn_send(s->id, msg, len, 0);
return rc;
}
inline void setsockopt (int level, int option, const void *optval,
size_t optvallen)
{
int rc = nn_setsockopt (s, level, option, optval, optvallen);
if (nn_slow (rc != 0))
throw nn::exception ();
}
int node (const int argc, const char **argv)
{
int sock = nn_socket (AF_SP, NN_BUS);
assert (sock >= 0);
assert (nn_bind (sock, argv[2]) >= 0);
sleep (1); // wait for connections
if (argc >= 3)
{
int x=3;
for(x; x<argc; x++)
assert (nn_connect (sock, argv[x]) >= 0);
}
sleep (1); // wait for connections
int to = 100;
assert (nn_setsockopt (sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof (to)) >= 0);
// SEND
int sz_n = strlen(argv[1]) + 1; // '\0' too
printf ("%s: SENDING '%s' ONTO BUS\n", argv[1], argv[1]);
int send = nn_send (sock, argv[1], sz_n, 0);
assert (send == sz_n);
while (1)
{
// RECV
char *buf = NULL;
int recv = nn_recv (sock, &buf, NN_MSG, 0);
if (recv >= 0)
{
printf ("%s: RECEIVED '%s' FROM BUS\n", argv[1], buf);
nn_freemsg (buf);
}
}
return nn_shutdown (sock, 0);
}
int ftw_publisher_publish(struct ftw_socket ** const sock, int send_timeout, ConstLStrH message)
{
struct ftw_socket const *s;
int rc;
const void *buf;
size_t len;
s = *sock;
if (s == NULL) {
errno = EBADF;
return -1;
}
buf = LHStrBuf(message);
len = LHStrLen(message);
rc = nn_setsockopt(s->id, NN_SOL_SOCKET, NN_SNDTIMEO, &send_timeout, sizeof(send_timeout));
if (rc < 0)
return rc;
rc = nn_send(s->id, buf, len, 0);
return rc;
}
void NanoSocket::SetSubscription(const std::string& sub) throw()
{
if (nn_setsockopt (m_socket, NN_SUB, NN_SUB_SUBSCRIBE, sub.c_str(), 0) < 0)
{
throw NanoException{};
}
}
int ftw_nanomsg_router_recv (int router_id, void *incoming_msg_body, size_t *incoming_body_size, void *incoming_msg_header, size_t *incoming_header_size, int timeout)
{
struct nn_iovec iov;
struct nn_msghdr hdr;
int rc;
iov.iov_base = incoming_msg_body;
iov.iov_len = NN_MSG;
hdr.msg_iov = &iov;
hdr.msg_iovlen = 1;
hdr.msg_control = incoming_msg_header;
hdr.msg_controllen = NN_MSG;
nn_setsockopt(router_id, NN_SOL_SOCKET, NN_RCVTIMEO, &timeout, sizeof(timeout));
rc = nn_recvmsg (router_id, &hdr, NN_NOFLAGS);
if (rc < 0) {
rc = nn_errno();
return rc;
}
else {
*incoming_body_size = rc;
*incoming_header_size = hdr.msg_controllen;
return 0;
}
}
void subscribe_socket::subscribe(std::string topic) {
std::lock_guard<mutex> guard(lock);
if (topics.find(topic) != topics.end()) return;
topics.insert(topic);
nn_setsockopt(z_socket, NN_SUB, NN_SUB_SUBSCRIBE, topic.c_str(), topic.length());
return;
}
ccx_share_status ccx_share_start(const char *stream_name) //TODO add stream
{
dbg_print(CCX_DMT_SHARE, "[share] ccx_share_start: starting service\n");
//TODO for multiple files we have to move creation to ccx_share_init
ccx_share_ctx.nn_sock = nn_socket(AF_SP, NN_PUB);
if (ccx_share_ctx.nn_sock < 0) {
perror("[share] ccx_share_start: can't nn_socket()\n");
fatal(EXIT_NOT_CLASSIFIED, "ccx_share_start");
}
if (!ccx_options.sharing_url) {
ccx_options.sharing_url = strdup("tcp://*:3269");
}
dbg_print(CCX_DMT_SHARE, "[share] ccx_share_start: url=%s\n", ccx_options.sharing_url);
ccx_share_ctx.nn_binder = nn_bind(ccx_share_ctx.nn_sock, ccx_options.sharing_url);
if (ccx_share_ctx.nn_binder < 0) {
perror("[share] ccx_share_start: can't nn_bind()\n");
fatal(EXIT_NOT_CLASSIFIED, "ccx_share_start");
}
int linger = -1;
int rc = nn_setsockopt(ccx_share_ctx.nn_sock, NN_SOL_SOCKET, NN_LINGER, &linger, sizeof(int));
if (rc < 0) {
perror("[share] ccx_share_start: can't nn_setsockopt()\n");
fatal(EXIT_NOT_CLASSIFIED, "ccx_share_start");
}
//TODO remove path from stream name to minimize traffic (/?)
ccx_share_ctx.stream_name = strdup(stream_name ? stream_name : "unknown");
sleep(1); //We have to sleep a while, because it takes some time for subscribers to subscribe
return CCX_SHARE_OK;
}
int ftw_nanomsg_setsockopt(const int socket_id, int level, int option, const void *value, size_t length)
{
int rc;
rc = nn_setsockopt(socket_id, level, option, value, length);
return rc;
}
int ftw_publisher_construct(struct ftw_socket_callsite **callsite, const char *addr,
int linger, struct ftw_socket **sock)
{
struct ftw_socket *inst;
int rcs;
int rco;
int rcb;
/* Preconditions expected of LabVIEW. */
ftw_assert(*callsite && addr);
nn_mutex_lock(&(*callsite)->sync);
rcs = nn_socket(AF_SP, NN_PUB);
/* Socket creation failure? */
if (rcs < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rcs;
}
rco = nn_setsockopt(rcs, NN_SOL_SOCKET, NN_LINGER, &linger, sizeof(linger));
if (rco < 0) {
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rco;
}
rcb = nn_bind(rcs, addr);
/* Endpoint creation failure? */
if (rcb < 0) {
nn_close(rcs);
*sock = NULL;
nn_mutex_unlock(&(*callsite)->sync);
return rcb;
}
inst = ftw_malloc(sizeof(struct ftw_socket));
ftw_assert(inst);
memset(inst, 0, sizeof(*inst));
inst->id = rcs;
inst->callsite = *callsite;
nn_list_item_init(&inst->item);
nn_list_insert(&(*callsite)->active_sockets, &inst->item,
nn_list_end(&(*callsite)->active_sockets));
*sock = inst;
(*callsite)->lifetime_sockets++;
nn_mutex_unlock(&(*callsite)->sync);
return 0;
}
int main(void)
{
printf("what: %d\n", ENOPROTOOPT);
printf("worker started\n");
int max_sz = -1;
int rsnd = 2000000000;
int router = nn_socket(AF_SP, NN_REQ);
nn_setsockopt(router, NN_SOL_SOCKET, NN_RCVMAXSIZE, &max_sz, sizeof(max_sz));
int optres = nn_setsockopt(router, NN_REQ, NN_REQ_RESEND_IVL, &rsnd, sizeof(rsnd));
printf("whats this: %d\n", optres);
assert(optres==0);
nn_connect(router, WORKERROUTER);
size_t nbytes;
char *buf = NULL;
char *greeting = "hey, another worker is here!";
nn_send(router, greeting, strlen(greeting), 0);
while(1){
nbytes = nn_recv(router, &buf, NN_MSG, 0);
char *uuid = malloc(sizeof(char)*37);
memcpy((void*)uuid,(const void*)buf,36);
uuid[36]='\0';
char *tevs = malloc(100);
sprintf(tevs, "tmp/%s",uuid);
FILE *file = fopen(tevs, "wb");
fwrite(buf+36, sizeof(char), nbytes-36, file);
fclose(file);
nn_freemsg(buf);
printf("got work for id: %s\n",uuid);
slice *result = forkorsomething(uuid);
printf("work %s done, reporting\n", uuid);
nn_send(router, result->bytes, result->len+1, 0);
free_slice(result);
printf("report sent\n");
}
}
int main (int argc, char *argv [])
{
const char *connect_to;
size_t sz;
int rts;
char *buf;
int nbytes;
int s;
int rc;
int i;
int opt;
struct nn_stopwatch sw;
uint64_t total;
double lat;
if (argc != 4) {
printf ("usage: remote_lat <connect-to> <msg-size> <roundtrips>\n");
return 1;
}
connect_to = argv [1];
sz = atoi (argv [2]);
rts = atoi (argv [3]);
s = nn_socket (AF_SP, NN_PAIR);
assert (s != -1);
opt = 1;
rc = nn_setsockopt (s, NN_TCP, NN_TCP_NODELAY, &opt, sizeof (opt));
assert (rc == 0);
rc = nn_connect (s, connect_to);
assert (rc >= 0);
buf = malloc (sz);
assert (buf);
memset (buf, 111, sz);
nn_stopwatch_init (&sw);
for (i = 0; i != rts; i++) {
nbytes = nn_send (s, buf, sz, 0);
assert (nbytes == (int)sz);
nbytes = nn_recv (s, buf, sz, 0);
assert (nbytes == (int)sz);
}
total = nn_stopwatch_term (&sw);
lat = (double) total / (rts * 2);
printf ("message size: %d [B]\n", (int) sz);
printf ("roundtrip count: %d\n", (int) rts);
printf ("average latency: %.3f [us]\n", (double) lat);
free (buf);
rc = nn_close (s);
assert (rc == 0);
return 0;
}
void process_json(cJSON *json)
{
int32_t sock,i,len,checklen,sendtimeout,recvtimeout; uint32_t apitag; uint64_t tag;
char endpoint[128],*resultstr,*jsonstr;
jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' ');
//fprintf(stderr,"jsonstr.(%s)\r\n",jsonstr);
len = (int32_t)strlen(jsonstr)+1;
apitag = _crc32(0,jsonstr,len);
sprintf(endpoint,"ipc://api.%u",apitag);
free(jsonstr);
recvtimeout = get_API_int(cJSON_GetObjectItem(json,"timeout"),10000);
sendtimeout = 5000;
randombytes(&tag,sizeof(tag));
cJSON_AddItemToObject(json,"tag",cJSON_CreateNumber(tag));
cJSON_AddItemToObject(json,"apitag",cJSON_CreateString(endpoint));
//cJSON_AddItemToObject(json,"timeout",cJSON_CreateNumber(recvtimeout));
jsonstr = cJSON_Print(json), _stripwhite(jsonstr,' ');
len = (int32_t)strlen(jsonstr)+1;
if ( json != 0 )
{
if ( (sock= nn_socket(AF_SP,NN_PAIR)) >= 0 )
{
if ( sendtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_SNDTIMEO,&sendtimeout,sizeof(sendtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
if ( nn_connect(sock,SUPERNET_APIENDPOINT) < 0 )
printf("error connecting to apiendpoint sock.%d type.%d (%s) %s\r\n",sock,NN_PUSH,SUPERNET_APIENDPOINT,nn_errstr());
else if ( (checklen= nn_send(sock,jsonstr,len,0)) != len )
printf("checklen.%d != len.%d for nn_send to (%s)\r\n",checklen,len,SUPERNET_APIENDPOINT);
else
{
if ( recvtimeout > 0 && nn_setsockopt(sock,NN_SOL_SOCKET,NN_RCVTIMEO,&recvtimeout,sizeof(recvtimeout)) < 0 )
fprintf(stderr,"error setting sendtimeout %s\n",nn_errstr());
if ( nn_recv(sock,&resultstr,NN_MSG,0) > 0 )
{
printf("Content-Length: %ld\r\n\r\n",strlen(resultstr)+2);
printf("%s\r\n",resultstr);
nn_freemsg(resultstr);
} else printf("error getting results %s\r\n",nn_errstr());
}
nn_shutdown(sock,0);
} else printf("error getting pushsock.%s\r\n",nn_errstr());
}
free(jsonstr);
}
int32_t crypto777_peer(struct crypto777_node *nn,struct crypto777_node *peer)
{
struct crypto777_peer *ptr;
int32_t err=0,err2=0,timeout = 1;//,insock;
struct crypto777_transport *transport = &nn->transport;
if ( nn->numpeers < MAXPEERS )
{
ptr = &transport->peers[transport->numpeers++];
printf("%p peer.(%s).%d\n",peer->ip_port,peer->ip_port,peer->transport.port);
strcpy(ptr->type,peer->transport.type), strcpy(ptr->ip_port,peer->ip_port), ptr->port = peer->transport.port;
//if ( nn_connect(transport->bus,peer->ip_port) < 0 )
// printf("error %d nn_connect.%d bus (%s) | %s\n",err,transport->bus,peer->ip_port,nn_strerror(nn_errno())), getchar();
if ( (ptr->subsock= nn_socket(AF_SP,NN_SUB)) < 0 || (err= nn_setsockopt(ptr->subsock,NN_SUB,NN_SUB_SUBSCRIBE,"",0)) < 0 || (err2= nn_connect(ptr->subsock,ptr->ip_port)) < 0 )
{
printf("error %d too many subs.%d nodeid.%d peerid.%d err.%s err.%d err2.%d ip_port.(%s)\n",ptr->subsock,nn->numpeers,nn->nodeid,peer->nodeid,nn_strerror(nn_errno()),err,err2,ptr->ip_port);
if ( ptr->subsock >= 0 )
nn_shutdown(ptr->subsock,0);
return(-1);
}
if ( nn_setsockopt(ptr->subsock,NN_SOL_SOCKET,NN_RCVTIMEO,&timeout,sizeof(timeout)) < 0 )
printf("error setting recv timeout to %d\n",timeout);
/*if ( (ptr->pairsock= nn_socket(AF_SP,NN_PAIR)) < 0 )
printf("error %d nn_socket err.%s\n",ptr->pairsock,nn_strerror(nn_errno()));
else if ( (err= nn_bind(ptr->pairsock,transport->ip_port)) < 0 )
printf("error %d nn_bind.%d (%s) | %s\n",err,ptr->pairsock,transport->ip_port,nn_strerror(nn_errno()));
else if ( nn_connect(ptr->pairsock,peer->ip_port) < 0 )
printf("error %d nn_connect.%d pairsock (%s) | %s\n",err,ptr->pairsock,peer->ip_port,nn_strerror(nn_errno()));
if ( nn_setsockopt(ptr->pairsock,NN_SOL_SOCKET,NN_RCVTIMEO,&timeout,sizeof(timeout)) < 0 )
printf("error setting recv timeout to %d\n",timeout);
if ( (insock= nn_socket(AF_SP,NN_PAIR)) < 0 )
printf("error %d nn_socket err.%s\n",insock,nn_strerror(nn_errno()));
else if ( (err= nn_bind(insock,peer->ip_port)) < 0 )
printf("error %d nn_bind.%d (%s) | %s\n",err,insock,peer->ip_port,nn_strerror(nn_errno()));
else if ( nn_connect(insock,nn->ip_port) < 0 )
printf("error %d nn_connect.%d insock (%s) | %s\n",err,insock,nn->ip_port,nn_strerror(nn_errno()));
else peer->transport.insocks[peer->transport.numpairs++] = insock;*/
set_bloombits(&nn->blooms[0],peer->nxt64bits);
nn->peers[nn->numpeers++] = peer;
return(nn->numpeers);
} else return(-1);
}
int send_recv(int sock, const char *name)
{
int to = 100;
assert(nn_setsockopt (sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof (to)) >= 0);
while(1)
{
recv_name(sock, name);
sleep(1);
send_name(sock, name);
}
}
static void ocnotify_newmail(TALLOC_CTX *mem_ctx, struct ocnotify_private ocnotify,
uint32_t count, const char **hosts, const char *data)
{
enum mapistore_error retval;
int sock;
int endpoint;
int i;
int bytes;
int timeout;
int rc;
uint8_t *blob = NULL;
size_t msglen;
if (ocnotify.backend == NULL) {
oc_log(OC_LOG_ERROR, "No backend specified");
exit (1);
}
retval = mapistore_notification_payload_newmail(mem_ctx, ocnotify.backend, (char *)data, ocnotify.dstfolder,
ocnotify.sep, &blob, &msglen);
if (retval != MAPISTORE_SUCCESS) {
oc_log(OC_LOG_ERROR, "unable to generate newmail payload");
exit (1);
}
sock = nn_socket(AF_SP, NN_PUSH);
if (sock < 0) {
oc_log(OC_LOG_FATAL, "unable to create socket");
exit (1);
}
timeout = 200;
rc = nn_setsockopt(sock, NN_SOL_SOCKET, NN_SNDTIMEO, &timeout, sizeof(timeout));
if (rc < 0) {
oc_log(OC_LOG_WARNING, "unable to set timeout on socket send");
}
for (i = 0; i < count; i++) {
endpoint = nn_connect(sock, hosts[i]);
if (endpoint < 0) {
oc_log(OC_LOG_ERROR, "unable to connect to %s", hosts[i]);
ocnotify_flush(ocnotify, hosts[i]);
continue;
}
bytes = nn_send(sock, (char *)blob, msglen, 0);
if (bytes != msglen) {
oc_log(OC_LOG_WARNING, "Error sending msg: %d sent but %d expected",
bytes, msglen);
}
oc_log(OC_LOG_INFO, "message sent to %s", hosts[i]);
nn_shutdown(sock, endpoint);
}
}
int node (const int argc, const char **argv)
{
int sock = nn_socket (AF_SP, NN_BUS);
int sock_fd, efd, nfds;
struct epoll_event event, events[MAX_EVENTS];
size_t sz = sizeof(sock_fd);
nn_getsockopt(sock, NN_SOL_SOCKET, NN_RCVFD, &sock_fd, &sz);
assert(sock >= 0);
assert(nn_bind (sock, argv[2]) >= 0);
sleep (1); // wait for connections
if (argc >= 3) {
int x;
for(x = 3; x < argc; x++)
assert(nn_connect(sock, argv[x]) >= 0);
}
efd = epoll_create(MAX_EVENTS);
assert(efd != -1);
event.data.fd = sock_fd;
event.events = EPOLLIN;
assert(epoll_ctl(efd, EPOLL_CTL_ADD, sock_fd, &event) != -1);
// wait for connections
sleep(1);
int to = 100;
assert(nn_setsockopt (sock, NN_SOL_SOCKET, NN_RCVTIMEO, &to, sizeof(to)) >= 0);
// SEND
int sz_n = strlen(argv[1]) + 1; // '\0' too
printf ("%s: SENDING '%s' ONTO BUS\n", argv[1], argv[1]);
int send = nn_send (sock, argv[1], sz_n, 0);
assert (send == sz_n);
for(;;) {
nfds = epoll_wait(efd, events, MAX_EVENTS, -1);
assert(nfds != -1);
int n, recv;
for (n = 0; n < nfds; ++n) {
if (events[n].data.fd == sock_fd) {
char *buf = NULL;
recv = nn_recv(sock, &buf, NN_MSG, 0);
if (recv >= 0) {
printf ("%s: RECEIVED '%s' FROM BUS\n", argv[1], buf);
nn_freemsg (buf);
}
}
}
}
return nn_shutdown (sock, 0);
}
static PyObject *sockSetInt(sock_t *self, PyObject *args, int option)
{
int timeout = -1;
int ret;
if (!PyArg_ParseTuple(args, "i", &timeout))
return NULL;
ret = nn_setsockopt(self->sock, NN_SOL_SOCKET, option,
(const void *)&timeout, sizeof(int));
if (ret == -1){
ERR;
return NULL;
}
Py_RETURN_NONE;
}
static gboolean gst_nanomsgsrc_update_rcvbufsize(GstNanomsgSrc *nanomsgsrc, int new_size)
{
nanomsgsrc->rcvbufsize = new_size;
if (nanomsgsrc->main_fd < 0)
return TRUE;
if (G_UNLIKELY(nn_setsockopt(nanomsgsrc->main_fd, NN_SOL_SOCKET, NN_RCVBUF, &new_size, sizeof(new_size)) == -1))
{
GST_ERROR_OBJECT(nanomsgsrc, "error while setting new receive buffer size: %s", strerror(errno));
return FALSE;
}
else
return TRUE;
}
JNIEXPORT jint JNICALL Java_org_nanomsg_NanoLibrary_nn_1setsockopt_1int(JNIEnv* env,
jobject obj,
jint socket,
jint level,
jint optidx,
jint optval)
{
jint ret = -1;
int go = 0;
switch (level) {
case NN_SOL_SOCKET:
switch (optidx) {
case NN_LINGER:
case NN_SNDBUF:
case NN_RCVBUF:
case NN_SNDTIMEO:
case NN_RCVTIMEO:
case NN_RECONNECT_IVL:
case NN_RECONNECT_IVL_MAX:
case NN_SNDPRIO:
go = 1;
break;
}
break;
case NN_TCP:
switch (optidx) {
case NN_TCP_NODELAY:
go = 1;
fprintf(stderr, "TCP_NODELAY\n");
break;
}
break;
}
if (go) {
int oval = optval;
size_t olen = sizeof(oval);
ret = nn_setsockopt(socket, level, optidx, &oval, olen);
if (ret >= 0) {
ret = olen;
}
}
return ret;
}
