Examples with ZMsg org.zeromq.ZMsg used on opensource projects

Example 11 with ZMsg

use of org.zeromq.ZMsg in project jeromq by zeromq.

the class lruqueue3 method handle.

@Override
public int handle(ZLoop loop, PollItem item, Object arg_) {
    LRUQueueArg arg = (LRUQueueArg) arg_;
    ZMsg msg = ZMsg.recvMsg(arg.backend);
    if (msg != null) {
        ZFrame address = msg.unwrap();
        //  Queue worker address for LRU routing
        arg.workers.add(address);
        //  Enable reader on frontend if we went from 0 to 1 workers
        if (arg.workers.size() == 1) {
            PollItem poller = new PollItem(arg.frontend, ZMQ.Poller.POLLIN);
            loop.addPoller(poller, lruqueue3.handle_frontend, arg);
        }
        //  Forward message to client if it's not a READY
        ZFrame frame = msg.getFirst();
        if (new String(frame.getData(), ZMQ.CHARSET).equals(lruqueue3.LRU_READY))
            msg.destroy();
        else
            msg.send(arg.frontend);
    }
    return 0;
}

Example 12 with ZMsg

use of org.zeromq.ZMsg in project jeromq by zeromq.

the class bstarsrv method main.

//  .split main task
//  This is our main task. First we bind/connect our sockets with our
//  peer and make sure we will get state messages correctly. We use
//  three sockets; one to publish state, one to subscribe to state, and
//  one for client requests/replies:
public static void main(String[] argv) {
    //  Arguments can be either of:
    //      -p  primary server, at tcp://localhost:5001
    //      -b  backup server, at tcp://localhost:5002
    ZContext ctx = new ZContext();
    Socket statepub = ctx.createSocket(ZMQ.PUB);
    Socket statesub = ctx.createSocket(ZMQ.SUB);
    statesub.subscribe(ZMQ.SUBSCRIPTION_ALL);
    Socket frontend = ctx.createSocket(ZMQ.ROUTER);
    bstarsrv fsm = new bstarsrv();
    if (argv.length == 1 && argv[0].equals("-p")) {
        System.out.printf("I: Primary active, waiting for backup (passive)\n");
        frontend.bind("tcp://*:5001");
        statepub.bind("tcp://*:5003");
        statesub.connect("tcp://localhost:5004");
        fsm.state = State.STATE_PRIMARY;
    } else if (argv.length == 1 && argv[0].equals("-b")) {
        System.out.printf("I: Backup passive, waiting for primary (active)\n");
        frontend.bind("tcp://*:5002");
        statepub.bind("tcp://*:5004");
        statesub.connect("tcp://localhost:5003");
        fsm.state = State.STATE_BACKUP;
    } else {
        System.out.printf("Usage: bstarsrv { -p | -b }\n");
        ctx.destroy();
        System.exit(0);
    }
    //  .split handling socket input
    //  We now process events on our two input sockets, and process these
    //  events one at a time via our finite-state machine. Our "work" for
    //  a client request is simply to echo it back.
    Poller poller = ctx.createPoller(2);
    poller.register(frontend, ZMQ.Poller.POLLIN);
    poller.register(statesub, ZMQ.Poller.POLLIN);
    //  Set timer for next outgoing state message
    long sendStateAt = System.currentTimeMillis() + HEARTBEAT;
    while (!Thread.currentThread().isInterrupted()) {
        int timeLeft = (int) ((sendStateAt - System.currentTimeMillis()));
        if (timeLeft < 0)
            timeLeft = 0;
        int rc = poller.poll(timeLeft);
        if (rc == -1)
            //  Context has been shut down
            break;
        if (poller.pollin(0)) {
            //  Have a client request
            ZMsg msg = ZMsg.recvMsg(frontend);
            fsm.event = Event.CLIENT_REQUEST;
            if (fsm.stateMachine() == false)
                //  Answer client by echoing request back
                msg.send(frontend);
            else
                msg.destroy();
        }
        if (poller.pollin(1)) {
            //  Have state from our peer, execute as event
            String message = statesub.recvStr();
            fsm.event = Event.values()[Integer.parseInt(message)];
            if (fsm.stateMachine())
                //  Error, so exit
                break;
            fsm.peerExpiry = System.currentTimeMillis() + 2 * HEARTBEAT;
        }
        //  If we timed out, send state to peer
        if (System.currentTimeMillis() >= sendStateAt) {
            statepub.send(String.valueOf(fsm.state.ordinal()));
            sendStateAt = System.currentTimeMillis() + HEARTBEAT;
        }
    }
    if (Thread.currentThread().isInterrupted())
        System.out.printf("W: interrupted\n");
    //  Shutdown sockets and context
    ctx.destroy();
}

Example 13 with ZMsg

use of org.zeromq.ZMsg in project jeromq by zeromq.

the class clone method get.

//  .split get method
//  Look up value in distributed hash table. Sends [GET][key] to the agent and
//  waits for a value response. If there is no value available, will eventually
//  return NULL:
public String get(String key) {
    ZMsg msg = new ZMsg();
    msg.add("GET");
    msg.add(key);
    msg.send(pipe);
    ZMsg reply = ZMsg.recvMsg(pipe);
    if (reply != null) {
        String value = reply.popString();
        reply.destroy();
        return value;
    }
    return null;
}

Example 14 with ZMsg

use of org.zeromq.ZMsg in project jeromq by zeromq.

the class clone method subtree.

//  .split subtree method
//  Specify subtree for snapshot and updates, which we must do before
//  connecting to a server as the subtree specification is sent as the
//  first command to the server. Sends a [SUBTREE][subtree] command to
//  the agent:
public void subtree(String subtree) {
    ZMsg msg = new ZMsg();
    msg.add("SUBTREE");
    msg.add(subtree);
    msg.send(pipe);
}

Example 15 with ZMsg

use of org.zeromq.ZMsg in project jeromq by zeromq.

the class clone method connect.

//  .split connect method
//  Connect to a new server endpoint. We can connect to at most two
//  servers. Sends [CONNECT][endpoint][service] to the agent:
public void connect(String address, String service) {
    ZMsg msg = new ZMsg();
    msg.add("CONNECT");
    msg.add(address);
    msg.add(service);
    msg.send(pipe);
}