Ejemplo n.º 1
0
int main (int argc, char *argv [])
{
    int verbose = (argc > 1 && streq (argv [1], "-v"));

    broker_t *self = s_broker_new (verbose);
    s_broker_bind (self, "tcp://*:5555");

    //  Get and process messages forever or until interrupted
    while (TRUE) {
        zmq_pollitem_t items [] = {
            { self->socket,  0, ZMQ_POLLIN, 0 } };
        int rc = zmq_poll (items, 1, HEARTBEAT_INTERVAL * ZMQ_POLL_MSEC);
        if (rc == -1)
            break;              //  Interrupted

        //  Process next input message, if any
        if (items [0].revents & ZMQ_POLLIN) {
            zmsg_t *msg = zmsg_recv (self->socket);
            if (!msg)
                break;          //  Interrupted
            if (self->verbose) {
                zclock_log ("I: received message:");
                zmsg_dump (msg);
            }
            zframe_t *sender = zmsg_pop (msg);
            zframe_t *empty  = zmsg_pop (msg);
            zframe_t *header = zmsg_pop (msg);

            if (zframe_streq (header, MDPC_CLIENT))
                s_client_process (self, sender, msg);
            else
            if (zframe_streq (header, MDPW_WORKER))
                s_worker_process (self, sender, msg);
            else {
                zclock_log ("E: invalid message:");
                zmsg_dump (msg);
                zmsg_destroy (&msg);
            }
            zframe_destroy (&sender);
            zframe_destroy (&empty);
            zframe_destroy (&header);
        }
        //  Disconnect and delete any expired workers
        //  Send heartbeats to idle workers if needed
        if (zclock_time () > self->heartbeat_at) {
            s_broker_purge_workers (self);
            worker_t *worker = (worker_t *) zlist_first (self->waiting);
            while (worker) {
                s_worker_send (self, worker, MDPW_HEARTBEAT, NULL, NULL);
                worker = (worker_t *) zlist_next (self->waiting);
            }
            self->heartbeat_at = zclock_time () + HEARTBEAT_INTERVAL;
        }
    }
    if (zctx_interrupted)
        printf ("W: interrupt received, shutting down...\n");

    s_broker_destroy (&self);
    return 0;
}
Ejemplo n.º 2
0
int main (int argc, char *argv[])
{
	int verbose = (argc > 1 && streq(argv[1], "-v"));

	broker_t *self = s_broker_new(verbose);
	s_broker_bind(self, "tcp://127.0.0.1:5555");

	while(true){
		zmq_pollitem_t items [] = {
			{self->socket, 0, ZMQ_POLLIN, 0}
		};
		int rc = zmq_poll(items, 1, HEARTBEAT_INTERVAL * ZMQ_POLL_MSEC);
		if (rc == -1)
			break;

		if (items[0].revents & ZMQ_POLLIN){
			zmsg_t *msg = zmsg_recv(self->socket);
			if (!msg)
				break;
			if (self->verbose){
				zclock_log("I: received message");
				zmsg_dump(msg);
			}
			zframe_t *sender = zmsg_pop(msg);
			zframe_t *empty = zmsg_pop(msg);
			zframe_t *header = zmsg_pop(msg);

			if (zframe_streq(header, MDPC_CLIENT))
				s_broker_client_msg(self, sender, msg);
			else
			if (zframe_streq(header, MDPW_WORKER))
				s_broker_worker_msg(self, sender, msg);
			else{
				zclock_log("E: invalid message:");
				zmsg_dump(msg);
				zmsg_destroy(&msg);
			}
			zframe_destroy(&sender);
			zframe_destroy(&empty);
			zframe_destroy(&header);
		}

		if (zclock_time() > self->heartbeat_at){
			s_broker_purge(self);
			worker_t *worker = (worker_t *)zlist_first(self->waiting);
			while (worker){
				s_worker_send(worker, MDPW_HEARTBEAT, NULL, NULL);
				worker = (worker_t *)zlist_next(self->waiting);
			}
			self->heartbeat_at = zclock_time() + HEARTBEAT_INTERVAL;
		}
	}

	if (zctx_interrupted)
		printf("W: interrupt receivde, shutting down...\n");

	s_broker_destroy(&self);
	return 0;
}
Ejemplo n.º 3
0
int main (int argc, char *argv [])
{
    int verbose = (argc > 1 && streq (argv [1], "-v"));

    s_version_assert (2, 1);
    s_catch_signals ();
    broker_t *self = s_broker_new (verbose);
    s_broker_bind (self, "tcp://*:5555");

    //  Get and process messages forever or until interrupted
    while (!s_interrupted) {
        zmq_pollitem_t items [] = { 
            { self->socket,  0, ZMQ_POLLIN, 0 } };
        zmq_poll (items, 1, HEARTBEAT_INTERVAL * 1000);

        //  Process next input message, if any
        if (items [0].revents & ZMQ_POLLIN) {
            zmsg_t *msg = zmsg_recv (self->socket);
            if (self->verbose) {
                s_console ("I: received message:");
                zmsg_dump (msg);
            }
            char *sender = zmsg_pop (msg);
            char *empty  = zmsg_pop (msg);
            char *header = zmsg_pop (msg);

            if (streq (header, MDPC_CLIENT))
                s_client_process (self, sender, msg);
            else
            if (streq (header, MDPW_WORKER))
                s_worker_process (self, sender, msg);
            else {
                s_console ("E: invalid message:");
                zmsg_dump (msg);
                zmsg_destroy (&msg);
            }
            free (sender);
            free (empty);
            free (header);
        }
        //  Disconnect and delete any expired workers
        //  Send heartbeats to idle workers if needed
        if (s_clock () > self->heartbeat_at) {
            s_broker_purge_workers (self);
            worker_t *worker = zlist_first (self->waiting);
            while (worker) {
                s_worker_send (self, worker, MDPW_HEARTBEAT, NULL, NULL);
                worker = zlist_next (self->waiting);
            }
            self->heartbeat_at = s_clock () + HEARTBEAT_INTERVAL;
        }
    }
    if (s_interrupted)
        printf ("W: interrupt received, shutting down...\n");

    s_broker_destroy (&self);
    return 0;
}
Ejemplo n.º 4
0
static void
s_worker_delete(worker_t *self, int disconnect)
{
	assert(self);
	if (disconnect)
		s_worker_send(self, MDPW_DISCONNECT, NULL, NULL);

	if (self->service){
		zlist_remove(self->service->waiting, self);
		self->service->workers--;
	}
	zlist_remove(self->broker->waiting, self);

	zhash_delete(self->broker->workers, self->id_string);
}
Ejemplo n.º 5
0
static void
s_worker_delete (worker_t *self, int disconnect)
{
    assert (self);
    if (disconnect)
        s_worker_send (self, MDPW_DISCONNECT, NULL, NULL);

    if (self->service) {
        zlist_remove (self->service->waiting, self);
        self->service->workers--;
    }
    zlist_remove (self->broker->waiting, self);
    //  This implicitly calls s_worker_destroy
    zhash_delete (self->broker->workers, self->identity);
}
Ejemplo n.º 6
0
Archivo: broker.c Proyecto: tnako/DP
static void s_service_dispatch(service_t *self, zmsg_t *msg)
{
    assert(self);
    if (msg) {                    //  Queue message if any
        zlist_append(self->requests, msg);
	}

    s_broker_purge(self->broker);
    while (zlist_size(self->waiting) && zlist_size(self->requests)) {
        worker_t *worker = zlist_pop(self->waiting);
        zlist_remove(self->broker->waiting, worker);
        zmsg_t *msg = zlist_pop(self->requests);
        s_worker_send(worker, MDPW_REQUEST, msg);
        zmsg_destroy (&msg);
    }
}
Ejemplo n.º 7
0
Archivo: broker.c Proyecto: tnako/DP
static void s_worker_delete(worker_t *self, int disconnect)
{
    assert (self);
    if (disconnect) {
        s_worker_send (self, MDPW_DISCONNECT, NULL); // ! Расширить до отключение через mmi
	}

    if (self->service) {
        zlist_remove (self->service->waiting, self);
        self->service->workers--;
    }
    
    zlist_remove (self->broker->waiting, self);
    //  This implicitly calls s_worker_destroy
    zhash_delete (self->broker->workers, self->id_string);
}
Ejemplo n.º 8
0
//  The dispatch method sends request to the worker.
static void
s_service_dispatch (service_t *self)
{
    assert (self);

    s_broker_purge (self->broker);
    if (zlist_size (self->waiting) == 0)
        return;

    while (zlist_size (self->requests) > 0) {
        worker_t *worker = (worker_t*)zlist_pop (self->waiting);
        zlist_remove (self->waiting, worker);
        zmsg_t *msg = (zmsg_t*)zlist_pop (self->requests);
        s_worker_send (worker, MDPW_REQUEST, NULL, msg);
        //  Workers are scheduled in the round-robin fashion
        zlist_append (self->waiting, worker);
        zmsg_destroy (&msg);
    }
}
Ejemplo n.º 9
0
int main (int argc, char *argv [])
{
    int verbose = 0;
    int daemonize = 0;
    for (int i = 1; i < argc; i++)
    {
        if (streq(argv[i], "-v")) verbose = 1;
        else if (streq(argv[i], "-d")) daemonize = 1;
        else if (streq(argv[i], "-h"))
        {
            printf("%s [-h] | [-d] [-v] [broker url]\n\t-h This help message\n\t-d Daemon mode.\n\t-v Verbose output\n\tbroker url defaults to tcp://*:5555\n", argv[0]);
            return -1;
        }
    }

    if (daemonize != 0)
    {
        daemon(0, 0);
    }

    broker_t *self = s_broker_new (verbose);
    /* did the user specify a bind address? */
    if (argc > 1)
    {
        s_broker_bind (self, argv[argc-1]);
        printf("Bound to %s\n", argv[argc-1]);
    }
    else
    {
        /* default */
        s_broker_bind (self, "tcp://*:5555");
        printf("Bound to tcp://*:5555\n");
    }

    //  Get and process messages forever or until interrupted
    while (true) {
        zmq_pollitem_t items [] = {
            { self->socket,  0, ZMQ_POLLIN, 0 } };
        int rc = zmq_poll (items, 1, HEARTBEAT_INTERVAL * ZMQ_POLL_MSEC);
        if (rc == -1)
            break;              //  Interrupted

        //  Process next input message, if any
        if (items [0].revents & ZMQ_POLLIN) {
            zmsg_t *msg = zmsg_recv (self->socket);
            if (!msg)
                break;          //  Interrupted
            if (self->verbose) {
                zclock_log ("I: received message:");
                zmsg_dump (msg);
            }
            zframe_t *sender = zmsg_pop (msg);
            zframe_t *empty  = zmsg_pop (msg);
            zframe_t *header = zmsg_pop (msg);

            if (zframe_streq (header, MDPC_CLIENT))
                s_broker_client_msg (self, sender, msg);
            else
            if (zframe_streq (header, MDPW_WORKER))
                s_broker_worker_msg (self, sender, msg);
            else {
                zclock_log ("E: invalid message:");
                zmsg_dump (msg);
                zmsg_destroy (&msg);
            }
            zframe_destroy (&sender);
            zframe_destroy (&empty);
            zframe_destroy (&header);
        }
        //  Disconnect and delete any expired workers
        //  Send heartbeats to idle workers if needed
        if (zclock_time () > self->heartbeat_at) {
            s_broker_purge (self);
            worker_t *worker = (worker_t *) zlist_first (self->waiting);
            while (worker) {
                s_worker_send (worker, MDPW_HEARTBEAT, NULL, NULL);
                worker = (worker_t *) zlist_next (self->waiting);
            }
            self->heartbeat_at = zclock_time () + HEARTBEAT_INTERVAL;
        }
    }
    if (zctx_interrupted)
        printf ("W: interrupt received, shutting down...\n");

    s_broker_destroy (&self);
    return 0;
}
Ejemplo n.º 10
0
Archivo: broker.c Proyecto: tnako/DP
int main ()
{
    broker_t *self = s_broker_new(1);
	zsocket_bind(self, "tcp://*:5555");

    while (true) {
        zmq_pollitem_t items[] = { { self->socket,  0, ZMQ_POLLIN, 0 } };
        int rc = zmq_poll(items, 1, HEARTBEAT_INTERVAL * ZMQ_POLL_MSEC);
		
        if (rc == -1) {
            break;     
		}

        if (items [0].revents & ZMQ_POLLIN) {
            zmsg_t *msg = zmsg_recv(self->socket);
			
            if (!msg) {
                break;
			}
			
            if (self->verbose) {
                zclock_log("I: received message:");
                zmsg_dump(msg);
            }
            
            zframe_t *sender = zmsg_pop(msg);
            zframe_t *empty  = zmsg_pop(msg);
            zframe_t *header = zmsg_pop(msg);

            if (zframe_streq(header, MDPC_CLIENT)) {
                s_broker_client_msg(self, sender, msg);
			} else {
			  if (zframe_streq(header, MDPW_WORKER)) {
				  s_broker_worker_msg(self, sender, msg);
			  } else {
				  zclock_log("E: invalid message:");
				  zmsg_dump(msg);
				  zmsg_destroy(&msg);
			  }
			}
            zframe_destroy(&sender);
            zframe_destroy(&empty);
            zframe_destroy(&header);
        }
        //  Disconnect and delete any expired workers
        //  Send heartbeats to idle workers if needed
 // Зачем посылать им, пусть они нам присылают
        if (zclock_time() > self->heartbeat_at) {
            s_broker_purge(self);
            worker_t *worker = (worker_t *) zlist_first(self->waiting);
            while (worker) {
                s_worker_send(worker, MDPW_HEARTBEAT, NULL);
                worker = (worker_t *) zlist_next(self->waiting);
            }
            self->heartbeat_at = zclock_time () + HEARTBEAT_INTERVAL;
        }
    }
    if (zctx_interrupted)
        printf ("W: interrupt received, shutting down...\n");

	zctx_destroy(&self->ctx);
	zhash_destroy(&self->services);
	zhash_destroy(&self->workers);
	zlist_destroy(&self->waiting);
	free(self);

	return 0;
}